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

apk_decompiled/sources/androidx/datastore/preferences/protobuf/A.java

@@ -0,0 +1,36 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.io.IOException;
+
+/* loaded from: classes.dex */
+public class A extends IOException {
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.A, java.io.IOException] */
+    public static A a() {
+        return new IOException("Protocol message had invalid UTF-8.");
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.z, java.io.IOException] */
+    public static C0134z b() {
+        return new IOException("Protocol message tag had invalid wire type.");
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.A, java.io.IOException] */
+    public static A c() {
+        return new IOException("CodedInputStream encountered a malformed varint.");
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.A, java.io.IOException] */
+    public static A d() {
+        return new IOException("CodedInputStream encountered an embedded string or message which claimed to have negative size.");
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.A, java.io.IOException] */
+    public static A e() {
+        return new IOException("Failed to parse the message.");
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.A, java.io.IOException] */
+    public static A f() {
+        return new IOException("While parsing a protocol message, the input ended unexpectedly in the middle of a field.  This could mean either that the input has been truncated or that an embedded message misreported its own length.");
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/A0.java

@@ -0,0 +1,80 @@
+package androidx.datastore.preferences.protobuf;
+
+/* JADX WARN: Enum visitor error
+jadx.core.utils.exceptions.JadxRuntimeException: Init of enum field 'EF12' uses external variables
+	at jadx.core.dex.visitors.EnumVisitor.createEnumFieldByConstructor(EnumVisitor.java:451)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByRegister(EnumVisitor.java:395)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromFilledArray(EnumVisitor.java:324)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:262)
+	at jadx.core.dex.visitors.EnumVisitor.convertToEnum(EnumVisitor.java:151)
+	at jadx.core.dex.visitors.EnumVisitor.visit(EnumVisitor.java:100)
+ */
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* loaded from: classes.dex */
+public class A0 {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final w0 f2821c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final x0 f2822d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final y0 f2823e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final /* synthetic */ A0[] f2824f;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final B0 f2825a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final int f2826b;
+
+    /* JADX INFO: Fake field, exist only in values array */
+    A0 EF10;
+
+    /* JADX INFO: Fake field, exist only in values array */
+    A0 EF11;
+
+    /* JADX INFO: Fake field, exist only in values array */
+    A0 EF12;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v2, types: [androidx.datastore.preferences.protobuf.A0, androidx.datastore.preferences.protobuf.w0] */
+    /* JADX WARN: Type inference failed for: r2v2, types: [androidx.datastore.preferences.protobuf.A0, androidx.datastore.preferences.protobuf.y0] */
+    /* JADX WARN: Type inference failed for: r8v2, types: [androidx.datastore.preferences.protobuf.A0, androidx.datastore.preferences.protobuf.x0] */
+    static {
+        A0 a02 = new A0("DOUBLE", 0, B0.DOUBLE, 1);
+        A0 a03 = new A0("FLOAT", 1, B0.FLOAT, 5);
+        B0 b02 = B0.LONG;
+        A0 a04 = new A0("INT64", 2, b02, 0);
+        A0 a05 = new A0("UINT64", 3, b02, 0);
+        B0 b03 = B0.INT;
+        A0 a06 = new A0("INT32", 4, b03, 0);
+        A0 a07 = new A0("FIXED64", 5, b02, 1);
+        A0 a08 = new A0("FIXED32", 6, b03, 5);
+        A0 a09 = new A0("BOOL", 7, B0.BOOLEAN, 0);
+        ?? a010 = new A0("STRING", 8, B0.STRING, 2);
+        f2821c = a010;
+        B0 b04 = B0.MESSAGE;
+        ?? a011 = new A0("GROUP", 9, b04, 3);
+        f2822d = a011;
+        ?? a012 = new A0("MESSAGE", 10, b04, 2);
+        f2823e = a012;
+        f2824f = new A0[]{a02, a03, a04, a05, a06, a07, a08, a09, a010, a011, a012, new A0("BYTES", 11, B0.BYTE_STRING, 2), new A0("UINT32", 12, b03, 0), new A0("ENUM", 13, B0.ENUM, 0), new A0("SFIXED32", 14, b03, 5), new A0("SFIXED64", 15, b02, 1), new A0("SINT32", 16, b03, 0), new A0("SINT64", 17, b02, 0)};
+    }
+
+    public A0(String str, int i, B0 b02, int i4) {
+        this.f2825a = b02;
+        this.f2826b = i4;
+    }
+
+    public static A0 valueOf(String str) {
+        return (A0) Enum.valueOf(A0.class, str);
+    }
+
+    public static A0[] values() {
+        return (A0[]) f2824f.clone();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0108a.java

@@ -0,0 +1,22 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0108a {
+    protected int memoizedHashCode;
+
+    public abstract int a();
+
+    public final int b(InterfaceC0111b0 interfaceC0111b0) {
+        AbstractC0130v abstractC0130v = (AbstractC0130v) this;
+        int i = abstractC0130v.memoizedSerializedSize;
+        if (i != -1) {
+            return i;
+        }
+        int e4 = interfaceC0111b0.e(this);
+        abstractC0130v.memoizedSerializedSize = e4;
+        return e4;
+    }
+
+    public abstract void c(C0119j c0119j);
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0110b.java

@@ -0,0 +1,96 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.AbstractList;
+import java.util.Collection;
+import java.util.List;
+import java.util.RandomAccess;
+
+/* renamed from: androidx.datastore.preferences.protobuf.b, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0110b extends AbstractList implements InterfaceC0132x {
+
+    /* renamed from: a, reason: collision with root package name */
+    public boolean f2891a = true;
+
+    public final void a() {
+        if (!this.f2891a) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean add(Object obj) {
+        a();
+        return super.add(obj);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean addAll(Collection collection) {
+        a();
+        return super.addAll(collection);
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public void clear() {
+        a();
+        super.clear();
+    }
+
+    @Override // java.util.AbstractList, java.util.Collection, java.util.List
+    public final boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof List)) {
+            return false;
+        }
+        if (!(obj instanceof RandomAccess)) {
+            return super.equals(obj);
+        }
+        List list = (List) obj;
+        int size = size();
+        if (size != list.size()) {
+            return false;
+        }
+        for (int i = 0; i < size; i++) {
+            if (!get(i).equals(list.get(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.Collection, java.util.List
+    public final int hashCode() {
+        int size = size();
+        int i = 1;
+        for (int i4 = 0; i4 < size; i4++) {
+            i = (i * 31) + get(i4).hashCode();
+        }
+        return i;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean remove(Object obj) {
+        a();
+        return super.remove(obj);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean removeAll(Collection collection) {
+        a();
+        return super.removeAll(collection);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean retainAll(Collection collection) {
+        a();
+        return super.retainAll(collection);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public boolean addAll(int i, Collection collection) {
+        a();
+        return super.addAll(i, collection);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0112c.java

@@ -0,0 +1,32 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.c, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0112c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Class f2892a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final boolean f2893b;
+
+    static {
+        Class<?> cls;
+        Class<?> cls2 = null;
+        try {
+            cls = Class.forName("libcore.io.Memory");
+        } catch (Throwable unused) {
+            cls = null;
+        }
+        f2892a = cls;
+        try {
+            cls2 = Class.forName("org.robolectric.Robolectric");
+        } catch (Throwable unused2) {
+        }
+        f2893b = cls2 != null;
+    }
+
+    public static boolean a() {
+        return (f2892a == null || f2893b) ? false : true;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0113d.java

@@ -0,0 +1,8 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.RandomAccess;
+
+/* renamed from: androidx.datastore.preferences.protobuf.d, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0113d extends AbstractC0110b implements RandomAccess, X {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0120k.java

@@ -0,0 +1,8 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.RandomAccess;
+
+/* renamed from: androidx.datastore.preferences.protobuf.k, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0120k extends AbstractC0110b implements RandomAccess, X {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0121l.java

@@ -0,0 +1,19 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.l, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0121l {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Class f2941a;
+
+    static {
+        Class<?> cls;
+        try {
+            cls = Class.forName("androidx.datastore.preferences.protobuf.ExtensionRegistry");
+        } catch (ClassNotFoundException unused) {
+            cls = null;
+        }
+        f2941a = cls;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0124o.java

@@ -0,0 +1,23 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.o, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0124o {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0123n f2948a = new Object();
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final C0123n f2949b;
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.n, java.lang.Object] */
+    static {
+        C0123n c0123n;
+        try {
+            c0123n = (C0123n) Class.forName("androidx.datastore.preferences.protobuf.ExtensionSchemaFull").getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (Exception unused) {
+            c0123n = null;
+        }
+        f2949b = c0123n;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0128t.java

@@ -0,0 +1,64 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.t, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0128t implements Cloneable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final AbstractC0130v f2970a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public AbstractC0130v f2971b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f2972c = false;
+
+    public AbstractC0128t(AbstractC0130v abstractC0130v) {
+        this.f2970a = abstractC0130v;
+        this.f2971b = (AbstractC0130v) abstractC0130v.d(4);
+    }
+
+    public static void d(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2) {
+        Y y3 = Y.f2881c;
+        y3.getClass();
+        y3.a(abstractC0130v.getClass()).h(abstractC0130v, abstractC0130v2);
+    }
+
+    public final AbstractC0130v a() {
+        AbstractC0130v b4 = b();
+        if (b4.g()) {
+            return b4;
+        }
+        throw new Q2.j();
+    }
+
+    public final AbstractC0130v b() {
+        if (this.f2972c) {
+            return this.f2971b;
+        }
+        AbstractC0130v abstractC0130v = this.f2971b;
+        abstractC0130v.getClass();
+        Y y3 = Y.f2881c;
+        y3.getClass();
+        y3.a(abstractC0130v.getClass()).d(abstractC0130v);
+        this.f2972c = true;
+        return this.f2971b;
+    }
+
+    public final void c() {
+        if (this.f2972c) {
+            AbstractC0130v abstractC0130v = (AbstractC0130v) this.f2971b.d(4);
+            d(abstractC0130v, this.f2971b);
+            this.f2971b = abstractC0130v;
+            this.f2972c = false;
+        }
+    }
+
+    public final Object clone() {
+        AbstractC0128t abstractC0128t = (AbstractC0128t) this.f2970a.d(5);
+        AbstractC0130v b4 = b();
+        abstractC0128t.c();
+        d(abstractC0128t.f2971b, b4);
+        return abstractC0128t;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0130v.java

@@ -0,0 +1,134 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* renamed from: androidx.datastore.preferences.protobuf.v, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0130v extends AbstractC0108a {
+    private static Map<Object, AbstractC0130v> defaultInstanceMap = new ConcurrentHashMap();
+    protected int memoizedSerializedSize;
+    protected j0 unknownFields;
+
+    public AbstractC0130v() {
+        this.memoizedHashCode = 0;
+        this.unknownFields = j0.f2935f;
+        this.memoizedSerializedSize = -1;
+    }
+
+    public static AbstractC0130v e(Class cls) {
+        AbstractC0130v abstractC0130v = defaultInstanceMap.get(cls);
+        if (abstractC0130v == null) {
+            try {
+                Class.forName(cls.getName(), true, cls.getClassLoader());
+                abstractC0130v = defaultInstanceMap.get(cls);
+            } catch (ClassNotFoundException e4) {
+                throw new IllegalStateException("Class initialization cannot fail.", e4);
+            }
+        }
+        if (abstractC0130v != null) {
+            return abstractC0130v;
+        }
+        AbstractC0130v abstractC0130v2 = (AbstractC0130v) ((AbstractC0130v) s0.a(cls)).d(6);
+        if (abstractC0130v2 == null) {
+            throw new IllegalStateException();
+        }
+        defaultInstanceMap.put(cls, abstractC0130v2);
+        return abstractC0130v2;
+    }
+
+    public static Object f(Method method, AbstractC0108a abstractC0108a, Object... objArr) {
+        try {
+            return method.invoke(abstractC0108a, objArr);
+        } catch (IllegalAccessException e4) {
+            throw new RuntimeException("Couldn't use Java reflection to implement protocol message reflection.", e4);
+        } catch (InvocationTargetException e5) {
+            Throwable cause = e5.getCause();
+            if (cause instanceof RuntimeException) {
+                throw ((RuntimeException) cause);
+            }
+            if (cause instanceof Error) {
+                throw ((Error) cause);
+            }
+            throw new RuntimeException("Unexpected exception thrown by generated accessor method.", cause);
+        }
+    }
+
+    public static void h(Class cls, AbstractC0130v abstractC0130v) {
+        defaultInstanceMap.put(cls, abstractC0130v);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.AbstractC0108a
+    public final int a() {
+        if (this.memoizedSerializedSize == -1) {
+            Y y3 = Y.f2881c;
+            y3.getClass();
+            this.memoizedSerializedSize = y3.a(getClass()).e(this);
+        }
+        return this.memoizedSerializedSize;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.AbstractC0108a
+    public final void c(C0119j c0119j) {
+        Y y3 = Y.f2881c;
+        y3.getClass();
+        InterfaceC0111b0 a2 = y3.a(getClass());
+        J j4 = c0119j.f2930c;
+        if (j4 == null) {
+            j4 = new J(c0119j);
+        }
+        a2.a(this, j4);
+    }
+
+    public abstract Object d(int i);
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!((AbstractC0130v) d(6)).getClass().isInstance(obj)) {
+            return false;
+        }
+        Y y3 = Y.f2881c;
+        y3.getClass();
+        return y3.a(getClass()).g(this, (AbstractC0130v) obj);
+    }
+
+    public final boolean g() {
+        byte byteValue = ((Byte) d(1)).byteValue();
+        if (byteValue == 1) {
+            return true;
+        }
+        if (byteValue == 0) {
+            return false;
+        }
+        Y y3 = Y.f2881c;
+        y3.getClass();
+        boolean f2 = y3.a(getClass()).f(this);
+        d(2);
+        return f2;
+    }
+
+    public final int hashCode() {
+        int i = this.memoizedHashCode;
+        if (i != 0) {
+            return i;
+        }
+        Y y3 = Y.f2881c;
+        y3.getClass();
+        int b4 = y3.a(getClass()).b(this);
+        this.memoizedHashCode = b4;
+        return b4;
+    }
+
+    public final String toString() {
+        String obj = super.toString();
+        StringBuilder sb = new StringBuilder();
+        sb.append("# ");
+        sb.append(obj);
+        Q.k(this, sb, 0);
+        return sb.toString();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0131w.java

@@ -0,0 +1,8 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.RandomAccess;
+
+/* renamed from: androidx.datastore.preferences.protobuf.w, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0131w extends AbstractC0110b implements RandomAccess, X {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/AbstractC0133y.java

@@ -0,0 +1,54 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+
+/* renamed from: androidx.datastore.preferences.protobuf.y, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0133y {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Charset f2975a = Charset.forName("UTF-8");
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final byte[] f2976b;
+
+    static {
+        Charset.forName("ISO-8859-1");
+        byte[] bArr = new byte[0];
+        f2976b = bArr;
+        ByteBuffer.wrap(bArr);
+        if (0 + 0 <= Integer.MAX_VALUE) {
+            return;
+        }
+        try {
+            throw A.f();
+        } catch (A e4) {
+            throw new IllegalArgumentException(e4);
+        }
+    }
+
+    public static void a(Object obj, String str) {
+        if (obj == null) {
+            throw new NullPointerException(str);
+        }
+    }
+
+    public static int b(long j4) {
+        return (int) (j4 ^ (j4 >>> 32));
+    }
+
+    public static AbstractC0130v c(Object obj, Object obj2) {
+        AbstractC0130v abstractC0130v = (AbstractC0130v) ((AbstractC0108a) obj);
+        AbstractC0128t abstractC0128t = (AbstractC0128t) abstractC0130v.d(5);
+        abstractC0128t.c();
+        AbstractC0128t.d(abstractC0128t.f2971b, abstractC0130v);
+        AbstractC0108a abstractC0108a = (AbstractC0108a) obj2;
+        if (!abstractC0128t.f2970a.getClass().isInstance(abstractC0108a)) {
+            throw new IllegalArgumentException("mergeFrom(MessageLite) can only merge messages of the same type.");
+        }
+        abstractC0128t.c();
+        AbstractC0128t.d(abstractC0128t.f2971b, (AbstractC0130v) abstractC0108a);
+        return abstractC0128t.b();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/B.java

@@ -0,0 +1,27 @@
+package androidx.datastore.preferences.protobuf;
+
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import com.google.firebase.remoteconfig.FirebaseRemoteConfig;
+import java.io.Serializable;
+
+/* loaded from: classes.dex */
+public enum B {
+    VOID(Void.class, null),
+    INT(Integer.class, 0),
+    LONG(Long.class, 0L),
+    FLOAT(Float.class, Float.valueOf(BitmapDescriptorFactory.HUE_RED)),
+    DOUBLE(Double.class, Double.valueOf(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_DOUBLE)),
+    BOOLEAN(Boolean.class, Boolean.FALSE),
+    STRING(String.class, ""),
+    BYTE_STRING(C0116g.class, C0116g.f2909c),
+    ENUM(Integer.class, null),
+    MESSAGE(Object.class, null);
+
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Serializable f2836a;
+
+    B(Class cls, Serializable serializable) {
+        this.f2836a = serializable;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/B0.java

@@ -0,0 +1,26 @@
+package androidx.datastore.preferences.protobuf;
+
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import com.google.firebase.remoteconfig.FirebaseRemoteConfig;
+import java.io.Serializable;
+
+/* loaded from: classes.dex */
+public enum B0 {
+    INT(0),
+    LONG(0L),
+    FLOAT(Float.valueOf(BitmapDescriptorFactory.HUE_RED)),
+    DOUBLE(Double.valueOf(FirebaseRemoteConfig.DEFAULT_VALUE_FOR_DOUBLE)),
+    BOOLEAN(Boolean.FALSE),
+    STRING(""),
+    BYTE_STRING(C0116g.f2909c),
+    ENUM(null),
+    MESSAGE(null);
+
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Serializable f2845a;
+
+    B0(Serializable serializable) {
+        this.f2845a = serializable;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C.java

@@ -0,0 +1,167 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.nio.charset.Charset;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.RandomAccess;
+
+/* loaded from: classes.dex */
+public final class C extends AbstractC0110b implements D, RandomAccess {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final ArrayList f2846b;
+
+    static {
+        new C(10).f2891a = false;
+    }
+
+    public C(int i) {
+        this(new ArrayList(i));
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        a();
+        this.f2846b.add(i, (String) obj);
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.AbstractC0110b, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean addAll(Collection collection) {
+        return addAll(this.f2846b.size(), collection);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.AbstractC0110b, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final void clear() {
+        a();
+        this.f2846b.clear();
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0132x
+    public final InterfaceC0132x d(int i) {
+        ArrayList arrayList = this.f2846b;
+        if (i < arrayList.size()) {
+            throw new IllegalArgumentException();
+        }
+        ArrayList arrayList2 = new ArrayList(i);
+        arrayList2.addAll(arrayList);
+        return new C(arrayList2);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final void e(C0116g c0116g) {
+        a();
+        this.f2846b.add(c0116g);
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        String str;
+        ArrayList arrayList = this.f2846b;
+        Object obj = arrayList.get(i);
+        if (obj instanceof String) {
+            return (String) obj;
+        }
+        if (!(obj instanceof C0116g)) {
+            byte[] bArr = (byte[]) obj;
+            String str2 = new String(bArr, AbstractC0133y.f2975a);
+            Q q4 = v0.f2974a;
+            if (v0.f2974a.i(bArr, 0, bArr.length) == 0) {
+                arrayList.set(i, str2);
+            }
+            return str2;
+        }
+        C0116g c0116g = (C0116g) obj;
+        c0116g.getClass();
+        Charset charset = AbstractC0133y.f2975a;
+        if (c0116g.size() == 0) {
+            str = "";
+        } else {
+            str = new String(c0116g.f2912b, c0116g.b(), c0116g.size(), charset);
+        }
+        int b4 = c0116g.b();
+        if (v0.f2974a.i(c0116g.f2912b, b4, c0116g.size() + b4) == 0) {
+            arrayList.set(i, str);
+        }
+        return str;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final List getUnderlyingElements() {
+        return Collections.unmodifiableList(this.f2846b);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final D getUnmodifiableView() {
+        return this.f2891a ? new n0(this) : this;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        a();
+        Object remove = this.f2846b.remove(i);
+        ((AbstractList) this).modCount++;
+        if (remove instanceof String) {
+            return (String) remove;
+        }
+        if (!(remove instanceof C0116g)) {
+            return new String((byte[]) remove, AbstractC0133y.f2975a);
+        }
+        C0116g c0116g = (C0116g) remove;
+        c0116g.getClass();
+        Charset charset = AbstractC0133y.f2975a;
+        if (c0116g.size() == 0) {
+            return "";
+        }
+        return new String(c0116g.f2912b, c0116g.b(), c0116g.size(), charset);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final Object s(int i) {
+        return this.f2846b.get(i);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        a();
+        Object obj2 = this.f2846b.set(i, (String) obj);
+        if (obj2 instanceof String) {
+            return (String) obj2;
+        }
+        if (!(obj2 instanceof C0116g)) {
+            return new String((byte[]) obj2, AbstractC0133y.f2975a);
+        }
+        C0116g c0116g = (C0116g) obj2;
+        c0116g.getClass();
+        Charset charset = AbstractC0133y.f2975a;
+        if (c0116g.size() == 0) {
+            return "";
+        }
+        return new String(c0116g.f2912b, c0116g.b(), c0116g.size(), charset);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.f2846b.size();
+    }
+
+    public C(ArrayList arrayList) {
+        this.f2846b = arrayList;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.AbstractC0110b, java.util.AbstractList, java.util.List
+    public final boolean addAll(int i, Collection collection) {
+        a();
+        if (collection instanceof D) {
+            collection = ((D) collection).getUnderlyingElements();
+        }
+        boolean addAll = this.f2846b.addAll(i, collection);
+        ((AbstractList) this).modCount++;
+        return addAll;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0109a0.java

@@ -0,0 +1,44 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.a0, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0109a0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final AbstractC0130v f2887a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final String f2888b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Object[] f2889c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final int f2890d;
+
+    public C0109a0(AbstractC0130v abstractC0130v, String str, Object[] objArr) {
+        this.f2887a = abstractC0130v;
+        this.f2888b = str;
+        this.f2889c = objArr;
+        char charAt = str.charAt(0);
+        if (charAt < 55296) {
+            this.f2890d = charAt;
+            return;
+        }
+        int i = charAt & 8191;
+        int i4 = 1;
+        int i5 = 13;
+        while (true) {
+            int i6 = i4 + 1;
+            char charAt2 = str.charAt(i4);
+            if (charAt2 < 55296) {
+                this.f2890d = i | (charAt2 << i5);
+                return;
+            } else {
+                i |= (charAt2 & 8191) << i5;
+                i5 += 13;
+                i4 = i6;
+            }
+        }
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0114e.java

@@ -0,0 +1,43 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/* renamed from: androidx.datastore.preferences.protobuf.e, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0114e implements Iterator {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f2905a = 0;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final int f2906b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ C0116g f2907c;
+
+    public C0114e(C0116g c0116g) {
+        this.f2907c = c0116g;
+        this.f2906b = c0116g.size();
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        return this.f2905a < this.f2906b;
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        int i = this.f2905a;
+        if (i >= this.f2906b) {
+            throw new NoSuchElementException();
+        }
+        this.f2905a = i + 1;
+        return Byte.valueOf(this.f2907c.f2912b[i]);
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0115f.java

@@ -0,0 +1,9 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.f, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0115f {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f2908a;
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0116g.java

@@ -0,0 +1,132 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Iterator;
+
+/* renamed from: androidx.datastore.preferences.protobuf.g, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public class C0116g implements Iterable, Serializable {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final C0116g f2909c = new C0116g(AbstractC0133y.f2976b);
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final C0115f f2910d;
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f2911a = 0;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final byte[] f2912b;
+
+    static {
+        f2910d = AbstractC0112c.a() ? new C0115f(1) : new C0115f(0);
+    }
+
+    public C0116g(byte[] bArr) {
+        bArr.getClass();
+        this.f2912b = bArr;
+    }
+
+    public static C0116g a(int i, int i4, byte[] bArr) {
+        byte[] copyOfRange;
+        int i5 = i + i4;
+        int length = bArr.length;
+        if (((i5 - i) | i | i5 | (length - i5)) < 0) {
+            if (i < 0) {
+                throw new IndexOutOfBoundsException(C.w.i(i, "Beginning index: ", " < 0"));
+            }
+            if (i5 < i) {
+                throw new IndexOutOfBoundsException(C.w.k("Beginning index larger than ending index: ", i, i5, ", "));
+            }
+            throw new IndexOutOfBoundsException(C.w.k("End index: ", i5, length, " >= "));
+        }
+        switch (f2910d.f2908a) {
+            case 0:
+                copyOfRange = Arrays.copyOfRange(bArr, i, i4 + i);
+                break;
+            default:
+                copyOfRange = new byte[i4];
+                System.arraycopy(bArr, i, copyOfRange, 0, i4);
+                break;
+        }
+        return new C0116g(copyOfRange);
+    }
+
+    public int b() {
+        return 0;
+    }
+
+    public final boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof C0116g) || size() != ((C0116g) obj).size()) {
+            return false;
+        }
+        if (size() == 0) {
+            return true;
+        }
+        if (!(obj instanceof C0116g)) {
+            return obj.equals(this);
+        }
+        C0116g c0116g = (C0116g) obj;
+        int i = this.f2911a;
+        int i4 = c0116g.f2911a;
+        if (i != 0 && i4 != 0 && i != i4) {
+            return false;
+        }
+        int size = size();
+        if (size > c0116g.size()) {
+            throw new IllegalArgumentException("Length too large: " + size + size());
+        }
+        if (size > c0116g.size()) {
+            StringBuilder t2 = C.w.t(size, "Ran off end of other: 0, ", ", ");
+            t2.append(c0116g.size());
+            throw new IllegalArgumentException(t2.toString());
+        }
+        int b4 = b() + size;
+        int b5 = b();
+        int b6 = c0116g.b();
+        while (b5 < b4) {
+            if (this.f2912b[b5] != c0116g.f2912b[b6]) {
+                return false;
+            }
+            b5++;
+            b6++;
+        }
+        return true;
+    }
+
+    public final int hashCode() {
+        int i = this.f2911a;
+        if (i != 0) {
+            return i;
+        }
+        int size = size();
+        int b4 = b();
+        int i4 = size;
+        for (int i5 = b4; i5 < b4 + size; i5++) {
+            i4 = (i4 * 31) + this.f2912b[i5];
+        }
+        if (i4 == 0) {
+            i4 = 1;
+        }
+        this.f2911a = i4;
+        return i4;
+    }
+
+    @Override // java.lang.Iterable
+    public final Iterator iterator() {
+        return new C0114e(this);
+    }
+
+    public int size() {
+        return this.f2912b.length;
+    }
+
+    public final String toString() {
+        return String.format("<ByteString@%s size=%d>", Integer.toHexString(System.identityHashCode(this)), Integer.valueOf(size()));
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0117h.java

@@ -0,0 +1,599 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Iterator;
+import kotlin.UByte;
+import kotlin.io.ConstantsKt;
+import kotlin.jvm.internal.ByteCompanionObject;
+
+/* renamed from: androidx.datastore.preferences.protobuf.h, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0117h {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f2916a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Z2.y f2917b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final FileInputStream f2918c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final byte[] f2919d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public int f2920e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public int f2921f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public int f2922g;
+    public int h;
+    public int i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public int f2923j = Integer.MAX_VALUE;
+
+    public C0117h(FileInputStream fileInputStream) {
+        Charset charset = AbstractC0133y.f2975a;
+        this.f2918c = fileInputStream;
+        this.f2919d = new byte[ConstantsKt.DEFAULT_BLOCK_SIZE];
+        this.f2920e = 0;
+        this.f2922g = 0;
+        this.i = 0;
+    }
+
+    public final int A() {
+        return s();
+    }
+
+    public final long B() {
+        return t();
+    }
+
+    public final void C() {
+        int i = this.f2920e + this.f2921f;
+        this.f2920e = i;
+        int i4 = this.i + i;
+        int i5 = this.f2923j;
+        if (i4 <= i5) {
+            this.f2921f = 0;
+            return;
+        }
+        int i6 = i4 - i5;
+        this.f2921f = i6;
+        this.f2920e = i - i6;
+    }
+
+    public final void D(int i) {
+        if (G(i)) {
+            return;
+        }
+        if (i <= (Integer.MAX_VALUE - this.i) - this.f2922g) {
+            throw A.f();
+        }
+        throw new IOException("Protocol message was too large.  May be malicious.  Use CodedInputStream.setSizeLimit() to increase the size limit.");
+    }
+
+    public final boolean E(int i) {
+        int z3;
+        int i4 = i & 7;
+        int i5 = 0;
+        if (i4 == 0) {
+            int i6 = this.f2920e - this.f2922g;
+            byte[] bArr = this.f2919d;
+            if (i6 >= 10) {
+                while (i5 < 10) {
+                    int i7 = this.f2922g;
+                    this.f2922g = i7 + 1;
+                    if (bArr[i7] < 0) {
+                        i5++;
+                    }
+                }
+                throw A.c();
+            }
+            while (i5 < 10) {
+                if (this.f2922g == this.f2920e) {
+                    D(1);
+                }
+                int i8 = this.f2922g;
+                this.f2922g = i8 + 1;
+                if (bArr[i8] < 0) {
+                    i5++;
+                }
+            }
+            throw A.c();
+            return true;
+        }
+        if (i4 == 1) {
+            F(8);
+            return true;
+        }
+        if (i4 == 2) {
+            F(s());
+            return true;
+        }
+        if (i4 != 3) {
+            if (i4 == 4) {
+                return false;
+            }
+            if (i4 != 5) {
+                throw A.b();
+            }
+            F(4);
+            return true;
+        }
+        do {
+            z3 = z();
+            if (z3 == 0) {
+                break;
+            }
+        } while (E(z3));
+        a(((i >>> 3) << 3) | 4);
+        return true;
+    }
+
+    public final void F(int i) {
+        int i4 = this.f2920e;
+        int i5 = this.f2922g;
+        int i6 = i4 - i5;
+        if (i <= i6 && i >= 0) {
+            this.f2922g = i5 + i;
+            return;
+        }
+        FileInputStream fileInputStream = this.f2918c;
+        if (i < 0) {
+            throw A.d();
+        }
+        int i7 = this.i;
+        int i8 = i7 + i5;
+        int i9 = i8 + i;
+        int i10 = this.f2923j;
+        if (i9 > i10) {
+            F((i10 - i7) - i5);
+            throw A.f();
+        }
+        this.i = i8;
+        this.f2920e = 0;
+        this.f2922g = 0;
+        while (i6 < i) {
+            long j4 = i - i6;
+            try {
+                long skip = fileInputStream.skip(j4);
+                if (skip < 0 || skip > j4) {
+                    throw new IllegalStateException(fileInputStream.getClass() + "#skip returned invalid result: " + skip + "\nThe InputStream implementation is buggy.");
+                }
+                if (skip == 0) {
+                    break;
+                } else {
+                    i6 += (int) skip;
+                }
+            } finally {
+                this.i += i6;
+                C();
+            }
+        }
+        if (i6 >= i) {
+            return;
+        }
+        int i11 = this.f2920e;
+        int i12 = i11 - this.f2922g;
+        this.f2922g = i11;
+        D(1);
+        while (true) {
+            int i13 = i - i12;
+            int i14 = this.f2920e;
+            if (i13 <= i14) {
+                this.f2922g = i13;
+                return;
+            } else {
+                i12 += i14;
+                this.f2922g = i14;
+                D(1);
+            }
+        }
+    }
+
+    public final boolean G(int i) {
+        int i4 = this.f2922g;
+        int i5 = i4 + i;
+        int i6 = this.f2920e;
+        if (i5 <= i6) {
+            throw new IllegalStateException(C.w.i(i, "refillBuffer() called when ", " bytes were already available in buffer"));
+        }
+        int i7 = this.i;
+        if (i <= (Integer.MAX_VALUE - i7) - i4 && i7 + i4 + i <= this.f2923j) {
+            byte[] bArr = this.f2919d;
+            if (i4 > 0) {
+                if (i6 > i4) {
+                    System.arraycopy(bArr, i4, bArr, 0, i6 - i4);
+                }
+                this.i += i4;
+                this.f2920e -= i4;
+                this.f2922g = 0;
+            }
+            int i8 = this.f2920e;
+            int min = Math.min(bArr.length - i8, (Integer.MAX_VALUE - this.i) - i8);
+            FileInputStream fileInputStream = this.f2918c;
+            int read = fileInputStream.read(bArr, i8, min);
+            if (read == 0 || read < -1 || read > bArr.length) {
+                throw new IllegalStateException(fileInputStream.getClass() + "#read(byte[]) returned invalid result: " + read + "\nThe InputStream implementation is buggy.");
+            }
+            if (read > 0) {
+                this.f2920e += read;
+                C();
+                if (this.f2920e >= i) {
+                    return true;
+                }
+                return G(i);
+            }
+        }
+        return false;
+    }
+
+    public final void a(int i) {
+        if (this.h != i) {
+            throw new IOException("Protocol message end-group tag did not match expected tag.");
+        }
+    }
+
+    public final int b() {
+        return this.i + this.f2922g;
+    }
+
+    public final boolean c() {
+        return this.f2922g == this.f2920e && !G(1);
+    }
+
+    public final void d(int i) {
+        this.f2923j = i;
+        C();
+    }
+
+    public final int e(int i) {
+        if (i < 0) {
+            throw A.d();
+        }
+        int i4 = this.i + this.f2922g + i;
+        int i5 = this.f2923j;
+        if (i4 > i5) {
+            throw A.f();
+        }
+        this.f2923j = i4;
+        C();
+        return i5;
+    }
+
+    public final boolean f() {
+        return t() != 0;
+    }
+
+    public final double g() {
+        return Double.longBitsToDouble(r());
+    }
+
+    public final int h() {
+        return s();
+    }
+
+    public final int i() {
+        return q();
+    }
+
+    public final long j() {
+        return r();
+    }
+
+    public final float k() {
+        return Float.intBitsToFloat(q());
+    }
+
+    public final int l() {
+        return s();
+    }
+
+    public final long m() {
+        return t();
+    }
+
+    public final byte[] n(int i) {
+        byte[] o4 = o(i);
+        if (o4 != null) {
+            return o4;
+        }
+        int i4 = this.f2922g;
+        int i5 = this.f2920e;
+        int i6 = i5 - i4;
+        this.i += i5;
+        this.f2922g = 0;
+        this.f2920e = 0;
+        ArrayList p = p(i - i6);
+        byte[] bArr = new byte[i];
+        System.arraycopy(this.f2919d, i4, bArr, 0, i6);
+        Iterator it = p.iterator();
+        while (it.hasNext()) {
+            byte[] bArr2 = (byte[]) it.next();
+            System.arraycopy(bArr2, 0, bArr, i6, bArr2.length);
+            i6 += bArr2.length;
+        }
+        return bArr;
+    }
+
+    public final byte[] o(int i) {
+        if (i == 0) {
+            return AbstractC0133y.f2976b;
+        }
+        if (i < 0) {
+            throw A.d();
+        }
+        int i4 = this.i;
+        int i5 = this.f2922g;
+        int i6 = i4 + i5 + i;
+        if (i6 - Integer.MAX_VALUE > 0) {
+            throw new IOException("Protocol message was too large.  May be malicious.  Use CodedInputStream.setSizeLimit() to increase the size limit.");
+        }
+        int i7 = this.f2923j;
+        if (i6 > i7) {
+            F((i7 - i4) - i5);
+            throw A.f();
+        }
+        int i8 = this.f2920e - i5;
+        int i9 = i - i8;
+        FileInputStream fileInputStream = this.f2918c;
+        if (i9 >= 4096 && i9 > fileInputStream.available()) {
+            return null;
+        }
+        byte[] bArr = new byte[i];
+        System.arraycopy(this.f2919d, this.f2922g, bArr, 0, i8);
+        this.i += this.f2920e;
+        this.f2922g = 0;
+        this.f2920e = 0;
+        while (i8 < i) {
+            int read = fileInputStream.read(bArr, i8, i - i8);
+            if (read == -1) {
+                throw A.f();
+            }
+            this.i += read;
+            i8 += read;
+        }
+        return bArr;
+    }
+
+    public final ArrayList p(int i) {
+        ArrayList arrayList = new ArrayList();
+        while (i > 0) {
+            int min = Math.min(i, ConstantsKt.DEFAULT_BLOCK_SIZE);
+            byte[] bArr = new byte[min];
+            int i4 = 0;
+            while (i4 < min) {
+                int read = this.f2918c.read(bArr, i4, min - i4);
+                if (read == -1) {
+                    throw A.f();
+                }
+                this.i += read;
+                i4 += read;
+            }
+            i -= min;
+            arrayList.add(bArr);
+        }
+        return arrayList;
+    }
+
+    public final int q() {
+        int i = this.f2922g;
+        if (this.f2920e - i < 4) {
+            D(4);
+            i = this.f2922g;
+        }
+        this.f2922g = i + 4;
+        byte[] bArr = this.f2919d;
+        return ((bArr[i + 3] & UByte.MAX_VALUE) << 24) | (bArr[i] & UByte.MAX_VALUE) | ((bArr[i + 1] & UByte.MAX_VALUE) << 8) | ((bArr[i + 2] & UByte.MAX_VALUE) << 16);
+    }
+
+    public final long r() {
+        int i = this.f2922g;
+        if (this.f2920e - i < 8) {
+            D(8);
+            i = this.f2922g;
+        }
+        this.f2922g = i + 8;
+        byte[] bArr = this.f2919d;
+        return ((bArr[i + 1] & 255) << 8) | (bArr[i] & 255) | ((bArr[i + 2] & 255) << 16) | ((bArr[i + 3] & 255) << 24) | ((bArr[i + 4] & 255) << 32) | ((bArr[i + 5] & 255) << 40) | ((bArr[i + 6] & 255) << 48) | ((bArr[i + 7] & 255) << 56);
+    }
+
+    public final int s() {
+        int i;
+        int i4 = this.f2922g;
+        int i5 = this.f2920e;
+        if (i5 != i4) {
+            int i6 = i4 + 1;
+            byte[] bArr = this.f2919d;
+            byte b4 = bArr[i4];
+            if (b4 >= 0) {
+                this.f2922g = i6;
+                return b4;
+            }
+            if (i5 - i6 >= 9) {
+                int i7 = i4 + 2;
+                int i8 = (bArr[i6] << 7) ^ b4;
+                if (i8 < 0) {
+                    i = i8 ^ (-128);
+                } else {
+                    int i9 = i4 + 3;
+                    int i10 = (bArr[i7] << 14) ^ i8;
+                    if (i10 >= 0) {
+                        i = i10 ^ 16256;
+                    } else {
+                        int i11 = i4 + 4;
+                        int i12 = i10 ^ (bArr[i9] << 21);
+                        if (i12 < 0) {
+                            i = (-2080896) ^ i12;
+                        } else {
+                            i9 = i4 + 5;
+                            byte b5 = bArr[i11];
+                            int i13 = (i12 ^ (b5 << 28)) ^ 266354560;
+                            if (b5 < 0) {
+                                i11 = i4 + 6;
+                                if (bArr[i9] < 0) {
+                                    i9 = i4 + 7;
+                                    if (bArr[i11] < 0) {
+                                        i11 = i4 + 8;
+                                        if (bArr[i9] < 0) {
+                                            i9 = i4 + 9;
+                                            if (bArr[i11] < 0) {
+                                                int i14 = i4 + 10;
+                                                if (bArr[i9] >= 0) {
+                                                    i7 = i14;
+                                                    i = i13;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                i = i13;
+                            }
+                            i = i13;
+                        }
+                        i7 = i11;
+                    }
+                    i7 = i9;
+                }
+                this.f2922g = i7;
+                return i;
+            }
+        }
+        return (int) u();
+    }
+
+    public final long t() {
+        long j4;
+        long j5;
+        long j6;
+        long j7;
+        int i = this.f2922g;
+        int i4 = this.f2920e;
+        if (i4 != i) {
+            int i5 = i + 1;
+            byte[] bArr = this.f2919d;
+            byte b4 = bArr[i];
+            if (b4 >= 0) {
+                this.f2922g = i5;
+                return b4;
+            }
+            if (i4 - i5 >= 9) {
+                int i6 = i + 2;
+                int i7 = (bArr[i5] << 7) ^ b4;
+                if (i7 < 0) {
+                    j4 = i7 ^ (-128);
+                } else {
+                    int i8 = i + 3;
+                    int i9 = (bArr[i6] << 14) ^ i7;
+                    if (i9 >= 0) {
+                        j4 = i9 ^ 16256;
+                        i6 = i8;
+                    } else {
+                        int i10 = i + 4;
+                        int i11 = i9 ^ (bArr[i8] << 21);
+                        if (i11 < 0) {
+                            j7 = (-2080896) ^ i11;
+                        } else {
+                            long j8 = i11;
+                            i6 = i + 5;
+                            long j9 = j8 ^ (bArr[i10] << 28);
+                            if (j9 >= 0) {
+                                j6 = 266354560;
+                            } else {
+                                i10 = i + 6;
+                                long j10 = j9 ^ (bArr[i6] << 35);
+                                if (j10 < 0) {
+                                    j5 = -34093383808L;
+                                } else {
+                                    i6 = i + 7;
+                                    j9 = j10 ^ (bArr[i10] << 42);
+                                    if (j9 >= 0) {
+                                        j6 = 4363953127296L;
+                                    } else {
+                                        i10 = i + 8;
+                                        j10 = j9 ^ (bArr[i6] << 49);
+                                        if (j10 < 0) {
+                                            j5 = -558586000294016L;
+                                        } else {
+                                            i6 = i + 9;
+                                            long j11 = (j10 ^ (bArr[i10] << 56)) ^ 71499008037633920L;
+                                            if (j11 < 0) {
+                                                int i12 = i + 10;
+                                                if (bArr[i6] >= 0) {
+                                                    i6 = i12;
+                                                }
+                                            }
+                                            j4 = j11;
+                                        }
+                                    }
+                                }
+                                j7 = j5 ^ j10;
+                            }
+                            j4 = j6 ^ j9;
+                        }
+                        i6 = i10;
+                        j4 = j7;
+                    }
+                }
+                this.f2922g = i6;
+                return j4;
+            }
+        }
+        return u();
+    }
+
+    public final long u() {
+        long j4 = 0;
+        for (int i = 0; i < 64; i += 7) {
+            if (this.f2922g == this.f2920e) {
+                D(1);
+            }
+            int i4 = this.f2922g;
+            this.f2922g = i4 + 1;
+            j4 |= (r3 & ByteCompanionObject.MAX_VALUE) << i;
+            if ((this.f2919d[i4] & ByteCompanionObject.MIN_VALUE) == 0) {
+                return j4;
+            }
+        }
+        throw A.c();
+    }
+
+    public final int v() {
+        return q();
+    }
+
+    public final long w() {
+        return r();
+    }
+
+    public final int x() {
+        int s4 = s();
+        return (-(s4 & 1)) ^ (s4 >>> 1);
+    }
+
+    public final long y() {
+        long t2 = t();
+        return (-(t2 & 1)) ^ (t2 >>> 1);
+    }
+
+    public final int z() {
+        if (c()) {
+            this.h = 0;
+            return 0;
+        }
+        int s4 = s();
+        this.h = s4;
+        if ((s4 >>> 3) != 0) {
+            return s4;
+        }
+        throw new IOException("Protocol message contained an invalid tag (zero).");
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0118i.java

@@ -0,0 +1,11 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.io.IOException;
+
+/* renamed from: androidx.datastore.preferences.protobuf.i, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0118i extends IOException {
+    public C0118i(IndexOutOfBoundsException indexOutOfBoundsException) {
+        super("CodedOutputStream was writing to a flat byte array and ran out of space.", indexOutOfBoundsException);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0119j.java

@@ -0,0 +1,411 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import kotlin.KotlinVersion;
+import kotlinx.coroutines.scheduling.WorkQueueKt;
+
+/* renamed from: androidx.datastore.preferences.protobuf.j, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0119j extends Q {
+    public static final Logger h = Logger.getLogger(C0119j.class.getName());
+    public static final boolean i = s0.f2968f;
+
+    /* renamed from: c, reason: collision with root package name */
+    public J f2930c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final byte[] f2931d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final int f2932e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public int f2933f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final Y.n f2934g;
+
+    public C0119j(Y.n nVar, int i4) {
+        if (i4 < 0) {
+            throw new IllegalArgumentException("bufferSize must be >= 0");
+        }
+        int max = Math.max(i4, 20);
+        this.f2931d = new byte[max];
+        this.f2932e = max;
+        this.f2934g = nVar;
+    }
+
+    public static int A(long j4) {
+        int i4;
+        if (((-128) & j4) == 0) {
+            return 1;
+        }
+        if (j4 < 0) {
+            return 10;
+        }
+        if (((-34359738368L) & j4) != 0) {
+            j4 >>>= 28;
+            i4 = 6;
+        } else {
+            i4 = 2;
+        }
+        if (((-2097152) & j4) != 0) {
+            i4 += 2;
+            j4 >>>= 14;
+        }
+        return (j4 & (-16384)) != 0 ? i4 + 1 : i4;
+    }
+
+    public static int r(int i4, C0116g c0116g) {
+        return s(c0116g) + y(i4);
+    }
+
+    public static int s(C0116g c0116g) {
+        int size = c0116g.size();
+        return z(size) + size;
+    }
+
+    public static int t(int i4) {
+        return y(i4) + 4;
+    }
+
+    public static int u(int i4) {
+        return y(i4) + 8;
+    }
+
+    public static int v(int i4, AbstractC0108a abstractC0108a, InterfaceC0111b0 interfaceC0111b0) {
+        return abstractC0108a.b(interfaceC0111b0) + (y(i4) * 2);
+    }
+
+    public static int w(int i4) {
+        if (i4 >= 0) {
+            return z(i4);
+        }
+        return 10;
+    }
+
+    public static int x(String str) {
+        int length;
+        try {
+            length = v0.b(str);
+        } catch (u0 unused) {
+            length = str.getBytes(AbstractC0133y.f2975a).length;
+        }
+        return z(length) + length;
+    }
+
+    public static int y(int i4) {
+        return z(i4 << 3);
+    }
+
+    public static int z(int i4) {
+        if ((i4 & (-128)) == 0) {
+            return 1;
+        }
+        if ((i4 & (-16384)) == 0) {
+            return 2;
+        }
+        if (((-2097152) & i4) == 0) {
+            return 3;
+        }
+        return (i4 & (-268435456)) == 0 ? 4 : 5;
+    }
+
+    public final void B() {
+        this.f2934g.write(this.f2931d, 0, this.f2933f);
+        this.f2933f = 0;
+    }
+
+    public final void C(int i4) {
+        if (this.f2932e - this.f2933f < i4) {
+            B();
+        }
+    }
+
+    public final void D(byte b4) {
+        if (this.f2933f == this.f2932e) {
+            B();
+        }
+        int i4 = this.f2933f;
+        this.f2933f = i4 + 1;
+        this.f2931d[i4] = b4;
+    }
+
+    public final void E(byte[] bArr, int i4, int i5) {
+        int i6 = this.f2933f;
+        int i7 = this.f2932e;
+        int i8 = i7 - i6;
+        byte[] bArr2 = this.f2931d;
+        if (i8 >= i5) {
+            System.arraycopy(bArr, i4, bArr2, i6, i5);
+            this.f2933f += i5;
+            return;
+        }
+        System.arraycopy(bArr, i4, bArr2, i6, i8);
+        int i9 = i4 + i8;
+        int i10 = i5 - i8;
+        this.f2933f = i7;
+        B();
+        if (i10 > i7) {
+            this.f2934g.write(bArr, i9, i10);
+        } else {
+            System.arraycopy(bArr, i9, bArr2, 0, i10);
+            this.f2933f = i10;
+        }
+    }
+
+    public final void F(int i4, boolean z3) {
+        C(11);
+        o(i4, 0);
+        byte b4 = z3 ? (byte) 1 : (byte) 0;
+        int i5 = this.f2933f;
+        this.f2933f = i5 + 1;
+        this.f2931d[i5] = b4;
+    }
+
+    public final void G(int i4, C0116g c0116g) {
+        R(i4, 2);
+        H(c0116g);
+    }
+
+    public final void H(C0116g c0116g) {
+        T(c0116g.size());
+        l(c0116g.b(), c0116g.size(), c0116g.f2912b);
+    }
+
+    public final void I(int i4, int i5) {
+        C(14);
+        o(i4, 5);
+        m(i5);
+    }
+
+    public final void J(int i4) {
+        C(4);
+        m(i4);
+    }
+
+    public final void K(int i4, long j4) {
+        C(18);
+        o(i4, 1);
+        n(j4);
+    }
+
+    public final void L(long j4) {
+        C(8);
+        n(j4);
+    }
+
+    public final void M(int i4, int i5) {
+        C(20);
+        o(i4, 0);
+        if (i5 >= 0) {
+            p(i5);
+        } else {
+            q(i5);
+        }
+    }
+
+    public final void N(int i4) {
+        if (i4 >= 0) {
+            T(i4);
+        } else {
+            V(i4);
+        }
+    }
+
+    public final void O(int i4, AbstractC0108a abstractC0108a, InterfaceC0111b0 interfaceC0111b0) {
+        R(i4, 2);
+        T(abstractC0108a.b(interfaceC0111b0));
+        interfaceC0111b0.a(abstractC0108a, this.f2930c);
+    }
+
+    public final void P(int i4, String str) {
+        R(i4, 2);
+        Q(str);
+    }
+
+    public final void Q(String str) {
+        try {
+            int length = str.length() * 3;
+            int z3 = z(length);
+            int i4 = z3 + length;
+            int i5 = this.f2932e;
+            if (i4 > i5) {
+                byte[] bArr = new byte[length];
+                int f2 = v0.f2974a.f(str, bArr, 0, length);
+                T(f2);
+                E(bArr, 0, f2);
+                return;
+            }
+            if (i4 > i5 - this.f2933f) {
+                B();
+            }
+            int z4 = z(str.length());
+            int i6 = this.f2933f;
+            byte[] bArr2 = this.f2931d;
+            try {
+                if (z4 == z3) {
+                    int i7 = i6 + z4;
+                    this.f2933f = i7;
+                    int f4 = v0.f2974a.f(str, bArr2, i7, i5 - i7);
+                    this.f2933f = i6;
+                    p((f4 - i6) - z4);
+                    this.f2933f = f4;
+                } else {
+                    int b4 = v0.b(str);
+                    p(b4);
+                    this.f2933f = v0.f2974a.f(str, bArr2, this.f2933f, b4);
+                }
+            } catch (u0 e4) {
+                this.f2933f = i6;
+                throw e4;
+            } catch (ArrayIndexOutOfBoundsException e5) {
+                throw new C0118i(e5);
+            }
+        } catch (u0 e6) {
+            h.log(Level.WARNING, "Converting ill-formed UTF-16. Your Protocol Buffer will not round trip correctly!", (Throwable) e6);
+            byte[] bytes = str.getBytes(AbstractC0133y.f2975a);
+            try {
+                T(bytes.length);
+                l(0, bytes.length, bytes);
+            } catch (C0118i e7) {
+                throw e7;
+            } catch (IndexOutOfBoundsException e8) {
+                throw new C0118i(e8);
+            }
+        }
+    }
+
+    public final void R(int i4, int i5) {
+        T((i4 << 3) | i5);
+    }
+
+    public final void S(int i4, int i5) {
+        C(20);
+        o(i4, 0);
+        p(i5);
+    }
+
+    public final void T(int i4) {
+        C(5);
+        p(i4);
+    }
+
+    public final void U(int i4, long j4) {
+        C(20);
+        o(i4, 0);
+        q(j4);
+    }
+
+    public final void V(long j4) {
+        C(10);
+        q(j4);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.Q
+    public final void l(int i4, int i5, byte[] bArr) {
+        E(bArr, i4, i5);
+    }
+
+    public final void m(int i4) {
+        int i5 = this.f2933f;
+        int i6 = i5 + 1;
+        this.f2933f = i6;
+        byte b4 = (byte) (i4 & KotlinVersion.MAX_COMPONENT_VALUE);
+        byte[] bArr = this.f2931d;
+        bArr[i5] = b4;
+        int i7 = i5 + 2;
+        this.f2933f = i7;
+        bArr[i6] = (byte) ((i4 >> 8) & KotlinVersion.MAX_COMPONENT_VALUE);
+        int i8 = i5 + 3;
+        this.f2933f = i8;
+        bArr[i7] = (byte) ((i4 >> 16) & KotlinVersion.MAX_COMPONENT_VALUE);
+        this.f2933f = i5 + 4;
+        bArr[i8] = (byte) ((i4 >> 24) & KotlinVersion.MAX_COMPONENT_VALUE);
+    }
+
+    public final void n(long j4) {
+        int i4 = this.f2933f;
+        int i5 = i4 + 1;
+        this.f2933f = i5;
+        byte[] bArr = this.f2931d;
+        bArr[i4] = (byte) (j4 & 255);
+        int i6 = i4 + 2;
+        this.f2933f = i6;
+        bArr[i5] = (byte) ((j4 >> 8) & 255);
+        int i7 = i4 + 3;
+        this.f2933f = i7;
+        bArr[i6] = (byte) ((j4 >> 16) & 255);
+        int i8 = i4 + 4;
+        this.f2933f = i8;
+        bArr[i7] = (byte) (255 & (j4 >> 24));
+        int i9 = i4 + 5;
+        this.f2933f = i9;
+        bArr[i8] = (byte) (((int) (j4 >> 32)) & KotlinVersion.MAX_COMPONENT_VALUE);
+        int i10 = i4 + 6;
+        this.f2933f = i10;
+        bArr[i9] = (byte) (((int) (j4 >> 40)) & KotlinVersion.MAX_COMPONENT_VALUE);
+        int i11 = i4 + 7;
+        this.f2933f = i11;
+        bArr[i10] = (byte) (((int) (j4 >> 48)) & KotlinVersion.MAX_COMPONENT_VALUE);
+        this.f2933f = i4 + 8;
+        bArr[i11] = (byte) (((int) (j4 >> 56)) & KotlinVersion.MAX_COMPONENT_VALUE);
+    }
+
+    public final void o(int i4, int i5) {
+        p((i4 << 3) | i5);
+    }
+
+    public final void p(int i4) {
+        boolean z3 = i;
+        byte[] bArr = this.f2931d;
+        if (z3) {
+            while ((i4 & (-128)) != 0) {
+                int i5 = this.f2933f;
+                this.f2933f = i5 + 1;
+                s0.j(bArr, i5, (byte) ((i4 & WorkQueueKt.MASK) | 128));
+                i4 >>>= 7;
+            }
+            int i6 = this.f2933f;
+            this.f2933f = i6 + 1;
+            s0.j(bArr, i6, (byte) i4);
+            return;
+        }
+        while ((i4 & (-128)) != 0) {
+            int i7 = this.f2933f;
+            this.f2933f = i7 + 1;
+            bArr[i7] = (byte) ((i4 & WorkQueueKt.MASK) | 128);
+            i4 >>>= 7;
+        }
+        int i8 = this.f2933f;
+        this.f2933f = i8 + 1;
+        bArr[i8] = (byte) i4;
+    }
+
+    public final void q(long j4) {
+        boolean z3 = i;
+        byte[] bArr = this.f2931d;
+        if (z3) {
+            while ((j4 & (-128)) != 0) {
+                int i4 = this.f2933f;
+                this.f2933f = i4 + 1;
+                s0.j(bArr, i4, (byte) ((((int) j4) & WorkQueueKt.MASK) | 128));
+                j4 >>>= 7;
+            }
+            int i5 = this.f2933f;
+            this.f2933f = i5 + 1;
+            s0.j(bArr, i5, (byte) j4);
+            return;
+        }
+        while ((j4 & (-128)) != 0) {
+            int i6 = this.f2933f;
+            this.f2933f = i6 + 1;
+            bArr[i6] = (byte) ((((int) j4) & WorkQueueKt.MASK) | 128);
+            j4 >>>= 7;
+        }
+        int i7 = this.f2933f;
+        this.f2933f = i7 + 1;
+        bArr[i7] = (byte) j4;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0122m.java

@@ -0,0 +1,54 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Collections;
+import java.util.Map;
+
+/* renamed from: androidx.datastore.preferences.protobuf.m, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0122m {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static volatile C0122m f2943b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final C0122m f2944c;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Map f2945a = Collections.EMPTY_MAP;
+
+    static {
+        try {
+            Class.forName("androidx.datastore.preferences.protobuf.Extension");
+        } catch (ClassNotFoundException unused) {
+        }
+        f2944c = new C0122m();
+    }
+
+    public static C0122m a() {
+        C0122m c0122m;
+        C0122m c0122m2 = f2943b;
+        if (c0122m2 != null) {
+            return c0122m2;
+        }
+        synchronized (C0122m.class) {
+            try {
+                c0122m = f2943b;
+                if (c0122m == null) {
+                    Class cls = AbstractC0121l.f2941a;
+                    if (cls != null) {
+                        try {
+                            c0122m = (C0122m) cls.getDeclaredMethod("getEmptyRegistry", new Class[0]).invoke(null, new Object[0]);
+                        } catch (Exception unused) {
+                        }
+                        f2943b = c0122m;
+                    }
+                    c0122m = f2944c;
+                    f2943b = c0122m;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return c0122m;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0123n.java

@@ -0,0 +1,6 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.n, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0123n {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0125p.java

@@ -0,0 +1,177 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+
+/* renamed from: androidx.datastore.preferences.protobuf.p, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0125p {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final /* synthetic */ int f2950c = 0;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final d0 f2951a = new d0(16);
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f2952b;
+
+    static {
+        new C0125p(0);
+    }
+
+    public C0125p() {
+    }
+
+    public static void b(C0119j c0119j, A0 a02, int i, Object obj) {
+        if (a02 == A0.f2822d) {
+            c0119j.R(i, 3);
+            ((AbstractC0108a) obj).c(c0119j);
+            c0119j.R(i, 4);
+            return;
+        }
+        c0119j.R(i, a02.f2826b);
+        switch (a02.ordinal()) {
+            case 0:
+                c0119j.L(Double.doubleToRawLongBits(((Double) obj).doubleValue()));
+                return;
+            case 1:
+                c0119j.J(Float.floatToRawIntBits(((Float) obj).floatValue()));
+                return;
+            case 2:
+                c0119j.V(((Long) obj).longValue());
+                return;
+            case 3:
+                c0119j.V(((Long) obj).longValue());
+                return;
+            case 4:
+                c0119j.N(((Integer) obj).intValue());
+                return;
+            case 5:
+                c0119j.L(((Long) obj).longValue());
+                return;
+            case 6:
+                c0119j.J(((Integer) obj).intValue());
+                return;
+            case 7:
+                c0119j.D(((Boolean) obj).booleanValue() ? (byte) 1 : (byte) 0);
+                return;
+            case 8:
+                if (obj instanceof C0116g) {
+                    c0119j.H((C0116g) obj);
+                    return;
+                } else {
+                    c0119j.Q((String) obj);
+                    return;
+                }
+            case 9:
+                ((AbstractC0108a) obj).c(c0119j);
+                return;
+            case 10:
+                AbstractC0108a abstractC0108a = (AbstractC0108a) obj;
+                c0119j.getClass();
+                c0119j.T(abstractC0108a.a());
+                abstractC0108a.c(c0119j);
+                return;
+            case 11:
+                if (obj instanceof C0116g) {
+                    c0119j.H((C0116g) obj);
+                    return;
+                }
+                byte[] bArr = (byte[]) obj;
+                int length = bArr.length;
+                c0119j.T(length);
+                c0119j.E(bArr, 0, length);
+                return;
+            case 12:
+                c0119j.T(((Integer) obj).intValue());
+                return;
+            case 13:
+                c0119j.N(((Integer) obj).intValue());
+                return;
+            case 14:
+                c0119j.J(((Integer) obj).intValue());
+                return;
+            case 15:
+                c0119j.L(((Long) obj).longValue());
+                return;
+            case 16:
+                int intValue = ((Integer) obj).intValue();
+                c0119j.T((intValue >> 31) ^ (intValue << 1));
+                return;
+            case 17:
+                long longValue = ((Long) obj).longValue();
+                c0119j.V((longValue >> 63) ^ (longValue << 1));
+                return;
+            default:
+                return;
+        }
+    }
+
+    public final void a() {
+        if (this.f2952b) {
+            return;
+        }
+        d0 d0Var = this.f2951a;
+        if (!d0Var.f2902d) {
+            if (d0Var.f2900b.size() > 0) {
+                d0Var.c(0).getKey().getClass();
+                throw new ClassCastException();
+            }
+            Iterator it = d0Var.d().iterator();
+            if (it.hasNext()) {
+                ((Map.Entry) it.next()).getKey().getClass();
+                throw new ClassCastException();
+            }
+        }
+        if (!d0Var.f2902d) {
+            d0Var.f2901c = d0Var.f2901c.isEmpty() ? Collections.EMPTY_MAP : Collections.unmodifiableMap(d0Var.f2901c);
+            d0Var.f2904f = d0Var.f2904f.isEmpty() ? Collections.EMPTY_MAP : Collections.unmodifiableMap(d0Var.f2904f);
+            d0Var.f2902d = true;
+        }
+        this.f2952b = true;
+    }
+
+    public final Object clone() {
+        C0125p c0125p = new C0125p();
+        d0 d0Var = this.f2951a;
+        if (d0Var.f2900b.size() > 0) {
+            Map.Entry c4 = d0Var.c(0);
+            if (c4.getKey() != null) {
+                throw new ClassCastException();
+            }
+            c4.getValue();
+            throw null;
+        }
+        Iterator it = d0Var.d().iterator();
+        if (!it.hasNext()) {
+            return c0125p;
+        }
+        Map.Entry entry = (Map.Entry) it.next();
+        if (entry.getKey() != null) {
+            throw new ClassCastException();
+        }
+        entry.getValue();
+        throw null;
+    }
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof C0125p) {
+            return this.f2951a.equals(((C0125p) obj).f2951a);
+        }
+        return false;
+    }
+
+    public final int hashCode() {
+        return this.f2951a.hashCode();
+    }
+
+    public C0125p(int i) {
+        a();
+        a();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0127s.java

@@ -0,0 +1,43 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.s, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0127s implements P {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final C0127s f2961b = new C0127s(0);
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f2962a;
+
+    public /* synthetic */ C0127s(int i) {
+        this.f2962a = i;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.P
+    public final C0109a0 a(Class cls) {
+        switch (this.f2962a) {
+            case 0:
+                if (!AbstractC0130v.class.isAssignableFrom(cls)) {
+                    throw new IllegalArgumentException("Unsupported message type: ".concat(cls.getName()));
+                }
+                try {
+                    return (C0109a0) AbstractC0130v.e(cls.asSubclass(AbstractC0130v.class)).d(3);
+                } catch (Exception e4) {
+                    throw new RuntimeException("Unable to get message info for ".concat(cls.getName()), e4);
+                }
+            default:
+                throw new IllegalStateException("This should never be called.");
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.P
+    public final boolean b(Class cls) {
+        switch (this.f2962a) {
+            case 0:
+                return AbstractC0130v.class.isAssignableFrom(cls);
+            default:
+                return false;
+        }
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0129u.java

@@ -0,0 +1,9 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.u, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0129u implements W {
+    static {
+        C0122m.a();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/C0134z.java

@@ -0,0 +1,6 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.z, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0134z extends A {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/D.java

@@ -0,0 +1,14 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.List;
+
+/* loaded from: classes.dex */
+public interface D extends List {
+    void e(C0116g c0116g);
+
+    List getUnderlyingElements();
+
+    D getUnmodifiableView();
+
+    Object s(int i);
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/E.java

@@ -0,0 +1,85 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class E extends G {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final Class f2847c = Collections.unmodifiableList(Collections.EMPTY_LIST).getClass();
+
+    public static List d(Object obj, long j4, int i) {
+        List list = (List) s0.f2966d.i(j4, obj);
+        if (list.isEmpty()) {
+            List c4 = list instanceof D ? new C(i) : ((list instanceof X) && (list instanceof InterfaceC0132x)) ? ((InterfaceC0132x) list).d(i) : new ArrayList(i);
+            s0.o(obj, j4, c4);
+            return c4;
+        }
+        if (f2847c.isAssignableFrom(list.getClass())) {
+            ArrayList arrayList = new ArrayList(list.size() + i);
+            arrayList.addAll(list);
+            s0.o(obj, j4, arrayList);
+            return arrayList;
+        }
+        if (list instanceof n0) {
+            C c5 = new C(list.size() + i);
+            c5.addAll((n0) list);
+            s0.o(obj, j4, c5);
+            return c5;
+        }
+        if ((list instanceof X) && (list instanceof InterfaceC0132x)) {
+            InterfaceC0132x interfaceC0132x = (InterfaceC0132x) list;
+            if (!((AbstractC0110b) interfaceC0132x).f2891a) {
+                InterfaceC0132x d4 = interfaceC0132x.d(list.size() + i);
+                s0.o(obj, j4, d4);
+                return d4;
+            }
+        }
+        return list;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.G
+    public final void a(long j4, Object obj) {
+        Object unmodifiableList;
+        List list = (List) s0.f2966d.i(j4, obj);
+        if (list instanceof D) {
+            unmodifiableList = ((D) list).getUnmodifiableView();
+        } else {
+            if (f2847c.isAssignableFrom(list.getClass())) {
+                return;
+            }
+            if ((list instanceof X) && (list instanceof InterfaceC0132x)) {
+                AbstractC0110b abstractC0110b = (AbstractC0110b) ((InterfaceC0132x) list);
+                if (abstractC0110b.f2891a) {
+                    abstractC0110b.f2891a = false;
+                    return;
+                }
+                return;
+            }
+            unmodifiableList = Collections.unmodifiableList(list);
+        }
+        s0.o(obj, j4, unmodifiableList);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.G
+    public final void b(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2, long j4) {
+        List list = (List) s0.f2966d.i(j4, abstractC0130v2);
+        List d4 = d(abstractC0130v, j4, list.size());
+        int size = d4.size();
+        int size2 = list.size();
+        if (size > 0 && size2 > 0) {
+            d4.addAll(list);
+        }
+        if (size > 0) {
+            list = d4;
+        }
+        s0.o(abstractC0130v, j4, list);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.G
+    public final List c(long j4, Object obj) {
+        return d(obj, j4, 10);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/EnumC0126q.java

@@ -0,0 +1,131 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.lang.reflect.Type;
+import u.AbstractC0629f;
+
+/* JADX WARN: Enum visitor error
+jadx.core.utils.exceptions.JadxRuntimeException: Init of enum field 'EF0' uses external variables
+	at jadx.core.dex.visitors.EnumVisitor.createEnumFieldByConstructor(EnumVisitor.java:451)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByRegister(EnumVisitor.java:395)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromFilledArray(EnumVisitor.java:324)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:262)
+	at jadx.core.dex.visitors.EnumVisitor.convertToEnum(EnumVisitor.java:151)
+	at jadx.core.dex.visitors.EnumVisitor.visit(EnumVisitor.java:100)
+ */
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* renamed from: androidx.datastore.preferences.protobuf.q, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class EnumC0126q {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final EnumC0126q f2954b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final EnumC0126q f2955c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final EnumC0126q[] f2956d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final Type[] f2957e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final /* synthetic */ EnumC0126q[] f2958f;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f2959a;
+
+    /* JADX INFO: Fake field, exist only in values array */
+    EnumC0126q EF0;
+
+    static {
+        B b4 = B.DOUBLE;
+        EnumC0126q enumC0126q = new EnumC0126q("DOUBLE", 0, 0, 1, b4);
+        B b5 = B.FLOAT;
+        EnumC0126q enumC0126q2 = new EnumC0126q("FLOAT", 1, 1, 1, b5);
+        B b6 = B.LONG;
+        EnumC0126q enumC0126q3 = new EnumC0126q("INT64", 2, 2, 1, b6);
+        EnumC0126q enumC0126q4 = new EnumC0126q("UINT64", 3, 3, 1, b6);
+        B b7 = B.INT;
+        EnumC0126q enumC0126q5 = new EnumC0126q("INT32", 4, 4, 1, b7);
+        EnumC0126q enumC0126q6 = new EnumC0126q("FIXED64", 5, 5, 1, b6);
+        EnumC0126q enumC0126q7 = new EnumC0126q("FIXED32", 6, 6, 1, b7);
+        B b8 = B.BOOLEAN;
+        EnumC0126q enumC0126q8 = new EnumC0126q("BOOL", 7, 7, 1, b8);
+        B b9 = B.STRING;
+        EnumC0126q enumC0126q9 = new EnumC0126q("STRING", 8, 8, 1, b9);
+        B b10 = B.MESSAGE;
+        EnumC0126q enumC0126q10 = new EnumC0126q("MESSAGE", 9, 9, 1, b10);
+        B b11 = B.BYTE_STRING;
+        EnumC0126q enumC0126q11 = new EnumC0126q("BYTES", 10, 10, 1, b11);
+        EnumC0126q enumC0126q12 = new EnumC0126q("UINT32", 11, 11, 1, b7);
+        B b12 = B.ENUM;
+        EnumC0126q enumC0126q13 = new EnumC0126q("ENUM", 12, 12, 1, b12);
+        EnumC0126q enumC0126q14 = new EnumC0126q("SFIXED32", 13, 13, 1, b7);
+        EnumC0126q enumC0126q15 = new EnumC0126q("SFIXED64", 14, 14, 1, b6);
+        EnumC0126q enumC0126q16 = new EnumC0126q("SINT32", 15, 15, 1, b7);
+        EnumC0126q enumC0126q17 = new EnumC0126q("SINT64", 16, 16, 1, b6);
+        EnumC0126q enumC0126q18 = new EnumC0126q("GROUP", 17, 17, 1, b10);
+        EnumC0126q enumC0126q19 = new EnumC0126q("DOUBLE_LIST", 18, 18, 2, b4);
+        EnumC0126q enumC0126q20 = new EnumC0126q("FLOAT_LIST", 19, 19, 2, b5);
+        EnumC0126q enumC0126q21 = new EnumC0126q("INT64_LIST", 20, 20, 2, b6);
+        EnumC0126q enumC0126q22 = new EnumC0126q("UINT64_LIST", 21, 21, 2, b6);
+        EnumC0126q enumC0126q23 = new EnumC0126q("INT32_LIST", 22, 22, 2, b7);
+        EnumC0126q enumC0126q24 = new EnumC0126q("FIXED64_LIST", 23, 23, 2, b6);
+        EnumC0126q enumC0126q25 = new EnumC0126q("FIXED32_LIST", 24, 24, 2, b7);
+        EnumC0126q enumC0126q26 = new EnumC0126q("BOOL_LIST", 25, 25, 2, b8);
+        EnumC0126q enumC0126q27 = new EnumC0126q("STRING_LIST", 26, 26, 2, b9);
+        EnumC0126q enumC0126q28 = new EnumC0126q("MESSAGE_LIST", 27, 27, 2, b10);
+        EnumC0126q enumC0126q29 = new EnumC0126q("BYTES_LIST", 28, 28, 2, b11);
+        EnumC0126q enumC0126q30 = new EnumC0126q("UINT32_LIST", 29, 29, 2, b7);
+        EnumC0126q enumC0126q31 = new EnumC0126q("ENUM_LIST", 30, 30, 2, b12);
+        EnumC0126q enumC0126q32 = new EnumC0126q("SFIXED32_LIST", 31, 31, 2, b7);
+        EnumC0126q enumC0126q33 = new EnumC0126q("SFIXED64_LIST", 32, 32, 2, b6);
+        EnumC0126q enumC0126q34 = new EnumC0126q("SINT32_LIST", 33, 33, 2, b7);
+        EnumC0126q enumC0126q35 = new EnumC0126q("SINT64_LIST", 34, 34, 2, b6);
+        EnumC0126q enumC0126q36 = new EnumC0126q("DOUBLE_LIST_PACKED", 35, 35, 3, b4);
+        f2954b = enumC0126q36;
+        EnumC0126q enumC0126q37 = new EnumC0126q("FLOAT_LIST_PACKED", 36, 36, 3, b5);
+        EnumC0126q enumC0126q38 = new EnumC0126q("INT64_LIST_PACKED", 37, 37, 3, b6);
+        EnumC0126q enumC0126q39 = new EnumC0126q("UINT64_LIST_PACKED", 38, 38, 3, b6);
+        EnumC0126q enumC0126q40 = new EnumC0126q("INT32_LIST_PACKED", 39, 39, 3, b7);
+        EnumC0126q enumC0126q41 = new EnumC0126q("FIXED64_LIST_PACKED", 40, 40, 3, b6);
+        EnumC0126q enumC0126q42 = new EnumC0126q("FIXED32_LIST_PACKED", 41, 41, 3, b7);
+        EnumC0126q enumC0126q43 = new EnumC0126q("BOOL_LIST_PACKED", 42, 42, 3, b8);
+        EnumC0126q enumC0126q44 = new EnumC0126q("UINT32_LIST_PACKED", 43, 43, 3, b7);
+        EnumC0126q enumC0126q45 = new EnumC0126q("ENUM_LIST_PACKED", 44, 44, 3, b12);
+        EnumC0126q enumC0126q46 = new EnumC0126q("SFIXED32_LIST_PACKED", 45, 45, 3, b7);
+        EnumC0126q enumC0126q47 = new EnumC0126q("SFIXED64_LIST_PACKED", 46, 46, 3, b6);
+        EnumC0126q enumC0126q48 = new EnumC0126q("SINT32_LIST_PACKED", 47, 47, 3, b7);
+        EnumC0126q enumC0126q49 = new EnumC0126q("SINT64_LIST_PACKED", 48, 48, 3, b6);
+        f2955c = enumC0126q49;
+        f2958f = new EnumC0126q[]{enumC0126q, enumC0126q2, enumC0126q3, enumC0126q4, enumC0126q5, enumC0126q6, enumC0126q7, enumC0126q8, enumC0126q9, enumC0126q10, enumC0126q11, enumC0126q12, enumC0126q13, enumC0126q14, enumC0126q15, enumC0126q16, enumC0126q17, enumC0126q18, enumC0126q19, enumC0126q20, enumC0126q21, enumC0126q22, enumC0126q23, enumC0126q24, enumC0126q25, enumC0126q26, enumC0126q27, enumC0126q28, enumC0126q29, enumC0126q30, enumC0126q31, enumC0126q32, enumC0126q33, enumC0126q34, enumC0126q35, enumC0126q36, enumC0126q37, enumC0126q38, enumC0126q39, enumC0126q40, enumC0126q41, enumC0126q42, enumC0126q43, enumC0126q44, enumC0126q45, enumC0126q46, enumC0126q47, enumC0126q48, enumC0126q49, new EnumC0126q("GROUP_LIST", 49, 49, 2, b10), new EnumC0126q("MAP", 50, 50, 4, B.VOID)};
+        f2957e = new Type[0];
+        EnumC0126q[] values = values();
+        f2956d = new EnumC0126q[values.length];
+        for (EnumC0126q enumC0126q50 : values) {
+            f2956d[enumC0126q50.f2959a] = enumC0126q50;
+        }
+    }
+
+    public EnumC0126q(String str, int i, int i4, int i5, B b4) {
+        this.f2959a = i4;
+        int b5 = AbstractC0629f.b(i5);
+        if (b5 == 1) {
+            b4.getClass();
+        } else if (b5 == 3) {
+            b4.getClass();
+        }
+        if (i5 == 1) {
+            b4.ordinal();
+        }
+    }
+
+    public static EnumC0126q valueOf(String str) {
+        return (EnumC0126q) Enum.valueOf(EnumC0126q.class, str);
+    }
+
+    public static EnumC0126q[] values() {
+        return (EnumC0126q[]) f2958f.clone();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/F.java

@@ -0,0 +1,42 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class F extends G {
+    @Override // androidx.datastore.preferences.protobuf.G
+    public final void a(long j4, Object obj) {
+        ((AbstractC0110b) ((InterfaceC0132x) s0.f2966d.i(j4, obj))).f2891a = false;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.G
+    public final void b(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2, long j4) {
+        r0 r0Var = s0.f2966d;
+        InterfaceC0132x interfaceC0132x = (InterfaceC0132x) r0Var.i(j4, abstractC0130v);
+        InterfaceC0132x interfaceC0132x2 = (InterfaceC0132x) r0Var.i(j4, abstractC0130v2);
+        int size = interfaceC0132x.size();
+        int size2 = interfaceC0132x2.size();
+        if (size > 0 && size2 > 0) {
+            if (!((AbstractC0110b) interfaceC0132x).f2891a) {
+                interfaceC0132x = interfaceC0132x.d(size2 + size);
+            }
+            interfaceC0132x.addAll(interfaceC0132x2);
+        }
+        if (size > 0) {
+            interfaceC0132x2 = interfaceC0132x;
+        }
+        s0.o(abstractC0130v, j4, interfaceC0132x2);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.G
+    public final List c(long j4, Object obj) {
+        InterfaceC0132x interfaceC0132x = (InterfaceC0132x) s0.f2966d.i(j4, obj);
+        if (((AbstractC0110b) interfaceC0132x).f2891a) {
+            return interfaceC0132x;
+        }
+        int size = interfaceC0132x.size();
+        InterfaceC0132x d4 = interfaceC0132x.d(size == 0 ? 10 : size * 2);
+        s0.o(obj, j4, d4);
+        return d4;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/G.java

@@ -0,0 +1,19 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.List;
+
+/* loaded from: classes.dex */
+public abstract class G {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final E f2848a = new Object();
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final F f2849b = new Object();
+
+    public abstract void a(long j4, Object obj);
+
+    public abstract void b(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2, long j4);
+
+    public abstract List c(long j4, Object obj);
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/H.java

@@ -0,0 +1,7 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.RandomAccess;
+
+/* loaded from: classes.dex */
+public abstract class H extends AbstractC0110b implements RandomAccess, X {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/I.java

@@ -0,0 +1,28 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class I implements P {
+
+    /* renamed from: a, reason: collision with root package name */
+    public P[] f2850a;
+
+    @Override // androidx.datastore.preferences.protobuf.P
+    public final C0109a0 a(Class cls) {
+        for (P p : this.f2850a) {
+            if (p.b(cls)) {
+                return p.a(cls);
+            }
+        }
+        throw new UnsupportedOperationException("No factory is available for message type: ".concat(cls.getName()));
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.P
+    public final boolean b(Class cls) {
+        for (P p : this.f2850a) {
+            if (p.b(cls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/InterfaceC0111b0.java

@@ -0,0 +1,23 @@
+package androidx.datastore.preferences.protobuf;
+
+/* renamed from: androidx.datastore.preferences.protobuf.b0, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0111b0 {
+    void a(Object obj, J j4);
+
+    int b(AbstractC0130v abstractC0130v);
+
+    void c(Object obj, Z2.y yVar, C0122m c0122m);
+
+    void d(Object obj);
+
+    int e(AbstractC0108a abstractC0108a);
+
+    boolean f(Object obj);
+
+    boolean g(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2);
+
+    void h(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2);
+
+    Object i();
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/InterfaceC0132x.java

@@ -0,0 +1,10 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.List;
+import java.util.RandomAccess;
+
+/* renamed from: androidx.datastore.preferences.protobuf.x, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0132x extends List, RandomAccess {
+    InterfaceC0132x d(int i);
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/J.java

@@ -0,0 +1,45 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.nio.charset.Charset;
+
+/* loaded from: classes.dex */
+public final class J {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final C0127s f2851b = new C0127s(1);
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Object f2852a;
+
+    public J(C0119j c0119j) {
+        AbstractC0133y.a(c0119j, "output");
+        this.f2852a = c0119j;
+        c0119j.f2930c = this;
+    }
+
+    public void a(int i, C0116g c0116g) {
+        ((C0119j) this.f2852a).G(i, c0116g);
+    }
+
+    public void b(int i, Object obj, InterfaceC0111b0 interfaceC0111b0) {
+        C0119j c0119j = (C0119j) this.f2852a;
+        c0119j.R(i, 3);
+        interfaceC0111b0.a((AbstractC0108a) obj, c0119j.f2930c);
+        c0119j.R(i, 4);
+    }
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [androidx.datastore.preferences.protobuf.I, java.lang.Object] */
+    public J() {
+        P p;
+        try {
+            p = (P) Class.forName("androidx.datastore.preferences.protobuf.DescriptorMessageInfoFactory").getDeclaredMethod("getInstance", new Class[0]).invoke(null, new Object[0]);
+        } catch (Exception unused) {
+            p = f2851b;
+        }
+        P[] pArr = {C0127s.f2961b, p};
+        ?? obj = new Object();
+        obj.f2850a = pArr;
+        Charset charset = AbstractC0133y.f2975a;
+        this.f2852a = obj;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/K.java

@@ -0,0 +1,20 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class K {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final w0 f2853a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final y0 f2854b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final a0.j f2855c;
+
+    public K(w0 w0Var, y0 y0Var, a0.j jVar) {
+        this.f2853a = w0Var;
+        this.f2854b = y0Var;
+        this.f2855c = jVar;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/L.java

@@ -0,0 +1,12 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class L {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final K f2856a;
+
+    public L(w0 w0Var, y0 y0Var, a0.j jVar) {
+        this.f2856a = new K(w0Var, y0Var, jVar);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/M.java

@@ -0,0 +1,178 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.nio.charset.Charset;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public final class M extends LinkedHashMap {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final M f2857b;
+
+    /* renamed from: a, reason: collision with root package name */
+    public boolean f2858a = true;
+
+    static {
+        M m4 = new M();
+        f2857b = m4;
+        m4.f2858a = false;
+    }
+
+    public final void a() {
+        if (!this.f2858a) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r0v1, types: [java.util.LinkedHashMap, androidx.datastore.preferences.protobuf.M] */
+    public final M b() {
+        if (isEmpty()) {
+            return new M();
+        }
+        ?? linkedHashMap = new LinkedHashMap(this);
+        linkedHashMap.f2858a = true;
+        return linkedHashMap;
+    }
+
+    @Override // java.util.LinkedHashMap, java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final void clear() {
+        a();
+        super.clear();
+    }
+
+    @Override // java.util.LinkedHashMap, java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final Set entrySet() {
+        return isEmpty() ? Collections.EMPTY_SET : super.entrySet();
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:7:0x005d A[RETURN] */
+    @Override // java.util.AbstractMap, java.util.Map
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final boolean equals(java.lang.Object r6) {
+        /*
+            r5 = this;
+            boolean r0 = r6 instanceof java.util.Map
+            r1 = 0
+            if (r0 == 0) goto L5e
+            java.util.Map r6 = (java.util.Map) r6
+            r0 = 1
+            if (r5 != r6) goto Lc
+        La:
+            r5 = r0
+            goto L5b
+        Lc:
+            int r2 = r5.size()
+            int r3 = r6.size()
+            if (r2 == r3) goto L18
+        L16:
+            r5 = r1
+            goto L5b
+        L18:
+            java.util.Set r5 = r5.entrySet()
+            java.util.Iterator r5 = r5.iterator()
+        L20:
+            boolean r2 = r5.hasNext()
+            if (r2 == 0) goto La
+            java.lang.Object r2 = r5.next()
+            java.util.Map$Entry r2 = (java.util.Map.Entry) r2
+            java.lang.Object r3 = r2.getKey()
+            boolean r3 = r6.containsKey(r3)
+            if (r3 != 0) goto L37
+            goto L16
+        L37:
+            java.lang.Object r3 = r2.getValue()
+            java.lang.Object r2 = r2.getKey()
+            java.lang.Object r2 = r6.get(r2)
+            boolean r4 = r3 instanceof byte[]
+            if (r4 == 0) goto L54
+            boolean r4 = r2 instanceof byte[]
+            if (r4 == 0) goto L54
+            byte[] r3 = (byte[]) r3
+            byte[] r2 = (byte[]) r2
+            boolean r2 = java.util.Arrays.equals(r3, r2)
+            goto L58
+        L54:
+            boolean r2 = r3.equals(r2)
+        L58:
+            if (r2 != 0) goto L20
+            goto L16
+        L5b:
+            if (r5 == 0) goto L5e
+            return r0
+        L5e:
+            return r1
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.datastore.preferences.protobuf.M.equals(java.lang.Object):boolean");
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final int hashCode() {
+        int hashCode;
+        int hashCode2;
+        int i = 0;
+        for (Map.Entry entry : entrySet()) {
+            Object key = entry.getKey();
+            if (key instanceof byte[]) {
+                byte[] bArr = (byte[]) key;
+                Charset charset = AbstractC0133y.f2975a;
+                hashCode = bArr.length;
+                for (byte b4 : bArr) {
+                    hashCode = (hashCode * 31) + b4;
+                }
+                if (hashCode == 0) {
+                    hashCode = 1;
+                }
+            } else {
+                hashCode = key.hashCode();
+            }
+            Object value = entry.getValue();
+            if (value instanceof byte[]) {
+                byte[] bArr2 = (byte[]) value;
+                Charset charset2 = AbstractC0133y.f2975a;
+                hashCode2 = bArr2.length;
+                for (byte b5 : bArr2) {
+                    hashCode2 = (hashCode2 * 31) + b5;
+                }
+                if (hashCode2 == 0) {
+                    hashCode2 = 1;
+                }
+            } else {
+                hashCode2 = value.hashCode();
+            }
+            i += hashCode ^ hashCode2;
+        }
+        return i;
+    }
+
+    @Override // java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final Object put(Object obj, Object obj2) {
+        a();
+        Charset charset = AbstractC0133y.f2975a;
+        obj.getClass();
+        obj2.getClass();
+        return super.put(obj, obj2);
+    }
+
+    @Override // java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final void putAll(Map map) {
+        a();
+        for (Object obj : map.keySet()) {
+            Charset charset = AbstractC0133y.f2975a;
+            obj.getClass();
+            map.get(obj).getClass();
+        }
+        super.putAll(map);
+    }
+
+    @Override // java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final Object remove(Object obj) {
+        a();
+        return super.remove(obj);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/N.java

@@ -0,0 +1,53 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class N {
+    /* JADX WARN: Failed to find 'out' block for switch in B:12:0x004f. Please report as an issue. */
+    /* JADX WARN: Failed to find 'out' block for switch in B:18:0x012d. Please report as an issue. */
+    /* JADX WARN: Removed duplicated region for block: B:16:0x0128  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0136  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x0146  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x0157  */
+    /* JADX WARN: Removed duplicated region for block: B:26:0x015e  */
+    /* JADX WARN: Removed duplicated region for block: B:29:0x0166  */
+    /* JADX WARN: Removed duplicated region for block: B:31:0x0172  */
+    /* JADX WARN: Removed duplicated region for block: B:33:0x017e  */
+    /* JADX WARN: Removed duplicated region for block: B:40:0x0194  */
+    /* JADX WARN: Removed duplicated region for block: B:41:0x019f  */
+    /* JADX WARN: Removed duplicated region for block: B:43:0x01a6  */
+    /* JADX WARN: Removed duplicated region for block: B:49:0x01b8  */
+    /* JADX WARN: Removed duplicated region for block: B:51:0x01bf  */
+    /* JADX WARN: Removed duplicated region for block: B:52:0x01c5  */
+    /* JADX WARN: Removed duplicated region for block: B:54:0x01cb  */
+    /* JADX WARN: Removed duplicated region for block: B:56:0x01d6  */
+    /* JADX WARN: Removed duplicated region for block: B:58:0x01e1  */
+    /* JADX WARN: Removed duplicated region for block: B:60:0x01ec  */
+    /* JADX WARN: Removed duplicated region for block: B:61:0x01f3  */
+    /* JADX WARN: Removed duplicated region for block: B:63:0x0130 A[SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static int a(int r20, java.lang.Object r21, java.lang.Object r22) {
+        /*
+            Method dump skipped, instructions count: 594
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.datastore.preferences.protobuf.N.a(int, java.lang.Object, java.lang.Object):int");
+    }
+
+    public static M b(Object obj, Object obj2) {
+        M m4 = (M) obj;
+        M m5 = (M) obj2;
+        if (!m5.isEmpty()) {
+            if (!m4.f2858a) {
+                m4 = m4.b();
+            }
+            m4.a();
+            if (!m5.isEmpty()) {
+                m4.putAll(m5);
+            }
+        }
+        return m4;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/O.java

@@ -0,0 +1,23 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public abstract class O {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final N f2859a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final N f2860b;
+
+    /* JADX WARN: Type inference failed for: r0v2, types: [androidx.datastore.preferences.protobuf.N, java.lang.Object] */
+    static {
+        N n4;
+        try {
+            n4 = (N) Class.forName("androidx.datastore.preferences.protobuf.MapFieldSchemaFull").getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (Exception unused) {
+            n4 = null;
+        }
+        f2859a = n4;
+        f2860b = new Object();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/P.java

@@ -0,0 +1,8 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public interface P {
+    C0109a0 a(Class cls);
+
+    boolean b(Class cls);
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/Q.java

@@ -0,0 +1,208 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import kotlin.text.Typography;
+
+/* loaded from: classes.dex */
+public abstract class Q {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final e0 f2861a = new Object();
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final f0 f2862b = new Object();
+
+    public static void a(byte b4, byte b5, byte b6, byte b7, char[] cArr, int i) {
+        if (!h(b5)) {
+            if ((((b5 + 112) + (b4 << 28)) >> 30) == 0 && !h(b6) && !h(b7)) {
+                int i4 = ((b4 & 7) << 18) | ((b5 & 63) << 12) | ((b6 & 63) << 6) | (b7 & 63);
+                cArr[i] = (char) ((i4 >>> 10) + 55232);
+                cArr[i + 1] = (char) ((i4 & 1023) + 56320);
+                return;
+            }
+        }
+        throw A.a();
+    }
+
+    public static void b(byte b4, byte b5, char[] cArr, int i) {
+        if (b4 < -62 || h(b5)) {
+            throw A.a();
+        }
+        cArr[i] = (char) (((b4 & 31) << 6) | (b5 & 63));
+    }
+
+    public static void c(byte b4, byte b5, byte b6, char[] cArr, int i) {
+        if (h(b5) || ((b4 == -32 && b5 < -96) || ((b4 == -19 && b5 >= -96) || h(b6)))) {
+            throw A.a();
+        }
+        cArr[i] = (char) (((b4 & 15) << 12) | ((b5 & 63) << 6) | (b6 & 63));
+    }
+
+    public static final String d(String str) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < str.length(); i++) {
+            char charAt = str.charAt(i);
+            if (Character.isUpperCase(charAt)) {
+                sb.append("_");
+            }
+            sb.append(Character.toLowerCase(charAt));
+        }
+        return sb.toString();
+    }
+
+    public static String g(C0116g c0116g) {
+        StringBuilder sb = new StringBuilder(c0116g.size());
+        for (int i = 0; i < c0116g.size(); i++) {
+            byte b4 = c0116g.f2912b[i];
+            if (b4 == 34) {
+                sb.append("\\\"");
+            } else if (b4 == 39) {
+                sb.append("\\'");
+            } else if (b4 != 92) {
+                switch (b4) {
+                    case 7:
+                        sb.append("\\a");
+                        break;
+                    case 8:
+                        sb.append("\\b");
+                        break;
+                    case 9:
+                        sb.append("\\t");
+                        break;
+                    case 10:
+                        sb.append("\\n");
+                        break;
+                    case 11:
+                        sb.append("\\v");
+                        break;
+                    case 12:
+                        sb.append("\\f");
+                        break;
+                    case 13:
+                        sb.append("\\r");
+                        break;
+                    default:
+                        if (b4 < 32 || b4 > 126) {
+                            sb.append('\\');
+                            sb.append((char) (((b4 >>> 6) & 3) + 48));
+                            sb.append((char) (((b4 >>> 3) & 7) + 48));
+                            sb.append((char) ((b4 & 7) + 48));
+                            break;
+                        } else {
+                            sb.append((char) b4);
+                            break;
+                        }
+                        break;
+                }
+            } else {
+                sb.append("\\\\");
+            }
+        }
+        return sb.toString();
+    }
+
+    public static boolean h(byte b4) {
+        return b4 > -65;
+    }
+
+    public static final void j(StringBuilder sb, int i, String str, Object obj) {
+        if (obj instanceof List) {
+            Iterator it = ((List) obj).iterator();
+            while (it.hasNext()) {
+                j(sb, i, str, it.next());
+            }
+            return;
+        }
+        if (obj instanceof Map) {
+            Iterator it2 = ((Map) obj).entrySet().iterator();
+            while (it2.hasNext()) {
+                j(sb, i, str, (Map.Entry) it2.next());
+            }
+            return;
+        }
+        sb.append('\n');
+        int i4 = 0;
+        for (int i5 = 0; i5 < i; i5++) {
+            sb.append(' ');
+        }
+        sb.append(str);
+        if (obj instanceof String) {
+            sb.append(": \"");
+            C0116g c0116g = C0116g.f2909c;
+            sb.append(g(new C0116g(((String) obj).getBytes(AbstractC0133y.f2975a))));
+            sb.append(Typography.quote);
+            return;
+        }
+        if (obj instanceof C0116g) {
+            sb.append(": \"");
+            sb.append(g((C0116g) obj));
+            sb.append(Typography.quote);
+            return;
+        }
+        if (obj instanceof AbstractC0130v) {
+            sb.append(" {");
+            k((AbstractC0130v) obj, sb, i + 2);
+            sb.append("\n");
+            while (i4 < i) {
+                sb.append(' ');
+                i4++;
+            }
+            sb.append("}");
+            return;
+        }
+        if (!(obj instanceof Map.Entry)) {
+            sb.append(": ");
+            sb.append(obj.toString());
+            return;
+        }
+        sb.append(" {");
+        Map.Entry entry = (Map.Entry) obj;
+        int i6 = i + 2;
+        j(sb, i6, "key", entry.getKey());
+        j(sb, i6, "value", entry.getValue());
+        sb.append("\n");
+        while (i4 < i) {
+            sb.append(' ');
+            i4++;
+        }
+        sb.append("}");
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:68:0x01ad, code lost:
+    
+        if (((java.lang.Integer) r11).intValue() == 0) goto L57;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:69:0x01af, code lost:
+    
+        r7 = true;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:74:0x01c1, code lost:
+    
+        if (((java.lang.Float) r11).floatValue() == com.google.android.gms.maps.model.BitmapDescriptorFactory.HUE_RED) goto L57;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:78:0x01d3, code lost:
+    
+        if (((java.lang.Double) r11).doubleValue() == com.google.firebase.remoteconfig.FirebaseRemoteConfig.DEFAULT_VALUE_FOR_DOUBLE) goto L57;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static void k(androidx.datastore.preferences.protobuf.AbstractC0130v r18, java.lang.StringBuilder r19, int r20) {
+        /*
+            Method dump skipped, instructions count: 580
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.datastore.preferences.protobuf.Q.k(androidx.datastore.preferences.protobuf.v, java.lang.StringBuilder, int):void");
+    }
+
+    public abstract String e(int i, int i4, byte[] bArr);
+
+    public abstract int f(String str, byte[] bArr, int i, int i4);
+
+    public abstract int i(byte[] bArr, int i, int i4);
+
+    public abstract void l(int i, int i4, byte[] bArr);
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/T.java

@@ -0,0 +1,95 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class T implements InterfaceC0111b0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final AbstractC0130v f2876a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final k0 f2877b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final C0123n f2878c;
+
+    public T(k0 k0Var, C0123n c0123n, AbstractC0130v abstractC0130v) {
+        this.f2877b = k0Var;
+        c0123n.getClass();
+        this.f2878c = c0123n;
+        this.f2876a = abstractC0130v;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final void a(Object obj, J j4) {
+        this.f2878c.getClass();
+        C.w.w(obj);
+        throw null;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final int b(AbstractC0130v abstractC0130v) {
+        this.f2877b.getClass();
+        return abstractC0130v.unknownFields.hashCode();
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final void c(Object obj, Z2.y yVar, C0122m c0122m) {
+        this.f2877b.getClass();
+        AbstractC0130v abstractC0130v = (AbstractC0130v) obj;
+        if (abstractC0130v.unknownFields == j0.f2935f) {
+            abstractC0130v.unknownFields = j0.b();
+        }
+        this.f2878c.getClass();
+        obj.getClass();
+        throw new ClassCastException();
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final void d(Object obj) {
+        this.f2877b.getClass();
+        ((AbstractC0130v) obj).unknownFields.f2940e = false;
+        this.f2878c.getClass();
+        C.w.w(obj);
+        throw null;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final int e(AbstractC0108a abstractC0108a) {
+        this.f2877b.getClass();
+        j0 j0Var = ((AbstractC0130v) abstractC0108a).unknownFields;
+        int i = j0Var.f2939d;
+        if (i != -1) {
+            return i;
+        }
+        int i4 = 0;
+        for (int i5 = 0; i5 < j0Var.f2936a; i5++) {
+            int i6 = j0Var.f2937b[i5] >>> 3;
+            i4 += C0119j.r(3, (C0116g) j0Var.f2938c[i5]) + C0119j.z(i6) + C0119j.y(2) + (C0119j.y(1) * 2);
+        }
+        j0Var.f2939d = i4;
+        return i4;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final boolean f(Object obj) {
+        this.f2878c.getClass();
+        C.w.w(obj);
+        throw null;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final boolean g(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2) {
+        this.f2877b.getClass();
+        return abstractC0130v.unknownFields.equals(abstractC0130v2.unknownFields);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final void h(AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2) {
+        c0.x(this.f2877b, abstractC0130v, abstractC0130v2);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0111b0
+    public final Object i() {
+        return ((AbstractC0128t) this.f2876a.d(5)).b();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/U.java

@@ -0,0 +1,5 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class U {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/V.java

@@ -0,0 +1,23 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public abstract class V {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final U f2879a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final U f2880b;
+
+    /* JADX WARN: Type inference failed for: r0v2, types: [java.lang.Object, androidx.datastore.preferences.protobuf.U] */
+    static {
+        U u3;
+        try {
+            u3 = (U) Class.forName("androidx.datastore.preferences.protobuf.NewInstanceSchemaFull").getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (Exception unused) {
+            u3 = null;
+        }
+        f2879a = u3;
+        f2880b = new Object();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/W.java

@@ -0,0 +1,5 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public interface W {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/X.java

@@ -0,0 +1,5 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public interface X {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/Y.java

@@ -0,0 +1,63 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes.dex */
+public final class Y {
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final Y f2881c = new Y();
+
+    /* renamed from: b, reason: collision with root package name */
+    public final ConcurrentHashMap f2883b = new ConcurrentHashMap();
+
+    /* renamed from: a, reason: collision with root package name */
+    public final J f2882a = new J();
+
+    public final InterfaceC0111b0 a(Class cls) {
+        InterfaceC0111b0 x3;
+        Class cls2;
+        AbstractC0133y.a(cls, "messageType");
+        ConcurrentHashMap concurrentHashMap = this.f2883b;
+        InterfaceC0111b0 interfaceC0111b0 = (InterfaceC0111b0) concurrentHashMap.get(cls);
+        if (interfaceC0111b0 != null) {
+            return interfaceC0111b0;
+        }
+        J j4 = this.f2882a;
+        j4.getClass();
+        Class cls3 = c0.f2894a;
+        if (!AbstractC0130v.class.isAssignableFrom(cls) && (cls2 = c0.f2894a) != null && !cls2.isAssignableFrom(cls)) {
+            throw new IllegalArgumentException("Message classes must extend GeneratedMessage or GeneratedMessageLite");
+        }
+        C0109a0 a2 = ((I) j4.f2852a).a(cls);
+        if ((a2.f2890d & 2) == 2) {
+            boolean isAssignableFrom = AbstractC0130v.class.isAssignableFrom(cls);
+            AbstractC0130v abstractC0130v = a2.f2887a;
+            if (isAssignableFrom) {
+                x3 = new T(c0.f2897d, AbstractC0124o.f2948a, abstractC0130v);
+            } else {
+                k0 k0Var = c0.f2895b;
+                C0123n c0123n = AbstractC0124o.f2949b;
+                if (c0123n == null) {
+                    throw new IllegalStateException("Protobuf runtime is not correctly loaded.");
+                }
+                x3 = new T(k0Var, c0123n, abstractC0130v);
+            }
+        } else if (AbstractC0130v.class.isAssignableFrom(cls)) {
+            x3 = (a2.f2890d & 1) == 1 ? S.x(a2, V.f2880b, G.f2849b, c0.f2897d, AbstractC0124o.f2948a, O.f2860b) : S.x(a2, V.f2880b, G.f2849b, c0.f2897d, null, O.f2860b);
+        } else if ((a2.f2890d & 1) == 1) {
+            U u3 = V.f2879a;
+            E e4 = G.f2848a;
+            k0 k0Var2 = c0.f2895b;
+            C0123n c0123n2 = AbstractC0124o.f2949b;
+            if (c0123n2 == null) {
+                throw new IllegalStateException("Protobuf runtime is not correctly loaded.");
+            }
+            x3 = S.x(a2, u3, e4, k0Var2, c0123n2, O.f2859a);
+        } else {
+            x3 = S.x(a2, V.f2879a, G.f2848a, c0.f2896c, null, O.f2859a);
+        }
+        InterfaceC0111b0 interfaceC0111b02 = (InterfaceC0111b0) concurrentHashMap.putIfAbsent(cls, x3);
+        return interfaceC0111b02 != null ? interfaceC0111b02 : x3;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/Z.java

@@ -0,0 +1,121 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.RandomAccess;
+
+/* loaded from: classes.dex */
+public final class Z extends AbstractC0110b implements RandomAccess {
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final Z f2884d;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Object[] f2885b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f2886c;
+
+    static {
+        Z z3 = new Z(new Object[0], 0);
+        f2884d = z3;
+        z3.f2891a = false;
+    }
+
+    public Z(Object[] objArr, int i) {
+        this.f2885b = objArr;
+        this.f2886c = i;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.AbstractC0110b, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean add(Object obj) {
+        a();
+        int i = this.f2886c;
+        Object[] objArr = this.f2885b;
+        if (i == objArr.length) {
+            this.f2885b = Arrays.copyOf(objArr, ((i * 3) / 2) + 1);
+        }
+        Object[] objArr2 = this.f2885b;
+        int i4 = this.f2886c;
+        this.f2886c = i4 + 1;
+        objArr2[i4] = obj;
+        ((AbstractList) this).modCount++;
+        return true;
+    }
+
+    public final void b(int i) {
+        if (i < 0 || i >= this.f2886c) {
+            StringBuilder t2 = C.w.t(i, "Index:", ", Size:");
+            t2.append(this.f2886c);
+            throw new IndexOutOfBoundsException(t2.toString());
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.InterfaceC0132x
+    public final InterfaceC0132x d(int i) {
+        if (i >= this.f2886c) {
+            return new Z(Arrays.copyOf(this.f2885b, i), this.f2886c);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        b(i);
+        return this.f2885b[i];
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        a();
+        b(i);
+        Object[] objArr = this.f2885b;
+        Object obj = objArr[i];
+        if (i < this.f2886c - 1) {
+            System.arraycopy(objArr, i + 1, objArr, i, (r2 - i) - 1);
+        }
+        this.f2886c--;
+        ((AbstractList) this).modCount++;
+        return obj;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        a();
+        b(i);
+        Object[] objArr = this.f2885b;
+        Object obj2 = objArr[i];
+        objArr[i] = obj;
+        ((AbstractList) this).modCount++;
+        return obj2;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.f2886c;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        int i4;
+        a();
+        if (i >= 0 && i <= (i4 = this.f2886c)) {
+            Object[] objArr = this.f2885b;
+            if (i4 < objArr.length) {
+                System.arraycopy(objArr, i, objArr, i + 1, i4 - i);
+            } else {
+                Object[] objArr2 = new Object[((i4 * 3) / 2) + 1];
+                System.arraycopy(objArr, 0, objArr2, 0, i);
+                System.arraycopy(this.f2885b, i, objArr2, i + 1, this.f2886c - i);
+                this.f2885b = objArr2;
+            }
+            this.f2885b[i] = obj;
+            this.f2886c++;
+            ((AbstractList) this).modCount++;
+            return;
+        }
+        StringBuilder t2 = C.w.t(i, "Index:", ", Size:");
+        t2.append(this.f2886c);
+        throw new IndexOutOfBoundsException(t2.toString());
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/c0.java

@@ -0,0 +1,763 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.logging.Logger;
+
+/* loaded from: classes.dex */
+public abstract class c0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Class f2894a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final k0 f2895b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final k0 f2896c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final k0 f2897d;
+
+    /* JADX WARN: Type inference failed for: r0v6, types: [androidx.datastore.preferences.protobuf.k0, java.lang.Object] */
+    static {
+        Class<?> cls;
+        try {
+            cls = Class.forName("androidx.datastore.preferences.protobuf.GeneratedMessageV3");
+        } catch (Throwable unused) {
+            cls = null;
+        }
+        f2894a = cls;
+        f2895b = w(false);
+        f2896c = w(true);
+        f2897d = new Object();
+    }
+
+    public static void A(int i, List list, J j4) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        j4.getClass();
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((C0119j) j4.f2852a).G(i, (C0116g) list.get(i4));
+        }
+    }
+
+    public static void B(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                double doubleValue = ((Double) list.get(i4)).doubleValue();
+                c0119j.getClass();
+                c0119j.K(i, Double.doubleToRawLongBits(doubleValue));
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            ((Double) list.get(i6)).getClass();
+            Logger logger = C0119j.h;
+            i5 += 8;
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.L(Double.doubleToRawLongBits(((Double) list.get(i4)).doubleValue()));
+            i4++;
+        }
+    }
+
+    public static void C(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.M(i, ((Integer) list.get(i4)).intValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            i5 += C0119j.w(((Integer) list.get(i6)).intValue());
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.N(((Integer) list.get(i4)).intValue());
+            i4++;
+        }
+    }
+
+    public static void D(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.I(i, ((Integer) list.get(i4)).intValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            ((Integer) list.get(i6)).getClass();
+            Logger logger = C0119j.h;
+            i5 += 4;
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.J(((Integer) list.get(i4)).intValue());
+            i4++;
+        }
+    }
+
+    public static void E(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.K(i, ((Long) list.get(i4)).longValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            ((Long) list.get(i6)).getClass();
+            Logger logger = C0119j.h;
+            i5 += 8;
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.L(((Long) list.get(i4)).longValue());
+            i4++;
+        }
+    }
+
+    public static void F(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                float floatValue = ((Float) list.get(i4)).floatValue();
+                c0119j.getClass();
+                c0119j.I(i, Float.floatToRawIntBits(floatValue));
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            ((Float) list.get(i6)).getClass();
+            Logger logger = C0119j.h;
+            i5 += 4;
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.J(Float.floatToRawIntBits(((Float) list.get(i4)).floatValue()));
+            i4++;
+        }
+    }
+
+    public static void G(int i, List list, J j4, InterfaceC0111b0 interfaceC0111b0) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        j4.getClass();
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            j4.b(i, list.get(i4), interfaceC0111b0);
+        }
+    }
+
+    public static void H(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.M(i, ((Integer) list.get(i4)).intValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            i5 += C0119j.w(((Integer) list.get(i6)).intValue());
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.N(((Integer) list.get(i4)).intValue());
+            i4++;
+        }
+    }
+
+    public static void I(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.U(i, ((Long) list.get(i4)).longValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            i5 += C0119j.A(((Long) list.get(i6)).longValue());
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.V(((Long) list.get(i4)).longValue());
+            i4++;
+        }
+    }
+
+    public static void J(int i, List list, J j4, InterfaceC0111b0 interfaceC0111b0) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        j4.getClass();
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((C0119j) j4.f2852a).O(i, (AbstractC0108a) list.get(i4), interfaceC0111b0);
+        }
+    }
+
+    public static void K(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.I(i, ((Integer) list.get(i4)).intValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            ((Integer) list.get(i6)).getClass();
+            Logger logger = C0119j.h;
+            i5 += 4;
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.J(((Integer) list.get(i4)).intValue());
+            i4++;
+        }
+    }
+
+    public static void L(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.K(i, ((Long) list.get(i4)).longValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            ((Long) list.get(i6)).getClass();
+            Logger logger = C0119j.h;
+            i5 += 8;
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.L(((Long) list.get(i4)).longValue());
+            i4++;
+        }
+    }
+
+    public static void M(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                int intValue = ((Integer) list.get(i4)).intValue();
+                c0119j.S(i, (intValue >> 31) ^ (intValue << 1));
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            int intValue2 = ((Integer) list.get(i6)).intValue();
+            i5 += C0119j.z((intValue2 >> 31) ^ (intValue2 << 1));
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            int intValue3 = ((Integer) list.get(i4)).intValue();
+            c0119j.T((intValue3 >> 31) ^ (intValue3 << 1));
+            i4++;
+        }
+    }
+
+    public static void N(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                long longValue = ((Long) list.get(i4)).longValue();
+                c0119j.U(i, (longValue >> 63) ^ (longValue << 1));
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            long longValue2 = ((Long) list.get(i6)).longValue();
+            i5 += C0119j.A((longValue2 >> 63) ^ (longValue2 << 1));
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            long longValue3 = ((Long) list.get(i4)).longValue();
+            c0119j.V((longValue3 >> 63) ^ (longValue3 << 1));
+            i4++;
+        }
+    }
+
+    public static void O(int i, List list, J j4) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        j4.getClass();
+        boolean z3 = list instanceof D;
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.P(i, (String) list.get(i4));
+                i4++;
+            }
+            return;
+        }
+        D d4 = (D) list;
+        while (i4 < list.size()) {
+            Object s4 = d4.s(i4);
+            if (s4 instanceof String) {
+                c0119j.P(i, (String) s4);
+            } else {
+                c0119j.G(i, (C0116g) s4);
+            }
+            i4++;
+        }
+    }
+
+    public static void P(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.S(i, ((Integer) list.get(i4)).intValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            i5 += C0119j.z(((Integer) list.get(i6)).intValue());
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.T(((Integer) list.get(i4)).intValue());
+            i4++;
+        }
+    }
+
+    public static void Q(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.U(i, ((Long) list.get(i4)).longValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            i5 += C0119j.A(((Long) list.get(i6)).longValue());
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.V(((Long) list.get(i4)).longValue());
+            i4++;
+        }
+    }
+
+    public static int a(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        int y3 = C0119j.y(i) * size;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            y3 += C0119j.s((C0116g) list.get(i4));
+        }
+        return y3;
+    }
+
+    public static int b(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return (C0119j.y(i) * size) + c(list);
+    }
+
+    public static int c(List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof AbstractC0131w) {
+            if (size <= 0) {
+                return 0;
+            }
+            throw null;
+        }
+        int i = 0;
+        for (int i4 = 0; i4 < size; i4++) {
+            i += C0119j.w(((Integer) list.get(i4)).intValue());
+        }
+        return i;
+    }
+
+    public static int d(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return C0119j.t(i) * size;
+    }
+
+    public static int e(List list) {
+        return list.size() * 4;
+    }
+
+    public static int f(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return C0119j.u(i) * size;
+    }
+
+    public static int g(List list) {
+        return list.size() * 8;
+    }
+
+    public static int h(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return (C0119j.y(i) * size) + i(list);
+    }
+
+    public static int i(List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof AbstractC0131w) {
+            if (size <= 0) {
+                return 0;
+            }
+            throw null;
+        }
+        int i = 0;
+        for (int i4 = 0; i4 < size; i4++) {
+            i += C0119j.w(((Integer) list.get(i4)).intValue());
+        }
+        return i;
+    }
+
+    public static int j(int i, List list) {
+        if (list.size() == 0) {
+            return 0;
+        }
+        return (C0119j.y(i) * list.size()) + k(list);
+    }
+
+    public static int k(List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof H) {
+            if (size <= 0) {
+                return 0;
+            }
+            throw null;
+        }
+        int i = 0;
+        for (int i4 = 0; i4 < size; i4++) {
+            i += C0119j.A(((Long) list.get(i4)).longValue());
+        }
+        return i;
+    }
+
+    public static int l(int i, List list, InterfaceC0111b0 interfaceC0111b0) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        int y3 = C0119j.y(i) * size;
+        for (int i4 = 0; i4 < size; i4++) {
+            int b4 = ((AbstractC0108a) list.get(i4)).b(interfaceC0111b0);
+            y3 += C0119j.z(b4) + b4;
+        }
+        return y3;
+    }
+
+    public static int m(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return (C0119j.y(i) * size) + n(list);
+    }
+
+    public static int n(List list) {
+        int size = list.size();
+        if (size != 0) {
+            if (!(list instanceof AbstractC0131w)) {
+                int i = 0;
+                for (int i4 = 0; i4 < size; i4++) {
+                    int intValue = ((Integer) list.get(i4)).intValue();
+                    i += C0119j.z((intValue >> 31) ^ (intValue << 1));
+                }
+                return i;
+            }
+            if (size > 0) {
+                throw null;
+            }
+        }
+        return 0;
+    }
+
+    public static int o(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return (C0119j.y(i) * size) + p(list);
+    }
+
+    public static int p(List list) {
+        int size = list.size();
+        if (size != 0) {
+            if (!(list instanceof H)) {
+                int i = 0;
+                for (int i4 = 0; i4 < size; i4++) {
+                    long longValue = ((Long) list.get(i4)).longValue();
+                    i += C0119j.A((longValue >> 63) ^ (longValue << 1));
+                }
+                return i;
+            }
+            if (size > 0) {
+                throw null;
+            }
+        }
+        return 0;
+    }
+
+    public static int q(int i, List list) {
+        int size = list.size();
+        int i4 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        int y3 = C0119j.y(i) * size;
+        if (!(list instanceof D)) {
+            while (i4 < size) {
+                Object obj = list.get(i4);
+                y3 = (obj instanceof C0116g ? C0119j.s((C0116g) obj) : C0119j.x((String) obj)) + y3;
+                i4++;
+            }
+            return y3;
+        }
+        D d4 = (D) list;
+        while (i4 < size) {
+            Object s4 = d4.s(i4);
+            y3 = (s4 instanceof C0116g ? C0119j.s((C0116g) s4) : C0119j.x((String) s4)) + y3;
+            i4++;
+        }
+        return y3;
+    }
+
+    public static int r(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return (C0119j.y(i) * size) + s(list);
+    }
+
+    public static int s(List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof AbstractC0131w) {
+            if (size <= 0) {
+                return 0;
+            }
+            throw null;
+        }
+        int i = 0;
+        for (int i4 = 0; i4 < size; i4++) {
+            i += C0119j.z(((Integer) list.get(i4)).intValue());
+        }
+        return i;
+    }
+
+    public static int t(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return (C0119j.y(i) * size) + u(list);
+    }
+
+    public static int u(List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof H) {
+            if (size <= 0) {
+                return 0;
+            }
+            throw null;
+        }
+        int i = 0;
+        for (int i4 = 0; i4 < size; i4++) {
+            i += C0119j.A(((Long) list.get(i4)).longValue());
+        }
+        return i;
+    }
+
+    public static Object v(int i, List list, Object obj, k0 k0Var) {
+        return obj;
+    }
+
+    public static k0 w(boolean z3) {
+        Class<?> cls;
+        try {
+            cls = Class.forName("androidx.datastore.preferences.protobuf.UnknownFieldSetSchema");
+        } catch (Throwable unused) {
+            cls = null;
+        }
+        if (cls != null) {
+            try {
+                return (k0) cls.getConstructor(Boolean.TYPE).newInstance(Boolean.valueOf(z3));
+            } catch (Throwable unused2) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+    public static void x(k0 k0Var, AbstractC0130v abstractC0130v, AbstractC0130v abstractC0130v2) {
+        k0Var.getClass();
+        j0 j0Var = abstractC0130v.unknownFields;
+        j0 j0Var2 = abstractC0130v2.unknownFields;
+        if (!j0Var2.equals(j0.f2935f)) {
+            int i = j0Var.f2936a + j0Var2.f2936a;
+            int[] copyOf = Arrays.copyOf(j0Var.f2937b, i);
+            System.arraycopy(j0Var2.f2937b, 0, copyOf, j0Var.f2936a, j0Var2.f2936a);
+            Object[] copyOf2 = Arrays.copyOf(j0Var.f2938c, i);
+            System.arraycopy(j0Var2.f2938c, 0, copyOf2, j0Var.f2936a, j0Var2.f2936a);
+            j0Var = new j0(i, copyOf, copyOf2, true);
+        }
+        abstractC0130v.unknownFields = j0Var;
+    }
+
+    public static boolean y(Object obj, Object obj2) {
+        if (obj != obj2) {
+            return obj != null && obj.equals(obj2);
+        }
+        return true;
+    }
+
+    public static void z(int i, List list, J j4, boolean z3) {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        C0119j c0119j = (C0119j) j4.f2852a;
+        int i4 = 0;
+        if (!z3) {
+            while (i4 < list.size()) {
+                c0119j.F(i, ((Boolean) list.get(i4)).booleanValue());
+                i4++;
+            }
+            return;
+        }
+        c0119j.R(i, 2);
+        int i5 = 0;
+        for (int i6 = 0; i6 < list.size(); i6++) {
+            ((Boolean) list.get(i6)).getClass();
+            Logger logger = C0119j.h;
+            i5++;
+        }
+        c0119j.T(i5);
+        while (i4 < list.size()) {
+            c0119j.D(((Boolean) list.get(i4)).booleanValue() ? (byte) 1 : (byte) 0);
+            i4++;
+        }
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/d0.java

@@ -0,0 +1,233 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/* loaded from: classes.dex */
+public final class d0 extends AbstractMap {
+
+    /* renamed from: g, reason: collision with root package name */
+    public static final /* synthetic */ int f2898g = 0;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f2899a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public List f2900b = Collections.EMPTY_LIST;
+
+    /* renamed from: c, reason: collision with root package name */
+    public Map f2901c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public boolean f2902d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public volatile i0 f2903e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public Map f2904f;
+
+    public d0(int i) {
+        this.f2899a = i;
+        Map map = Collections.EMPTY_MAP;
+        this.f2901c = map;
+        this.f2904f = map;
+    }
+
+    public final int a(Comparable comparable) {
+        int i;
+        int size = this.f2900b.size();
+        int i4 = size - 1;
+        if (i4 >= 0) {
+            int compareTo = comparable.compareTo(((g0) this.f2900b.get(i4)).f2913a);
+            if (compareTo > 0) {
+                i = size + 1;
+                return -i;
+            }
+            if (compareTo == 0) {
+                return i4;
+            }
+        }
+        int i5 = 0;
+        while (i5 <= i4) {
+            int i6 = (i5 + i4) / 2;
+            int compareTo2 = comparable.compareTo(((g0) this.f2900b.get(i6)).f2913a);
+            if (compareTo2 < 0) {
+                i4 = i6 - 1;
+            } else {
+                if (compareTo2 <= 0) {
+                    return i6;
+                }
+                i5 = i6 + 1;
+            }
+        }
+        i = i5 + 1;
+        return -i;
+    }
+
+    public final void b() {
+        if (this.f2902d) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public final Map.Entry c(int i) {
+        return (Map.Entry) this.f2900b.get(i);
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final void clear() {
+        b();
+        if (!this.f2900b.isEmpty()) {
+            this.f2900b.clear();
+        }
+        if (this.f2901c.isEmpty()) {
+            return;
+        }
+        this.f2901c.clear();
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final boolean containsKey(Object obj) {
+        Comparable comparable = (Comparable) obj;
+        return a(comparable) >= 0 || this.f2901c.containsKey(comparable);
+    }
+
+    public final Iterable d() {
+        return this.f2901c.isEmpty() ? Q.f2862b : this.f2901c.entrySet();
+    }
+
+    public final SortedMap e() {
+        b();
+        if (this.f2901c.isEmpty() && !(this.f2901c instanceof TreeMap)) {
+            TreeMap treeMap = new TreeMap();
+            this.f2901c = treeMap;
+            this.f2904f = treeMap.descendingMap();
+        }
+        return (SortedMap) this.f2901c;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final Set entrySet() {
+        if (this.f2903e == null) {
+            this.f2903e = new i0(this, 0);
+        }
+        return this.f2903e;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof d0)) {
+            return super.equals(obj);
+        }
+        d0 d0Var = (d0) obj;
+        int size = size();
+        if (size == d0Var.size()) {
+            int size2 = this.f2900b.size();
+            if (size2 != d0Var.f2900b.size()) {
+                return ((AbstractSet) entrySet()).equals(d0Var.entrySet());
+            }
+            for (int i = 0; i < size2; i++) {
+                if (c(i).equals(d0Var.c(i))) {
+                }
+            }
+            if (size2 != size) {
+                return this.f2901c.equals(d0Var.f2901c);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public final Object f(Comparable comparable, Object obj) {
+        b();
+        int a2 = a(comparable);
+        if (a2 >= 0) {
+            return ((g0) this.f2900b.get(a2)).setValue(obj);
+        }
+        b();
+        boolean isEmpty = this.f2900b.isEmpty();
+        int i = this.f2899a;
+        if (isEmpty && !(this.f2900b instanceof ArrayList)) {
+            this.f2900b = new ArrayList(i);
+        }
+        int i4 = -(a2 + 1);
+        if (i4 >= i) {
+            return e().put(comparable, obj);
+        }
+        if (this.f2900b.size() == i) {
+            g0 g0Var = (g0) this.f2900b.remove(i - 1);
+            e().put(g0Var.f2913a, g0Var.f2914b);
+        }
+        this.f2900b.add(i4, new g0(this, comparable, obj));
+        return null;
+    }
+
+    public final Object g(int i) {
+        b();
+        Object obj = ((g0) this.f2900b.remove(i)).f2914b;
+        if (!this.f2901c.isEmpty()) {
+            Iterator it = e().entrySet().iterator();
+            List list = this.f2900b;
+            Map.Entry entry = (Map.Entry) it.next();
+            list.add(new g0(this, (Comparable) entry.getKey(), entry.getValue()));
+            it.remove();
+        }
+        return obj;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final Object get(Object obj) {
+        Comparable comparable = (Comparable) obj;
+        int a2 = a(comparable);
+        return a2 >= 0 ? ((g0) this.f2900b.get(a2)).f2914b : this.f2901c.get(comparable);
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final int hashCode() {
+        int size = this.f2900b.size();
+        int i = 0;
+        for (int i4 = 0; i4 < size; i4++) {
+            i += ((g0) this.f2900b.get(i4)).hashCode();
+        }
+        return this.f2901c.size() > 0 ? this.f2901c.hashCode() + i : i;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final /* synthetic */ Object put(Object obj, Object obj2) {
+        if (obj == null) {
+            return f(null, obj2);
+        }
+        throw new ClassCastException();
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final Object remove(Object obj) {
+        b();
+        Comparable comparable = (Comparable) obj;
+        int a2 = a(comparable);
+        if (a2 >= 0) {
+            return g(a2);
+        }
+        if (this.f2901c.isEmpty()) {
+            return null;
+        }
+        return this.f2901c.remove(comparable);
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final int size() {
+        return this.f2901c.size() + this.f2900b.size();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/e0.java

@@ -0,0 +1,22 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes.dex */
+public final class e0 implements Iterator {
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        return false;
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        throw new NoSuchElementException();
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/f0.java

@@ -0,0 +1,11 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public final class f0 implements Iterable {
+    @Override // java.lang.Iterable
+    public final Iterator iterator() {
+        return Q.f2861a;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/g0.java

@@ -0,0 +1,76 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public final class g0 implements Map.Entry, Comparable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Comparable f2913a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Object f2914b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ d0 f2915c;
+
+    public g0(d0 d0Var, Comparable comparable, Object obj) {
+        this.f2915c = d0Var;
+        this.f2913a = comparable;
+        this.f2914b = obj;
+    }
+
+    @Override // java.lang.Comparable
+    public final int compareTo(Object obj) {
+        return this.f2913a.compareTo(((g0) obj).f2913a);
+    }
+
+    @Override // java.util.Map.Entry
+    public final boolean equals(Object obj) {
+        if (obj != this) {
+            if (obj instanceof Map.Entry) {
+                Map.Entry entry = (Map.Entry) obj;
+                Object key = entry.getKey();
+                Comparable comparable = this.f2913a;
+                if (comparable == null ? key == null : comparable.equals(key)) {
+                    Object obj2 = this.f2914b;
+                    Object value = entry.getValue();
+                    if (obj2 == null ? value == null : obj2.equals(value)) {
+                    }
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object getKey() {
+        return this.f2913a;
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object getValue() {
+        return this.f2914b;
+    }
+
+    @Override // java.util.Map.Entry
+    public final int hashCode() {
+        Comparable comparable = this.f2913a;
+        int hashCode = comparable == null ? 0 : comparable.hashCode();
+        Object obj = this.f2914b;
+        return hashCode ^ (obj != null ? obj.hashCode() : 0);
+    }
+
+    @Override // java.util.Map.Entry
+    public final Object setValue(Object obj) {
+        this.f2915c.b();
+        Object obj2 = this.f2914b;
+        this.f2914b = obj;
+        return obj2;
+    }
+
+    public final String toString() {
+        return this.f2913a + "=" + this.f2914b;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/h0.java

@@ -0,0 +1,65 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public final class h0 implements Iterator {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f2924a = -1;
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f2925b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public Iterator f2926c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ d0 f2927d;
+
+    public h0(d0 d0Var) {
+        this.f2927d = d0Var;
+    }
+
+    public final Iterator a() {
+        if (this.f2926c == null) {
+            this.f2926c = this.f2927d.f2901c.entrySet().iterator();
+        }
+        return this.f2926c;
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        int i = this.f2924a + 1;
+        d0 d0Var = this.f2927d;
+        return i < d0Var.f2900b.size() || (!d0Var.f2901c.isEmpty() && a().hasNext());
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        this.f2925b = true;
+        int i = this.f2924a + 1;
+        this.f2924a = i;
+        d0 d0Var = this.f2927d;
+        return i < d0Var.f2900b.size() ? (Map.Entry) d0Var.f2900b.get(this.f2924a) : (Map.Entry) a().next();
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        if (!this.f2925b) {
+            throw new IllegalStateException("remove() was called before next()");
+        }
+        this.f2925b = false;
+        int i = d0.f2898g;
+        d0 d0Var = this.f2927d;
+        d0Var.b();
+        if (this.f2924a >= d0Var.f2900b.size()) {
+            a().remove();
+            return;
+        }
+        int i4 = this.f2924a;
+        this.f2924a = i4 - 1;
+        d0Var.g(i4);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/i0.java

@@ -0,0 +1,95 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.AbstractSet;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class i0 extends AbstractSet {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f2928a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Map f2929b;
+
+    public /* synthetic */ i0(Map map, int i) {
+        this.f2928a = i;
+        this.f2929b = map;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean add(Object obj) {
+        switch (this.f2928a) {
+            case 0:
+                Map.Entry entry = (Map.Entry) obj;
+                if (contains(entry)) {
+                    return false;
+                }
+                ((d0) this.f2929b).f((Comparable) entry.getKey(), entry.getValue());
+                return true;
+            default:
+                return super.add(obj);
+        }
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public void clear() {
+        switch (this.f2928a) {
+            case 0:
+                ((d0) this.f2929b).clear();
+                return;
+            default:
+                super.clear();
+                return;
+        }
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean contains(Object obj) {
+        switch (this.f2928a) {
+            case 0:
+                Map.Entry entry = (Map.Entry) obj;
+                Object obj2 = ((d0) this.f2929b).get(entry.getKey());
+                Object value = entry.getValue();
+                return obj2 == value || (obj2 != null && obj2.equals(value));
+            default:
+                return super.contains(obj);
+        }
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
+    public Iterator iterator() {
+        switch (this.f2928a) {
+            case 0:
+                return new h0((d0) this.f2929b);
+            default:
+                return new s.c((s.e) this.f2929b);
+        }
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public boolean remove(Object obj) {
+        switch (this.f2928a) {
+            case 0:
+                Map.Entry entry = (Map.Entry) obj;
+                if (!contains(entry)) {
+                    return false;
+                }
+                ((d0) this.f2929b).remove(entry.getKey());
+                return true;
+            default:
+                return super.remove(obj);
+        }
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+    public final int size() {
+        switch (this.f2928a) {
+            case 0:
+                return ((d0) this.f2929b).size();
+            default:
+                return ((s.e) this.f2929b).f8352c;
+        }
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/j0.java

@@ -0,0 +1,176 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public final class j0 {
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final j0 f2935f = new j0(0, new int[0], new Object[0], false);
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f2936a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public int[] f2937b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public Object[] f2938c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f2939d = -1;
+
+    /* renamed from: e, reason: collision with root package name */
+    public boolean f2940e;
+
+    public j0(int i, int[] iArr, Object[] objArr, boolean z3) {
+        this.f2936a = i;
+        this.f2937b = iArr;
+        this.f2938c = objArr;
+        this.f2940e = z3;
+    }
+
+    public static j0 b() {
+        return new j0(0, new int[8], new Object[8], true);
+    }
+
+    public final int a() {
+        int y3;
+        int A3;
+        int u3;
+        int i = this.f2939d;
+        if (i != -1) {
+            return i;
+        }
+        int i4 = 0;
+        for (int i5 = 0; i5 < this.f2936a; i5++) {
+            int i6 = this.f2937b[i5];
+            int i7 = i6 >>> 3;
+            int i8 = i6 & 7;
+            if (i8 != 0) {
+                if (i8 == 1) {
+                    ((Long) this.f2938c[i5]).getClass();
+                    u3 = C0119j.u(i7);
+                } else if (i8 == 2) {
+                    u3 = C0119j.r(i7, (C0116g) this.f2938c[i5]);
+                } else if (i8 == 3) {
+                    y3 = C0119j.y(i7) * 2;
+                    A3 = ((j0) this.f2938c[i5]).a();
+                } else {
+                    if (i8 != 5) {
+                        throw new IllegalStateException(A.b());
+                    }
+                    ((Integer) this.f2938c[i5]).getClass();
+                    u3 = C0119j.t(i7);
+                }
+                i4 = u3 + i4;
+            } else {
+                long longValue = ((Long) this.f2938c[i5]).longValue();
+                y3 = C0119j.y(i7);
+                A3 = C0119j.A(longValue);
+            }
+            i4 = A3 + y3 + i4;
+        }
+        this.f2939d = i4;
+        return i4;
+    }
+
+    public final void c(int i, Object obj) {
+        if (!this.f2940e) {
+            throw new UnsupportedOperationException();
+        }
+        int i4 = this.f2936a;
+        int[] iArr = this.f2937b;
+        if (i4 == iArr.length) {
+            int i5 = i4 + (i4 < 4 ? 8 : i4 >> 1);
+            this.f2937b = Arrays.copyOf(iArr, i5);
+            this.f2938c = Arrays.copyOf(this.f2938c, i5);
+        }
+        int[] iArr2 = this.f2937b;
+        int i6 = this.f2936a;
+        iArr2[i6] = i;
+        this.f2938c[i6] = obj;
+        this.f2936a = i6 + 1;
+    }
+
+    public final void d(J j4) {
+        if (this.f2936a == 0) {
+            return;
+        }
+        j4.getClass();
+        for (int i = 0; i < this.f2936a; i++) {
+            int i4 = this.f2937b[i];
+            Object obj = this.f2938c[i];
+            int i5 = i4 >>> 3;
+            int i6 = i4 & 7;
+            C0119j c0119j = (C0119j) j4.f2852a;
+            if (i6 == 0) {
+                c0119j.U(i5, ((Long) obj).longValue());
+            } else if (i6 == 1) {
+                c0119j.K(i5, ((Long) obj).longValue());
+            } else if (i6 == 2) {
+                j4.a(i5, (C0116g) obj);
+            } else if (i6 == 3) {
+                c0119j.R(i5, 3);
+                ((j0) obj).d(j4);
+                c0119j.R(i5, 4);
+            } else {
+                if (i6 != 5) {
+                    throw new RuntimeException(A.b());
+                }
+                c0119j.I(i5, ((Integer) obj).intValue());
+            }
+        }
+    }
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || !(obj instanceof j0)) {
+            return false;
+        }
+        j0 j0Var = (j0) obj;
+        int i = this.f2936a;
+        if (i == j0Var.f2936a) {
+            int[] iArr = this.f2937b;
+            int[] iArr2 = j0Var.f2937b;
+            int i4 = 0;
+            while (true) {
+                if (i4 >= i) {
+                    Object[] objArr = this.f2938c;
+                    Object[] objArr2 = j0Var.f2938c;
+                    int i5 = this.f2936a;
+                    for (int i6 = 0; i6 < i5; i6++) {
+                        if (objArr[i6].equals(objArr2[i6])) {
+                        }
+                    }
+                    return true;
+                }
+                if (iArr[i4] != iArr2[i4]) {
+                    break;
+                }
+                i4++;
+            }
+        }
+        return false;
+    }
+
+    public final int hashCode() {
+        int i = this.f2936a;
+        int i4 = (527 + i) * 31;
+        int[] iArr = this.f2937b;
+        int i5 = 17;
+        int i6 = 17;
+        for (int i7 = 0; i7 < i; i7++) {
+            i6 = (i6 * 31) + iArr[i7];
+        }
+        int i8 = (i4 + i6) * 31;
+        Object[] objArr = this.f2938c;
+        int i9 = this.f2936a;
+        for (int i10 = 0; i10 < i9; i10++) {
+            i5 = (i5 * 31) + objArr[i10].hashCode();
+        }
+        return i8 + i5;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/k0.java

@@ -0,0 +1,49 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.io.IOException;
+
+/* loaded from: classes.dex */
+public final class k0 {
+    public static boolean a(Object obj, Z2.y yVar) {
+        int e4 = yVar.e();
+        int i = e4 >>> 3;
+        int i4 = e4 & 7;
+        if (i4 == 0) {
+            ((j0) obj).c(i << 3, Long.valueOf(yVar.y()));
+            return true;
+        }
+        if (i4 == 1) {
+            ((j0) obj).c((i << 3) | 1, Long.valueOf(yVar.q()));
+            return true;
+        }
+        if (i4 == 2) {
+            ((j0) obj).c((i << 3) | 2, yVar.h());
+            return true;
+        }
+        if (i4 != 3) {
+            if (i4 == 4) {
+                return false;
+            }
+            if (i4 != 5) {
+                throw A.b();
+            }
+            ((j0) obj).c((i << 3) | 5, Integer.valueOf(yVar.o()));
+            return true;
+        }
+        j0 b4 = j0.b();
+        int i5 = i << 3;
+        int i6 = i5 | 4;
+        while (yVar.d() != Integer.MAX_VALUE && a(b4, yVar)) {
+        }
+        if (i6 != yVar.e()) {
+            throw new IOException("Protocol message end-group tag did not match expected tag.");
+        }
+        b4.f2940e = false;
+        ((j0) obj).c(i5 | 3, b4);
+        return true;
+    }
+
+    public static j0 b() {
+        return j0.b();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/l0.java

@@ -0,0 +1,55 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.ListIterator;
+
+/* loaded from: classes.dex */
+public final class l0 implements ListIterator {
+
+    /* renamed from: a, reason: collision with root package name */
+    public ListIterator f2942a;
+
+    @Override // java.util.ListIterator
+    public final void add(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.ListIterator, java.util.Iterator
+    public final boolean hasNext() {
+        return this.f2942a.hasNext();
+    }
+
+    @Override // java.util.ListIterator
+    public final boolean hasPrevious() {
+        return this.f2942a.hasPrevious();
+    }
+
+    @Override // java.util.ListIterator, java.util.Iterator
+    public final Object next() {
+        return (String) this.f2942a.next();
+    }
+
+    @Override // java.util.ListIterator
+    public final int nextIndex() {
+        return this.f2942a.nextIndex();
+    }
+
+    @Override // java.util.ListIterator
+    public final Object previous() {
+        return (String) this.f2942a.previous();
+    }
+
+    @Override // java.util.ListIterator
+    public final int previousIndex() {
+        return this.f2942a.previousIndex();
+    }
+
+    @Override // java.util.ListIterator, java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.ListIterator
+    public final void set(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/m0.java

@@ -0,0 +1,25 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public final class m0 implements Iterator {
+
+    /* renamed from: a, reason: collision with root package name */
+    public Iterator f2946a;
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        return this.f2946a.hasNext();
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        return (String) this.f2946a.next();
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/n0.java

@@ -0,0 +1,65 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.AbstractList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.RandomAccess;
+
+/* loaded from: classes.dex */
+public final class n0 extends AbstractList implements D, RandomAccess {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final C f2947a;
+
+    public n0(C c4) {
+        this.f2947a = c4;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final void e(C0116g c0116g) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        return (String) this.f2947a.get(i);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final List getUnderlyingElements() {
+        return Collections.unmodifiableList(this.f2947a.f2846b);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final D getUnmodifiableView() {
+        return this;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.m0, java.util.Iterator, java.lang.Object] */
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.List
+    public final Iterator iterator() {
+        ?? obj = new Object();
+        obj.f2946a = this.f2947a.iterator();
+        return obj;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [androidx.datastore.preferences.protobuf.l0, java.util.ListIterator, java.lang.Object] */
+    @Override // java.util.AbstractList, java.util.List
+    public final ListIterator listIterator(int i) {
+        ?? obj = new Object();
+        obj.f2942a = this.f2947a.listIterator(i);
+        return obj;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.D
+    public final Object s(int i) {
+        return this.f2947a.f2846b.get(i);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.f2947a.size();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/o0.java

@@ -0,0 +1,24 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.lang.reflect.Field;
+import java.security.PrivilegedExceptionAction;
+import sun.misc.Unsafe;
+
+/* loaded from: classes.dex */
+public final class o0 implements PrivilegedExceptionAction {
+    public static Unsafe a() {
+        for (Field field : Unsafe.class.getDeclaredFields()) {
+            field.setAccessible(true);
+            Object obj = field.get(null);
+            if (Unsafe.class.isInstance(obj)) {
+                return (Unsafe) Unsafe.class.cast(obj);
+            }
+        }
+        return null;
+    }
+
+    @Override // java.security.PrivilegedExceptionAction
+    public final /* bridge */ /* synthetic */ Object run() {
+        return a();
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/p0.java

@@ -0,0 +1,138 @@
+package androidx.datastore.preferences.protobuf;
+
+import sun.misc.Unsafe;
+
+/* loaded from: classes.dex */
+public final class p0 extends r0 {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ int f2953b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ p0(Unsafe unsafe, int i) {
+        super(unsafe);
+        this.f2953b = i;
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final boolean c(long j4, Object obj) {
+        switch (this.f2953b) {
+            case 0:
+                if (s0.h) {
+                    if (s0.g(j4, obj) == 0) {
+                        return false;
+                    }
+                } else if (s0.h(j4, obj) == 0) {
+                    return false;
+                }
+                return true;
+            default:
+                if (s0.h) {
+                    if (s0.g(j4, obj) == 0) {
+                        return false;
+                    }
+                } else if (s0.h(j4, obj) == 0) {
+                    return false;
+                }
+                return true;
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final byte d(long j4, Object obj) {
+        switch (this.f2953b) {
+            case 0:
+                return s0.h ? s0.g(j4, obj) : s0.h(j4, obj);
+            default:
+                return s0.h ? s0.g(j4, obj) : s0.h(j4, obj);
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final double e(long j4, Object obj) {
+        switch (this.f2953b) {
+            case 0:
+                return Double.longBitsToDouble(h(j4, obj));
+            default:
+                return Double.longBitsToDouble(h(j4, obj));
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final float f(long j4, Object obj) {
+        switch (this.f2953b) {
+            case 0:
+                return Float.intBitsToFloat(g(j4, obj));
+            default:
+                return Float.intBitsToFloat(g(j4, obj));
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void k(Object obj, long j4, boolean z3) {
+        switch (this.f2953b) {
+            case 0:
+                if (s0.h) {
+                    s0.k(obj, j4, z3 ? (byte) 1 : (byte) 0);
+                    return;
+                } else {
+                    s0.l(obj, j4, z3 ? (byte) 1 : (byte) 0);
+                    return;
+                }
+            default:
+                if (s0.h) {
+                    s0.k(obj, j4, z3 ? (byte) 1 : (byte) 0);
+                    return;
+                } else {
+                    s0.l(obj, j4, z3 ? (byte) 1 : (byte) 0);
+                    return;
+                }
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void l(Object obj, long j4, byte b4) {
+        switch (this.f2953b) {
+            case 0:
+                if (s0.h) {
+                    s0.k(obj, j4, b4);
+                    return;
+                } else {
+                    s0.l(obj, j4, b4);
+                    return;
+                }
+            default:
+                if (s0.h) {
+                    s0.k(obj, j4, b4);
+                    return;
+                } else {
+                    s0.l(obj, j4, b4);
+                    return;
+                }
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void m(Object obj, long j4, double d4) {
+        switch (this.f2953b) {
+            case 0:
+                p(obj, j4, Double.doubleToLongBits(d4));
+                return;
+            default:
+                p(obj, j4, Double.doubleToLongBits(d4));
+                return;
+        }
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void n(Object obj, long j4, float f2) {
+        switch (this.f2953b) {
+            case 0:
+                o(obj, j4, Float.floatToIntBits(f2));
+                return;
+            default:
+                o(obj, j4, Float.floatToIntBits(f2));
+                return;
+        }
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/q0.java

@@ -0,0 +1,44 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class q0 extends r0 {
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final boolean c(long j4, Object obj) {
+        return this.f2960a.getBoolean(obj, j4);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final byte d(long j4, Object obj) {
+        return this.f2960a.getByte(obj, j4);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final double e(long j4, Object obj) {
+        return this.f2960a.getDouble(obj, j4);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final float f(long j4, Object obj) {
+        return this.f2960a.getFloat(obj, j4);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void k(Object obj, long j4, boolean z3) {
+        this.f2960a.putBoolean(obj, j4, z3);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void l(Object obj, long j4, byte b4) {
+        this.f2960a.putByte(obj, j4, b4);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void m(Object obj, long j4, double d4) {
+        this.f2960a.putDouble(obj, j4, d4);
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.r0
+    public final void n(Object obj, long j4, float f2) {
+        this.f2960a.putFloat(obj, j4, f2);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/r.java

@@ -0,0 +1,7 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.util.RandomAccess;
+
+/* loaded from: classes.dex */
+public abstract class r extends AbstractC0110b implements RandomAccess, X {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/r0.java

@@ -0,0 +1,67 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.lang.reflect.Field;
+import sun.misc.Unsafe;
+
+/* loaded from: classes.dex */
+public abstract class r0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Unsafe f2960a;
+
+    public r0(Unsafe unsafe) {
+        this.f2960a = unsafe;
+    }
+
+    public final int a(Class cls) {
+        return this.f2960a.arrayBaseOffset(cls);
+    }
+
+    public final int b(Class cls) {
+        return this.f2960a.arrayIndexScale(cls);
+    }
+
+    public abstract boolean c(long j4, Object obj);
+
+    public abstract byte d(long j4, Object obj);
+
+    public abstract double e(long j4, Object obj);
+
+    public abstract float f(long j4, Object obj);
+
+    public final int g(long j4, Object obj) {
+        return this.f2960a.getInt(obj, j4);
+    }
+
+    public final long h(long j4, Object obj) {
+        return this.f2960a.getLong(obj, j4);
+    }
+
+    public final Object i(long j4, Object obj) {
+        return this.f2960a.getObject(obj, j4);
+    }
+
+    public final long j(Field field) {
+        return this.f2960a.objectFieldOffset(field);
+    }
+
+    public abstract void k(Object obj, long j4, boolean z3);
+
+    public abstract void l(Object obj, long j4, byte b4);
+
+    public abstract void m(Object obj, long j4, double d4);
+
+    public abstract void n(Object obj, long j4, float f2);
+
+    public final void o(Object obj, long j4, int i) {
+        this.f2960a.putInt(obj, j4, i);
+    }
+
+    public final void p(Object obj, long j4, long j5) {
+        this.f2960a.putLong(obj, j4, j5);
+    }
+
+    public final void q(Object obj, long j4, Object obj2) {
+        this.f2960a.putObject(obj, j4, obj2);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/s0.java

@@ -0,0 +1,164 @@
+package androidx.datastore.preferences.protobuf;
+
+import java.lang.reflect.Field;
+import java.nio.Buffer;
+import java.security.AccessController;
+import java.security.PrivilegedExceptionAction;
+import java.util.logging.Logger;
+import kotlin.KotlinVersion;
+import sun.misc.Unsafe;
+
+/* loaded from: classes.dex */
+public abstract class s0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Logger f2963a = Logger.getLogger(s0.class.getName());
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final Unsafe f2964b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final Class f2965c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final r0 f2966d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final boolean f2967e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final boolean f2968f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public static final long f2969g;
+    public static final boolean h;
+
+    /* JADX WARN: Removed duplicated region for block: B:18:0x01d4  */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x01e4  */
+    /* JADX WARN: Removed duplicated region for block: B:27:0x01e6  */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x00df A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    static {
+        /*
+            Method dump skipped, instructions count: 491
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.datastore.preferences.protobuf.s0.<clinit>():void");
+    }
+
+    public static Object a(Class cls) {
+        try {
+            return f2964b.allocateInstance(cls);
+        } catch (InstantiationException e4) {
+            throw new IllegalStateException(e4);
+        }
+    }
+
+    public static int b(Class cls) {
+        if (f2968f) {
+            return f2966d.a(cls);
+        }
+        return -1;
+    }
+
+    public static void c(Class cls) {
+        if (f2968f) {
+            f2966d.b(cls);
+        }
+    }
+
+    public static Field d() {
+        Field field;
+        Field field2;
+        if (AbstractC0112c.a()) {
+            try {
+                field2 = Buffer.class.getDeclaredField("effectiveDirectAddress");
+            } catch (Throwable unused) {
+                field2 = null;
+            }
+            if (field2 != null) {
+                return field2;
+            }
+        }
+        try {
+            field = Buffer.class.getDeclaredField("address");
+        } catch (Throwable unused2) {
+            field = null;
+        }
+        if (field == null || field.getType() != Long.TYPE) {
+            return null;
+        }
+        return field;
+    }
+
+    public static boolean e(Class cls) {
+        if (!AbstractC0112c.a()) {
+            return false;
+        }
+        try {
+            Class cls2 = f2965c;
+            Class cls3 = Boolean.TYPE;
+            cls2.getMethod("peekLong", cls, cls3);
+            cls2.getMethod("pokeLong", cls, Long.TYPE, cls3);
+            Class cls4 = Integer.TYPE;
+            cls2.getMethod("pokeInt", cls, cls4, cls3);
+            cls2.getMethod("peekInt", cls, cls3);
+            cls2.getMethod("pokeByte", cls, Byte.TYPE);
+            cls2.getMethod("peekByte", cls);
+            cls2.getMethod("pokeByteArray", cls, byte[].class, cls4, cls4);
+            cls2.getMethod("peekByteArray", cls, byte[].class, cls4, cls4);
+            return true;
+        } catch (Throwable unused) {
+            return false;
+        }
+    }
+
+    public static byte f(byte[] bArr, long j4) {
+        return f2966d.d(f2969g + j4, bArr);
+    }
+
+    public static byte g(long j4, Object obj) {
+        return (byte) ((f2966d.g((-4) & j4, obj) >>> ((int) (((~j4) & 3) << 3))) & KotlinVersion.MAX_COMPONENT_VALUE);
+    }
+
+    public static byte h(long j4, Object obj) {
+        return (byte) ((f2966d.g((-4) & j4, obj) >>> ((int) ((j4 & 3) << 3))) & KotlinVersion.MAX_COMPONENT_VALUE);
+    }
+
+    /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Object, java.security.PrivilegedExceptionAction] */
+    public static Unsafe i() {
+        try {
+            return (Unsafe) AccessController.doPrivileged((PrivilegedExceptionAction) new Object());
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    public static void j(byte[] bArr, long j4, byte b4) {
+        f2966d.l(bArr, f2969g + j4, b4);
+    }
+
+    public static void k(Object obj, long j4, byte b4) {
+        long j5 = (-4) & j4;
+        int g4 = f2966d.g(j5, obj);
+        int i = ((~((int) j4)) & 3) << 3;
+        m(obj, j5, ((255 & b4) << i) | (g4 & (~(KotlinVersion.MAX_COMPONENT_VALUE << i))));
+    }
+
+    public static void l(Object obj, long j4, byte b4) {
+        long j5 = (-4) & j4;
+        int i = (((int) j4) & 3) << 3;
+        m(obj, j5, ((255 & b4) << i) | (f2966d.g(j5, obj) & (~(KotlinVersion.MAX_COMPONENT_VALUE << i))));
+    }
+
+    public static void m(Object obj, long j4, int i) {
+        f2966d.o(obj, j4, i);
+    }
+
+    public static void n(Object obj, long j4, long j5) {
+        f2966d.p(obj, j4, j5);
+    }
+
+    public static void o(Object obj, long j4, Object obj2) {
+        f2966d.q(obj, j4, obj2);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/t0.java

@@ -0,0 +1,209 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class t0 extends Q {
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ int f2973c;
+
+    public /* synthetic */ t0(int i) {
+        this.f2973c = i;
+    }
+
+    public static int m(long j4, byte[] bArr, int i, int i4) {
+        if (i4 == 0) {
+            Q q4 = v0.f2974a;
+            if (i > -12) {
+                return -1;
+            }
+            return i;
+        }
+        if (i4 == 1) {
+            return v0.c(i, s0.f(bArr, j4));
+        }
+        if (i4 == 2) {
+            return v0.d(i, s0.f(bArr, j4), s0.f(bArr, j4 + 1));
+        }
+        throw new AssertionError();
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:13:0x0028  */
+    /* JADX WARN: Removed duplicated region for block: B:72:0x00f1  */
+    @Override // androidx.datastore.preferences.protobuf.Q
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.String e(int r10, int r11, byte[] r12) {
+        /*
+            Method dump skipped, instructions count: 390
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.datastore.preferences.protobuf.t0.e(int, int, byte[]):java.lang.String");
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:79:?, code lost:
+    
+        return r26 + r3;
+     */
+    @Override // androidx.datastore.preferences.protobuf.Q
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final int f(java.lang.String r24, byte[] r25, int r26, int r27) {
+        /*
+            Method dump skipped, instructions count: 606
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.datastore.preferences.protobuf.t0.f(java.lang.String, byte[], int, int):int");
+    }
+
+    @Override // androidx.datastore.preferences.protobuf.Q
+    public final int i(byte[] bArr, int i, int i4) {
+        int i5;
+        switch (this.f2973c) {
+            case 0:
+                break;
+            default:
+                if ((i | i4 | (bArr.length - i4)) < 0) {
+                    throw new ArrayIndexOutOfBoundsException(String.format("Array length=%d, index=%d, limit=%d", Integer.valueOf(bArr.length), Integer.valueOf(i), Integer.valueOf(i4)));
+                }
+                long j4 = i;
+                int i6 = (int) (i4 - j4);
+                if (i6 < 16) {
+                    i5 = 0;
+                } else {
+                    i5 = 0;
+                    long j5 = j4;
+                    while (true) {
+                        if (i5 < i6) {
+                            long j6 = j5 + 1;
+                            if (s0.f(bArr, j5) >= 0) {
+                                i5++;
+                                j5 = j6;
+                            }
+                        } else {
+                            i5 = i6;
+                        }
+                    }
+                }
+                int i7 = i6 - i5;
+                long j7 = j4 + i5;
+                while (true) {
+                    byte b4 = 0;
+                    while (true) {
+                        if (i7 > 0) {
+                            long j8 = j7 + 1;
+                            b4 = s0.f(bArr, j7);
+                            if (b4 >= 0) {
+                                i7--;
+                                j7 = j8;
+                            } else {
+                                j7 = j8;
+                            }
+                        }
+                    }
+                    if (i7 == 0) {
+                        return 0;
+                    }
+                    int i8 = i7 - 1;
+                    if (b4 < -32) {
+                        if (i8 == 0) {
+                            return b4;
+                        }
+                        i7 -= 2;
+                        if (b4 >= -62) {
+                            long j9 = j7 + 1;
+                            if (s0.f(bArr, j7) <= -65) {
+                                j7 = j9;
+                            }
+                        }
+                    } else if (b4 < -16) {
+                        if (i8 < 2) {
+                            return m(j7, bArr, b4, i8);
+                        }
+                        i7 -= 3;
+                        long j10 = j7 + 1;
+                        byte f2 = s0.f(bArr, j7);
+                        if (f2 <= -65 && ((b4 != -32 || f2 >= -96) && (b4 != -19 || f2 < -96))) {
+                            j7 += 2;
+                            if (s0.f(bArr, j10) > -65) {
+                            }
+                        }
+                    } else {
+                        if (i8 < 3) {
+                            return m(j7, bArr, b4, i8);
+                        }
+                        i7 -= 4;
+                        long j11 = j7 + 1;
+                        byte f4 = s0.f(bArr, j7);
+                        if (f4 <= -65) {
+                            if ((((f4 + 112) + (b4 << 28)) >> 30) == 0) {
+                                long j12 = 2 + j7;
+                                if (s0.f(bArr, j11) <= -65) {
+                                    j7 += 3;
+                                    if (s0.f(bArr, j12) > -65) {
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return -1;
+        }
+        while (i < i4 && bArr[i] >= 0) {
+            i++;
+        }
+        if (i < i4) {
+            while (i < i4) {
+                int i9 = i + 1;
+                byte b5 = bArr[i];
+                if (b5 < 0) {
+                    if (b5 < -32) {
+                        if (i9 >= i4) {
+                            return b5;
+                        }
+                        if (b5 >= -62) {
+                            i += 2;
+                            if (bArr[i9] > -65) {
+                            }
+                        }
+                        return -1;
+                    }
+                    if (b5 < -16) {
+                        if (i9 >= i4 - 1) {
+                            return v0.a(i9, i4, bArr);
+                        }
+                        int i10 = i + 2;
+                        byte b6 = bArr[i9];
+                        if (b6 <= -65 && ((b5 != -32 || b6 >= -96) && (b5 != -19 || b6 < -96))) {
+                            i += 3;
+                            if (bArr[i10] > -65) {
+                            }
+                        }
+                        return -1;
+                    }
+                    if (i9 >= i4 - 2) {
+                        return v0.a(i9, i4, bArr);
+                    }
+                    int i11 = i + 2;
+                    byte b7 = bArr[i9];
+                    if (b7 <= -65) {
+                        if ((((b7 + 112) + (b5 << 28)) >> 30) == 0) {
+                            int i12 = i + 3;
+                            if (bArr[i11] <= -65) {
+                                i += 4;
+                                if (bArr[i12] > -65) {
+                                }
+                            }
+                        }
+                    }
+                    return -1;
+                }
+                i = i9;
+            }
+        }
+        return 0;
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/u0.java

@@ -0,0 +1,8 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public final class u0 extends IllegalArgumentException {
+    public u0(int i, int i4) {
+        super(C.w.k("Unpaired surrogate at index ", i, i4, " of "));
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/v0.java

@@ -0,0 +1,86 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public abstract class v0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Q f2974a;
+
+    static {
+        f2974a = (s0.f2968f && s0.f2967e && !AbstractC0112c.a()) ? new t0(1) : new t0(0);
+    }
+
+    public static int a(int i, int i4, byte[] bArr) {
+        byte b4 = bArr[i - 1];
+        int i5 = i4 - i;
+        if (i5 == 0) {
+            if (b4 > -12) {
+                return -1;
+            }
+            return b4;
+        }
+        if (i5 == 1) {
+            return c(b4, bArr[i]);
+        }
+        if (i5 == 2) {
+            return d(b4, bArr[i], bArr[i + 1]);
+        }
+        throw new AssertionError();
+    }
+
+    public static int b(String str) {
+        int length = str.length();
+        int i = 0;
+        int i4 = 0;
+        while (i4 < length && str.charAt(i4) < 128) {
+            i4++;
+        }
+        int i5 = length;
+        while (true) {
+            if (i4 >= length) {
+                break;
+            }
+            char charAt = str.charAt(i4);
+            if (charAt < 2048) {
+                i5 += (127 - charAt) >>> 31;
+                i4++;
+            } else {
+                int length2 = str.length();
+                while (i4 < length2) {
+                    char charAt2 = str.charAt(i4);
+                    if (charAt2 < 2048) {
+                        i += (127 - charAt2) >>> 31;
+                    } else {
+                        i += 2;
+                        if (55296 <= charAt2 && charAt2 <= 57343) {
+                            if (Character.codePointAt(str, i4) < 65536) {
+                                throw new u0(i4, length2);
+                            }
+                            i4++;
+                        }
+                    }
+                    i4++;
+                }
+                i5 += i;
+            }
+        }
+        if (i5 >= length) {
+            return i5;
+        }
+        throw new IllegalArgumentException("UTF-8 length does not fit in int: " + (i5 + 4294967296L));
+    }
+
+    public static int c(int i, int i4) {
+        if (i > -12 || i4 > -65) {
+            return -1;
+        }
+        return i ^ (i4 << 8);
+    }
+
+    public static int d(int i, int i4, int i5) {
+        if (i > -12 || i4 > -65 || i5 > -65) {
+            return -1;
+        }
+        return (i ^ (i4 << 8)) ^ (i5 << 16);
+    }
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/w0.java

@@ -0,0 +1,5 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public enum w0 extends A0 {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/x0.java

@@ -0,0 +1,5 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public enum x0 extends A0 {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/y0.java

@@ -0,0 +1,5 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public enum y0 extends A0 {
+}

apk_decompiled/sources/androidx/datastore/preferences/protobuf/z0.java

@@ -0,0 +1,5 @@
+package androidx.datastore.preferences.protobuf;
+
+/* loaded from: classes.dex */
+public enum z0 extends A0 {
+}