// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package com.fasterxml.jackson.databind.deser.std;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.io.NumberInput;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.KeyDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.Converter;
import java.io.IOException;
import java.io.Serializable;
import java.util.Date;

// Referenced classes of package com.fasterxml.jackson.databind.deser.std:
//            StdDelegatingDeserializer

public abstract class StdDeserializer extends JsonDeserializer
    implements Serializable
{

    protected static final int F_MASK_INT_COERCIONS;
    private static final long serialVersionUID = 1L;
    protected final Class _valueClass;

    protected StdDeserializer(JavaType javatype)
    {
        if (javatype == null)
        {
            javatype = null;
        } else
        {
            javatype = javatype.getRawClass();
        }
        _valueClass = javatype;
    }

    protected StdDeserializer(StdDeserializer stddeserializer)
    {
        _valueClass = stddeserializer._valueClass;
    }

    protected StdDeserializer(Class class1)
    {
        _valueClass = class1;
    }

    protected static final double parseDouble(String s)
        throws NumberFormatException
    {
        if ("2.2250738585072012e-308".equals(s))
        {
            return 4.9406564584124654E-324D;
        } else
        {
            return Double.parseDouble(s);
        }
    }

    protected Object _coerceIntegral(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        int i = deserializationcontext.getDeserializationFeatures();
        if (DeserializationFeature.USE_BIG_INTEGER_FOR_INTS.enabledIn(i))
        {
            return jsonparser.getBigIntegerValue();
        }
        if (DeserializationFeature.USE_LONG_FOR_INTS.enabledIn(i))
        {
            return Long.valueOf(jsonparser.getLongValue());
        } else
        {
            return jsonparser.getBigIntegerValue();
        }
    }

    protected Object _deserializeFromEmpty(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        JsonToken jsontoken = jsonparser.getCurrentToken();
        if (jsontoken != JsonToken.START_ARRAY) goto _L2; else goto _L1
_L1:
        if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT)) goto _L4; else goto _L3
_L3:
        if (jsonparser.nextToken() != JsonToken.END_ARRAY) goto _L6; else goto _L5
_L5:
        return null;
_L6:
        throw deserializationcontext.mappingException(handledType(), JsonToken.START_ARRAY);
_L2:
        if (jsontoken == JsonToken.VALUE_STRING && deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT) && jsonparser.getText().trim().isEmpty()) goto _L5; else goto _L4
_L4:
        throw deserializationcontext.mappingException(handledType());
    }

    protected void _failDoubleToIntCoercion(JsonParser jsonparser, DeserializationContext deserializationcontext, String s)
        throws IOException
    {
        throw deserializationcontext.mappingException("Can not coerce a floating-point value ('%s') into %s; enable `DeserializationFeature.ACCEPT_FLOAT_AS_INT` to allow", new Object[] {
            jsonparser.getValueAsString(), s
        });
    }

    protected boolean _hasTextualNull(String s)
    {
        return "null".equals(s);
    }

    protected final boolean _isIntNumber(String s)
    {
        int j = s.length();
        if (j <= 0) goto _L2; else goto _L1
_L1:
        int i;
        i = s.charAt(0);
        char c;
        if (i == '-' || i == '+')
        {
            i = 1;
        } else
        {
            i = 0;
        }
_L5:
        if (i >= j)
        {
            break; /* Loop/switch isn't completed */
        }
        c = s.charAt(i);
        if (c <= '9' && c >= '0') goto _L3; else goto _L2
_L2:
        return false;
_L3:
        i++;
        if (true) goto _L5; else goto _L4
_L4:
        return true;
    }

    protected final boolean _isNaN(String s)
    {
        return "NaN".equals(s);
    }

    protected final boolean _isNegInf(String s)
    {
        return "-Infinity".equals(s) || "-INF".equals(s);
    }

    protected final boolean _isPosInf(String s)
    {
        return "Infinity".equals(s) || "INF".equals(s);
    }

    protected final Boolean _parseBoolean(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_TRUE)
        {
            return Boolean.TRUE;
        }
        if (obj == JsonToken.VALUE_FALSE)
        {
            return Boolean.FALSE;
        }
        if (obj == JsonToken.VALUE_NUMBER_INT)
        {
            if (jsonparser.getNumberType() == com.fasterxml.jackson.core.JsonParser.NumberType.INT)
            {
                if (jsonparser.getIntValue() == 0)
                {
                    return Boolean.FALSE;
                } else
                {
                    return Boolean.TRUE;
                }
            } else
            {
                return Boolean.valueOf(_parseBooleanFromNumber(jsonparser, deserializationcontext));
            }
        }
        if (obj == JsonToken.VALUE_NULL)
        {
            return (Boolean)getNullValue(deserializationcontext);
        }
        if (obj == JsonToken.VALUE_STRING)
        {
            jsonparser = jsonparser.getText().trim();
            if ("true".equals(jsonparser) || "True".equals(jsonparser))
            {
                return Boolean.TRUE;
            }
            if ("false".equals(jsonparser) || "False".equals(jsonparser))
            {
                return Boolean.FALSE;
            }
            if (jsonparser.length() == 0)
            {
                return (Boolean)getEmptyValue(deserializationcontext);
            }
            if (_hasTextualNull(jsonparser))
            {
                return (Boolean)getNullValue(deserializationcontext);
            } else
            {
                throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "only \"true\" or \"false\" recognized");
            }
        }
        if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            obj = _parseBoolean(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Boolean' value but there was more than a single value in the array");
            } else
            {
                return ((Boolean) (obj));
            }
        } else
        {
            throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
        }
    }

    protected final boolean _parseBooleanFromNumber(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        if (jsonparser.getNumberType() == com.fasterxml.jackson.core.JsonParser.NumberType.LONG)
        {
            if (jsonparser.getLongValue() == 0L)
            {
                jsonparser = Boolean.FALSE;
            } else
            {
                jsonparser = Boolean.TRUE;
            }
            return jsonparser.booleanValue();
        }
        jsonparser = jsonparser.getText();
        if ("0.0".equals(jsonparser) || "0".equals(jsonparser))
        {
            return Boolean.FALSE.booleanValue();
        } else
        {
            return Boolean.TRUE.booleanValue();
        }
    }

    protected final boolean _parseBooleanPrimitive(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        boolean flag2 = true;
        boolean flag3 = false;
        JsonToken jsontoken = jsonparser.getCurrentToken();
        boolean flag;
        if (jsontoken == JsonToken.VALUE_TRUE)
        {
            flag = true;
        } else
        {
            flag = flag3;
            if (jsontoken != JsonToken.VALUE_FALSE)
            {
                flag = flag3;
                if (jsontoken != JsonToken.VALUE_NULL)
                {
                    if (jsontoken == JsonToken.VALUE_NUMBER_INT)
                    {
                        if (jsonparser.getNumberType() == com.fasterxml.jackson.core.JsonParser.NumberType.INT)
                        {
                            if (jsonparser.getIntValue() != 0)
                            {
                                flag = flag2;
                            } else
                            {
                                flag = false;
                            }
                            return flag;
                        } else
                        {
                            return _parseBooleanFromNumber(jsonparser, deserializationcontext);
                        }
                    }
                    if (jsontoken == JsonToken.VALUE_STRING)
                    {
                        jsonparser = jsonparser.getText().trim();
                        if ("true".equals(jsonparser) || "True".equals(jsonparser))
                        {
                            return true;
                        }
                        flag = flag3;
                        if (!"false".equals(jsonparser))
                        {
                            flag = flag3;
                            if (!"False".equals(jsonparser))
                            {
                                flag = flag3;
                                if (jsonparser.length() != 0)
                                {
                                    flag = flag3;
                                    if (!_hasTextualNull(jsonparser))
                                    {
                                        throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "only \"true\" or \"false\" recognized");
                                    }
                                }
                            }
                        }
                    } else
                    if (jsontoken == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
                    {
                        jsonparser.nextToken();
                        boolean flag1 = _parseBooleanPrimitive(jsonparser, deserializationcontext);
                        if (jsonparser.nextToken() != JsonToken.END_ARRAY)
                        {
                            throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'boolean' value but there was more than a single value in the array");
                        } else
                        {
                            return flag1;
                        }
                    } else
                    {
                        throw deserializationcontext.mappingException(_valueClass, jsontoken);
                    }
                }
            }
        }
        return flag;
    }

    protected Byte _parseByte(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_NUMBER_INT)
        {
            return Byte.valueOf(jsonparser.getByteValue());
        }
        if (obj == JsonToken.VALUE_STRING)
        {
            jsonparser = jsonparser.getText().trim();
            if (_hasTextualNull(jsonparser))
            {
                return (Byte)getNullValue(deserializationcontext);
            }
            int i;
            try
            {
                if (jsonparser.length() == 0)
                {
                    return (Byte)getEmptyValue(deserializationcontext);
                }
                i = NumberInput.parseInt(jsonparser);
            }
            // Misplaced declaration of an exception variable
            catch (Object obj)
            {
                throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid Byte value");
            }
            if (i < -128 || i > 255)
            {
                throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "overflow, value can not be represented as 8-bit value");
            } else
            {
                return Byte.valueOf((byte)i);
            }
        }
        if (obj == JsonToken.VALUE_NUMBER_FLOAT)
        {
            if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT))
            {
                _failDoubleToIntCoercion(jsonparser, deserializationcontext, "Byte");
            }
            return Byte.valueOf(jsonparser.getByteValue());
        }
        if (obj == JsonToken.VALUE_NULL)
        {
            return (Byte)getNullValue(deserializationcontext);
        }
        if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            obj = _parseByte(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Byte' value but there was more than a single value in the array");
            } else
            {
                return ((Byte) (obj));
            }
        } else
        {
            throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
        }
    }

    protected Date _parseDate(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj;
        obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_NUMBER_INT)
        {
            return new Date(jsonparser.getLongValue());
        }
        if (obj == JsonToken.VALUE_NULL)
        {
            return (Date)getNullValue(deserializationcontext);
        }
        if (obj != JsonToken.VALUE_STRING)
        {
            break MISSING_BLOCK_LABEL_148;
        }
        obj = null;
        try
        {
            jsonparser = jsonparser.getText().trim();
        }
        // Misplaced declaration of an exception variable
        catch (JsonParser jsonparser)
        {
            throw deserializationcontext.weirdStringException(((String) (obj)), _valueClass, (new StringBuilder()).append("not a valid representation (error: ").append(jsonparser.getMessage()).append(")").toString());
        }
        obj = jsonparser;
        if (jsonparser.length() != 0)
        {
            break MISSING_BLOCK_LABEL_77;
        }
        obj = jsonparser;
        return (Date)getEmptyValue(deserializationcontext);
        obj = jsonparser;
        if (!_hasTextualNull(jsonparser))
        {
            break MISSING_BLOCK_LABEL_98;
        }
        obj = jsonparser;
        return (Date)getNullValue(deserializationcontext);
        obj = jsonparser;
        jsonparser = deserializationcontext.parseDate(jsonparser);
        return jsonparser;
        if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            obj = _parseDate(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'java.util.Date' value but there was more than a single value in the array");
            } else
            {
                return ((Date) (obj));
            }
        } else
        {
            throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
        }
    }

    protected final Double _parseDouble(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj;
        obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_NUMBER_INT || obj == JsonToken.VALUE_NUMBER_FLOAT)
        {
            return Double.valueOf(jsonparser.getDoubleValue());
        }
        if (obj != JsonToken.VALUE_STRING) goto _L2; else goto _L1
_L1:
        jsonparser = jsonparser.getText().trim();
        if (jsonparser.length() == 0)
        {
            return (Double)getEmptyValue(deserializationcontext);
        }
        if (_hasTextualNull(jsonparser))
        {
            return (Double)getNullValue(deserializationcontext);
        }
        jsonparser.charAt(0);
        JVM INSTR lookupswitch 3: default 120
    //                   45: 160
    //                   73: 130
    //                   78: 145;
           goto _L3 _L4 _L5 _L6
_L3:
        double d;
        try
        {
            d = parseDouble(jsonparser);
        }
        // Misplaced declaration of an exception variable
        catch (Object obj)
        {
            throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid Double value");
        }
        return Double.valueOf(d);
_L5:
        if (!_isPosInf(jsonparser)) goto _L3; else goto _L7
_L7:
        return Double.valueOf((1.0D / 0.0D));
_L6:
        if (!_isNaN(jsonparser)) goto _L3; else goto _L8
_L8:
        return Double.valueOf((0.0D / 0.0D));
_L4:
        if (!_isNegInf(jsonparser)) goto _L3; else goto _L9
_L9:
        return Double.valueOf((-1.0D / 0.0D));
_L2:
        if (obj == JsonToken.VALUE_NULL)
        {
            return (Double)getNullValue(deserializationcontext);
        }
        if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            obj = _parseDouble(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Double' value but there was more than a single value in the array");
            } else
            {
                return ((Double) (obj));
            }
        } else
        {
            throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
        }
    }

    protected final double _parseDoublePrimitive(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        double d1;
        Object obj;
        d1 = 0.0D;
        obj = jsonparser.getCurrentToken();
        if (obj != JsonToken.VALUE_NUMBER_INT && obj != JsonToken.VALUE_NUMBER_FLOAT) goto _L2; else goto _L1
_L1:
        double d = jsonparser.getDoubleValue();
_L13:
        return d;
_L2:
        if (obj != JsonToken.VALUE_STRING) goto _L4; else goto _L3
_L3:
        jsonparser = jsonparser.getText().trim();
        d = d1;
        if (jsonparser.length() == 0)
        {
            continue; /* Loop/switch isn't completed */
        }
        d = d1;
        if (_hasTextualNull(jsonparser))
        {
            continue; /* Loop/switch isn't completed */
        }
        jsonparser.charAt(0);
        JVM INSTR lookupswitch 3: default 108
    //                   45: 139
    //                   73: 115
    //                   78: 127;
           goto _L5 _L6 _L7 _L8
_L5:
        try
        {
            d = parseDouble(jsonparser);
        }
        // Misplaced declaration of an exception variable
        catch (Object obj)
        {
            throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid double value");
        }
        return d;
_L7:
        if (!_isPosInf(jsonparser)) goto _L5; else goto _L9
_L9:
        return (1.0D / 0.0D);
_L8:
        if (!_isNaN(jsonparser)) goto _L5; else goto _L10
_L10:
        return (0.0D / 0.0D);
_L6:
        if (!_isNegInf(jsonparser)) goto _L5; else goto _L11
_L11:
        return (-1.0D / 0.0D);
_L4:
        d = d1;
        if (obj != JsonToken.VALUE_NULL)
        {
            if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
            {
                jsonparser.nextToken();
                d = _parseDoublePrimitive(jsonparser, deserializationcontext);
                if (jsonparser.nextToken() != JsonToken.END_ARRAY)
                {
                    throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Byte' value but there was more than a single value in the array");
                }
            } else
            {
                throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
            }
        }
        if (true) goto _L13; else goto _L12
_L12:
    }

    protected final Float _parseFloat(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj;
        obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_NUMBER_INT || obj == JsonToken.VALUE_NUMBER_FLOAT)
        {
            return Float.valueOf(jsonparser.getFloatValue());
        }
        if (obj != JsonToken.VALUE_STRING) goto _L2; else goto _L1
_L1:
        jsonparser = jsonparser.getText().trim();
        if (jsonparser.length() == 0)
        {
            return (Float)getEmptyValue(deserializationcontext);
        }
        if (_hasTextualNull(jsonparser))
        {
            return (Float)getNullValue(deserializationcontext);
        }
        jsonparser.charAt(0);
        JVM INSTR lookupswitch 3: default 120
    //                   45: 160
    //                   73: 130
    //                   78: 145;
           goto _L3 _L4 _L5 _L6
_L3:
        float f;
        try
        {
            f = Float.parseFloat(jsonparser);
        }
        // Misplaced declaration of an exception variable
        catch (Object obj)
        {
            throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid Float value");
        }
        return Float.valueOf(f);
_L5:
        if (!_isPosInf(jsonparser)) goto _L3; else goto _L7
_L7:
        return Float.valueOf((1.0F / 0.0F));
_L6:
        if (!_isNaN(jsonparser)) goto _L3; else goto _L8
_L8:
        return Float.valueOf((0.0F / 0.0F));
_L4:
        if (!_isNegInf(jsonparser)) goto _L3; else goto _L9
_L9:
        return Float.valueOf((-1.0F / 0.0F));
_L2:
        if (obj == JsonToken.VALUE_NULL)
        {
            return (Float)getNullValue(deserializationcontext);
        }
        if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            obj = _parseFloat(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Byte' value but there was more than a single value in the array");
            } else
            {
                return ((Float) (obj));
            }
        } else
        {
            throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
        }
    }

    protected final float _parseFloatPrimitive(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        float f1;
        Object obj;
        f1 = 0.0F;
        obj = jsonparser.getCurrentToken();
        if (obj != JsonToken.VALUE_NUMBER_INT && obj != JsonToken.VALUE_NUMBER_FLOAT) goto _L2; else goto _L1
_L1:
        float f = jsonparser.getFloatValue();
_L13:
        return f;
_L2:
        if (obj != JsonToken.VALUE_STRING) goto _L4; else goto _L3
_L3:
        jsonparser = jsonparser.getText().trim();
        f = f1;
        if (jsonparser.length() == 0)
        {
            continue; /* Loop/switch isn't completed */
        }
        f = f1;
        if (_hasTextualNull(jsonparser))
        {
            continue; /* Loop/switch isn't completed */
        }
        jsonparser.charAt(0);
        JVM INSTR lookupswitch 3: default 108
    //                   45: 139
    //                   73: 115
    //                   78: 127;
           goto _L5 _L6 _L7 _L8
_L5:
        try
        {
            f = Float.parseFloat(jsonparser);
        }
        // Misplaced declaration of an exception variable
        catch (Object obj)
        {
            throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid float value");
        }
        return f;
_L7:
        if (!_isPosInf(jsonparser)) goto _L5; else goto _L9
_L9:
        return (1.0F / 0.0F);
_L8:
        if (!_isNaN(jsonparser)) goto _L5; else goto _L10
_L10:
        return (0.0F / 0.0F);
_L6:
        if (!_isNegInf(jsonparser)) goto _L5; else goto _L11
_L11:
        return (-1.0F / 0.0F);
_L4:
        f = f1;
        if (obj != JsonToken.VALUE_NULL)
        {
            if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
            {
                jsonparser.nextToken();
                f = _parseFloatPrimitive(jsonparser, deserializationcontext);
                if (jsonparser.nextToken() != JsonToken.END_ARRAY)
                {
                    throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'float' value but there was more than a single value in the array");
                }
            } else
            {
                throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
            }
        }
        if (true) goto _L13; else goto _L12
_L12:
    }

    protected final int _parseIntPrimitive(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        boolean flag = false;
        if (!jsonparser.hasToken(JsonToken.VALUE_NUMBER_INT)) goto _L2; else goto _L1
_L1:
        int i = jsonparser.getIntValue();
_L4:
        return i;
_L2:
        Object obj;
        int j;
        long l;
        obj = jsonparser.getCurrentToken();
        if (obj != JsonToken.VALUE_STRING)
        {
            break MISSING_BLOCK_LABEL_187;
        }
        jsonparser = jsonparser.getText().trim();
        i = ((flag) ? 1 : 0);
        if (_hasTextualNull(jsonparser))
        {
            continue; /* Loop/switch isn't completed */
        }
        try
        {
            j = jsonparser.length();
        }
        // Misplaced declaration of an exception variable
        catch (Object obj)
        {
            throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid int value");
        }
        if (j <= 9)
        {
            break MISSING_BLOCK_LABEL_169;
        }
        l = Long.parseLong(jsonparser);
        if (l >= 0xffffffff80000000L && l <= 0x7fffffffL)
        {
            break MISSING_BLOCK_LABEL_165;
        }
        throw deserializationcontext.weirdStringException(jsonparser, _valueClass, (new StringBuilder()).append("Overflow: numeric value (").append(jsonparser).append(") out of range of int (").append(0x80000000).append(" - ").append(0x7fffffff).append(")").toString());
        return (int)l;
        i = ((flag) ? 1 : 0);
        if (j == 0)
        {
            continue; /* Loop/switch isn't completed */
        }
        i = NumberInput.parseInt(jsonparser);
        return i;
        if (obj == JsonToken.VALUE_NUMBER_FLOAT)
        {
            if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT))
            {
                _failDoubleToIntCoercion(jsonparser, deserializationcontext, "int");
            }
            return jsonparser.getValueAsInt();
        }
        i = ((flag) ? 1 : 0);
        if (obj != JsonToken.VALUE_NULL)
        {
            if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
            {
                jsonparser.nextToken();
                i = _parseIntPrimitive(jsonparser, deserializationcontext);
                if (jsonparser.nextToken() != JsonToken.END_ARRAY)
                {
                    throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'int' value but there was more than a single value in the array");
                }
            } else
            {
                throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
            }
        }
        if (true) goto _L4; else goto _L3
_L3:
    }

    protected final Integer _parseInteger(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        jsonparser.getCurrentTokenId();
        JVM INSTR tableswitch 3 11: default 56
    //                   3 286
    //                   4 56
    //                   5 56
    //                   6 104
    //                   7 69
    //                   8 77
    //                   9 56
    //                   10 56
    //                   11 277;
           goto _L1 _L2 _L1 _L1 _L3 _L4 _L5 _L1 _L1 _L6
_L1:
        throw deserializationcontext.mappingException(_valueClass, jsonparser.getCurrentToken());
_L4:
        return Integer.valueOf(jsonparser.getIntValue());
_L5:
        if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT))
        {
            _failDoubleToIntCoercion(jsonparser, deserializationcontext, "Integer");
        }
        return Integer.valueOf(jsonparser.getValueAsInt());
_L3:
        int i;
        long l;
        jsonparser = jsonparser.getText().trim();
        try
        {
            i = jsonparser.length();
            if (_hasTextualNull(jsonparser))
            {
                return (Integer)getNullValue(deserializationcontext);
            }
        }
        catch (IllegalArgumentException illegalargumentexception)
        {
            throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid Integer value");
        }
        if (i <= 9) goto _L8; else goto _L7
_L7:
        l = Long.parseLong(jsonparser);
        if (l >= 0xffffffff80000000L && l <= 0x7fffffffL) goto _L10; else goto _L9
_L9:
        throw deserializationcontext.weirdStringException(jsonparser, _valueClass, (new StringBuilder()).append("Overflow: numeric value (").append(jsonparser).append(") out of range of Integer (").append(0x80000000).append(" - ").append(0x7fffffff).append(")").toString());
_L10:
        i = (int)l;
        return Integer.valueOf(i);
_L8:
        if (i != 0) goto _L12; else goto _L11
_L11:
        return (Integer)getEmptyValue(deserializationcontext);
_L12:
        i = NumberInput.parseInt(jsonparser);
        return Integer.valueOf(i);
_L6:
        return (Integer)getNullValue(deserializationcontext);
_L2:
        if (deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            Integer integer = _parseInteger(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Integer' value but there was more than a single value in the array");
            } else
            {
                return integer;
            }
        }
        if (true) goto _L1; else goto _L13
_L13:
    }

    protected final Long _parseLong(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        jsonparser.getCurrentTokenId();
        JVM INSTR tableswitch 3 11: default 56
    //                   3 180
    //                   4 56
    //                   5 56
    //                   6 104
    //                   7 69
    //                   8 77
    //                   9 56
    //                   10 56
    //                   11 171;
           goto _L1 _L2 _L1 _L1 _L3 _L4 _L5 _L1 _L1 _L6
_L1:
        throw deserializationcontext.mappingException(_valueClass, jsonparser.getCurrentToken());
_L4:
        return Long.valueOf(jsonparser.getLongValue());
_L5:
        if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT))
        {
            _failDoubleToIntCoercion(jsonparser, deserializationcontext, "Long");
        }
        return Long.valueOf(jsonparser.getValueAsLong());
_L3:
        jsonparser = jsonparser.getText().trim();
        if (jsonparser.length() == 0)
        {
            return (Long)getEmptyValue(deserializationcontext);
        }
        if (_hasTextualNull(jsonparser))
        {
            return (Long)getNullValue(deserializationcontext);
        }
        long l;
        try
        {
            l = NumberInput.parseLong(jsonparser);
        }
        catch (IllegalArgumentException illegalargumentexception)
        {
            throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid Long value");
        }
        return Long.valueOf(l);
_L6:
        return (Long)getNullValue(deserializationcontext);
_L2:
        if (deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            Long long1 = _parseLong(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Long' value but there was more than a single value in the array");
            } else
            {
                return long1;
            }
        }
        if (true) goto _L1; else goto _L7
_L7:
    }

    protected final long _parseLongPrimitive(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        long l;
        long l1;
        l1 = 0L;
        l = l1;
        jsonparser.getCurrentTokenId();
        JVM INSTR tableswitch 3 11: default 60
    //                   3 160
    //                   4 60
    //                   5 60
    //                   6 106
    //                   7 73
    //                   8 82
    //                   9 60
    //                   10 60
    //                   11 79;
           goto _L1 _L2 _L1 _L1 _L3 _L4 _L5 _L1 _L1 _L6
_L6:
        break; /* Loop/switch isn't completed */
_L1:
        throw deserializationcontext.mappingException(_valueClass, jsonparser.getCurrentToken());
_L4:
        l = jsonparser.getLongValue();
_L8:
        return l;
_L5:
        if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT))
        {
            _failDoubleToIntCoercion(jsonparser, deserializationcontext, "long");
        }
        return jsonparser.getValueAsLong();
_L3:
        jsonparser = jsonparser.getText().trim();
        l = l1;
        if (jsonparser.length() != 0)
        {
            l = l1;
            if (!_hasTextualNull(jsonparser))
            {
                try
                {
                    l = NumberInput.parseLong(jsonparser);
                }
                catch (IllegalArgumentException illegalargumentexception)
                {
                    throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid long value");
                }
                return l;
            }
        }
        continue; /* Loop/switch isn't completed */
_L2:
        if (!deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            continue; /* Loop/switch isn't completed */
        }
        jsonparser.nextToken();
        l = _parseLongPrimitive(jsonparser, deserializationcontext);
        if (jsonparser.nextToken() != JsonToken.END_ARRAY)
        {
            throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'long' value but there was more than a single value in the array");
        }
        if (true) goto _L8; else goto _L7
_L7:
        if (true) goto _L1; else goto _L9
_L9:
    }

    protected Short _parseShort(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_NUMBER_INT)
        {
            return Short.valueOf(jsonparser.getShortValue());
        }
        if (obj == JsonToken.VALUE_STRING)
        {
            jsonparser = jsonparser.getText().trim();
            int i;
            try
            {
                if (jsonparser.length() == 0)
                {
                    return (Short)getEmptyValue(deserializationcontext);
                }
                if (_hasTextualNull(jsonparser))
                {
                    return (Short)getNullValue(deserializationcontext);
                }
                i = NumberInput.parseInt(jsonparser);
            }
            // Misplaced declaration of an exception variable
            catch (Object obj)
            {
                throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "not a valid Short value");
            }
            if (i < -32768 || i > 32767)
            {
                throw deserializationcontext.weirdStringException(jsonparser, _valueClass, "overflow, value can not be represented as 16-bit value");
            } else
            {
                return Short.valueOf((short)i);
            }
        }
        if (obj == JsonToken.VALUE_NUMBER_FLOAT)
        {
            if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_FLOAT_AS_INT))
            {
                _failDoubleToIntCoercion(jsonparser, deserializationcontext, "Short");
            }
            return Short.valueOf(jsonparser.getShortValue());
        }
        if (obj == JsonToken.VALUE_NULL)
        {
            return (Short)getNullValue(deserializationcontext);
        }
        if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            obj = _parseShort(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'Short' value but there was more than a single value in the array");
            } else
            {
                return ((Short) (obj));
            }
        } else
        {
            throw deserializationcontext.mappingException(_valueClass, ((JsonToken) (obj)));
        }
    }

    protected final short _parseShortPrimitive(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        int i = _parseIntPrimitive(jsonparser, deserializationcontext);
        if (i < -32768 || i > 32767)
        {
            throw deserializationcontext.weirdStringException(String.valueOf(i), _valueClass, "overflow, value can not be represented as 16-bit value");
        } else
        {
            return (short)i;
        }
    }

    protected final String _parseString(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_STRING)
        {
            obj = jsonparser.getText();
        } else
        if (obj == JsonToken.START_ARRAY && deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS))
        {
            jsonparser.nextToken();
            obj = _parseString(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'String' value but there was more than a single value in the array");
            }
        } else
        {
            String s = jsonparser.getValueAsString();
            if (s != null)
            {
                return s;
            } else
            {
                throw deserializationcontext.mappingException(java/lang/String, jsonparser.getCurrentToken());
            }
        }
        return ((String) (obj));
    }

    public Object deserializeWithType(JsonParser jsonparser, DeserializationContext deserializationcontext, TypeDeserializer typedeserializer)
        throws IOException
    {
        return typedeserializer.deserializeTypedFromAny(jsonparser, deserializationcontext);
    }

    protected JsonDeserializer findConvertingContentDeserializer(DeserializationContext deserializationcontext, BeanProperty beanproperty, JsonDeserializer jsondeserializer)
        throws JsonMappingException
    {
        Object obj = deserializationcontext.getAnnotationIntrospector();
        if (obj != null && beanproperty != null)
        {
            com.fasterxml.jackson.databind.introspect.AnnotatedMember annotatedmember = beanproperty.getMember();
            if (annotatedmember != null)
            {
                obj = ((AnnotationIntrospector) (obj)).findDeserializationContentConverter(annotatedmember);
                if (obj != null)
                {
                    Converter converter = deserializationcontext.converterInstance(beanproperty.getMember(), obj);
                    JavaType javatype = converter.getInputType(deserializationcontext.getTypeFactory());
                    obj = jsondeserializer;
                    if (jsondeserializer == null)
                    {
                        obj = deserializationcontext.findContextualValueDeserializer(javatype, beanproperty);
                    }
                    return new StdDelegatingDeserializer(converter, javatype, ((JsonDeserializer) (obj)));
                }
            }
        }
        return jsondeserializer;
    }

    protected JsonDeserializer findDeserializer(DeserializationContext deserializationcontext, JavaType javatype, BeanProperty beanproperty)
        throws JsonMappingException
    {
        return deserializationcontext.findContextualValueDeserializer(javatype, beanproperty);
    }

    public final Class getValueClass()
    {
        return _valueClass;
    }

    public JavaType getValueType()
    {
        return null;
    }

    protected void handleUnknownProperty(JsonParser jsonparser, DeserializationContext deserializationcontext, Object obj, String s)
        throws IOException
    {
        Object obj1 = obj;
        if (obj == null)
        {
            obj1 = handledType();
        }
        if (deserializationcontext.handleUnknownProperty(jsonparser, this, obj1, s))
        {
            return;
        } else
        {
            deserializationcontext.reportUnknownProperty(obj1, s, this);
            jsonparser.skipChildren();
            return;
        }
    }

    public Class handledType()
    {
        return _valueClass;
    }

    protected boolean isDefaultDeserializer(JsonDeserializer jsondeserializer)
    {
        return ClassUtil.isJacksonStdImpl(jsondeserializer);
    }

    protected boolean isDefaultKeyDeserializer(KeyDeserializer keydeserializer)
    {
        return ClassUtil.isJacksonStdImpl(keydeserializer);
    }

    static 
    {
        F_MASK_INT_COERCIONS = DeserializationFeature.USE_BIG_INTEGER_FOR_INTS.getMask() | DeserializationFeature.USE_LONG_FOR_INTS.getMask();
    }
}