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/kotlin/random/AbstractPlatformRandom.java

@@ -0,0 +1,26 @@
+package kotlin.random;
+
+/* loaded from: classes5.dex */
+public abstract class AbstractPlatformRandom extends Random {
+    public abstract java.util.Random getImpl();
+
+    @Override // kotlin.random.Random
+    public int nextBits(int i) {
+        return RandomKt.takeUpperBits(getImpl().nextInt(), i);
+    }
+
+    @Override // kotlin.random.Random
+    public int nextInt() {
+        return getImpl().nextInt();
+    }
+
+    @Override // kotlin.random.Random
+    public int nextInt(int i) {
+        return getImpl().nextInt(i);
+    }
+
+    @Override // kotlin.random.Random
+    public long nextLong() {
+        return getImpl().nextLong();
+    }
+}

decompiled/sources/kotlin/random/FallbackThreadLocalRandom.java

@@ -0,0 +1,20 @@
+package kotlin.random;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class FallbackThreadLocalRandom extends AbstractPlatformRandom {
+    public final FallbackThreadLocalRandom$implStorage$1 implStorage = new ThreadLocal() { // from class: kotlin.random.FallbackThreadLocalRandom$implStorage$1
+        @Override // java.lang.ThreadLocal
+        public java.util.Random initialValue() {
+            return new java.util.Random();
+        }
+    };
+
+    @Override // kotlin.random.AbstractPlatformRandom
+    public java.util.Random getImpl() {
+        Object obj = get();
+        Intrinsics.checkNotNullExpressionValue(obj, "get(...)");
+        return (java.util.Random) obj;
+    }
+}

decompiled/sources/kotlin/random/Random.java

@@ -0,0 +1,133 @@
+package kotlin.random;
+
+import java.io.Serializable;
+import kotlin.internal.PlatformImplementationsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes5.dex */
+public abstract class Random {
+    public static final Default Default = new Default(null);
+    public static final Random defaultRandom = PlatformImplementationsKt.IMPLEMENTATIONS.defaultPlatformRandom();
+
+    public abstract int nextBits(int i);
+
+    public abstract int nextInt();
+
+    public abstract int nextInt(int i);
+
+    public abstract long nextLong();
+
+    public int nextInt(int i, int i2) {
+        int nextInt;
+        int i3;
+        int i4;
+        RandomKt.checkRangeBounds(i, i2);
+        int i5 = i2 - i;
+        if (i5 > 0 || i5 == Integer.MIN_VALUE) {
+            if (((-i5) & i5) == i5) {
+                i4 = nextBits(RandomKt.fastLog2(i5));
+            } else {
+                do {
+                    nextInt = nextInt() >>> 1;
+                    i3 = nextInt % i5;
+                } while ((nextInt - i3) + (i5 - 1) < 0);
+                i4 = i3;
+            }
+            return i + i4;
+        }
+        while (true) {
+            int nextInt2 = nextInt();
+            if (i <= nextInt2 && nextInt2 < i2) {
+                return nextInt2;
+            }
+        }
+    }
+
+    public long nextLong(long j, long j2) {
+        long nextLong;
+        long j3;
+        long j4;
+        int nextInt;
+        RandomKt.checkRangeBounds(j, j2);
+        long j5 = j2 - j;
+        if (j5 > 0) {
+            if (((-j5) & j5) == j5) {
+                int i = (int) j5;
+                int i2 = (int) (j5 >>> 32);
+                if (i != 0) {
+                    nextInt = nextBits(RandomKt.fastLog2(i));
+                } else if (i2 == 1) {
+                    nextInt = nextInt();
+                } else {
+                    j4 = (nextBits(RandomKt.fastLog2(i2)) << 32) + (nextInt() & 4294967295L);
+                }
+                j4 = nextInt & 4294967295L;
+            } else {
+                do {
+                    nextLong = nextLong() >>> 1;
+                    j3 = nextLong % j5;
+                } while ((nextLong - j3) + (j5 - 1) < 0);
+                j4 = j3;
+            }
+            return j + j4;
+        }
+        while (true) {
+            long nextLong2 = nextLong();
+            if (j <= nextLong2 && nextLong2 < j2) {
+                return nextLong2;
+            }
+        }
+    }
+
+    public static final class Default extends Random implements Serializable {
+        public /* synthetic */ Default(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Default() {
+        }
+
+        public static final class Serialized implements Serializable {
+            public static final Serialized INSTANCE = new Serialized();
+            private static final long serialVersionUID = 0;
+
+            private final Object readResolve() {
+                return Random.Default;
+            }
+        }
+
+        private final Object writeReplace() {
+            return Serialized.INSTANCE;
+        }
+
+        @Override // kotlin.random.Random
+        public int nextBits(int i) {
+            return Random.defaultRandom.nextBits(i);
+        }
+
+        @Override // kotlin.random.Random
+        public int nextInt() {
+            return Random.defaultRandom.nextInt();
+        }
+
+        @Override // kotlin.random.Random
+        public int nextInt(int i) {
+            return Random.defaultRandom.nextInt(i);
+        }
+
+        @Override // kotlin.random.Random
+        public int nextInt(int i, int i2) {
+            return Random.defaultRandom.nextInt(i, i2);
+        }
+
+        @Override // kotlin.random.Random
+        public long nextLong() {
+            return Random.defaultRandom.nextLong();
+        }
+
+        @Override // kotlin.random.Random
+        public long nextLong(long j, long j2) {
+            return Random.defaultRandom.nextLong(j, j2);
+        }
+    }
+}

decompiled/sources/kotlin/random/RandomKt.java

@@ -0,0 +1,42 @@
+package kotlin.random;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.IntRange;
+
+/* loaded from: classes5.dex */
+public abstract class RandomKt {
+    public static final int takeUpperBits(int i, int i2) {
+        return (i >>> (32 - i2)) & ((-i2) >> 31);
+    }
+
+    public static final int nextInt(Random random, IntRange range) {
+        Intrinsics.checkNotNullParameter(random, "<this>");
+        Intrinsics.checkNotNullParameter(range, "range");
+        if (!range.isEmpty()) {
+            return range.getLast() < Integer.MAX_VALUE ? random.nextInt(range.getFirst(), range.getLast() + 1) : range.getFirst() > Integer.MIN_VALUE ? random.nextInt(range.getFirst() - 1, range.getLast()) + 1 : random.nextInt();
+        }
+        throw new IllegalArgumentException("Cannot get random in empty range: " + range);
+    }
+
+    public static final int fastLog2(int i) {
+        return 31 - Integer.numberOfLeadingZeros(i);
+    }
+
+    public static final void checkRangeBounds(int i, int i2) {
+        if (i2 <= i) {
+            throw new IllegalArgumentException(boundsErrorMessage(Integer.valueOf(i), Integer.valueOf(i2)).toString());
+        }
+    }
+
+    public static final void checkRangeBounds(long j, long j2) {
+        if (j2 <= j) {
+            throw new IllegalArgumentException(boundsErrorMessage(Long.valueOf(j), Long.valueOf(j2)).toString());
+        }
+    }
+
+    public static final String boundsErrorMessage(Object from, Object until) {
+        Intrinsics.checkNotNullParameter(from, "from");
+        Intrinsics.checkNotNullParameter(until, "until");
+        return "Random range is empty: [" + from + ", " + until + ").";
+    }
+}

decompiled/sources/kotlin/random/jdk8/PlatformThreadLocalRandom.java

@@ -0,0 +1,26 @@
+package kotlin.random.jdk8;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.random.AbstractPlatformRandom;
+
+/* loaded from: classes5.dex */
+public final class PlatformThreadLocalRandom extends AbstractPlatformRandom {
+    @Override // kotlin.random.AbstractPlatformRandom
+    public Random getImpl() {
+        ThreadLocalRandom current = ThreadLocalRandom.current();
+        Intrinsics.checkNotNullExpressionValue(current, "current(...)");
+        return current;
+    }
+
+    @Override // kotlin.random.Random
+    public int nextInt(int i, int i2) {
+        return ThreadLocalRandom.current().nextInt(i, i2);
+    }
+
+    @Override // kotlin.random.Random
+    public long nextLong(long j, long j2) {
+        return ThreadLocalRandom.current().nextLong(j, j2);
+    }
+}