Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/b0/AbstractC0261f.java

@@ -0,0 +1,6 @@
+package b0;
+
+/* renamed from: b0.f, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0261f {
+}

apk_decompiled/sources/b0/AbstractC0262g.java

@@ -0,0 +1,7 @@
+package b0;
+
+/* renamed from: b0.g, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0262g {
+    public abstract Object a(C0260e c0260e);
+}

apk_decompiled/sources/b0/AbstractC0264i.java

@@ -0,0 +1,24 @@
+package b0;
+
+import u.AbstractC0629f;
+
+/* renamed from: b0.i, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class AbstractC0264i {
+    public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+    static {
+        int[] iArr = new int[8];
+        System.arraycopy(AbstractC0629f.f8583a, 0, iArr, 0, 8);
+        int[] iArr2 = new int[iArr.length];
+        iArr2[0] = 1;
+        iArr2[1] = 2;
+        iArr2[6] = 3;
+        iArr2[2] = 4;
+        iArr2[3] = 5;
+        iArr2[4] = 6;
+        iArr2[5] = 7;
+        iArr2[7] = 8;
+        $EnumSwitchMapping$0 = iArr2;
+    }
+}

apk_decompiled/sources/b0/C0256a.java

@@ -0,0 +1,21 @@
+package b0;
+
+import java.util.Map;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* renamed from: b0.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0256a extends Lambda implements Function1 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0256a f4152a = new Lambda(1);
+
+    @Override // kotlin.jvm.functions.Function1
+    public final Object invoke(Object obj) {
+        Map.Entry entry = (Map.Entry) obj;
+        Intrinsics.checkNotNullParameter(entry, "entry");
+        return "  " + ((C0260e) entry.getKey()).f4159a + " = " + entry.getValue();
+    }
+}

apk_decompiled/sources/b0/C0257b.java

@@ -0,0 +1,79 @@
+package b0;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b0.b, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0257b extends AbstractC0262g {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Map f4153a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final AtomicBoolean f4154b;
+
+    public C0257b(Map preferencesMap, boolean z3) {
+        Intrinsics.checkNotNullParameter(preferencesMap, "preferencesMap");
+        this.f4153a = preferencesMap;
+        this.f4154b = new AtomicBoolean(z3);
+    }
+
+    @Override // b0.AbstractC0262g
+    public final Object a(C0260e key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return this.f4153a.get(key);
+    }
+
+    public final void b() {
+        if (this.f4154b.get()) {
+            throw new IllegalStateException("Do mutate preferences once returned to DataStore.");
+        }
+    }
+
+    public final void c(C0260e key, Object obj) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        b();
+        Map map = this.f4153a;
+        if (obj == null) {
+            Intrinsics.checkNotNullParameter(key, "key");
+            b();
+            map.remove(key);
+        } else {
+            if (!(obj instanceof Set)) {
+                map.put(key, obj);
+                return;
+            }
+            Set unmodifiableSet = Collections.unmodifiableSet(CollectionsKt.toSet((Iterable) obj));
+            Intrinsics.checkNotNullExpressionValue(unmodifiableSet, "unmodifiableSet(value.toSet())");
+            map.put(key, unmodifiableSet);
+        }
+    }
+
+    public final boolean equals(Object obj) {
+        if (!(obj instanceof C0257b)) {
+            return false;
+        }
+        return Intrinsics.areEqual(this.f4153a, ((C0257b) obj).f4153a);
+    }
+
+    public final int hashCode() {
+        return this.f4153a.hashCode();
+    }
+
+    public final String toString() {
+        String joinToString$default;
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(this.f4153a.entrySet(), ",\n", "{\n", "\n}", 0, null, C0256a.f4152a, 24, null);
+        return joinToString$default;
+    }
+
+    public /* synthetic */ C0257b(boolean z3) {
+        this(new LinkedHashMap(), z3);
+    }
+}

apk_decompiled/sources/b0/C0258c.java

@@ -0,0 +1,66 @@
+package b0;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+
+/* renamed from: b0.c, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0258c extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f4155a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f4156b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f4157c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Multi-variable type inference failed */
+    public C0258c(Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f4157c = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        C0258c c0258c = new C0258c(this.f4157c, continuation);
+        c0258c.f4156b = obj;
+        return c0258c;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0258c) create((AbstractC0262g) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f4155a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            AbstractC0262g abstractC0262g = (AbstractC0262g) this.f4156b;
+            this.f4155a = 1;
+            obj = this.f4157c.invoke(abstractC0262g, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        AbstractC0262g abstractC0262g2 = (AbstractC0262g) obj;
+        ((C0257b) abstractC0262g2).f4154b.set(true);
+        return abstractC0262g2;
+    }
+}

apk_decompiled/sources/b0/C0259d.java

@@ -0,0 +1,31 @@
+package b0;
+
+import Y.F;
+import Y.InterfaceC0091g;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.flow.Flow;
+
+/* renamed from: b0.d, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0259d implements InterfaceC0091g {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final F f4158a;
+
+    public C0259d(F delegate) {
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+        this.f4158a = delegate;
+    }
+
+    @Override // Y.InterfaceC0091g
+    public final Object a(Function2 function2, Continuation continuation) {
+        return this.f4158a.a(new C0258c(function2, null), continuation);
+    }
+
+    @Override // Y.InterfaceC0091g
+    public final Flow b() {
+        return this.f4158a.f2058d;
+    }
+}

apk_decompiled/sources/b0/C0260e.java

@@ -0,0 +1,31 @@
+package b0;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b0.e, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0260e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final String f4159a;
+
+    public C0260e(String name) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.f4159a = name;
+    }
+
+    public final boolean equals(Object obj) {
+        if (!(obj instanceof C0260e)) {
+            return false;
+        }
+        return Intrinsics.areEqual(this.f4159a, ((C0260e) obj).f4159a);
+    }
+
+    public final int hashCode() {
+        return this.f4159a.hashCode();
+    }
+
+    public final String toString() {
+        return this.f4159a;
+    }
+}

apk_decompiled/sources/b0/C0263h.java

@@ -0,0 +1,68 @@
+package b0;
+
+import java.util.Collections;
+import java.util.Map;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.collections.MapsKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b0.h, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0263h extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f4160a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f4161b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f4162c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Multi-variable type inference failed */
+    public C0263h(Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f4162c = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        C0263h c0263h = new C0263h(this.f4162c, continuation);
+        c0263h.f4161b = obj;
+        return c0263h;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0263h) create((AbstractC0262g) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r5v7, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f4160a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            C0257b c0257b = (C0257b) this.f4161b;
+            ResultKt.throwOnFailure(obj);
+            return c0257b;
+        }
+        ResultKt.throwOnFailure(obj);
+        Map unmodifiableMap = Collections.unmodifiableMap(((C0257b) ((AbstractC0262g) this.f4161b)).f4153a);
+        Intrinsics.checkNotNullExpressionValue(unmodifiableMap, "unmodifiableMap(preferencesMap)");
+        C0257b c0257b2 = new C0257b(MapsKt.toMutableMap(unmodifiableMap), false);
+        this.f4161b = c0257b2;
+        this.f4160a = 1;
+        return this.f4162c.invoke(c0257b2, this) == coroutine_suspended ? coroutine_suspended : c0257b2;
+    }
+}

apk_decompiled/sources/b0/C0265j.java

@@ -0,0 +1,205 @@
+package b0;
+
+import Y.C0085a;
+import Y.n;
+import androidx.datastore.preferences.protobuf.A;
+import androidx.datastore.preferences.protobuf.AbstractC0130v;
+import androidx.datastore.preferences.protobuf.C0119j;
+import androidx.datastore.preferences.protobuf.InterfaceC0132x;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Logger;
+import kotlin.NoWhenBranchMatchedException;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.internal.Intrinsics;
+import u.AbstractC0629f;
+
+/* renamed from: b0.j, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0265j {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0265j f4163a = new Object();
+
+    public final C0257b a(FileInputStream input) {
+        Intrinsics.checkNotNullParameter(input, "input");
+        try {
+            a0.f l4 = a0.f.l(input);
+            Intrinsics.checkNotNullExpressionValue(l4, "{\n                PreferencesProto.PreferenceMap.parseFrom(input)\n            }");
+            AbstractC0261f[] pairs = new AbstractC0261f[0];
+            Intrinsics.checkNotNullParameter(pairs, "pairs");
+            C0257b c0257b = new C0257b(false);
+            AbstractC0261f[] pairs2 = (AbstractC0261f[]) Arrays.copyOf(pairs, 0);
+            Intrinsics.checkNotNullParameter(pairs2, "pairs");
+            c0257b.b();
+            if (pairs2.length > 0) {
+                AbstractC0261f abstractC0261f = pairs2[0];
+                throw null;
+            }
+            Map j4 = l4.j();
+            Intrinsics.checkNotNullExpressionValue(j4, "preferencesProto.preferencesMap");
+            for (Map.Entry entry : j4.entrySet()) {
+                String name = (String) entry.getKey();
+                a0.j value = (a0.j) entry.getValue();
+                Intrinsics.checkNotNullExpressionValue(name, "name");
+                Intrinsics.checkNotNullExpressionValue(value, "value");
+                int x3 = value.x();
+                switch (x3 == 0 ? -1 : AbstractC0264i.$EnumSwitchMapping$0[AbstractC0629f.b(x3)]) {
+                    case -1:
+                        throw new C0085a("Value case is null.", 0);
+                    case 0:
+                    default:
+                        throw new NoWhenBranchMatchedException();
+                    case 1:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key = new C0260e(name);
+                        Boolean valueOf = Boolean.valueOf(value.p());
+                        Intrinsics.checkNotNullParameter(key, "key");
+                        c0257b.c(key, valueOf);
+                        break;
+                    case 2:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key2 = new C0260e(name);
+                        Float valueOf2 = Float.valueOf(value.s());
+                        Intrinsics.checkNotNullParameter(key2, "key");
+                        c0257b.c(key2, valueOf2);
+                        break;
+                    case 3:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key3 = new C0260e(name);
+                        Double valueOf3 = Double.valueOf(value.r());
+                        Intrinsics.checkNotNullParameter(key3, "key");
+                        c0257b.c(key3, valueOf3);
+                        break;
+                    case 4:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key4 = new C0260e(name);
+                        Integer valueOf4 = Integer.valueOf(value.t());
+                        Intrinsics.checkNotNullParameter(key4, "key");
+                        c0257b.c(key4, valueOf4);
+                        break;
+                    case 5:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key5 = new C0260e(name);
+                        Long valueOf5 = Long.valueOf(value.u());
+                        Intrinsics.checkNotNullParameter(key5, "key");
+                        c0257b.c(key5, valueOf5);
+                        break;
+                    case 6:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key6 = new C0260e(name);
+                        String v3 = value.v();
+                        Intrinsics.checkNotNullExpressionValue(v3, "value.string");
+                        Intrinsics.checkNotNullParameter(key6, "key");
+                        c0257b.c(key6, v3);
+                        break;
+                    case 7:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key7 = new C0260e(name);
+                        InterfaceC0132x k4 = value.w().k();
+                        Intrinsics.checkNotNullExpressionValue(k4, "value.stringSet.stringsList");
+                        Set set = CollectionsKt.toSet(k4);
+                        Intrinsics.checkNotNullParameter(key7, "key");
+                        c0257b.c(key7, set);
+                        break;
+                    case 8:
+                        throw new C0085a("Value not set.", 0);
+                }
+            }
+            Map unmodifiableMap = Collections.unmodifiableMap(c0257b.f4153a);
+            Intrinsics.checkNotNullExpressionValue(unmodifiableMap, "unmodifiableMap(preferencesMap)");
+            return new C0257b(MapsKt.toMutableMap(unmodifiableMap), true);
+        } catch (A e4) {
+            Intrinsics.checkNotNullParameter("Unable to parse preferences proto.", "message");
+            throw new IOException("Unable to parse preferences proto.", e4);
+        }
+    }
+
+    public final Unit b(Object obj, n nVar) {
+        AbstractC0130v a2;
+        Map unmodifiableMap = Collections.unmodifiableMap(((C0257b) ((AbstractC0262g) obj)).f4153a);
+        Intrinsics.checkNotNullExpressionValue(unmodifiableMap, "unmodifiableMap(preferencesMap)");
+        a0.d k4 = a0.f.k();
+        for (Map.Entry entry : unmodifiableMap.entrySet()) {
+            C0260e c0260e = (C0260e) entry.getKey();
+            Object value = entry.getValue();
+            String str = c0260e.f4159a;
+            if (value instanceof Boolean) {
+                a0.i y3 = a0.j.y();
+                boolean booleanValue = ((Boolean) value).booleanValue();
+                y3.c();
+                a0.j.m((a0.j) y3.f2971b, booleanValue);
+                a2 = y3.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setBoolean(value).build()");
+            } else if (value instanceof Float) {
+                a0.i y4 = a0.j.y();
+                float floatValue = ((Number) value).floatValue();
+                y4.c();
+                a0.j.n((a0.j) y4.f2971b, floatValue);
+                a2 = y4.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setFloat(value).build()");
+            } else if (value instanceof Double) {
+                a0.i y5 = a0.j.y();
+                double doubleValue = ((Number) value).doubleValue();
+                y5.c();
+                a0.j.l((a0.j) y5.f2971b, doubleValue);
+                a2 = y5.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setDouble(value).build()");
+            } else if (value instanceof Integer) {
+                a0.i y6 = a0.j.y();
+                int intValue = ((Number) value).intValue();
+                y6.c();
+                a0.j.o((a0.j) y6.f2971b, intValue);
+                a2 = y6.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setInteger(value).build()");
+            } else if (value instanceof Long) {
+                a0.i y7 = a0.j.y();
+                long longValue = ((Number) value).longValue();
+                y7.c();
+                a0.j.i((a0.j) y7.f2971b, longValue);
+                a2 = y7.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setLong(value).build()");
+            } else if (value instanceof String) {
+                a0.i y8 = a0.j.y();
+                y8.c();
+                a0.j.j((a0.j) y8.f2971b, (String) value);
+                a2 = y8.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setString(value).build()");
+            } else {
+                if (!(value instanceof Set)) {
+                    throw new IllegalStateException(Intrinsics.stringPlus("PreferencesSerializer does not support type: ", value.getClass().getName()));
+                }
+                a0.i y9 = a0.j.y();
+                a0.g l4 = a0.h.l();
+                l4.c();
+                a0.h.i((a0.h) l4.f2971b, (Set) value);
+                y9.c();
+                a0.j.k((a0.j) y9.f2971b, l4);
+                a2 = y9.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setStringSet(\n                    StringSet.newBuilder().addAllStrings(value as Set<String>)\n                ).build()");
+            }
+            k4.getClass();
+            str.getClass();
+            k4.c();
+            a0.f.i((a0.f) k4.f2971b).put(str, (a0.j) a2);
+        }
+        a0.f fVar = (a0.f) k4.a();
+        int a4 = fVar.a();
+        Logger logger = C0119j.h;
+        if (a4 > 4096) {
+            a4 = 4096;
+        }
+        C0119j c0119j = new C0119j(nVar, a4);
+        fVar.c(c0119j);
+        if (c0119j.f2933f > 0) {
+            c0119j.B();
+        }
+        return Unit.INSTANCE;
+    }
+}