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/ranges/CharProgression.java

@@ -0,0 +1,48 @@
+package kotlin.ranges;
+
+import kotlin.collections.CharIterator;
+import kotlin.internal.ProgressionUtilKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class CharProgression implements Iterable, KMappedMarker {
+    public static final Companion Companion = new Companion(null);
+    public final char first;
+    public final char last;
+    public final int step;
+
+    public final char getFirst() {
+        return this.first;
+    }
+
+    public final char getLast() {
+        return this.last;
+    }
+
+    public CharProgression(char c, char c2, int i) {
+        if (i == 0) {
+            throw new IllegalArgumentException("Step must be non-zero.");
+        }
+        if (i == Integer.MIN_VALUE) {
+            throw new IllegalArgumentException("Step must be greater than Int.MIN_VALUE to avoid overflow on negation.");
+        }
+        this.first = c;
+        this.last = (char) ProgressionUtilKt.getProgressionLastElement((int) c, (int) c2, i);
+        this.step = i;
+    }
+
+    @Override // java.lang.Iterable
+    public CharIterator iterator() {
+        return new CharProgressionIterator(this.first, this.last, this.step);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/ranges/CharProgressionIterator.java

@@ -0,0 +1,43 @@
+package kotlin.ranges;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.CharIterator;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class CharProgressionIterator extends CharIterator {
+    public final int finalElement;
+    public boolean hasNext;
+    public int next;
+    public final int step;
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.hasNext;
+    }
+
+    public CharProgressionIterator(char c, char c2, int i) {
+        this.step = i;
+        this.finalElement = c2;
+        boolean z = true;
+        if (i <= 0 ? Intrinsics.compare((int) c, (int) c2) < 0 : Intrinsics.compare((int) c, (int) c2) > 0) {
+            z = false;
+        }
+        this.hasNext = z;
+        this.next = z ? c : c2;
+    }
+
+    @Override // kotlin.collections.CharIterator
+    public char nextChar() {
+        int i = this.next;
+        if (i != this.finalElement) {
+            this.next = this.step + i;
+        } else {
+            if (!this.hasNext) {
+                throw new NoSuchElementException();
+            }
+            this.hasNext = false;
+        }
+        return (char) i;
+    }
+}

decompiled/sources/kotlin/ranges/CharRange.java

@@ -0,0 +1,60 @@
+package kotlin.ranges;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class CharRange extends CharProgression implements ClosedRange {
+    public static final Companion Companion = new Companion(null);
+    public static final CharRange EMPTY = new CharRange(1, 0);
+
+    public CharRange(char c, char c2) {
+        super(c, c2, 1);
+    }
+
+    @Override // kotlin.ranges.ClosedRange
+    public Character getStart() {
+        return Character.valueOf(getFirst());
+    }
+
+    @Override // kotlin.ranges.ClosedRange
+    public Character getEndInclusive() {
+        return Character.valueOf(getLast());
+    }
+
+    public boolean isEmpty() {
+        return Intrinsics.compare((int) getFirst(), (int) getLast()) > 0;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof CharRange) {
+            if (!isEmpty() || !((CharRange) obj).isEmpty()) {
+                CharRange charRange = (CharRange) obj;
+                if (getFirst() != charRange.getFirst() || getLast() != charRange.getLast()) {
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        if (isEmpty()) {
+            return -1;
+        }
+        return (getFirst() * 31) + getLast();
+    }
+
+    public String toString() {
+        return getFirst() + ".." + getLast();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/ranges/ClosedRange.java

@@ -0,0 +1,21 @@
+package kotlin.ranges;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public interface ClosedRange {
+    Comparable getEndInclusive();
+
+    Comparable getStart();
+
+    public static final class DefaultImpls {
+        public static boolean contains(ClosedRange closedRange, Comparable value) {
+            Intrinsics.checkNotNullParameter(value, "value");
+            return value.compareTo(closedRange.getStart()) >= 0 && value.compareTo(closedRange.getEndInclusive()) <= 0;
+        }
+
+        public static boolean isEmpty(ClosedRange closedRange) {
+            return closedRange.getStart().compareTo(closedRange.getEndInclusive()) > 0;
+        }
+    }
+}

decompiled/sources/kotlin/ranges/IntProgression.java

@@ -0,0 +1,108 @@
+package kotlin.ranges;
+
+import kotlin.collections.IntIterator;
+import kotlin.internal.ProgressionUtilKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public class IntProgression implements Iterable, KMappedMarker {
+    public static final Companion Companion = new Companion(null);
+    public final int first;
+    public final int last;
+    public final int step;
+
+    public final int getFirst() {
+        return this.first;
+    }
+
+    public final int getLast() {
+        return this.last;
+    }
+
+    public final int getStep() {
+        return this.step;
+    }
+
+    public boolean isEmpty() {
+        if (this.step > 0) {
+            if (this.first <= this.last) {
+                return false;
+            }
+        } else if (this.first >= this.last) {
+            return false;
+        }
+        return true;
+    }
+
+    public IntProgression(int i, int i2, int i3) {
+        if (i3 == 0) {
+            throw new IllegalArgumentException("Step must be non-zero.");
+        }
+        if (i3 == Integer.MIN_VALUE) {
+            throw new IllegalArgumentException("Step must be greater than Int.MIN_VALUE to avoid overflow on negation.");
+        }
+        this.first = i;
+        this.last = ProgressionUtilKt.getProgressionLastElement(i, i2, i3);
+        this.step = i3;
+    }
+
+    @Override // java.lang.Iterable
+    public IntIterator iterator() {
+        return new IntProgressionIterator(this.first, this.last, this.step);
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof IntProgression) {
+            if (!isEmpty() || !((IntProgression) obj).isEmpty()) {
+                IntProgression intProgression = (IntProgression) obj;
+                if (this.first != intProgression.first || this.last != intProgression.last || this.step != intProgression.step) {
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        if (isEmpty()) {
+            return -1;
+        }
+        return (((this.first * 31) + this.last) * 31) + this.step;
+    }
+
+    public String toString() {
+        StringBuilder sb;
+        int i;
+        if (this.step > 0) {
+            sb = new StringBuilder();
+            sb.append(this.first);
+            sb.append("..");
+            sb.append(this.last);
+            sb.append(" step ");
+            i = this.step;
+        } else {
+            sb = new StringBuilder();
+            sb.append(this.first);
+            sb.append(" downTo ");
+            sb.append(this.last);
+            sb.append(" step ");
+            i = -this.step;
+        }
+        sb.append(i);
+        return sb.toString();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+
+        public final IntProgression fromClosedRange(int i, int i2, int i3) {
+            return new IntProgression(i, i2, i3);
+        }
+    }
+}

decompiled/sources/kotlin/ranges/IntProgressionIterator.java

@@ -0,0 +1,42 @@
+package kotlin.ranges;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.IntIterator;
+
+/* loaded from: classes5.dex */
+public final class IntProgressionIterator extends IntIterator {
+    public final int finalElement;
+    public boolean hasNext;
+    public int next;
+    public final int step;
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.hasNext;
+    }
+
+    public IntProgressionIterator(int i, int i2, int i3) {
+        this.step = i3;
+        this.finalElement = i2;
+        boolean z = true;
+        if (i3 <= 0 ? i < i2 : i > i2) {
+            z = false;
+        }
+        this.hasNext = z;
+        this.next = z ? i : i2;
+    }
+
+    @Override // kotlin.collections.IntIterator
+    public int nextInt() {
+        int i = this.next;
+        if (i != this.finalElement) {
+            this.next = this.step + i;
+        } else {
+            if (!this.hasNext) {
+                throw new NoSuchElementException();
+            }
+            this.hasNext = false;
+        }
+        return i;
+    }
+}

decompiled/sources/kotlin/ranges/IntRange.java

@@ -0,0 +1,71 @@
+package kotlin.ranges;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes5.dex */
+public final class IntRange extends IntProgression implements ClosedRange {
+    public static final Companion Companion = new Companion(null);
+    public static final IntRange EMPTY = new IntRange(1, 0);
+
+    public IntRange(int i, int i2) {
+        super(i, i2, 1);
+    }
+
+    @Override // kotlin.ranges.ClosedRange
+    public Integer getStart() {
+        return Integer.valueOf(getFirst());
+    }
+
+    @Override // kotlin.ranges.ClosedRange
+    public Integer getEndInclusive() {
+        return Integer.valueOf(getLast());
+    }
+
+    public boolean contains(int i) {
+        return getFirst() <= i && i <= getLast();
+    }
+
+    @Override // kotlin.ranges.IntProgression
+    public boolean isEmpty() {
+        return getFirst() > getLast();
+    }
+
+    @Override // kotlin.ranges.IntProgression
+    public boolean equals(Object obj) {
+        if (obj instanceof IntRange) {
+            if (!isEmpty() || !((IntRange) obj).isEmpty()) {
+                IntRange intRange = (IntRange) obj;
+                if (getFirst() != intRange.getFirst() || getLast() != intRange.getLast()) {
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override // kotlin.ranges.IntProgression
+    public int hashCode() {
+        if (isEmpty()) {
+            return -1;
+        }
+        return (getFirst() * 31) + getLast();
+    }
+
+    @Override // kotlin.ranges.IntProgression
+    public String toString() {
+        return getFirst() + ".." + getLast();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+
+        public final IntRange getEMPTY() {
+            return IntRange.EMPTY;
+        }
+    }
+}

decompiled/sources/kotlin/ranges/LongProgression.java

@@ -0,0 +1,48 @@
+package kotlin.ranges;
+
+import kotlin.collections.LongIterator;
+import kotlin.internal.ProgressionUtilKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes5.dex */
+public abstract class LongProgression implements Iterable, KMappedMarker {
+    public static final Companion Companion = new Companion(null);
+    public final long first;
+    public final long last;
+    public final long step;
+
+    public final long getFirst() {
+        return this.first;
+    }
+
+    public final long getLast() {
+        return this.last;
+    }
+
+    public LongProgression(long j, long j2, long j3) {
+        if (j3 == 0) {
+            throw new IllegalArgumentException("Step must be non-zero.");
+        }
+        if (j3 == Long.MIN_VALUE) {
+            throw new IllegalArgumentException("Step must be greater than Long.MIN_VALUE to avoid overflow on negation.");
+        }
+        this.first = j;
+        this.last = ProgressionUtilKt.getProgressionLastElement(j, j2, j3);
+        this.step = j3;
+    }
+
+    @Override // java.lang.Iterable
+    public LongIterator iterator() {
+        return new LongProgressionIterator(this.first, this.last, this.step);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/ranges/LongProgressionIterator.java

@@ -0,0 +1,42 @@
+package kotlin.ranges;
+
+import java.util.NoSuchElementException;
+import kotlin.collections.LongIterator;
+
+/* loaded from: classes5.dex */
+public final class LongProgressionIterator extends LongIterator {
+    public final long finalElement;
+    public boolean hasNext;
+    public long next;
+    public final long step;
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.hasNext;
+    }
+
+    public LongProgressionIterator(long j, long j2, long j3) {
+        this.step = j3;
+        this.finalElement = j2;
+        boolean z = true;
+        if (j3 <= 0 ? j < j2 : j > j2) {
+            z = false;
+        }
+        this.hasNext = z;
+        this.next = z ? j : j2;
+    }
+
+    @Override // kotlin.collections.LongIterator
+    public long nextLong() {
+        long j = this.next;
+        if (j != this.finalElement) {
+            this.next = this.step + j;
+        } else {
+            if (!this.hasNext) {
+                throw new NoSuchElementException();
+            }
+            this.hasNext = false;
+        }
+        return j;
+    }
+}

decompiled/sources/kotlin/ranges/LongRange.java

@@ -0,0 +1,63 @@
+package kotlin.ranges;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes5.dex */
+public final class LongRange extends LongProgression implements ClosedRange {
+    public static final Companion Companion = new Companion(null);
+    public static final LongRange EMPTY = new LongRange(1, 0);
+
+    public LongRange(long j, long j2) {
+        super(j, j2, 1L);
+    }
+
+    @Override // kotlin.ranges.ClosedRange
+    public Long getStart() {
+        return Long.valueOf(getFirst());
+    }
+
+    @Override // kotlin.ranges.ClosedRange
+    public Long getEndInclusive() {
+        return Long.valueOf(getLast());
+    }
+
+    public boolean contains(long j) {
+        return getFirst() <= j && j <= getLast();
+    }
+
+    public boolean isEmpty() {
+        return getFirst() > getLast();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof LongRange) {
+            if (!isEmpty() || !((LongRange) obj).isEmpty()) {
+                LongRange longRange = (LongRange) obj;
+                if (getFirst() != longRange.getFirst() || getLast() != longRange.getLast()) {
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        if (isEmpty()) {
+            return -1;
+        }
+        return (int) ((31 * (getFirst() ^ (getFirst() >>> 32))) + (getLast() ^ (getLast() >>> 32)));
+    }
+
+    public String toString() {
+        return getFirst() + ".." + getLast();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/ranges/RangesKt.java

@@ -0,0 +1,5 @@
+package kotlin.ranges;
+
+/* loaded from: classes5.dex */
+public abstract class RangesKt extends RangesKt___RangesKt {
+}

decompiled/sources/kotlin/ranges/RangesKt__RangesKt.java

@@ -0,0 +1,5 @@
+package kotlin.ranges;
+
+/* loaded from: classes5.dex */
+public abstract class RangesKt__RangesKt {
+}

decompiled/sources/kotlin/ranges/RangesKt___RangesKt.java

@@ -0,0 +1,60 @@
+package kotlin.ranges;
+
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.random.Random;
+import kotlin.random.RandomKt;
+
+/* loaded from: classes5.dex */
+public abstract class RangesKt___RangesKt extends RangesKt__RangesKt {
+    public static int coerceAtLeast(int i, int i2) {
+        return i < i2 ? i2 : i;
+    }
+
+    public static long coerceAtLeast(long j, long j2) {
+        return j < j2 ? j2 : j;
+    }
+
+    public static int coerceAtMost(int i, int i2) {
+        return i > i2 ? i2 : i;
+    }
+
+    public static long coerceAtMost(long j, long j2) {
+        return j > j2 ? j2 : j;
+    }
+
+    public static int random(IntRange intRange, Random random) {
+        Intrinsics.checkNotNullParameter(intRange, "<this>");
+        Intrinsics.checkNotNullParameter(random, "random");
+        try {
+            return RandomKt.nextInt(random, intRange);
+        } catch (IllegalArgumentException e) {
+            throw new NoSuchElementException(e.getMessage());
+        }
+    }
+
+    public static IntProgression downTo(int i, int i2) {
+        return IntProgression.Companion.fromClosedRange(i, i2, -1);
+    }
+
+    public static IntRange until(int i, int i2) {
+        if (i2 <= Integer.MIN_VALUE) {
+            return IntRange.Companion.getEMPTY();
+        }
+        return new IntRange(i, i2 - 1);
+    }
+
+    public static int coerceIn(int i, int i2, int i3) {
+        if (i2 <= i3) {
+            return i < i2 ? i2 : i > i3 ? i3 : i;
+        }
+        throw new IllegalArgumentException("Cannot coerce value to an empty range: maximum " + i3 + " is less than minimum " + i2 + '.');
+    }
+
+    public static long coerceIn(long j, long j2, long j3) {
+        if (j2 <= j3) {
+            return j < j2 ? j2 : j > j3 ? j3 : j;
+        }
+        throw new IllegalArgumentException("Cannot coerce value to an empty range: maximum " + j3 + " is less than minimum " + j2 + '.');
+    }
+}