Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/d0/AbstractC0304b.java

@@ -0,0 +1,12 @@
+package d0;
+
+import android.os.Handler;
+import android.os.Looper;
+
+/* renamed from: d0.b, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0304b {
+    public static Handler a(Looper looper) {
+        return Handler.createAsync(looper);
+    }
+}

apk_decompiled/sources/d0/C0305c.java

@@ -0,0 +1,20 @@
+package d0;
+
+import android.text.TextPaint;
+
+/* renamed from: d0.c, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0305c {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final ThreadLocal f6116b = new ThreadLocal();
+
+    /* renamed from: a, reason: collision with root package name */
+    public final TextPaint f6117a;
+
+    public C0305c() {
+        TextPaint textPaint = new TextPaint();
+        this.f6117a = textPaint;
+        textPaint.setTextSize(10.0f);
+    }
+}

apk_decompiled/sources/d0/C0306d.java

@@ -0,0 +1,60 @@
+package d0;
+
+import a.AbstractC0105a;
+import android.os.Build;
+import java.util.ArrayList;
+import java.util.Set;
+
+/* renamed from: d0.d, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0306d extends m3.l {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ e f6118a;
+
+    public C0306d(e eVar) {
+        this.f6118a = eVar;
+    }
+
+    @Override // m3.l
+    public final void L(Throwable th) {
+        this.f6118a.f6119a.d(th);
+    }
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [java.lang.Object, R0.h] */
+    @Override // m3.l
+    public final void M(A.j jVar) {
+        e eVar = this.f6118a;
+        eVar.f6121c = jVar;
+        A.j jVar2 = eVar.f6121c;
+        h hVar = eVar.f6119a;
+        E2.e eVar2 = hVar.f6130g;
+        C0305c c0305c = hVar.i;
+        Set<int[]> a2 = Build.VERSION.SDK_INT >= 34 ? l.a() : AbstractC0105a.A();
+        ?? obj = new Object();
+        obj.f1413a = eVar2;
+        obj.f1414b = jVar2;
+        obj.f1415c = c0305c;
+        if (!a2.isEmpty()) {
+            for (int[] iArr : a2) {
+                String str = new String(iArr, 0, iArr.length);
+                obj.m(str, 0, str.length(), 1, true, new S2.e(str, 2));
+            }
+        }
+        eVar.f6120b = obj;
+        h hVar2 = eVar.f6119a;
+        hVar2.getClass();
+        ArrayList arrayList = new ArrayList();
+        hVar2.f6124a.writeLock().lock();
+        try {
+            hVar2.f6126c = 1;
+            arrayList.addAll(hVar2.f6125b);
+            hVar2.f6125b.clear();
+            hVar2.f6124a.writeLock().unlock();
+            hVar2.f6127d.post(new H0.p(arrayList, hVar2.f6126c, (Throwable) null));
+        } catch (Throwable th) {
+            hVar2.f6124a.writeLock().unlock();
+            throw th;
+        }
+    }
+}

apk_decompiled/sources/d0/ThreadFactoryC0303a.java

@@ -0,0 +1,18 @@
+package d0;
+
+import java.util.concurrent.ThreadFactory;
+
+/* renamed from: d0.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final /* synthetic */ class ThreadFactoryC0303a implements ThreadFactory {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ String f6115a;
+
+    @Override // java.util.concurrent.ThreadFactory
+    public final Thread newThread(Runnable runnable) {
+        Thread thread = new Thread(runnable, this.f6115a);
+        thread.setPriority(10);
+        return thread;
+    }
+}

apk_decompiled/sources/d0/e.java

@@ -0,0 +1,18 @@
+package d0;
+
+/* loaded from: classes.dex */
+public final class e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final h f6119a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public volatile R0.h f6120b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public volatile A.j f6121c;
+
+    public e(h hVar) {
+        this.f6119a = hVar;
+    }
+}

apk_decompiled/sources/d0/f.java

@@ -0,0 +1,9 @@
+package d0;
+
+/* loaded from: classes.dex */
+public abstract class f {
+    public void a() {
+    }
+
+    public abstract void b();
+}

apk_decompiled/sources/d0/g.java

@@ -0,0 +1,6 @@
+package d0;
+
+/* loaded from: classes.dex */
+public interface g {
+    void a(m3.l lVar);
+}

apk_decompiled/sources/d0/h.java

@@ -0,0 +1,170 @@
+package d0;
+
+import android.os.Handler;
+import android.os.Looper;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/* loaded from: classes.dex */
+public final class h {
+
+    /* renamed from: j, reason: collision with root package name */
+    public static final Object f6122j = new Object();
+
+    /* renamed from: k, reason: collision with root package name */
+    public static volatile h f6123k;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final ReentrantReadWriteLock f6124a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final s.f f6125b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public volatile int f6126c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final Handler f6127d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final e f6128e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final g f6129f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final E2.e f6130g;
+    public final int h;
+    public final C0305c i;
+
+    public h(p pVar) {
+        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
+        this.f6124a = reentrantReadWriteLock;
+        this.f6126c = 3;
+        g gVar = (g) pVar.f3794b;
+        this.f6129f = gVar;
+        int i = pVar.f3793a;
+        this.h = i;
+        this.i = (C0305c) pVar.f3795c;
+        this.f6127d = new Handler(Looper.getMainLooper());
+        this.f6125b = new s.f(0);
+        this.f6130g = new E2.e(27);
+        e eVar = new e(this);
+        this.f6128e = eVar;
+        reentrantReadWriteLock.writeLock().lock();
+        if (i == 0) {
+            try {
+                this.f6126c = 0;
+            } catch (Throwable th) {
+                this.f6124a.writeLock().unlock();
+                throw th;
+            }
+        }
+        reentrantReadWriteLock.writeLock().unlock();
+        if (b() == 0) {
+            try {
+                gVar.a(new C0306d(eVar));
+            } catch (Throwable th2) {
+                d(th2);
+            }
+        }
+    }
+
+    public static h a() {
+        h hVar;
+        synchronized (f6122j) {
+            try {
+                hVar = f6123k;
+                if (!(hVar != null)) {
+                    throw new IllegalStateException("EmojiCompat is not initialized.\n\nYou must initialize EmojiCompat prior to referencing the EmojiCompat instance.\n\nThe most likely cause of this error is disabling the EmojiCompatInitializer\neither explicitly in AndroidManifest.xml, or by including\nandroidx.emoji2:emoji2-bundled.\n\nAutomatic initialization is typically performed by EmojiCompatInitializer. If\nyou are not expecting to initialize EmojiCompat manually in your application,\nplease check to ensure it has not been removed from your APK's manifest. You can\ndo this in Android Studio using Build > Analyze APK.\n\nIn the APK Analyzer, ensure that the startup entry for\nEmojiCompatInitializer and InitializationProvider is present in\n AndroidManifest.xml. If it is missing or contains tools:node=\"remove\", and you\nintend to use automatic configuration, verify:\n\n  1. Your application does not include emoji2-bundled\n  2. All modules do not contain an exclusion manifest rule for\n     EmojiCompatInitializer or InitializationProvider. For more information\n     about manifest exclusions see the documentation for the androidx startup\n     library.\n\nIf you intend to use emoji2-bundled, please call EmojiCompat.init. You can\nlearn more in the documentation for BundledEmojiCompatConfig.\n\nIf you intended to perform manual configuration, it is recommended that you call\nEmojiCompat.init immediately on application startup.\n\nIf you still cannot resolve this issue, please open a bug with your specific\nconfiguration to help improve error message.");
+                }
+            } finally {
+            }
+        }
+        return hVar;
+    }
+
+    public final int b() {
+        this.f6124a.readLock().lock();
+        try {
+            return this.f6126c;
+        } finally {
+            this.f6124a.readLock().unlock();
+        }
+    }
+
+    public final void c() {
+        if (!(this.h == 1)) {
+            throw new IllegalStateException("Set metadataLoadStrategy to LOAD_STRATEGY_MANUAL to execute manual loading");
+        }
+        if (b() == 1) {
+            return;
+        }
+        this.f6124a.writeLock().lock();
+        try {
+            if (this.f6126c == 0) {
+                return;
+            }
+            this.f6126c = 0;
+            this.f6124a.writeLock().unlock();
+            e eVar = this.f6128e;
+            h hVar = eVar.f6119a;
+            try {
+                hVar.f6129f.a(new C0306d(eVar));
+            } catch (Throwable th) {
+                hVar.d(th);
+            }
+        } finally {
+            this.f6124a.writeLock().unlock();
+        }
+    }
+
+    public final void d(Throwable th) {
+        ArrayList arrayList = new ArrayList();
+        this.f6124a.writeLock().lock();
+        try {
+            this.f6126c = 2;
+            arrayList.addAll(this.f6125b);
+            this.f6125b.clear();
+            this.f6124a.writeLock().unlock();
+            this.f6127d.post(new H0.p(arrayList, this.f6126c, th));
+        } catch (Throwable th2) {
+            this.f6124a.writeLock().unlock();
+            throw th2;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:43:0x009f A[Catch: all -> 0x0082, TryCatch #0 {all -> 0x0082, blocks: (B:28:0x005a, B:31:0x005f, B:33:0x0063, B:35:0x0070, B:37:0x008f, B:39:0x0099, B:41:0x009c, B:43:0x009f, B:45:0x00af, B:46:0x00b2), top: B:27:0x005a }] */
+    /* JADX WARN: Removed duplicated region for block: B:75:0x0105  */
+    /* JADX WARN: Removed duplicated region for block: B:77:? A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:86:? A[RETURN, SYNTHETIC] */
+    /* JADX WARN: Type inference failed for: r0v13, types: [java.lang.Object, d0.v] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.CharSequence e(java.lang.CharSequence r10, int r11, int r12) {
+        /*
+            Method dump skipped, instructions count: 293
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: d0.h.e(java.lang.CharSequence, int, int):java.lang.CharSequence");
+    }
+
+    public final void f(f fVar) {
+        m3.d.i(fVar, "initCallback cannot be null");
+        this.f6124a.writeLock().lock();
+        try {
+            if (this.f6126c != 1 && this.f6126c != 2) {
+                this.f6125b.add(fVar);
+                this.f6124a.writeLock().unlock();
+            }
+            this.f6127d.post(new H0.p(Arrays.asList(fVar), this.f6126c, (Throwable) null));
+            this.f6124a.writeLock().unlock();
+        } catch (Throwable th) {
+            this.f6124a.writeLock().unlock();
+            throw th;
+        }
+    }
+}

apk_decompiled/sources/d0/i.java

@@ -0,0 +1,26 @@
+package d0;
+
+import android.os.Looper;
+import androidx.emoji2.text.EmojiCompatInitializer;
+import androidx.lifecycle.C;
+import androidx.lifecycle.InterfaceC0192m;
+import androidx.lifecycle.J;
+
+/* loaded from: classes.dex */
+public final class i implements InterfaceC0192m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ C f6131a;
+
+    public i(EmojiCompatInitializer emojiCompatInitializer, C c4) {
+        this.f6131a = c4;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v0, types: [java.lang.Object, java.lang.Runnable] */
+    @Override // androidx.lifecycle.InterfaceC0192m
+    public final void d(J j4) {
+        AbstractC0304b.a(Looper.getMainLooper()).postDelayed(new Object(), 500L);
+        this.f6131a.c(this);
+    }
+}

apk_decompiled/sources/d0/j.java

@@ -0,0 +1,38 @@
+package d0;
+
+import java.util.concurrent.ThreadPoolExecutor;
+
+/* loaded from: classes.dex */
+public final class j extends m3.l {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ m3.l f6132a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ ThreadPoolExecutor f6133b;
+
+    public j(m3.l lVar, ThreadPoolExecutor threadPoolExecutor) {
+        this.f6132a = lVar;
+        this.f6133b = threadPoolExecutor;
+    }
+
+    @Override // m3.l
+    public final void L(Throwable th) {
+        ThreadPoolExecutor threadPoolExecutor = this.f6133b;
+        try {
+            this.f6132a.L(th);
+        } finally {
+            threadPoolExecutor.shutdown();
+        }
+    }
+
+    @Override // m3.l
+    public final void M(A.j jVar) {
+        ThreadPoolExecutor threadPoolExecutor = this.f6133b;
+        try {
+            this.f6132a.M(jVar);
+        } finally {
+            threadPoolExecutor.shutdown();
+        }
+    }
+}

apk_decompiled/sources/d0/k.java

@@ -0,0 +1,18 @@
+package d0;
+
+import android.os.Trace;
+
+/* loaded from: classes.dex */
+public final class k implements Runnable {
+    @Override // java.lang.Runnable
+    public final void run() {
+        try {
+            Trace.beginSection("EmojiCompat.EmojiCompatInitializer.run");
+            if (h.f6123k != null) {
+                h.a().c();
+            }
+        } finally {
+            Trace.endSection();
+        }
+    }
+}

apk_decompiled/sources/d0/l.java

@@ -0,0 +1,11 @@
+package d0;
+
+import a.AbstractC0105a;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public abstract class l {
+    public static Set<int[]> a() {
+        return AbstractC0105a.A();
+    }
+}

apk_decompiled/sources/d0/m.java

@@ -0,0 +1,8 @@
+package d0;
+
+/* loaded from: classes.dex */
+public interface m {
+    Object d();
+
+    boolean k(CharSequence charSequence, int i, int i4, t tVar);
+}

apk_decompiled/sources/d0/n.java

@@ -0,0 +1,42 @@
+package d0;
+
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class n {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f6134a = 1;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final q f6135b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public q f6136c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public q f6137d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public int f6138e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public int f6139f;
+
+    public n(q qVar) {
+        this.f6135b = qVar;
+        this.f6136c = qVar;
+    }
+
+    public final void a() {
+        this.f6134a = 1;
+        this.f6136c = this.f6135b;
+        this.f6139f = 0;
+    }
+
+    public final boolean b() {
+        e0.a b4 = this.f6136c.f6149b.b();
+        int a2 = b4.a(6);
+        return !(a2 == 0 || ((ByteBuffer) b4.f1221d).get(a2 + b4.f1218a) == 0) || this.f6138e == 65039;
+    }
+}

apk_decompiled/sources/d0/o.java

@@ -0,0 +1,109 @@
+package d0;
+
+import C.w;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Handler;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes.dex */
+public final class o implements g {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Context f6140a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final I0.b f6141b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final E2.e f6142c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final Object f6143d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public Handler f6144e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public ThreadPoolExecutor f6145f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public ThreadPoolExecutor f6146g;
+    public m3.l h;
+
+    public o(Context context, I0.b bVar) {
+        E2.e eVar = p.f6147d;
+        this.f6143d = new Object();
+        m3.d.i(context, "Context cannot be null");
+        this.f6140a = context.getApplicationContext();
+        this.f6141b = bVar;
+        this.f6142c = eVar;
+    }
+
+    @Override // d0.g
+    public final void a(m3.l lVar) {
+        synchronized (this.f6143d) {
+            this.h = lVar;
+        }
+        synchronized (this.f6143d) {
+            try {
+                if (this.h == null) {
+                    return;
+                }
+                if (this.f6145f == null) {
+                    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, 1, 15L, TimeUnit.SECONDS, new LinkedBlockingDeque(), new ThreadFactoryC0303a("emojiCompat"));
+                    threadPoolExecutor.allowCoreThreadTimeOut(true);
+                    this.f6146g = threadPoolExecutor;
+                    this.f6145f = threadPoolExecutor;
+                }
+                this.f6145f.execute(new F2.f(this, 10));
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void b() {
+        synchronized (this.f6143d) {
+            try {
+                this.h = null;
+                Handler handler = this.f6144e;
+                if (handler != null) {
+                    handler.removeCallbacks(null);
+                }
+                this.f6144e = null;
+                ThreadPoolExecutor threadPoolExecutor = this.f6146g;
+                if (threadPoolExecutor != null) {
+                    threadPoolExecutor.shutdown();
+                }
+                this.f6145f = null;
+                this.f6146g = null;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final L.i c() {
+        try {
+            E2.e eVar = this.f6142c;
+            Context context = this.f6140a;
+            I0.b bVar = this.f6141b;
+            eVar.getClass();
+            L.h a2 = L.c.a(context, bVar);
+            int i = a2.f1036a;
+            if (i != 0) {
+                throw new RuntimeException(w.i(i, "fetchFonts failed (", ")"));
+            }
+            L.i[] iVarArr = (L.i[]) a2.f1037b;
+            if (iVarArr == null || iVarArr.length == 0) {
+                throw new RuntimeException("fetchFonts failed (empty result)");
+            }
+            return iVarArr[0];
+        } catch (PackageManager.NameNotFoundException e4) {
+            throw new RuntimeException("provider not found", e4);
+        }
+    }
+}

apk_decompiled/sources/d0/p.java

@@ -0,0 +1,10 @@
+package d0;
+
+import androidx.recyclerview.widget.AbstractC0208b0;
+
+/* loaded from: classes.dex */
+public final class p extends AbstractC0208b0 {
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final E2.e f6147d = new E2.e(28);
+}

apk_decompiled/sources/d0/q.java

@@ -0,0 +1,32 @@
+package d0;
+
+import android.util.SparseArray;
+
+/* loaded from: classes.dex */
+public final class q {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final SparseArray f6148a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public t f6149b;
+
+    public q(int i) {
+        this.f6148a = new SparseArray(i);
+    }
+
+    public final void a(t tVar, int i, int i4) {
+        int a2 = tVar.a(i);
+        SparseArray sparseArray = this.f6148a;
+        q qVar = sparseArray == null ? null : (q) sparseArray.get(a2);
+        if (qVar == null) {
+            qVar = new q(1);
+            sparseArray.put(tVar.a(i), qVar);
+        }
+        if (i4 > i) {
+            qVar.a(tVar, i + 1, i4);
+        } else {
+            qVar.f6149b = tVar;
+        }
+    }
+}

apk_decompiled/sources/d0/r.java

@@ -0,0 +1,57 @@
+package d0;
+
+import android.text.Editable;
+import android.text.SpanWatcher;
+import android.text.Spannable;
+import android.text.TextWatcher;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes.dex */
+public final class r implements TextWatcher, SpanWatcher {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Object f6150a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final AtomicInteger f6151b = new AtomicInteger(0);
+
+    public r(Object obj) {
+        this.f6150a = obj;
+    }
+
+    @Override // android.text.TextWatcher
+    public final void afterTextChanged(Editable editable) {
+        ((TextWatcher) this.f6150a).afterTextChanged(editable);
+    }
+
+    @Override // android.text.TextWatcher
+    public final void beforeTextChanged(CharSequence charSequence, int i, int i4, int i5) {
+        ((TextWatcher) this.f6150a).beforeTextChanged(charSequence, i, i4, i5);
+    }
+
+    @Override // android.text.SpanWatcher
+    public final void onSpanAdded(Spannable spannable, Object obj, int i, int i4) {
+        if (this.f6151b.get() <= 0 || !(obj instanceof u)) {
+            ((SpanWatcher) this.f6150a).onSpanAdded(spannable, obj, i, i4);
+        }
+    }
+
+    @Override // android.text.SpanWatcher
+    public final void onSpanChanged(Spannable spannable, Object obj, int i, int i4, int i5, int i6) {
+        if (this.f6151b.get() <= 0 || !(obj instanceof u)) {
+            ((SpanWatcher) this.f6150a).onSpanChanged(spannable, obj, i, i4, i5, i6);
+        }
+    }
+
+    @Override // android.text.SpanWatcher
+    public final void onSpanRemoved(Spannable spannable, Object obj, int i, int i4) {
+        if (this.f6151b.get() <= 0 || !(obj instanceof u)) {
+            ((SpanWatcher) this.f6150a).onSpanRemoved(spannable, obj, i, i4);
+        }
+    }
+
+    @Override // android.text.TextWatcher
+    public final void onTextChanged(CharSequence charSequence, int i, int i4, int i5) {
+        ((TextWatcher) this.f6150a).onTextChanged(charSequence, i, i4, i5);
+    }
+}

apk_decompiled/sources/d0/s.java

@@ -0,0 +1,293 @@
+package d0;
+
+import android.text.Editable;
+import android.text.SpannableStringBuilder;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class s extends SpannableStringBuilder {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Class f6152a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final ArrayList f6153b;
+
+    public s(Class cls, CharSequence charSequence) {
+        super(charSequence);
+        this.f6153b = new ArrayList();
+        m3.d.i(cls, "watcherClass cannot be null");
+        this.f6152a = cls;
+    }
+
+    public final void a() {
+        int i = 0;
+        while (true) {
+            ArrayList arrayList = this.f6153b;
+            if (i >= arrayList.size()) {
+                return;
+            }
+            ((r) arrayList.get(i)).f6151b.incrementAndGet();
+            i++;
+        }
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final Editable append(CharSequence charSequence) {
+        super.append(charSequence);
+        return this;
+    }
+
+    public final void b() {
+        e();
+        int i = 0;
+        while (true) {
+            ArrayList arrayList = this.f6153b;
+            if (i >= arrayList.size()) {
+                return;
+            }
+            ((r) arrayList.get(i)).onTextChanged(this, 0, length(), length());
+            i++;
+        }
+    }
+
+    public final r c(Object obj) {
+        int i = 0;
+        while (true) {
+            ArrayList arrayList = this.f6153b;
+            if (i >= arrayList.size()) {
+                return null;
+            }
+            r rVar = (r) arrayList.get(i);
+            if (rVar.f6150a == obj) {
+                return rVar;
+            }
+            i++;
+        }
+    }
+
+    public final boolean d(Object obj) {
+        if (obj != null) {
+            return this.f6152a == obj.getClass();
+        }
+        return false;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final Editable delete(int i, int i4) {
+        super.delete(i, i4);
+        return this;
+    }
+
+    public final void e() {
+        int i = 0;
+        while (true) {
+            ArrayList arrayList = this.f6153b;
+            if (i >= arrayList.size()) {
+                return;
+            }
+            ((r) arrayList.get(i)).f6151b.decrementAndGet();
+            i++;
+        }
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Spanned
+    public final int getSpanEnd(Object obj) {
+        r c4;
+        if (d(obj) && (c4 = c(obj)) != null) {
+            obj = c4;
+        }
+        return super.getSpanEnd(obj);
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Spanned
+    public final int getSpanFlags(Object obj) {
+        r c4;
+        if (d(obj) && (c4 = c(obj)) != null) {
+            obj = c4;
+        }
+        return super.getSpanFlags(obj);
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Spanned
+    public final int getSpanStart(Object obj) {
+        r c4;
+        if (d(obj) && (c4 = c(obj)) != null) {
+            obj = c4;
+        }
+        return super.getSpanStart(obj);
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Spanned
+    public final Object[] getSpans(int i, int i4, Class cls) {
+        if (this.f6152a != cls) {
+            return super.getSpans(i, i4, cls);
+        }
+        r[] rVarArr = (r[]) super.getSpans(i, i4, r.class);
+        Object[] objArr = (Object[]) Array.newInstance((Class<?>) cls, rVarArr.length);
+        for (int i5 = 0; i5 < rVarArr.length; i5++) {
+            objArr[i5] = rVarArr[i5].f6150a;
+        }
+        return objArr;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final Editable insert(int i, CharSequence charSequence) {
+        super.insert(i, charSequence);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Spanned
+    public final int nextSpanTransition(int i, int i4, Class cls) {
+        if (cls == null || this.f6152a == cls) {
+            cls = r.class;
+        }
+        return super.nextSpanTransition(i, i4, cls);
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Spannable
+    public final void removeSpan(Object obj) {
+        r rVar;
+        if (d(obj)) {
+            rVar = c(obj);
+            if (rVar != null) {
+                obj = rVar;
+            }
+        } else {
+            rVar = null;
+        }
+        super.removeSpan(obj);
+        if (rVar != null) {
+            this.f6153b.remove(rVar);
+        }
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final /* bridge */ /* synthetic */ Editable replace(int i, int i4, CharSequence charSequence) {
+        replace(i, i4, charSequence);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Spannable
+    public final void setSpan(Object obj, int i, int i4, int i5) {
+        if (d(obj)) {
+            r rVar = new r(obj);
+            this.f6153b.add(rVar);
+            obj = rVar;
+        }
+        super.setSpan(obj, i, i4, i5);
+    }
+
+    @Override // android.text.SpannableStringBuilder, java.lang.CharSequence
+    public final CharSequence subSequence(int i, int i4) {
+        return new s(this.f6152a, this, i, i4);
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final SpannableStringBuilder append(CharSequence charSequence) {
+        super.append(charSequence);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final SpannableStringBuilder delete(int i, int i4) {
+        super.delete(i, i4);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final SpannableStringBuilder insert(int i, CharSequence charSequence) {
+        super.insert(i, charSequence);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final /* bridge */ /* synthetic */ Editable replace(int i, int i4, CharSequence charSequence, int i5, int i6) {
+        replace(i, i4, charSequence, i5, i6);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final Appendable append(CharSequence charSequence) {
+        super.append(charSequence);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final Editable insert(int i, CharSequence charSequence, int i4, int i5) {
+        super.insert(i, charSequence, i4, i5);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final SpannableStringBuilder replace(int i, int i4, CharSequence charSequence) {
+        a();
+        super.replace(i, i4, charSequence);
+        e();
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final Editable append(char c4) {
+        super.append(c4);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final SpannableStringBuilder insert(int i, CharSequence charSequence, int i4, int i5) {
+        super.insert(i, charSequence, i4, i5);
+        return this;
+    }
+
+    public s(Class cls, s sVar, int i, int i4) {
+        super(sVar, i, i4);
+        this.f6153b = new ArrayList();
+        m3.d.i(cls, "watcherClass cannot be null");
+        this.f6152a = cls;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final SpannableStringBuilder append(char c4) {
+        super.append(c4);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final Appendable append(char c4) {
+        super.append(c4);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable
+    public final SpannableStringBuilder replace(int i, int i4, CharSequence charSequence, int i5, int i6) {
+        a();
+        super.replace(i, i4, charSequence, i5, i6);
+        e();
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final Editable append(CharSequence charSequence, int i, int i4) {
+        super.append(charSequence, i, i4);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final SpannableStringBuilder append(CharSequence charSequence, int i, int i4) {
+        super.append(charSequence, i, i4);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder, android.text.Editable, java.lang.Appendable
+    public final Appendable append(CharSequence charSequence, int i, int i4) {
+        super.append(charSequence, i, i4);
+        return this;
+    }
+
+    @Override // android.text.SpannableStringBuilder
+    public final SpannableStringBuilder append(CharSequence charSequence, Object obj, int i) {
+        super.append(charSequence, obj, i);
+        return this;
+    }
+}

apk_decompiled/sources/d0/t.java

@@ -0,0 +1,93 @@
+package d0;
+
+import O.I;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class t {
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final ThreadLocal f6154d = new ThreadLocal();
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f6155a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final A.j f6156b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public volatile int f6157c = 0;
+
+    public t(A.j jVar, int i) {
+        this.f6156b = jVar;
+        this.f6155a = i;
+    }
+
+    public final int a(int i) {
+        e0.a b4 = b();
+        int a2 = b4.a(16);
+        if (a2 == 0) {
+            return 0;
+        }
+        ByteBuffer byteBuffer = (ByteBuffer) b4.f1221d;
+        int i4 = a2 + b4.f1218a;
+        return byteBuffer.getInt((i * 4) + byteBuffer.getInt(i4) + i4 + 4);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r1v3, types: [java.lang.Object, O.I] */
+    public final e0.a b() {
+        ThreadLocal threadLocal = f6154d;
+        e0.a aVar = (e0.a) threadLocal.get();
+        e0.a aVar2 = aVar;
+        if (aVar == null) {
+            ?? i = new I();
+            threadLocal.set(i);
+            aVar2 = i;
+        }
+        e0.b bVar = (e0.b) this.f6156b.f27a;
+        int a2 = bVar.a(6);
+        if (a2 != 0) {
+            int i4 = a2 + bVar.f1218a;
+            int i5 = (this.f6155a * 4) + ((ByteBuffer) bVar.f1221d).getInt(i4) + i4 + 4;
+            int i6 = ((ByteBuffer) bVar.f1221d).getInt(i5) + i5;
+            ByteBuffer byteBuffer = (ByteBuffer) bVar.f1221d;
+            aVar2.f1221d = byteBuffer;
+            if (byteBuffer != null) {
+                aVar2.f1218a = i6;
+                int i7 = i6 - byteBuffer.getInt(i6);
+                aVar2.f1219b = i7;
+                aVar2.f1220c = ((ByteBuffer) aVar2.f1221d).getShort(i7);
+                return aVar2;
+            }
+            aVar2.f1218a = 0;
+            aVar2.f1219b = 0;
+            aVar2.f1220c = 0;
+        }
+        return aVar2;
+    }
+
+    public final String toString() {
+        int i;
+        StringBuilder sb = new StringBuilder();
+        sb.append(super.toString());
+        sb.append(", id:");
+        e0.a b4 = b();
+        int a2 = b4.a(4);
+        sb.append(Integer.toHexString(a2 != 0 ? ((ByteBuffer) b4.f1221d).getInt(a2 + b4.f1218a) : 0));
+        sb.append(", codepoints:");
+        e0.a b5 = b();
+        int a4 = b5.a(16);
+        if (a4 != 0) {
+            int i4 = a4 + b5.f1218a;
+            i = ((ByteBuffer) b5.f1221d).getInt(((ByteBuffer) b5.f1221d).getInt(i4) + i4);
+        } else {
+            i = 0;
+        }
+        for (int i5 = 0; i5 < i; i5++) {
+            sb.append(Integer.toHexString(a(i5)));
+            sb.append(" ");
+        }
+        return sb.toString();
+    }
+}

apk_decompiled/sources/d0/u.java

@@ -0,0 +1,107 @@
+package d0;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Typeface;
+import android.text.Spanned;
+import android.text.TextPaint;
+import android.text.style.CharacterStyle;
+import android.text.style.ReplacementSpan;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes.dex */
+public final class u extends ReplacementSpan {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final t f6159b;
+
+    /* renamed from: e, reason: collision with root package name */
+    public TextPaint f6162e;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Paint.FontMetricsInt f6158a = new Paint.FontMetricsInt();
+
+    /* renamed from: c, reason: collision with root package name */
+    public short f6160c = -1;
+
+    /* renamed from: d, reason: collision with root package name */
+    public float f6161d = 1.0f;
+
+    public u(t tVar) {
+        m3.d.i(tVar, "rasterizer cannot be null");
+        this.f6159b = tVar;
+    }
+
+    @Override // android.text.style.ReplacementSpan
+    public final void draw(Canvas canvas, CharSequence charSequence, int i, int i4, float f2, int i5, int i6, int i7, Paint paint) {
+        TextPaint textPaint = null;
+        if (charSequence instanceof Spanned) {
+            CharacterStyle[] characterStyleArr = (CharacterStyle[]) ((Spanned) charSequence).getSpans(i, i4, CharacterStyle.class);
+            if (characterStyleArr.length != 0) {
+                if (characterStyleArr.length != 1 || characterStyleArr[0] != this) {
+                    TextPaint textPaint2 = this.f6162e;
+                    if (textPaint2 == null) {
+                        textPaint2 = new TextPaint();
+                        this.f6162e = textPaint2;
+                    }
+                    textPaint = textPaint2;
+                    textPaint.set(paint);
+                    for (CharacterStyle characterStyle : characterStyleArr) {
+                        characterStyle.updateDrawState(textPaint);
+                    }
+                }
+            }
+            if (paint instanceof TextPaint) {
+                textPaint = (TextPaint) paint;
+            }
+        } else if (paint instanceof TextPaint) {
+            textPaint = (TextPaint) paint;
+        }
+        TextPaint textPaint3 = textPaint;
+        if (textPaint3 != null && textPaint3.bgColor != 0) {
+            int color = textPaint3.getColor();
+            Paint.Style style = textPaint3.getStyle();
+            textPaint3.setColor(textPaint3.bgColor);
+            textPaint3.setStyle(Paint.Style.FILL);
+            canvas.drawRect(f2, i5, f2 + this.f6160c, i7, textPaint3);
+            textPaint3.setStyle(style);
+            textPaint3.setColor(color);
+        }
+        h.a().getClass();
+        float f4 = i6;
+        Paint paint2 = textPaint3;
+        if (textPaint3 == null) {
+            paint2 = paint;
+        }
+        t tVar = this.f6159b;
+        A.j jVar = tVar.f6156b;
+        Typeface typeface = (Typeface) jVar.f30d;
+        Typeface typeface2 = paint2.getTypeface();
+        paint2.setTypeface(typeface);
+        canvas.drawText((char[]) jVar.f28b, tVar.f6155a * 2, 2, f2, f4, paint2);
+        paint2.setTypeface(typeface2);
+    }
+
+    @Override // android.text.style.ReplacementSpan
+    public final int getSize(Paint paint, CharSequence charSequence, int i, int i4, Paint.FontMetricsInt fontMetricsInt) {
+        Paint.FontMetricsInt fontMetricsInt2 = this.f6158a;
+        paint.getFontMetricsInt(fontMetricsInt2);
+        float abs = Math.abs(fontMetricsInt2.descent - fontMetricsInt2.ascent) * 1.0f;
+        t tVar = this.f6159b;
+        this.f6161d = abs / (tVar.b().a(14) != 0 ? ((ByteBuffer) r8.f1221d).getShort(r1 + r8.f1218a) : (short) 0);
+        e0.a b4 = tVar.b();
+        int a2 = b4.a(14);
+        if (a2 != 0) {
+            ((ByteBuffer) b4.f1221d).getShort(a2 + b4.f1218a);
+        }
+        short s4 = (short) ((tVar.b().a(12) != 0 ? ((ByteBuffer) r5.f1221d).getShort(r7 + r5.f1218a) : (short) 0) * this.f6161d);
+        this.f6160c = s4;
+        if (fontMetricsInt != null) {
+            fontMetricsInt.ascent = fontMetricsInt2.ascent;
+            fontMetricsInt.descent = fontMetricsInt2.descent;
+            fontMetricsInt.top = fontMetricsInt2.top;
+            fontMetricsInt.bottom = fontMetricsInt2.bottom;
+        }
+        return s4;
+    }
+}

apk_decompiled/sources/d0/v.java

@@ -0,0 +1,95 @@
+package d0;
+
+import android.text.PrecomputedText;
+import android.text.Spannable;
+import android.text.SpannableString;
+import java.util.stream.IntStream;
+
+/* loaded from: classes.dex */
+public final class v implements Spannable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public boolean f6163a = false;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Spannable f6164b;
+
+    public v(Spannable spannable) {
+        this.f6164b = spannable;
+    }
+
+    @Override // java.lang.CharSequence
+    public final char charAt(int i) {
+        return this.f6164b.charAt(i);
+    }
+
+    @Override // java.lang.CharSequence
+    public final IntStream chars() {
+        return this.f6164b.chars();
+    }
+
+    @Override // java.lang.CharSequence
+    public final IntStream codePoints() {
+        return this.f6164b.codePoints();
+    }
+
+    @Override // android.text.Spanned
+    public final int getSpanEnd(Object obj) {
+        return this.f6164b.getSpanEnd(obj);
+    }
+
+    @Override // android.text.Spanned
+    public final int getSpanFlags(Object obj) {
+        return this.f6164b.getSpanFlags(obj);
+    }
+
+    @Override // android.text.Spanned
+    public final int getSpanStart(Object obj) {
+        return this.f6164b.getSpanStart(obj);
+    }
+
+    @Override // android.text.Spanned
+    public final Object[] getSpans(int i, int i4, Class cls) {
+        return this.f6164b.getSpans(i, i4, cls);
+    }
+
+    @Override // java.lang.CharSequence
+    public final int length() {
+        return this.f6164b.length();
+    }
+
+    @Override // android.text.Spanned
+    public final int nextSpanTransition(int i, int i4, Class cls) {
+        return this.f6164b.nextSpanTransition(i, i4, cls);
+    }
+
+    @Override // android.text.Spannable
+    public final void removeSpan(Object obj) {
+        Spannable spannable = this.f6164b;
+        if (!this.f6163a && (spannable instanceof PrecomputedText)) {
+            this.f6164b = new SpannableString(spannable);
+        }
+        this.f6163a = true;
+        this.f6164b.removeSpan(obj);
+    }
+
+    @Override // android.text.Spannable
+    public final void setSpan(Object obj, int i, int i4, int i5) {
+        Spannable spannable = this.f6164b;
+        if (!this.f6163a && (spannable instanceof PrecomputedText)) {
+            this.f6164b = new SpannableString(spannable);
+        }
+        this.f6163a = true;
+        this.f6164b.setSpan(obj, i, i4, i5);
+    }
+
+    @Override // java.lang.CharSequence
+    public final CharSequence subSequence(int i, int i4) {
+        return this.f6164b.subSequence(i, i4);
+    }
+
+    @Override // java.lang.CharSequence
+    public final String toString() {
+        return this.f6164b.toString();
+    }
+}