Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/com/google/android/gms/common/server/FavaDiagnosticsEntity.java

@@ -0,0 +1,50 @@
+package com.google.android.gms.common.server;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+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: classes3.dex */
+public class FavaDiagnosticsEntity extends AbstractSafeParcelable implements ReflectedParcelable {
+
+    @KeepForSdk
+    public static final Parcelable.Creator<FavaDiagnosticsEntity> CREATOR = new zaa();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zaa;
+
+    @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, @SafeParcelable.Param(id = 2) String str, @SafeParcelable.Param(id = 3) int i4) {
+        this.zaa = i;
+        this.zab = str;
+        this.zac = i4;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        SafeParcelWriter.writeString(parcel, 2, this.zab, false);
+        SafeParcelWriter.writeInt(parcel, 3, this.zac);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    @KeepForSdk
+    public FavaDiagnosticsEntity(String str, int i) {
+        this.zaa = 1;
+        this.zab = str;
+        this.zac = i;
+    }
+}

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

@@ -0,0 +1,84 @@
+package com.google.android.gms.common.server.converter;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.SparseArray;
+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: classes3.dex */
+public final class StringToIntConverter extends AbstractSafeParcelable implements FastJsonResponse.FieldConverter<String, Integer> {
+    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();
+    }
+
+    @KeepForSdk
+    public StringToIntConverter add(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(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 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
+    public final /* bridge */ /* synthetic */ Object zac(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
+    public final /* bridge */ /* synthetic */ Object zad(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 i4 = 0; i4 < size; i4++) {
+            zac zacVar = (zac) arrayList.get(i4);
+            add(zacVar.zab, zacVar.zac);
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+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: classes3.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;
+    }
+
+    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.");
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        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;
+    }
+}

apk_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: classes3.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);
+        int i = 0;
+        StringToIntConverter stringToIntConverter = 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) {
+                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];
+    }
+}

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

@@ -0,0 +1,44 @@
+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: classes3.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 i4) {
+        this.zaa = i;
+        this.zab = str;
+        this.zac = i4;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        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;
+    }
+}

apk_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: classes3.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);
+        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) {
+                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];
+    }
+}

apk_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: classes3.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 i4 = 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 {
+                i4 = SafeParcelReader.readInt(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new zac(i, str, i4);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new zac[i];
+    }
+}

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

@@ -0,0 +1,689 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.util.Log;
+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.google.android.gms.common.util.VisibleForTesting;
+import com.google.android.gms.measurement.internal.a;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.dex */
+public abstract class FastJsonResponse {
+
+    @ShowFirstParty
+    /* loaded from: classes3.dex */
+    public interface FieldConverter<I, O> {
+        int zaa();
+
+        int zab();
+
+        Object zac(Object obj);
+
+        Object zad(Object obj);
+    }
+
+    public static final Object zaD(Field field, Object obj) {
+        return field.zak != null ? field.zaf(obj) : obj;
+    }
+
+    private final void zaE(Field field, Object obj) {
+        String str = field.zae;
+        Object zae = field.zae(obj);
+        int i = field.zac;
+        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(a.l(i, "Unsupported type for conversion: "));
+            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(Field field, String str, ArrayList<T> arrayList) {
+        throw new UnsupportedOperationException("Concrete type array not supported");
+    }
+
+    @KeepForSdk
+    public <T extends FastJsonResponse> void addConcreteTypeInternal(Field field, String str, T t2) {
+        throw new UnsupportedOperationException("Concrete type not supported");
+    }
+
+    @KeepForSdk
+    public abstract Map<String, Field<?, ?>> getFieldMappings();
+
+    @KeepForSdk
+    public Object getFieldValue(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 e4) {
+            throw new RuntimeException(e4);
+        }
+    }
+
+    @KeepForSdk
+    public abstract Object getValueObject(String str);
+
+    @KeepForSdk
+    public boolean isFieldSet(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");
+    }
+
+    @KeepForSdk
+    public abstract boolean isPrimitiveFieldSet(String str);
+
+    @KeepForSdk
+    public void setBooleanInternal(Field<?, ?> field, String str, boolean z3) {
+        throw new UnsupportedOperationException("Boolean not supported");
+    }
+
+    @KeepForSdk
+    public void setDecodedBytesInternal(Field<?, ?> field, String str, byte[] bArr) {
+        throw new UnsupportedOperationException("byte[] not supported");
+    }
+
+    @KeepForSdk
+    public void setIntegerInternal(Field<?, ?> field, String str, int i) {
+        throw new UnsupportedOperationException("Integer not supported");
+    }
+
+    @KeepForSdk
+    public void setLongInternal(Field<?, ?> field, String str, long j4) {
+        throw new UnsupportedOperationException("Long not supported");
+    }
+
+    @KeepForSdk
+    public void setStringInternal(Field<?, ?> field, String str, String str2) {
+        throw new UnsupportedOperationException("String not supported");
+    }
+
+    @KeepForSdk
+    public void setStringMapInternal(Field<?, ?> field, String str, Map<String, String> map) {
+        throw new UnsupportedOperationException("String map not supported");
+    }
+
+    @KeepForSdk
+    public void setStringsInternal(Field<?, ?> field, String str, ArrayList<String> arrayList) {
+        throw new UnsupportedOperationException("String list not supported");
+    }
+
+    @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("[");
+                                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("]");
+                                break;
+                            } else {
+                                zaF(sb, field, zaD);
+                                break;
+                            }
+                    }
+                } else {
+                    sb.append("null");
+                }
+            }
+        }
+        if (sb.length() > 0) {
+            sb.append("}");
+        } else {
+            sb.append("{}");
+        }
+        return sb.toString();
+    }
+
+    public final void zaA(Field field, String str) {
+        if (field.zak != null) {
+            zaE(field, str);
+        } else {
+            setStringInternal(field, field.zae, str);
+        }
+    }
+
+    public final void zaB(Field field, Map map) {
+        if (field.zak != null) {
+            zaE(field, map);
+        } else {
+            setStringMapInternal(field, field.zae, map);
+        }
+    }
+
+    public final void zaC(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            setStringsInternal(field, field.zae, arrayList);
+        }
+    }
+
+    public final void zaa(Field field, BigDecimal bigDecimal) {
+        if (field.zak != null) {
+            zaE(field, bigDecimal);
+        } else {
+            zab(field, field.zae, bigDecimal);
+        }
+    }
+
+    public void zab(Field field, String str, BigDecimal bigDecimal) {
+        throw new UnsupportedOperationException("BigDecimal not supported");
+    }
+
+    public final void zac(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zad(field, field.zae, arrayList);
+        }
+    }
+
+    public void zad(Field field, String str, ArrayList arrayList) {
+        throw new UnsupportedOperationException("BigDecimal list not supported");
+    }
+
+    public final void zae(Field field, BigInteger bigInteger) {
+        if (field.zak != null) {
+            zaE(field, bigInteger);
+        } else {
+            zaf(field, field.zae, bigInteger);
+        }
+    }
+
+    public void zaf(Field field, String str, BigInteger bigInteger) {
+        throw new UnsupportedOperationException("BigInteger not supported");
+    }
+
+    public final void zag(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zah(field, field.zae, arrayList);
+        }
+    }
+
+    public void zah(Field field, String str, ArrayList arrayList) {
+        throw new UnsupportedOperationException("BigInteger list not supported");
+    }
+
+    public final void zai(Field field, boolean z3) {
+        if (field.zak != null) {
+            zaE(field, Boolean.valueOf(z3));
+        } else {
+            setBooleanInternal(field, field.zae, z3);
+        }
+    }
+
+    public final void zaj(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zak(field, field.zae, arrayList);
+        }
+    }
+
+    public void zak(Field field, String str, ArrayList arrayList) {
+        throw new UnsupportedOperationException("Boolean list not supported");
+    }
+
+    public final void zal(Field field, byte[] bArr) {
+        if (field.zak != null) {
+            zaE(field, bArr);
+        } else {
+            setDecodedBytesInternal(field, field.zae, bArr);
+        }
+    }
+
+    public final void zam(Field field, double d4) {
+        if (field.zak != null) {
+            zaE(field, Double.valueOf(d4));
+        } else {
+            zan(field, field.zae, d4);
+        }
+    }
+
+    public void zan(Field field, String str, double d4) {
+        throw new UnsupportedOperationException("Double not supported");
+    }
+
+    public final void zao(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zap(field, field.zae, arrayList);
+        }
+    }
+
+    public void zap(Field field, String str, ArrayList arrayList) {
+        throw new UnsupportedOperationException("Double list not supported");
+    }
+
+    public final void zaq(Field field, float f2) {
+        if (field.zak != null) {
+            zaE(field, Float.valueOf(f2));
+        } else {
+            zar(field, field.zae, f2);
+        }
+    }
+
+    public void zar(Field field, String str, float f2) {
+        throw new UnsupportedOperationException("Float not supported");
+    }
+
+    public final void zas(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zat(field, field.zae, arrayList);
+        }
+    }
+
+    public void zat(Field field, String str, ArrayList arrayList) {
+        throw new UnsupportedOperationException("Float list not supported");
+    }
+
+    public final void zau(Field field, int i) {
+        if (field.zak != null) {
+            zaE(field, Integer.valueOf(i));
+        } else {
+            setIntegerInternal(field, field.zae, i);
+        }
+    }
+
+    public final void zav(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zaw(field, field.zae, arrayList);
+        }
+    }
+
+    public void zaw(Field field, String str, ArrayList arrayList) {
+        throw new UnsupportedOperationException("Integer list not supported");
+    }
+
+    public final void zax(Field field, long j4) {
+        if (field.zak != null) {
+            zaE(field, Long.valueOf(j4));
+        } else {
+            setLongInternal(field, field.zae, j4);
+        }
+    }
+
+    public final void zay(Field field, ArrayList arrayList) {
+        if (field.zak != null) {
+            zaE(field, arrayList);
+        } else {
+            zaz(field, field.zae, arrayList);
+        }
+    }
+
+    public void zaz(Field field, String str, ArrayList arrayList) {
+        throw new UnsupportedOperationException("Long list not supported");
+    }
+
+    @VisibleForTesting
+    @SafeParcelable.Class(creator = "FieldCreator")
+    @ShowFirstParty
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    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;
+
+        @SafeParcelable.Field(getter = "getOutputFieldName", id = 6)
+        protected final String zae;
+
+        @SafeParcelable.Field(getter = "getSafeParcelableFieldId", id = 7)
+        protected final int zaf;
+        protected final Class zag;
+
+        @SafeParcelable.Field(getter = "getConcreteTypeName", id = 8)
+        protected final String zah;
+
+        @SafeParcelable.VersionField(getter = "getVersionCode", id = 1)
+        private final int zai;
+        private zan zaj;
+
+        @SafeParcelable.Field(getter = "getWrappedConverter", id = 9, type = "com.google.android.gms.common.server.converter.ConverterWrapper")
+        private FieldConverter zak;
+
+        @SafeParcelable.Constructor
+        public Field(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) int i4, @SafeParcelable.Param(id = 3) boolean z3, @SafeParcelable.Param(id = 4) int i5, @SafeParcelable.Param(id = 5) boolean z4, @SafeParcelable.Param(id = 6) String str, @SafeParcelable.Param(id = 7) int i6, @SafeParcelable.Param(id = 8) String str2, @SafeParcelable.Param(id = 9) com.google.android.gms.common.server.converter.zaa zaaVar) {
+            this.zai = i;
+            this.zaa = i4;
+            this.zab = z3;
+            this.zac = i5;
+            this.zad = z4;
+            this.zae = str;
+            this.zaf = i6;
+            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();
+            }
+        }
+
+        @VisibleForTesting
+        @KeepForSdk
+        public static Field<byte[], byte[]> forBase64(String str, int i) {
+            return new Field<>(8, false, 8, false, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static Field<Boolean, Boolean> forBoolean(String str, int i) {
+            return new Field<>(6, false, 6, false, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static <T extends FastJsonResponse> Field<T, T> forConcreteType(String str, int i, Class<T> cls) {
+            return new Field<>(11, false, 11, false, str, i, cls, null);
+        }
+
+        @KeepForSdk
+        public static <T extends FastJsonResponse> Field<ArrayList<T>, ArrayList<T>> forConcreteTypeArray(String str, int i, Class<T> cls) {
+            return new Field<>(11, true, 11, true, str, i, cls, null);
+        }
+
+        @KeepForSdk
+        public static Field<Double, Double> forDouble(String str, int i) {
+            return new Field<>(4, false, 4, false, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static Field<Float, Float> forFloat(String str, int i) {
+            return new Field<>(3, false, 3, false, str, i, null, null);
+        }
+
+        @VisibleForTesting
+        @KeepForSdk
+        public static Field<Integer, Integer> forInteger(String str, int i) {
+            return new Field<>(0, false, 0, false, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static Field<Long, Long> forLong(String str, int i) {
+            return new Field<>(2, false, 2, false, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static Field<String, String> forString(String str, int i) {
+            return new Field<>(7, false, 7, false, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static Field<HashMap<String, String>, HashMap<String, String>> forStringMap(String str, int i) {
+            return new Field<>(10, false, 10, false, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static Field<ArrayList<String>, ArrayList<String>> forStrings(String str, int i) {
+            return new Field<>(7, true, 7, true, str, i, null, null);
+        }
+
+        @KeepForSdk
+        public static Field withConverter(String str, int i, FieldConverter<?, ?> fieldConverter, boolean z3) {
+            fieldConverter.zaa();
+            fieldConverter.zab();
+            return new Field(7, z3, 0, false, str, i, null, fieldConverter);
+        }
+
+        @KeepForSdk
+        public int getSafeParcelableFieldId() {
+            return this.zaf;
+        }
+
+        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(Parcel parcel, int i) {
+            int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+            SafeParcelWriter.writeInt(parcel, 1, this.zai);
+            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);
+        }
+
+        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);
+        }
+
+        public final Field zab() {
+            return new Field(this.zai, this.zaa, this.zab, this.zac, this.zad, this.zae, this.zaf, this.zah, zaa());
+        }
+
+        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);
+        }
+
+        public final Object zae(Object obj) {
+            Preconditions.checkNotNull(this.zak);
+            return Preconditions.checkNotNull(this.zak.zac(obj));
+        }
+
+        public final Object zaf(Object obj) {
+            Preconditions.checkNotNull(this.zak);
+            return this.zak.zad(obj);
+        }
+
+        public final String zag() {
+            String str = this.zah;
+            if (str == null) {
+                return null;
+            }
+            return str;
+        }
+
+        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 z3, int i4, boolean z4, String str, int i5, Class cls, FieldConverter fieldConverter) {
+            this.zai = 1;
+            this.zaa = i;
+            this.zab = z3;
+            this.zac = i4;
+            this.zad = z4;
+            this.zae = str;
+            this.zaf = i5;
+            this.zag = cls;
+            if (cls == null) {
+                this.zah = null;
+            } else {
+                this.zah = cls.getCanonicalName();
+            }
+            this.zak = fieldConverter;
+        }
+    }
+}

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

@@ -0,0 +1,670 @@
+package com.google.android.gms.common.server.response;
+
+import C.w;
+import android.util.Log;
+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.maps.model.BitmapDescriptorFactory;
+import com.google.firebase.remoteconfig.FirebaseRemoteConfig;
+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;
+import kotlin.jvm.internal.IntCompanionObject;
+import kotlin.text.Typography;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.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', Typography.quote};
+    private static final char[] zad = {'a', 'l', 's', 'e'};
+    private static final char[] zae = {'a', 'l', 's', 'e', Typography.quote};
+    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
+    /* loaded from: classes3.dex */
+    public static class ParseException extends Exception {
+        public ParseException(String str) {
+            super(str);
+        }
+
+        public ParseException(String str, Throwable th) {
+            super("Error instantiating inner object", th);
+        }
+
+        public ParseException(Throwable th) {
+            super(th);
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:17:0x0030, code lost:
+    
+        throw new com.google.android.gms.common.server.response.FastParser.ParseException("Unexpected control character while reading string");
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static final java.lang.String zaA(java.io.BufferedReader r8, char[] r9, java.lang.StringBuilder r10, char[] r11) throws com.google.android.gms.common.server.response.FastParser.ParseException, java.io.IOException {
+        /*
+            r0 = 0
+            r10.setLength(r0)
+            int r1 = r9.length
+            r8.mark(r1)
+            r1 = r0
+            r2 = r1
+        La:
+            int r3 = r8.read(r9)
+            r4 = -1
+            if (r3 == r4) goto L68
+            r4 = r0
+        L12:
+            if (r4 >= r3) goto L60
+            char r5 = r9[r4]
+            boolean r6 = java.lang.Character.isISOControl(r5)
+            if (r6 == 0) goto L31
+            if (r11 == 0) goto L29
+            r6 = r0
+        L1f:
+            if (r6 > 0) goto L29
+            char r7 = r11[r6]
+            if (r7 != r5) goto L26
+            goto L31
+        L26:
+            int r6 = r6 + 1
+            goto L1f
+        L29:
+            com.google.android.gms.common.server.response.FastParser$ParseException r8 = new com.google.android.gms.common.server.response.FastParser$ParseException
+            java.lang.String r9 = "Unexpected control character while reading string"
+            r8.<init>(r9)
+            throw r8
+        L31:
+            r6 = 34
+            r7 = 1
+            if (r5 != r6) goto L55
+            if (r2 != 0) goto L53
+            r10.append(r9, r0, r4)
+            r8.reset()
+            int r4 = r4 + r7
+            long r2 = (long) r4
+            r8.skip(r2)
+            if (r1 == 0) goto L4e
+            java.lang.String r8 = r10.toString()
+            java.lang.String r8 = com.google.android.gms.common.util.JsonUtils.unescapeString(r8)
+            return r8
+        L4e:
+            java.lang.String r8 = r10.toString()
+            return r8
+        L53:
+            r2 = r0
+            goto L5d
+        L55:
+            r6 = 92
+            if (r5 != r6) goto L53
+            r1 = r2 ^ 1
+            r2 = r1
+            r1 = r7
+        L5d:
+            int r4 = r4 + 1
+            goto L12
+        L60:
+            r10.append(r9, r0, r3)
+            int r3 = r9.length
+            r8.mark(r3)
+            goto La
+        L68:
+            com.google.android.gms.common.server.response.FastParser$ParseException r8 = new com.google.android.gms.common.server.response.FastParser$ParseException
+            java.lang.String r9 = "Unexpected EOF while parsing string"
+            r8.<init>(r9)
+            throw r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.server.response.FastParser.zaA(java.io.BufferedReader, char[], java.lang.StringBuilder, char[]):java.lang.String");
+    }
+
+    private final char zai(BufferedReader bufferedReader) throws ParseException, IOException {
+        if (bufferedReader.read(this.zao) == -1) {
+            return (char) 0;
+        }
+        while (Character.isWhitespace(this.zao[0])) {
+            if (bufferedReader.read(this.zao) == -1) {
+                return (char) 0;
+            }
+        }
+        return this.zao[0];
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final double zaj(BufferedReader bufferedReader) throws ParseException, IOException {
+        int zam2 = zam(bufferedReader, this.zaq);
+        return zam2 == 0 ? FirebaseRemoteConfig.DEFAULT_VALUE_FOR_DOUBLE : 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);
+        return zam2 == 0 ? BitmapDescriptorFactory.HUE_RED : 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 i4;
+        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 c4 = cArr[0];
+        int i5 = c4 == '-' ? IntCompanionObject.MIN_VALUE : -2147483647;
+        int i6 = c4 == '-' ? 1 : 0;
+        if (i6 < zam2) {
+            i4 = i6 + 1;
+            int digit = Character.digit(cArr[i6], 10);
+            if (digit < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            i = -digit;
+        } else {
+            i = 0;
+            i4 = i6;
+        }
+        while (i4 < zam2) {
+            int i7 = i4 + 1;
+            int digit2 = Character.digit(cArr[i4], 10);
+            if (digit2 < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            if (i < -214748364) {
+                throw new ParseException("Number too large");
+            }
+            int i8 = i * 10;
+            if (i8 < i5 + digit2) {
+                throw new ParseException("Number too large");
+            }
+            i = i8 - digit2;
+            i4 = i7;
+        }
+        if (i6 == 0) {
+            return -i;
+        }
+        if (i4 > 1) {
+            return i;
+        }
+        throw new ParseException("No digits to parse");
+    }
+
+    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 z3 = false;
+            while (i < 1024 && bufferedReader.read(cArr, i, 1) != -1) {
+                char c4 = cArr[i];
+                if (Character.isISOControl(c4)) {
+                    throw new ParseException("Unexpected control character while reading string");
+                }
+                if (c4 == '\"') {
+                    if (!z3) {
+                        bufferedReader.reset();
+                        bufferedReader.skip(i + 1);
+                        return i;
+                    }
+                } else if (c4 == '\\') {
+                    z3 = !z3;
+                    i++;
+                }
+                z3 = false;
+                i++;
+            }
+        } else {
+            cArr[0] = zai2;
+            i = 1;
+            while (i < 1024 && bufferedReader.read(cArr, i, 1) != -1) {
+                char c5 = cArr[i];
+                if (c5 == '}' || c5 == ',' || Character.isWhitespace(c5) || 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 j4;
+        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 c4 = cArr[0];
+        long j5 = c4 == '-' ? Long.MIN_VALUE : -9223372036854775807L;
+        int i4 = c4 == '-' ? 1 : 0;
+        if (i4 < zam2) {
+            i = i4 + 1;
+            int digit = Character.digit(cArr[i4], 10);
+            if (digit < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            j4 = -digit;
+        } else {
+            j4 = 0;
+            i = i4;
+        }
+        while (i < zam2) {
+            int i5 = i + 1;
+            int digit2 = Character.digit(cArr[i], 10);
+            if (digit2 < 0) {
+                throw new ParseException("Unexpected non-digit character");
+            }
+            if (j4 < -922337203685477580L) {
+                throw new ParseException("Number too large");
+            }
+            long j6 = j4 * 10;
+            long j7 = digit2;
+            if (j6 < j5 + j7) {
+                throw new ParseException("Number too large");
+            }
+            j4 = j6 - j7;
+            i = i5;
+        }
+        if (i4 == 0) {
+            return -j4;
+        }
+        if (i > 1) {
+            return j4;
+        }
+        throw new ParseException("No digits to parse");
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final String zao(BufferedReader bufferedReader) throws ParseException, IOException {
+        return zap(bufferedReader, this.zap, this.zar, null);
+    }
+
+    private final String zap(BufferedReader bufferedReader, char[] cArr, StringBuilder sb, 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;
+    }
+
+    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);
+    }
+
+    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 c4 = this.zao[0];
+            boolean z3 = false;
+            do {
+                if (c4 == '\"') {
+                    if (z3) {
+                        c4 = '\"';
+                        z3 = true;
+                    }
+                }
+                z3 = c4 == '\\' ? !z3 : false;
+                if (bufferedReader.read(this.zao) == -1) {
+                    throw new ParseException("Unexpected EOF while parsing string");
+                }
+                c4 = this.zao[0];
+            } while (!Character.isISOControl(c4));
+            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 z4 = false;
+                boolean z5 = 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 (!z5) {
+                            z4 = !z4;
+                        }
+                        zai3 = '\"';
+                    }
+                    if (zai3 == '[') {
+                        if (!z4) {
+                            i++;
+                        }
+                        zai3 = '[';
+                    }
+                    if (zai3 == ']' && !z4) {
+                        i--;
+                    }
+                    z5 = (zai3 == '\\' && z4) ? !z5 : 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);
+                do {
+                } 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 */
+    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 */
+    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));
+    }
+
+    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));
+            }
+        }
+    }
+
+    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 e4) {
+                throw new ParseException("Error instantiating inner object", e4);
+            } catch (InstantiationException e5) {
+                throw new ParseException("Error instantiating inner object", e5);
+            }
+        }
+    }
+
+    private final void zaw(int i) throws ParseException {
+        if (this.zat.isEmpty()) {
+            throw new ParseException(w.i(i, "Expected state ", " but had empty stack"));
+        }
+        int intValue = ((Integer) this.zat.pop()).intValue();
+        if (intValue != i) {
+            throw new ParseException(w.k("Expected state ", i, intValue, " but had "));
+        }
+    }
+
+    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 i4 = 0; i4 < read; i4++) {
+                if (cArr[i4 + i] != this.zap[i4]) {
+                    throw new ParseException("Unexpected character");
+                }
+            }
+            i += read;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final boolean zay(BufferedReader bufferedReader, boolean z3) throws ParseException, IOException {
+        char zai2 = zai(bufferedReader);
+        if (zai2 == '\"') {
+            if (z3) {
+                throw new ParseException("No boolean value found in string");
+            }
+            return zay(bufferedReader, true);
+        }
+        if (zai2 == 'f') {
+            zax(bufferedReader, z3 ? zae : zad);
+            return false;
+        }
+        if (zai2 == 'n') {
+            zax(bufferedReader, zaa);
+            return false;
+        }
+        if (zai2 == 't') {
+            zax(bufferedReader, z3 ? zac : zab);
+            return true;
+        }
+        throw new ParseException("Unexpected token: " + zai2);
+    }
+
+    /* JADX WARN: Failed to find 'out' block for switch in B:8:0x003b. Please report as an issue. */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:17:0x026a A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0251 A[SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private final boolean zaz(java.io.BufferedReader r18, com.google.android.gms.common.server.response.FastJsonResponse r19) throws com.google.android.gms.common.server.response.FastParser.ParseException, java.io.IOException {
+        /*
+            Method dump skipped, instructions count: 662
+            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(InputStream inputStream, T t2) 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 = t2.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();
+                    t2.addConcreteTypeArrayInternal(value, value.zae, zav(bufferedReader, value));
+                } else {
+                    if (zai2 != '{') {
+                        throw new ParseException("Unexpected token: " + zai2);
+                    }
+                    this.zat.push(1);
+                    zaz(bufferedReader, t2);
+                }
+                zaw(0);
+                try {
+                    bufferedReader.close();
+                } catch (IOException unused) {
+                    Log.w("FastParser", "Failed to close reader while parsing.");
+                }
+            } catch (IOException e4) {
+                throw new ParseException(e4);
+            }
+        } catch (Throwable th) {
+            try {
+                bufferedReader.close();
+            } catch (IOException unused2) {
+                Log.w("FastParser", "Failed to close reader while parsing.");
+            }
+            throw th;
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+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;
+import com.google.android.gms.common.util.VisibleForTesting;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.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(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
+    @VisibleForTesting
+    public Object getValueObject(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
+    @VisibleForTesting
+    public boolean isPrimitiveFieldSet(String str) {
+        return false;
+    }
+
+    @KeepForSdk
+    public byte[] toByteArray() {
+        Parcel obtain = Parcel.obtain();
+        writeToParcel(obtain, 0);
+        byte[] marshall = obtain.marshall();
+        obtain.recycle();
+        return marshall;
+    }
+}

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

@@ -0,0 +1,593 @@
+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 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.google.android.gms.common.util.VisibleForTesting;
+import com.google.android.gms.measurement.internal.a;
+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;
+
+@VisibleForTesting
+@KeepForSdk
+@SafeParcelable.Class(creator = "SafeParcelResponseCreator")
+/* loaded from: classes3.dex */
+public class SafeParcelResponse extends FastSafeParcelableJsonResponse {
+
+    @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;
+    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;
+    }
+
+    @KeepForSdk
+    public static <T extends FastJsonResponse & SafeParcelable> SafeParcelResponse from(T t2) {
+        String str = (String) Preconditions.checkNotNull(t2.getClass().getCanonicalName());
+        zan zanVar = new zan(t2.getClass());
+        zaF(zanVar, t2);
+        zanVar.zac();
+        zanVar.zad();
+        return new SafeParcelResponse(t2, 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 e4) {
+                    throw new IllegalStateException("Could not access object of type ".concat(String.valueOf(((Class) Preconditions.checkNotNull(field.zag)).getCanonicalName())), e4);
+                } catch (InstantiationException e5) {
+                    throw new IllegalStateException("Could not instantiate an object of type ".concat(String.valueOf(((Class) Preconditions.checkNotNull(field.zag)).getCanonicalName())), e5);
+                }
+            }
+        }
+    }
+
+    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 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 z3 = false;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            Map.Entry entry2 = (Map.Entry) sparseArray.get(SafeParcelReader.getFieldId(readHeader));
+            if (entry2 != null) {
+                if (z3) {
+                    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(a.l(i, "Unknown field out type = "));
+                    }
+                } else if (field.zad) {
+                    sb.append("[");
+                    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 i4 = 0; i4 < length; i4++) {
+                                if (i4 > 0) {
+                                    sb.append(",");
+                                }
+                                createParcelArray[i4].setDataPosition(0);
+                                zaH(sb, field.zah(), createParcelArray[i4]);
+                            }
+                            break;
+                        default:
+                            throw new IllegalStateException("Unknown field type out.");
+                    }
+                    sb.append("]");
+                } 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 z4 = true;
+                            for (String str3 : keySet) {
+                                if (!z4) {
+                                    sb.append(",");
+                                }
+                                sb.append("\"");
+                                sb.append(str3);
+                                sb.append("\":\"");
+                                sb.append(JsonUtils.escapeString(createBundle2.getString(str3)));
+                                sb.append("\"");
+                                z4 = 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");
+                    }
+                }
+                z3 = true;
+            }
+        }
+        if (parcel.dataPosition() != validateObjectHeader) {
+            throw new SafeParcelReader.ParseException(a.l(validateObjectHeader, "Overread allowed size end="), parcel);
+        }
+        sb.append('}');
+    }
+
+    private static final void zaI(StringBuilder sb, int i, 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(a.l(i, "Unknown type = "));
+        }
+    }
+
+    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("[");
+        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("]");
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final <T extends FastJsonResponse> void addConcreteTypeArrayInternal(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, T t2) {
+        zaG(field);
+        SafeParcelWriter.writeParcel(this.zab, field.getSafeParcelableFieldId(), ((SafeParcelResponse) t2).zaE(), true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    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
+    public final Object getValueObject(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(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(FastJsonResponse.Field<?, ?> field, String str, boolean z3) {
+        zaG(field);
+        SafeParcelWriter.writeBoolean(this.zab, field.getSafeParcelableFieldId(), z3);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setDecodedBytesInternal(FastJsonResponse.Field<?, ?> field, String str, 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(FastJsonResponse.Field<?, ?> field, 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(FastJsonResponse.Field<?, ?> field, String str, long j4) {
+        zaG(field);
+        SafeParcelWriter.writeLong(this.zab, field.getSafeParcelableFieldId(), j4);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void setStringInternal(FastJsonResponse.Field<?, ?> field, String str, 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(FastJsonResponse.Field<?, ?> field, String str, 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(FastJsonResponse.Field<?, ?> field, String str, 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
+    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(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        SafeParcelWriter.writeParcel(parcel, 2, zaE(), false);
+        int i4 = this.zac;
+        SafeParcelWriter.writeParcelable(parcel, 3, i4 != 0 ? i4 != 1 ? this.zad : this.zad : null, i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    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(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, double d4) {
+        zaG(field);
+        SafeParcelWriter.writeDouble(this.zab, field.getSafeParcelableFieldId(), d4);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zap(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, float f2) {
+        zaG(field);
+        SafeParcelWriter.writeFloat(this.zab, field.getSafeParcelableFieldId(), f2);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public final void zat(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, 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(FastJsonResponse.Field field, String str, 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;
+    }
+
+    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;
+    }
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+package com.google.android.gms.common.server.response;
+
+import com.google.android.gms.common.server.response.FastParser;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+/* loaded from: classes3.dex */
+final class zae implements zai {
+    @Override // com.google.android.gms.common.server.response.zai
+    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);
+    }
+}

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

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

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

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

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

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

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

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

apk_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: classes3.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);
+        int i = 0;
+        int i4 = 0;
+        boolean z3 = false;
+        int i5 = 0;
+        boolean z4 = false;
+        int i6 = 0;
+        String str = null;
+        String str2 = null;
+        com.google.android.gms.common.server.converter.zaa zaaVar = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            switch (SafeParcelReader.getFieldId(readHeader)) {
+                case 1:
+                    i = SafeParcelReader.readInt(parcel, readHeader);
+                    break;
+                case 2:
+                    i4 = SafeParcelReader.readInt(parcel, readHeader);
+                    break;
+                case 3:
+                    z3 = SafeParcelReader.readBoolean(parcel, readHeader);
+                    break;
+                case 4:
+                    i5 = SafeParcelReader.readInt(parcel, readHeader);
+                    break;
+                case 5:
+                    z4 = SafeParcelReader.readBoolean(parcel, readHeader);
+                    break;
+                case 6:
+                    str = SafeParcelReader.createString(parcel, readHeader);
+                    break;
+                case 7:
+                    i6 = 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, i4, z3, i5, z4, str, i6, str2, zaaVar);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new FastJsonResponse.Field[i];
+    }
+}

apk_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: classes3.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);
+        int i = 0;
+        String str = null;
+        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];
+    }
+}

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

@@ -0,0 +1,58 @@
+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;
+import java.util.ArrayList;
+import java.util.Map;
+
+@ShowFirstParty
+@SafeParcelable.Class(creator = "FieldMappingDictionaryEntryCreator")
+/* loaded from: classes3.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;
+
+    @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 beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        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;
+    }
+}

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

@@ -0,0 +1,47 @@
+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: classes3.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 beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zaa);
+        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;
+    }
+}

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

@@ -0,0 +1,122 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+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: classes3.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 i4 = 0; i4 < size; i4++) {
+            zal zalVar = (zal) arrayList.get(i4);
+            String str2 = zalVar.zab;
+            HashMap hashMap2 = new HashMap();
+            int size2 = ((ArrayList) Preconditions.checkNotNull(zalVar.zac)).size();
+            for (int i5 = 0; i5 < size2; i5++) {
+                zam zamVar = (zam) zalVar.zac.get(i5);
+                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;
+    }
+
+    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());
+    }
+}

apk_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: classes3.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);
+        int i = 0;
+        ArrayList arrayList = null;
+        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];
+    }
+}

apk_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: classes3.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);
+        int i = 0;
+        String str = null;
+        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];
+    }
+}

apk_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: classes3.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);
+        int i = 0;
+        Parcel parcel2 = null;
+        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];
+    }
+}

apk_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: classes3.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 i4 = 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 {
+                i4 = SafeParcelReader.readInt(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new FavaDiagnosticsEntity(i, str, i4);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new FavaDiagnosticsEntity[i];
+    }
+}