Initial import of ADIF API reverse-engineering toolkit

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];
+    }
+}