Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/google/gson/internal/bind/ArrayTypeAdapter.java

@@ -0,0 +1,72 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.C$Gson$Types;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+
+/* loaded from: classes3.dex */
+public final class ArrayTypeAdapter<E> extends TypeAdapter<Object> {
+    public static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() { // from class: com.google.gson.internal.bind.ArrayTypeAdapter.1
+        @Override // com.google.gson.TypeAdapterFactory
+        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+            Type type = typeToken.getType();
+            if (!(type instanceof GenericArrayType) && (!(type instanceof Class) || !((Class) type).isArray())) {
+                return null;
+            }
+            Type arrayComponentType = C$Gson$Types.getArrayComponentType(type);
+            return new ArrayTypeAdapter(gson, gson.getAdapter(TypeToken.get(arrayComponentType)), C$Gson$Types.getRawType(arrayComponentType));
+        }
+    };
+    private final Class<E> componentType;
+    private final TypeAdapter<E> componentTypeAdapter;
+
+    public ArrayTypeAdapter(Gson gson, TypeAdapter<E> typeAdapter, Class<E> cls) {
+        this.componentTypeAdapter = new TypeAdapterRuntimeTypeWrapper(gson, typeAdapter, cls);
+        this.componentType = cls;
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    /* renamed from: read */
+    public Object read2(JsonReader jsonReader) throws IOException {
+        if (jsonReader.peek() == JsonToken.NULL) {
+            jsonReader.nextNull();
+            return null;
+        }
+        ArrayList arrayList = new ArrayList();
+        jsonReader.beginArray();
+        while (jsonReader.hasNext()) {
+            arrayList.add(this.componentTypeAdapter.read2(jsonReader));
+        }
+        jsonReader.endArray();
+        int size = arrayList.size();
+        Object newInstance = Array.newInstance((Class<?>) this.componentType, size);
+        for (int i = 0; i < size; i++) {
+            Array.set(newInstance, i, arrayList.get(i));
+        }
+        return newInstance;
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    public void write(JsonWriter jsonWriter, Object obj) throws IOException {
+        if (obj == null) {
+            jsonWriter.nullValue();
+            return;
+        }
+        jsonWriter.beginArray();
+        int length = Array.getLength(obj);
+        for (int i = 0; i < length; i++) {
+            this.componentTypeAdapter.write(jsonWriter, Array.get(obj, i));
+        }
+        jsonWriter.endArray();
+    }
+}

decompiled/sources/com/google/gson/internal/bind/CollectionTypeAdapterFactory.java

@@ -0,0 +1,76 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.C$Gson$Types;
+import com.google.gson.internal.ConstructorConstructor;
+import com.google.gson.internal.ObjectConstructor;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.Iterator;
+
+/* loaded from: classes3.dex */
+public final class CollectionTypeAdapterFactory implements TypeAdapterFactory {
+    private final ConstructorConstructor constructorConstructor;
+
+    public CollectionTypeAdapterFactory(ConstructorConstructor constructorConstructor) {
+        this.constructorConstructor = constructorConstructor;
+    }
+
+    @Override // com.google.gson.TypeAdapterFactory
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+        Type type = typeToken.getType();
+        Class<? super T> rawType = typeToken.getRawType();
+        if (!Collection.class.isAssignableFrom(rawType)) {
+            return null;
+        }
+        Type collectionElementType = C$Gson$Types.getCollectionElementType(type, rawType);
+        return new Adapter(gson, collectionElementType, gson.getAdapter(TypeToken.get(collectionElementType)), this.constructorConstructor.get(typeToken));
+    }
+
+    public static final class Adapter<E> extends TypeAdapter<Collection<E>> {
+        private final ObjectConstructor<? extends Collection<E>> constructor;
+        private final TypeAdapter<E> elementTypeAdapter;
+
+        public Adapter(Gson gson, Type type, TypeAdapter<E> typeAdapter, ObjectConstructor<? extends Collection<E>> objectConstructor) {
+            this.elementTypeAdapter = new TypeAdapterRuntimeTypeWrapper(gson, typeAdapter, type);
+            this.constructor = objectConstructor;
+        }
+
+        @Override // com.google.gson.TypeAdapter
+        /* renamed from: read */
+        public Collection<E> read2(JsonReader jsonReader) throws IOException {
+            if (jsonReader.peek() == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return null;
+            }
+            Collection<E> construct = this.constructor.construct();
+            jsonReader.beginArray();
+            while (jsonReader.hasNext()) {
+                construct.add(this.elementTypeAdapter.read2(jsonReader));
+            }
+            jsonReader.endArray();
+            return construct;
+        }
+
+        @Override // com.google.gson.TypeAdapter
+        public void write(JsonWriter jsonWriter, Collection<E> collection) throws IOException {
+            if (collection == null) {
+                jsonWriter.nullValue();
+                return;
+            }
+            jsonWriter.beginArray();
+            Iterator<E> it = collection.iterator();
+            while (it.hasNext()) {
+                this.elementTypeAdapter.write(jsonWriter, it.next());
+            }
+            jsonWriter.endArray();
+        }
+    }
+}

decompiled/sources/com/google/gson/internal/bind/DateTypeAdapter.java

@@ -0,0 +1,83 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.JavaVersion;
+import com.google.gson.internal.PreJava9DateFormatProvider;
+import com.google.gson.internal.bind.util.ISO8601Utils;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.ParsePosition;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+
+/* loaded from: classes3.dex */
+public final class DateTypeAdapter extends TypeAdapter<Date> {
+    public static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() { // from class: com.google.gson.internal.bind.DateTypeAdapter.1
+        @Override // com.google.gson.TypeAdapterFactory
+        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+            if (typeToken.getRawType() == Date.class) {
+                return new DateTypeAdapter();
+            }
+            return null;
+        }
+    };
+    private final List<DateFormat> dateFormats;
+
+    public DateTypeAdapter() {
+        ArrayList arrayList = new ArrayList();
+        this.dateFormats = arrayList;
+        Locale locale = Locale.US;
+        arrayList.add(DateFormat.getDateTimeInstance(2, 2, locale));
+        if (!Locale.getDefault().equals(locale)) {
+            arrayList.add(DateFormat.getDateTimeInstance(2, 2));
+        }
+        if (JavaVersion.isJava9OrLater()) {
+            arrayList.add(PreJava9DateFormatProvider.getUSDateTimeFormat(2, 2));
+        }
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    /* renamed from: read, reason: avoid collision after fix types in other method */
+    public Date read2(JsonReader jsonReader) throws IOException {
+        if (jsonReader.peek() == JsonToken.NULL) {
+            jsonReader.nextNull();
+            return null;
+        }
+        return deserializeToDate(jsonReader.nextString());
+    }
+
+    private synchronized Date deserializeToDate(String str) {
+        Iterator<DateFormat> it = this.dateFormats.iterator();
+        while (it.hasNext()) {
+            try {
+                return it.next().parse(str);
+            } catch (ParseException unused) {
+            }
+        }
+        try {
+            return ISO8601Utils.parse(str, new ParsePosition(0));
+        } catch (ParseException e) {
+            throw new JsonSyntaxException(str, e);
+        }
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    public synchronized void write(JsonWriter jsonWriter, Date date) throws IOException {
+        if (date == null) {
+            jsonWriter.nullValue();
+        } else {
+            jsonWriter.value(this.dateFormats.get(0).format(date));
+        }
+    }
+}

decompiled/sources/com/google/gson/internal/bind/DefaultDateTypeAdapter.java

@@ -0,0 +1,156 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.C$Gson$Preconditions;
+import com.google.gson.internal.JavaVersion;
+import com.google.gson.internal.PreJava9DateFormatProvider;
+import com.google.gson.internal.bind.util.ISO8601Utils;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.ParsePosition;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+
+/* loaded from: classes3.dex */
+public final class DefaultDateTypeAdapter<T extends Date> extends TypeAdapter<T> {
+    private static final String SIMPLE_NAME = "DefaultDateTypeAdapter";
+    private final List<DateFormat> dateFormats;
+    private final DateType<T> dateType;
+
+    public static abstract class DateType<T extends Date> {
+        public static final DateType<Date> DATE = new DateType<Date>(Date.class) { // from class: com.google.gson.internal.bind.DefaultDateTypeAdapter.DateType.1
+            @Override // com.google.gson.internal.bind.DefaultDateTypeAdapter.DateType
+            public Date deserialize(Date date) {
+                return date;
+            }
+        };
+        private final Class<T> dateClass;
+
+        public abstract T deserialize(Date date);
+
+        public DateType(Class<T> cls) {
+            this.dateClass = cls;
+        }
+
+        private final TypeAdapterFactory createFactory(DefaultDateTypeAdapter<T> defaultDateTypeAdapter) {
+            return TypeAdapters.newFactory(this.dateClass, defaultDateTypeAdapter);
+        }
+
+        public final TypeAdapterFactory createAdapterFactory(String str) {
+            return createFactory(new DefaultDateTypeAdapter<>(this, str));
+        }
+
+        public final TypeAdapterFactory createAdapterFactory(int i) {
+            return createFactory(new DefaultDateTypeAdapter<>(this, i));
+        }
+
+        public final TypeAdapterFactory createAdapterFactory(int i, int i2) {
+            return createFactory(new DefaultDateTypeAdapter<>(this, i, i2));
+        }
+
+        public final TypeAdapterFactory createDefaultsAdapterFactory() {
+            int i = 2;
+            return createFactory(new DefaultDateTypeAdapter<>(this, i, i));
+        }
+    }
+
+    private DefaultDateTypeAdapter(DateType<T> dateType, String str) {
+        ArrayList arrayList = new ArrayList();
+        this.dateFormats = arrayList;
+        this.dateType = (DateType) C$Gson$Preconditions.checkNotNull(dateType);
+        Locale locale = Locale.US;
+        arrayList.add(new SimpleDateFormat(str, locale));
+        if (Locale.getDefault().equals(locale)) {
+            return;
+        }
+        arrayList.add(new SimpleDateFormat(str));
+    }
+
+    private DefaultDateTypeAdapter(DateType<T> dateType, int i) {
+        ArrayList arrayList = new ArrayList();
+        this.dateFormats = arrayList;
+        this.dateType = (DateType) C$Gson$Preconditions.checkNotNull(dateType);
+        Locale locale = Locale.US;
+        arrayList.add(DateFormat.getDateInstance(i, locale));
+        if (!Locale.getDefault().equals(locale)) {
+            arrayList.add(DateFormat.getDateInstance(i));
+        }
+        if (JavaVersion.isJava9OrLater()) {
+            arrayList.add(PreJava9DateFormatProvider.getUSDateFormat(i));
+        }
+    }
+
+    private DefaultDateTypeAdapter(DateType<T> dateType, int i, int i2) {
+        ArrayList arrayList = new ArrayList();
+        this.dateFormats = arrayList;
+        this.dateType = (DateType) C$Gson$Preconditions.checkNotNull(dateType);
+        Locale locale = Locale.US;
+        arrayList.add(DateFormat.getDateTimeInstance(i, i2, locale));
+        if (!Locale.getDefault().equals(locale)) {
+            arrayList.add(DateFormat.getDateTimeInstance(i, i2));
+        }
+        if (JavaVersion.isJava9OrLater()) {
+            arrayList.add(PreJava9DateFormatProvider.getUSDateTimeFormat(i, i2));
+        }
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    public void write(JsonWriter jsonWriter, Date date) throws IOException {
+        if (date == null) {
+            jsonWriter.nullValue();
+            return;
+        }
+        synchronized (this.dateFormats) {
+            jsonWriter.value(this.dateFormats.get(0).format(date));
+        }
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    /* renamed from: read */
+    public T read2(JsonReader jsonReader) throws IOException {
+        if (jsonReader.peek() == JsonToken.NULL) {
+            jsonReader.nextNull();
+            return null;
+        }
+        return this.dateType.deserialize(deserializeToDate(jsonReader.nextString()));
+    }
+
+    private Date deserializeToDate(String str) {
+        synchronized (this.dateFormats) {
+            try {
+                Iterator<DateFormat> it = this.dateFormats.iterator();
+                while (it.hasNext()) {
+                    try {
+                        return it.next().parse(str);
+                    } catch (ParseException unused) {
+                    }
+                }
+                try {
+                    return ISO8601Utils.parse(str, new ParsePosition(0));
+                } catch (ParseException e) {
+                    throw new JsonSyntaxException(str, e);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public String toString() {
+        DateFormat dateFormat = this.dateFormats.get(0);
+        if (dateFormat instanceof SimpleDateFormat) {
+            return "DefaultDateTypeAdapter(" + ((SimpleDateFormat) dateFormat).toPattern() + ')';
+        }
+        return "DefaultDateTypeAdapter(" + dateFormat.getClass().getSimpleName() + ')';
+    }
+}

decompiled/sources/com/google/gson/internal/bind/JsonAdapterAnnotationTypeAdapterFactory.java

@@ -0,0 +1,46 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonSerializer;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.annotations.JsonAdapter;
+import com.google.gson.internal.ConstructorConstructor;
+import com.google.gson.reflect.TypeToken;
+
+/* loaded from: classes3.dex */
+public final class JsonAdapterAnnotationTypeAdapterFactory implements TypeAdapterFactory {
+    private final ConstructorConstructor constructorConstructor;
+
+    public JsonAdapterAnnotationTypeAdapterFactory(ConstructorConstructor constructorConstructor) {
+        this.constructorConstructor = constructorConstructor;
+    }
+
+    @Override // com.google.gson.TypeAdapterFactory
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+        JsonAdapter jsonAdapter = (JsonAdapter) typeToken.getRawType().getAnnotation(JsonAdapter.class);
+        if (jsonAdapter == null) {
+            return null;
+        }
+        return (TypeAdapter<T>) getTypeAdapter(this.constructorConstructor, gson, typeToken, jsonAdapter);
+    }
+
+    public TypeAdapter<?> getTypeAdapter(ConstructorConstructor constructorConstructor, Gson gson, TypeToken<?> typeToken, JsonAdapter jsonAdapter) {
+        TypeAdapter<?> treeTypeAdapter;
+        Object construct = constructorConstructor.get(TypeToken.get((Class) jsonAdapter.value())).construct();
+        if (construct instanceof TypeAdapter) {
+            treeTypeAdapter = (TypeAdapter) construct;
+        } else if (construct instanceof TypeAdapterFactory) {
+            treeTypeAdapter = ((TypeAdapterFactory) construct).create(gson, typeToken);
+        } else {
+            boolean z = construct instanceof JsonSerializer;
+            if (z || (construct instanceof JsonDeserializer)) {
+                treeTypeAdapter = new TreeTypeAdapter<>(z ? (JsonSerializer) construct : null, construct instanceof JsonDeserializer ? (JsonDeserializer) construct : null, gson, typeToken, null);
+            } else {
+                throw new IllegalArgumentException("Invalid attempt to bind an instance of " + construct.getClass().getName() + " as a @JsonAdapter for " + typeToken.toString() + ". @JsonAdapter value must be a TypeAdapter, TypeAdapterFactory, JsonSerializer or JsonDeserializer.");
+            }
+        }
+        return (treeTypeAdapter == null || !jsonAdapter.nullSafe()) ? treeTypeAdapter : treeTypeAdapter.nullSafe();
+    }
+}

decompiled/sources/com/google/gson/internal/bind/JsonTreeReader.java

@@ -0,0 +1,361 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class JsonTreeReader extends JsonReader {
+    private int[] pathIndices;
+    private String[] pathNames;
+    private Object[] stack;
+    private int stackSize;
+    private static final Reader UNREADABLE_READER = new Reader() { // from class: com.google.gson.internal.bind.JsonTreeReader.1
+        @Override // java.io.Reader
+        public int read(char[] cArr, int i, int i2) throws IOException {
+            throw new AssertionError();
+        }
+
+        @Override // java.io.Reader, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            throw new AssertionError();
+        }
+    };
+    private static final Object SENTINEL_CLOSED = new Object();
+
+    @Override // com.google.gson.stream.JsonReader, java.io.Closeable, java.lang.AutoCloseable
+    public void close() throws IOException {
+        this.stack = new Object[]{SENTINEL_CLOSED};
+        this.stackSize = 1;
+    }
+
+    public JsonTreeReader(JsonElement jsonElement) {
+        super(UNREADABLE_READER);
+        this.stack = new Object[32];
+        this.stackSize = 0;
+        this.pathNames = new String[32];
+        this.pathIndices = new int[32];
+        push(jsonElement);
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public void beginArray() throws IOException {
+        expect(JsonToken.BEGIN_ARRAY);
+        push(((JsonArray) peekStack()).iterator());
+        this.pathIndices[this.stackSize - 1] = 0;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public void endArray() throws IOException {
+        expect(JsonToken.END_ARRAY);
+        popStack();
+        popStack();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public void beginObject() throws IOException {
+        expect(JsonToken.BEGIN_OBJECT);
+        push(((JsonObject) peekStack()).entrySet().iterator());
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public void endObject() throws IOException {
+        expect(JsonToken.END_OBJECT);
+        popStack();
+        popStack();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public boolean hasNext() throws IOException {
+        JsonToken peek = peek();
+        return (peek == JsonToken.END_OBJECT || peek == JsonToken.END_ARRAY) ? false : true;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public JsonToken peek() throws IOException {
+        if (this.stackSize == 0) {
+            return JsonToken.END_DOCUMENT;
+        }
+        Object peekStack = peekStack();
+        if (peekStack instanceof Iterator) {
+            boolean z = this.stack[this.stackSize - 2] instanceof JsonObject;
+            Iterator it = (Iterator) peekStack;
+            if (!it.hasNext()) {
+                return z ? JsonToken.END_OBJECT : JsonToken.END_ARRAY;
+            }
+            if (z) {
+                return JsonToken.NAME;
+            }
+            push(it.next());
+            return peek();
+        }
+        if (peekStack instanceof JsonObject) {
+            return JsonToken.BEGIN_OBJECT;
+        }
+        if (peekStack instanceof JsonArray) {
+            return JsonToken.BEGIN_ARRAY;
+        }
+        if (peekStack instanceof JsonPrimitive) {
+            JsonPrimitive jsonPrimitive = (JsonPrimitive) peekStack;
+            if (jsonPrimitive.isString()) {
+                return JsonToken.STRING;
+            }
+            if (jsonPrimitive.isBoolean()) {
+                return JsonToken.BOOLEAN;
+            }
+            if (jsonPrimitive.isNumber()) {
+                return JsonToken.NUMBER;
+            }
+            throw new AssertionError();
+        }
+        if (peekStack instanceof JsonNull) {
+            return JsonToken.NULL;
+        }
+        if (peekStack == SENTINEL_CLOSED) {
+            throw new IllegalStateException("JsonReader is closed");
+        }
+        throw new AssertionError();
+    }
+
+    private Object peekStack() {
+        return this.stack[this.stackSize - 1];
+    }
+
+    private Object popStack() {
+        Object[] objArr = this.stack;
+        int i = this.stackSize - 1;
+        this.stackSize = i;
+        Object obj = objArr[i];
+        objArr[i] = null;
+        return obj;
+    }
+
+    private void expect(JsonToken jsonToken) throws IOException {
+        if (peek() == jsonToken) {
+            return;
+        }
+        throw new IllegalStateException("Expected " + jsonToken + " but was " + peek() + locationString());
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public String nextName() throws IOException {
+        expect(JsonToken.NAME);
+        Map.Entry entry = (Map.Entry) ((Iterator) peekStack()).next();
+        String str = (String) entry.getKey();
+        this.pathNames[this.stackSize - 1] = str;
+        push(entry.getValue());
+        return str;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public String nextString() throws IOException {
+        JsonToken peek = peek();
+        JsonToken jsonToken = JsonToken.STRING;
+        if (peek != jsonToken && peek != JsonToken.NUMBER) {
+            throw new IllegalStateException("Expected " + jsonToken + " but was " + peek + locationString());
+        }
+        String asString = ((JsonPrimitive) popStack()).getAsString();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+        return asString;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public boolean nextBoolean() throws IOException {
+        expect(JsonToken.BOOLEAN);
+        boolean asBoolean = ((JsonPrimitive) popStack()).getAsBoolean();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+        return asBoolean;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public void nextNull() throws IOException {
+        expect(JsonToken.NULL);
+        popStack();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public double nextDouble() throws IOException {
+        JsonToken peek = peek();
+        JsonToken jsonToken = JsonToken.NUMBER;
+        if (peek != jsonToken && peek != JsonToken.STRING) {
+            throw new IllegalStateException("Expected " + jsonToken + " but was " + peek + locationString());
+        }
+        double asDouble = ((JsonPrimitive) peekStack()).getAsDouble();
+        if (!isLenient() && (Double.isNaN(asDouble) || Double.isInfinite(asDouble))) {
+            throw new NumberFormatException("JSON forbids NaN and infinities: " + asDouble);
+        }
+        popStack();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+        return asDouble;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public long nextLong() throws IOException {
+        JsonToken peek = peek();
+        JsonToken jsonToken = JsonToken.NUMBER;
+        if (peek != jsonToken && peek != JsonToken.STRING) {
+            throw new IllegalStateException("Expected " + jsonToken + " but was " + peek + locationString());
+        }
+        long asLong = ((JsonPrimitive) peekStack()).getAsLong();
+        popStack();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+        return asLong;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public int nextInt() throws IOException {
+        JsonToken peek = peek();
+        JsonToken jsonToken = JsonToken.NUMBER;
+        if (peek != jsonToken && peek != JsonToken.STRING) {
+            throw new IllegalStateException("Expected " + jsonToken + " but was " + peek + locationString());
+        }
+        int asInt = ((JsonPrimitive) peekStack()).getAsInt();
+        popStack();
+        int i = this.stackSize;
+        if (i > 0) {
+            int[] iArr = this.pathIndices;
+            int i2 = i - 1;
+            iArr[i2] = iArr[i2] + 1;
+        }
+        return asInt;
+    }
+
+    public JsonElement nextJsonElement() throws IOException {
+        JsonToken peek = peek();
+        if (peek == JsonToken.NAME || peek == JsonToken.END_ARRAY || peek == JsonToken.END_OBJECT || peek == JsonToken.END_DOCUMENT) {
+            throw new IllegalStateException("Unexpected " + peek + " when reading a JsonElement.");
+        }
+        JsonElement jsonElement = (JsonElement) peekStack();
+        skipValue();
+        return jsonElement;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public void skipValue() throws IOException {
+        if (peek() == JsonToken.NAME) {
+            nextName();
+            this.pathNames[this.stackSize - 2] = "null";
+        } else {
+            popStack();
+            int i = this.stackSize;
+            if (i > 0) {
+                this.pathNames[i - 1] = "null";
+            }
+        }
+        int i2 = this.stackSize;
+        if (i2 > 0) {
+            int[] iArr = this.pathIndices;
+            int i3 = i2 - 1;
+            iArr[i3] = iArr[i3] + 1;
+        }
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public String toString() {
+        return JsonTreeReader.class.getSimpleName() + locationString();
+    }
+
+    public void promoteNameToValue() throws IOException {
+        expect(JsonToken.NAME);
+        Map.Entry entry = (Map.Entry) ((Iterator) peekStack()).next();
+        push(entry.getValue());
+        push(new JsonPrimitive((String) entry.getKey()));
+    }
+
+    private void push(Object obj) {
+        int i = this.stackSize;
+        Object[] objArr = this.stack;
+        if (i == objArr.length) {
+            int i2 = i * 2;
+            this.stack = Arrays.copyOf(objArr, i2);
+            this.pathIndices = Arrays.copyOf(this.pathIndices, i2);
+            this.pathNames = (String[]) Arrays.copyOf(this.pathNames, i2);
+        }
+        Object[] objArr2 = this.stack;
+        int i3 = this.stackSize;
+        this.stackSize = i3 + 1;
+        objArr2[i3] = obj;
+    }
+
+    @Override // com.google.gson.stream.JsonReader
+    public String getPath() {
+        StringBuilder sb = new StringBuilder();
+        sb.append('$');
+        int i = 0;
+        while (true) {
+            int i2 = this.stackSize;
+            if (i < i2) {
+                Object[] objArr = this.stack;
+                Object obj = objArr[i];
+                if (obj instanceof JsonArray) {
+                    i++;
+                    if (i < i2 && (objArr[i] instanceof Iterator)) {
+                        sb.append('[');
+                        sb.append(this.pathIndices[i]);
+                        sb.append(']');
+                    }
+                } else if ((obj instanceof JsonObject) && (i = i + 1) < i2 && (objArr[i] instanceof Iterator)) {
+                    sb.append('.');
+                    String str = this.pathNames[i];
+                    if (str != null) {
+                        sb.append(str);
+                    }
+                }
+                i++;
+            } else {
+                return sb.toString();
+            }
+        }
+    }
+
+    private String locationString() {
+        return " at path " + getPath();
+    }
+}

decompiled/sources/com/google/gson/internal/bind/JsonTreeWriter.java

@@ -0,0 +1,201 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.stream.JsonWriter;
+import csdk.gluads.Consts;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class JsonTreeWriter extends JsonWriter {
+    private String pendingName;
+    private JsonElement product;
+    private final List<JsonElement> stack;
+    private static final Writer UNWRITABLE_WRITER = new Writer() { // from class: com.google.gson.internal.bind.JsonTreeWriter.1
+        @Override // java.io.Writer
+        public void write(char[] cArr, int i, int i2) {
+            throw new AssertionError();
+        }
+
+        @Override // java.io.Writer, java.io.Flushable
+        public void flush() throws IOException {
+            throw new AssertionError();
+        }
+
+        @Override // java.io.Writer, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            throw new AssertionError();
+        }
+    };
+    private static final JsonPrimitive SENTINEL_CLOSED = new JsonPrimitive(Consts.PLACEMENT_STATUS_CLOSED);
+
+    @Override // com.google.gson.stream.JsonWriter, java.io.Flushable
+    public void flush() throws IOException {
+    }
+
+    public JsonTreeWriter() {
+        super(UNWRITABLE_WRITER);
+        this.stack = new ArrayList();
+        this.product = JsonNull.INSTANCE;
+    }
+
+    public JsonElement get() {
+        if (this.stack.isEmpty()) {
+            return this.product;
+        }
+        throw new IllegalStateException("Expected one JSON element but was " + this.stack);
+    }
+
+    private JsonElement peek() {
+        return this.stack.get(r0.size() - 1);
+    }
+
+    private void put(JsonElement jsonElement) {
+        if (this.pendingName != null) {
+            if (!jsonElement.isJsonNull() || getSerializeNulls()) {
+                ((JsonObject) peek()).add(this.pendingName, jsonElement);
+            }
+            this.pendingName = null;
+            return;
+        }
+        if (this.stack.isEmpty()) {
+            this.product = jsonElement;
+            return;
+        }
+        JsonElement peek = peek();
+        if (peek instanceof JsonArray) {
+            ((JsonArray) peek).add(jsonElement);
+            return;
+        }
+        throw new IllegalStateException();
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter beginArray() throws IOException {
+        JsonArray jsonArray = new JsonArray();
+        put(jsonArray);
+        this.stack.add(jsonArray);
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter endArray() throws IOException {
+        if (this.stack.isEmpty() || this.pendingName != null) {
+            throw new IllegalStateException();
+        }
+        if (peek() instanceof JsonArray) {
+            this.stack.remove(r0.size() - 1);
+            return this;
+        }
+        throw new IllegalStateException();
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter beginObject() throws IOException {
+        JsonObject jsonObject = new JsonObject();
+        put(jsonObject);
+        this.stack.add(jsonObject);
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter endObject() throws IOException {
+        if (this.stack.isEmpty() || this.pendingName != null) {
+            throw new IllegalStateException();
+        }
+        if (peek() instanceof JsonObject) {
+            this.stack.remove(r0.size() - 1);
+            return this;
+        }
+        throw new IllegalStateException();
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter name(String str) throws IOException {
+        if (str == null) {
+            throw new NullPointerException("name == null");
+        }
+        if (this.stack.isEmpty() || this.pendingName != null) {
+            throw new IllegalStateException();
+        }
+        if (!(peek() instanceof JsonObject)) {
+            throw new IllegalStateException();
+        }
+        this.pendingName = str;
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter value(String str) throws IOException {
+        if (str == null) {
+            return nullValue();
+        }
+        put(new JsonPrimitive(str));
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter nullValue() throws IOException {
+        put(JsonNull.INSTANCE);
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter value(boolean z) throws IOException {
+        put(new JsonPrimitive(Boolean.valueOf(z)));
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter value(Boolean bool) throws IOException {
+        if (bool == null) {
+            return nullValue();
+        }
+        put(new JsonPrimitive(bool));
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter value(double d) throws IOException {
+        if (!isLenient() && (Double.isNaN(d) || Double.isInfinite(d))) {
+            throw new IllegalArgumentException("JSON forbids NaN and infinities: " + d);
+        }
+        put(new JsonPrimitive(Double.valueOf(d)));
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter value(long j) throws IOException {
+        put(new JsonPrimitive(Long.valueOf(j)));
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter
+    public JsonWriter value(Number number) throws IOException {
+        if (number == null) {
+            return nullValue();
+        }
+        if (!isLenient()) {
+            double doubleValue = number.doubleValue();
+            if (Double.isNaN(doubleValue) || Double.isInfinite(doubleValue)) {
+                throw new IllegalArgumentException("JSON forbids NaN and infinities: " + number);
+            }
+        }
+        put(new JsonPrimitive(number));
+        return this;
+    }
+
+    @Override // com.google.gson.stream.JsonWriter, java.io.Closeable, java.lang.AutoCloseable
+    public void close() throws IOException {
+        if (!this.stack.isEmpty()) {
+            throw new IOException("Incomplete document");
+        }
+        this.stack.add(SENTINEL_CLOSED);
+    }
+}

decompiled/sources/com/google/gson/internal/bind/MapTypeAdapterFactory.java

@@ -0,0 +1,163 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.C$Gson$Types;
+import com.google.gson.internal.ConstructorConstructor;
+import com.google.gson.internal.JsonReaderInternalAccess;
+import com.google.gson.internal.ObjectConstructor;
+import com.google.gson.internal.Streams;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class MapTypeAdapterFactory implements TypeAdapterFactory {
+    final boolean complexMapKeySerialization;
+    private final ConstructorConstructor constructorConstructor;
+
+    public MapTypeAdapterFactory(ConstructorConstructor constructorConstructor, boolean z) {
+        this.constructorConstructor = constructorConstructor;
+        this.complexMapKeySerialization = z;
+    }
+
+    @Override // com.google.gson.TypeAdapterFactory
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+        Type type = typeToken.getType();
+        if (!Map.class.isAssignableFrom(typeToken.getRawType())) {
+            return null;
+        }
+        Type[] mapKeyAndValueTypes = C$Gson$Types.getMapKeyAndValueTypes(type, C$Gson$Types.getRawType(type));
+        return new Adapter(gson, mapKeyAndValueTypes[0], getKeyAdapter(gson, mapKeyAndValueTypes[0]), mapKeyAndValueTypes[1], gson.getAdapter(TypeToken.get(mapKeyAndValueTypes[1])), this.constructorConstructor.get(typeToken));
+    }
+
+    private TypeAdapter<?> getKeyAdapter(Gson gson, Type type) {
+        if (type == Boolean.TYPE || type == Boolean.class) {
+            return TypeAdapters.BOOLEAN_AS_STRING;
+        }
+        return gson.getAdapter(TypeToken.get(type));
+    }
+
+    public final class Adapter<K, V> extends TypeAdapter<Map<K, V>> {
+        private final ObjectConstructor<? extends Map<K, V>> constructor;
+        private final TypeAdapter<K> keyTypeAdapter;
+        private final TypeAdapter<V> valueTypeAdapter;
+
+        public Adapter(Gson gson, Type type, TypeAdapter<K> typeAdapter, Type type2, TypeAdapter<V> typeAdapter2, ObjectConstructor<? extends Map<K, V>> objectConstructor) {
+            this.keyTypeAdapter = new TypeAdapterRuntimeTypeWrapper(gson, typeAdapter, type);
+            this.valueTypeAdapter = new TypeAdapterRuntimeTypeWrapper(gson, typeAdapter2, type2);
+            this.constructor = objectConstructor;
+        }
+
+        @Override // com.google.gson.TypeAdapter
+        /* renamed from: read */
+        public Map<K, V> read2(JsonReader jsonReader) throws IOException {
+            JsonToken peek = jsonReader.peek();
+            if (peek == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return null;
+            }
+            Map<K, V> construct = this.constructor.construct();
+            if (peek == JsonToken.BEGIN_ARRAY) {
+                jsonReader.beginArray();
+                while (jsonReader.hasNext()) {
+                    jsonReader.beginArray();
+                    K read2 = this.keyTypeAdapter.read2(jsonReader);
+                    if (construct.put(read2, this.valueTypeAdapter.read2(jsonReader)) != null) {
+                        throw new JsonSyntaxException("duplicate key: " + read2);
+                    }
+                    jsonReader.endArray();
+                }
+                jsonReader.endArray();
+            } else {
+                jsonReader.beginObject();
+                while (jsonReader.hasNext()) {
+                    JsonReaderInternalAccess.INSTANCE.promoteNameToValue(jsonReader);
+                    K read22 = this.keyTypeAdapter.read2(jsonReader);
+                    if (construct.put(read22, this.valueTypeAdapter.read2(jsonReader)) != null) {
+                        throw new JsonSyntaxException("duplicate key: " + read22);
+                    }
+                }
+                jsonReader.endObject();
+            }
+            return construct;
+        }
+
+        @Override // com.google.gson.TypeAdapter
+        public void write(JsonWriter jsonWriter, Map<K, V> map) throws IOException {
+            if (map == null) {
+                jsonWriter.nullValue();
+                return;
+            }
+            if (!MapTypeAdapterFactory.this.complexMapKeySerialization) {
+                jsonWriter.beginObject();
+                for (Map.Entry<K, V> entry : map.entrySet()) {
+                    jsonWriter.name(String.valueOf(entry.getKey()));
+                    this.valueTypeAdapter.write(jsonWriter, entry.getValue());
+                }
+                jsonWriter.endObject();
+                return;
+            }
+            ArrayList arrayList = new ArrayList(map.size());
+            ArrayList arrayList2 = new ArrayList(map.size());
+            int i = 0;
+            boolean z = false;
+            for (Map.Entry<K, V> entry2 : map.entrySet()) {
+                JsonElement jsonTree = this.keyTypeAdapter.toJsonTree(entry2.getKey());
+                arrayList.add(jsonTree);
+                arrayList2.add(entry2.getValue());
+                z |= jsonTree.isJsonArray() || jsonTree.isJsonObject();
+            }
+            if (z) {
+                jsonWriter.beginArray();
+                int size = arrayList.size();
+                while (i < size) {
+                    jsonWriter.beginArray();
+                    Streams.write((JsonElement) arrayList.get(i), jsonWriter);
+                    this.valueTypeAdapter.write(jsonWriter, arrayList2.get(i));
+                    jsonWriter.endArray();
+                    i++;
+                }
+                jsonWriter.endArray();
+                return;
+            }
+            jsonWriter.beginObject();
+            int size2 = arrayList.size();
+            while (i < size2) {
+                jsonWriter.name(keyToString((JsonElement) arrayList.get(i)));
+                this.valueTypeAdapter.write(jsonWriter, arrayList2.get(i));
+                i++;
+            }
+            jsonWriter.endObject();
+        }
+
+        private String keyToString(JsonElement jsonElement) {
+            if (jsonElement.isJsonPrimitive()) {
+                JsonPrimitive asJsonPrimitive = jsonElement.getAsJsonPrimitive();
+                if (asJsonPrimitive.isNumber()) {
+                    return String.valueOf(asJsonPrimitive.getAsNumber());
+                }
+                if (asJsonPrimitive.isBoolean()) {
+                    return Boolean.toString(asJsonPrimitive.getAsBoolean());
+                }
+                if (asJsonPrimitive.isString()) {
+                    return asJsonPrimitive.getAsString();
+                }
+                throw new AssertionError();
+            }
+            if (jsonElement.isJsonNull()) {
+                return "null";
+            }
+            throw new AssertionError();
+        }
+    }
+}

decompiled/sources/com/google/gson/internal/bind/NumberTypeAdapter.java

@@ -0,0 +1,82 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.ToNumberPolicy;
+import com.google.gson.ToNumberStrategy;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+
+/* loaded from: classes3.dex */
+public final class NumberTypeAdapter extends TypeAdapter<Number> {
+    private static final TypeAdapterFactory LAZILY_PARSED_NUMBER_FACTORY = newFactory(ToNumberPolicy.LAZILY_PARSED_NUMBER);
+    private final ToNumberStrategy toNumberStrategy;
+
+    private NumberTypeAdapter(ToNumberStrategy toNumberStrategy) {
+        this.toNumberStrategy = toNumberStrategy;
+    }
+
+    private static TypeAdapterFactory newFactory(ToNumberStrategy toNumberStrategy) {
+        return new TypeAdapterFactory() { // from class: com.google.gson.internal.bind.NumberTypeAdapter.1
+            @Override // com.google.gson.TypeAdapterFactory
+            public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+                if (typeToken.getRawType() == Number.class) {
+                    return NumberTypeAdapter.this;
+                }
+                return null;
+            }
+        };
+    }
+
+    public static TypeAdapterFactory getFactory(ToNumberStrategy toNumberStrategy) {
+        return toNumberStrategy == ToNumberPolicy.LAZILY_PARSED_NUMBER ? LAZILY_PARSED_NUMBER_FACTORY : newFactory(toNumberStrategy);
+    }
+
+    /* renamed from: com.google.gson.internal.bind.NumberTypeAdapter$2, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass2 {
+        static final /* synthetic */ int[] $SwitchMap$com$google$gson$stream$JsonToken;
+
+        static {
+            int[] iArr = new int[JsonToken.values().length];
+            $SwitchMap$com$google$gson$stream$JsonToken = iArr;
+            try {
+                iArr[JsonToken.NULL.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$google$gson$stream$JsonToken[JsonToken.NUMBER.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$com$google$gson$stream$JsonToken[JsonToken.STRING.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+        }
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.google.gson.TypeAdapter
+    /* renamed from: read */
+    public Number read2(JsonReader jsonReader) throws IOException {
+        JsonToken peek = jsonReader.peek();
+        int i = AnonymousClass2.$SwitchMap$com$google$gson$stream$JsonToken[peek.ordinal()];
+        if (i == 1) {
+            jsonReader.nextNull();
+            return null;
+        }
+        if (i == 2 || i == 3) {
+            return this.toNumberStrategy.readNumber(jsonReader);
+        }
+        throw new JsonSyntaxException("Expecting number, got: " + peek);
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    public void write(JsonWriter jsonWriter, Number number) throws IOException {
+        jsonWriter.value(number);
+    }
+}

decompiled/sources/com/google/gson/internal/bind/ObjectTypeAdapter.java

@@ -0,0 +1,125 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.ToNumberPolicy;
+import com.google.gson.ToNumberStrategy;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.LinkedTreeMap;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+
+/* loaded from: classes3.dex */
+public final class ObjectTypeAdapter extends TypeAdapter<Object> {
+    private static final TypeAdapterFactory DOUBLE_FACTORY = newFactory(ToNumberPolicy.DOUBLE);
+    private final Gson gson;
+    private final ToNumberStrategy toNumberStrategy;
+
+    private ObjectTypeAdapter(Gson gson, ToNumberStrategy toNumberStrategy) {
+        this.gson = gson;
+        this.toNumberStrategy = toNumberStrategy;
+    }
+
+    private static TypeAdapterFactory newFactory(final ToNumberStrategy toNumberStrategy) {
+        return new TypeAdapterFactory() { // from class: com.google.gson.internal.bind.ObjectTypeAdapter.1
+            @Override // com.google.gson.TypeAdapterFactory
+            public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+                if (typeToken.getRawType() == Object.class) {
+                    return new ObjectTypeAdapter(gson, ToNumberStrategy.this);
+                }
+                return null;
+            }
+        };
+    }
+
+    public static TypeAdapterFactory getFactory(ToNumberStrategy toNumberStrategy) {
+        return toNumberStrategy == ToNumberPolicy.DOUBLE ? DOUBLE_FACTORY : newFactory(toNumberStrategy);
+    }
+
+    /* renamed from: com.google.gson.internal.bind.ObjectTypeAdapter$2, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass2 {
+        static final /* synthetic */ int[] $SwitchMap$com$google$gson$stream$JsonToken;
+
+        static {
+            int[] iArr = new int[JsonToken.values().length];
+            $SwitchMap$com$google$gson$stream$JsonToken = iArr;
+            try {
+                iArr[JsonToken.BEGIN_ARRAY.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$google$gson$stream$JsonToken[JsonToken.BEGIN_OBJECT.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$com$google$gson$stream$JsonToken[JsonToken.STRING.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                $SwitchMap$com$google$gson$stream$JsonToken[JsonToken.NUMBER.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                $SwitchMap$com$google$gson$stream$JsonToken[JsonToken.BOOLEAN.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                $SwitchMap$com$google$gson$stream$JsonToken[JsonToken.NULL.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+        }
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    /* renamed from: read */
+    public Object read2(JsonReader jsonReader) throws IOException {
+        switch (AnonymousClass2.$SwitchMap$com$google$gson$stream$JsonToken[jsonReader.peek().ordinal()]) {
+            case 1:
+                ArrayList arrayList = new ArrayList();
+                jsonReader.beginArray();
+                while (jsonReader.hasNext()) {
+                    arrayList.add(read2(jsonReader));
+                }
+                jsonReader.endArray();
+                return arrayList;
+            case 2:
+                LinkedTreeMap linkedTreeMap = new LinkedTreeMap();
+                jsonReader.beginObject();
+                while (jsonReader.hasNext()) {
+                    linkedTreeMap.put(jsonReader.nextName(), read2(jsonReader));
+                }
+                jsonReader.endObject();
+                return linkedTreeMap;
+            case 3:
+                return jsonReader.nextString();
+            case 4:
+                return this.toNumberStrategy.readNumber(jsonReader);
+            case 5:
+                return Boolean.valueOf(jsonReader.nextBoolean());
+            case 6:
+                jsonReader.nextNull();
+                return null;
+            default:
+                throw new IllegalStateException();
+        }
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    public void write(JsonWriter jsonWriter, Object obj) throws IOException {
+        if (obj == null) {
+            jsonWriter.nullValue();
+            return;
+        }
+        TypeAdapter adapter = this.gson.getAdapter(obj.getClass());
+        if (adapter instanceof ObjectTypeAdapter) {
+            jsonWriter.beginObject();
+            jsonWriter.endObject();
+        } else {
+            adapter.write(jsonWriter, obj);
+        }
+    }
+}

decompiled/sources/com/google/gson/internal/bind/ReflectiveTypeAdapterFactory.java

@@ -0,0 +1,241 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.FieldNamingStrategy;
+import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.annotations.JsonAdapter;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.internal.C$Gson$Types;
+import com.google.gson.internal.ConstructorConstructor;
+import com.google.gson.internal.Excluder;
+import com.google.gson.internal.ObjectConstructor;
+import com.google.gson.internal.Primitives;
+import com.google.gson.internal.reflect.ReflectionAccessor;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
+    private final ReflectionAccessor accessor = ReflectionAccessor.getInstance();
+    private final ConstructorConstructor constructorConstructor;
+    private final Excluder excluder;
+    private final FieldNamingStrategy fieldNamingPolicy;
+    private final JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory;
+
+    public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor, FieldNamingStrategy fieldNamingStrategy, Excluder excluder, JsonAdapterAnnotationTypeAdapterFactory jsonAdapterAnnotationTypeAdapterFactory) {
+        this.constructorConstructor = constructorConstructor;
+        this.fieldNamingPolicy = fieldNamingStrategy;
+        this.excluder = excluder;
+        this.jsonAdapterFactory = jsonAdapterAnnotationTypeAdapterFactory;
+    }
+
+    public boolean excludeField(Field field, boolean z) {
+        return excludeField(field, z, this.excluder);
+    }
+
+    public static boolean excludeField(Field field, boolean z, Excluder excluder) {
+        return (excluder.excludeClass(field.getType(), z) || excluder.excludeField(field, z)) ? false : true;
+    }
+
+    private List<String> getFieldNames(Field field) {
+        SerializedName serializedName = (SerializedName) field.getAnnotation(SerializedName.class);
+        if (serializedName == null) {
+            return Collections.singletonList(this.fieldNamingPolicy.translateName(field));
+        }
+        String value = serializedName.value();
+        String[] alternate = serializedName.alternate();
+        if (alternate.length == 0) {
+            return Collections.singletonList(value);
+        }
+        ArrayList arrayList = new ArrayList(alternate.length + 1);
+        arrayList.add(value);
+        for (String str : alternate) {
+            arrayList.add(str);
+        }
+        return arrayList;
+    }
+
+    @Override // com.google.gson.TypeAdapterFactory
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+        Class<? super T> rawType = typeToken.getRawType();
+        if (Object.class.isAssignableFrom(rawType)) {
+            return new Adapter(this.constructorConstructor.get(typeToken), getBoundFields(gson, typeToken, rawType));
+        }
+        return null;
+    }
+
+    private BoundField createBoundField(final Gson gson, final Field field, String str, final TypeToken<?> typeToken, boolean z, boolean z2) {
+        final boolean isPrimitive = Primitives.isPrimitive(typeToken.getRawType());
+        JsonAdapter jsonAdapter = (JsonAdapter) field.getAnnotation(JsonAdapter.class);
+        TypeAdapter<?> typeAdapter = jsonAdapter != null ? this.jsonAdapterFactory.getTypeAdapter(this.constructorConstructor, gson, typeToken, jsonAdapter) : null;
+        final boolean z3 = typeAdapter != null;
+        if (typeAdapter == null) {
+            typeAdapter = gson.getAdapter(typeToken);
+        }
+        final TypeAdapter<?> typeAdapter2 = typeAdapter;
+        return new BoundField(str, z, z2) { // from class: com.google.gson.internal.bind.ReflectiveTypeAdapterFactory.1
+            @Override // com.google.gson.internal.bind.ReflectiveTypeAdapterFactory.BoundField
+            public void write(JsonWriter jsonWriter, Object obj) throws IOException, IllegalAccessException {
+                (z3 ? typeAdapter2 : new TypeAdapterRuntimeTypeWrapper(gson, typeAdapter2, typeToken.getType())).write(jsonWriter, field.get(obj));
+            }
+
+            @Override // com.google.gson.internal.bind.ReflectiveTypeAdapterFactory.BoundField
+            public void read(JsonReader jsonReader, Object obj) throws IOException, IllegalAccessException {
+                Object read2 = typeAdapter2.read2(jsonReader);
+                if (read2 == null && isPrimitive) {
+                    return;
+                }
+                field.set(obj, read2);
+            }
+
+            @Override // com.google.gson.internal.bind.ReflectiveTypeAdapterFactory.BoundField
+            public boolean writeField(Object obj) throws IOException, IllegalAccessException {
+                return this.serialized && field.get(obj) != obj;
+            }
+        };
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r2v1 */
+    /* JADX WARN: Type inference failed for: r2v2, types: [int] */
+    /* JADX WARN: Type inference failed for: r2v7 */
+    private Map<String, BoundField> getBoundFields(Gson gson, TypeToken<?> typeToken, Class<?> cls) {
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        if (cls.isInterface()) {
+            return linkedHashMap;
+        }
+        Type type = typeToken.getType();
+        TypeToken<?> typeToken2 = typeToken;
+        Class<?> cls2 = cls;
+        while (cls2 != Object.class) {
+            Field[] declaredFields = cls2.getDeclaredFields();
+            int length = declaredFields.length;
+            boolean z = false;
+            int i = 0;
+            while (i < length) {
+                Field field = declaredFields[i];
+                boolean excludeField = excludeField(field, true);
+                boolean excludeField2 = excludeField(field, z);
+                if (excludeField || excludeField2) {
+                    this.accessor.makeAccessible(field);
+                    Type resolve = C$Gson$Types.resolve(typeToken2.getType(), cls2, field.getGenericType());
+                    List<String> fieldNames = getFieldNames(field);
+                    int size = fieldNames.size();
+                    BoundField boundField = null;
+                    ?? r2 = z;
+                    while (r2 < size) {
+                        String str = fieldNames.get(r2);
+                        boolean z2 = r2 != 0 ? z : excludeField;
+                        int i2 = r2;
+                        BoundField boundField2 = boundField;
+                        int i3 = size;
+                        List<String> list = fieldNames;
+                        Field field2 = field;
+                        boundField = boundField2 == null ? (BoundField) linkedHashMap.put(str, createBoundField(gson, field, str, TypeToken.get(resolve), z2, excludeField2)) : boundField2;
+                        excludeField = z2;
+                        fieldNames = list;
+                        size = i3;
+                        field = field2;
+                        z = false;
+                        r2 = i2 + 1;
+                    }
+                    BoundField boundField3 = boundField;
+                    if (boundField3 != null) {
+                        throw new IllegalArgumentException(type + " declares multiple JSON fields named " + boundField3.name);
+                    }
+                }
+                i++;
+                z = false;
+            }
+            typeToken2 = TypeToken.get(C$Gson$Types.resolve(typeToken2.getType(), cls2, cls2.getGenericSuperclass()));
+            cls2 = typeToken2.getRawType();
+        }
+        return linkedHashMap;
+    }
+
+    public static abstract class BoundField {
+        final boolean deserialized;
+        final String name;
+        final boolean serialized;
+
+        public abstract void read(JsonReader jsonReader, Object obj) throws IOException, IllegalAccessException;
+
+        public abstract void write(JsonWriter jsonWriter, Object obj) throws IOException, IllegalAccessException;
+
+        public abstract boolean writeField(Object obj) throws IOException, IllegalAccessException;
+
+        public BoundField(String str, boolean z, boolean z2) {
+            this.name = str;
+            this.serialized = z;
+            this.deserialized = z2;
+        }
+    }
+
+    public static final class Adapter<T> extends TypeAdapter<T> {
+        private final Map<String, BoundField> boundFields;
+        private final ObjectConstructor<T> constructor;
+
+        public Adapter(ObjectConstructor<T> objectConstructor, Map<String, BoundField> map) {
+            this.constructor = objectConstructor;
+            this.boundFields = map;
+        }
+
+        @Override // com.google.gson.TypeAdapter
+        /* renamed from: read */
+        public T read2(JsonReader jsonReader) throws IOException {
+            if (jsonReader.peek() == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return null;
+            }
+            T construct = this.constructor.construct();
+            try {
+                jsonReader.beginObject();
+                while (jsonReader.hasNext()) {
+                    BoundField boundField = this.boundFields.get(jsonReader.nextName());
+                    if (boundField != null && boundField.deserialized) {
+                        boundField.read(jsonReader, construct);
+                    }
+                    jsonReader.skipValue();
+                }
+                jsonReader.endObject();
+                return construct;
+            } catch (IllegalAccessException e) {
+                throw new AssertionError(e);
+            } catch (IllegalStateException e2) {
+                throw new JsonSyntaxException(e2);
+            }
+        }
+
+        @Override // com.google.gson.TypeAdapter
+        public void write(JsonWriter jsonWriter, T t) throws IOException {
+            if (t == null) {
+                jsonWriter.nullValue();
+                return;
+            }
+            jsonWriter.beginObject();
+            try {
+                for (BoundField boundField : this.boundFields.values()) {
+                    if (boundField.writeField(t)) {
+                        jsonWriter.name(boundField.name);
+                        boundField.write(jsonWriter, t);
+                    }
+                }
+                jsonWriter.endObject();
+            } catch (IllegalAccessException e) {
+                throw new AssertionError(e);
+            }
+        }
+    }
+}

decompiled/sources/com/google/gson/internal/bind/TreeTypeAdapter.java

@@ -0,0 +1,132 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.C$Gson$Preconditions;
+import com.google.gson.internal.Streams;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+/* loaded from: classes3.dex */
+public final class TreeTypeAdapter<T> extends TypeAdapter<T> {
+    private final TreeTypeAdapter<T>.GsonContextImpl context = new GsonContextImpl();
+    private TypeAdapter<T> delegate;
+    private final JsonDeserializer<T> deserializer;
+    final Gson gson;
+    private final JsonSerializer<T> serializer;
+    private final TypeAdapterFactory skipPast;
+    private final TypeToken<T> typeToken;
+
+    public TreeTypeAdapter(JsonSerializer<T> jsonSerializer, JsonDeserializer<T> jsonDeserializer, Gson gson, TypeToken<T> typeToken, TypeAdapterFactory typeAdapterFactory) {
+        this.serializer = jsonSerializer;
+        this.deserializer = jsonDeserializer;
+        this.gson = gson;
+        this.typeToken = typeToken;
+        this.skipPast = typeAdapterFactory;
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    /* renamed from: read */
+    public T read2(JsonReader jsonReader) throws IOException {
+        if (this.deserializer == null) {
+            return delegate().read2(jsonReader);
+        }
+        JsonElement parse = Streams.parse(jsonReader);
+        if (parse.isJsonNull()) {
+            return null;
+        }
+        return this.deserializer.deserialize(parse, this.typeToken.getType(), this.context);
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    public void write(JsonWriter jsonWriter, T t) throws IOException {
+        JsonSerializer<T> jsonSerializer = this.serializer;
+        if (jsonSerializer == null) {
+            delegate().write(jsonWriter, t);
+        } else if (t == null) {
+            jsonWriter.nullValue();
+        } else {
+            Streams.write(jsonSerializer.serialize(t, this.typeToken.getType(), this.context), jsonWriter);
+        }
+    }
+
+    private TypeAdapter<T> delegate() {
+        TypeAdapter<T> typeAdapter = this.delegate;
+        if (typeAdapter != null) {
+            return typeAdapter;
+        }
+        TypeAdapter<T> delegateAdapter = this.gson.getDelegateAdapter(this.skipPast, this.typeToken);
+        this.delegate = delegateAdapter;
+        return delegateAdapter;
+    }
+
+    public static TypeAdapterFactory newFactory(TypeToken<?> typeToken, Object obj) {
+        return new SingleTypeFactory(obj, typeToken, false, null);
+    }
+
+    public static TypeAdapterFactory newFactoryWithMatchRawType(TypeToken<?> typeToken, Object obj) {
+        return new SingleTypeFactory(obj, typeToken, typeToken.getType() == typeToken.getRawType(), null);
+    }
+
+    public static TypeAdapterFactory newTypeHierarchyFactory(Class<?> cls, Object obj) {
+        return new SingleTypeFactory(obj, null, false, cls);
+    }
+
+    public static final class SingleTypeFactory implements TypeAdapterFactory {
+        private final JsonDeserializer<?> deserializer;
+        private final TypeToken<?> exactType;
+        private final Class<?> hierarchyType;
+        private final boolean matchRawType;
+        private final JsonSerializer<?> serializer;
+
+        public SingleTypeFactory(Object obj, TypeToken<?> typeToken, boolean z, Class<?> cls) {
+            JsonSerializer<?> jsonSerializer = obj instanceof JsonSerializer ? (JsonSerializer) obj : null;
+            this.serializer = jsonSerializer;
+            JsonDeserializer<?> jsonDeserializer = obj instanceof JsonDeserializer ? (JsonDeserializer) obj : null;
+            this.deserializer = jsonDeserializer;
+            C$Gson$Preconditions.checkArgument((jsonSerializer == null && jsonDeserializer == null) ? false : true);
+            this.exactType = typeToken;
+            this.matchRawType = z;
+            this.hierarchyType = cls;
+        }
+
+        @Override // com.google.gson.TypeAdapterFactory
+        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+            TypeToken<?> typeToken2 = this.exactType;
+            if (typeToken2 == null ? !this.hierarchyType.isAssignableFrom(typeToken.getRawType()) : !(typeToken2.equals(typeToken) || (this.matchRawType && this.exactType.getType() == typeToken.getRawType()))) {
+                return null;
+            }
+            return new TreeTypeAdapter(this.serializer, this.deserializer, gson, typeToken, this);
+        }
+    }
+
+    public final class GsonContextImpl implements JsonSerializationContext, JsonDeserializationContext {
+        private GsonContextImpl() {
+        }
+
+        @Override // com.google.gson.JsonSerializationContext
+        public JsonElement serialize(Object obj) {
+            return TreeTypeAdapter.this.gson.toJsonTree(obj);
+        }
+
+        @Override // com.google.gson.JsonSerializationContext
+        public JsonElement serialize(Object obj, Type type) {
+            return TreeTypeAdapter.this.gson.toJsonTree(obj, type);
+        }
+
+        @Override // com.google.gson.JsonDeserializationContext
+        public <R> R deserialize(JsonElement jsonElement, Type type) throws JsonParseException {
+            return (R) TreeTypeAdapter.this.gson.fromJson(jsonElement, type);
+        }
+    }
+}

decompiled/sources/com/google/gson/internal/bind/TypeAdapterRuntimeTypeWrapper.java

@@ -0,0 +1,50 @@
+package com.google.gson.internal.bind;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.internal.bind.ReflectiveTypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+/* loaded from: classes3.dex */
+final class TypeAdapterRuntimeTypeWrapper<T> extends TypeAdapter<T> {
+    private final Gson context;
+    private final TypeAdapter<T> delegate;
+    private final Type type;
+
+    public TypeAdapterRuntimeTypeWrapper(Gson gson, TypeAdapter<T> typeAdapter, Type type) {
+        this.context = gson;
+        this.delegate = typeAdapter;
+        this.type = type;
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    /* renamed from: read */
+    public T read2(JsonReader jsonReader) throws IOException {
+        return this.delegate.read2(jsonReader);
+    }
+
+    @Override // com.google.gson.TypeAdapter
+    public void write(JsonWriter jsonWriter, T t) throws IOException {
+        TypeAdapter<T> typeAdapter = this.delegate;
+        Type runtimeTypeIfMoreSpecific = getRuntimeTypeIfMoreSpecific(this.type, t);
+        if (runtimeTypeIfMoreSpecific != this.type) {
+            typeAdapter = this.context.getAdapter(TypeToken.get(runtimeTypeIfMoreSpecific));
+            if (typeAdapter instanceof ReflectiveTypeAdapterFactory.Adapter) {
+                TypeAdapter<T> typeAdapter2 = this.delegate;
+                if (!(typeAdapter2 instanceof ReflectiveTypeAdapterFactory.Adapter)) {
+                    typeAdapter = typeAdapter2;
+                }
+            }
+        }
+        typeAdapter.write(jsonWriter, t);
+    }
+
+    private Type getRuntimeTypeIfMoreSpecific(Type type, Object obj) {
+        return obj != null ? (type == Object.class || (type instanceof TypeVariable) || (type instanceof Class)) ? obj.getClass() : type : type;
+    }
+}

decompiled/sources/com/google/gson/internal/bind/util/ISO8601Utils.java

@@ -0,0 +1,122 @@
+package com.google.gson.internal.bind.util;
+
+import com.mbridge.msdk.newreward.function.common.MBridgeCommon;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
+
+/* loaded from: classes3.dex */
+public class ISO8601Utils {
+    private static final String UTC_ID = "UTC";
+    private static final TimeZone TIMEZONE_UTC = TimeZone.getTimeZone(UTC_ID);
+
+    public static String format(Date date) {
+        return format(date, false, TIMEZONE_UTC);
+    }
+
+    public static String format(Date date, boolean z) {
+        return format(date, z, TIMEZONE_UTC);
+    }
+
+    public static String format(Date date, boolean z, TimeZone timeZone) {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(timeZone, Locale.US);
+        gregorianCalendar.setTime(date);
+        StringBuilder sb = new StringBuilder(19 + (z ? 4 : 0) + (timeZone.getRawOffset() == 0 ? 1 : 6));
+        padInt(sb, gregorianCalendar.get(1), 4);
+        sb.append('-');
+        padInt(sb, gregorianCalendar.get(2) + 1, 2);
+        sb.append('-');
+        padInt(sb, gregorianCalendar.get(5), 2);
+        sb.append('T');
+        padInt(sb, gregorianCalendar.get(11), 2);
+        sb.append(':');
+        padInt(sb, gregorianCalendar.get(12), 2);
+        sb.append(':');
+        padInt(sb, gregorianCalendar.get(13), 2);
+        if (z) {
+            sb.append('.');
+            padInt(sb, gregorianCalendar.get(14), 3);
+        }
+        int offset = timeZone.getOffset(gregorianCalendar.getTimeInMillis());
+        if (offset != 0) {
+            int i = offset / MBridgeCommon.DEFAULT_LOAD_TIMEOUT;
+            int abs = Math.abs(i / 60);
+            int abs2 = Math.abs(i % 60);
+            sb.append(offset >= 0 ? '+' : '-');
+            padInt(sb, abs, 2);
+            sb.append(':');
+            padInt(sb, abs2, 2);
+        } else {
+            sb.append('Z');
+        }
+        return sb.toString();
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:82:0x01cf  */
+    /* JADX WARN: Removed duplicated region for block: B:85:0x01eb  */
+    /* JADX WARN: Removed duplicated region for block: B:90:0x01d1  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static java.util.Date parse(java.lang.String r19, java.text.ParsePosition r20) throws java.text.ParseException {
+        /*
+            Method dump skipped, instructions count: 565
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.gson.internal.bind.util.ISO8601Utils.parse(java.lang.String, java.text.ParsePosition):java.util.Date");
+    }
+
+    private static boolean checkOffset(String str, int i, char c) {
+        return i < str.length() && str.charAt(i) == c;
+    }
+
+    private static int parseInt(String str, int i, int i2) throws NumberFormatException {
+        int i3;
+        int i4;
+        if (i < 0 || i2 > str.length() || i > i2) {
+            throw new NumberFormatException(str);
+        }
+        if (i < i2) {
+            i4 = i + 1;
+            int digit = Character.digit(str.charAt(i), 10);
+            if (digit < 0) {
+                throw new NumberFormatException("Invalid number: " + str.substring(i, i2));
+            }
+            i3 = -digit;
+        } else {
+            i3 = 0;
+            i4 = i;
+        }
+        while (i4 < i2) {
+            int i5 = i4 + 1;
+            int digit2 = Character.digit(str.charAt(i4), 10);
+            if (digit2 < 0) {
+                throw new NumberFormatException("Invalid number: " + str.substring(i, i2));
+            }
+            i3 = (i3 * 10) - digit2;
+            i4 = i5;
+        }
+        return -i3;
+    }
+
+    private static void padInt(StringBuilder sb, int i, int i2) {
+        String num = Integer.toString(i);
+        for (int length = i2 - num.length(); length > 0; length--) {
+            sb.append('0');
+        }
+        sb.append(num);
+    }
+
+    private static int indexOfNonDigit(String str, int i) {
+        while (i < str.length()) {
+            char charAt = str.charAt(i);
+            if (charAt < '0' || charAt > '9') {
+                return i;
+            }
+            i++;
+        }
+        return str.length();
+    }
+}