Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/core/util/AndroidXConsumerKt.java

@@ -0,0 +1,10 @@
+package androidx.core.util;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes.dex */
+public final class AndroidXConsumerKt {
+    public static final <T> Consumer<T> asAndroidXConsumer(Continuation continuation) {
+        return new AndroidXContinuationConsumer(continuation);
+    }
+}

decompiled/sources/androidx/core/util/AndroidXContinuationConsumer.java

@@ -0,0 +1,27 @@
+package androidx.core.util;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.Result;
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes.dex */
+final class AndroidXContinuationConsumer<T> extends AtomicBoolean implements Consumer<T> {
+    private final Continuation continuation;
+
+    public AndroidXContinuationConsumer(Continuation continuation) {
+        super(false);
+        this.continuation = continuation;
+    }
+
+    @Override // androidx.core.util.Consumer
+    public void accept(T t) {
+        if (compareAndSet(false, true)) {
+            this.continuation.resumeWith(Result.m4060constructorimpl(t));
+        }
+    }
+
+    @Override // java.util.concurrent.atomic.AtomicBoolean
+    public String toString() {
+        return "ContinuationConsumer(resultAccepted = " + get() + ')';
+    }
+}

decompiled/sources/androidx/core/util/AtomicFile.java

@@ -0,0 +1,141 @@
+package androidx.core.util;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/* loaded from: classes.dex */
+public class AtomicFile {
+    private static final String LOG_TAG = "AtomicFile";
+    private final File mBaseName;
+    private final File mLegacyBackupName;
+    private final File mNewName;
+
+    @NonNull
+    public File getBaseFile() {
+        return this.mBaseName;
+    }
+
+    public AtomicFile(@NonNull File file) {
+        this.mBaseName = file;
+        this.mNewName = new File(file.getPath() + ".new");
+        this.mLegacyBackupName = new File(file.getPath() + ".bak");
+    }
+
+    public void delete() {
+        this.mBaseName.delete();
+        this.mNewName.delete();
+        this.mLegacyBackupName.delete();
+    }
+
+    @NonNull
+    public FileOutputStream startWrite() throws IOException {
+        if (this.mLegacyBackupName.exists()) {
+            rename(this.mLegacyBackupName, this.mBaseName);
+        }
+        try {
+            return new FileOutputStream(this.mNewName);
+        } catch (FileNotFoundException unused) {
+            if (!this.mNewName.getParentFile().mkdirs()) {
+                throw new IOException("Failed to create directory for " + this.mNewName);
+            }
+            try {
+                return new FileOutputStream(this.mNewName);
+            } catch (FileNotFoundException e) {
+                throw new IOException("Failed to create new file " + this.mNewName, e);
+            }
+        }
+    }
+
+    public void finishWrite(@Nullable FileOutputStream fileOutputStream) {
+        if (fileOutputStream == null) {
+            return;
+        }
+        if (!sync(fileOutputStream)) {
+            Log.e(LOG_TAG, "Failed to sync file output stream");
+        }
+        try {
+            fileOutputStream.close();
+        } catch (IOException e) {
+            Log.e(LOG_TAG, "Failed to close file output stream", e);
+        }
+        rename(this.mNewName, this.mBaseName);
+    }
+
+    public void failWrite(@Nullable FileOutputStream fileOutputStream) {
+        if (fileOutputStream == null) {
+            return;
+        }
+        if (!sync(fileOutputStream)) {
+            Log.e(LOG_TAG, "Failed to sync file output stream");
+        }
+        try {
+            fileOutputStream.close();
+        } catch (IOException e) {
+            Log.e(LOG_TAG, "Failed to close file output stream", e);
+        }
+        if (this.mNewName.delete()) {
+            return;
+        }
+        Log.e(LOG_TAG, "Failed to delete new file " + this.mNewName);
+    }
+
+    @NonNull
+    public FileInputStream openRead() throws FileNotFoundException {
+        if (this.mLegacyBackupName.exists()) {
+            rename(this.mLegacyBackupName, this.mBaseName);
+        }
+        if (this.mNewName.exists() && this.mBaseName.exists() && !this.mNewName.delete()) {
+            Log.e(LOG_TAG, "Failed to delete outdated new file " + this.mNewName);
+        }
+        return new FileInputStream(this.mBaseName);
+    }
+
+    @NonNull
+    public byte[] readFully() throws IOException {
+        FileInputStream openRead = openRead();
+        try {
+            byte[] bArr = new byte[openRead.available()];
+            int i = 0;
+            while (true) {
+                int read = openRead.read(bArr, i, bArr.length - i);
+                if (read <= 0) {
+                    return bArr;
+                }
+                i += read;
+                int available = openRead.available();
+                if (available > bArr.length - i) {
+                    byte[] bArr2 = new byte[available + i];
+                    System.arraycopy(bArr, 0, bArr2, 0, i);
+                    bArr = bArr2;
+                }
+            }
+        } finally {
+            openRead.close();
+        }
+    }
+
+    private static boolean sync(@NonNull FileOutputStream fileOutputStream) {
+        try {
+            fileOutputStream.getFD().sync();
+            return true;
+        } catch (IOException unused) {
+            return false;
+        }
+    }
+
+    private static void rename(@NonNull File file, @NonNull File file2) {
+        if (file2.isDirectory() && !file2.delete()) {
+            Log.e(LOG_TAG, "Failed to delete file which is a directory " + file2);
+        }
+        if (file.renameTo(file2)) {
+            return;
+        }
+        Log.e(LOG_TAG, "Failed to rename " + file + " to " + file2);
+    }
+}

decompiled/sources/androidx/core/util/AtomicFileKt.java

@@ -0,0 +1,67 @@
+package androidx.core.util;
+
+import java.io.FileOutputStream;
+import java.nio.charset.Charset;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.InlineMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.text.Charsets;
+
+@SourceDebugExtension({"SMAP\nAtomicFile.kt\nKotlin\n*S Kotlin\n*F\n+ 1 AtomicFile.kt\nandroidx/core/util/AtomicFileKt\n*L\n1#1,72:1\n30#1,13:73\n*S KotlinDebug\n*F\n+ 1 AtomicFile.kt\nandroidx/core/util/AtomicFileKt\n*L\n46#1:73,13\n*E\n"})
+/* loaded from: classes.dex */
+public final class AtomicFileKt {
+    public static final void tryWrite(android.util.AtomicFile atomicFile, Function1 function1) {
+        FileOutputStream startWrite = atomicFile.startWrite();
+        try {
+            function1.invoke(startWrite);
+            InlineMarker.finallyStart(1);
+            atomicFile.finishWrite(startWrite);
+            InlineMarker.finallyEnd(1);
+        } catch (Throwable th) {
+            InlineMarker.finallyStart(1);
+            atomicFile.failWrite(startWrite);
+            InlineMarker.finallyEnd(1);
+            throw th;
+        }
+    }
+
+    public static final void writeBytes(android.util.AtomicFile atomicFile, byte[] bArr) {
+        FileOutputStream startWrite = atomicFile.startWrite();
+        try {
+            startWrite.write(bArr);
+            atomicFile.finishWrite(startWrite);
+        } catch (Throwable th) {
+            atomicFile.failWrite(startWrite);
+            throw th;
+        }
+    }
+
+    public static /* synthetic */ void writeText$default(android.util.AtomicFile atomicFile, String str, Charset charset, int i, Object obj) {
+        if ((i & 2) != 0) {
+            charset = Charsets.UTF_8;
+        }
+        writeText(atomicFile, str, charset);
+    }
+
+    public static final void writeText(android.util.AtomicFile atomicFile, String str, Charset charset) {
+        byte[] bytes = str.getBytes(charset);
+        Intrinsics.checkNotNullExpressionValue(bytes, "this as java.lang.String).getBytes(charset)");
+        writeBytes(atomicFile, bytes);
+    }
+
+    public static final byte[] readBytes(android.util.AtomicFile atomicFile) {
+        return atomicFile.readFully();
+    }
+
+    public static /* synthetic */ String readText$default(android.util.AtomicFile atomicFile, Charset charset, int i, Object obj) {
+        if ((i & 1) != 0) {
+            charset = Charsets.UTF_8;
+        }
+        return readText(atomicFile, charset);
+    }
+
+    public static final String readText(android.util.AtomicFile atomicFile, Charset charset) {
+        return new String(atomicFile.readFully(), charset);
+    }
+}

decompiled/sources/androidx/core/util/Consumer.java

@@ -0,0 +1,6 @@
+package androidx.core.util;
+
+/* loaded from: classes.dex */
+public interface Consumer<T> {
+    void accept(T t);
+}

decompiled/sources/androidx/core/util/ConsumerKt.java

@@ -0,0 +1,13 @@
+package androidx.core.util;
+
+import androidx.annotation.RequiresApi;
+import kotlin.coroutines.Continuation;
+
+@RequiresApi(24)
+/* loaded from: classes.dex */
+public final class ConsumerKt {
+    @RequiresApi(24)
+    public static final <T> java.util.function.Consumer<T> asConsumer(Continuation continuation) {
+        return new ContinuationConsumer(continuation);
+    }
+}

decompiled/sources/androidx/core/util/ContinuationConsumer.java

@@ -0,0 +1,29 @@
+package androidx.core.util;
+
+import androidx.annotation.RequiresApi;
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.Result;
+import kotlin.coroutines.Continuation;
+
+@RequiresApi(24)
+/* loaded from: classes.dex */
+final class ContinuationConsumer<T> extends AtomicBoolean implements java.util.function.Consumer<T> {
+    private final Continuation continuation;
+
+    public ContinuationConsumer(Continuation continuation) {
+        super(false);
+        this.continuation = continuation;
+    }
+
+    @Override // java.util.function.Consumer
+    public void accept(T t) {
+        if (compareAndSet(false, true)) {
+            this.continuation.resumeWith(Result.m4060constructorimpl(t));
+        }
+    }
+
+    @Override // java.util.concurrent.atomic.AtomicBoolean
+    public String toString() {
+        return "ContinuationConsumer(resultAccepted = " + get() + ')';
+    }
+}

decompiled/sources/androidx/core/util/ContinuationRunnable.java

@@ -0,0 +1,30 @@
+package androidx.core.util;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.Result;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes.dex */
+final class ContinuationRunnable extends AtomicBoolean implements Runnable {
+    private final Continuation continuation;
+
+    public ContinuationRunnable(Continuation continuation) {
+        super(false);
+        this.continuation = continuation;
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        if (compareAndSet(false, true)) {
+            Continuation continuation = this.continuation;
+            Result.Companion companion = Result.Companion;
+            continuation.resumeWith(Result.m4060constructorimpl(Unit.INSTANCE));
+        }
+    }
+
+    @Override // java.util.concurrent.atomic.AtomicBoolean
+    public String toString() {
+        return "ContinuationRunnable(ran = " + get() + ')';
+    }
+}

decompiled/sources/androidx/core/util/DebugUtils.java

@@ -0,0 +1,25 @@
+package androidx.core.util;
+
+import androidx.annotation.RestrictTo;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public class DebugUtils {
+    public static void buildShortClassTag(Object obj, StringBuilder sb) {
+        int lastIndexOf;
+        if (obj == null) {
+            sb.append("null");
+            return;
+        }
+        String simpleName = obj.getClass().getSimpleName();
+        if (simpleName.length() <= 0 && (lastIndexOf = (simpleName = obj.getClass().getName()).lastIndexOf(46)) > 0) {
+            simpleName = simpleName.substring(lastIndexOf + 1);
+        }
+        sb.append(simpleName);
+        sb.append('{');
+        sb.append(Integer.toHexString(System.identityHashCode(obj)));
+    }
+
+    private DebugUtils() {
+    }
+}

decompiled/sources/androidx/core/util/Function.java

@@ -0,0 +1,6 @@
+package androidx.core.util;
+
+/* loaded from: classes.dex */
+public interface Function<T, R> {
+    R apply(T t);
+}

decompiled/sources/androidx/core/util/HalfKt.java

@@ -0,0 +1,31 @@
+package androidx.core.util;
+
+import android.annotation.SuppressLint;
+import android.util.Half;
+import androidx.annotation.RequiresApi;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SuppressLint({"ClassVerificationFailure"})
+@SourceDebugExtension({"SMAP\nHalf.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Half.kt\nandroidx/core/util/HalfKt\n*L\n1#1,57:1\n42#1:58\n*S KotlinDebug\n*F\n+ 1 Half.kt\nandroidx/core/util/HalfKt\n*L\n49#1:58\n*E\n"})
+/* loaded from: classes.dex */
+public final class HalfKt {
+    @RequiresApi(26)
+    public static final Half toHalf(short s) {
+        return Half.valueOf(s);
+    }
+
+    @RequiresApi(26)
+    public static final Half toHalf(double d) {
+        return Half.valueOf((float) d);
+    }
+
+    @RequiresApi(26)
+    public static final Half toHalf(float f) {
+        return Half.valueOf(f);
+    }
+
+    @RequiresApi(26)
+    public static final Half toHalf(String str) {
+        return Half.valueOf(str);
+    }
+}

decompiled/sources/androidx/core/util/LogWriter.java

@@ -0,0 +1,46 @@
+package androidx.core.util;
+
+import androidx.annotation.RestrictTo;
+import java.io.Writer;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+@Deprecated
+/* loaded from: classes.dex */
+public class LogWriter extends Writer {
+    private StringBuilder mBuilder = new StringBuilder(128);
+    private final String mTag;
+
+    public LogWriter(String str) {
+        this.mTag = str;
+    }
+
+    @Override // java.io.Writer, java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        flushBuilder();
+    }
+
+    @Override // java.io.Writer, java.io.Flushable
+    public void flush() {
+        flushBuilder();
+    }
+
+    @Override // java.io.Writer
+    public void write(char[] cArr, int i, int i2) {
+        for (int i3 = 0; i3 < i2; i3++) {
+            char c = cArr[i + i3];
+            if (c == '\n') {
+                flushBuilder();
+            } else {
+                this.mBuilder.append(c);
+            }
+        }
+    }
+
+    private void flushBuilder() {
+        if (this.mBuilder.length() > 0) {
+            this.mBuilder.toString();
+            StringBuilder sb = this.mBuilder;
+            sb.delete(0, sb.length());
+        }
+    }
+}

decompiled/sources/androidx/core/util/LongSparseArrayKt$valueIterator$1.java

@@ -0,0 +1,42 @@
+package androidx.core.util;
+
+import android.util.LongSparseArray;
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* JADX INFO: Add missing generic type declarations: [T] */
+/* loaded from: classes.dex */
+public final class LongSparseArrayKt$valueIterator$1<T> implements Iterator<T>, KMappedMarker {
+    final /* synthetic */ LongSparseArray<T> $this_valueIterator;
+    private int index;
+
+    public final int getIndex() {
+        return this.index;
+    }
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public final void setIndex(int i) {
+        this.index = i;
+    }
+
+    public LongSparseArrayKt$valueIterator$1(LongSparseArray<T> longSparseArray) {
+        this.$this_valueIterator = longSparseArray;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.$this_valueIterator.size();
+    }
+
+    @Override // java.util.Iterator
+    public T next() {
+        LongSparseArray<T> longSparseArray = this.$this_valueIterator;
+        int i = this.index;
+        this.index = i + 1;
+        return longSparseArray.valueAt(i);
+    }
+}

decompiled/sources/androidx/core/util/LongSparseArrayKt.java

@@ -0,0 +1,112 @@
+package androidx.core.util;
+
+import android.util.LongSparseArray;
+import java.util.Iterator;
+import kotlin.collections.LongIterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nLongSparseArray.kt\nKotlin\n*S Kotlin\n*F\n+ 1 LongSparseArray.kt\nandroidx/core/util/LongSparseArrayKt\n*L\n1#1,101:1\n77#1,4:102\n*S KotlinDebug\n*F\n+ 1 LongSparseArray.kt\nandroidx/core/util/LongSparseArrayKt\n*L\n73#1:102,4\n*E\n"})
+/* loaded from: classes.dex */
+public final class LongSparseArrayKt {
+    public static final <T> int getSize(LongSparseArray<T> longSparseArray) {
+        return longSparseArray.size();
+    }
+
+    public static final <T> boolean contains(LongSparseArray<T> longSparseArray, long j) {
+        return longSparseArray.indexOfKey(j) >= 0;
+    }
+
+    public static final <T> void set(LongSparseArray<T> longSparseArray, long j, T t) {
+        longSparseArray.put(j, t);
+    }
+
+    public static final <T> LongSparseArray<T> plus(LongSparseArray<T> longSparseArray, LongSparseArray<T> longSparseArray2) {
+        LongSparseArray<T> longSparseArray3 = new LongSparseArray<>(longSparseArray.size() + longSparseArray2.size());
+        putAll(longSparseArray3, longSparseArray);
+        putAll(longSparseArray3, longSparseArray2);
+        return longSparseArray3;
+    }
+
+    public static final <T> boolean containsKey(LongSparseArray<T> longSparseArray, long j) {
+        return longSparseArray.indexOfKey(j) >= 0;
+    }
+
+    public static final <T> boolean containsValue(LongSparseArray<T> longSparseArray, T t) {
+        return longSparseArray.indexOfValue(t) >= 0;
+    }
+
+    public static final <T> T getOrDefault(LongSparseArray<T> longSparseArray, long j, T t) {
+        T t2 = longSparseArray.get(j);
+        return t2 == null ? t : t2;
+    }
+
+    public static final <T> T getOrElse(LongSparseArray<T> longSparseArray, long j, Function0 function0) {
+        T t = longSparseArray.get(j);
+        return t == null ? (T) function0.invoke() : t;
+    }
+
+    public static final <T> boolean isEmpty(LongSparseArray<T> longSparseArray) {
+        return longSparseArray.size() == 0;
+    }
+
+    public static final <T> boolean isNotEmpty(LongSparseArray<T> longSparseArray) {
+        return longSparseArray.size() != 0;
+    }
+
+    public static final <T> boolean remove(LongSparseArray<T> longSparseArray, long j, T t) {
+        int indexOfKey = longSparseArray.indexOfKey(j);
+        if (indexOfKey < 0 || !Intrinsics.areEqual(t, longSparseArray.valueAt(indexOfKey))) {
+            return false;
+        }
+        longSparseArray.removeAt(indexOfKey);
+        return true;
+    }
+
+    public static final <T> void forEach(LongSparseArray<T> longSparseArray, Function2 function2) {
+        int size = longSparseArray.size();
+        for (int i = 0; i < size; i++) {
+            function2.invoke(Long.valueOf(longSparseArray.keyAt(i)), longSparseArray.valueAt(i));
+        }
+    }
+
+    public static final <T> void putAll(LongSparseArray<T> longSparseArray, LongSparseArray<T> longSparseArray2) {
+        int size = longSparseArray2.size();
+        for (int i = 0; i < size; i++) {
+            longSparseArray.put(longSparseArray2.keyAt(i), longSparseArray2.valueAt(i));
+        }
+    }
+
+    public static final <T> LongIterator keyIterator(final LongSparseArray<T> longSparseArray) {
+        return new LongIterator() { // from class: androidx.core.util.LongSparseArrayKt$keyIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < longSparseArray.size();
+            }
+
+            @Override // kotlin.collections.LongIterator
+            public long nextLong() {
+                LongSparseArray<T> longSparseArray2 = longSparseArray;
+                int i = this.index;
+                this.index = i + 1;
+                return longSparseArray2.keyAt(i);
+            }
+        };
+    }
+
+    public static final <T> Iterator<T> valueIterator(LongSparseArray<T> longSparseArray) {
+        return new LongSparseArrayKt$valueIterator$1(longSparseArray);
+    }
+}

decompiled/sources/androidx/core/util/LruCacheKt$lruCache$4.java

@@ -0,0 +1,37 @@
+package androidx.core.util;
+
+import android.util.LruCache;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function4;
+
+/* JADX INFO: Add missing generic type declarations: [V, K] */
+/* loaded from: classes.dex */
+public final class LruCacheKt$lruCache$4<K, V> extends LruCache<K, V> {
+    final /* synthetic */ Function1 $create;
+    final /* synthetic */ Function4 $onEntryRemoved;
+    final /* synthetic */ Function2 $sizeOf;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public LruCacheKt$lruCache$4(int i, Function2 function2, Function1 function1, Function4 function4) {
+        super(i);
+        this.$sizeOf = function2;
+        this.$create = function1;
+        this.$onEntryRemoved = function4;
+    }
+
+    @Override // android.util.LruCache
+    public int sizeOf(K k, V v) {
+        return ((Number) this.$sizeOf.invoke(k, v)).intValue();
+    }
+
+    @Override // android.util.LruCache
+    public V create(K k) {
+        return (V) this.$create.invoke(k);
+    }
+
+    @Override // android.util.LruCache
+    public void entryRemoved(boolean z, K k, V v, V v2) {
+        this.$onEntryRemoved.invoke(Boolean.valueOf(z), k, v, v2);
+    }
+}

decompiled/sources/androidx/core/util/LruCacheKt.java

@@ -0,0 +1,46 @@
+package androidx.core.util;
+
+import android.util.LruCache;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function4;
+
+/* loaded from: classes.dex */
+public final class LruCacheKt {
+    public static final <K, V> LruCache<K, V> lruCache(int i, Function2 function2, Function1 function1, Function4 function4) {
+        return new LruCacheKt$lruCache$4(i, function2, function1, function4);
+    }
+
+    public static /* synthetic */ LruCache lruCache$default(int i, Function2 function2, Function1 function1, Function4 function4, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            function2 = new Function2() { // from class: androidx.core.util.LruCacheKt$lruCache$1
+                @Override // kotlin.jvm.functions.Function2
+                public final Integer invoke(Object obj2, Object obj3) {
+                    return 1;
+                }
+            };
+        }
+        if ((i2 & 4) != 0) {
+            function1 = new Function1() { // from class: androidx.core.util.LruCacheKt$lruCache$2
+                @Override // kotlin.jvm.functions.Function1
+                public final Object invoke(Object obj2) {
+                    return null;
+                }
+            };
+        }
+        if ((i2 & 8) != 0) {
+            function4 = new Function4() { // from class: androidx.core.util.LruCacheKt$lruCache$3
+                public final void invoke(boolean z, Object obj2, Object obj3, Object obj4) {
+                }
+
+                @Override // kotlin.jvm.functions.Function4
+                public /* bridge */ /* synthetic */ Object invoke(Object obj2, Object obj3, Object obj4, Object obj5) {
+                    invoke(((Boolean) obj2).booleanValue(), obj3, obj4, obj5);
+                    return Unit.INSTANCE;
+                }
+            };
+        }
+        return new LruCacheKt$lruCache$4(i, function2, function1, function4);
+    }
+}

decompiled/sources/androidx/core/util/ObjectsCompat.java

@@ -0,0 +1,45 @@
+package androidx.core.util;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.Objects;
+
+/* loaded from: classes.dex */
+public class ObjectsCompat {
+    private ObjectsCompat() {
+    }
+
+    public static boolean equals(@Nullable Object obj, @Nullable Object obj2) {
+        return Objects.equals(obj, obj2);
+    }
+
+    public static int hashCode(@Nullable Object obj) {
+        if (obj != null) {
+            return obj.hashCode();
+        }
+        return 0;
+    }
+
+    public static int hash(@Nullable Object... objArr) {
+        return Objects.hash(objArr);
+    }
+
+    @Nullable
+    public static String toString(@Nullable Object obj, @Nullable String str) {
+        return obj != null ? obj.toString() : str;
+    }
+
+    @NonNull
+    public static <T> T requireNonNull(@Nullable T t) {
+        t.getClass();
+        return t;
+    }
+
+    @NonNull
+    public static <T> T requireNonNull(@Nullable T t, @NonNull String str) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(str);
+    }
+}

decompiled/sources/androidx/core/util/Pair.java

@@ -0,0 +1,39 @@
+package androidx.core.util;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public class Pair<F, S> {
+    public final F first;
+    public final S second;
+
+    public Pair(F f, S s) {
+        this.first = f;
+        this.second = s;
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Pair)) {
+            return false;
+        }
+        Pair pair = (Pair) obj;
+        return ObjectsCompat.equals(pair.first, this.first) && ObjectsCompat.equals(pair.second, this.second);
+    }
+
+    public int hashCode() {
+        F f = this.first;
+        int hashCode = f == null ? 0 : f.hashCode();
+        S s = this.second;
+        return hashCode ^ (s != null ? s.hashCode() : 0);
+    }
+
+    @NonNull
+    public String toString() {
+        return "Pair{" + this.first + " " + this.second + "}";
+    }
+
+    @NonNull
+    public static <A, B> Pair<A, B> create(A a, B b) {
+        return new Pair<>(a, b);
+    }
+}

decompiled/sources/androidx/core/util/PairKt.java

@@ -0,0 +1,42 @@
+package androidx.core.util;
+
+import android.annotation.SuppressLint;
+
+/* loaded from: classes.dex */
+public final class PairKt {
+    @SuppressLint({"UnknownNullness"})
+    public static final <F, S> F component1(Pair<F, S> pair) {
+        return pair.first;
+    }
+
+    @SuppressLint({"UnknownNullness"})
+    public static final <F, S> S component2(Pair<F, S> pair) {
+        return pair.second;
+    }
+
+    public static final <F, S> kotlin.Pair toKotlinPair(Pair<F, S> pair) {
+        return new kotlin.Pair(pair.first, pair.second);
+    }
+
+    public static final <F, S> Pair<F, S> toAndroidXPair(kotlin.Pair pair) {
+        return new Pair<>(pair.getFirst(), pair.getSecond());
+    }
+
+    @SuppressLint({"UnknownNullness"})
+    public static final <F, S> F component1(android.util.Pair<F, S> pair) {
+        return (F) pair.first;
+    }
+
+    @SuppressLint({"UnknownNullness"})
+    public static final <F, S> S component2(android.util.Pair<F, S> pair) {
+        return (S) pair.second;
+    }
+
+    public static final <F, S> kotlin.Pair toKotlinPair(android.util.Pair<F, S> pair) {
+        return new kotlin.Pair(pair.first, pair.second);
+    }
+
+    public static final <F, S> android.util.Pair<F, S> toAndroidPair(kotlin.Pair pair) {
+        return new android.util.Pair<>(pair.getFirst(), pair.getSecond());
+    }
+}

decompiled/sources/androidx/core/util/Pools.java

@@ -0,0 +1,99 @@
+package androidx.core.util;
+
+import androidx.annotation.IntRange;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+/* loaded from: classes.dex */
+public final class Pools {
+
+    public interface Pool<T> {
+        T acquire();
+
+        boolean release(T t);
+    }
+
+    private Pools() {
+    }
+
+    @SourceDebugExtension({"SMAP\nPools.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Pools.kt\nandroidx/core/util/Pools$SimplePool\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,133:1\n1#2:134\n*E\n"})
+    public static class SimplePool<T> implements Pool<T> {
+        private final Object[] pool;
+        private int poolSize;
+
+        public SimplePool(@IntRange(from = 1) int i) {
+            if (i <= 0) {
+                throw new IllegalArgumentException("The max pool size must be > 0".toString());
+            }
+            this.pool = new Object[i];
+        }
+
+        @Override // androidx.core.util.Pools.Pool
+        public T acquire() {
+            int i = this.poolSize;
+            if (i <= 0) {
+                return null;
+            }
+            int i2 = i - 1;
+            T t = (T) this.pool[i2];
+            Intrinsics.checkNotNull(t, "null cannot be cast to non-null type T of androidx.core.util.Pools.SimplePool");
+            this.pool[i2] = null;
+            this.poolSize--;
+            return t;
+        }
+
+        @Override // androidx.core.util.Pools.Pool
+        public boolean release(T instance) {
+            Intrinsics.checkNotNullParameter(instance, "instance");
+            if (!(!isInPool(instance))) {
+                throw new IllegalStateException("Already in the pool!".toString());
+            }
+            int i = this.poolSize;
+            Object[] objArr = this.pool;
+            if (i >= objArr.length) {
+                return false;
+            }
+            objArr[i] = instance;
+            this.poolSize = i + 1;
+            return true;
+        }
+
+        private final boolean isInPool(T t) {
+            int i = this.poolSize;
+            for (int i2 = 0; i2 < i; i2++) {
+                if (this.pool[i2] == t) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    public static class SynchronizedPool<T> extends SimplePool<T> {
+        private final Object lock;
+
+        public SynchronizedPool(int i) {
+            super(i);
+            this.lock = new Object();
+        }
+
+        @Override // androidx.core.util.Pools.SimplePool, androidx.core.util.Pools.Pool
+        public T acquire() {
+            T t;
+            synchronized (this.lock) {
+                t = (T) super.acquire();
+            }
+            return t;
+        }
+
+        @Override // androidx.core.util.Pools.SimplePool, androidx.core.util.Pools.Pool
+        public boolean release(T instance) {
+            boolean release;
+            Intrinsics.checkNotNullParameter(instance, "instance");
+            synchronized (this.lock) {
+                release = super.release(instance);
+            }
+            return release;
+        }
+    }
+}

decompiled/sources/androidx/core/util/Preconditions.java

@@ -0,0 +1,154 @@
+package androidx.core.util;
+
+import android.text.TextUtils;
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import java.util.Locale;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class Preconditions {
+    public static void checkArgument(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void checkArgument(boolean z, @NonNull Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(String.valueOf(obj));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NonNull String str, @NonNull Object... objArr) {
+        if (!z) {
+            throw new IllegalArgumentException(String.format(str, objArr));
+        }
+    }
+
+    @NonNull
+    public static <T extends CharSequence> T checkStringNotEmpty(@Nullable T t) {
+        if (TextUtils.isEmpty(t)) {
+            throw new IllegalArgumentException();
+        }
+        return t;
+    }
+
+    @NonNull
+    public static <T extends CharSequence> T checkStringNotEmpty(@Nullable T t, @NonNull Object obj) {
+        if (TextUtils.isEmpty(t)) {
+            throw new IllegalArgumentException(String.valueOf(obj));
+        }
+        return t;
+    }
+
+    @NonNull
+    public static <T extends CharSequence> T checkStringNotEmpty(@Nullable T t, @NonNull String str, @NonNull Object... objArr) {
+        if (TextUtils.isEmpty(t)) {
+            throw new IllegalArgumentException(String.format(str, objArr));
+        }
+        return t;
+    }
+
+    @NonNull
+    public static <T> T checkNotNull(@Nullable T t) {
+        t.getClass();
+        return t;
+    }
+
+    @NonNull
+    public static <T> T checkNotNull(@Nullable T t, @NonNull Object obj) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(String.valueOf(obj));
+    }
+
+    public static void checkState(boolean z, @Nullable String str) {
+        if (!z) {
+            throw new IllegalStateException(str);
+        }
+    }
+
+    public static void checkState(boolean z) {
+        checkState(z, null);
+    }
+
+    public static int checkFlagsArgument(int i, int i2) {
+        if ((i & i2) == i) {
+            return i;
+        }
+        throw new IllegalArgumentException("Requested flags 0x" + Integer.toHexString(i) + ", but only 0x" + Integer.toHexString(i2) + " are allowed");
+    }
+
+    @IntRange(from = 0)
+    public static int checkArgumentNonnegative(int i, @Nullable String str) {
+        if (i >= 0) {
+            return i;
+        }
+        throw new IllegalArgumentException(str);
+    }
+
+    @IntRange(from = 0)
+    public static int checkArgumentNonnegative(int i) {
+        if (i >= 0) {
+            return i;
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public static int checkArgumentInRange(int i, int i2, int i3, @NonNull String str) {
+        if (i < i2) {
+            throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%d, %d] (too low)", str, Integer.valueOf(i2), Integer.valueOf(i3)));
+        }
+        if (i <= i3) {
+            return i;
+        }
+        throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%d, %d] (too high)", str, Integer.valueOf(i2), Integer.valueOf(i3)));
+    }
+
+    public static long checkArgumentInRange(long j, long j2, long j3, @NonNull String str) {
+        if (j < j2) {
+            throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%d, %d] (too low)", str, Long.valueOf(j2), Long.valueOf(j3)));
+        }
+        if (j <= j3) {
+            return j;
+        }
+        throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%d, %d] (too high)", str, Long.valueOf(j2), Long.valueOf(j3)));
+    }
+
+    public static float checkArgumentInRange(float f, float f2, float f3, @NonNull String str) {
+        if (f < f2) {
+            throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%f, %f] (too low)", str, Float.valueOf(f2), Float.valueOf(f3)));
+        }
+        if (f <= f3) {
+            return f;
+        }
+        throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%f, %f] (too high)", str, Float.valueOf(f2), Float.valueOf(f3)));
+    }
+
+    public static double checkArgumentInRange(double d, double d2, double d3, @NonNull String str) {
+        if (d < d2) {
+            throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%f, %f] (too low)", str, Double.valueOf(d2), Double.valueOf(d3)));
+        }
+        if (d <= d3) {
+            return d;
+        }
+        throw new IllegalArgumentException(String.format(Locale.US, "%s is out of range of [%f, %f] (too high)", str, Double.valueOf(d2), Double.valueOf(d3)));
+    }
+
+    public static float checkArgumentFinite(float f, @NonNull String str) {
+        if (Float.isNaN(f)) {
+            throw new IllegalArgumentException(str + " must not be NaN");
+        }
+        if (!Float.isInfinite(f)) {
+            return f;
+        }
+        throw new IllegalArgumentException(str + " must not be infinite");
+    }
+
+    private Preconditions() {
+    }
+}

decompiled/sources/androidx/core/util/Predicate.java

@@ -0,0 +1,94 @@
+package androidx.core.util;
+
+import android.annotation.SuppressLint;
+import java.util.Objects;
+
+@SuppressLint({"UnknownNullness"})
+/* loaded from: classes.dex */
+public interface Predicate<T> {
+    boolean test(T t);
+
+    @SuppressLint({"MissingNullability"})
+    default Predicate<T> and(@SuppressLint({"MissingNullability"}) final Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        return new Predicate() { // from class: androidx.core.util.Predicate$$ExternalSyntheticLambda3
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$and$0;
+                lambda$and$0 = Predicate.this.lambda$and$0(predicate, obj);
+                return lambda$and$0;
+            }
+        };
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* synthetic */ default boolean lambda$and$0(Predicate predicate, Object obj) {
+        return test(obj) && predicate.test(obj);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* synthetic */ default boolean lambda$negate$1(Object obj) {
+        return !test(obj);
+    }
+
+    @SuppressLint({"MissingNullability"})
+    default Predicate<T> negate() {
+        return new Predicate() { // from class: androidx.core.util.Predicate$$ExternalSyntheticLambda4
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$negate$1;
+                lambda$negate$1 = Predicate.this.lambda$negate$1(obj);
+                return lambda$negate$1;
+            }
+        };
+    }
+
+    @SuppressLint({"MissingNullability"})
+    default Predicate<T> or(@SuppressLint({"MissingNullability"}) final Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        return new Predicate() { // from class: androidx.core.util.Predicate$$ExternalSyntheticLambda0
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$or$2;
+                lambda$or$2 = Predicate.this.lambda$or$2(predicate, obj);
+                return lambda$or$2;
+            }
+        };
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Multi-variable type inference failed */
+    /* synthetic */ default boolean lambda$or$2(Predicate predicate, Object obj) {
+        return test(obj) || predicate.test(obj);
+    }
+
+    @SuppressLint({"MissingNullability"})
+    static <T> Predicate<T> isEqual(@SuppressLint({"MissingNullability"}) final Object obj) {
+        if (obj == null) {
+            return new Predicate() { // from class: androidx.core.util.Predicate$$ExternalSyntheticLambda1
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj2) {
+                    boolean isNull;
+                    isNull = Objects.isNull(obj2);
+                    return isNull;
+                }
+            };
+        }
+        return new Predicate() { // from class: androidx.core.util.Predicate$$ExternalSyntheticLambda2
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj2) {
+                boolean equals;
+                equals = obj.equals(obj2);
+                return equals;
+            }
+        };
+    }
+
+    @SuppressLint({"MissingNullability"})
+    static <T> Predicate<T> not(@SuppressLint({"MissingNullability"}) Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        return predicate.negate();
+    }
+}

decompiled/sources/androidx/core/util/RangeKt.java

@@ -0,0 +1,61 @@
+package androidx.core.util;
+
+import android.annotation.SuppressLint;
+import android.util.Range;
+import androidx.annotation.RequiresApi;
+import kotlin.ranges.ClosedRange;
+
+@SuppressLint({"ClassVerificationFailure"})
+/* loaded from: classes.dex */
+public final class RangeKt {
+    @RequiresApi(21)
+    public static final <T extends Comparable<? super T>> Range<T> rangeTo(T t, T t2) {
+        return new Range<>(t, t2);
+    }
+
+    @RequiresApi(21)
+    public static final <T extends Comparable<? super T>> Range<T> plus(Range<T> range, T t) {
+        return range.extend((Range<T>) t);
+    }
+
+    @RequiresApi(21)
+    public static final <T extends Comparable<? super T>> Range<T> plus(Range<T> range, Range<T> range2) {
+        return range.extend(range2);
+    }
+
+    @RequiresApi(21)
+    public static final <T extends Comparable<? super T>> Range<T> and(Range<T> range, Range<T> range2) {
+        return range.intersect(range2);
+    }
+
+    @RequiresApi(21)
+    public static final <T extends Comparable<? super T>> ClosedRange toClosedRange(final Range<T> range) {
+        return new ClosedRange() { // from class: androidx.core.util.RangeKt$toClosedRange$1
+            /* JADX WARN: Incorrect types in method signature: (TT;)Z */
+            public boolean contains(Comparable comparable) {
+                return ClosedRange.DefaultImpls.contains(this, comparable);
+            }
+
+            public boolean isEmpty() {
+                return ClosedRange.DefaultImpls.isEmpty(this);
+            }
+
+            /* JADX WARN: Incorrect return type in method signature: ()TT; */
+            @Override // kotlin.ranges.ClosedRange
+            public Comparable getEndInclusive() {
+                return range.getUpper();
+            }
+
+            /* JADX WARN: Incorrect return type in method signature: ()TT; */
+            @Override // kotlin.ranges.ClosedRange
+            public Comparable getStart() {
+                return range.getLower();
+            }
+        };
+    }
+
+    @RequiresApi(21)
+    public static final <T extends Comparable<? super T>> Range<T> toRange(ClosedRange closedRange) {
+        return new Range<>(closedRange.getStart(), closedRange.getEndInclusive());
+    }
+}

decompiled/sources/androidx/core/util/RunnableKt.java

@@ -0,0 +1,10 @@
+package androidx.core.util;
+
+import kotlin.coroutines.Continuation;
+
+/* loaded from: classes.dex */
+public final class RunnableKt {
+    public static final Runnable asRunnable(Continuation continuation) {
+        return new ContinuationRunnable(continuation);
+    }
+}

decompiled/sources/androidx/core/util/SizeFCompat.java

@@ -0,0 +1,74 @@
+package androidx.core.util;
+
+import android.util.SizeF;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public final class SizeFCompat {
+    private final float mHeight;
+    private final float mWidth;
+
+    public float getHeight() {
+        return this.mHeight;
+    }
+
+    public float getWidth() {
+        return this.mWidth;
+    }
+
+    public SizeFCompat(float f, float f2) {
+        this.mWidth = Preconditions.checkArgumentFinite(f, "width");
+        this.mHeight = Preconditions.checkArgumentFinite(f2, "height");
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof SizeFCompat)) {
+            return false;
+        }
+        SizeFCompat sizeFCompat = (SizeFCompat) obj;
+        return sizeFCompat.mWidth == this.mWidth && sizeFCompat.mHeight == this.mHeight;
+    }
+
+    public int hashCode() {
+        return Float.floatToIntBits(this.mWidth) ^ Float.floatToIntBits(this.mHeight);
+    }
+
+    @NonNull
+    public String toString() {
+        return this.mWidth + "x" + this.mHeight;
+    }
+
+    @NonNull
+    @RequiresApi(21)
+    public SizeF toSizeF() {
+        return Api21Impl.toSizeF(this);
+    }
+
+    @NonNull
+    @RequiresApi(21)
+    public static SizeFCompat toSizeFCompat(@NonNull SizeF sizeF) {
+        return Api21Impl.toSizeFCompat(sizeF);
+    }
+
+    @RequiresApi(21)
+    public static final class Api21Impl {
+        private Api21Impl() {
+        }
+
+        @NonNull
+        public static SizeFCompat toSizeFCompat(@NonNull SizeF sizeF) {
+            Preconditions.checkNotNull(sizeF);
+            return new SizeFCompat(sizeF.getWidth(), sizeF.getHeight());
+        }
+
+        @NonNull
+        public static SizeF toSizeF(@NonNull SizeFCompat sizeFCompat) {
+            Preconditions.checkNotNull(sizeFCompat);
+            return new SizeF(sizeFCompat.getWidth(), sizeFCompat.getHeight());
+        }
+    }
+}

decompiled/sources/androidx/core/util/SizeKt.java

@@ -0,0 +1,38 @@
+package androidx.core.util;
+
+import android.annotation.SuppressLint;
+import android.util.Size;
+import android.util.SizeF;
+import androidx.annotation.RequiresApi;
+
+@SuppressLint({"ClassVerificationFailure"})
+/* loaded from: classes.dex */
+public final class SizeKt {
+    @RequiresApi(21)
+    public static final int component1(Size size) {
+        return size.getWidth();
+    }
+
+    @RequiresApi(21)
+    public static final int component2(Size size) {
+        return size.getHeight();
+    }
+
+    @RequiresApi(21)
+    public static final float component1(SizeF sizeF) {
+        return sizeF.getWidth();
+    }
+
+    @RequiresApi(21)
+    public static final float component2(SizeF sizeF) {
+        return sizeF.getHeight();
+    }
+
+    public static final float component1(SizeFCompat sizeFCompat) {
+        return sizeFCompat.getWidth();
+    }
+
+    public static final float component2(SizeFCompat sizeFCompat) {
+        return sizeFCompat.getHeight();
+    }
+}

decompiled/sources/androidx/core/util/SparseArrayKt$valueIterator$1.java

@@ -0,0 +1,42 @@
+package androidx.core.util;
+
+import android.util.SparseArray;
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* JADX INFO: Add missing generic type declarations: [T] */
+/* loaded from: classes.dex */
+public final class SparseArrayKt$valueIterator$1<T> implements Iterator<T>, KMappedMarker {
+    final /* synthetic */ SparseArray<T> $this_valueIterator;
+    private int index;
+
+    public final int getIndex() {
+        return this.index;
+    }
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public final void setIndex(int i) {
+        this.index = i;
+    }
+
+    public SparseArrayKt$valueIterator$1(SparseArray<T> sparseArray) {
+        this.$this_valueIterator = sparseArray;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.$this_valueIterator.size();
+    }
+
+    @Override // java.util.Iterator
+    public T next() {
+        SparseArray<T> sparseArray = this.$this_valueIterator;
+        int i = this.index;
+        this.index = i + 1;
+        return sparseArray.valueAt(i);
+    }
+}

decompiled/sources/androidx/core/util/SparseArrayKt.java

@@ -0,0 +1,112 @@
+package androidx.core.util;
+
+import android.util.SparseArray;
+import java.util.Iterator;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nSparseArray.kt\nKotlin\n*S Kotlin\n*F\n+ 1 SparseArray.kt\nandroidx/core/util/SparseArrayKt\n*L\n1#1,101:1\n77#1,4:102\n*S KotlinDebug\n*F\n+ 1 SparseArray.kt\nandroidx/core/util/SparseArrayKt\n*L\n73#1:102,4\n*E\n"})
+/* loaded from: classes.dex */
+public final class SparseArrayKt {
+    public static final <T> int getSize(SparseArray<T> sparseArray) {
+        return sparseArray.size();
+    }
+
+    public static final <T> boolean contains(SparseArray<T> sparseArray, int i) {
+        return sparseArray.indexOfKey(i) >= 0;
+    }
+
+    public static final <T> void set(SparseArray<T> sparseArray, int i, T t) {
+        sparseArray.put(i, t);
+    }
+
+    public static final <T> SparseArray<T> plus(SparseArray<T> sparseArray, SparseArray<T> sparseArray2) {
+        SparseArray<T> sparseArray3 = new SparseArray<>(sparseArray.size() + sparseArray2.size());
+        putAll(sparseArray3, sparseArray);
+        putAll(sparseArray3, sparseArray2);
+        return sparseArray3;
+    }
+
+    public static final <T> boolean containsKey(SparseArray<T> sparseArray, int i) {
+        return sparseArray.indexOfKey(i) >= 0;
+    }
+
+    public static final <T> boolean containsValue(SparseArray<T> sparseArray, T t) {
+        return sparseArray.indexOfValue(t) >= 0;
+    }
+
+    public static final <T> T getOrDefault(SparseArray<T> sparseArray, int i, T t) {
+        T t2 = sparseArray.get(i);
+        return t2 == null ? t : t2;
+    }
+
+    public static final <T> T getOrElse(SparseArray<T> sparseArray, int i, Function0 function0) {
+        T t = sparseArray.get(i);
+        return t == null ? (T) function0.invoke() : t;
+    }
+
+    public static final <T> boolean isEmpty(SparseArray<T> sparseArray) {
+        return sparseArray.size() == 0;
+    }
+
+    public static final <T> boolean isNotEmpty(SparseArray<T> sparseArray) {
+        return sparseArray.size() != 0;
+    }
+
+    public static final <T> boolean remove(SparseArray<T> sparseArray, int i, T t) {
+        int indexOfKey = sparseArray.indexOfKey(i);
+        if (indexOfKey < 0 || !Intrinsics.areEqual(t, sparseArray.valueAt(indexOfKey))) {
+            return false;
+        }
+        sparseArray.removeAt(indexOfKey);
+        return true;
+    }
+
+    public static final <T> void forEach(SparseArray<T> sparseArray, Function2 function2) {
+        int size = sparseArray.size();
+        for (int i = 0; i < size; i++) {
+            function2.invoke(Integer.valueOf(sparseArray.keyAt(i)), sparseArray.valueAt(i));
+        }
+    }
+
+    public static final <T> void putAll(SparseArray<T> sparseArray, SparseArray<T> sparseArray2) {
+        int size = sparseArray2.size();
+        for (int i = 0; i < size; i++) {
+            sparseArray.put(sparseArray2.keyAt(i), sparseArray2.valueAt(i));
+        }
+    }
+
+    public static final <T> IntIterator keyIterator(final SparseArray<T> sparseArray) {
+        return new IntIterator() { // from class: androidx.core.util.SparseArrayKt$keyIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < sparseArray.size();
+            }
+
+            @Override // kotlin.collections.IntIterator
+            public int nextInt() {
+                SparseArray<T> sparseArray2 = sparseArray;
+                int i = this.index;
+                this.index = i + 1;
+                return sparseArray2.keyAt(i);
+            }
+        };
+    }
+
+    public static final <T> Iterator<T> valueIterator(SparseArray<T> sparseArray) {
+        return new SparseArrayKt$valueIterator$1(sparseArray);
+    }
+}

decompiled/sources/androidx/core/util/SparseBooleanArrayKt.java

@@ -0,0 +1,133 @@
+package androidx.core.util;
+
+import android.util.SparseBooleanArray;
+import kotlin.collections.BooleanIterator;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nSparseBooleanArray.kt\nKotlin\n*S Kotlin\n*F\n+ 1 SparseBooleanArray.kt\nandroidx/core/util/SparseBooleanArrayKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,102:1\n78#1,4:104\n1#2:103\n*S KotlinDebug\n*F\n+ 1 SparseBooleanArray.kt\nandroidx/core/util/SparseBooleanArrayKt\n*L\n74#1:104,4\n*E\n"})
+/* loaded from: classes.dex */
+public final class SparseBooleanArrayKt {
+    public static final int getSize(SparseBooleanArray sparseBooleanArray) {
+        return sparseBooleanArray.size();
+    }
+
+    public static final boolean contains(SparseBooleanArray sparseBooleanArray, int i) {
+        return sparseBooleanArray.indexOfKey(i) >= 0;
+    }
+
+    public static final void set(SparseBooleanArray sparseBooleanArray, int i, boolean z) {
+        sparseBooleanArray.put(i, z);
+    }
+
+    public static final SparseBooleanArray plus(SparseBooleanArray sparseBooleanArray, SparseBooleanArray sparseBooleanArray2) {
+        SparseBooleanArray sparseBooleanArray3 = new SparseBooleanArray(sparseBooleanArray.size() + sparseBooleanArray2.size());
+        putAll(sparseBooleanArray3, sparseBooleanArray);
+        putAll(sparseBooleanArray3, sparseBooleanArray2);
+        return sparseBooleanArray3;
+    }
+
+    public static final boolean containsKey(SparseBooleanArray sparseBooleanArray, int i) {
+        return sparseBooleanArray.indexOfKey(i) >= 0;
+    }
+
+    public static final boolean containsValue(SparseBooleanArray sparseBooleanArray, boolean z) {
+        return sparseBooleanArray.indexOfValue(z) >= 0;
+    }
+
+    public static final boolean getOrDefault(SparseBooleanArray sparseBooleanArray, int i, boolean z) {
+        return sparseBooleanArray.get(i, z);
+    }
+
+    public static final boolean getOrElse(SparseBooleanArray sparseBooleanArray, int i, Function0 function0) {
+        int indexOfKey = sparseBooleanArray.indexOfKey(i);
+        return indexOfKey >= 0 ? sparseBooleanArray.valueAt(indexOfKey) : ((Boolean) function0.invoke()).booleanValue();
+    }
+
+    public static final boolean isEmpty(SparseBooleanArray sparseBooleanArray) {
+        return sparseBooleanArray.size() == 0;
+    }
+
+    public static final boolean isNotEmpty(SparseBooleanArray sparseBooleanArray) {
+        return sparseBooleanArray.size() != 0;
+    }
+
+    public static final boolean remove(SparseBooleanArray sparseBooleanArray, int i, boolean z) {
+        int indexOfKey = sparseBooleanArray.indexOfKey(i);
+        if (indexOfKey < 0 || z != sparseBooleanArray.valueAt(indexOfKey)) {
+            return false;
+        }
+        sparseBooleanArray.delete(i);
+        return true;
+    }
+
+    public static final void forEach(SparseBooleanArray sparseBooleanArray, Function2 function2) {
+        int size = sparseBooleanArray.size();
+        for (int i = 0; i < size; i++) {
+            function2.invoke(Integer.valueOf(sparseBooleanArray.keyAt(i)), Boolean.valueOf(sparseBooleanArray.valueAt(i)));
+        }
+    }
+
+    public static final void putAll(SparseBooleanArray sparseBooleanArray, SparseBooleanArray sparseBooleanArray2) {
+        int size = sparseBooleanArray2.size();
+        for (int i = 0; i < size; i++) {
+            sparseBooleanArray.put(sparseBooleanArray2.keyAt(i), sparseBooleanArray2.valueAt(i));
+        }
+    }
+
+    public static final IntIterator keyIterator(final SparseBooleanArray sparseBooleanArray) {
+        return new IntIterator() { // from class: androidx.core.util.SparseBooleanArrayKt$keyIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < sparseBooleanArray.size();
+            }
+
+            @Override // kotlin.collections.IntIterator
+            public int nextInt() {
+                SparseBooleanArray sparseBooleanArray2 = sparseBooleanArray;
+                int i = this.index;
+                this.index = i + 1;
+                return sparseBooleanArray2.keyAt(i);
+            }
+        };
+    }
+
+    public static final BooleanIterator valueIterator(final SparseBooleanArray sparseBooleanArray) {
+        return new BooleanIterator() { // from class: androidx.core.util.SparseBooleanArrayKt$valueIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < sparseBooleanArray.size();
+            }
+
+            @Override // kotlin.collections.BooleanIterator
+            public boolean nextBoolean() {
+                SparseBooleanArray sparseBooleanArray2 = sparseBooleanArray;
+                int i = this.index;
+                this.index = i + 1;
+                return sparseBooleanArray2.valueAt(i);
+            }
+        };
+    }
+}

decompiled/sources/androidx/core/util/SparseIntArrayKt.java

@@ -0,0 +1,132 @@
+package androidx.core.util;
+
+import android.util.SparseIntArray;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nSparseIntArray.kt\nKotlin\n*S Kotlin\n*F\n+ 1 SparseIntArray.kt\nandroidx/core/util/SparseIntArrayKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,100:1\n76#1,4:102\n1#2:101\n*S KotlinDebug\n*F\n+ 1 SparseIntArray.kt\nandroidx/core/util/SparseIntArrayKt\n*L\n72#1:102,4\n*E\n"})
+/* loaded from: classes.dex */
+public final class SparseIntArrayKt {
+    public static final int getSize(SparseIntArray sparseIntArray) {
+        return sparseIntArray.size();
+    }
+
+    public static final boolean contains(SparseIntArray sparseIntArray, int i) {
+        return sparseIntArray.indexOfKey(i) >= 0;
+    }
+
+    public static final void set(SparseIntArray sparseIntArray, int i, int i2) {
+        sparseIntArray.put(i, i2);
+    }
+
+    public static final SparseIntArray plus(SparseIntArray sparseIntArray, SparseIntArray sparseIntArray2) {
+        SparseIntArray sparseIntArray3 = new SparseIntArray(sparseIntArray.size() + sparseIntArray2.size());
+        putAll(sparseIntArray3, sparseIntArray);
+        putAll(sparseIntArray3, sparseIntArray2);
+        return sparseIntArray3;
+    }
+
+    public static final boolean containsKey(SparseIntArray sparseIntArray, int i) {
+        return sparseIntArray.indexOfKey(i) >= 0;
+    }
+
+    public static final boolean containsValue(SparseIntArray sparseIntArray, int i) {
+        return sparseIntArray.indexOfValue(i) >= 0;
+    }
+
+    public static final int getOrDefault(SparseIntArray sparseIntArray, int i, int i2) {
+        return sparseIntArray.get(i, i2);
+    }
+
+    public static final int getOrElse(SparseIntArray sparseIntArray, int i, Function0 function0) {
+        int indexOfKey = sparseIntArray.indexOfKey(i);
+        return indexOfKey >= 0 ? sparseIntArray.valueAt(indexOfKey) : ((Number) function0.invoke()).intValue();
+    }
+
+    public static final boolean isEmpty(SparseIntArray sparseIntArray) {
+        return sparseIntArray.size() == 0;
+    }
+
+    public static final boolean isNotEmpty(SparseIntArray sparseIntArray) {
+        return sparseIntArray.size() != 0;
+    }
+
+    public static final boolean remove(SparseIntArray sparseIntArray, int i, int i2) {
+        int indexOfKey = sparseIntArray.indexOfKey(i);
+        if (indexOfKey < 0 || i2 != sparseIntArray.valueAt(indexOfKey)) {
+            return false;
+        }
+        sparseIntArray.removeAt(indexOfKey);
+        return true;
+    }
+
+    public static final void forEach(SparseIntArray sparseIntArray, Function2 function2) {
+        int size = sparseIntArray.size();
+        for (int i = 0; i < size; i++) {
+            function2.invoke(Integer.valueOf(sparseIntArray.keyAt(i)), Integer.valueOf(sparseIntArray.valueAt(i)));
+        }
+    }
+
+    public static final void putAll(SparseIntArray sparseIntArray, SparseIntArray sparseIntArray2) {
+        int size = sparseIntArray2.size();
+        for (int i = 0; i < size; i++) {
+            sparseIntArray.put(sparseIntArray2.keyAt(i), sparseIntArray2.valueAt(i));
+        }
+    }
+
+    public static final IntIterator keyIterator(final SparseIntArray sparseIntArray) {
+        return new IntIterator() { // from class: androidx.core.util.SparseIntArrayKt$keyIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < sparseIntArray.size();
+            }
+
+            @Override // kotlin.collections.IntIterator
+            public int nextInt() {
+                SparseIntArray sparseIntArray2 = sparseIntArray;
+                int i = this.index;
+                this.index = i + 1;
+                return sparseIntArray2.keyAt(i);
+            }
+        };
+    }
+
+    public static final IntIterator valueIterator(final SparseIntArray sparseIntArray) {
+        return new IntIterator() { // from class: androidx.core.util.SparseIntArrayKt$valueIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < sparseIntArray.size();
+            }
+
+            @Override // kotlin.collections.IntIterator
+            public int nextInt() {
+                SparseIntArray sparseIntArray2 = sparseIntArray;
+                int i = this.index;
+                this.index = i + 1;
+                return sparseIntArray2.valueAt(i);
+            }
+        };
+    }
+}

decompiled/sources/androidx/core/util/SparseLongArrayKt.java

@@ -0,0 +1,133 @@
+package androidx.core.util;
+
+import android.util.SparseLongArray;
+import kotlin.collections.IntIterator;
+import kotlin.collections.LongIterator;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nSparseLongArray.kt\nKotlin\n*S Kotlin\n*F\n+ 1 SparseLongArray.kt\nandroidx/core/util/SparseLongArrayKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,100:1\n76#1,4:102\n1#2:101\n*S KotlinDebug\n*F\n+ 1 SparseLongArray.kt\nandroidx/core/util/SparseLongArrayKt\n*L\n72#1:102,4\n*E\n"})
+/* loaded from: classes.dex */
+public final class SparseLongArrayKt {
+    public static final int getSize(SparseLongArray sparseLongArray) {
+        return sparseLongArray.size();
+    }
+
+    public static final boolean contains(SparseLongArray sparseLongArray, int i) {
+        return sparseLongArray.indexOfKey(i) >= 0;
+    }
+
+    public static final void set(SparseLongArray sparseLongArray, int i, long j) {
+        sparseLongArray.put(i, j);
+    }
+
+    public static final SparseLongArray plus(SparseLongArray sparseLongArray, SparseLongArray sparseLongArray2) {
+        SparseLongArray sparseLongArray3 = new SparseLongArray(sparseLongArray.size() + sparseLongArray2.size());
+        putAll(sparseLongArray3, sparseLongArray);
+        putAll(sparseLongArray3, sparseLongArray2);
+        return sparseLongArray3;
+    }
+
+    public static final boolean containsKey(SparseLongArray sparseLongArray, int i) {
+        return sparseLongArray.indexOfKey(i) >= 0;
+    }
+
+    public static final boolean containsValue(SparseLongArray sparseLongArray, long j) {
+        return sparseLongArray.indexOfValue(j) >= 0;
+    }
+
+    public static final long getOrDefault(SparseLongArray sparseLongArray, int i, long j) {
+        return sparseLongArray.get(i, j);
+    }
+
+    public static final long getOrElse(SparseLongArray sparseLongArray, int i, Function0 function0) {
+        int indexOfKey = sparseLongArray.indexOfKey(i);
+        return indexOfKey >= 0 ? sparseLongArray.valueAt(indexOfKey) : ((Number) function0.invoke()).longValue();
+    }
+
+    public static final boolean isEmpty(SparseLongArray sparseLongArray) {
+        return sparseLongArray.size() == 0;
+    }
+
+    public static final boolean isNotEmpty(SparseLongArray sparseLongArray) {
+        return sparseLongArray.size() != 0;
+    }
+
+    public static final boolean remove(SparseLongArray sparseLongArray, int i, long j) {
+        int indexOfKey = sparseLongArray.indexOfKey(i);
+        if (indexOfKey < 0 || j != sparseLongArray.valueAt(indexOfKey)) {
+            return false;
+        }
+        sparseLongArray.removeAt(indexOfKey);
+        return true;
+    }
+
+    public static final void forEach(SparseLongArray sparseLongArray, Function2 function2) {
+        int size = sparseLongArray.size();
+        for (int i = 0; i < size; i++) {
+            function2.invoke(Integer.valueOf(sparseLongArray.keyAt(i)), Long.valueOf(sparseLongArray.valueAt(i)));
+        }
+    }
+
+    public static final void putAll(SparseLongArray sparseLongArray, SparseLongArray sparseLongArray2) {
+        int size = sparseLongArray2.size();
+        for (int i = 0; i < size; i++) {
+            sparseLongArray.put(sparseLongArray2.keyAt(i), sparseLongArray2.valueAt(i));
+        }
+    }
+
+    public static final IntIterator keyIterator(final SparseLongArray sparseLongArray) {
+        return new IntIterator() { // from class: androidx.core.util.SparseLongArrayKt$keyIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < sparseLongArray.size();
+            }
+
+            @Override // kotlin.collections.IntIterator
+            public int nextInt() {
+                SparseLongArray sparseLongArray2 = sparseLongArray;
+                int i = this.index;
+                this.index = i + 1;
+                return sparseLongArray2.keyAt(i);
+            }
+        };
+    }
+
+    public static final LongIterator valueIterator(final SparseLongArray sparseLongArray) {
+        return new LongIterator() { // from class: androidx.core.util.SparseLongArrayKt$valueIterator$1
+            private int index;
+
+            public final int getIndex() {
+                return this.index;
+            }
+
+            public final void setIndex(int i) {
+                this.index = i;
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.index < sparseLongArray.size();
+            }
+
+            @Override // kotlin.collections.LongIterator
+            public long nextLong() {
+                SparseLongArray sparseLongArray2 = sparseLongArray;
+                int i = this.index;
+                this.index = i + 1;
+                return sparseLongArray2.valueAt(i);
+            }
+        };
+    }
+}

decompiled/sources/androidx/core/util/Supplier.java

@@ -0,0 +1,6 @@
+package androidx.core.util;
+
+/* loaded from: classes.dex */
+public interface Supplier<T> {
+    T get();
+}

decompiled/sources/androidx/core/util/TimeUtils.java

@@ -0,0 +1,158 @@
+package androidx.core.util;
+
+import androidx.annotation.RestrictTo;
+import java.io.PrintWriter;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class TimeUtils {
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static final int HUNDRED_DAY_FIELD_LEN = 19;
+    private static final int SECONDS_PER_DAY = 86400;
+    private static final int SECONDS_PER_HOUR = 3600;
+    private static final int SECONDS_PER_MINUTE = 60;
+    private static final Object sFormatSync = new Object();
+    private static char[] sFormatStr = new char[24];
+
+    private static int accumField(int i, int i2, boolean z, int i3) {
+        if (i > 99 || (z && i3 >= 3)) {
+            return i2 + 3;
+        }
+        if (i > 9 || (z && i3 >= 2)) {
+            return i2 + 2;
+        }
+        if (z || i > 0) {
+            return i2 + 1;
+        }
+        return 0;
+    }
+
+    private static int printField(char[] cArr, int i, char c, int i2, boolean z, int i3) {
+        int i4;
+        if (!z && i <= 0) {
+            return i2;
+        }
+        if ((!z || i3 < 3) && i <= 99) {
+            i4 = i2;
+        } else {
+            int i5 = i / 100;
+            cArr[i2] = (char) (i5 + 48);
+            i4 = i2 + 1;
+            i -= i5 * 100;
+        }
+        if ((z && i3 >= 2) || i > 9 || i2 != i4) {
+            int i6 = i / 10;
+            cArr[i4] = (char) (i6 + 48);
+            i4++;
+            i -= i6 * 10;
+        }
+        cArr[i4] = (char) (i + 48);
+        cArr[i4 + 1] = c;
+        return i4 + 2;
+    }
+
+    private static int formatDurationLocked(long j, int i) {
+        char c;
+        int i2;
+        int i3;
+        int i4;
+        int i5;
+        int i6;
+        long j2 = j;
+        if (sFormatStr.length < i) {
+            sFormatStr = new char[i];
+        }
+        char[] cArr = sFormatStr;
+        if (j2 == 0) {
+            int i7 = i - 1;
+            while (i7 > 0) {
+                cArr[0] = ' ';
+            }
+            cArr[0] = '0';
+            return 1;
+        }
+        if (j2 > 0) {
+            c = '+';
+        } else {
+            j2 = -j2;
+            c = '-';
+        }
+        int i8 = (int) (j2 % 1000);
+        int floor = (int) Math.floor(j2 / 1000);
+        if (floor > SECONDS_PER_DAY) {
+            i2 = floor / SECONDS_PER_DAY;
+            floor -= SECONDS_PER_DAY * i2;
+        } else {
+            i2 = 0;
+        }
+        if (floor > 3600) {
+            i3 = floor / 3600;
+            floor -= i3 * 3600;
+        } else {
+            i3 = 0;
+        }
+        if (floor > 60) {
+            int i9 = floor / 60;
+            i4 = floor - (i9 * 60);
+            i5 = i9;
+        } else {
+            i4 = floor;
+            i5 = 0;
+        }
+        if (i != 0) {
+            int accumField = accumField(i2, 1, false, 0);
+            int accumField2 = accumField + accumField(i3, 1, accumField > 0, 2);
+            int accumField3 = accumField2 + accumField(i5, 1, accumField2 > 0, 2);
+            int accumField4 = accumField3 + accumField(i4, 1, accumField3 > 0, 2);
+            i6 = 0;
+            for (int accumField5 = accumField4 + accumField(i8, 2, true, accumField4 > 0 ? 3 : 0) + 1; accumField5 < i; accumField5++) {
+                cArr[i6] = ' ';
+                i6++;
+            }
+        } else {
+            i6 = 0;
+        }
+        cArr[i6] = c;
+        int i10 = i6 + 1;
+        boolean z = i != 0;
+        int printField = printField(cArr, i2, 'd', i10, false, 0);
+        int printField2 = printField(cArr, i3, 'h', printField, printField != i10, z ? 2 : 0);
+        int printField3 = printField(cArr, i5, 'm', printField2, printField2 != i10, z ? 2 : 0);
+        int printField4 = printField(cArr, i4, 's', printField3, printField3 != i10, z ? 2 : 0);
+        int printField5 = printField(cArr, i8, 'm', printField4, true, (!z || printField4 == i10) ? 0 : 3);
+        cArr[printField5] = 's';
+        return printField5 + 1;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static void formatDuration(long j, StringBuilder sb) {
+        synchronized (sFormatSync) {
+            sb.append(sFormatStr, 0, formatDurationLocked(j, 0));
+        }
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static void formatDuration(long j, PrintWriter printWriter, int i) {
+        synchronized (sFormatSync) {
+            printWriter.print(new String(sFormatStr, 0, formatDurationLocked(j, i)));
+        }
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static void formatDuration(long j, PrintWriter printWriter) {
+        formatDuration(j, printWriter, 0);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static void formatDuration(long j, long j2, PrintWriter printWriter) {
+        if (j == 0) {
+            printWriter.print("--");
+        } else {
+            formatDuration(j - j2, printWriter, 0);
+        }
+    }
+
+    private TimeUtils() {
+    }
+}

decompiled/sources/androidx/core/util/TypedValueCompat.java

@@ -0,0 +1,108 @@
+package androidx.core.util;
+
+import android.annotation.SuppressLint;
+import android.os.Build;
+import android.util.DisplayMetrics;
+import android.util.TypedValue;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public class TypedValueCompat {
+    private static final float INCHES_PER_MM = 0.03937008f;
+    private static final float INCHES_PER_PT = 0.013888889f;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface ComplexDimensionUnit {
+    }
+
+    @SuppressLint({"WrongConstant"})
+    public static int getUnitFromComplexDimension(int i) {
+        return i & 15;
+    }
+
+    private TypedValueCompat() {
+    }
+
+    public static float deriveDimension(int i, float f, @NonNull DisplayMetrics displayMetrics) {
+        float f2;
+        float f3;
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api34Impl.deriveDimension(i, f, displayMetrics);
+        }
+        if (i == 0) {
+            return f;
+        }
+        if (i == 1) {
+            float f4 = displayMetrics.density;
+            if (f4 == 0.0f) {
+                return 0.0f;
+            }
+            return f / f4;
+        }
+        if (i == 2) {
+            float f5 = displayMetrics.scaledDensity;
+            if (f5 == 0.0f) {
+                return 0.0f;
+            }
+            return f / f5;
+        }
+        if (i == 3) {
+            float f6 = displayMetrics.xdpi;
+            if (f6 == 0.0f) {
+                return 0.0f;
+            }
+            f2 = f / f6;
+            f3 = INCHES_PER_PT;
+        } else {
+            if (i == 4) {
+                float f7 = displayMetrics.xdpi;
+                if (f7 == 0.0f) {
+                    return 0.0f;
+                }
+                return f / f7;
+            }
+            if (i == 5) {
+                float f8 = displayMetrics.xdpi;
+                if (f8 == 0.0f) {
+                    return 0.0f;
+                }
+                f2 = f / f8;
+                f3 = INCHES_PER_MM;
+            } else {
+                throw new IllegalArgumentException("Invalid unitToConvertTo " + i);
+            }
+        }
+        return f2 / f3;
+    }
+
+    public static float dpToPx(float f, @NonNull DisplayMetrics displayMetrics) {
+        return TypedValue.applyDimension(1, f, displayMetrics);
+    }
+
+    public static float pxToDp(float f, @NonNull DisplayMetrics displayMetrics) {
+        return deriveDimension(1, f, displayMetrics);
+    }
+
+    public static float spToPx(float f, @NonNull DisplayMetrics displayMetrics) {
+        return TypedValue.applyDimension(2, f, displayMetrics);
+    }
+
+    public static float pxToSp(float f, @NonNull DisplayMetrics displayMetrics) {
+        return deriveDimension(2, f, displayMetrics);
+    }
+
+    @RequiresApi(34)
+    public static class Api34Impl {
+        private Api34Impl() {
+        }
+
+        public static float deriveDimension(int i, float f, DisplayMetrics displayMetrics) {
+            return TypedValue.deriveDimension(i, f, displayMetrics);
+        }
+    }
+}