Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/com/google/android/gms/common/internal/safeparcel/AbstractSafeParcelable.java

@@ -0,0 +1,9 @@
+package com.google.android.gms.common.internal.safeparcel;
+
+/* loaded from: classes2.dex */
+public abstract class AbstractSafeParcelable implements SafeParcelable {
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/internal/safeparcel/SafeParcelReader.java

@@ -0,0 +1,782 @@
+package com.google.android.gms.common.internal.safeparcel;
+
+import android.app.PendingIntent;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.SparseArray;
+import android.util.SparseBooleanArray;
+import android.util.SparseIntArray;
+import android.util.SparseLongArray;
+import androidx.annotation.NonNull;
+import androidx.core.internal.view.SupportMenu;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class SafeParcelReader {
+
+    public static class ParseException extends RuntimeException {
+        public ParseException(@NonNull String str, @NonNull Parcel parcel) {
+            super(str + " Parcel: pos=" + parcel.dataPosition() + " size=" + parcel.dataSize());
+        }
+    }
+
+    private SafeParcelReader() {
+    }
+
+    @NonNull
+    public static BigDecimal createBigDecimal(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        byte[] createByteArray = parcel.createByteArray();
+        int readInt = parcel.readInt();
+        parcel.setDataPosition(dataPosition + readSize);
+        return new BigDecimal(new BigInteger(createByteArray), readInt);
+    }
+
+    @NonNull
+    public static BigDecimal[] createBigDecimalArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        BigDecimal[] bigDecimalArr = new BigDecimal[readInt];
+        for (int i2 = 0; i2 < readInt; i2++) {
+            byte[] createByteArray = parcel.createByteArray();
+            bigDecimalArr[i2] = new BigDecimal(new BigInteger(createByteArray), parcel.readInt());
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return bigDecimalArr;
+    }
+
+    @NonNull
+    public static BigInteger createBigInteger(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        byte[] createByteArray = parcel.createByteArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return new BigInteger(createByteArray);
+    }
+
+    @NonNull
+    public static BigInteger[] createBigIntegerArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        BigInteger[] bigIntegerArr = new BigInteger[readInt];
+        for (int i2 = 0; i2 < readInt; i2++) {
+            bigIntegerArr[i2] = new BigInteger(parcel.createByteArray());
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return bigIntegerArr;
+    }
+
+    @NonNull
+    public static boolean[] createBooleanArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        boolean[] createBooleanArray = parcel.createBooleanArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createBooleanArray;
+    }
+
+    @NonNull
+    public static ArrayList<Boolean> createBooleanList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<Boolean> arrayList = new ArrayList<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            arrayList.add(Boolean.valueOf(parcel.readInt() != 0));
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return arrayList;
+    }
+
+    @NonNull
+    public static Bundle createBundle(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        Bundle readBundle = parcel.readBundle();
+        parcel.setDataPosition(dataPosition + readSize);
+        return readBundle;
+    }
+
+    @NonNull
+    public static byte[] createByteArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        byte[] createByteArray = parcel.createByteArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createByteArray;
+    }
+
+    @NonNull
+    public static byte[][] createByteArrayArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        byte[][] bArr = new byte[readInt][];
+        for (int i2 = 0; i2 < readInt; i2++) {
+            bArr[i2] = parcel.createByteArray();
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return bArr;
+    }
+
+    @NonNull
+    public static SparseArray<byte[]> createByteArraySparseArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        SparseArray<byte[]> sparseArray = new SparseArray<>(readInt);
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseArray.append(parcel.readInt(), parcel.createByteArray());
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseArray;
+    }
+
+    @NonNull
+    public static char[] createCharArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        char[] createCharArray = parcel.createCharArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createCharArray;
+    }
+
+    @NonNull
+    public static double[] createDoubleArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        double[] createDoubleArray = parcel.createDoubleArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createDoubleArray;
+    }
+
+    @NonNull
+    public static ArrayList<Double> createDoubleList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<Double> arrayList = new ArrayList<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            arrayList.add(Double.valueOf(parcel.readDouble()));
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return arrayList;
+    }
+
+    @NonNull
+    public static SparseArray<Double> createDoubleSparseArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        SparseArray<Double> sparseArray = new SparseArray<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseArray.append(parcel.readInt(), Double.valueOf(parcel.readDouble()));
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseArray;
+    }
+
+    @NonNull
+    public static float[] createFloatArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        float[] createFloatArray = parcel.createFloatArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createFloatArray;
+    }
+
+    @NonNull
+    public static ArrayList<Float> createFloatList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<Float> arrayList = new ArrayList<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            arrayList.add(Float.valueOf(parcel.readFloat()));
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return arrayList;
+    }
+
+    @NonNull
+    public static SparseArray<Float> createFloatSparseArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        SparseArray<Float> sparseArray = new SparseArray<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseArray.append(parcel.readInt(), Float.valueOf(parcel.readFloat()));
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseArray;
+    }
+
+    @NonNull
+    public static IBinder[] createIBinderArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        IBinder[] createBinderArray = parcel.createBinderArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createBinderArray;
+    }
+
+    @NonNull
+    public static ArrayList<IBinder> createIBinderList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<IBinder> createBinderArrayList = parcel.createBinderArrayList();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createBinderArrayList;
+    }
+
+    @NonNull
+    public static SparseArray<IBinder> createIBinderSparseArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        SparseArray<IBinder> sparseArray = new SparseArray<>(readInt);
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseArray.append(parcel.readInt(), parcel.readStrongBinder());
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseArray;
+    }
+
+    @NonNull
+    public static int[] createIntArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int[] createIntArray = parcel.createIntArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createIntArray;
+    }
+
+    @NonNull
+    public static ArrayList<Integer> createIntegerList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<Integer> arrayList = new ArrayList<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            arrayList.add(Integer.valueOf(parcel.readInt()));
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return arrayList;
+    }
+
+    @NonNull
+    public static long[] createLongArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        long[] createLongArray = parcel.createLongArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createLongArray;
+    }
+
+    @NonNull
+    public static ArrayList<Long> createLongList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<Long> arrayList = new ArrayList<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            arrayList.add(Long.valueOf(parcel.readLong()));
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return arrayList;
+    }
+
+    @NonNull
+    public static Parcel createParcel(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        Parcel obtain = Parcel.obtain();
+        obtain.appendFrom(parcel, dataPosition, readSize);
+        parcel.setDataPosition(dataPosition + readSize);
+        return obtain;
+    }
+
+    @NonNull
+    public static Parcel[] createParcelArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        Parcel[] parcelArr = new Parcel[readInt];
+        for (int i2 = 0; i2 < readInt; i2++) {
+            int readInt2 = parcel.readInt();
+            if (readInt2 != 0) {
+                int dataPosition2 = parcel.dataPosition();
+                Parcel obtain = Parcel.obtain();
+                obtain.appendFrom(parcel, dataPosition2, readInt2);
+                parcelArr[i2] = obtain;
+                parcel.setDataPosition(dataPosition2 + readInt2);
+            } else {
+                parcelArr[i2] = null;
+            }
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return parcelArr;
+    }
+
+    @NonNull
+    public static ArrayList<Parcel> createParcelList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        ArrayList<Parcel> arrayList = new ArrayList<>();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            int readInt2 = parcel.readInt();
+            if (readInt2 != 0) {
+                int dataPosition2 = parcel.dataPosition();
+                Parcel obtain = Parcel.obtain();
+                obtain.appendFrom(parcel, dataPosition2, readInt2);
+                arrayList.add(obtain);
+                parcel.setDataPosition(dataPosition2 + readInt2);
+            } else {
+                arrayList.add(null);
+            }
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return arrayList;
+    }
+
+    @NonNull
+    public static SparseArray<Parcel> createParcelSparseArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        SparseArray<Parcel> sparseArray = new SparseArray<>();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            int readInt2 = parcel.readInt();
+            int readInt3 = parcel.readInt();
+            if (readInt3 != 0) {
+                int dataPosition2 = parcel.dataPosition();
+                Parcel obtain = Parcel.obtain();
+                obtain.appendFrom(parcel, dataPosition2, readInt3);
+                sparseArray.append(readInt2, obtain);
+                parcel.setDataPosition(dataPosition2 + readInt3);
+            } else {
+                sparseArray.append(readInt2, null);
+            }
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseArray;
+    }
+
+    @NonNull
+    public static <T extends Parcelable> T createParcelable(@NonNull Parcel parcel, int i, @NonNull Parcelable.Creator<T> creator) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        T createFromParcel = creator.createFromParcel(parcel);
+        parcel.setDataPosition(dataPosition + readSize);
+        return createFromParcel;
+    }
+
+    @NonNull
+    public static SparseBooleanArray createSparseBooleanArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        SparseBooleanArray readSparseBooleanArray = parcel.readSparseBooleanArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return readSparseBooleanArray;
+    }
+
+    @NonNull
+    public static SparseIntArray createSparseIntArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        SparseIntArray sparseIntArray = new SparseIntArray();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseIntArray.append(parcel.readInt(), parcel.readInt());
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseIntArray;
+    }
+
+    @NonNull
+    public static SparseLongArray createSparseLongArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        SparseLongArray sparseLongArray = new SparseLongArray();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseLongArray.append(parcel.readInt(), parcel.readLong());
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseLongArray;
+    }
+
+    @NonNull
+    public static String createString(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        String readString = parcel.readString();
+        parcel.setDataPosition(dataPosition + readSize);
+        return readString;
+    }
+
+    @NonNull
+    public static String[] createStringArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        String[] createStringArray = parcel.createStringArray();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createStringArray;
+    }
+
+    @NonNull
+    public static ArrayList<String> createStringList(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<String> createStringArrayList = parcel.createStringArrayList();
+        parcel.setDataPosition(dataPosition + readSize);
+        return createStringArrayList;
+    }
+
+    @NonNull
+    public static SparseArray<String> createStringSparseArray(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        SparseArray<String> sparseArray = new SparseArray<>();
+        int readInt = parcel.readInt();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseArray.append(parcel.readInt(), parcel.readString());
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseArray;
+    }
+
+    @NonNull
+    public static <T> T[] createTypedArray(@NonNull Parcel parcel, int i, @NonNull Parcelable.Creator<T> creator) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        T[] tArr = (T[]) parcel.createTypedArray(creator);
+        parcel.setDataPosition(dataPosition + readSize);
+        return tArr;
+    }
+
+    @NonNull
+    public static <T> ArrayList<T> createTypedList(@NonNull Parcel parcel, int i, @NonNull Parcelable.Creator<T> creator) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        ArrayList<T> createTypedArrayList = parcel.createTypedArrayList(creator);
+        parcel.setDataPosition(dataPosition + readSize);
+        return createTypedArrayList;
+    }
+
+    @NonNull
+    public static <T> SparseArray<T> createTypedSparseArray(@NonNull Parcel parcel, int i, @NonNull Parcelable.Creator<T> creator) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        int readInt = parcel.readInt();
+        SparseArray<T> sparseArray = new SparseArray<>();
+        for (int i2 = 0; i2 < readInt; i2++) {
+            sparseArray.append(parcel.readInt(), parcel.readInt() != 0 ? creator.createFromParcel(parcel) : null);
+        }
+        parcel.setDataPosition(dataPosition + readSize);
+        return sparseArray;
+    }
+
+    public static void ensureAtEnd(@NonNull Parcel parcel, int i) {
+        if (parcel.dataPosition() == i) {
+            return;
+        }
+        throw new ParseException("Overread allowed size end=" + i, parcel);
+    }
+
+    public static int getFieldId(int i) {
+        return (char) i;
+    }
+
+    public static boolean readBoolean(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 4);
+        return parcel.readInt() != 0;
+    }
+
+    @NonNull
+    public static Boolean readBooleanObject(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        if (readSize == 0) {
+            return null;
+        }
+        zza(parcel, i, readSize, 4);
+        return Boolean.valueOf(parcel.readInt() != 0);
+    }
+
+    public static byte readByte(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 4);
+        return (byte) parcel.readInt();
+    }
+
+    public static char readChar(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 4);
+        return (char) parcel.readInt();
+    }
+
+    public static double readDouble(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 8);
+        return parcel.readDouble();
+    }
+
+    @NonNull
+    public static Double readDoubleObject(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        if (readSize == 0) {
+            return null;
+        }
+        zza(parcel, i, readSize, 8);
+        return Double.valueOf(parcel.readDouble());
+    }
+
+    public static float readFloat(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 4);
+        return parcel.readFloat();
+    }
+
+    @NonNull
+    public static Float readFloatObject(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        if (readSize == 0) {
+            return null;
+        }
+        zza(parcel, i, readSize, 4);
+        return Float.valueOf(parcel.readFloat());
+    }
+
+    public static int readHeader(@NonNull Parcel parcel) {
+        return parcel.readInt();
+    }
+
+    @NonNull
+    public static IBinder readIBinder(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        IBinder readStrongBinder = parcel.readStrongBinder();
+        parcel.setDataPosition(dataPosition + readSize);
+        return readStrongBinder;
+    }
+
+    public static int readInt(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 4);
+        return parcel.readInt();
+    }
+
+    @NonNull
+    public static Integer readIntegerObject(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        if (readSize == 0) {
+            return null;
+        }
+        zza(parcel, i, readSize, 4);
+        return Integer.valueOf(parcel.readInt());
+    }
+
+    public static void readList(@NonNull Parcel parcel, int i, @NonNull List list, @NonNull ClassLoader classLoader) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return;
+        }
+        parcel.readList(list, classLoader);
+        parcel.setDataPosition(dataPosition + readSize);
+    }
+
+    public static long readLong(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 8);
+        return parcel.readLong();
+    }
+
+    @NonNull
+    public static Long readLongObject(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        if (readSize == 0) {
+            return null;
+        }
+        zza(parcel, i, readSize, 8);
+        return Long.valueOf(parcel.readLong());
+    }
+
+    @NonNull
+    public static PendingIntent readPendingIntent(@NonNull Parcel parcel, int i) {
+        int readSize = readSize(parcel, i);
+        int dataPosition = parcel.dataPosition();
+        if (readSize == 0) {
+            return null;
+        }
+        PendingIntent readPendingIntentOrNullFromParcel = PendingIntent.readPendingIntentOrNullFromParcel(parcel);
+        parcel.setDataPosition(dataPosition + readSize);
+        return readPendingIntentOrNullFromParcel;
+    }
+
+    public static short readShort(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i, 4);
+        return (short) parcel.readInt();
+    }
+
+    public static int readSize(@NonNull Parcel parcel, int i) {
+        return (i & SupportMenu.CATEGORY_MASK) != -65536 ? (char) (i >> 16) : parcel.readInt();
+    }
+
+    public static void skipUnknownField(@NonNull Parcel parcel, int i) {
+        parcel.setDataPosition(parcel.dataPosition() + readSize(parcel, i));
+    }
+
+    public static int validateObjectHeader(@NonNull Parcel parcel) {
+        int readHeader = readHeader(parcel);
+        int readSize = readSize(parcel, readHeader);
+        int fieldId = getFieldId(readHeader);
+        int dataPosition = parcel.dataPosition();
+        if (fieldId != 20293) {
+            throw new ParseException("Expected object header. Got 0x".concat(String.valueOf(Integer.toHexString(readHeader))), parcel);
+        }
+        int i = readSize + dataPosition;
+        if (i >= dataPosition && i <= parcel.dataSize()) {
+            return i;
+        }
+        throw new ParseException("Size read is invalid start=" + dataPosition + " end=" + i, parcel);
+    }
+
+    private static void zza(Parcel parcel, int i, int i2, int i3) {
+        if (i2 == i3) {
+            return;
+        }
+        throw new ParseException("Expected size " + i3 + " got " + i2 + " (0x" + Integer.toHexString(i2) + ")", parcel);
+    }
+
+    private static void zzb(Parcel parcel, int i, int i2) {
+        int readSize = readSize(parcel, i);
+        if (readSize == i2) {
+            return;
+        }
+        throw new ParseException("Expected size " + i2 + " got " + readSize + " (0x" + Integer.toHexString(readSize) + ")", parcel);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/internal/safeparcel/SafeParcelWriter.java

@@ -0,0 +1,790 @@
+package com.google.android.gms.common.internal.safeparcel;
+
+import android.app.PendingIntent;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.SparseArray;
+import android.util.SparseBooleanArray;
+import android.util.SparseIntArray;
+import android.util.SparseLongArray;
+import androidx.annotation.NonNull;
+import androidx.core.internal.view.SupportMenu;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public class SafeParcelWriter {
+    private SafeParcelWriter() {
+    }
+
+    public static int beginObjectHeader(@NonNull Parcel parcel) {
+        return zza(parcel, 20293);
+    }
+
+    public static void finishObjectHeader(@NonNull Parcel parcel, int i) {
+        zzb(parcel, i);
+    }
+
+    public static void writeBigDecimal(@NonNull Parcel parcel, int i, @NonNull BigDecimal bigDecimal, boolean z) {
+        if (bigDecimal == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeByteArray(bigDecimal.unscaledValue().toByteArray());
+            parcel.writeInt(bigDecimal.scale());
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeBigDecimalArray(@NonNull Parcel parcel, int i, @NonNull BigDecimal[] bigDecimalArr, boolean z) {
+        if (bigDecimalArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int length = bigDecimalArr.length;
+        parcel.writeInt(length);
+        for (int i2 = 0; i2 < length; i2++) {
+            parcel.writeByteArray(bigDecimalArr[i2].unscaledValue().toByteArray());
+            parcel.writeInt(bigDecimalArr[i2].scale());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeBigInteger(@NonNull Parcel parcel, int i, @NonNull BigInteger bigInteger, boolean z) {
+        if (bigInteger == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeByteArray(bigInteger.toByteArray());
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeBigIntegerArray(@NonNull Parcel parcel, int i, @NonNull BigInteger[] bigIntegerArr, boolean z) {
+        if (bigIntegerArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        parcel.writeInt(bigIntegerArr.length);
+        for (BigInteger bigInteger : bigIntegerArr) {
+            parcel.writeByteArray(bigInteger.toByteArray());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeBoolean(@NonNull Parcel parcel, int i, boolean z) {
+        zzc(parcel, i, 4);
+        parcel.writeInt(z ? 1 : 0);
+    }
+
+    public static void writeBooleanArray(@NonNull Parcel parcel, int i, @NonNull boolean[] zArr, boolean z) {
+        if (zArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeBooleanArray(zArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeBooleanList(@NonNull Parcel parcel, int i, @NonNull List<Boolean> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = list.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(list.get(i2).booleanValue() ? 1 : 0);
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeBooleanObject(@NonNull Parcel parcel, int i, @NonNull Boolean bool, boolean z) {
+        if (bool != null) {
+            zzc(parcel, i, 4);
+            parcel.writeInt(bool.booleanValue() ? 1 : 0);
+        } else if (z) {
+            zzc(parcel, i, 0);
+        }
+    }
+
+    public static void writeBundle(@NonNull Parcel parcel, int i, @NonNull Bundle bundle, boolean z) {
+        if (bundle == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeBundle(bundle);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeByte(@NonNull Parcel parcel, int i, byte b) {
+        zzc(parcel, i, 4);
+        parcel.writeInt(b);
+    }
+
+    public static void writeByteArray(@NonNull Parcel parcel, int i, @NonNull byte[] bArr, boolean z) {
+        if (bArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeByteArray(bArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeByteArrayArray(@NonNull Parcel parcel, int i, @NonNull byte[][] bArr, boolean z) {
+        if (bArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        parcel.writeInt(bArr.length);
+        for (byte[] bArr2 : bArr) {
+            parcel.writeByteArray(bArr2);
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeByteArraySparseArray(@NonNull Parcel parcel, int i, @NonNull SparseArray<byte[]> sparseArray, boolean z) {
+        if (sparseArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseArray.keyAt(i2));
+            parcel.writeByteArray(sparseArray.valueAt(i2));
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeChar(@NonNull Parcel parcel, int i, char c) {
+        zzc(parcel, i, 4);
+        parcel.writeInt(c);
+    }
+
+    public static void writeCharArray(@NonNull Parcel parcel, int i, @NonNull char[] cArr, boolean z) {
+        if (cArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeCharArray(cArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeDouble(@NonNull Parcel parcel, int i, double d) {
+        zzc(parcel, i, 8);
+        parcel.writeDouble(d);
+    }
+
+    public static void writeDoubleArray(@NonNull Parcel parcel, int i, @NonNull double[] dArr, boolean z) {
+        if (dArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeDoubleArray(dArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeDoubleList(@NonNull Parcel parcel, int i, @NonNull List<Double> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = list.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeDouble(list.get(i2).doubleValue());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeDoubleObject(@NonNull Parcel parcel, int i, @NonNull Double d, boolean z) {
+        if (d != null) {
+            zzc(parcel, i, 8);
+            parcel.writeDouble(d.doubleValue());
+        } else if (z) {
+            zzc(parcel, i, 0);
+        }
+    }
+
+    public static void writeDoubleSparseArray(@NonNull Parcel parcel, int i, @NonNull SparseArray<Double> sparseArray, boolean z) {
+        if (sparseArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseArray.keyAt(i2));
+            parcel.writeDouble(sparseArray.valueAt(i2).doubleValue());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeFloat(@NonNull Parcel parcel, int i, float f) {
+        zzc(parcel, i, 4);
+        parcel.writeFloat(f);
+    }
+
+    public static void writeFloatArray(@NonNull Parcel parcel, int i, @NonNull float[] fArr, boolean z) {
+        if (fArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeFloatArray(fArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeFloatList(@NonNull Parcel parcel, int i, @NonNull List<Float> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = list.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeFloat(list.get(i2).floatValue());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeFloatObject(@NonNull Parcel parcel, int i, @NonNull Float f, boolean z) {
+        if (f != null) {
+            zzc(parcel, i, 4);
+            parcel.writeFloat(f.floatValue());
+        } else if (z) {
+            zzc(parcel, i, 0);
+        }
+    }
+
+    public static void writeFloatSparseArray(@NonNull Parcel parcel, int i, @NonNull SparseArray<Float> sparseArray, boolean z) {
+        if (sparseArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseArray.keyAt(i2));
+            parcel.writeFloat(sparseArray.valueAt(i2).floatValue());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeIBinder(@NonNull Parcel parcel, int i, @NonNull IBinder iBinder, boolean z) {
+        if (iBinder == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeStrongBinder(iBinder);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeIBinderArray(@NonNull Parcel parcel, int i, @NonNull IBinder[] iBinderArr, boolean z) {
+        if (iBinderArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeBinderArray(iBinderArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeIBinderList(@NonNull Parcel parcel, int i, @NonNull List<IBinder> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeBinderList(list);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeIBinderSparseArray(@NonNull Parcel parcel, int i, @NonNull SparseArray<IBinder> sparseArray, boolean z) {
+        if (sparseArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseArray.keyAt(i2));
+            parcel.writeStrongBinder(sparseArray.valueAt(i2));
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeInt(@NonNull Parcel parcel, int i, int i2) {
+        zzc(parcel, i, 4);
+        parcel.writeInt(i2);
+    }
+
+    public static void writeIntArray(@NonNull Parcel parcel, int i, @NonNull int[] iArr, boolean z) {
+        if (iArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeIntArray(iArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeIntegerList(@NonNull Parcel parcel, int i, @NonNull List<Integer> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = list.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(list.get(i2).intValue());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeIntegerObject(@NonNull Parcel parcel, int i, @NonNull Integer num, boolean z) {
+        if (num != null) {
+            zzc(parcel, i, 4);
+            parcel.writeInt(num.intValue());
+        } else if (z) {
+            zzc(parcel, i, 0);
+        }
+    }
+
+    public static void writeList(@NonNull Parcel parcel, int i, @NonNull List list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeList(list);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeLong(@NonNull Parcel parcel, int i, long j) {
+        zzc(parcel, i, 8);
+        parcel.writeLong(j);
+    }
+
+    public static void writeLongArray(@NonNull Parcel parcel, int i, @NonNull long[] jArr, boolean z) {
+        if (jArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeLongArray(jArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeLongList(@NonNull Parcel parcel, int i, @NonNull List<Long> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = list.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeLong(list.get(i2).longValue());
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeLongObject(@NonNull Parcel parcel, int i, @NonNull Long l, boolean z) {
+        if (l != null) {
+            zzc(parcel, i, 8);
+            parcel.writeLong(l.longValue());
+        } else if (z) {
+            zzc(parcel, i, 0);
+        }
+    }
+
+    public static void writeParcel(@NonNull Parcel parcel, int i, @NonNull Parcel parcel2, boolean z) {
+        if (parcel2 == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.appendFrom(parcel2, 0, parcel2.dataSize());
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeParcelArray(@NonNull Parcel parcel, int i, @NonNull Parcel[] parcelArr, boolean z) {
+        if (parcelArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        parcel.writeInt(parcelArr.length);
+        for (Parcel parcel2 : parcelArr) {
+            if (parcel2 != null) {
+                parcel.writeInt(parcel2.dataSize());
+                parcel.appendFrom(parcel2, 0, parcel2.dataSize());
+            } else {
+                parcel.writeInt(0);
+            }
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeParcelList(@NonNull Parcel parcel, int i, @NonNull List<Parcel> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = list.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            Parcel parcel2 = list.get(i2);
+            if (parcel2 != null) {
+                parcel.writeInt(parcel2.dataSize());
+                parcel.appendFrom(parcel2, 0, parcel2.dataSize());
+            } else {
+                parcel.writeInt(0);
+            }
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeParcelSparseArray(@NonNull Parcel parcel, int i, @NonNull SparseArray<Parcel> sparseArray, boolean z) {
+        if (sparseArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseArray.keyAt(i2));
+            Parcel valueAt = sparseArray.valueAt(i2);
+            if (valueAt != null) {
+                parcel.writeInt(valueAt.dataSize());
+                parcel.appendFrom(valueAt, 0, valueAt.dataSize());
+            } else {
+                parcel.writeInt(0);
+            }
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeParcelable(@NonNull Parcel parcel, int i, @NonNull Parcelable parcelable, int i2, boolean z) {
+        if (parcelable == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcelable.writeToParcel(parcel, i2);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writePendingIntent(@NonNull Parcel parcel, int i, @NonNull PendingIntent pendingIntent, boolean z) {
+        if (pendingIntent == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            PendingIntent.writePendingIntentOrNullToParcel(pendingIntent, parcel);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeShort(@NonNull Parcel parcel, int i, short s) {
+        zzc(parcel, i, 4);
+        parcel.writeInt(s);
+    }
+
+    public static void writeSparseBooleanArray(@NonNull Parcel parcel, int i, @NonNull SparseBooleanArray sparseBooleanArray, boolean z) {
+        if (sparseBooleanArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeSparseBooleanArray(sparseBooleanArray);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeSparseIntArray(@NonNull Parcel parcel, int i, @NonNull SparseIntArray sparseIntArray, boolean z) {
+        if (sparseIntArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseIntArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseIntArray.keyAt(i2));
+            parcel.writeInt(sparseIntArray.valueAt(i2));
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeSparseLongArray(@NonNull Parcel parcel, int i, @NonNull SparseLongArray sparseLongArray, boolean z) {
+        if (sparseLongArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseLongArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseLongArray.keyAt(i2));
+            parcel.writeLong(sparseLongArray.valueAt(i2));
+        }
+        zzb(parcel, zza);
+    }
+
+    public static void writeString(@NonNull Parcel parcel, int i, @NonNull String str, boolean z) {
+        if (str == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeString(str);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeStringArray(@NonNull Parcel parcel, int i, @NonNull String[] strArr, boolean z) {
+        if (strArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeStringArray(strArr);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeStringList(@NonNull Parcel parcel, int i, @NonNull List<String> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+            }
+        } else {
+            int zza = zza(parcel, i);
+            parcel.writeStringList(list);
+            zzb(parcel, zza);
+        }
+    }
+
+    public static void writeStringSparseArray(@NonNull Parcel parcel, int i, @NonNull SparseArray<String> sparseArray, boolean z) {
+        if (sparseArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseArray.keyAt(i2));
+            parcel.writeString(sparseArray.valueAt(i2));
+        }
+        zzb(parcel, zza);
+    }
+
+    public static <T extends Parcelable> void writeTypedArray(@NonNull Parcel parcel, int i, @NonNull T[] tArr, int i2, boolean z) {
+        if (tArr == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        parcel.writeInt(tArr.length);
+        for (T t : tArr) {
+            if (t == null) {
+                parcel.writeInt(0);
+            } else {
+                zzd(parcel, t, i2);
+            }
+        }
+        zzb(parcel, zza);
+    }
+
+    public static <T extends Parcelable> void writeTypedList(@NonNull Parcel parcel, int i, @NonNull List<T> list, boolean z) {
+        if (list == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = list.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            T t = list.get(i2);
+            if (t == null) {
+                parcel.writeInt(0);
+            } else {
+                zzd(parcel, t, 0);
+            }
+        }
+        zzb(parcel, zza);
+    }
+
+    public static <T extends Parcelable> void writeTypedSparseArray(@NonNull Parcel parcel, int i, @NonNull SparseArray<T> sparseArray, boolean z) {
+        if (sparseArray == null) {
+            if (z) {
+                zzc(parcel, i, 0);
+                return;
+            }
+            return;
+        }
+        int zza = zza(parcel, i);
+        int size = sparseArray.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeInt(sparseArray.keyAt(i2));
+            T valueAt = sparseArray.valueAt(i2);
+            if (valueAt == null) {
+                parcel.writeInt(0);
+            } else {
+                zzd(parcel, valueAt, 0);
+            }
+        }
+        zzb(parcel, zza);
+    }
+
+    private static int zza(Parcel parcel, int i) {
+        parcel.writeInt(i | SupportMenu.CATEGORY_MASK);
+        parcel.writeInt(0);
+        return parcel.dataPosition();
+    }
+
+    private static void zzb(Parcel parcel, int i) {
+        int dataPosition = parcel.dataPosition();
+        parcel.setDataPosition(i - 4);
+        parcel.writeInt(dataPosition - i);
+        parcel.setDataPosition(dataPosition);
+    }
+
+    private static void zzc(Parcel parcel, int i, int i2) {
+        parcel.writeInt(i | (i2 << 16));
+    }
+
+    private static void zzd(Parcel parcel, Parcelable parcelable, int i) {
+        int dataPosition = parcel.dataPosition();
+        parcel.writeInt(1);
+        int dataPosition2 = parcel.dataPosition();
+        parcelable.writeToParcel(parcel, i);
+        int dataPosition3 = parcel.dataPosition();
+        parcel.setDataPosition(dataPosition);
+        parcel.writeInt(dataPosition3 - dataPosition2);
+        parcel.setDataPosition(dataPosition3);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/internal/safeparcel/SafeParcelable.java

@@ -0,0 +1,75 @@
+package com.google.android.gms.common.internal.safeparcel;
+
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes2.dex */
+public interface SafeParcelable extends Parcelable {
+
+    @NonNull
+    public static final String NULL = "SAFE_PARCELABLE_NULL_STRING";
+
+    public @interface Class {
+        @NonNull
+        String creator();
+
+        boolean creatorIsFinal() default true;
+
+        boolean doNotParcelTypeDefaultValues() default false;
+
+        boolean validate() default false;
+    }
+
+    public @interface Constructor {
+    }
+
+    public @interface Field {
+        @NonNull
+        String defaultValue() default "SAFE_PARCELABLE_NULL_STRING";
+
+        @NonNull
+        String defaultValueUnchecked() default "SAFE_PARCELABLE_NULL_STRING";
+
+        @NonNull
+        String getter() default "SAFE_PARCELABLE_NULL_STRING";
+
+        int id();
+
+        @NonNull
+        String type() default "SAFE_PARCELABLE_NULL_STRING";
+    }
+
+    public @interface Indicator {
+        @NonNull
+        String getter() default "SAFE_PARCELABLE_NULL_STRING";
+    }
+
+    public @interface Param {
+        int id();
+    }
+
+    public @interface RemovedParam {
+        @NonNull
+        String defaultValue() default "SAFE_PARCELABLE_NULL_STRING";
+
+        @NonNull
+        String defaultValueUnchecked() default "SAFE_PARCELABLE_NULL_STRING";
+
+        int id();
+    }
+
+    public @interface Reserved {
+        @NonNull
+        int[] value();
+    }
+
+    public @interface VersionField {
+        @NonNull
+        String getter() default "SAFE_PARCELABLE_NULL_STRING";
+
+        int id();
+
+        @NonNull
+        String type() default "SAFE_PARCELABLE_NULL_STRING";
+    }
+}

decompiled-community/sources/com/google/android/gms/common/internal/safeparcel/SafeParcelableSerializer.java

@@ -0,0 +1,171 @@
+package com.google.android.gms.common.internal.safeparcel;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.Base64Utils;
+import com.google.android.gms.internal.common.zzag;
+import com.ironsource.un;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class SafeParcelableSerializer {
+    private SafeParcelableSerializer() {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T extends SafeParcelable> T deserializeFromBytes(@NonNull byte[] bArr, @NonNull Parcelable.Creator<T> creator) {
+        Preconditions.checkNotNull(creator);
+        Parcel obtain = Parcel.obtain();
+        obtain.unmarshall(bArr, 0, bArr.length);
+        obtain.setDataPosition(0);
+        T createFromParcel = creator.createFromParcel(obtain);
+        obtain.recycle();
+        return createFromParcel;
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static <T extends SafeParcelable> T deserializeFromIntentExtra(@NonNull Intent intent, @NonNull String str, @NonNull Parcelable.Creator<T> creator) {
+        byte[] byteArrayExtra = intent.getByteArrayExtra(str);
+        if (byteArrayExtra == null) {
+            return null;
+        }
+        return (T) deserializeFromBytes(byteArrayExtra, creator);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T extends SafeParcelable> T deserializeFromString(@NonNull String str, @NonNull Parcelable.Creator<T> creator) {
+        return (T) deserializeFromBytes(Base64Utils.decodeUrlSafe(str), creator);
+    }
+
+    @Nullable
+    @Deprecated
+    public static <T extends SafeParcelable> ArrayList<T> deserializeIterableFromBundle(@NonNull Bundle bundle, @NonNull String str, @NonNull Parcelable.Creator<T> creator) {
+        ArrayList arrayList = (ArrayList) bundle.getSerializable(str);
+        if (arrayList == null) {
+            return null;
+        }
+        un.a aVar = (ArrayList<T>) new ArrayList(arrayList.size());
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            aVar.add(deserializeFromBytes((byte[]) arrayList.get(i), creator));
+        }
+        return aVar;
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static <T extends SafeParcelable> ArrayList<T> deserializeIterableFromBundleSafe(@NonNull Bundle bundle, @NonNull String str, @NonNull Parcelable.Creator<T> creator) {
+        return deserializeIterableFromBytes(bundle.getByteArray(str), creator);
+    }
+
+    @Nullable
+    public static <T extends SafeParcelable> ArrayList<T> deserializeIterableFromBytes(@Nullable byte[] bArr, @NonNull Parcelable.Creator<T> creator) {
+        if (bArr == null) {
+            return null;
+        }
+        Parcel obtain = Parcel.obtain();
+        obtain.unmarshall(bArr, 0, bArr.length);
+        obtain.setDataPosition(0);
+        try {
+            ArrayList<T> arrayList = new ArrayList<>();
+            obtain.readTypedList(arrayList, creator);
+            return arrayList;
+        } finally {
+            obtain.recycle();
+        }
+    }
+
+    @Nullable
+    @KeepForSdk
+    @Deprecated
+    public static <T extends SafeParcelable> ArrayList<T> deserializeIterableFromIntentExtra(@NonNull Intent intent, @NonNull String str, @NonNull Parcelable.Creator<T> creator) {
+        ArrayList arrayList = (ArrayList) intent.getSerializableExtra(str);
+        if (arrayList == null) {
+            return null;
+        }
+        un.a aVar = (ArrayList<T>) new ArrayList(arrayList.size());
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            aVar.add(deserializeFromBytes((byte[]) arrayList.get(i), creator));
+        }
+        return aVar;
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static <T extends SafeParcelable> ArrayList<T> deserializeIterableFromIntentExtraSafe(@NonNull Intent intent, @NonNull String str, @NonNull Parcelable.Creator<T> creator) {
+        return deserializeIterableFromBytes(intent.getByteArrayExtra(str), creator);
+    }
+
+    @Deprecated
+    public static <T extends SafeParcelable> void serializeIterableToBundle(@NonNull Iterable<T> iterable, @NonNull Bundle bundle, @NonNull String str) {
+        ArrayList arrayList = new ArrayList();
+        Iterator<T> it = iterable.iterator();
+        while (it.hasNext()) {
+            arrayList.add(serializeToBytes(it.next()));
+        }
+        bundle.putSerializable(str, arrayList);
+    }
+
+    public static <T extends SafeParcelable> void serializeIterableToBundleSafe(@NonNull Iterable<T> iterable, @NonNull Bundle bundle, @NonNull String str) {
+        bundle.putByteArray(str, zza(iterable));
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static <T extends SafeParcelable> void serializeIterableToIntentExtra(@NonNull Iterable<T> iterable, @NonNull Intent intent, @NonNull String str) {
+        ArrayList arrayList = new ArrayList();
+        Iterator<T> it = iterable.iterator();
+        while (it.hasNext()) {
+            arrayList.add(serializeToBytes(it.next()));
+        }
+        intent.putExtra(str, arrayList);
+    }
+
+    @KeepForSdk
+    public static <T extends SafeParcelable> void serializeIterableToIntentExtraSafe(@NonNull Iterable<T> iterable, @NonNull Intent intent, @NonNull String str) {
+        intent.putExtra(str, zza(iterable));
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T extends SafeParcelable> byte[] serializeToBytes(@NonNull T t) {
+        Parcel obtain = Parcel.obtain();
+        t.writeToParcel(obtain, 0);
+        byte[] marshall = obtain.marshall();
+        obtain.recycle();
+        return marshall;
+    }
+
+    @KeepForSdk
+    public static <T extends SafeParcelable> void serializeToIntentExtra(@NonNull T t, @NonNull Intent intent, @NonNull String str) {
+        intent.putExtra(str, serializeToBytes(t));
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T extends SafeParcelable> String serializeToString(@NonNull T t) {
+        return Base64Utils.encodeUrlSafe(serializeToBytes(t));
+    }
+
+    private static byte[] zza(Iterable iterable) {
+        Parcel obtain = Parcel.obtain();
+        try {
+            obtain.writeTypedList(zzag.zzj(iterable));
+            return obtain.marshall();
+        } finally {
+            obtain.recycle();
+        }
+    }
+}