Initial commit

sources/com/google/android/gms/common/server/FavaDiagnosticsEntity.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.ReflectedParcelable;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes.dex */
+public class FavaDiagnosticsEntity extends AbstractSafeParcelable implements ReflectedParcelable {
+    public static final Parcelable.Creator<FavaDiagnosticsEntity> CREATOR = new zaa();
+    private final int zale;
+    private final String zapi;
+    private final int zapj;
+
+    public FavaDiagnosticsEntity(int i, String str, int i2) {
+        this.zale = i;
+        this.zapi = str;
+        this.zapj = i2;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        int a = SafeParcelWriter.a(parcel);
+        SafeParcelWriter.a(parcel, 1, this.zale);
+        SafeParcelWriter.a(parcel, 2, this.zapi, false);
+        SafeParcelWriter.a(parcel, 3, this.zapj);
+        SafeParcelWriter.a(parcel, a);
+    }
+
+    public FavaDiagnosticsEntity(String str, int i) {
+        this.zale = 1;
+        this.zapi = str;
+        this.zapj = i;
+    }
+}

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

@@ -0,0 +1,109 @@
+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.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/* loaded from: classes.dex */
+public final class StringToIntConverter extends AbstractSafeParcelable implements FastJsonResponse.FieldConverter<String, Integer> {
+    public static final Parcelable.Creator<StringToIntConverter> CREATOR = new zac();
+    private final int zale;
+    private final HashMap<String, Integer> zapl;
+    private final SparseArray<String> zapm;
+    private final ArrayList<zaa> zapn;
+
+    StringToIntConverter(int i, ArrayList<zaa> arrayList) {
+        this.zale = i;
+        this.zapl = new HashMap<>();
+        this.zapm = new SparseArray<>();
+        this.zapn = null;
+        int size = arrayList.size();
+        int i2 = 0;
+        while (i2 < size) {
+            zaa zaaVar = arrayList.get(i2);
+            i2++;
+            zaa zaaVar2 = zaaVar;
+            add(zaaVar2.zapo, zaaVar2.zapp);
+        }
+    }
+
+    public final StringToIntConverter add(String str, int i) {
+        this.zapl.put(str, Integer.valueOf(i));
+        this.zapm.put(i, str);
+        return this;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    public final /* synthetic */ Integer convert(String str) {
+        Integer num = this.zapl.get(str);
+        return num == null ? this.zapl.get("gms_unknown") : num;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    public final /* synthetic */ String convertBack(Integer num) {
+        String str = this.zapm.get(num.intValue());
+        return (str == null && this.zapl.containsKey("gms_unknown")) ? "gms_unknown" : str;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int a = SafeParcelWriter.a(parcel);
+        SafeParcelWriter.a(parcel, 1, this.zale);
+        ArrayList arrayList = new ArrayList();
+        for (String str : this.zapl.keySet()) {
+            arrayList.add(new zaa(str, this.zapl.get(str).intValue()));
+        }
+        SafeParcelWriter.c(parcel, 2, arrayList, false);
+        SafeParcelWriter.a(parcel, a);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    public final int zacj() {
+        return 7;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse.FieldConverter
+    public final int zack() {
+        return 0;
+    }
+
+    public static final class zaa extends AbstractSafeParcelable {
+        public static final Parcelable.Creator<zaa> CREATOR = new zad();
+        private final int versionCode;
+        final String zapo;
+        final int zapp;
+
+        zaa(int i, String str, int i2) {
+            this.versionCode = i;
+            this.zapo = str;
+            this.zapp = i2;
+        }
+
+        @Override // android.os.Parcelable
+        public final void writeToParcel(Parcel parcel, int i) {
+            int a = SafeParcelWriter.a(parcel);
+            SafeParcelWriter.a(parcel, 1, this.versionCode);
+            SafeParcelWriter.a(parcel, 2, this.zapo, false);
+            SafeParcelWriter.a(parcel, 3, this.zapp);
+            SafeParcelWriter.a(parcel, a);
+        }
+
+        zaa(String str, int i) {
+            this.versionCode = 1;
+            this.zapo = str;
+            this.zapp = i;
+        }
+    }
+
+    public StringToIntConverter() {
+        this.zale = 1;
+        this.zapl = new HashMap<>();
+        this.zapm = new SparseArray<>();
+        this.zapn = null;
+    }
+}

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

@@ -0,0 +1,47 @@
+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.server.response.FastJsonResponse;
+
+/* loaded from: classes.dex */
+public final class zaa extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zaa> CREATOR = new zab();
+    private final int zale;
+    private final StringToIntConverter zapk;
+
+    zaa(int i, StringToIntConverter stringToIntConverter) {
+        this.zale = i;
+        this.zapk = 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 a = SafeParcelWriter.a(parcel);
+        SafeParcelWriter.a(parcel, 1, this.zale);
+        SafeParcelWriter.a(parcel, 2, (Parcelable) this.zapk, i, false);
+        SafeParcelWriter.a(parcel, a);
+    }
+
+    public final FastJsonResponse.FieldConverter<?, ?> zaci() {
+        StringToIntConverter stringToIntConverter = this.zapk;
+        if (stringToIntConverter != null) {
+            return stringToIntConverter;
+        }
+        throw new IllegalStateException("There was no converter wrapped in this ConverterWrapper.");
+    }
+
+    private zaa(StringToIntConverter stringToIntConverter) {
+        this.zale = 1;
+        this.zapk = stringToIntConverter;
+    }
+}

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: classes.dex */
+public final class zab implements Parcelable.Creator<zaa> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zaa createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        int i = 0;
+        StringToIntConverter stringToIntConverter = null;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 != 2) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                stringToIntConverter = (StringToIntConverter) SafeParcelReader.a(parcel, a, StringToIntConverter.CREATOR);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new zaa(i, stringToIntConverter);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zaa[] newArray(int i) {
+        return new zaa[i];
+    }
+}

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

@@ -0,0 +1,35 @@
+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 com.google.android.gms.common.server.converter.StringToIntConverter;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class zac implements Parcelable.Creator<StringToIntConverter> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ StringToIntConverter createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        int i = 0;
+        ArrayList arrayList = null;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 != 2) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                arrayList = SafeParcelReader.c(parcel, a, StringToIntConverter.zaa.CREATOR);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new StringToIntConverter(i, arrayList);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ StringToIntConverter[] newArray(int i) {
+        return new StringToIntConverter[i];
+    }
+}

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

@@ -0,0 +1,37 @@
+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 com.google.android.gms.common.server.converter.StringToIntConverter;
+
+/* loaded from: classes.dex */
+public final class zad implements Parcelable.Creator<StringToIntConverter.zaa> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ StringToIntConverter.zaa createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        int i = 0;
+        String str = null;
+        int i2 = 0;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 == 2) {
+                str = SafeParcelReader.n(parcel, a);
+            } else if (a2 != 3) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                i2 = SafeParcelReader.x(parcel, a);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new StringToIntConverter.zaa(i, str, i2);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ StringToIntConverter.zaa[] newArray(int i) {
+        return new StringToIntConverter.zaa[i];
+    }
+}

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

@@ -0,0 +1,636 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Log;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.server.converter.zaa;
+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 java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public abstract class FastJsonResponse {
+
+    public static class Field<I, O> extends AbstractSafeParcelable {
+        public static final zai CREATOR = new zai();
+        private final int zale;
+        protected final int zapq;
+        protected final boolean zapr;
+        protected final int zaps;
+        protected final boolean zapt;
+        protected final String zapu;
+        protected final int zapv;
+        protected final Class<? extends FastJsonResponse> zapw;
+        private final String zapx;
+        private zak zapy;
+        private FieldConverter<I, O> zapz;
+
+        Field(int i, int i2, boolean z, int i3, boolean z2, String str, int i4, String str2, zaa zaaVar) {
+            this.zale = i;
+            this.zapq = i2;
+            this.zapr = z;
+            this.zaps = i3;
+            this.zapt = z2;
+            this.zapu = str;
+            this.zapv = i4;
+            if (str2 == null) {
+                this.zapw = null;
+                this.zapx = null;
+            } else {
+                this.zapw = SafeParcelResponse.class;
+                this.zapx = str2;
+            }
+            if (zaaVar == null) {
+                this.zapz = null;
+            } else {
+                this.zapz = (FieldConverter<I, O>) zaaVar.zaci();
+            }
+        }
+
+        public static Field<byte[], byte[]> forBase64(String str, int i) {
+            return new Field<>(8, false, 8, false, str, i, null, null);
+        }
+
+        public static Field<Boolean, Boolean> forBoolean(String str, int i) {
+            return new Field<>(6, false, 6, false, str, i, null, null);
+        }
+
+        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);
+        }
+
+        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);
+        }
+
+        public static Field<Double, Double> forDouble(String str, int i) {
+            return new Field<>(4, false, 4, false, str, i, null, null);
+        }
+
+        public static Field<Float, Float> forFloat(String str, int i) {
+            return new Field<>(3, false, 3, false, str, i, null, null);
+        }
+
+        public static Field<Integer, Integer> forInteger(String str, int i) {
+            return new Field<>(0, false, 0, false, str, i, null, null);
+        }
+
+        public static Field<Long, Long> forLong(String str, int i) {
+            return new Field<>(2, false, 2, false, str, i, null, null);
+        }
+
+        public static Field<String, String> forString(String str, int i) {
+            return new Field<>(7, false, 7, false, str, i, null, null);
+        }
+
+        public static Field<ArrayList<String>, ArrayList<String>> forStrings(String str, int i) {
+            return new Field<>(7, true, 7, true, str, i, null, null);
+        }
+
+        public static Field withConverter(String str, int i, FieldConverter<?, ?> fieldConverter, boolean z) {
+            return new Field(fieldConverter.zacj(), z, fieldConverter.zack(), false, str, i, null, fieldConverter);
+        }
+
+        private final String zacm() {
+            String str = this.zapx;
+            if (str == null) {
+                return null;
+            }
+            return str;
+        }
+
+        private final zaa zaco() {
+            FieldConverter<I, O> fieldConverter = this.zapz;
+            if (fieldConverter == null) {
+                return null;
+            }
+            return zaa.zaa(fieldConverter);
+        }
+
+        public final O convert(I i) {
+            return this.zapz.convert(i);
+        }
+
+        public final I convertBack(O o) {
+            return this.zapz.convertBack(o);
+        }
+
+        public int getSafeParcelableFieldId() {
+            return this.zapv;
+        }
+
+        public String toString() {
+            Objects.ToStringHelper a = Objects.a(this);
+            a.a("versionCode", Integer.valueOf(this.zale));
+            a.a("typeIn", Integer.valueOf(this.zapq));
+            a.a("typeInArray", Boolean.valueOf(this.zapr));
+            a.a("typeOut", Integer.valueOf(this.zaps));
+            a.a("typeOutArray", Boolean.valueOf(this.zapt));
+            a.a("outputFieldName", this.zapu);
+            a.a("safeParcelFieldId", Integer.valueOf(this.zapv));
+            a.a("concreteTypeName", zacm());
+            Class<? extends FastJsonResponse> cls = this.zapw;
+            if (cls != null) {
+                a.a("concreteType.class", cls.getCanonicalName());
+            }
+            FieldConverter<I, O> fieldConverter = this.zapz;
+            if (fieldConverter != null) {
+                a.a("converterName", fieldConverter.getClass().getCanonicalName());
+            }
+            return a.toString();
+        }
+
+        @Override // android.os.Parcelable
+        public void writeToParcel(Parcel parcel, int i) {
+            int a = SafeParcelWriter.a(parcel);
+            SafeParcelWriter.a(parcel, 1, this.zale);
+            SafeParcelWriter.a(parcel, 2, this.zapq);
+            SafeParcelWriter.a(parcel, 3, this.zapr);
+            SafeParcelWriter.a(parcel, 4, this.zaps);
+            SafeParcelWriter.a(parcel, 5, this.zapt);
+            SafeParcelWriter.a(parcel, 6, this.zapu, false);
+            SafeParcelWriter.a(parcel, 7, getSafeParcelableFieldId());
+            SafeParcelWriter.a(parcel, 8, zacm(), false);
+            SafeParcelWriter.a(parcel, 9, (Parcelable) zaco(), i, false);
+            SafeParcelWriter.a(parcel, a);
+        }
+
+        public final void zaa(zak zakVar) {
+            this.zapy = zakVar;
+        }
+
+        public final Field<I, O> zacl() {
+            return new Field<>(this.zale, this.zapq, this.zapr, this.zaps, this.zapt, this.zapu, this.zapv, this.zapx, zaco());
+        }
+
+        public final boolean zacn() {
+            return this.zapz != null;
+        }
+
+        public final FastJsonResponse zacp() throws InstantiationException, IllegalAccessException {
+            Class<? extends FastJsonResponse> cls = this.zapw;
+            if (cls != SafeParcelResponse.class) {
+                return cls.newInstance();
+            }
+            Preconditions.a(this.zapy, "The field mapping dictionary must be set if the concrete type is a SafeParcelResponse object.");
+            return new SafeParcelResponse(this.zapy, this.zapx);
+        }
+
+        public final Map<String, Field<?, ?>> zacq() {
+            Preconditions.a(this.zapx);
+            Preconditions.a(this.zapy);
+            return this.zapy.zai(this.zapx);
+        }
+
+        private Field(int i, boolean z, int i2, boolean z2, String str, int i3, Class<? extends FastJsonResponse> cls, FieldConverter<I, O> fieldConverter) {
+            this.zale = 1;
+            this.zapq = i;
+            this.zapr = z;
+            this.zaps = i2;
+            this.zapt = z2;
+            this.zapu = str;
+            this.zapv = i3;
+            this.zapw = cls;
+            if (cls == null) {
+                this.zapx = null;
+            } else {
+                this.zapx = cls.getCanonicalName();
+            }
+            this.zapz = fieldConverter;
+        }
+    }
+
+    public interface FieldConverter<I, O> {
+        O convert(I i);
+
+        I convertBack(O o);
+
+        int zacj();
+
+        int zack();
+    }
+
+    private final <I, O> void zaa(Field<I, O> field, I i) {
+        String str = field.zapu;
+        O convert = field.convert(i);
+        int i2 = field.zaps;
+        switch (i2) {
+            case 0:
+                if (zaa(str, convert)) {
+                    setIntegerInternal(field, str, ((Integer) convert).intValue());
+                    return;
+                }
+                return;
+            case 1:
+                zaa((Field<?, ?>) field, str, (BigInteger) convert);
+                return;
+            case 2:
+                if (zaa(str, convert)) {
+                    setLongInternal(field, str, ((Long) convert).longValue());
+                    return;
+                }
+                return;
+            case 3:
+            default:
+                StringBuilder sb = new StringBuilder(44);
+                sb.append("Unsupported type for conversion: ");
+                sb.append(i2);
+                throw new IllegalStateException(sb.toString());
+            case 4:
+                if (zaa(str, convert)) {
+                    zaa((Field<?, ?>) field, str, ((Double) convert).doubleValue());
+                    return;
+                }
+                return;
+            case 5:
+                zaa((Field<?, ?>) field, str, (BigDecimal) convert);
+                return;
+            case 6:
+                if (zaa(str, convert)) {
+                    setBooleanInternal(field, str, ((Boolean) convert).booleanValue());
+                    return;
+                }
+                return;
+            case 7:
+                setStringInternal(field, str, (String) convert);
+                return;
+            case 8:
+            case 9:
+                if (zaa(str, convert)) {
+                    setDecodedBytesInternal(field, str, (byte[]) convert);
+                    return;
+                }
+                return;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    protected static <O, I> I zab(Field<I, O> field, Object obj) {
+        return ((Field) field).zapz != null ? field.convertBack(obj) : obj;
+    }
+
+    public <T extends FastJsonResponse> void addConcreteTypeArrayInternal(Field<?, ?> field, String str, ArrayList<T> arrayList) {
+        throw new UnsupportedOperationException("Concrete type array not supported");
+    }
+
+    public <T extends FastJsonResponse> void addConcreteTypeInternal(Field<?, ?> field, String str, T t) {
+        throw new UnsupportedOperationException("Concrete type not supported");
+    }
+
+    public abstract Map<String, Field<?, ?>> getFieldMappings();
+
+    protected Object getFieldValue(Field field) {
+        String str = field.zapu;
+        if (field.zapw == null) {
+            return getValueObject(str);
+        }
+        Preconditions.a(getValueObject(str) == null, "Concrete field shouldn't be value object: %s", field.zapu);
+        boolean z = field.zapt;
+        try {
+            char upperCase = Character.toUpperCase(str.charAt(0));
+            String substring = str.substring(1);
+            StringBuilder sb = new StringBuilder(String.valueOf(substring).length() + 4);
+            sb.append("get");
+            sb.append(upperCase);
+            sb.append(substring);
+            return getClass().getMethod(sb.toString(), new Class[0]).invoke(this, new Object[0]);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    protected abstract Object getValueObject(String str);
+
+    protected boolean isFieldSet(Field field) {
+        if (field.zaps != 11) {
+            return isPrimitiveFieldSet(field.zapu);
+        }
+        if (field.zapt) {
+            String str = field.zapu;
+            throw new UnsupportedOperationException("Concrete type arrays not supported");
+        }
+        String str2 = field.zapu;
+        throw new UnsupportedOperationException("Concrete types not supported");
+    }
+
+    protected abstract boolean isPrimitiveFieldSet(String str);
+
+    protected void setBooleanInternal(Field<?, ?> field, String str, boolean z) {
+        throw new UnsupportedOperationException("Boolean not supported");
+    }
+
+    protected void setDecodedBytesInternal(Field<?, ?> field, String str, byte[] bArr) {
+        throw new UnsupportedOperationException("byte[] not supported");
+    }
+
+    protected void setIntegerInternal(Field<?, ?> field, String str, int i) {
+        throw new UnsupportedOperationException("Integer not supported");
+    }
+
+    protected void setLongInternal(Field<?, ?> field, String str, long j) {
+        throw new UnsupportedOperationException("Long not supported");
+    }
+
+    protected void setStringInternal(Field<?, ?> field, String str, String str2) {
+        throw new UnsupportedOperationException("String not supported");
+    }
+
+    protected void setStringsInternal(Field<?, ?> field, String str, ArrayList<String> arrayList) {
+        throw new UnsupportedOperationException("String list not supported");
+    }
+
+    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 zab = zab(field, getFieldValue(field));
+                if (sb.length() == 0) {
+                    sb.append("{");
+                } else {
+                    sb.append(",");
+                }
+                sb.append("\"");
+                sb.append(str);
+                sb.append("\":");
+                if (zab != null) {
+                    switch (field.zaps) {
+                        case 8:
+                            sb.append("\"");
+                            sb.append(Base64Utils.a((byte[]) zab));
+                            sb.append("\"");
+                            break;
+                        case 9:
+                            sb.append("\"");
+                            sb.append(Base64Utils.b((byte[]) zab));
+                            sb.append("\"");
+                            break;
+                        case 10:
+                            MapUtils.a(sb, (HashMap) zab);
+                            break;
+                        default:
+                            if (field.zapr) {
+                                ArrayList arrayList = (ArrayList) zab;
+                                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) {
+                                        zaa(sb, field, obj);
+                                    }
+                                }
+                                sb.append("]");
+                                break;
+                            } else {
+                                zaa(sb, field, zab);
+                                break;
+                            }
+                    }
+                } else {
+                    sb.append("null");
+                }
+            }
+        }
+        if (sb.length() > 0) {
+            sb.append("}");
+        } else {
+            sb.append("{}");
+        }
+        return sb.toString();
+    }
+
+    public final <O> void zac(Field<ArrayList<Long>, O> field, ArrayList<Long> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<Long>, O>, O>) field, (Field<ArrayList<Long>, O>) arrayList);
+        } else {
+            zac(field, field.zapu, arrayList);
+        }
+    }
+
+    public final <O> void zad(Field<ArrayList<Float>, O> field, ArrayList<Float> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<Float>, O>, O>) field, (Field<ArrayList<Float>, O>) arrayList);
+        } else {
+            zad(field, field.zapu, arrayList);
+        }
+    }
+
+    public final <O> void zae(Field<ArrayList<Double>, O> field, ArrayList<Double> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<Double>, O>, O>) field, (Field<ArrayList<Double>, O>) arrayList);
+        } else {
+            zae(field, field.zapu, arrayList);
+        }
+    }
+
+    public final <O> void zaf(Field<ArrayList<BigDecimal>, O> field, ArrayList<BigDecimal> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<BigDecimal>, O>, O>) field, (Field<ArrayList<BigDecimal>, O>) arrayList);
+        } else {
+            zaf(field, field.zapu, arrayList);
+        }
+    }
+
+    public final <O> void zag(Field<ArrayList<Boolean>, O> field, ArrayList<Boolean> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<Boolean>, O>, O>) field, (Field<ArrayList<Boolean>, O>) arrayList);
+        } else {
+            zag(field, field.zapu, arrayList);
+        }
+    }
+
+    public final <O> void zah(Field<ArrayList<String>, O> field, ArrayList<String> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<String>, O>, O>) field, (Field<ArrayList<String>, O>) arrayList);
+        } else {
+            setStringsInternal(field, field.zapu, arrayList);
+        }
+    }
+
+    public final <O> void zab(Field<ArrayList<BigInteger>, O> field, ArrayList<BigInteger> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<BigInteger>, O>, O>) field, (Field<ArrayList<BigInteger>, O>) arrayList);
+        } else {
+            zab(field, field.zapu, arrayList);
+        }
+    }
+
+    protected void zac(Field<?, ?> field, String str, ArrayList<Long> arrayList) {
+        throw new UnsupportedOperationException("Long list not supported");
+    }
+
+    protected void zad(Field<?, ?> field, String str, ArrayList<Float> arrayList) {
+        throw new UnsupportedOperationException("Float list not supported");
+    }
+
+    protected void zae(Field<?, ?> field, String str, ArrayList<Double> arrayList) {
+        throw new UnsupportedOperationException("Double list not supported");
+    }
+
+    protected void zaf(Field<?, ?> field, String str, ArrayList<BigDecimal> arrayList) {
+        throw new UnsupportedOperationException("BigDecimal list not supported");
+    }
+
+    protected void zag(Field<?, ?> field, String str, ArrayList<Boolean> arrayList) {
+        throw new UnsupportedOperationException("Boolean list not supported");
+    }
+
+    protected void zab(Field<?, ?> field, String str, ArrayList<BigInteger> arrayList) {
+        throw new UnsupportedOperationException("BigInteger list not supported");
+    }
+
+    public final <O> void zaa(Field<Integer, O> field, int i) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<Integer, O>, O>) field, (Field<Integer, O>) Integer.valueOf(i));
+        } else {
+            setIntegerInternal(field, field.zapu, i);
+        }
+    }
+
+    public final <O> void zaa(Field<ArrayList<Integer>, O> field, ArrayList<Integer> arrayList) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<ArrayList<Integer>, O>, O>) field, (Field<ArrayList<Integer>, O>) arrayList);
+        } else {
+            zaa(field, field.zapu, arrayList);
+        }
+    }
+
+    public final <O> void zaa(Field<BigInteger, O> field, BigInteger bigInteger) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<BigInteger, O>, O>) field, (Field<BigInteger, O>) bigInteger);
+        } else {
+            zaa(field, field.zapu, bigInteger);
+        }
+    }
+
+    public final <O> void zaa(Field<Long, O> field, long j) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<Long, O>, O>) field, (Field<Long, O>) Long.valueOf(j));
+        } else {
+            setLongInternal(field, field.zapu, j);
+        }
+    }
+
+    public final <O> void zaa(Field<Float, O> field, float f) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<Float, O>, O>) field, (Field<Float, O>) Float.valueOf(f));
+        } else {
+            zaa((Field<?, ?>) field, field.zapu, f);
+        }
+    }
+
+    public final <O> void zaa(Field<Double, O> field, double d) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<Double, O>, O>) field, (Field<Double, O>) Double.valueOf(d));
+        } else {
+            zaa(field, field.zapu, d);
+        }
+    }
+
+    public final <O> void zaa(Field<BigDecimal, O> field, BigDecimal bigDecimal) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<BigDecimal, O>, O>) field, (Field<BigDecimal, O>) bigDecimal);
+        } else {
+            zaa(field, field.zapu, bigDecimal);
+        }
+    }
+
+    public final <O> void zaa(Field<Boolean, O> field, boolean z) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<Boolean, O>, O>) field, (Field<Boolean, O>) Boolean.valueOf(z));
+        } else {
+            setBooleanInternal(field, field.zapu, z);
+        }
+    }
+
+    public final <O> void zaa(Field<String, O> field, String str) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<String, O>, O>) field, (Field<String, O>) str);
+        } else {
+            setStringInternal(field, field.zapu, str);
+        }
+    }
+
+    public final <O> void zaa(Field<byte[], O> field, byte[] bArr) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<byte[], O>, O>) field, (Field<byte[], O>) bArr);
+        } else {
+            setDecodedBytesInternal(field, field.zapu, bArr);
+        }
+    }
+
+    public final <O> void zaa(Field<Map<String, String>, O> field, Map<String, String> map) {
+        if (((Field) field).zapz != null) {
+            zaa((Field<Field<Map<String, String>, O>, O>) field, (Field<Map<String, String>, O>) map);
+        } else {
+            zaa(field, field.zapu, map);
+        }
+    }
+
+    protected void zaa(Field<?, ?> field, String str, ArrayList<Integer> arrayList) {
+        throw new UnsupportedOperationException("Integer list not supported");
+    }
+
+    protected void zaa(Field<?, ?> field, String str, BigInteger bigInteger) {
+        throw new UnsupportedOperationException("BigInteger not supported");
+    }
+
+    protected void zaa(Field<?, ?> field, String str, float f) {
+        throw new UnsupportedOperationException("Float not supported");
+    }
+
+    protected void zaa(Field<?, ?> field, String str, double d) {
+        throw new UnsupportedOperationException("Double not supported");
+    }
+
+    protected void zaa(Field<?, ?> field, String str, BigDecimal bigDecimal) {
+        throw new UnsupportedOperationException("BigDecimal not supported");
+    }
+
+    protected void zaa(Field<?, ?> field, String str, Map<String, String> map) {
+        throw new UnsupportedOperationException("String map not supported");
+    }
+
+    private static <O> boolean zaa(String str, O o) {
+        if (o != null) {
+            return true;
+        }
+        if (!Log.isLoggable("FastJsonResponse", 6)) {
+            return false;
+        }
+        StringBuilder sb = new StringBuilder(String.valueOf(str).length() + 58);
+        sb.append("Output field (");
+        sb.append(str);
+        sb.append(") has a null value, but expected a primitive");
+        Log.e("FastJsonResponse", sb.toString());
+        return false;
+    }
+
+    private static void zaa(StringBuilder sb, Field field, Object obj) {
+        int i = field.zapq;
+        if (i == 11) {
+            sb.append(field.zapw.cast(obj).toString());
+        } else {
+            if (i == 7) {
+                sb.append("\"");
+                sb.append(JsonUtils.a((String) obj));
+                sb.append("\"");
+                return;
+            }
+            sb.append(obj);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.google.android.gms.common.server.response;
+
+/* loaded from: classes.dex */
+public class FastParser$ParseException extends Exception {
+    public FastParser$ParseException(String str) {
+        super(str);
+    }
+
+    public FastParser$ParseException(String str, Throwable th) {
+        super(str, th);
+    }
+
+    public FastParser$ParseException(Throwable th) {
+        super(th);
+    }
+}

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

@@ -0,0 +1,61 @@
+package com.google.android.gms.common.server.response;
+
+import android.os.Parcel;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+/* loaded from: classes.dex */
+public abstract class FastSafeParcelableJsonResponse extends FastJsonResponse implements SafeParcelable {
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    public boolean equals(Object obj) {
+        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) || !getFieldValue(field).equals(fastJsonResponse.getFieldValue(field))) {
+                    return false;
+                }
+            } else if (fastJsonResponse.isFieldSet(field)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public Object getValueObject(String str) {
+        return null;
+    }
+
+    public int hashCode() {
+        int i = 0;
+        for (FastJsonResponse.Field<?, ?> field : getFieldMappings().values()) {
+            if (isFieldSet(field)) {
+                i = (i * 31) + getFieldValue(field).hashCode();
+            }
+        }
+        return i;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public boolean isPrimitiveFieldSet(String str) {
+        return false;
+    }
+
+    public byte[] toByteArray() {
+        Parcel obtain = Parcel.obtain();
+        writeToParcel(obtain, 0);
+        byte[] marshall = obtain.marshall();
+        obtain.recycle();
+        return marshall;
+    }
+}

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

@@ -0,0 +1,640 @@
+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.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 java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public class SafeParcelResponse extends FastSafeParcelableJsonResponse {
+    public static final Parcelable.Creator<SafeParcelResponse> CREATOR = new zap();
+    private final String mClassName;
+    private final int zale;
+    private final zak zapy;
+    private final Parcel zara;
+    private final int zarb;
+    private int zarc;
+    private int zard;
+
+    public SafeParcelResponse(zak zakVar, String str) {
+        this.zale = 1;
+        this.zara = Parcel.obtain();
+        this.zarb = 0;
+        Preconditions.a(zakVar);
+        this.zapy = zakVar;
+        Preconditions.a(str);
+        this.mClassName = str;
+        this.zarc = 0;
+    }
+
+    public static <T extends FastJsonResponse & SafeParcelable> SafeParcelResponse from(T t) {
+        String canonicalName = t.getClass().getCanonicalName();
+        zak zakVar = new zak(t.getClass());
+        zaa(zakVar, t);
+        zakVar.zacs();
+        zakVar.zacr();
+        return new SafeParcelResponse(t, zakVar, canonicalName);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private static void zaa(zak zakVar, FastJsonResponse fastJsonResponse) {
+        Class<?> cls = fastJsonResponse.getClass();
+        if (zakVar.zaa(cls)) {
+            return;
+        }
+        Map<String, FastJsonResponse.Field<?, ?>> fieldMappings = fastJsonResponse.getFieldMappings();
+        zakVar.zaa(cls, fieldMappings);
+        Iterator<String> it = fieldMappings.keySet().iterator();
+        while (it.hasNext()) {
+            FastJsonResponse.Field<?, ?> field = fieldMappings.get(it.next());
+            Class<? extends FastJsonResponse> cls2 = field.zapw;
+            if (cls2 != null) {
+                try {
+                    zaa(zakVar, cls2.newInstance());
+                } catch (IllegalAccessException e) {
+                    String valueOf = String.valueOf(field.zapw.getCanonicalName());
+                    throw new IllegalStateException(valueOf.length() != 0 ? "Could not access object of type ".concat(valueOf) : new String("Could not access object of type "), e);
+                } catch (InstantiationException e2) {
+                    String valueOf2 = String.valueOf(field.zapw.getCanonicalName());
+                    throw new IllegalStateException(valueOf2.length() != 0 ? "Could not instantiate an object of type ".concat(valueOf2) : new String("Could not instantiate an object of type "), e2);
+                }
+            }
+        }
+    }
+
+    private final void zab(FastJsonResponse.Field<?, ?> field) {
+        if (!(field.zapv != -1)) {
+            throw new IllegalStateException("Field does not have a valid safe parcelable field id.");
+        }
+        Parcel parcel = this.zara;
+        if (parcel == null) {
+            throw new IllegalStateException("Internal Parcel object is null.");
+        }
+        int i = this.zarc;
+        if (i == 0) {
+            this.zard = SafeParcelWriter.a(parcel);
+            this.zarc = 1;
+        } else if (i != 1) {
+            if (i == 2) {
+                throw new IllegalStateException("Attempted to parse JSON with a SafeParcelResponse object that is already filled with data.");
+            }
+            throw new IllegalStateException("Unknown parse state in SafeParcelResponse.");
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:4:0x0005, code lost:
+    
+        if (r0 != 1) goto L9;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    private final android.os.Parcel zacu() {
+        /*
+            r2 = this;
+            int r0 = r2.zarc
+            if (r0 == 0) goto L8
+            r1 = 1
+            if (r0 == r1) goto L10
+            goto L1a
+        L8:
+            android.os.Parcel r0 = r2.zara
+            int r0 = com.google.android.gms.common.internal.safeparcel.SafeParcelWriter.a(r0)
+            r2.zard = r0
+        L10:
+            android.os.Parcel r0 = r2.zara
+            int r1 = r2.zard
+            com.google.android.gms.common.internal.safeparcel.SafeParcelWriter.a(r0, r1)
+            r0 = 2
+            r2.zarc = r0
+        L1a:
+            android.os.Parcel r0 = r2.zara
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.server.response.SafeParcelResponse.zacu():android.os.Parcel");
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public <T extends FastJsonResponse> void addConcreteTypeArrayInternal(FastJsonResponse.Field<?, ?> field, String str, ArrayList<T> arrayList) {
+        zab(field);
+        ArrayList arrayList2 = new ArrayList();
+        arrayList.size();
+        int size = arrayList.size();
+        int i = 0;
+        while (i < size) {
+            T t = arrayList.get(i);
+            i++;
+            arrayList2.add(((SafeParcelResponse) t).zacu());
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), (List<Parcel>) arrayList2, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public <T extends FastJsonResponse> void addConcreteTypeInternal(FastJsonResponse.Field<?, ?> field, String str, T t) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), ((SafeParcelResponse) t).zacu(), true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public Map<String, FastJsonResponse.Field<?, ?>> getFieldMappings() {
+        zak zakVar = this.zapy;
+        if (zakVar == null) {
+            return null;
+        }
+        return zakVar.zai(this.mClassName);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastSafeParcelableJsonResponse, com.google.android.gms.common.server.response.FastJsonResponse
+    public 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 boolean isPrimitiveFieldSet(String str) {
+        throw new UnsupportedOperationException("Converting to JSON does not require this method.");
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected void setBooleanInternal(FastJsonResponse.Field<?, ?> field, String str, boolean z) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), z);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected void setDecodedBytesInternal(FastJsonResponse.Field<?, ?> field, String str, byte[] bArr) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), bArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected void setIntegerInternal(FastJsonResponse.Field<?, ?> field, String str, int i) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), i);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected void setLongInternal(FastJsonResponse.Field<?, ?> field, String str, long j) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), j);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected void setStringInternal(FastJsonResponse.Field<?, ?> field, String str, String str2) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), str2, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected void setStringsInternal(FastJsonResponse.Field<?, ?> field, String str, ArrayList<String> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        String[] strArr = new String[size];
+        for (int i = 0; i < size; i++) {
+            strArr[i] = arrayList.get(i);
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), strArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    public String toString() {
+        Preconditions.a(this.zapy, "Cannot convert to JSON on client side.");
+        Parcel zacu = zacu();
+        zacu.setDataPosition(0);
+        StringBuilder sb = new StringBuilder(100);
+        zaa(sb, this.zapy.zai(this.mClassName), zacu);
+        return sb.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        zak zakVar;
+        int a = SafeParcelWriter.a(parcel);
+        SafeParcelWriter.a(parcel, 1, this.zale);
+        SafeParcelWriter.a(parcel, 2, zacu(), false);
+        int i2 = this.zarb;
+        if (i2 == 0) {
+            zakVar = null;
+        } else if (i2 == 1) {
+            zakVar = this.zapy;
+        } else {
+            if (i2 != 2) {
+                StringBuilder sb = new StringBuilder(34);
+                sb.append("Invalid creation type: ");
+                sb.append(i2);
+                throw new IllegalStateException(sb.toString());
+            }
+            zakVar = this.zapy;
+        }
+        SafeParcelWriter.a(parcel, 3, (Parcelable) zakVar, i, false);
+        SafeParcelWriter.a(parcel, a);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zac(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Long> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        long[] jArr = new long[size];
+        for (int i = 0; i < size; i++) {
+            jArr[i] = arrayList.get(i).longValue();
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), jArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zad(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Float> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        float[] fArr = new float[size];
+        for (int i = 0; i < size; i++) {
+            fArr[i] = arrayList.get(i).floatValue();
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), fArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zae(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Double> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        double[] dArr = new double[size];
+        for (int i = 0; i < size; i++) {
+            dArr[i] = arrayList.get(i).doubleValue();
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), dArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zaf(FastJsonResponse.Field<?, ?> field, String str, ArrayList<BigDecimal> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        BigDecimal[] bigDecimalArr = new BigDecimal[size];
+        for (int i = 0; i < size; i++) {
+            bigDecimalArr[i] = arrayList.get(i);
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), bigDecimalArr, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zag(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Boolean> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        boolean[] zArr = new boolean[size];
+        for (int i = 0; i < size; i++) {
+            zArr[i] = arrayList.get(i).booleanValue();
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), zArr, true);
+    }
+
+    private SafeParcelResponse(SafeParcelable safeParcelable, zak zakVar, String str) {
+        this.zale = 1;
+        this.zara = Parcel.obtain();
+        safeParcelable.writeToParcel(this.zara, 0);
+        this.zarb = 1;
+        Preconditions.a(zakVar);
+        this.zapy = zakVar;
+        Preconditions.a(str);
+        this.mClassName = str;
+        this.zarc = 2;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zab(FastJsonResponse.Field<?, ?> field, String str, ArrayList<BigInteger> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        BigInteger[] bigIntegerArr = new BigInteger[size];
+        for (int i = 0; i < size; i++) {
+            bigIntegerArr[i] = arrayList.get(i);
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), bigIntegerArr, true);
+    }
+
+    SafeParcelResponse(int i, Parcel parcel, zak zakVar) {
+        this.zale = i;
+        Preconditions.a(parcel);
+        this.zara = parcel;
+        this.zarb = 2;
+        this.zapy = zakVar;
+        zak zakVar2 = this.zapy;
+        if (zakVar2 == null) {
+            this.mClassName = null;
+        } else {
+            this.mClassName = zakVar2.zact();
+        }
+        this.zarc = 2;
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zaa(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Integer> arrayList) {
+        zab(field);
+        int size = arrayList.size();
+        int[] iArr = new int[size];
+        for (int i = 0; i < size; i++) {
+            iArr[i] = arrayList.get(i).intValue();
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), iArr, true);
+    }
+
+    private final void zab(StringBuilder sb, FastJsonResponse.Field<?, ?> field, Object obj) {
+        if (field.zapr) {
+            ArrayList arrayList = (ArrayList) obj;
+            sb.append("[");
+            int size = arrayList.size();
+            for (int i = 0; i < size; i++) {
+                if (i != 0) {
+                    sb.append(",");
+                }
+                zaa(sb, field.zapq, arrayList.get(i));
+            }
+            sb.append("]");
+            return;
+        }
+        zaa(sb, field.zapq, obj);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zaa(FastJsonResponse.Field<?, ?> field, String str, BigInteger bigInteger) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), bigInteger, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zaa(FastJsonResponse.Field<?, ?> field, String str, float f) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), f);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zaa(FastJsonResponse.Field<?, ?> field, String str, double d) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), d);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zaa(FastJsonResponse.Field<?, ?> field, String str, BigDecimal bigDecimal) {
+        zab(field);
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), bigDecimal, true);
+    }
+
+    @Override // com.google.android.gms.common.server.response.FastJsonResponse
+    protected final void zaa(FastJsonResponse.Field<?, ?> field, String str, Map<String, String> map) {
+        zab(field);
+        Bundle bundle = new Bundle();
+        for (String str2 : map.keySet()) {
+            bundle.putString(str2, map.get(str2));
+        }
+        SafeParcelWriter.a(this.zara, field.getSafeParcelableFieldId(), bundle, true);
+    }
+
+    private final void zaa(StringBuilder sb, Map<String, FastJsonResponse.Field<?, ?>> map, Parcel parcel) {
+        SparseArray sparseArray = new SparseArray();
+        for (Map.Entry<String, FastJsonResponse.Field<?, ?>> entry : map.entrySet()) {
+            sparseArray.put(entry.getValue().getSafeParcelableFieldId(), entry);
+        }
+        sb.append('{');
+        int b = SafeParcelReader.b(parcel);
+        boolean z = false;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            Map.Entry entry2 = (Map.Entry) sparseArray.get(SafeParcelReader.a(a));
+            if (entry2 != null) {
+                if (z) {
+                    sb.append(",");
+                }
+                String str = (String) entry2.getKey();
+                FastJsonResponse.Field<?, ?> field = (FastJsonResponse.Field) entry2.getValue();
+                sb.append("\"");
+                sb.append(str);
+                sb.append("\":");
+                if (field.zacn()) {
+                    int i = field.zaps;
+                    switch (i) {
+                        case 0:
+                            zab(sb, field, FastJsonResponse.zab(field, Integer.valueOf(SafeParcelReader.x(parcel, a))));
+                            break;
+                        case 1:
+                            zab(sb, field, FastJsonResponse.zab(field, SafeParcelReader.c(parcel, a)));
+                            break;
+                        case 2:
+                            zab(sb, field, FastJsonResponse.zab(field, Long.valueOf(SafeParcelReader.z(parcel, a))));
+                            break;
+                        case 3:
+                            zab(sb, field, FastJsonResponse.zab(field, Float.valueOf(SafeParcelReader.u(parcel, a))));
+                            break;
+                        case 4:
+                            zab(sb, field, FastJsonResponse.zab(field, Double.valueOf(SafeParcelReader.s(parcel, a))));
+                            break;
+                        case 5:
+                            zab(sb, field, FastJsonResponse.zab(field, SafeParcelReader.a(parcel, a)));
+                            break;
+                        case 6:
+                            zab(sb, field, FastJsonResponse.zab(field, Boolean.valueOf(SafeParcelReader.r(parcel, a))));
+                            break;
+                        case 7:
+                            zab(sb, field, FastJsonResponse.zab(field, SafeParcelReader.n(parcel, a)));
+                            break;
+                        case 8:
+                        case 9:
+                            zab(sb, field, FastJsonResponse.zab(field, SafeParcelReader.g(parcel, a)));
+                            break;
+                        case 10:
+                            Bundle f = SafeParcelReader.f(parcel, a);
+                            HashMap hashMap = new HashMap();
+                            for (String str2 : f.keySet()) {
+                                hashMap.put(str2, f.getString(str2));
+                            }
+                            zab(sb, field, FastJsonResponse.zab(field, hashMap));
+                            break;
+                        case 11:
+                            throw new IllegalArgumentException("Method does not accept concrete type.");
+                        default:
+                            StringBuilder sb2 = new StringBuilder(36);
+                            sb2.append("Unknown field out type = ");
+                            sb2.append(i);
+                            throw new IllegalArgumentException(sb2.toString());
+                    }
+                } else if (field.zapt) {
+                    sb.append("[");
+                    switch (field.zaps) {
+                        case 0:
+                            ArrayUtils.a(sb, SafeParcelReader.j(parcel, a));
+                            break;
+                        case 1:
+                            ArrayUtils.a(sb, SafeParcelReader.d(parcel, a));
+                            break;
+                        case 2:
+                            ArrayUtils.a(sb, SafeParcelReader.k(parcel, a));
+                            break;
+                        case 3:
+                            ArrayUtils.a(sb, SafeParcelReader.i(parcel, a));
+                            break;
+                        case 4:
+                            ArrayUtils.a(sb, SafeParcelReader.h(parcel, a));
+                            break;
+                        case 5:
+                            ArrayUtils.a(sb, SafeParcelReader.b(parcel, a));
+                            break;
+                        case 6:
+                            ArrayUtils.a(sb, SafeParcelReader.e(parcel, a));
+                            break;
+                        case 7:
+                            ArrayUtils.a(sb, SafeParcelReader.o(parcel, a));
+                            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[] m = SafeParcelReader.m(parcel, a);
+                            int length = m.length;
+                            for (int i2 = 0; i2 < length; i2++) {
+                                if (i2 > 0) {
+                                    sb.append(",");
+                                }
+                                m[i2].setDataPosition(0);
+                                zaa(sb, field.zacq(), m[i2]);
+                            }
+                            break;
+                        default:
+                            throw new IllegalStateException("Unknown field type out.");
+                    }
+                    sb.append("]");
+                } else {
+                    switch (field.zaps) {
+                        case 0:
+                            sb.append(SafeParcelReader.x(parcel, a));
+                            break;
+                        case 1:
+                            sb.append(SafeParcelReader.c(parcel, a));
+                            break;
+                        case 2:
+                            sb.append(SafeParcelReader.z(parcel, a));
+                            break;
+                        case 3:
+                            sb.append(SafeParcelReader.u(parcel, a));
+                            break;
+                        case 4:
+                            sb.append(SafeParcelReader.s(parcel, a));
+                            break;
+                        case 5:
+                            sb.append(SafeParcelReader.a(parcel, a));
+                            break;
+                        case 6:
+                            sb.append(SafeParcelReader.r(parcel, a));
+                            break;
+                        case 7:
+                            String n = SafeParcelReader.n(parcel, a);
+                            sb.append("\"");
+                            sb.append(JsonUtils.a(n));
+                            sb.append("\"");
+                            break;
+                        case 8:
+                            byte[] g = SafeParcelReader.g(parcel, a);
+                            sb.append("\"");
+                            sb.append(Base64Utils.a(g));
+                            sb.append("\"");
+                            break;
+                        case 9:
+                            byte[] g2 = SafeParcelReader.g(parcel, a);
+                            sb.append("\"");
+                            sb.append(Base64Utils.b(g2));
+                            sb.append("\"");
+                            break;
+                        case 10:
+                            Bundle f2 = SafeParcelReader.f(parcel, a);
+                            Set<String> keySet = f2.keySet();
+                            keySet.size();
+                            sb.append("{");
+                            boolean z2 = true;
+                            for (String str3 : keySet) {
+                                if (!z2) {
+                                    sb.append(",");
+                                }
+                                sb.append("\"");
+                                sb.append(str3);
+                                sb.append("\"");
+                                sb.append(":");
+                                sb.append("\"");
+                                sb.append(JsonUtils.a(f2.getString(str3)));
+                                sb.append("\"");
+                                z2 = false;
+                            }
+                            sb.append("}");
+                            break;
+                        case 11:
+                            Parcel l = SafeParcelReader.l(parcel, a);
+                            l.setDataPosition(0);
+                            zaa(sb, field.zacq(), l);
+                            break;
+                        default:
+                            throw new IllegalStateException("Unknown field type out");
+                    }
+                }
+                z = true;
+            }
+        }
+        if (parcel.dataPosition() == b) {
+            sb.append('}');
+            return;
+        }
+        StringBuilder sb3 = new StringBuilder(37);
+        sb3.append("Overread allowed size end=");
+        sb3.append(b);
+        throw new SafeParcelReader.ParseException(sb3.toString(), parcel);
+    }
+
+    private static void zaa(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.a(obj.toString()));
+                sb.append("\"");
+                return;
+            case 8:
+                sb.append("\"");
+                sb.append(Base64Utils.a((byte[]) obj));
+                sb.append("\"");
+                return;
+            case 9:
+                sb.append("\"");
+                sb.append(Base64Utils.b((byte[]) obj));
+                sb.append("\"");
+                return;
+            case 10:
+                MapUtils.a(sb, (HashMap) obj);
+                return;
+            case 11:
+                throw new IllegalArgumentException("Method does not accept concrete type.");
+            default:
+                StringBuilder sb2 = new StringBuilder(26);
+                sb2.append("Unknown type = ");
+                sb2.append(i);
+                throw new IllegalArgumentException(sb2.toString());
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+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.converter.zaa;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+/* loaded from: classes.dex */
+public final class zai implements Parcelable.Creator<FastJsonResponse.Field> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ FastJsonResponse.Field createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        String str = null;
+        String str2 = null;
+        zaa zaaVar = null;
+        int i = 0;
+        int i2 = 0;
+        boolean z = false;
+        int i3 = 0;
+        boolean z2 = false;
+        int i4 = 0;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            switch (SafeParcelReader.a(a)) {
+                case 1:
+                    i = SafeParcelReader.x(parcel, a);
+                    break;
+                case 2:
+                    i2 = SafeParcelReader.x(parcel, a);
+                    break;
+                case 3:
+                    z = SafeParcelReader.r(parcel, a);
+                    break;
+                case 4:
+                    i3 = SafeParcelReader.x(parcel, a);
+                    break;
+                case 5:
+                    z2 = SafeParcelReader.r(parcel, a);
+                    break;
+                case 6:
+                    str = SafeParcelReader.n(parcel, a);
+                    break;
+                case 7:
+                    i4 = SafeParcelReader.x(parcel, a);
+                    break;
+                case 8:
+                    str2 = SafeParcelReader.n(parcel, a);
+                    break;
+                case 9:
+                    zaaVar = (zaa) SafeParcelReader.a(parcel, a, zaa.CREATOR);
+                    break;
+                default:
+                    SafeParcelReader.C(parcel, a);
+                    break;
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new FastJsonResponse.Field(i, i2, z, i3, z2, str, i4, str2, zaaVar);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ FastJsonResponse.Field[] newArray(int i) {
+        return new FastJsonResponse.Field[i];
+    }
+}

sources/com/google/android/gms/common/server/response/zaj.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: classes.dex */
+public final class zaj implements Parcelable.Creator<zam> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zam createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        String str = null;
+        int i = 0;
+        FastJsonResponse.Field field = null;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 == 2) {
+                str = SafeParcelReader.n(parcel, a);
+            } else if (a2 != 3) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                field = (FastJsonResponse.Field) SafeParcelReader.a(parcel, a, FastJsonResponse.Field.CREATOR);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new zam(i, str, field);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zam[] newArray(int i) {
+        return new zam[i];
+    }
+}

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

@@ -0,0 +1,117 @@
+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.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+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;
+
+/* loaded from: classes.dex */
+public final class zak extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zak> CREATOR = new zan();
+    private final int zale;
+    private final HashMap<String, Map<String, FastJsonResponse.Field<?, ?>>> zaqu;
+    private final ArrayList<zal> zaqv;
+    private final String zaqw;
+
+    zak(int i, ArrayList<zal> arrayList, String str) {
+        this.zale = i;
+        this.zaqv = null;
+        HashMap<String, Map<String, FastJsonResponse.Field<?, ?>>> hashMap = new HashMap<>();
+        int size = arrayList.size();
+        for (int i2 = 0; i2 < size; i2++) {
+            zal zalVar = arrayList.get(i2);
+            String str2 = zalVar.className;
+            HashMap hashMap2 = new HashMap();
+            int size2 = zalVar.zaqx.size();
+            for (int i3 = 0; i3 < size2; i3++) {
+                zam zamVar = zalVar.zaqx.get(i3);
+                hashMap2.put(zamVar.zaqy, zamVar.zaqz);
+            }
+            hashMap.put(str2, hashMap2);
+        }
+        this.zaqu = hashMap;
+        Preconditions.a(str);
+        this.zaqw = str;
+        zacr();
+    }
+
+    public final String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (String str : this.zaqu.keySet()) {
+            sb.append(str);
+            sb.append(":\n");
+            Map<String, FastJsonResponse.Field<?, ?>> map = this.zaqu.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 a = SafeParcelWriter.a(parcel);
+        SafeParcelWriter.a(parcel, 1, this.zale);
+        ArrayList arrayList = new ArrayList();
+        for (String str : this.zaqu.keySet()) {
+            arrayList.add(new zal(str, this.zaqu.get(str)));
+        }
+        SafeParcelWriter.c(parcel, 2, arrayList, false);
+        SafeParcelWriter.a(parcel, 3, this.zaqw, false);
+        SafeParcelWriter.a(parcel, a);
+    }
+
+    public final void zaa(Class<? extends FastJsonResponse> cls, Map<String, FastJsonResponse.Field<?, ?>> map) {
+        this.zaqu.put(cls.getCanonicalName(), map);
+    }
+
+    public final void zacr() {
+        Iterator<String> it = this.zaqu.keySet().iterator();
+        while (it.hasNext()) {
+            Map<String, FastJsonResponse.Field<?, ?>> map = this.zaqu.get(it.next());
+            Iterator<String> it2 = map.keySet().iterator();
+            while (it2.hasNext()) {
+                map.get(it2.next()).zaa(this);
+            }
+        }
+    }
+
+    public final void zacs() {
+        for (String str : this.zaqu.keySet()) {
+            Map<String, FastJsonResponse.Field<?, ?>> map = this.zaqu.get(str);
+            HashMap hashMap = new HashMap();
+            for (String str2 : map.keySet()) {
+                hashMap.put(str2, map.get(str2).zacl());
+            }
+            this.zaqu.put(str, hashMap);
+        }
+    }
+
+    public final String zact() {
+        return this.zaqw;
+    }
+
+    public final Map<String, FastJsonResponse.Field<?, ?>> zai(String str) {
+        return this.zaqu.get(str);
+    }
+
+    public final boolean zaa(Class<? extends FastJsonResponse> cls) {
+        return this.zaqu.containsKey(cls.getCanonicalName());
+    }
+
+    public zak(Class<? extends FastJsonResponse> cls) {
+        this.zale = 1;
+        this.zaqv = null;
+        this.zaqu = new HashMap<>();
+        this.zaqw = cls.getCanonicalName();
+    }
+}

sources/com/google/android/gms/common/server/response/zal.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.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+import java.util.ArrayList;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public final class zal extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zal> CREATOR = new zao();
+    final String className;
+    private final int versionCode;
+    final ArrayList<zam> zaqx;
+
+    zal(int i, String str, ArrayList<zam> arrayList) {
+        this.versionCode = i;
+        this.className = str;
+        this.zaqx = arrayList;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int a = SafeParcelWriter.a(parcel);
+        SafeParcelWriter.a(parcel, 1, this.versionCode);
+        SafeParcelWriter.a(parcel, 2, this.className, false);
+        SafeParcelWriter.c(parcel, 3, this.zaqx, false);
+        SafeParcelWriter.a(parcel, a);
+    }
+
+    zal(String str, Map<String, FastJsonResponse.Field<?, ?>> map) {
+        ArrayList<zam> arrayList;
+        this.versionCode = 1;
+        this.className = str;
+        if (map == null) {
+            arrayList = null;
+        } else {
+            arrayList = new ArrayList<>();
+            for (String str2 : map.keySet()) {
+                arrayList.add(new zam(str2, map.get(str2)));
+            }
+        }
+        this.zaqx = arrayList;
+    }
+}

sources/com/google/android/gms/common/server/response/zam.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.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.server.response.FastJsonResponse;
+
+/* loaded from: classes.dex */
+public final class zam extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<zam> CREATOR = new zaj();
+    private final int versionCode;
+    final String zaqy;
+    final FastJsonResponse.Field<?, ?> zaqz;
+
+    zam(int i, String str, FastJsonResponse.Field<?, ?> field) {
+        this.versionCode = i;
+        this.zaqy = str;
+        this.zaqz = field;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int a = SafeParcelWriter.a(parcel);
+        SafeParcelWriter.a(parcel, 1, this.versionCode);
+        SafeParcelWriter.a(parcel, 2, this.zaqy, false);
+        SafeParcelWriter.a(parcel, 3, (Parcelable) this.zaqz, i, false);
+        SafeParcelWriter.a(parcel, a);
+    }
+
+    zam(String str, FastJsonResponse.Field<?, ?> field) {
+        this.versionCode = 1;
+        this.zaqy = str;
+        this.zaqz = field;
+    }
+}

sources/com/google/android/gms/common/server/response/zan.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: classes.dex */
+public final class zan implements Parcelable.Creator<zak> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zak createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        ArrayList arrayList = null;
+        int i = 0;
+        String str = null;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 == 2) {
+                arrayList = SafeParcelReader.c(parcel, a, zal.CREATOR);
+            } else if (a2 != 3) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                str = SafeParcelReader.n(parcel, a);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new zak(i, arrayList, str);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zak[] newArray(int i) {
+        return new zak[i];
+    }
+}

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: classes.dex */
+public final class zao implements Parcelable.Creator<zal> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zal createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        String str = null;
+        int i = 0;
+        ArrayList arrayList = null;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 == 2) {
+                str = SafeParcelReader.n(parcel, a);
+            } else if (a2 != 3) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                arrayList = SafeParcelReader.c(parcel, a, zam.CREATOR);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new zal(i, str, arrayList);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ zal[] newArray(int i) {
+        return new zal[i];
+    }
+}

sources/com/google/android/gms/common/server/response/zap.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: classes.dex */
+public final class zap implements Parcelable.Creator<SafeParcelResponse> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ SafeParcelResponse createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        Parcel parcel2 = null;
+        int i = 0;
+        zak zakVar = null;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 == 2) {
+                parcel2 = SafeParcelReader.l(parcel, a);
+            } else if (a2 != 3) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                zakVar = (zak) SafeParcelReader.a(parcel, a, zak.CREATOR);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new SafeParcelResponse(i, parcel2, zakVar);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ SafeParcelResponse[] newArray(int i) {
+        return new SafeParcelResponse[i];
+    }
+}

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: classes.dex */
+public final class zaa implements Parcelable.Creator<FavaDiagnosticsEntity> {
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ FavaDiagnosticsEntity createFromParcel(Parcel parcel) {
+        int b = SafeParcelReader.b(parcel);
+        int i = 0;
+        String str = null;
+        int i2 = 0;
+        while (parcel.dataPosition() < b) {
+            int a = SafeParcelReader.a(parcel);
+            int a2 = SafeParcelReader.a(a);
+            if (a2 == 1) {
+                i = SafeParcelReader.x(parcel, a);
+            } else if (a2 == 2) {
+                str = SafeParcelReader.n(parcel, a);
+            } else if (a2 != 3) {
+                SafeParcelReader.C(parcel, a);
+            } else {
+                i2 = SafeParcelReader.x(parcel, a);
+            }
+        }
+        SafeParcelReader.q(parcel, b);
+        return new FavaDiagnosticsEntity(i, str, i2);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ FavaDiagnosticsEntity[] newArray(int i) {
+        return new FavaDiagnosticsEntity[i];
+    }
+}