protected Date _parseDate(String dateStr, ParsePosition pos) throws ParseException
{
    if (looksLikeISO8601(dateStr)) { // also includes "plain"
        return parseAsISO8601(dateStr, pos);
    }
    // Also consider "stringified" simple time stamp
    int i = dateStr.length();
    while (--i >= 0) {
        char ch = dateStr.charAt(i);
        if (ch < '0' || ch > '9') {
            // 07-Aug-2013, tatu: And [databind#267] points out that negative numbers should also work
            if (i > 0 || ch != '-') {
                break;
            }
        }
    }
    if ((i < 0)
        // let's just assume negative numbers are fine (can't be RFC-1123 anyway); check length for positive
            && (dateStr.charAt(0) == '-' || NumberInput.inLongRange(dateStr, false))) {
        return _parseDateFromLong(dateStr, pos);
    }
    // Otherwise, fall back to using RFC 1123. NOTE: call will NOT throw, just returns `null`
    return parseAsRFC1123(dateStr, pos);
}
 

private void _parseSlowInt(int expType) throws IOException
{
    String numStr = _textBuffer.contentsAsString();
    try {
        int len = _intLength;
        char[] buf = _textBuffer.getTextBuffer();
        int offset = _textBuffer.getTextOffset();
        if (_numberNegative) {
            ++offset;
        }
        // Some long cases still...
        if (NumberInput.inLongRange(buf, offset, len, _numberNegative)) {
            // Probably faster to construct a String, call parse, than to use BigInteger
            _numberLong = Long.parseLong(numStr);
            _numTypesValid = NR_LONG;
        } else {
            // nope, need the heavy guns... (rare case)
            _numberBigInt = new BigInteger(numStr);
            _numTypesValid = NR_BIGINT;
        }
    } catch (NumberFormatException nex) {
        // Can this ever occur? Due to overflow, maybe?
        _wrapError("Malformed numeric value '"+numStr+"'", nex);
    }
}
 

/**
 * Convenience method for converting contents of the buffer
 * into a {@link BigDecimal}.
 */
public BigDecimal contentsAsDecimal() throws NumberFormatException
{
    // Already got a pre-cut array?
    if (_resultArray != null) {
        return NumberInput.parseBigDecimal(_resultArray);
    }
    // Or a shared buffer?
    if ((_inputStart >= 0) && (_inputBuffer != null)) {
        return NumberInput.parseBigDecimal(_inputBuffer, _inputStart, _inputLen);
    }
    // Or if not, just a single buffer (the usual case)
    if ((_segmentSize == 0) && (_currentSegment != null)) {
        return NumberInput.parseBigDecimal(_currentSegment, 0, _currentSize);
    }
    // If not, let's just get it aggregated...
    return NumberInput.parseBigDecimal(contentsAsArray());
}
 

private void _parseSlowInt(int expType, char[] buf, int offset, int len) throws IOException
{
    String numStr = _textBuffer.contentsAsString();
    try {
        // [JACKSON-230] Some long cases still...
        if (NumberInput.inLongRange(buf, offset, len, _numberNegative)) {
            // Probably faster to construct a String, call parse, than to use BigInteger
            _numberLong = Long.parseLong(numStr);
            _numTypesValid = NR_LONG;
        } else {
            // nope, need the heavy guns... (rare case)
            _numberBigInt = new BigInteger(numStr);
            _numTypesValid = NR_BIGINT;
        }
    } catch (NumberFormatException nex) {
        // Can this ever occur? Due to overflow, maybe?
        _wrapError("Malformed numeric value '"+numStr+"'", nex);
    }
}
 

/**
 * Convenience method for converting contents of the buffer
 * into a {@link BigDecimal}.
 */
public BigDecimal contentsAsDecimal() throws NumberFormatException
{
    // Already got a pre-cut array?
    if (_resultArray != null) {
        return NumberInput.parseBigDecimal(_resultArray);
    }
    // Or a shared buffer?
    if ((_inputStart >= 0) && (_inputBuffer != null)) {
        return NumberInput.parseBigDecimal(_inputBuffer, _inputStart, _inputLen);
    }
    // Or if not, just a single buffer (the usual case)
    if ((_segmentSize == 0) && (_currentSegment != null)) {
        return NumberInput.parseBigDecimal(_currentSegment, 0, _currentSize);
    }
    // If not, let's just get it aggregated...
    return NumberInput.parseBigDecimal(contentsAsArray());
}
 

private Long rangeCheckedLong(JsonParser parser, DeserializationContext context)
throws IOException {
    String text = parser.getText().trim();
    if (text.length() == 0) {
        return null;
    }
    try {
        return Long.valueOf(NumberInput.parseLong(text));
    }
    catch (Exception e) {
        throw context.weirdStringException(//NOSONAR
            _valueClass,
            "Over/underflow: numeric value (" + text +") out of range of Long ("
                + Long.MIN_VALUE + " to " + Long.MAX_VALUE + ")"
        );
    }
}
 

/**
 * @since 2.9
 */
protected final long _parseLongPrimitive(DeserializationContext ctxt, String text) throws IOException
{
    try {
        return NumberInput.parseLong(text);
    } catch (IllegalArgumentException iae) { }
    {
        Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text,
                "not a valid long value");
        return _nonNullNumber(v).longValue();
    }
}
 

/**
 * Helper method for encapsulating calls to low-level double value parsing; single place
 * just because we need a work-around that must be applied to all calls.
 */
protected final static double parseDouble(String numStr) throws NumberFormatException
{
    // avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?
    if (NumberInput.NASTY_SMALL_DOUBLE.equals(numStr)) {
        return Double.MIN_NORMAL; // since 2.7; was MIN_VALUE prior
    }
    return Double.parseDouble(numStr);
}
 

protected final Long _parseLong(JsonParser p, DeserializationContext ctxt) throws IOException
{
    switch (p.getCurrentTokenId()) {
    // NOTE: caller assumed to usually check VALUE_NUMBER_INT in fast path
    case JsonTokenId.ID_NUMBER_INT:
        return p.getLongValue();
    case JsonTokenId.ID_NUMBER_FLOAT:
        if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT)) {
            _failDoubleToIntCoercion(p, ctxt, "Long");
        }
        return p.getValueAsLong();
    case JsonTokenId.ID_STRING:
        String text = p.getText().trim();
        if (text.length() == 0) {
            return (Long) _coerceEmptyString(ctxt, _primitive);
        }
        if (_hasTextualNull(text)) {
            return (Long) _coerceTextualNull(ctxt, _primitive);
        }
        _verifyStringForScalarCoercion(ctxt, text);
        // let's allow Strings to be converted too
        try {
            return Long.valueOf(NumberInput.parseLong(text));
        } catch (IllegalArgumentException iae) { }
        return (Long) ctxt.handleWeirdStringValue(_valueClass, text,
                "not a valid Long value");
        // fall-through
    case JsonTokenId.ID_NULL:
        return (Long) _coerceNullToken(ctxt, _primitive);
    case JsonTokenId.ID_START_ARRAY:
        return _deserializeFromArray(p, ctxt);
    }
    // Otherwise, no can do:
    return (Long) ctxt.handleUnexpectedToken(_valueClass, p);
}
 

private Date _parseDateFromLong(String longStr, ParsePosition pos) throws ParseException
{
    long ts;
    try {
        ts = NumberInput.parseLong(longStr);
    } catch (NumberFormatException e) {
        throw new ParseException(String.format(
                "Timestamp value %s out of 64-bit value range", longStr),
                pos.getErrorIndex());
    }
    return new Date(ts);
}
 

private final static int _parseIndex(String str) {
    final int len = str.length();
    // [core#133]: beware of super long indexes; assume we never
    // have arrays over 2 billion entries so ints are fine.
    if (len == 0 || len > 10) {
        return -1;
    }
    // [core#176]: no leading zeroes allowed
    char c = str.charAt(0);
    if (c <= '0') {
        return (len == 1 && c == '0') ? 0 : -1;
    }
    if (c > '9') {
        return -1;
    }
    for (int i = 1; i < len; ++i) {
        c = str.charAt(i);
        if (c > '9' || c < '0') {
            return -1;
        }
    }
    if (len == 10) {
        long l = NumberInput.parseLong(str);
        if (l > Integer.MAX_VALUE) {
            return -1;
        }
    }
    return NumberInput.parseInt(str);
}
 

@Override
public int getValueAsInt(int defaultValue) throws IOException
{
    JsonToken t = _currToken;
    if ((t == JsonToken.VALUE_NUMBER_INT) || (t == JsonToken.VALUE_NUMBER_FLOAT)) {
        return getIntValue();
    }
    if (t != null) {
        switch (t.id()) {
        case ID_STRING:
            String str = getText();
            if (_hasTextualNull(str)) {
                return 0;
            }
            return NumberInput.parseAsInt(str, defaultValue);
        case ID_TRUE:
            return 1;
        case ID_FALSE:
            return 0;
        case ID_NULL:
            return 0;
        case ID_EMBEDDED_OBJECT:
            Object value = getEmbeddedObject();
            if (value instanceof Number) {
                return ((Number) value).intValue();
            }
        }
    }
    return defaultValue;
}
 

@Override
public long getValueAsLong(long defaultValue) throws IOException
{
    JsonToken t = _currToken;
    if ((t == JsonToken.VALUE_NUMBER_INT) || (t == JsonToken.VALUE_NUMBER_FLOAT)) {
        return getLongValue();
    }
    if (t != null) {
        switch (t.id()) {
        case ID_STRING:
            String str = getText();
            if (_hasTextualNull(str)) {
                return 0L;
            }
            return NumberInput.parseAsLong(str, defaultValue);
        case ID_TRUE:
            return 1L;
        case ID_FALSE:
        case ID_NULL:
            return 0L;
        case ID_EMBEDDED_OBJECT:
            Object value = getEmbeddedObject();
            if (value instanceof Number) {
                return ((Number) value).longValue();
            }
        }
    }
    return defaultValue;
}
 

@Override
public double getValueAsDouble(double defaultValue) throws IOException
{
    JsonToken t = _currToken;
    if (t != null) {
        switch (t.id()) {
        case ID_STRING:
            String str = getText();
            if (_hasTextualNull(str)) {
                return 0L;
            }
            return NumberInput.parseAsDouble(str, defaultValue);
        case ID_NUMBER_INT:
        case ID_NUMBER_FLOAT:
            return getDoubleValue();
        case ID_TRUE:
            return 1.0;
        case ID_FALSE:
        case ID_NULL:
            return 0.0;
        case ID_EMBEDDED_OBJECT:
            Object value = this.getEmbeddedObject();
            if (value instanceof Number) {
                return ((Number) value).doubleValue();
            }
        }
    }
    return defaultValue;
}
 

/**
 * Specialized convenience method that will decode a 32-bit int,
 * of at most 9 digits (and possible leading minus sign).
 *
 * @param neg Whether contents start with a minus sign
 *
 * @since 2.9
 */
public int contentsAsInt(boolean neg) {
    if ((_inputStart >= 0) && (_inputBuffer != null)) {
        if (neg) {
            return -NumberInput.parseInt(_inputBuffer, _inputStart+1, _inputLen-1);
        }
        return NumberInput.parseInt(_inputBuffer, _inputStart, _inputLen);
    }
    if (neg) {
        return -NumberInput.parseInt(_currentSegment, 1, _currentSize-1);
    }
    return NumberInput.parseInt(_currentSegment, 0, _currentSize);
}
 

/**
 * Specialized convenience method that will decode a 64-bit int,
 * of at most 18 digits (and possible leading minus sign).
 *
 * @param neg Whether contents start with a minus sign
 *
 * @since 2.9
 */
public long contentsAsLong(boolean neg) {
    if ((_inputStart >= 0) && (_inputBuffer != null)) {
        if (neg) {
            return -NumberInput.parseLong(_inputBuffer, _inputStart+1, _inputLen-1);
        }
        return NumberInput.parseLong(_inputBuffer, _inputStart, _inputLen);
    }
    if (neg) {
        return -NumberInput.parseLong(_currentSegment, 1, _currentSize-1);
    }
    return NumberInput.parseLong(_currentSegment, 0, _currentSize);
}
 

/** Parses a long out of the input, using the optimized path when the value is not quoted. */
private static long parseLong(JsonParser parser) throws IOException {
  if (parser.currentToken() == JsonToken.VALUE_NUMBER_INT) {
    return parser.getLongValue();
  }
  return NumberInput.parseLong(parser.getText());
}
 

protected final long _deserializeLong(JsonParser p, DeserializationContext ctxt)
    throws IOException
{
    switch (p.currentTokenId()) {
    case JsonTokenId.ID_NUMBER_INT:
        return p.getLongValue();
    case JsonTokenId.ID_NUMBER_FLOAT:
        if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT)) {
            _failDoubleToIntCoercion(p, ctxt, "long");
        }
        return p.getValueAsLong();
    case JsonTokenId.ID_STRING:
        _verifyScalarCoercion(ctxt, p, "long");
        String text = p.getText().trim();
        if (text.length() == 0 || _hasTextualNull(text)) {
            return 0L;
        }
        try {
            return NumberInput.parseLong(text);
        } catch (IllegalArgumentException iae) { }
        throw ctxt.weirdStringException(text, Long.TYPE, "not a valid long value");
    case JsonTokenId.ID_NULL:
        if (ctxt.isEnabled(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES)) {
            _failNullToPrimitiveCoercion(ctxt, "long");
        }
        return 0L;
    case JsonTokenId.ID_START_ARRAY:
        if (ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) {
            p.nextToken();
            final long parsed = _deserializeLong(p, ctxt);
            JsonToken t = p.nextToken();
            if (t != JsonToken.END_ARRAY) {
                _handleMissingEndArrayForSingle(p, ctxt);
            }            
            return parsed;
        }
        break;
    }
    return (Long) ctxt.handleUnexpectedToken(getType(), p);
}
 

private final static int _parseIndex(String str) {
    final int len = str.length();
    // [core#133]: beware of super long indexes; assume we never
    // have arrays over 2 billion entries so ints are fine.
    if (len == 0 || len > 10) {
        return -1;
    }
    // [core#176]: no leading zeroes allowed
    char c = str.charAt(0);
    if (c <= '0') {
        return (len == 1 && c == '0') ? 0 : -1;
    }
    if (c > '9') {
        return -1;
    }
    for (int i = 1; i < len; ++i) {
        c = str.charAt(i);
        if (c > '9' || c < '0') {
            return -1;
        }
    }
    if (len == 10) {
        long l = NumberInput.parseLong(str);
        if (l > Integer.MAX_VALUE) {
            return -1;
        }
    }
    return NumberInput.parseInt(str);
}
 

/**
 * @since 2.6
 */
protected int _parseIntValue() throws IOException
{
    // Inlined variant of: _parseNumericValue(NR_INT)

    if (_currToken == JsonToken.VALUE_NUMBER_INT) {
        char[] buf = _textBuffer.getTextBuffer();
        int offset = _textBuffer.getTextOffset();
        int len = _intLength;
        if (_numberNegative) {
            ++offset;
        }
        if (len <= 9) {
            int i = NumberInput.parseInt(buf, offset, len);
            if (_numberNegative) {
                i = -i;
            }
            _numberInt = i;
            _numTypesValid = NR_INT;
            return i;
        }
    }
    _parseNumericValue(NR_INT);
    if ((_numTypesValid & NR_INT) == 0) {
        convertNumberToInt();
    }
    return _numberInt;
}
 

@Override
public int getValueAsInt(int defaultValue) throws IOException
{
    JsonToken t = _currToken;
    if (t == JsonToken.VALUE_NUMBER_INT) {
        return getIntValue();
    }
    if (t == JsonToken.VALUE_NUMBER_FLOAT) {
        return getIntValue();
    }
    if (t != null) {
        switch (t.id()) {
        case ID_STRING:
            String str = getText();
            if (_hasTextualNull(str)) {
                return 0;
            }
            return NumberInput.parseAsInt(str, defaultValue);
        case ID_TRUE:
            return 1;
        case ID_FALSE:
            return 0;
        case ID_NULL:
            return 0;
        case ID_EMBEDDED_OBJECT:
            Object value = this.getEmbeddedObject();
            if (value instanceof Number) {
                return ((Number) value).intValue();
            }
        }
    }
    return defaultValue;
}
 

@Override
public long getValueAsLong(long defaultValue) throws IOException
{
    JsonToken t = _currToken;
    if (t == JsonToken.VALUE_NUMBER_INT) {
        return getLongValue();
    }
    if (t == JsonToken.VALUE_NUMBER_FLOAT) {
        return getLongValue();
    }
    if (t != null) {
        switch (t.id()) {
        case ID_STRING:
            String str = getText();
            if (_hasTextualNull(str)) {
                return 0L;
            }
            return NumberInput.parseAsLong(str, defaultValue);
        case ID_TRUE:
            return 1L;
        case ID_FALSE:
        case ID_NULL:
            return 0L;
        case ID_EMBEDDED_OBJECT:
            Object value = this.getEmbeddedObject();
            if (value instanceof Number) {
                return ((Number) value).longValue();
            }
        }
    }
    return defaultValue;
}
 

@Override
public double getValueAsDouble(double defaultValue) throws IOException
{
    JsonToken t = _currToken;
    if (t != null) {
        switch (t.id()) {
        case ID_STRING:
            String str = getText();
            if (_hasTextualNull(str)) {
                return 0L;
            }
            return NumberInput.parseAsDouble(str, defaultValue);
        case ID_NUMBER_INT:
        case ID_NUMBER_FLOAT:
            return getDoubleValue();
        case ID_TRUE:
            return 1.0;
        case ID_FALSE:
        case ID_NULL:
            return 0.0;
        case ID_EMBEDDED_OBJECT:
            Object value = this.getEmbeddedObject();
            if (value instanceof Number) {
                return ((Number) value).doubleValue();
            }
        }
    }
    return defaultValue;
}
 

@Override
public Integer deserialize(JsonParser parser, DeserializationContext context) throws IOException {
    JsonToken t = parser.getCurrentToken();
    if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) { // coercing should work too
        return rangeCheckedInteger(parser, context);
    }
    if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        String text = parser.getText().trim();
        try {
            int len = text.length();
            if (len > 9) {
                return rangeCheckedInteger(parser, context);
            }
            if (len == 0) {
                return null;
            }
            return Integer.valueOf(NumberInput.parseInt(text));
        } catch (IllegalArgumentException iae) {
            throw context.weirdStringException(_valueClass, "not a valid Integer value");//NOSONAR
        }
    }
    if (t == JsonToken.VALUE_NULL) {
        return null;
    }
    // Otherwise, no can do:
    throw context.mappingException(_valueClass);
}
 

@Override
protected Byte _parseByte(JsonParser jp, DeserializationContext ctxt) throws IOException {
    JsonToken t = jp.getCurrentToken();
    Integer value = null;
    if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) { // coercing should work too
        value = jp.getIntValue();
    }
    else if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        String text = jp.getText().trim();
        try {
            int len = text.length();
            if (len == 0) {
                return getEmptyValue();
            }
            value = NumberInput.parseInt(text);
        } catch (IllegalArgumentException iae) {
            throw ctxt.weirdStringException(_valueClass, "not a valid Byte value");//NOSONAR
        }
    }
    if (value != null) {
        // So far so good: but does it fit?
        if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
            throw ctxt.weirdStringException(_valueClass, "overflow, value can not be represented as 8-bit value");
        }
        return (byte) (int) value;
    }
    if (t == JsonToken.VALUE_NULL) {
        return getNullValue();
    }
    throw ctxt.mappingException(_valueClass, t);
}
 

protected Byte _parseByte(JsonParser p, DeserializationContext ctxt) throws IOException
{
    JsonToken t = p.getCurrentToken();
    if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        String text = p.getText().trim();
        if (_hasTextualNull(text)) {
            return (Byte) _coerceTextualNull(ctxt, _primitive);
        }
        int len = text.length();
        if (len == 0) {
            return (Byte) _coerceEmptyString(ctxt, _primitive);
        }
        _verifyStringForScalarCoercion(ctxt, text);
        int value;
        try {
            value = NumberInput.parseInt(text);
        } catch (IllegalArgumentException iae) {
            return (Byte) ctxt.handleWeirdStringValue(_valueClass, text,
                    "not a valid Byte value");
        }
        // So far so good: but does it fit?
        // as per [JACKSON-804], allow range up to 255, inclusive
        if (_byteOverflow(value)) {
            return (Byte) ctxt.handleWeirdStringValue(_valueClass, text,
                    "overflow, value cannot be represented as 8-bit value");
            // fall-through for deferred fails
        }
        return Byte.valueOf((byte) value);
    }
    if (t == JsonToken.VALUE_NUMBER_FLOAT) {
        if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT)) {
            _failDoubleToIntCoercion(p, ctxt, "Byte");
        }
        return p.getByteValue();
    }
    if (t == JsonToken.VALUE_NULL) {
        return (Byte) _coerceNullToken(ctxt, _primitive);
    }
    // [databind#381]
    if (t == JsonToken.START_ARRAY) {
        return _deserializeFromArray(p, ctxt);
    }
    if (t == JsonToken.VALUE_NUMBER_INT) { // shouldn't usually be called with it but
        return p.getByteValue();
    }
    return (Byte) ctxt.handleUnexpectedToken(_valueClass, p);
}
 

protected Short _parseShort(JsonParser p, DeserializationContext ctxt) throws IOException
{
    JsonToken t = p.getCurrentToken();
    if (t == JsonToken.VALUE_NUMBER_INT) {
        return p.getShortValue();
    }
    if (t == JsonToken.VALUE_STRING) { // let's do implicit re-parse
        String text = p.getText().trim();
        int len = text.length();
        if (len == 0) {
            return (Short) _coerceEmptyString(ctxt, _primitive);
        }
        if (_hasTextualNull(text)) {
            return (Short) _coerceTextualNull(ctxt, _primitive);
        }
        _verifyStringForScalarCoercion(ctxt, text);
        int value;
        try {
            value = NumberInput.parseInt(text);
        } catch (IllegalArgumentException iae) {
            return (Short) ctxt.handleWeirdStringValue(_valueClass, text,
                    "not a valid Short value");
        }
        // So far so good: but does it fit?
        if (_shortOverflow(value)) {
            return (Short) ctxt.handleWeirdStringValue(_valueClass, text,
                    "overflow, value cannot be represented as 16-bit value");
        }
        return Short.valueOf((short) value);
    }
    if (t == JsonToken.VALUE_NUMBER_FLOAT) {
        if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT)) {
            _failDoubleToIntCoercion(p, ctxt, "Short");
        }
        return p.getShortValue();
    }
    if (t == JsonToken.VALUE_NULL) {
        return (Short) _coerceNullToken(ctxt, _primitive);
    }
    if (t == JsonToken.START_ARRAY) {
        return _deserializeFromArray(p, ctxt);
    }
    return (Short) ctxt.handleUnexpectedToken(_valueClass, p);
}
 

protected final Integer _parseInteger(JsonParser p, DeserializationContext ctxt) throws IOException
{
    switch (p.getCurrentTokenId()) {
    // NOTE: caller assumed to usually check VALUE_NUMBER_INT in fast path
    case JsonTokenId.ID_NUMBER_INT:
        return Integer.valueOf(p.getIntValue());
    case JsonTokenId.ID_NUMBER_FLOAT: // coercing may work too
        if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT)) {
            _failDoubleToIntCoercion(p, ctxt, "Integer");
        }
        return Integer.valueOf(p.getValueAsInt());
    case JsonTokenId.ID_STRING: // let's do implicit re-parse
        String text = p.getText().trim();
        int len = text.length();
        if (len == 0) {
            return (Integer) _coerceEmptyString(ctxt, _primitive);
        }
        if (_hasTextualNull(text)) {
            return (Integer) _coerceTextualNull(ctxt, _primitive);
        }
        _verifyStringForScalarCoercion(ctxt, text);
        try {
            if (len > 9) {
                long l = Long.parseLong(text);
                if (_intOverflow(l)) {
                    return (Integer) ctxt.handleWeirdStringValue(_valueClass, text, String.format(
                        "Overflow: numeric value (%s) out of range of Integer (%d - %d)",
                        text, Integer.MIN_VALUE, Integer.MAX_VALUE));
                }
                return Integer.valueOf((int) l);
            }
            return Integer.valueOf(NumberInput.parseInt(text));
        } catch (IllegalArgumentException iae) {
            return (Integer) ctxt.handleWeirdStringValue(_valueClass, text,
                    "not a valid Integer value");
        }
    case JsonTokenId.ID_NULL:
        return (Integer) _coerceNullToken(ctxt, _primitive);
    case JsonTokenId.ID_START_ARRAY:
        return _deserializeFromArray(p, ctxt);
    }
    // Otherwise, no can do:
    return (Integer) ctxt.handleUnexpectedToken(_valueClass, p);
}
 

protected double _parseDouble(String key) throws IllegalArgumentException {
    return NumberInput.parseDouble(key);
}
 

@Override
public int asInt(int defaultValue) {
    return NumberInput.parseAsInt(_value, defaultValue);
}