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/android/gms/common/server/FavaDiagnosticsEntity.java

@@ -0,0 +1,54 @@
+package com.google.android.gms.common.server;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ReflectedParcelable;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+
+@KeepForSdk
+@SafeParcelable.Class(creator = "FavaDiagnosticsEntityCreator")
+/* loaded from: classes2.dex */
+public class FavaDiagnosticsEntity extends AbstractSafeParcelable implements ReflectedParcelable {
+
+    @NonNull
+    @KeepForSdk
+    public static final Parcelable.Creator<FavaDiagnosticsEntity> CREATOR = new zaa();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+
+    @NonNull
+    @SafeParcelable.Field(id = 2)
+    public final String zab;
+
+    @SafeParcelable.Field(id = 3)
+    public final int zac;
+
+    @SafeParcelable.Constructor
+    public FavaDiagnosticsEntity(@SafeParcelable.Param(id = 1) int i, @NonNull @SafeParcelable.Param(id = 2) String str, @SafeParcelable.Param(id = 3) int i2) {
+        this.zaa = i;
+        this.zab = str;
+        this.zac = i2;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(@NonNull Parcel parcel, int i) {
+        int i2 = this.zaa;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        SafeParcelWriter.writeString(parcel, 2, this.zab, false);
+        SafeParcelWriter.writeInt(parcel, 3, this.zac);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    @KeepForSdk
+    public FavaDiagnosticsEntity(@NonNull String str, int i) {
+        this.zaa = 1;
+        this.zab = str;
+        this.zac = i;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/converter/StringToIntConverter.java

@@ -0,0 +1,92 @@
+package com.google.android.gms.common.server.converter;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.SparseArray;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+@KeepForSdk
+@SafeParcelable.Class(creator = "StringToIntConverterCreator")
+/* loaded from: classes2.dex */
+public final class StringToIntConverter extends AbstractSafeParcelable implements FastJsonResponse.FieldConverter<String, Integer> {
+
+    @NonNull
+    public static final Parcelable.Creator<StringToIntConverter> CREATOR = new zad();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+    private final HashMap zab;
+    private final SparseArray zac;
+
+    @KeepForSdk
+    public StringToIntConverter() {
+        this.zaa = 1;
+        this.zab = new HashMap();
+        this.zac = new SparseArray();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public StringToIntConverter add(@NonNull String str, int i) {
+        this.zab.put(str, Integer.valueOf(i));
+        this.zac.put(i, str);
+        return this;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(@NonNull Parcel parcel, int i) {
+        int i2 = this.zaa;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        ArrayList arrayList = new ArrayList();
+        for (String str : this.zab.keySet()) {
+            arrayList.add(new zac(str, ((Integer) this.zab.get(str)).intValue()));
+        }
+        SafeParcelWriter.writeTypedList(parcel, 2, arrayList, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    public final int zaa() {
+        return 7;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    public final int zab() {
+        return 0;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    @Nullable
+    public final /* bridge */ /* synthetic */ Object zac(@NonNull Object obj) {
+        Integer num = (Integer) this.zab.get((String) obj);
+        return num == null ? (Integer) this.zab.get("gms_unknown") : num;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    @NonNull
+    public final /* bridge */ /* synthetic */ Object zad(@NonNull Object obj) {
+        String str = (String) this.zac.get(((Integer) obj).intValue());
+        return (str == null && this.zab.containsKey("gms_unknown")) ? "gms_unknown" : str;
+    }
+
+    @SafeParcelable.Constructor
+    public StringToIntConverter(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) ArrayList arrayList) {
+        this.zaa = i;
+        this.zab = new HashMap();
+        this.zac = new SparseArray();
+        int size = arrayList.size();
+        for (int i2 = 0; i2 < size; i2++) {
+            zac zacVar = (zac) arrayList.get(i2);
+            add(zacVar.zab, zacVar.zac);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/server/converter/zaa.java

@@ -0,0 +1,55 @@
+package com.google.android.gms.common.server.converter;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+@SafeParcelable.Class(creator = "ConverterWrapperCreator")
+/* loaded from: classes2.dex */
+public final class zaa extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zaa> CREATOR = new zab();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+
+    @SafeParcelable.Field(getter = "getStringToIntConverter", id = 2)
+    private final StringToIntConverter zab;
+
+    @SafeParcelable.Constructor
+    public zaa(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) StringToIntConverter stringToIntConverter) {
+        this.zaa = i;
+        this.zab = stringToIntConverter;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int i2 = this.zaa;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        SafeParcelWriter.writeParcelable(parcel, 2, this.zab, i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public final FastJsonResponse.FieldConverter zab() {
+        StringToIntConverter stringToIntConverter = this.zab;
+        if (stringToIntConverter != null) {
+            return stringToIntConverter;
+        }
+        throw new IllegalStateException("There was no converter wrapped in this ConverterWrapper.");
+    }
+
+    private zaa(StringToIntConverter stringToIntConverter) {
+        this.zaa = 1;
+        this.zab = stringToIntConverter;
+    }
+
+    public static zaa zaa(FastJsonResponse.FieldConverter fieldConverter) {
+        if (fieldConverter instanceof StringToIntConverter) {
+            return new zaa((StringToIntConverter) fieldConverter);
+        }
+        throw new IllegalArgumentException("Unsupported safe parcelable field converter class.");
+    }
+}

decompiled/sources/com/google/android/gms/common/server/converter/zab.java

@@ -0,0 +1,33 @@
+package com.google.android.gms.common.server.converter;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+
+/* loaded from: classes2.dex */
+public final class zab implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        StringToIntConverter stringToIntConverter = null;
+        int i = 0;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId != 2) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                stringToIntConverter = (StringToIntConverter) SafeParcelReader.createParcelable(parcel, readHeader, StringToIntConverter.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new zaa(i, stringToIntConverter);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new zaa[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/converter/zac.java

@@ -0,0 +1,45 @@
+package com.google.android.gms.common.server.converter;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+
+@SafeParcelable.Class(creator = "StringToIntConverterEntryCreator")
+/* loaded from: classes2.dex */
+public final class zac extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zac> CREATOR = new zae();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+
+    @SafeParcelable.Field(id = 2)
+    final String zab;
+
+    @SafeParcelable.Field(id = 3)
+    final int zac;
+
+    @SafeParcelable.Constructor
+    public zac(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) String str, @SafeParcelable.Param(id = 3) int i2) {
+        this.zaa = i;
+        this.zab = str;
+        this.zac = i2;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int i2 = this.zaa;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        SafeParcelWriter.writeString(parcel, 2, this.zab, false);
+        SafeParcelWriter.writeInt(parcel, 3, this.zac);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public zac(String str, int i) {
+        this.zaa = 1;
+        this.zab = str;
+        this.zac = i;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/converter/zad.java

@@ -0,0 +1,34 @@
+package com.google.android.gms.common.server.converter;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import java.util.ArrayList;
+
+/* loaded from: classes2.dex */
+public final class zad implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        ArrayList arrayList = null;
+        int i = 0;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId != 2) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                arrayList = SafeParcelReader.createTypedList(parcel, readHeader, zac.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new StringToIntConverter(i, arrayList);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new StringToIntConverter[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/converter/zae.java

@@ -0,0 +1,36 @@
+package com.google.android.gms.common.server.converter;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+
+/* loaded from: classes2.dex */
+public final class zae implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        int i = 0;
+        String str = null;
+        int i2 = 0;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 2) {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId != 3) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                i2 = SafeParcelReader.readInt(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new zac(i, str, i2);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new zac[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/FastJsonResponse.java

@@ -0,0 +1,718 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.util.Base64Utils;
+import com.google.android.gms.common.util.JsonUtils;
+import com.google.android.gms.common.util.MapUtils;
+import com.ironsource.v8;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class FastJsonResponse {
+
+    @ShowFirstParty
+    public interface FieldConverter<I, O> {
+        int zaa();
+
+        int zab();
+
+        @Nullable
+        Object zac(@NonNull Object obj);
+
+        @NonNull
+        Object zad(@NonNull Object obj);
+    }
+
+    @NonNull
+    public static final Object zaD(@NonNull Field field, @Nullable Object obj) {
+        return field.zak != null ? field.zaf(obj) : obj;
+    }
+
+    private final void zaE(Field field, @Nullable Object obj) {
+        int i = field.zac;
+        Object zae = field.zae(obj);
+        String str = field.zae;
+        switch (i) {
+            case 0:
+                if (zae != null) {
+                    setIntegerInternal(field, str, ((Integer) zae).intValue());
+                    return;
+                } else {
+                    zaG(str);
+                    return;
+                }
+            case 1:
+                zaf(field, str, (BigInteger) zae);
+                return;
+            case 2:
+                if (zae != null) {
+                    setLongInternal(field, str, ((Long) zae).longValue());
+                    return;
+                } else {
+                    zaG(str);
+                    return;
+                }
+            case 3:
+            default:
+                throw new IllegalStateException("Unsupported type for conversion: " + i);
+            case 4:
+                if (zae != null) {
+                    zan(field, str, ((Double) zae).doubleValue());
+                    return;
+                } else {
+                    zaG(str);
+                    return;
+                }
+            case 5:
+                zab(field, str, (BigDecimal) zae);
+                return;
+            case 6:
+                if (zae != null) {
+                    setBooleanInternal(field, str, ((Boolean) zae).booleanValue());
+                    return;
+                } else {
+                    zaG(str);
+                    return;
+                }
+            case 7:
+                setStringInternal(field, str, (String) zae);
+                return;
+            case 8:
+            case 9:
+                if (zae != null) {
+                    setDecodedBytesInternal(field, str, (byte[]) zae);
+                    return;
+                } else {
+                    zaG(str);
+                    return;
+                }
+        }
+    }
+
+    private static final void zaF(StringBuilder sb, Field field, Object obj) {
+        int i = field.zaa;
+        if (i == 11) {
+            Class cls = field.zag;
+            Preconditions.checkNotNull(cls);
+            sb.append(((FastJsonResponse) cls.cast(obj)).toString());
+        } else {
+            if (i != 7) {
+                sb.append(obj);
+                return;
+            }
+            sb.append("\"");
+            sb.append(JsonUtils.escapeString((String) obj));
+            sb.append("\"");
+        }
+    }
+
+    private static final void zaG(String str) {
+        if (Log.isLoggable("FastJsonResponse", 6)) {
+            Log.e("FastJsonResponse", "Output field (" + str + ") has a null value, but expected a primitive");
+        }
+    }
+
+    @KeepForSdk
+    public <T extends FastJsonResponse> void addConcreteTypeArrayInternal(@NonNull Field field, @NonNull String str, @Nullable ArrayList<T> arrayList) {
+        throw new UnsupportedOperationException("Concrete type array not supported");
+    }
+
+    @KeepForSdk
+    public <T extends FastJsonResponse> void addConcreteTypeInternal(@NonNull Field field, @NonNull String str, @NonNull T t) {
+        throw new UnsupportedOperationException("Concrete type not supported");
+    }
+
+    @NonNull
+    @KeepForSdk
+    public abstract Map<String, Field<?, ?>> getFieldMappings();
+
+    @Nullable
+    @KeepForSdk
+    public abstract Object getValueObject(@NonNull String str);
+
+    @KeepForSdk
+    public abstract boolean isPrimitiveFieldSet(@NonNull String str);
+
+    @KeepForSdk
+    public void setBooleanInternal(@NonNull Field<?, ?> field, @NonNull String str, boolean z) {
+        throw new UnsupportedOperationException("Boolean not supported");
+    }
+
+    @KeepForSdk
+    public void setDecodedBytesInternal(@NonNull Field<?, ?> field, @NonNull String str, @Nullable byte[] bArr) {
+        throw new UnsupportedOperationException("byte[] not supported");
+    }
+
+    @KeepForSdk
+    public void setIntegerInternal(@NonNull Field<?, ?> field, @NonNull String str, int i) {
+        throw new UnsupportedOperationException("Integer not supported");
+    }
+
+    @KeepForSdk
+    public void setLongInternal(@NonNull Field<?, ?> field, @NonNull String str, long j) {
+        throw new UnsupportedOperationException("Long not supported");
+    }
+
+    @KeepForSdk
+    public void setStringInternal(@NonNull Field<?, ?> field, @NonNull String str, @Nullable String str2) {
+        throw new UnsupportedOperationException("String not supported");
+    }
+
+    @KeepForSdk
+    public void setStringMapInternal(@NonNull Field<?, ?> field, @NonNull String str, @Nullable Map<String, String> map) {
+        throw new UnsupportedOperationException("String map not supported");
+    }
+
+    @KeepForSdk
+    public void setStringsInternal(@NonNull Field<?, ?> field, @NonNull String str, @Nullable ArrayList<String> arrayList) {
+        throw new UnsupportedOperationException("String list not supported");
+    }
+
+    @NonNull
+    @KeepForSdk
+    public String toString() {
+        Map<String, Field<?, ?>> fieldMappings = getFieldMappings();
+        StringBuilder sb = new StringBuilder(100);
+        for (String str : fieldMappings.keySet()) {
+            Field<?, ?> field = fieldMappings.get(str);
+            if (isFieldSet(field)) {
+                Object zaD = zaD(field, getFieldValue(field));
+                if (sb.length() == 0) {
+                    sb.append("{");
+                } else {
+                    sb.append(",");
+                }
+                sb.append("\"");
+                sb.append(str);
+                sb.append("\":");
+                if (zaD != null) {
+                    switch (field.zac) {
+                        case 8:
+                            sb.append("\"");
+                            sb.append(Base64Utils.encode((byte[]) zaD));
+                            sb.append("\"");
+                            break;
+                        case 9:
+                            sb.append("\"");
+                            sb.append(Base64Utils.encodeUrlSafe((byte[]) zaD));
+                            sb.append("\"");
+                            break;
+                        case 10:
+                            MapUtils.writeStringMapToJson(sb, (HashMap) zaD);
+                            break;
+                        default:
+                            if (field.zab) {
+                                ArrayList arrayList = (ArrayList) zaD;
+                                sb.append(v8.i.d);
+                                int size = arrayList.size();
+                                for (int i = 0; i < size; i++) {
+                                    if (i > 0) {
+                                        sb.append(",");
+                                    }
+                                    Object obj = arrayList.get(i);
+                                    if (obj != null) {
+                                        zaF(sb, field, obj);
+                                    }
+                                }
+                                sb.append(v8.i.e);
+                                break;
+                            } else {
+                                zaF(sb, field, zaD);
+                                break;
+                            }
+                    }
+                } else {
+                    sb.append("null");
+                }
+            }
+        }
+        if (sb.length() > 0) {
+            sb.append("}");
+        } else {
+            sb.append(com.applovin.impl.sdk.utils.JsonUtils.EMPTY_JSON);
+        }
+        return sb.toString();
+    }
+
+    public final void zaA(@NonNull Field field, @Nullable String str) {
+        if (field.zak != null) {
+            zaE(field, str);
+        } else {
+            setStringInternal(field, field.zae, str);
+        }
+    }
+
+    public final void zaB(@NonNull Field field, @Nullable Map map) {
+        if (field.zak != null) {
+            zaE(field, map);
+        } else {
+            setStringMapInternal(field, field.zae, map);
+        }
+    }
+
+    public final void zaC(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            setStringsInternal(field, field.zae, arrayList);
+        }
+    }
+
+    public final void zaa(@NonNull Field field, @Nullable BigDecimal bigDecimal) {
+        if (field.zak != null) {
+            zaE(field, bigDecimal);
+        } else {
+            zab(field, field.zae, bigDecimal);
+        }
+    }
+
+    public void zab(@NonNull Field field, @NonNull String str, @Nullable BigDecimal bigDecimal) {
+        throw new UnsupportedOperationException("BigDecimal not supported");
+    }
+
+    public final void zac(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zad(field, field.zae, arrayList);
+        }
+    }
+
+    public void zad(@NonNull Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        throw new UnsupportedOperationException("BigDecimal list not supported");
+    }
+
+    public final void zae(@NonNull Field field, @Nullable BigInteger bigInteger) {
+        if (field.zak != null) {
+            zaE(field, bigInteger);
+        } else {
+            zaf(field, field.zae, bigInteger);
+        }
+    }
+
+    public void zaf(@NonNull Field field, @NonNull String str, @Nullable BigInteger bigInteger) {
+        throw new UnsupportedOperationException("BigInteger not supported");
+    }
+
+    public final void zag(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zah(field, field.zae, arrayList);
+        }
+    }
+
+    public void zah(@NonNull Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        throw new UnsupportedOperationException("BigInteger list not supported");
+    }
+
+    public final void zai(@NonNull Field field, boolean z) {
+        if (field.zak != null) {
+            zaE(field, Boolean.valueOf(z));
+        } else {
+            setBooleanInternal(field, field.zae, z);
+        }
+    }
+
+    public final void zaj(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zak(field, field.zae, arrayList);
+        }
+    }
+
+    public void zak(@NonNull Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        throw new UnsupportedOperationException("Boolean list not supported");
+    }
+
+    public final void zal(@NonNull Field field, @Nullable byte[] bArr) {
+        if (field.zak != null) {
+            zaE(field, bArr);
+        } else {
+            setDecodedBytesInternal(field, field.zae, bArr);
+        }
+    }
+
+    public final void zam(@NonNull Field field, double d) {
+        if (field.zak != null) {
+            zaE(field, Double.valueOf(d));
+        } else {
+            zan(field, field.zae, d);
+        }
+    }
+
+    public void zan(@NonNull Field field, @NonNull String str, double d) {
+        throw new UnsupportedOperationException("Double not supported");
+    }
+
+    public final void zao(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zap(field, field.zae, arrayList);
+        }
+    }
+
+    public void zap(@NonNull Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        throw new UnsupportedOperationException("Double list not supported");
+    }
+
+    public final void zaq(@NonNull Field field, float f) {
+        if (field.zak != null) {
+            zaE(field, Float.valueOf(f));
+        } else {
+            zar(field, field.zae, f);
+        }
+    }
+
+    public void zar(@NonNull Field field, @NonNull String str, float f) {
+        throw new UnsupportedOperationException("Float not supported");
+    }
+
+    public final void zas(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zat(field, field.zae, arrayList);
+        }
+    }
+
+    public void zat(@NonNull Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        throw new UnsupportedOperationException("Float list not supported");
+    }
+
+    public final void zau(@NonNull Field field, int i) {
+        if (field.zak != null) {
+            zaE(field, Integer.valueOf(i));
+        } else {
+            setIntegerInternal(field, field.zae, i);
+        }
+    }
+
+    public final void zav(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zaw(field, field.zae, arrayList);
+        }
+    }
+
+    public void zaw(@NonNull Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        throw new UnsupportedOperationException("Integer list not supported");
+    }
+
+    public final void zax(@NonNull Field field, long j) {
+        if (field.zak != null) {
+            zaE(field, Long.valueOf(j));
+        } else {
+            setLongInternal(field, field.zae, j);
+        }
+    }
+
+    public final void zay(@NonNull Field field, @Nullable ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zaz(field, field.zae, arrayList);
+        }
+    }
+
+    public void zaz(@NonNull Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        throw new UnsupportedOperationException("Long list not supported");
+    }
+
+    @SafeParcelable.Class(creator = "FieldCreator")
+    @ShowFirstParty
+    @KeepForSdk
+    public static class Field<I, O> extends AbstractSafeParcelable {
+        public static final zaj CREATOR = new zaj();
+
+        @SafeParcelable.Field(getter = "getTypeIn", id = 2)
+        protected final int zaa;
+
+        @SafeParcelable.Field(getter = "isTypeInArray", id = 3)
+        protected final boolean zab;
+
+        @SafeParcelable.Field(getter = "getTypeOut", id = 4)
+        protected final int zac;
+
+        @SafeParcelable.Field(getter = "isTypeOutArray", id = 5)
+        protected final boolean zad;
+
+        @NonNull
+        @SafeParcelable.Field(getter = "getOutputFieldName", id = 6)
+        protected final String zae;
+
+        @SafeParcelable.Field(getter = "getSafeParcelableFieldId", id = 7)
+        protected final int zaf;
+
+        @Nullable
+        protected final Class zag;
+
+        @Nullable
+        @SafeParcelable.Field(getter = "getConcreteTypeName", id = 8)
+        protected final String zah;
+
+        @SafeParcelable.VersionField(getter = "getVersionCode", id = 1)
+        private final int zai;
+        private zan zaj;
+
+        @Nullable
+        @SafeParcelable.Field(getter = "getWrappedConverter", id = 9, type = "com.google.android.gms.common.server.converter.ConverterWrapper")
+        private final FieldConverter zak;
+
+        @SafeParcelable.Constructor
+        public Field(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) int i2, @SafeParcelable.Param(id = 3) boolean z, @SafeParcelable.Param(id = 4) int i3, @SafeParcelable.Param(id = 5) boolean z2, @SafeParcelable.Param(id = 6) String str, @SafeParcelable.Param(id = 7) int i4, @Nullable @SafeParcelable.Param(id = 8) String str2, @Nullable @SafeParcelable.Param(id = 9) com.google.android.gms.common.server.converter.zaa zaaVar) {
+            this.zai = i;
+            this.zaa = i2;
+            this.zab = z;
+            this.zac = i3;
+            this.zad = z2;
+            this.zae = str;
+            this.zaf = i4;
+            if (str2 == null) {
+                this.zag = null;
+                this.zah = null;
+            } else {
+                this.zag = SafeParcelResponse.class;
+                this.zah = str2;
+            }
+            if (zaaVar == null) {
+                this.zak = null;
+            } else {
+                this.zak = zaaVar.zab();
+            }
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<byte[], byte[]> forBase64(@NonNull String str, int i) {
+            return new Field<>(8, false, 8, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<Boolean, Boolean> forBoolean(@NonNull String str, int i) {
+            return new Field<>(6, false, 6, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static <T extends FastJsonResponse> Field<T, T> forConcreteType(@NonNull String str, int i, @NonNull Class<T> cls) {
+            return new Field<>(11, false, 11, false, str, i, cls, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static <T extends FastJsonResponse> Field<ArrayList<T>, ArrayList<T>> forConcreteTypeArray(@NonNull String str, int i, @NonNull Class<T> cls) {
+            return new Field<>(11, true, 11, true, str, i, cls, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<Double, Double> forDouble(@NonNull String str, int i) {
+            return new Field<>(4, false, 4, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<Float, Float> forFloat(@NonNull String str, int i) {
+            return new Field<>(3, false, 3, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<Integer, Integer> forInteger(@NonNull String str, int i) {
+            return new Field<>(0, false, 0, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<Long, Long> forLong(@NonNull String str, int i) {
+            return new Field<>(2, false, 2, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<String, String> forString(@NonNull String str, int i) {
+            return new Field<>(7, false, 7, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<HashMap<String, String>, HashMap<String, String>> forStringMap(@NonNull String str, int i) {
+            return new Field<>(10, false, 10, false, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field<ArrayList<String>, ArrayList<String>> forStrings(@NonNull String str, int i) {
+            return new Field<>(7, true, 7, true, str, i, null, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public static Field withConverter(@NonNull String str, int i, @NonNull FieldConverter<?, ?> fieldConverter, boolean z) {
+            fieldConverter.zaa();
+            fieldConverter.zab();
+            return new Field(7, z, 0, false, str, i, null, fieldConverter);
+        }
+
+        @KeepForSdk
+        public int getSafeParcelableFieldId() {
+            return this.zaf;
+        }
+
+        @NonNull
+        public final String toString() {
+            Objects.ToStringHelper add = Objects.toStringHelper(this).add("versionCode", Integer.valueOf(this.zai)).add("typeIn", Integer.valueOf(this.zaa)).add("typeInArray", Boolean.valueOf(this.zab)).add("typeOut", Integer.valueOf(this.zac)).add("typeOutArray", Boolean.valueOf(this.zad)).add("outputFieldName", this.zae).add("safeParcelFieldId", Integer.valueOf(this.zaf)).add("concreteTypeName", zag());
+            Class cls = this.zag;
+            if (cls != null) {
+                add.add("concreteType.class", cls.getCanonicalName());
+            }
+            FieldConverter fieldConverter = this.zak;
+            if (fieldConverter != null) {
+                add.add("converterName", fieldConverter.getClass().getCanonicalName());
+            }
+            return add.toString();
+        }
+
+        @Override // android.os.Parcelable
+        public final void writeToParcel(@NonNull Parcel parcel, int i) {
+            int i2 = this.zai;
+            int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+            SafeParcelWriter.writeInt(parcel, 1, i2);
+            SafeParcelWriter.writeInt(parcel, 2, this.zaa);
+            SafeParcelWriter.writeBoolean(parcel, 3, this.zab);
+            SafeParcelWriter.writeInt(parcel, 4, this.zac);
+            SafeParcelWriter.writeBoolean(parcel, 5, this.zad);
+            SafeParcelWriter.writeString(parcel, 6, this.zae, false);
+            SafeParcelWriter.writeInt(parcel, 7, getSafeParcelableFieldId());
+            SafeParcelWriter.writeString(parcel, 8, zag(), false);
+            SafeParcelWriter.writeParcelable(parcel, 9, zaa(), i, false);
+            SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+        }
+
+        @Nullable
+        public final com.google.android.gms.common.server.converter.zaa zaa() {
+            FieldConverter fieldConverter = this.zak;
+            if (fieldConverter == null) {
+                return null;
+            }
+            return com.google.android.gms.common.server.converter.zaa.zaa(fieldConverter);
+        }
+
+        @NonNull
+        public final Field zab() {
+            return new Field(this.zai, this.zaa, this.zab, this.zac, this.zad, this.zae, this.zaf, this.zah, zaa());
+        }
+
+        @NonNull
+        public final FastJsonResponse zad() throws InstantiationException, IllegalAccessException {
+            Preconditions.checkNotNull(this.zag);
+            Class cls = this.zag;
+            if (cls != SafeParcelResponse.class) {
+                return (FastJsonResponse) cls.newInstance();
+            }
+            Preconditions.checkNotNull(this.zah);
+            Preconditions.checkNotNull(this.zaj, "The field mapping dictionary must be set if the concrete type is a SafeParcelResponse object.");
+            return new SafeParcelResponse(this.zaj, this.zah);
+        }
+
+        @NonNull
+        public final Object zae(@Nullable Object obj) {
+            Preconditions.checkNotNull(this.zak);
+            return Preconditions.checkNotNull(this.zak.zac(obj));
+        }
+
+        @NonNull
+        public final Object zaf(@NonNull Object obj) {
+            Preconditions.checkNotNull(this.zak);
+            return this.zak.zad(obj);
+        }
+
+        @Nullable
+        public final String zag() {
+            String str = this.zah;
+            if (str == null) {
+                return null;
+            }
+            return str;
+        }
+
+        @NonNull
+        public final Map zah() {
+            Preconditions.checkNotNull(this.zah);
+            Preconditions.checkNotNull(this.zaj);
+            return (Map) Preconditions.checkNotNull(this.zaj.zab(this.zah));
+        }
+
+        public final void zai(zan zanVar) {
+            this.zaj = zanVar;
+        }
+
+        public final boolean zaj() {
+            return this.zak != null;
+        }
+
+        public Field(int i, boolean z, int i2, boolean z2, @NonNull String str, int i3, @Nullable Class cls, @Nullable FieldConverter fieldConverter) {
+            this.zai = 1;
+            this.zaa = i;
+            this.zab = z;
+            this.zac = i2;
+            this.zad = z2;
+            this.zae = str;
+            this.zaf = i3;
+            this.zag = cls;
+            if (cls == null) {
+                this.zah = null;
+            } else {
+                this.zah = cls.getCanonicalName();
+            }
+            this.zak = fieldConverter;
+        }
+    }
+
+    @Nullable
+    @KeepForSdk
+    public Object getFieldValue(@NonNull Field field) {
+        String str = field.zae;
+        if (field.zag == null) {
+            return getValueObject(str);
+        }
+        Preconditions.checkState(getValueObject(str) == null, "Concrete field shouldn't be value object: %s", field.zae);
+        try {
+            return getClass().getMethod("get" + Character.toUpperCase(str.charAt(0)) + str.substring(1), new Class[0]).invoke(this, new Object[0]);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @KeepForSdk
+    public boolean isFieldSet(@NonNull Field field) {
+        if (field.zac != 11) {
+            return isPrimitiveFieldSet(field.zae);
+        }
+        if (field.zad) {
+            throw new UnsupportedOperationException("Concrete type arrays not supported");
+        }
+        throw new UnsupportedOperationException("Concrete types not supported");
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/FastParser.java

@@ -0,0 +1,641 @@
+package com.google.android.gms.common.server.response;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+import com.google.android.gms.common.util.JsonUtils;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Stack;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class FastParser<T extends FastJsonResponse> {
+    private static final char[] zaa = {'u', 'l', 'l'};
+    private static final char[] zab = {'r', 'u', 'e'};
+    private static final char[] zac = {'r', 'u', 'e', '\"'};
+    private static final char[] zad = {'a', 'l', 's', 'e'};
+    private static final char[] zae = {'a', 'l', 's', 'e', '\"'};
+    private static final char[] zaf = {'\n'};
+    private static final zai zag = new zaa();
+    private static final zai zah = new zab();
+    private static final zai zai = new zac();
+    private static final zai zaj = new zad();
+    private static final zai zak = new zae();
+    private static final zai zal = new zaf();
+    private static final zai zam = new zag();
+    private static final zai zan = new zah();
+    private final char[] zao = new char[1];
+    private final char[] zap = new char[32];
+    private final char[] zaq = new char[1024];
+    private final StringBuilder zar = new StringBuilder(32);
+    private final StringBuilder zas = new StringBuilder(1024);
+    private final Stack zat = new Stack();
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static class ParseException extends Exception {
+        public ParseException(@NonNull String str) {
+            super(str);
+        }
+
+        public ParseException(@NonNull String str, @NonNull Throwable th) {
+            super("Error instantiating inner object", th);
+        }
+
+        public ParseException(@NonNull Throwable th) {
+            super(th);
+        }
+    }
+
+    private static final String zaA(BufferedReader bufferedReader, char[] cArr, StringBuilder sb, @Nullable char[] cArr2) throws ParseException, IOException {
+        sb.setLength(0);
+        bufferedReader.mark(cArr.length);
+        boolean z = false;
+        boolean z2 = false;
+        loop0: while (true) {
+            int read = bufferedReader.read(cArr);
+            if (read == -1) {
+                throw new ParseException("Unexpected EOF while parsing string");
+            }
+            int i = 0;
+            while (i < read) {
+                char c = cArr[i];
+                if (!Character.isISOControl(c) || (cArr2 != null && cArr2[0] == c)) {
+                    int i2 = i + 1;
+                    if (c == '\"') {
+                        if (!z) {
+                            sb.append(cArr, 0, i);
+                            bufferedReader.reset();
+                            bufferedReader.skip(i2);
+                            return z2 ? JsonUtils.unescapeString(sb.toString()) : sb.toString();
+                        }
+                    } else if (c == '\\') {
+                        z = !z;
+                        z2 = true;
+                        i = i2;
+                    }
+                    z = false;
+                    i = i2;
+                }
+            }
+            sb.append(cArr, 0, read);
+            bufferedReader.mark(cArr.length);
+        }
+        throw new ParseException("Unexpected control character while reading string");
+    }
+
+    private final char zai(BufferedReader bufferedReader) throws ParseException, IOException {
+        if (bufferedReader.read(this.zao) != -1) {
+            while (Character.isWhitespace(this.zao[0])) {
+                if (bufferedReader.read(this.zao) == -1) {
+                }
+            }
+            return this.zao[0];
+        }
+        return (char) 0;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final double zaj(BufferedReader bufferedReader) throws ParseException, IOException {
+        int zam2 = zam(bufferedReader, this.zaq);
+        if (zam2 == 0) {
+            return 0.0d;
+        }
+        return Double.parseDouble(new String(this.zaq, 0, zam2));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final float zak(BufferedReader bufferedReader) throws ParseException, IOException {
+        int zam2 = zam(bufferedReader, this.zaq);
+        if (zam2 == 0) {
+            return 0.0f;
+        }
+        return Float.parseFloat(new String(this.zaq, 0, zam2));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final int zal(BufferedReader bufferedReader) throws ParseException, IOException {
+        int i;
+        int i2;
+        int zam2 = zam(bufferedReader, this.zaq);
+        if (zam2 == 0) {
+            return 0;
+        }
+        char[] cArr = this.zaq;
+        if (zam2 <= 0) {
+            throw new ParseException("No number to parse");
+        }
+        char c = cArr[0];
+        int i3 = c == '-' ? Integer.MIN_VALUE : -2147483647;
+        int i4 = c == '-' ? 1 : 0;
+        if (i4 < zam2) {
+            i2 = i4 + 1;
+            int digit = Character.digit(cArr[i4], 10);
+            if (digit < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            i = -digit;
+        } else {
+            i = 0;
+            i2 = i4;
+        }
+        while (i2 < zam2) {
+            int i5 = i2 + 1;
+            int digit2 = Character.digit(cArr[i2], 10);
+            if (digit2 < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            if (i < -214748364) {
+                throw new ParseException("Number too large");
+            }
+            int i6 = i * 10;
+            if (i6 < i3 + digit2) {
+                throw new ParseException("Number too large");
+            }
+            i = i6 - digit2;
+            i2 = i5;
+        }
+        if (i4 == 0) {
+            return -i;
+        }
+        if (i2 > 1) {
+            return i;
+        }
+        throw new ParseException("No digits to parse");
+    }
+
+    @ResultIgnorabilityUnspecified
+    private final int zam(BufferedReader bufferedReader, char[] cArr) throws ParseException, IOException {
+        int i;
+        char zai2 = zai(bufferedReader);
+        if (zai2 == 0) {
+            throw new ParseException("Unexpected EOF");
+        }
+        if (zai2 == ',') {
+            throw new ParseException("Missing value");
+        }
+        if (zai2 == 'n') {
+            zax(bufferedReader, zaa);
+            return 0;
+        }
+        bufferedReader.mark(1024);
+        if (zai2 == '\"') {
+            i = 0;
+            boolean z = false;
+            while (i < 1024 && bufferedReader.read(cArr, i, 1) != -1) {
+                char c = cArr[i];
+                if (Character.isISOControl(c)) {
+                    throw new ParseException("Unexpected control character while reading string");
+                }
+                int i2 = i + 1;
+                if (c == '\"') {
+                    if (!z) {
+                        bufferedReader.reset();
+                        bufferedReader.skip(i2);
+                        return i;
+                    }
+                } else if (c == '\\') {
+                    z = !z;
+                    i = i2;
+                }
+                z = false;
+                i = i2;
+            }
+        } else {
+            cArr[0] = zai2;
+            i = 1;
+            while (i < 1024 && bufferedReader.read(cArr, i, 1) != -1) {
+                char c2 = cArr[i];
+                if (c2 == '}' || c2 == ',' || Character.isWhitespace(c2) || cArr[i] == ']') {
+                    bufferedReader.reset();
+                    bufferedReader.skip(i - 1);
+                    cArr[i] = 0;
+                    return i;
+                }
+                i++;
+            }
+        }
+        if (i == 1024) {
+            throw new ParseException("Absurdly long value");
+        }
+        throw new ParseException("Unexpected EOF");
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final long zan(BufferedReader bufferedReader) throws ParseException, IOException {
+        long j;
+        int i;
+        int zam2 = zam(bufferedReader, this.zaq);
+        if (zam2 == 0) {
+            return 0L;
+        }
+        char[] cArr = this.zaq;
+        if (zam2 <= 0) {
+            throw new ParseException("No number to parse");
+        }
+        char c = cArr[0];
+        long j2 = c == '-' ? Long.MIN_VALUE : C.TIME_UNSET;
+        int i2 = c == '-' ? 1 : 0;
+        if (i2 < zam2) {
+            i = i2 + 1;
+            int digit = Character.digit(cArr[i2], 10);
+            if (digit < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            j = -digit;
+        } else {
+            j = 0;
+            i = i2;
+        }
+        while (i < zam2) {
+            int i3 = i + 1;
+            int digit2 = Character.digit(cArr[i], 10);
+            if (digit2 < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            if (j < -922337203685477580L) {
+                throw new ParseException("Number too large");
+            }
+            long j3 = j * 10;
+            int i4 = zam2;
+            long j4 = digit2;
+            if (j3 < j2 + j4) {
+                throw new ParseException("Number too large");
+            }
+            j = j3 - j4;
+            zam2 = i4;
+            i = i3;
+        }
+        if (i2 == 0) {
+            return -j;
+        }
+        if (i > 1) {
+            return j;
+        }
+        throw new ParseException("No digits to parse");
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @Nullable
+    public final String zao(BufferedReader bufferedReader) throws ParseException, IOException {
+        return zap(bufferedReader, this.zap, this.zar, null);
+    }
+
+    @Nullable
+    private final String zap(BufferedReader bufferedReader, char[] cArr, StringBuilder sb, @Nullable char[] cArr2) throws ParseException, IOException {
+        char zai2 = zai(bufferedReader);
+        if (zai2 == '\"') {
+            return zaA(bufferedReader, cArr, sb, cArr2);
+        }
+        if (zai2 != 'n') {
+            throw new ParseException("Expected string");
+        }
+        zax(bufferedReader, zaa);
+        return null;
+    }
+
+    @Nullable
+    @ResultIgnorabilityUnspecified
+    private final String zaq(BufferedReader bufferedReader) throws ParseException, IOException {
+        this.zat.push(2);
+        char zai2 = zai(bufferedReader);
+        if (zai2 == '\"') {
+            this.zat.push(3);
+            String zaA = zaA(bufferedReader, this.zap, this.zar, null);
+            zaw(3);
+            if (zai(bufferedReader) == ':') {
+                return zaA;
+            }
+            throw new ParseException("Expected key/value separator");
+        }
+        if (zai2 == ']') {
+            zaw(2);
+            zaw(1);
+            zaw(5);
+            return null;
+        }
+        if (zai2 == '}') {
+            zaw(2);
+            return null;
+        }
+        throw new ParseException("Unexpected token: " + zai2);
+    }
+
+    @Nullable
+    private final String zar(BufferedReader bufferedReader) throws ParseException, IOException {
+        bufferedReader.mark(1024);
+        char zai2 = zai(bufferedReader);
+        int i = 1;
+        if (zai2 == '\"') {
+            if (bufferedReader.read(this.zao) == -1) {
+                throw new ParseException("Unexpected EOF while parsing string");
+            }
+            char c = this.zao[0];
+            boolean z = false;
+            do {
+                if (c == '\"') {
+                    if (z) {
+                        c = '\"';
+                        z = true;
+                    }
+                }
+                z = c == '\\' ? !z : false;
+                if (bufferedReader.read(this.zao) == -1) {
+                    throw new ParseException("Unexpected EOF while parsing string");
+                }
+                c = this.zao[0];
+            } while (!Character.isISOControl(c));
+            throw new ParseException("Unexpected control character while reading string");
+        }
+        if (zai2 == ',') {
+            throw new ParseException("Missing value");
+        }
+        if (zai2 == '[') {
+            this.zat.push(5);
+            bufferedReader.mark(32);
+            if (zai(bufferedReader) == ']') {
+                zaw(5);
+            } else {
+                bufferedReader.reset();
+                boolean z2 = false;
+                boolean z3 = false;
+                while (i > 0) {
+                    char zai3 = zai(bufferedReader);
+                    if (zai3 == 0) {
+                        throw new ParseException("Unexpected EOF while parsing array");
+                    }
+                    if (Character.isISOControl(zai3)) {
+                        throw new ParseException("Unexpected control character while reading array");
+                    }
+                    if (zai3 == '\"') {
+                        if (!z3) {
+                            z2 = !z2;
+                        }
+                        zai3 = '\"';
+                    }
+                    if (zai3 == '[') {
+                        if (!z2) {
+                            i++;
+                        }
+                        zai3 = '[';
+                    }
+                    if (zai3 == ']' && !z2) {
+                        i--;
+                    }
+                    z3 = (zai3 == '\\' && z2) ? !z3 : false;
+                }
+                zaw(5);
+            }
+        } else if (zai2 != '{') {
+            bufferedReader.reset();
+            zam(bufferedReader, this.zaq);
+        } else {
+            this.zat.push(1);
+            bufferedReader.mark(32);
+            char zai4 = zai(bufferedReader);
+            if (zai4 == '}') {
+                zaw(1);
+            } else {
+                if (zai4 != '\"') {
+                    throw new ParseException("Unexpected token " + zai4);
+                }
+                bufferedReader.reset();
+                zaq(bufferedReader);
+                while (zar(bufferedReader) != null) {
+                }
+                zaw(1);
+            }
+        }
+        char zai5 = zai(bufferedReader);
+        if (zai5 == ',') {
+            zaw(2);
+            return zaq(bufferedReader);
+        }
+        if (zai5 == '}') {
+            zaw(2);
+            return null;
+        }
+        throw new ParseException("Unexpected token " + zai5);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @Nullable
+    public final BigDecimal zas(BufferedReader bufferedReader) throws ParseException, IOException {
+        int zam2 = zam(bufferedReader, this.zaq);
+        if (zam2 == 0) {
+            return null;
+        }
+        return new BigDecimal(new String(this.zaq, 0, zam2));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @Nullable
+    public final BigInteger zat(BufferedReader bufferedReader) throws ParseException, IOException {
+        int zam2 = zam(bufferedReader, this.zaq);
+        if (zam2 == 0) {
+            return null;
+        }
+        return new BigInteger(new String(this.zaq, 0, zam2));
+    }
+
+    @Nullable
+    private final ArrayList zau(BufferedReader bufferedReader, zai zaiVar) throws ParseException, IOException {
+        char zai2 = zai(bufferedReader);
+        if (zai2 == 'n') {
+            zax(bufferedReader, zaa);
+            return null;
+        }
+        if (zai2 != '[') {
+            throw new ParseException("Expected start of array");
+        }
+        this.zat.push(5);
+        ArrayList arrayList = new ArrayList();
+        while (true) {
+            bufferedReader.mark(1024);
+            char zai3 = zai(bufferedReader);
+            if (zai3 == 0) {
+                throw new ParseException("Unexpected EOF");
+            }
+            if (zai3 != ',') {
+                if (zai3 == ']') {
+                    zaw(5);
+                    return arrayList;
+                }
+                bufferedReader.reset();
+                arrayList.add(zaiVar.zaa(this, bufferedReader));
+            }
+        }
+    }
+
+    @Nullable
+    private final ArrayList zav(BufferedReader bufferedReader, FastJsonResponse.Field field) throws ParseException, IOException {
+        ArrayList arrayList = new ArrayList();
+        char zai2 = zai(bufferedReader);
+        if (zai2 == ']') {
+            zaw(5);
+            return arrayList;
+        }
+        if (zai2 == 'n') {
+            zax(bufferedReader, zaa);
+            zaw(5);
+            return null;
+        }
+        if (zai2 != '{') {
+            throw new ParseException("Unexpected token: " + zai2);
+        }
+        this.zat.push(1);
+        while (true) {
+            try {
+                FastJsonResponse zad2 = field.zad();
+                if (!zaz(bufferedReader, zad2)) {
+                    return arrayList;
+                }
+                arrayList.add(zad2);
+                char zai3 = zai(bufferedReader);
+                if (zai3 != ',') {
+                    if (zai3 == ']') {
+                        zaw(5);
+                        return arrayList;
+                    }
+                    throw new ParseException("Unexpected token: " + zai3);
+                }
+                if (zai(bufferedReader) != '{') {
+                    throw new ParseException("Expected start of next object in array");
+                }
+                this.zat.push(1);
+            } catch (IllegalAccessException e) {
+                throw new ParseException("Error instantiating inner object", e);
+            } catch (InstantiationException e2) {
+                throw new ParseException("Error instantiating inner object", e2);
+            }
+        }
+    }
+
+    private final void zaw(int i) throws ParseException {
+        if (this.zat.isEmpty()) {
+            throw new ParseException("Expected state " + i + " but had empty stack");
+        }
+        int intValue = ((Integer) this.zat.pop()).intValue();
+        if (intValue == i) {
+            return;
+        }
+        throw new ParseException("Expected state " + i + " but had " + intValue);
+    }
+
+    private final void zax(BufferedReader bufferedReader, char[] cArr) throws ParseException, IOException {
+        int i = 0;
+        while (true) {
+            int length = cArr.length;
+            if (i >= length) {
+                return;
+            }
+            int read = bufferedReader.read(this.zap, 0, length - i);
+            if (read == -1) {
+                throw new ParseException("Unexpected EOF");
+            }
+            for (int i2 = 0; i2 < read; i2++) {
+                if (cArr[i2 + i] != this.zap[i2]) {
+                    throw new ParseException("Unexpected character");
+                }
+            }
+            i += read;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final boolean zay(BufferedReader bufferedReader, boolean z) throws ParseException, IOException {
+        char zai2 = zai(bufferedReader);
+        if (zai2 == '\"') {
+            if (z) {
+                throw new ParseException("No boolean value found in string");
+            }
+            return zay(bufferedReader, true);
+        }
+        if (zai2 == 'f') {
+            zax(bufferedReader, z ? zae : zad);
+            return false;
+        }
+        if (zai2 == 'n') {
+            zax(bufferedReader, zaa);
+            return false;
+        }
+        if (zai2 == 't') {
+            zax(bufferedReader, z ? zac : zab);
+            return true;
+        }
+        throw new ParseException("Unexpected token: " + zai2);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:17:0x027b A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x025f A[SYNTHETIC] */
+    @com.google.errorprone.annotations.ResultIgnorabilityUnspecified
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private final boolean zaz(java.io.BufferedReader r17, com.google.android.gms.common.server.response.FastJsonResponse r18) throws com.google.android.gms.common.server.response.FastParser.ParseException, java.io.IOException {
+        /*
+            Method dump skipped, instructions count: 678
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.server.response.FastParser.zaz(java.io.BufferedReader, com.google.android.gms.common.server.response.FastJsonResponse):boolean");
+    }
+
+    @KeepForSdk
+    public void parse(@NonNull InputStream inputStream, @NonNull T t) throws ParseException {
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream), 1024);
+        try {
+            try {
+                this.zat.push(0);
+                char zai2 = zai(bufferedReader);
+                if (zai2 == 0) {
+                    throw new ParseException("No data to parse");
+                }
+                if (zai2 == '[') {
+                    this.zat.push(5);
+                    Map<String, FastJsonResponse.Field<?, ?>> fieldMappings = t.getFieldMappings();
+                    if (fieldMappings.size() != 1) {
+                        throw new ParseException("Object array response class must have a single Field");
+                    }
+                    FastJsonResponse.Field<?, ?> value = fieldMappings.entrySet().iterator().next().getValue();
+                    t.addConcreteTypeArrayInternal(value, value.zae, zav(bufferedReader, value));
+                } else {
+                    if (zai2 != '{') {
+                        throw new ParseException("Unexpected token: " + zai2);
+                    }
+                    this.zat.push(1);
+                    zaz(bufferedReader, t);
+                }
+                zaw(0);
+                try {
+                    bufferedReader.close();
+                } catch (IOException unused) {
+                    Log.w("FastParser", "Failed to close reader while parsing.");
+                }
+            } catch (IOException e) {
+                throw new ParseException(e);
+            }
+        } catch (Throwable th) {
+            try {
+                bufferedReader.close();
+            } catch (IOException unused2) {
+                Log.w("FastParser", "Failed to close reader while parsing.");
+            }
+            throw th;
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/FastSafeParcelableJsonResponse.java

@@ -0,0 +1,81 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class FastSafeParcelableJsonResponse extends FastJsonResponse implements SafeParcelable {
+    @KeepForSdk
+    public FastSafeParcelableJsonResponse() {
+    }
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    @KeepForSdk
+    public boolean equals(@Nullable Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (this == obj) {
+            return true;
+        }
+        if (!getClass().isInstance(obj)) {
+            return false;
+        }
+        FastJsonResponse fastJsonResponse = (FastJsonResponse) obj;
+        for (FastJsonResponse.Field<?, ?> field : getFieldMappings().values()) {
+            if (isFieldSet(field)) {
+                if (!fastJsonResponse.isFieldSet(field) || !Objects.equal(getFieldValue(field), fastJsonResponse.getFieldValue(field))) {
+                    return false;
+                }
+            } else if (fastJsonResponse.isFieldSet(field)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    @Nullable
+    public Object getValueObject(@NonNull String str) {
+        return null;
+    }
+
+    @KeepForSdk
+    public int hashCode() {
+        int i = 0;
+        for (FastJsonResponse.Field<?, ?> field : getFieldMappings().values()) {
+            if (isFieldSet(field)) {
+                i = (i * 31) + Preconditions.checkNotNull(getFieldValue(field)).hashCode();
+            }
+        }
+        return i;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public boolean isPrimitiveFieldSet(@NonNull String str) {
+        return false;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public byte[] toByteArray() {
+        Parcel obtain = Parcel.obtain();
+        writeToParcel(obtain, 0);
+        byte[] marshall = obtain.marshall();
+        obtain.recycle();
+        return marshall;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/SafeParcelResponse.java

@@ -0,0 +1,603 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.SparseArray;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+import com.google.android.gms.common.util.ArrayUtils;
+import com.google.android.gms.common.util.Base64Utils;
+import com.google.android.gms.common.util.JsonUtils;
+import com.google.android.gms.common.util.MapUtils;
+import com.ironsource.v8;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+@KeepForSdk
+@SafeParcelable.Class(creator = "SafeParcelResponseCreator")
+/* loaded from: classes2.dex */
+public class SafeParcelResponse extends FastSafeParcelableJsonResponse {
+
+    @NonNull
+    @KeepForSdk
+    public static final Parcelable.Creator<SafeParcelResponse> CREATOR = new zaq();
+
+    @SafeParcelable.VersionField(getter = "getVersionCode", id = 1)
+    private final int zaa;
+
+    @SafeParcelable.Field(getter = "getParcel", id = 2)
+    private final Parcel zab;
+    private final int zac;
+
+    @SafeParcelable.Field(getter = "getFieldMappingDictionary", id = 3)
+    private final zan zad;
+
+    @Nullable
+    private final String zae;
+    private int zaf;
+    private int zag;
+
+    @SafeParcelable.Constructor
+    public SafeParcelResponse(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) Parcel parcel, @SafeParcelable.Param(id = 3) zan zanVar) {
+        this.zaa = i;
+        this.zab = (Parcel) Preconditions.checkNotNull(parcel);
+        this.zac = 2;
+        this.zad = zanVar;
+        this.zae = zanVar == null ? null : zanVar.zaa();
+        this.zaf = 2;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T extends FastJsonResponse & SafeParcelable> SafeParcelResponse from(@NonNull T t) {
+        String str = (String) Preconditions.checkNotNull(t.getClass().getCanonicalName());
+        zan zanVar = new zan(t.getClass());
+        zaF(zanVar, t);
+        zanVar.zac();
+        zanVar.zad();
+        return new SafeParcelResponse(t, zanVar, str);
+    }
+
+    private static void zaF(zan zanVar, FastJsonResponse fastJsonResponse) {
+        Class<?> cls = fastJsonResponse.getClass();
+        if (zanVar.zaf(cls)) {
+            return;
+        }
+        Map<String, FastJsonResponse.Field<?, ?>> fieldMappings = fastJsonResponse.getFieldMappings();
+        zanVar.zae(cls, fieldMappings);
+        Iterator<String> it = fieldMappings.keySet().iterator();
+        while (it.hasNext()) {
+            FastJsonResponse.Field<?, ?> field = fieldMappings.get(it.next());
+            Class cls2 = field.zag;
+            if (cls2 != null) {
+                try {
+                    zaF(zanVar, (FastJsonResponse) cls2.newInstance());
+                } catch (IllegalAccessException e) {
+                    throw new IllegalStateException("Could not access object of type ".concat(String.valueOf(((Class) Preconditions.checkNotNull(field.zag)).getCanonicalName())), e);
+                } catch (InstantiationException e2) {
+                    throw new IllegalStateException("Could not instantiate an object of type ".concat(String.valueOf(((Class) Preconditions.checkNotNull(field.zag)).getCanonicalName())), e2);
+                }
+            }
+        }
+    }
+
+    private final void zaH(StringBuilder sb, Map map, Parcel parcel) {
+        SparseArray sparseArray = new SparseArray();
+        for (Map.Entry entry : map.entrySet()) {
+            sparseArray.put(((FastJsonResponse.Field) entry.getValue()).getSafeParcelableFieldId(), entry);
+        }
+        sb.append('{');
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        boolean z = false;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            Map.Entry entry2 = (Map.Entry) sparseArray.get(SafeParcelReader.getFieldId(readHeader));
+            if (entry2 != null) {
+                if (z) {
+                    sb.append(",");
+                }
+                String str = (String) entry2.getKey();
+                FastJsonResponse.Field field = (FastJsonResponse.Field) entry2.getValue();
+                sb.append("\"");
+                sb.append(str);
+                sb.append("\":");
+                if (field.zaj()) {
+                    int i = field.zac;
+                    switch (i) {
+                        case 0:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, Integer.valueOf(SafeParcelReader.readInt(parcel, readHeader))));
+                            break;
+                        case 1:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, SafeParcelReader.createBigInteger(parcel, readHeader)));
+                            break;
+                        case 2:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, Long.valueOf(SafeParcelReader.readLong(parcel, readHeader))));
+                            break;
+                        case 3:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, Float.valueOf(SafeParcelReader.readFloat(parcel, readHeader))));
+                            break;
+                        case 4:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, Double.valueOf(SafeParcelReader.readDouble(parcel, readHeader))));
+                            break;
+                        case 5:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, SafeParcelReader.createBigDecimal(parcel, readHeader)));
+                            break;
+                        case 6:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, Boolean.valueOf(SafeParcelReader.readBoolean(parcel, readHeader))));
+                            break;
+                        case 7:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, SafeParcelReader.createString(parcel, readHeader)));
+                            break;
+                        case 8:
+                        case 9:
+                            zaJ(sb, field, FastJsonResponse.zaD(field, SafeParcelReader.createByteArray(parcel, readHeader)));
+                            break;
+                        case 10:
+                            Bundle createBundle = SafeParcelReader.createBundle(parcel, readHeader);
+                            HashMap hashMap = new HashMap();
+                            for (String str2 : createBundle.keySet()) {
+                                hashMap.put(str2, (String) Preconditions.checkNotNull(createBundle.getString(str2)));
+                            }
+                            zaJ(sb, field, FastJsonResponse.zaD(field, hashMap));
+                            break;
+                        case 11:
+                            throw new IllegalArgumentException("Method does not accept concrete type.");
+                        default:
+                            throw new IllegalArgumentException("Unknown field out type = " + i);
+                    }
+                } else if (field.zad) {
+                    sb.append(v8.i.d);
+                    switch (field.zac) {
+                        case 0:
+                            ArrayUtils.writeArray(sb, SafeParcelReader.createIntArray(parcel, readHeader));
+                            break;
+                        case 1:
+                            ArrayUtils.writeArray(sb, SafeParcelReader.createBigIntegerArray(parcel, readHeader));
+                            break;
+                        case 2:
+                            ArrayUtils.writeArray(sb, SafeParcelReader.createLongArray(parcel, readHeader));
+                            break;
+                        case 3:
+                            ArrayUtils.writeArray(sb, SafeParcelReader.createFloatArray(parcel, readHeader));
+                            break;
+                        case 4:
+                            ArrayUtils.writeArray(sb, SafeParcelReader.createDoubleArray(parcel, readHeader));
+                            break;
+                        case 5:
+                            ArrayUtils.writeArray(sb, SafeParcelReader.createBigDecimalArray(parcel, readHeader));
+                            break;
+                        case 6:
+                            ArrayUtils.writeArray(sb, SafeParcelReader.createBooleanArray(parcel, readHeader));
+                            break;
+                        case 7:
+                            ArrayUtils.writeStringArray(sb, SafeParcelReader.createStringArray(parcel, readHeader));
+                            break;
+                        case 8:
+                        case 9:
+                        case 10:
+                            throw new UnsupportedOperationException("List of type BASE64, BASE64_URL_SAFE, or STRING_MAP is not supported");
+                        case 11:
+                            Parcel[] createParcelArray = SafeParcelReader.createParcelArray(parcel, readHeader);
+                            int length = createParcelArray.length;
+                            for (int i2 = 0; i2 < length; i2++) {
+                                if (i2 > 0) {
+                                    sb.append(",");
+                                }
+                                createParcelArray[i2].setDataPosition(0);
+                                zaH(sb, field.zah(), createParcelArray[i2]);
+                            }
+                            break;
+                        default:
+                            throw new IllegalStateException("Unknown field type out.");
+                    }
+                    sb.append(v8.i.e);
+                } else {
+                    switch (field.zac) {
+                        case 0:
+                            sb.append(SafeParcelReader.readInt(parcel, readHeader));
+                            break;
+                        case 1:
+                            sb.append(SafeParcelReader.createBigInteger(parcel, readHeader));
+                            break;
+                        case 2:
+                            sb.append(SafeParcelReader.readLong(parcel, readHeader));
+                            break;
+                        case 3:
+                            sb.append(SafeParcelReader.readFloat(parcel, readHeader));
+                            break;
+                        case 4:
+                            sb.append(SafeParcelReader.readDouble(parcel, readHeader));
+                            break;
+                        case 5:
+                            sb.append(SafeParcelReader.createBigDecimal(parcel, readHeader));
+                            break;
+                        case 6:
+                            sb.append(SafeParcelReader.readBoolean(parcel, readHeader));
+                            break;
+                        case 7:
+                            String createString = SafeParcelReader.createString(parcel, readHeader);
+                            sb.append("\"");
+                            sb.append(JsonUtils.escapeString(createString));
+                            sb.append("\"");
+                            break;
+                        case 8:
+                            byte[] createByteArray = SafeParcelReader.createByteArray(parcel, readHeader);
+                            sb.append("\"");
+                            sb.append(Base64Utils.encode(createByteArray));
+                            sb.append("\"");
+                            break;
+                        case 9:
+                            byte[] createByteArray2 = SafeParcelReader.createByteArray(parcel, readHeader);
+                            sb.append("\"");
+                            sb.append(Base64Utils.encodeUrlSafe(createByteArray2));
+                            sb.append("\"");
+                            break;
+                        case 10:
+                            Bundle createBundle2 = SafeParcelReader.createBundle(parcel, readHeader);
+                            Set<String> keySet = createBundle2.keySet();
+                            sb.append("{");
+                            boolean z2 = true;
+                            for (String str3 : keySet) {
+                                if (!z2) {
+                                    sb.append(",");
+                                }
+                                sb.append("\"");
+                                sb.append(str3);
+                                sb.append("\":\"");
+                                sb.append(JsonUtils.escapeString(createBundle2.getString(str3)));
+                                sb.append("\"");
+                                z2 = false;
+                            }
+                            sb.append("}");
+                            break;
+                        case 11:
+                            Parcel createParcel = SafeParcelReader.createParcel(parcel, readHeader);
+                            createParcel.setDataPosition(0);
+                            zaH(sb, field.zah(), createParcel);
+                            break;
+                        default:
+                            throw new IllegalStateException("Unknown field type out");
+                    }
+                }
+                z = true;
+            }
+        }
+        if (parcel.dataPosition() == validateObjectHeader) {
+            sb.append('}');
+            return;
+        }
+        throw new SafeParcelReader.ParseException("Overread allowed size end=" + validateObjectHeader, parcel);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final <T extends FastJsonResponse> void addConcreteTypeArrayInternal(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList<T> arrayList) {
+        zaG(field);
+        ArrayList arrayList2 = new ArrayList();
+        ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            arrayList2.add(((SafeParcelResponse) arrayList.get(i)).zaE());
+        }
+        SafeParcelWriter.writeParcelList(this.zab, field.getSafeParcelableFieldId(), arrayList2, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final <T extends FastJsonResponse> void addConcreteTypeInternal(@NonNull FastJsonResponse.Field field, @NonNull String str, @NonNull T t) {
+        zaG(field);
+        SafeParcelWriter.writeParcel(this.zab, field.getSafeParcelableFieldId(), ((SafeParcelResponse) t).zaE(), true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    @Nullable
+    public final Map<String, FastJsonResponse.Field<?, ?>> getFieldMappings() {
+        zan zanVar = this.zad;
+        if (zanVar == null) {
+            return null;
+        }
+        return zanVar.zab((String) Preconditions.checkNotNull(this.zae));
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastSafeParcelableJsonResponse, com.google.android.gms.common.server.response.FastJsonResponse
+    @NonNull
+    public final Object getValueObject(@NonNull String str) {
+        throw new UnsupportedOperationException("Converting to JSON does not require this method.");
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastSafeParcelableJsonResponse, com.google.android.gms.common.server.response.FastJsonResponse
+    public final boolean isPrimitiveFieldSet(@NonNull String str) {
+        throw new UnsupportedOperationException("Converting to JSON does not require this method.");
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setBooleanInternal(@NonNull FastJsonResponse.Field<?, ?> field, @NonNull String str, boolean z) {
+        zaG(field);
+        SafeParcelWriter.writeBoolean(this.zab, field.getSafeParcelableFieldId(), z);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setDecodedBytesInternal(@NonNull FastJsonResponse.Field<?, ?> field, @NonNull String str, @Nullable byte[] bArr) {
+        zaG(field);
+        SafeParcelWriter.writeByteArray(this.zab, field.getSafeParcelableFieldId(), bArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setIntegerInternal(@NonNull FastJsonResponse.Field<?, ?> field, @NonNull String str, int i) {
+        zaG(field);
+        SafeParcelWriter.writeInt(this.zab, field.getSafeParcelableFieldId(), i);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setLongInternal(@NonNull FastJsonResponse.Field<?, ?> field, @NonNull String str, long j) {
+        zaG(field);
+        SafeParcelWriter.writeLong(this.zab, field.getSafeParcelableFieldId(), j);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setStringInternal(@NonNull FastJsonResponse.Field<?, ?> field, @NonNull String str, @Nullable String str2) {
+        zaG(field);
+        SafeParcelWriter.writeString(this.zab, field.getSafeParcelableFieldId(), str2, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setStringMapInternal(@NonNull FastJsonResponse.Field<?, ?> field, @NonNull String str, @Nullable Map<String, String> map) {
+        zaG(field);
+        Bundle bundle = new Bundle();
+        for (String str2 : ((Map) Preconditions.checkNotNull(map)).keySet()) {
+            bundle.putString(str2, map.get(str2));
+        }
+        SafeParcelWriter.writeBundle(this.zab, field.getSafeParcelableFieldId(), bundle, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setStringsInternal(@NonNull FastJsonResponse.Field<?, ?> field, @NonNull String str, @Nullable ArrayList<String> arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        String[] strArr = new String[size];
+        for (int i = 0; i < size; i++) {
+            strArr[i] = arrayList.get(i);
+        }
+        SafeParcelWriter.writeStringArray(this.zab, field.getSafeParcelableFieldId(), strArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    @NonNull
+    public final String toString() {
+        Preconditions.checkNotNull(this.zad, "Cannot convert to JSON on client side.");
+        Parcel zaE = zaE();
+        zaE.setDataPosition(0);
+        StringBuilder sb = new StringBuilder(100);
+        zaH(sb, (Map) Preconditions.checkNotNull(this.zad.zab((String) Preconditions.checkNotNull(this.zae))), zaE);
+        return sb.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(@NonNull Parcel parcel, int i) {
+        int i2 = this.zaa;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        SafeParcelWriter.writeParcel(parcel, 2, zaE(), false);
+        int i3 = this.zac;
+        SafeParcelWriter.writeParcelable(parcel, 3, i3 != 0 ? i3 != 1 ? this.zad : this.zad : null, i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    @NonNull
+    public final Parcel zaE() {
+        int i = this.zaf;
+        if (i == 0) {
+            int beginObjectHeader = SafeParcelWriter.beginObjectHeader(this.zab);
+            this.zag = beginObjectHeader;
+            SafeParcelWriter.finishObjectHeader(this.zab, beginObjectHeader);
+            this.zaf = 2;
+        } else if (i == 1) {
+            SafeParcelWriter.finishObjectHeader(this.zab, this.zag);
+            this.zaf = 2;
+        }
+        return this.zab;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zab(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable BigDecimal bigDecimal) {
+        zaG(field);
+        SafeParcelWriter.writeBigDecimal(this.zab, field.getSafeParcelableFieldId(), bigDecimal, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zad(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        BigDecimal[] bigDecimalArr = new BigDecimal[size];
+        for (int i = 0; i < size; i++) {
+            bigDecimalArr[i] = (BigDecimal) arrayList.get(i);
+        }
+        SafeParcelWriter.writeBigDecimalArray(this.zab, field.getSafeParcelableFieldId(), bigDecimalArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zaf(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable BigInteger bigInteger) {
+        zaG(field);
+        SafeParcelWriter.writeBigInteger(this.zab, field.getSafeParcelableFieldId(), bigInteger, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zah(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        BigInteger[] bigIntegerArr = new BigInteger[size];
+        for (int i = 0; i < size; i++) {
+            bigIntegerArr[i] = (BigInteger) arrayList.get(i);
+        }
+        SafeParcelWriter.writeBigIntegerArray(this.zab, field.getSafeParcelableFieldId(), bigIntegerArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zak(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        boolean[] zArr = new boolean[size];
+        for (int i = 0; i < size; i++) {
+            zArr[i] = ((Boolean) arrayList.get(i)).booleanValue();
+        }
+        SafeParcelWriter.writeBooleanArray(this.zab, field.getSafeParcelableFieldId(), zArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zan(@NonNull FastJsonResponse.Field field, @NonNull String str, double d) {
+        zaG(field);
+        SafeParcelWriter.writeDouble(this.zab, field.getSafeParcelableFieldId(), d);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zap(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        double[] dArr = new double[size];
+        for (int i = 0; i < size; i++) {
+            dArr[i] = ((Double) arrayList.get(i)).doubleValue();
+        }
+        SafeParcelWriter.writeDoubleArray(this.zab, field.getSafeParcelableFieldId(), dArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zar(@NonNull FastJsonResponse.Field field, @NonNull String str, float f) {
+        zaG(field);
+        SafeParcelWriter.writeFloat(this.zab, field.getSafeParcelableFieldId(), f);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zat(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        float[] fArr = new float[size];
+        for (int i = 0; i < size; i++) {
+            fArr[i] = ((Float) arrayList.get(i)).floatValue();
+        }
+        SafeParcelWriter.writeFloatArray(this.zab, field.getSafeParcelableFieldId(), fArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zaw(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        int[] iArr = new int[size];
+        for (int i = 0; i < size; i++) {
+            iArr[i] = ((Integer) arrayList.get(i)).intValue();
+        }
+        SafeParcelWriter.writeIntArray(this.zab, field.getSafeParcelableFieldId(), iArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zaz(@NonNull FastJsonResponse.Field field, @NonNull String str, @Nullable ArrayList arrayList) {
+        zaG(field);
+        int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
+        long[] jArr = new long[size];
+        for (int i = 0; i < size; i++) {
+            jArr[i] = ((Long) arrayList.get(i)).longValue();
+        }
+        SafeParcelWriter.writeLongArray(this.zab, field.getSafeParcelableFieldId(), jArr, true);
+    }
+
+    private SafeParcelResponse(SafeParcelable safeParcelable, zan zanVar, String str) {
+        this.zaa = 1;
+        Parcel obtain = Parcel.obtain();
+        this.zab = obtain;
+        safeParcelable.writeToParcel(obtain, 0);
+        this.zac = 1;
+        this.zad = (zan) Preconditions.checkNotNull(zanVar);
+        this.zae = (String) Preconditions.checkNotNull(str);
+        this.zaf = 2;
+    }
+
+    private final void zaG(FastJsonResponse.Field field) {
+        if (field.zaf == -1) {
+            throw new IllegalStateException("Field does not have a valid safe parcelable field id.");
+        }
+        Parcel parcel = this.zab;
+        if (parcel == null) {
+            throw new IllegalStateException("Internal Parcel object is null.");
+        }
+        int i = this.zaf;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("Attempted to parse JSON with a SafeParcelResponse object that is already filled with data.");
+            }
+        } else {
+            this.zag = SafeParcelWriter.beginObjectHeader(parcel);
+            this.zaf = 1;
+        }
+    }
+
+    private static final void zaJ(StringBuilder sb, FastJsonResponse.Field field, Object obj) {
+        if (!field.zab) {
+            zaI(sb, field.zaa, obj);
+            return;
+        }
+        ArrayList arrayList = (ArrayList) obj;
+        sb.append(v8.i.d);
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            zaI(sb, field.zaa, arrayList.get(i));
+        }
+        sb.append(v8.i.e);
+    }
+
+    public SafeParcelResponse(zan zanVar, String str) {
+        this.zaa = 1;
+        this.zab = Parcel.obtain();
+        this.zac = 0;
+        this.zad = (zan) Preconditions.checkNotNull(zanVar);
+        this.zae = (String) Preconditions.checkNotNull(str);
+        this.zaf = 0;
+    }
+
+    private static final void zaI(StringBuilder sb, int i, @Nullable Object obj) {
+        switch (i) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+                sb.append(obj);
+                return;
+            case 7:
+                sb.append("\"");
+                sb.append(JsonUtils.escapeString(Preconditions.checkNotNull(obj).toString()));
+                sb.append("\"");
+                return;
+            case 8:
+                sb.append("\"");
+                sb.append(Base64Utils.encode((byte[]) obj));
+                sb.append("\"");
+                return;
+            case 9:
+                sb.append("\"");
+                sb.append(Base64Utils.encodeUrlSafe((byte[]) obj));
+                sb.append("\"");
+                return;
+            case 10:
+                MapUtils.writeStringMapToJson(sb, (HashMap) Preconditions.checkNotNull(obj));
+                return;
+            case 11:
+                throw new IllegalArgumentException("Method does not accept concrete type.");
+            default:
+                throw new IllegalArgumentException("Unknown type = " + i);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zaa.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+final class zaa implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        int zal;
+        zal = fastParser.zal(bufferedReader);
+        return Integer.valueOf(zal);
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zab.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+final class zab implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        long zan;
+        zan = fastParser.zan(bufferedReader);
+        return Long.valueOf(zan);
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zac.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+final class zac implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        float zak;
+        zak = fastParser.zak(bufferedReader);
+        return Float.valueOf(zak);
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zad.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+final class zad implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        double zaj;
+        zaj = fastParser.zaj(bufferedReader);
+        return Double.valueOf(zaj);
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zae.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+final class zae implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* bridge */ /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        boolean zay;
+        zay = fastParser.zay(bufferedReader, false);
+        return Boolean.valueOf(zay);
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zaf.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+final class zaf implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        String zao;
+        zao = fastParser.zao(bufferedReader);
+        return zao;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zag.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/* loaded from: classes2.dex */
+final class zag implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        BigInteger zat;
+        zat = fastParser.zat(bufferedReader);
+        return zat;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zah.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.math.BigDecimal;
+
+/* loaded from: classes2.dex */
+final class zah implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    @Nullable
+    public final /* synthetic */ Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException {
+        BigDecimal zas;
+        zas = fastParser.zas(bufferedReader);
+        return zas;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zai.java

@@ -0,0 +1,12 @@
+package com.google.android.gms.common.server.response;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+interface zai {
+    @Nullable
+    Object zaa(FastParser fastParser, BufferedReader bufferedReader) throws FastParser.ParseException, IOException;
+}

decompiled/sources/com/google/android/gms/common/server/response/zaj.java

@@ -0,0 +1,65 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+/* loaded from: classes2.dex */
+public final class zaj implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        String str = null;
+        String str2 = null;
+        com.google.android.gms.common.server.converter.zaa zaaVar = null;
+        int i = 0;
+        int i2 = 0;
+        boolean z = false;
+        int i3 = 0;
+        boolean z2 = false;
+        int i4 = 0;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            switch (SafeParcelReader.getFieldId(readHeader)) {
+                case 1:
+                    i = SafeParcelReader.readInt(parcel, readHeader);
+                    break;
+                case 2:
+                    i2 = SafeParcelReader.readInt(parcel, readHeader);
+                    break;
+                case 3:
+                    z = SafeParcelReader.readBoolean(parcel, readHeader);
+                    break;
+                case 4:
+                    i3 = SafeParcelReader.readInt(parcel, readHeader);
+                    break;
+                case 5:
+                    z2 = SafeParcelReader.readBoolean(parcel, readHeader);
+                    break;
+                case 6:
+                    str = SafeParcelReader.createString(parcel, readHeader);
+                    break;
+                case 7:
+                    i4 = SafeParcelReader.readInt(parcel, readHeader);
+                    break;
+                case 8:
+                    str2 = SafeParcelReader.createString(parcel, readHeader);
+                    break;
+                case 9:
+                    zaaVar = (com.google.android.gms.common.server.converter.zaa) SafeParcelReader.createParcelable(parcel, readHeader, com.google.android.gms.common.server.converter.zaa.CREATOR);
+                    break;
+                default:
+                    SafeParcelReader.skipUnknownField(parcel, readHeader);
+                    break;
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new FastJsonResponse.Field(i, i2, z, i3, z2, str, i4, str2, zaaVar);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new FastJsonResponse.Field[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zak.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+/* loaded from: classes2.dex */
+public final class zak implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        String str = null;
+        int i = 0;
+        FastJsonResponse.Field field = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 2) {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId != 3) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                field = (FastJsonResponse.Field) SafeParcelReader.createParcelable(parcel, readHeader, FastJsonResponse.Field.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new zam(i, str, field);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new zam[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zal.java

@@ -0,0 +1,61 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+import java.util.ArrayList;
+import java.util.Map;
+
+@ShowFirstParty
+@SafeParcelable.Class(creator = "FieldMappingDictionaryEntryCreator")
+/* loaded from: classes2.dex */
+public final class zal extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zal> CREATOR = new zap();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+
+    @SafeParcelable.Field(id = 2)
+    final String zab;
+
+    @Nullable
+    @SafeParcelable.Field(id = 3)
+    final ArrayList zac;
+
+    @SafeParcelable.Constructor
+    public zal(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) String str, @SafeParcelable.Param(id = 3) ArrayList arrayList) {
+        this.zaa = i;
+        this.zab = str;
+        this.zac = arrayList;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int i2 = this.zaa;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        SafeParcelWriter.writeString(parcel, 2, this.zab, false);
+        SafeParcelWriter.writeTypedList(parcel, 3, this.zac, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public zal(String str, Map map) {
+        ArrayList arrayList;
+        this.zaa = 1;
+        this.zab = str;
+        if (map == null) {
+            arrayList = null;
+        } else {
+            arrayList = new ArrayList();
+            for (String str2 : map.keySet()) {
+                arrayList.add(new zam(str2, (FastJsonResponse.Field) map.get(str2)));
+            }
+        }
+        this.zac = arrayList;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zam.java

@@ -0,0 +1,48 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+@ShowFirstParty
+@SafeParcelable.Class(creator = "FieldMapPairCreator")
+/* loaded from: classes2.dex */
+public final class zam extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zam> CREATOR = new zak();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+
+    @SafeParcelable.Field(id = 2)
+    final String zab;
+
+    @SafeParcelable.Field(id = 3)
+    final FastJsonResponse.Field zac;
+
+    @SafeParcelable.Constructor
+    public zam(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) String str, @SafeParcelable.Param(id = 3) FastJsonResponse.Field field) {
+        this.zaa = i;
+        this.zab = str;
+        this.zac = field;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int i2 = this.zaa;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        SafeParcelWriter.writeString(parcel, 2, this.zab, false);
+        SafeParcelWriter.writeParcelable(parcel, 3, this.zac, i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public zam(String str, FastJsonResponse.Field field) {
+        this.zaa = 1;
+        this.zab = str;
+        this.zac = field;
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zan.java

@@ -0,0 +1,124 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+@ShowFirstParty
+@SafeParcelable.Class(creator = "FieldMappingDictionaryCreator")
+/* loaded from: classes2.dex */
+public final class zan extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zan> CREATOR = new zao();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+    private final HashMap zab;
+
+    @SafeParcelable.Field(getter = "getRootClassName", id = 3)
+    private final String zac;
+
+    @SafeParcelable.Constructor
+    public zan(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) ArrayList arrayList, @SafeParcelable.Param(id = 3) String str) {
+        this.zaa = i;
+        HashMap hashMap = new HashMap();
+        int size = arrayList.size();
+        for (int i2 = 0; i2 < size; i2++) {
+            zal zalVar = (zal) arrayList.get(i2);
+            String str2 = zalVar.zab;
+            HashMap hashMap2 = new HashMap();
+            int size2 = ((ArrayList) Preconditions.checkNotNull(zalVar.zac)).size();
+            for (int i3 = 0; i3 < size2; i3++) {
+                zam zamVar = (zam) zalVar.zac.get(i3);
+                hashMap2.put(zamVar.zab, zamVar.zac);
+            }
+            hashMap.put(str2, hashMap2);
+        }
+        this.zab = hashMap;
+        this.zac = (String) Preconditions.checkNotNull(str);
+        zad();
+    }
+
+    public final String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (String str : this.zab.keySet()) {
+            sb.append(str);
+            sb.append(":\n");
+            Map map = (Map) this.zab.get(str);
+            for (String str2 : map.keySet()) {
+                sb.append("  ");
+                sb.append(str2);
+                sb.append(": ");
+                sb.append(map.get(str2));
+            }
+        }
+        return sb.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        ArrayList arrayList = new ArrayList();
+        for (String str : this.zab.keySet()) {
+            arrayList.add(new zal(str, (Map) this.zab.get(str)));
+        }
+        SafeParcelWriter.writeTypedList(parcel, 2, arrayList, false);
+        SafeParcelWriter.writeString(parcel, 3, this.zac, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public final String zaa() {
+        return this.zac;
+    }
+
+    @Nullable
+    public final Map zab(String str) {
+        return (Map) this.zab.get(str);
+    }
+
+    public final void zac() {
+        for (String str : this.zab.keySet()) {
+            Map map = (Map) this.zab.get(str);
+            HashMap hashMap = new HashMap();
+            for (String str2 : map.keySet()) {
+                hashMap.put(str2, ((FastJsonResponse.Field) map.get(str2)).zab());
+            }
+            this.zab.put(str, hashMap);
+        }
+    }
+
+    public final void zad() {
+        Iterator it = this.zab.keySet().iterator();
+        while (it.hasNext()) {
+            Map map = (Map) this.zab.get((String) it.next());
+            Iterator it2 = map.keySet().iterator();
+            while (it2.hasNext()) {
+                ((FastJsonResponse.Field) map.get((String) it2.next())).zai(this);
+            }
+        }
+    }
+
+    public final void zae(Class cls, Map map) {
+        this.zab.put((String) Preconditions.checkNotNull(cls.getCanonicalName()), map);
+    }
+
+    public final boolean zaf(Class cls) {
+        return this.zab.containsKey(Preconditions.checkNotNull(cls.getCanonicalName()));
+    }
+
+    public zan(Class cls) {
+        this.zaa = 1;
+        this.zab = new HashMap();
+        this.zac = (String) Preconditions.checkNotNull(cls.getCanonicalName());
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zao.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import java.util.ArrayList;
+
+/* loaded from: classes2.dex */
+public final class zao implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        ArrayList arrayList = null;
+        int i = 0;
+        String str = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 2) {
+                arrayList = SafeParcelReader.createTypedList(parcel, readHeader, zal.CREATOR);
+            } else if (fieldId != 3) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new zan(i, arrayList, str);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new zan[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zap.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import java.util.ArrayList;
+
+/* loaded from: classes2.dex */
+public final class zap implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        String str = null;
+        int i = 0;
+        ArrayList arrayList = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 2) {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId != 3) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                arrayList = SafeParcelReader.createTypedList(parcel, readHeader, zam.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new zal(i, str, arrayList);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new zal[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/response/zaq.java

@@ -0,0 +1,36 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+
+/* loaded from: classes2.dex */
+public final class zaq implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        Parcel parcel2 = null;
+        int i = 0;
+        zan zanVar = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 2) {
+                parcel2 = SafeParcelReader.createParcel(parcel, readHeader);
+            } else if (fieldId != 3) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                zanVar = (zan) SafeParcelReader.createParcelable(parcel, readHeader, zan.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new SafeParcelResponse(i, parcel2, zanVar);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new SafeParcelResponse[i];
+    }
+}

decompiled/sources/com/google/android/gms/common/server/zaa.java

@@ -0,0 +1,36 @@
+package com.google.android.gms.common.server;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+
+/* loaded from: classes2.dex */
+public final class zaa implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        int i = 0;
+        String str = null;
+        int i2 = 0;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            int fieldId = SafeParcelReader.getFieldId(readHeader);
+            if (fieldId == 1) {
+                i = SafeParcelReader.readInt(parcel, readHeader);
+            } else if (fieldId == 2) {
+                str = SafeParcelReader.createString(parcel, readHeader);
+            } else if (fieldId != 3) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                i2 = SafeParcelReader.readInt(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new FavaDiagnosticsEntity(i, str, i2);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new FavaDiagnosticsEntity[i];
+    }
+}