Initial import of ADIF API reverse-engineering toolkit

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 {
+}