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/text/CharsKt.java

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

decompiled/sources/kotlin/text/CharsKt__CharJVMKt.java

@@ -0,0 +1,21 @@
+package kotlin.text;
+
+import kotlin.ranges.IntRange;
+
+/* loaded from: classes5.dex */
+public abstract class CharsKt__CharJVMKt {
+    public static final boolean isWhitespace(char c) {
+        return Character.isWhitespace(c) || Character.isSpaceChar(c);
+    }
+
+    public static final int digitOf(char c, int i) {
+        return Character.digit((int) c, i);
+    }
+
+    public static final int checkRadix(int i) {
+        if (new IntRange(2, 36).contains(i)) {
+            return i;
+        }
+        throw new IllegalArgumentException("radix " + i + " was not in valid range " + new IntRange(2, 36));
+    }
+}

decompiled/sources/kotlin/text/CharsKt__CharKt.java

@@ -0,0 +1,24 @@
+package kotlin.text;
+
+/* loaded from: classes5.dex */
+public abstract class CharsKt__CharKt extends CharsKt__CharJVMKt {
+    public static int digitToInt(char c) {
+        int digitOf = CharsKt__CharJVMKt.digitOf(c, 10);
+        if (digitOf >= 0) {
+            return digitOf;
+        }
+        throw new IllegalArgumentException("Char " + c + " is not a decimal digit");
+    }
+
+    public static final boolean equals(char c, char c2, boolean z) {
+        if (c == c2) {
+            return true;
+        }
+        if (!z) {
+            return false;
+        }
+        char upperCase = Character.toUpperCase(c);
+        char upperCase2 = Character.toUpperCase(c2);
+        return upperCase == upperCase2 || Character.toLowerCase(upperCase) == Character.toLowerCase(upperCase2);
+    }
+}

decompiled/sources/kotlin/text/Charsets.java

@@ -0,0 +1,36 @@
+package kotlin.text;
+
+import java.nio.charset.Charset;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public final class Charsets {
+    public static final Charsets INSTANCE = new Charsets();
+    public static final Charset ISO_8859_1;
+    public static final Charset US_ASCII;
+    public static final Charset UTF_16;
+    public static final Charset UTF_16BE;
+    public static final Charset UTF_16LE;
+    public static final Charset UTF_8;
+
+    static {
+        Charset forName = Charset.forName("UTF-8");
+        Intrinsics.checkNotNullExpressionValue(forName, "forName(...)");
+        UTF_8 = forName;
+        Charset forName2 = Charset.forName("UTF-16");
+        Intrinsics.checkNotNullExpressionValue(forName2, "forName(...)");
+        UTF_16 = forName2;
+        Charset forName3 = Charset.forName("UTF-16BE");
+        Intrinsics.checkNotNullExpressionValue(forName3, "forName(...)");
+        UTF_16BE = forName3;
+        Charset forName4 = Charset.forName("UTF-16LE");
+        Intrinsics.checkNotNullExpressionValue(forName4, "forName(...)");
+        UTF_16LE = forName4;
+        Charset forName5 = Charset.forName("US-ASCII");
+        Intrinsics.checkNotNullExpressionValue(forName5, "forName(...)");
+        US_ASCII = forName5;
+        Charset forName6 = Charset.forName("ISO-8859-1");
+        Intrinsics.checkNotNullExpressionValue(forName6, "forName(...)");
+        ISO_8859_1 = forName6;
+    }
+}

decompiled/sources/kotlin/text/DelimitedRangesSequence$iterator$1.java

@@ -0,0 +1,148 @@
+package kotlin.text;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.markers.KMappedMarker;
+import kotlin.ranges.IntRange;
+import kotlin.ranges.RangesKt___RangesKt;
+
+/* loaded from: classes5.dex */
+public final class DelimitedRangesSequence$iterator$1 implements Iterator, KMappedMarker {
+    public int counter;
+    public int currentStartIndex;
+    public IntRange nextItem;
+    public int nextSearchIndex;
+    public int nextState = -1;
+    public final /* synthetic */ DelimitedRangesSequence this$0;
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public DelimitedRangesSequence$iterator$1(DelimitedRangesSequence delimitedRangesSequence) {
+        int i;
+        CharSequence charSequence;
+        int coerceIn;
+        this.this$0 = delimitedRangesSequence;
+        i = delimitedRangesSequence.startIndex;
+        charSequence = delimitedRangesSequence.input;
+        coerceIn = RangesKt___RangesKt.coerceIn(i, 0, charSequence.length());
+        this.currentStartIndex = coerceIn;
+        this.nextSearchIndex = coerceIn;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:9:0x0021, code lost:
+    
+        if (r0 < r4) goto L9;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private final void calcNext() {
+        /*
+            r6 = this;
+            int r0 = r6.nextSearchIndex
+            r1 = 0
+            if (r0 >= 0) goto Lc
+            r6.nextState = r1
+            r0 = 0
+            r6.nextItem = r0
+            goto L9e
+        Lc:
+            kotlin.text.DelimitedRangesSequence r0 = r6.this$0
+            int r0 = kotlin.text.DelimitedRangesSequence.access$getLimit$p(r0)
+            r2 = -1
+            r3 = 1
+            if (r0 <= 0) goto L23
+            int r0 = r6.counter
+            int r0 = r0 + r3
+            r6.counter = r0
+            kotlin.text.DelimitedRangesSequence r4 = r6.this$0
+            int r4 = kotlin.text.DelimitedRangesSequence.access$getLimit$p(r4)
+            if (r0 >= r4) goto L31
+        L23:
+            int r0 = r6.nextSearchIndex
+            kotlin.text.DelimitedRangesSequence r4 = r6.this$0
+            java.lang.CharSequence r4 = kotlin.text.DelimitedRangesSequence.access$getInput$p(r4)
+            int r4 = r4.length()
+            if (r0 <= r4) goto L47
+        L31:
+            kotlin.ranges.IntRange r0 = new kotlin.ranges.IntRange
+            int r1 = r6.currentStartIndex
+            kotlin.text.DelimitedRangesSequence r4 = r6.this$0
+            java.lang.CharSequence r4 = kotlin.text.DelimitedRangesSequence.access$getInput$p(r4)
+            int r4 = kotlin.text.StringsKt__StringsKt.getLastIndex(r4)
+            r0.<init>(r1, r4)
+            r6.nextItem = r0
+            r6.nextSearchIndex = r2
+            goto L9c
+        L47:
+            kotlin.text.DelimitedRangesSequence r0 = r6.this$0
+            kotlin.jvm.functions.Function2 r0 = kotlin.text.DelimitedRangesSequence.access$getGetNextMatch$p(r0)
+            kotlin.text.DelimitedRangesSequence r4 = r6.this$0
+            java.lang.CharSequence r4 = kotlin.text.DelimitedRangesSequence.access$getInput$p(r4)
+            int r5 = r6.nextSearchIndex
+            java.lang.Integer r5 = java.lang.Integer.valueOf(r5)
+            java.lang.Object r0 = r0.invoke(r4, r5)
+            kotlin.Pair r0 = (kotlin.Pair) r0
+            if (r0 != 0) goto L77
+            kotlin.ranges.IntRange r0 = new kotlin.ranges.IntRange
+            int r1 = r6.currentStartIndex
+            kotlin.text.DelimitedRangesSequence r4 = r6.this$0
+            java.lang.CharSequence r4 = kotlin.text.DelimitedRangesSequence.access$getInput$p(r4)
+            int r4 = kotlin.text.StringsKt__StringsKt.getLastIndex(r4)
+            r0.<init>(r1, r4)
+            r6.nextItem = r0
+            r6.nextSearchIndex = r2
+            goto L9c
+        L77:
+            java.lang.Object r2 = r0.component1()
+            java.lang.Number r2 = (java.lang.Number) r2
+            int r2 = r2.intValue()
+            java.lang.Object r0 = r0.component2()
+            java.lang.Number r0 = (java.lang.Number) r0
+            int r0 = r0.intValue()
+            int r4 = r6.currentStartIndex
+            kotlin.ranges.IntRange r4 = kotlin.ranges.RangesKt.until(r4, r2)
+            r6.nextItem = r4
+            int r2 = r2 + r0
+            r6.currentStartIndex = r2
+            if (r0 != 0) goto L99
+            r1 = r3
+        L99:
+            int r2 = r2 + r1
+            r6.nextSearchIndex = r2
+        L9c:
+            r6.nextState = r3
+        L9e:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlin.text.DelimitedRangesSequence$iterator$1.calcNext():void");
+    }
+
+    @Override // java.util.Iterator
+    public IntRange next() {
+        if (this.nextState == -1) {
+            calcNext();
+        }
+        if (this.nextState == 0) {
+            throw new NoSuchElementException();
+        }
+        IntRange intRange = this.nextItem;
+        Intrinsics.checkNotNull(intRange, "null cannot be cast to non-null type kotlin.ranges.IntRange");
+        this.nextItem = null;
+        this.nextState = -1;
+        return intRange;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        if (this.nextState == -1) {
+            calcNext();
+        }
+        return this.nextState == 1;
+    }
+}

decompiled/sources/kotlin/text/DelimitedRangesSequence.java

@@ -0,0 +1,28 @@
+package kotlin.text;
+
+import java.util.Iterator;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.sequences.Sequence;
+
+/* loaded from: classes5.dex */
+public final class DelimitedRangesSequence implements Sequence {
+    public final Function2 getNextMatch;
+    public final CharSequence input;
+    public final int limit;
+    public final int startIndex;
+
+    public DelimitedRangesSequence(CharSequence input, int i, int i2, Function2 getNextMatch) {
+        Intrinsics.checkNotNullParameter(input, "input");
+        Intrinsics.checkNotNullParameter(getNextMatch, "getNextMatch");
+        this.input = input;
+        this.startIndex = i;
+        this.limit = i2;
+        this.getNextMatch = getNextMatch;
+    }
+
+    @Override // kotlin.sequences.Sequence
+    public Iterator iterator() {
+        return new DelimitedRangesSequence$iterator$1(this);
+    }
+}

decompiled/sources/kotlin/text/Regex.java

@@ -0,0 +1,124 @@
+package kotlin.text;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.RangesKt___RangesKt;
+
+/* loaded from: classes5.dex */
+public final class Regex implements Serializable {
+    public static final Companion Companion = new Companion(null);
+    public final Pattern nativePattern;
+
+    public Regex(Pattern nativePattern) {
+        Intrinsics.checkNotNullParameter(nativePattern, "nativePattern");
+        this.nativePattern = nativePattern;
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public Regex(java.lang.String r2) {
+        /*
+            r1 = this;
+            java.lang.String r0 = "pattern"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r2, r0)
+            java.util.regex.Pattern r2 = java.util.regex.Pattern.compile(r2)
+            java.lang.String r0 = "compile(...)"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r2, r0)
+            r1.<init>(r2)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: kotlin.text.Regex.<init>(java.lang.String):void");
+    }
+
+    public final boolean matches(CharSequence input) {
+        Intrinsics.checkNotNullParameter(input, "input");
+        return this.nativePattern.matcher(input).matches();
+    }
+
+    public final String replace(CharSequence input, String replacement) {
+        Intrinsics.checkNotNullParameter(input, "input");
+        Intrinsics.checkNotNullParameter(replacement, "replacement");
+        String replaceAll = this.nativePattern.matcher(input).replaceAll(replacement);
+        Intrinsics.checkNotNullExpressionValue(replaceAll, "replaceAll(...)");
+        return replaceAll;
+    }
+
+    public final List split(CharSequence input, int i) {
+        Intrinsics.checkNotNullParameter(input, "input");
+        StringsKt__StringsKt.requireNonNegativeLimit(i);
+        Matcher matcher = this.nativePattern.matcher(input);
+        if (i == 1 || !matcher.find()) {
+            return CollectionsKt__CollectionsJVMKt.listOf(input.toString());
+        }
+        ArrayList arrayList = new ArrayList(i > 0 ? RangesKt___RangesKt.coerceAtMost(i, 10) : 10);
+        int i2 = i - 1;
+        int i3 = 0;
+        do {
+            arrayList.add(input.subSequence(i3, matcher.start()).toString());
+            i3 = matcher.end();
+            if (i2 >= 0 && arrayList.size() == i2) {
+                break;
+            }
+        } while (matcher.find());
+        arrayList.add(input.subSequence(i3, input.length()).toString());
+        return arrayList;
+    }
+
+    public String toString() {
+        String pattern = this.nativePattern.toString();
+        Intrinsics.checkNotNullExpressionValue(pattern, "toString(...)");
+        return pattern;
+    }
+
+    private final Object writeReplace() {
+        String pattern = this.nativePattern.pattern();
+        Intrinsics.checkNotNullExpressionValue(pattern, "pattern(...)");
+        return new Serialized(pattern, this.nativePattern.flags());
+    }
+
+    public static final class Serialized implements Serializable {
+        public static final Companion Companion = new Companion(null);
+        private static final long serialVersionUID = 0;
+        public final int flags;
+        public final String pattern;
+
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            public Companion() {
+            }
+        }
+
+        public Serialized(String pattern, int i) {
+            Intrinsics.checkNotNullParameter(pattern, "pattern");
+            this.pattern = pattern;
+            this.flags = i;
+        }
+
+        private final Object readResolve() {
+            Pattern compile = Pattern.compile(this.pattern, this.flags);
+            Intrinsics.checkNotNullExpressionValue(compile, "compile(...)");
+            return new Regex(compile);
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/kotlin/text/StringsKt.java

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

decompiled/sources/kotlin/text/StringsKt__AppendableKt.java

@@ -0,0 +1,22 @@
+package kotlin.text;
+
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class StringsKt__AppendableKt {
+    public static void appendElement(Appendable appendable, Object obj, Function1 function1) {
+        Intrinsics.checkNotNullParameter(appendable, "<this>");
+        if (function1 != null) {
+            appendable.append((CharSequence) function1.invoke(obj));
+            return;
+        }
+        if (obj == null || (obj instanceof CharSequence)) {
+            appendable.append((CharSequence) obj);
+        } else if (obj instanceof Character) {
+            appendable.append(((Character) obj).charValue());
+        } else {
+            appendable.append(String.valueOf(obj));
+        }
+    }
+}

decompiled/sources/kotlin/text/StringsKt__IndentKt.java

@@ -0,0 +1,102 @@
+package kotlin.text;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class StringsKt__IndentKt extends StringsKt__AppendableKt {
+    public static String trimIndent(String str) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        return replaceIndent(str, "");
+    }
+
+    public static final String replaceIndent(String str, String newIndent) {
+        String str2;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(newIndent, "newIndent");
+        List lines = StringsKt__StringsKt.lines(str);
+        ArrayList arrayList = new ArrayList();
+        for (Object obj : lines) {
+            if (!StringsKt__StringsJVMKt.isBlank((String) obj)) {
+                arrayList.add(obj);
+            }
+        }
+        ArrayList arrayList2 = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(arrayList, 10));
+        Iterator it = arrayList.iterator();
+        while (it.hasNext()) {
+            arrayList2.add(Integer.valueOf(indentWidth$StringsKt__IndentKt((String) it.next())));
+        }
+        Integer num = (Integer) CollectionsKt___CollectionsKt.minOrNull(arrayList2);
+        int i = 0;
+        int intValue = num != null ? num.intValue() : 0;
+        int length = str.length() + (newIndent.length() * lines.size());
+        Function1 indentFunction$StringsKt__IndentKt = getIndentFunction$StringsKt__IndentKt(newIndent);
+        int lastIndex = CollectionsKt__CollectionsKt.getLastIndex(lines);
+        ArrayList arrayList3 = new ArrayList();
+        for (Object obj2 : lines) {
+            int i2 = i + 1;
+            if (i < 0) {
+                CollectionsKt__CollectionsKt.throwIndexOverflow();
+            }
+            String str3 = (String) obj2;
+            if ((i == 0 || i == lastIndex) && StringsKt__StringsJVMKt.isBlank(str3)) {
+                str3 = null;
+            } else {
+                String drop = StringsKt___StringsKt.drop(str3, intValue);
+                if (drop != null && (str2 = (String) indentFunction$StringsKt__IndentKt.invoke(drop)) != null) {
+                    str3 = str2;
+                }
+            }
+            if (str3 != null) {
+                arrayList3.add(str3);
+            }
+            i = i2;
+        }
+        String sb = ((StringBuilder) CollectionsKt___CollectionsKt.joinTo$default(arrayList3, new StringBuilder(length), "\n", null, null, 0, null, null, 124, null)).toString();
+        Intrinsics.checkNotNullExpressionValue(sb, "toString(...)");
+        return sb;
+    }
+
+    public static final Function1 getIndentFunction$StringsKt__IndentKt(final String str) {
+        return str.length() == 0 ? new Function1() { // from class: kotlin.text.StringsKt__IndentKt$getIndentFunction$1
+            @Override // kotlin.jvm.functions.Function1
+            public final String invoke(String line) {
+                Intrinsics.checkNotNullParameter(line, "line");
+                return line;
+            }
+        } : new Function1() { // from class: kotlin.text.StringsKt__IndentKt$getIndentFunction$2
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public final String invoke(String line) {
+                Intrinsics.checkNotNullParameter(line, "line");
+                return str + line;
+            }
+        };
+    }
+
+    public static final int indentWidth$StringsKt__IndentKt(String str) {
+        int length = str.length();
+        int i = 0;
+        while (true) {
+            if (i >= length) {
+                i = -1;
+                break;
+            }
+            if (!CharsKt__CharJVMKt.isWhitespace(str.charAt(i))) {
+                break;
+            }
+            i++;
+        }
+        return i == -1 ? str.length() : i;
+    }
+}

decompiled/sources/kotlin/text/StringsKt__RegexExtensionsJVMKt.java

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

decompiled/sources/kotlin/text/StringsKt__RegexExtensionsKt.java

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

decompiled/sources/kotlin/text/StringsKt__StringBuilderJVMKt.java

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

decompiled/sources/kotlin/text/StringsKt__StringBuilderKt.java

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

decompiled/sources/kotlin/text/StringsKt__StringNumberConversionsJVMKt.java

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

decompiled/sources/kotlin/text/StringsKt__StringNumberConversionsKt.java

@@ -0,0 +1,121 @@
+package kotlin.text;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class StringsKt__StringNumberConversionsKt extends StringsKt__StringNumberConversionsJVMKt {
+    public static Integer toIntOrNull(String str) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        return toIntOrNull(str, 10);
+    }
+
+    public static final Integer toIntOrNull(String str, int i) {
+        boolean z;
+        int i2;
+        int i3;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        CharsKt__CharJVMKt.checkRadix(i);
+        int length = str.length();
+        if (length == 0) {
+            return null;
+        }
+        int i4 = 0;
+        char charAt = str.charAt(0);
+        int i5 = -2147483647;
+        if (Intrinsics.compare((int) charAt, 48) < 0) {
+            i2 = 1;
+            if (length == 1) {
+                return null;
+            }
+            if (charAt == '-') {
+                i5 = Integer.MIN_VALUE;
+                z = true;
+            } else {
+                if (charAt != '+') {
+                    return null;
+                }
+                z = false;
+            }
+        } else {
+            z = false;
+            i2 = 0;
+        }
+        int i6 = -59652323;
+        while (i2 < length) {
+            int digitOf = CharsKt__CharJVMKt.digitOf(str.charAt(i2), i);
+            if (digitOf < 0) {
+                return null;
+            }
+            if ((i4 < i6 && (i6 != -59652323 || i4 < (i6 = i5 / i))) || (i3 = i4 * i) < i5 + digitOf) {
+                return null;
+            }
+            i4 = i3 - digitOf;
+            i2++;
+        }
+        return z ? Integer.valueOf(i4) : Integer.valueOf(-i4);
+    }
+
+    public static Long toLongOrNull(String str) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        return toLongOrNull(str, 10);
+    }
+
+    public static final Long toLongOrNull(String str, int i) {
+        boolean z;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        CharsKt__CharJVMKt.checkRadix(i);
+        int length = str.length();
+        if (length == 0) {
+            return null;
+        }
+        int i2 = 0;
+        char charAt = str.charAt(0);
+        int compare = Intrinsics.compare((int) charAt, 48);
+        long j = C.TIME_UNSET;
+        if (compare < 0) {
+            z = true;
+            if (length == 1) {
+                return null;
+            }
+            if (charAt == '-') {
+                j = Long.MIN_VALUE;
+                i2 = 1;
+            } else {
+                if (charAt != '+') {
+                    return null;
+                }
+                z = false;
+                i2 = 1;
+            }
+        } else {
+            z = false;
+        }
+        long j2 = -256204778801521550L;
+        long j3 = 0;
+        long j4 = -256204778801521550L;
+        while (i2 < length) {
+            int digitOf = CharsKt__CharJVMKt.digitOf(str.charAt(i2), i);
+            if (digitOf < 0) {
+                return null;
+            }
+            if (j3 < j4) {
+                if (j4 == j2) {
+                    j4 = j / i;
+                    if (j3 < j4) {
+                    }
+                }
+                return null;
+            }
+            long j5 = j3 * i;
+            long j6 = digitOf;
+            if (j5 < j + j6) {
+                return null;
+            }
+            j3 = j5 - j6;
+            i2++;
+            j2 = -256204778801521550L;
+        }
+        return z ? Long.valueOf(j3) : Long.valueOf(-j3);
+    }
+}

decompiled/sources/kotlin/text/StringsKt__StringsJVMKt.java

@@ -0,0 +1,150 @@
+package kotlin.text;
+
+import java.util.Collection;
+import java.util.Iterator;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.RangesKt___RangesKt;
+
+/* loaded from: classes5.dex */
+public abstract class StringsKt__StringsJVMKt extends StringsKt__StringNumberConversionsKt {
+    public static boolean equals(String str, String str2, boolean z) {
+        if (str == null) {
+            return str2 == null;
+        }
+        if (!z) {
+            return str.equals(str2);
+        }
+        return str.equalsIgnoreCase(str2);
+    }
+
+    public static /* synthetic */ String replace$default(String str, char c, char c2, boolean z, int i, Object obj) {
+        if ((i & 4) != 0) {
+            z = false;
+        }
+        return replace(str, c, c2, z);
+    }
+
+    public static final String replace(String str, char c, char c2, boolean z) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        if (!z) {
+            String replace = str.replace(c, c2);
+            Intrinsics.checkNotNullExpressionValue(replace, "replace(...)");
+            return replace;
+        }
+        StringBuilder sb = new StringBuilder(str.length());
+        for (int i = 0; i < str.length(); i++) {
+            char charAt = str.charAt(i);
+            if (CharsKt__CharKt.equals(charAt, c, z)) {
+                charAt = c2;
+            }
+            sb.append(charAt);
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+        return sb2;
+    }
+
+    public static /* synthetic */ String replace$default(String str, String str2, String str3, boolean z, int i, Object obj) {
+        if ((i & 4) != 0) {
+            z = false;
+        }
+        return replace(str, str2, str3, z);
+    }
+
+    public static final String replace(String str, String oldValue, String newValue, boolean z) {
+        int coerceAtLeast;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(oldValue, "oldValue");
+        Intrinsics.checkNotNullParameter(newValue, "newValue");
+        int i = 0;
+        int indexOf = StringsKt__StringsKt.indexOf(str, oldValue, 0, z);
+        if (indexOf < 0) {
+            return str;
+        }
+        int length = oldValue.length();
+        coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(length, 1);
+        int length2 = (str.length() - length) + newValue.length();
+        if (length2 < 0) {
+            throw new OutOfMemoryError();
+        }
+        StringBuilder sb = new StringBuilder(length2);
+        do {
+            sb.append((CharSequence) str, i, indexOf);
+            sb.append(newValue);
+            i = indexOf + length;
+            if (indexOf >= str.length()) {
+                break;
+            }
+            indexOf = StringsKt__StringsKt.indexOf(str, oldValue, indexOf + coerceAtLeast, z);
+        } while (indexOf > 0);
+        sb.append((CharSequence) str, i, str.length());
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+        return sb2;
+    }
+
+    public static byte[] encodeToByteArray(String str) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        byte[] bytes = str.getBytes(Charsets.UTF_8);
+        Intrinsics.checkNotNullExpressionValue(bytes, "getBytes(...)");
+        return bytes;
+    }
+
+    public static /* synthetic */ boolean startsWith$default(String str, String str2, boolean z, int i, Object obj) {
+        if ((i & 2) != 0) {
+            z = false;
+        }
+        return startsWith(str, str2, z);
+    }
+
+    public static final boolean startsWith(String str, String prefix, boolean z) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        if (!z) {
+            return str.startsWith(prefix);
+        }
+        return regionMatches(str, 0, prefix, 0, prefix.length(), z);
+    }
+
+    public static /* synthetic */ boolean endsWith$default(String str, String str2, boolean z, int i, Object obj) {
+        if ((i & 2) != 0) {
+            z = false;
+        }
+        return endsWith(str, str2, z);
+    }
+
+    public static final boolean endsWith(String str, String suffix, boolean z) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(suffix, "suffix");
+        if (!z) {
+            return str.endsWith(suffix);
+        }
+        return regionMatches(str, str.length() - suffix.length(), suffix, 0, suffix.length(), true);
+    }
+
+    public static boolean isBlank(CharSequence charSequence) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        if (charSequence.length() != 0) {
+            Iterable indices = StringsKt__StringsKt.getIndices(charSequence);
+            if (!(indices instanceof Collection) || !((Collection) indices).isEmpty()) {
+                Iterator it = indices.iterator();
+                while (it.hasNext()) {
+                    if (!CharsKt__CharJVMKt.isWhitespace(charSequence.charAt(((IntIterator) it).nextInt()))) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    public static final boolean regionMatches(String str, int i, String other, int i2, int i3, boolean z) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(other, "other");
+        if (!z) {
+            return str.regionMatches(i, other, i2, i3);
+        }
+        return str.regionMatches(z, i, other, i2, i3);
+    }
+}

decompiled/sources/kotlin/text/StringsKt__StringsKt.java

@@ -0,0 +1,798 @@
+package kotlin.text;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.Pair;
+import kotlin.TuplesKt;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.collections.ArraysKt___ArraysKt;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.IntProgression;
+import kotlin.ranges.IntRange;
+import kotlin.ranges.RangesKt___RangesKt;
+import kotlin.sequences.Sequence;
+import kotlin.sequences.SequencesKt___SequencesKt;
+
+/* loaded from: classes5.dex */
+public abstract class StringsKt__StringsKt extends StringsKt__StringsJVMKt {
+    public static CharSequence trim(CharSequence charSequence) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        int length = charSequence.length() - 1;
+        int i = 0;
+        boolean z = false;
+        while (i <= length) {
+            boolean isWhitespace = CharsKt__CharJVMKt.isWhitespace(charSequence.charAt(!z ? i : length));
+            if (z) {
+                if (!isWhitespace) {
+                    break;
+                }
+                length--;
+            } else if (isWhitespace) {
+                i++;
+            } else {
+                z = true;
+            }
+        }
+        return charSequence.subSequence(i, length + 1);
+    }
+
+    public static String trim(String str, char... chars) {
+        boolean contains;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(chars, "chars");
+        int length = str.length() - 1;
+        int i = 0;
+        boolean z = false;
+        while (i <= length) {
+            contains = ArraysKt___ArraysKt.contains(chars, str.charAt(!z ? i : length));
+            if (z) {
+                if (!contains) {
+                    break;
+                }
+                length--;
+            } else if (contains) {
+                i++;
+            } else {
+                z = true;
+            }
+        }
+        return str.subSequence(i, length + 1).toString();
+    }
+
+    public static final CharSequence padStart(CharSequence charSequence, int i, char c) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        if (i < 0) {
+            throw new IllegalArgumentException("Desired length " + i + " is less than zero.");
+        }
+        if (i <= charSequence.length()) {
+            return charSequence.subSequence(0, charSequence.length());
+        }
+        StringBuilder sb = new StringBuilder(i);
+        IntIterator it = new IntRange(1, i - charSequence.length()).iterator();
+        while (it.hasNext()) {
+            it.nextInt();
+            sb.append(c);
+        }
+        sb.append(charSequence);
+        return sb;
+    }
+
+    public static String padStart(String str, int i, char c) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        return padStart((CharSequence) str, i, c).toString();
+    }
+
+    public static final IntRange getIndices(CharSequence charSequence) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        return new IntRange(0, charSequence.length() - 1);
+    }
+
+    public static final int getLastIndex(CharSequence charSequence) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        return charSequence.length() - 1;
+    }
+
+    public static final String substring(CharSequence charSequence, IntRange range) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(range, "range");
+        return charSequence.subSequence(range.getStart().intValue(), range.getEndInclusive().intValue() + 1).toString();
+    }
+
+    public static /* synthetic */ String substringBefore$default(String str, char c, String str2, int i, Object obj) {
+        if ((i & 2) != 0) {
+            str2 = str;
+        }
+        return substringBefore(str, c, str2);
+    }
+
+    public static final String substringBefore(String str, char c, String missingDelimiterValue) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(missingDelimiterValue, "missingDelimiterValue");
+        int indexOf$default = indexOf$default((CharSequence) str, c, 0, false, 6, (Object) null);
+        if (indexOf$default == -1) {
+            return missingDelimiterValue;
+        }
+        String substring = str.substring(0, indexOf$default);
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static /* synthetic */ String substringBefore$default(String str, String str2, String str3, int i, Object obj) {
+        if ((i & 2) != 0) {
+            str3 = str;
+        }
+        return substringBefore(str, str2, str3);
+    }
+
+    public static final String substringBefore(String str, String delimiter, String missingDelimiterValue) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(delimiter, "delimiter");
+        Intrinsics.checkNotNullParameter(missingDelimiterValue, "missingDelimiterValue");
+        int indexOf$default = indexOf$default((CharSequence) str, delimiter, 0, false, 6, (Object) null);
+        if (indexOf$default == -1) {
+            return missingDelimiterValue;
+        }
+        String substring = str.substring(0, indexOf$default);
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static /* synthetic */ String substringAfter$default(String str, char c, String str2, int i, Object obj) {
+        if ((i & 2) != 0) {
+            str2 = str;
+        }
+        return substringAfter(str, c, str2);
+    }
+
+    public static final String substringAfter(String str, char c, String missingDelimiterValue) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(missingDelimiterValue, "missingDelimiterValue");
+        int indexOf$default = indexOf$default((CharSequence) str, c, 0, false, 6, (Object) null);
+        if (indexOf$default == -1) {
+            return missingDelimiterValue;
+        }
+        String substring = str.substring(indexOf$default + 1, str.length());
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static /* synthetic */ String substringAfter$default(String str, String str2, String str3, int i, Object obj) {
+        if ((i & 2) != 0) {
+            str3 = str;
+        }
+        return substringAfter(str, str2, str3);
+    }
+
+    public static final String substringAfter(String str, String delimiter, String missingDelimiterValue) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(delimiter, "delimiter");
+        Intrinsics.checkNotNullParameter(missingDelimiterValue, "missingDelimiterValue");
+        int indexOf$default = indexOf$default((CharSequence) str, delimiter, 0, false, 6, (Object) null);
+        if (indexOf$default == -1) {
+            return missingDelimiterValue;
+        }
+        String substring = str.substring(indexOf$default + delimiter.length(), str.length());
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static /* synthetic */ String substringBeforeLast$default(String str, String str2, String str3, int i, Object obj) {
+        if ((i & 2) != 0) {
+            str3 = str;
+        }
+        return substringBeforeLast(str, str2, str3);
+    }
+
+    public static final String substringBeforeLast(String str, String delimiter, String missingDelimiterValue) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(delimiter, "delimiter");
+        Intrinsics.checkNotNullParameter(missingDelimiterValue, "missingDelimiterValue");
+        int lastIndexOf$default = lastIndexOf$default((CharSequence) str, delimiter, 0, false, 6, (Object) null);
+        if (lastIndexOf$default == -1) {
+            return missingDelimiterValue;
+        }
+        String substring = str.substring(0, lastIndexOf$default);
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static /* synthetic */ String substringAfterLast$default(String str, char c, String str2, int i, Object obj) {
+        if ((i & 2) != 0) {
+            str2 = str;
+        }
+        return substringAfterLast(str, c, str2);
+    }
+
+    public static String substringAfterLast(String str, char c, String missingDelimiterValue) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(missingDelimiterValue, "missingDelimiterValue");
+        int lastIndexOf$default = lastIndexOf$default((CharSequence) str, c, 0, false, 6, (Object) null);
+        if (lastIndexOf$default == -1) {
+            return missingDelimiterValue;
+        }
+        String substring = str.substring(lastIndexOf$default + 1, str.length());
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static /* synthetic */ String substringAfterLast$default(String str, String str2, String str3, int i, Object obj) {
+        if ((i & 2) != 0) {
+            str3 = str;
+        }
+        return substringAfterLast(str, str2, str3);
+    }
+
+    public static final String substringAfterLast(String str, String delimiter, String missingDelimiterValue) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(delimiter, "delimiter");
+        Intrinsics.checkNotNullParameter(missingDelimiterValue, "missingDelimiterValue");
+        int lastIndexOf$default = lastIndexOf$default((CharSequence) str, delimiter, 0, false, 6, (Object) null);
+        if (lastIndexOf$default == -1) {
+            return missingDelimiterValue;
+        }
+        String substring = str.substring(lastIndexOf$default + delimiter.length(), str.length());
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static String removePrefix(String str, CharSequence prefix) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        if (!startsWith$default((CharSequence) str, prefix, false, 2, (Object) null)) {
+            return str;
+        }
+        String substring = str.substring(prefix.length());
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static String removeSuffix(String str, CharSequence suffix) {
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        Intrinsics.checkNotNullParameter(suffix, "suffix");
+        if (!endsWith$default((CharSequence) str, suffix, false, 2, (Object) null)) {
+            return str;
+        }
+        String substring = str.substring(0, str.length() - suffix.length());
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static final boolean regionMatchesImpl(CharSequence charSequence, int i, CharSequence other, int i2, int i3, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(other, "other");
+        if (i2 < 0 || i < 0 || i > charSequence.length() - i3 || i2 > other.length() - i3) {
+            return false;
+        }
+        for (int i4 = 0; i4 < i3; i4++) {
+            if (!CharsKt__CharKt.equals(charSequence.charAt(i + i4), other.charAt(i2 + i4), z)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static /* synthetic */ boolean endsWith$default(CharSequence charSequence, char c, boolean z, int i, Object obj) {
+        if ((i & 2) != 0) {
+            z = false;
+        }
+        return endsWith(charSequence, c, z);
+    }
+
+    public static final boolean endsWith(CharSequence charSequence, char c, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        return charSequence.length() > 0 && CharsKt__CharKt.equals(charSequence.charAt(getLastIndex(charSequence)), c, z);
+    }
+
+    public static /* synthetic */ boolean startsWith$default(CharSequence charSequence, CharSequence charSequence2, boolean z, int i, Object obj) {
+        if ((i & 2) != 0) {
+            z = false;
+        }
+        return startsWith(charSequence, charSequence2, z);
+    }
+
+    public static final boolean startsWith(CharSequence charSequence, CharSequence prefix, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        if (!z && (charSequence instanceof String) && (prefix instanceof String)) {
+            return StringsKt__StringsJVMKt.startsWith$default((String) charSequence, (String) prefix, false, 2, null);
+        }
+        return regionMatchesImpl(charSequence, 0, prefix, 0, prefix.length(), z);
+    }
+
+    public static /* synthetic */ boolean endsWith$default(CharSequence charSequence, CharSequence charSequence2, boolean z, int i, Object obj) {
+        if ((i & 2) != 0) {
+            z = false;
+        }
+        return endsWith(charSequence, charSequence2, z);
+    }
+
+    public static final boolean endsWith(CharSequence charSequence, CharSequence suffix, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(suffix, "suffix");
+        if (!z && (charSequence instanceof String) && (suffix instanceof String)) {
+            return StringsKt__StringsJVMKt.endsWith$default((String) charSequence, (String) suffix, false, 2, null);
+        }
+        return regionMatchesImpl(charSequence, charSequence.length() - suffix.length(), suffix, 0, suffix.length(), z);
+    }
+
+    public static final int indexOfAny(CharSequence charSequence, char[] chars, int i, boolean z) {
+        int coerceAtLeast;
+        char single;
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(chars, "chars");
+        if (!z && chars.length == 1 && (charSequence instanceof String)) {
+            single = ArraysKt___ArraysKt.single(chars);
+            return ((String) charSequence).indexOf(single, i);
+        }
+        coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(i, 0);
+        IntIterator it = new IntRange(coerceAtLeast, getLastIndex(charSequence)).iterator();
+        while (it.hasNext()) {
+            int nextInt = it.nextInt();
+            char charAt = charSequence.charAt(nextInt);
+            for (char c : chars) {
+                if (CharsKt__CharKt.equals(c, charAt, z)) {
+                    return nextInt;
+                }
+            }
+        }
+        return -1;
+    }
+
+    public static final int lastIndexOfAny(CharSequence charSequence, char[] chars, int i, boolean z) {
+        int coerceAtMost;
+        char single;
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(chars, "chars");
+        if (!z && chars.length == 1 && (charSequence instanceof String)) {
+            single = ArraysKt___ArraysKt.single(chars);
+            return ((String) charSequence).lastIndexOf(single, i);
+        }
+        for (coerceAtMost = RangesKt___RangesKt.coerceAtMost(i, getLastIndex(charSequence)); -1 < coerceAtMost; coerceAtMost--) {
+            char charAt = charSequence.charAt(coerceAtMost);
+            for (char c : chars) {
+                if (CharsKt__CharKt.equals(c, charAt, z)) {
+                    return coerceAtMost;
+                }
+            }
+        }
+        return -1;
+    }
+
+    public static /* synthetic */ int indexOf$StringsKt__StringsKt$default(CharSequence charSequence, CharSequence charSequence2, int i, int i2, boolean z, boolean z2, int i3, Object obj) {
+        if ((i3 & 16) != 0) {
+            z2 = false;
+        }
+        return indexOf$StringsKt__StringsKt(charSequence, charSequence2, i, i2, z, z2);
+    }
+
+    public static final int indexOf$StringsKt__StringsKt(CharSequence charSequence, CharSequence charSequence2, int i, int i2, boolean z, boolean z2) {
+        int coerceAtMost;
+        int coerceAtLeast;
+        IntProgression downTo;
+        int coerceAtLeast2;
+        int coerceAtMost2;
+        if (!z2) {
+            coerceAtLeast2 = RangesKt___RangesKt.coerceAtLeast(i, 0);
+            coerceAtMost2 = RangesKt___RangesKt.coerceAtMost(i2, charSequence.length());
+            downTo = new IntRange(coerceAtLeast2, coerceAtMost2);
+        } else {
+            coerceAtMost = RangesKt___RangesKt.coerceAtMost(i, getLastIndex(charSequence));
+            coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(i2, 0);
+            downTo = RangesKt___RangesKt.downTo(coerceAtMost, coerceAtLeast);
+        }
+        if ((charSequence instanceof String) && (charSequence2 instanceof String)) {
+            int first = downTo.getFirst();
+            int last = downTo.getLast();
+            int step = downTo.getStep();
+            if ((step <= 0 || first > last) && (step >= 0 || last > first)) {
+                return -1;
+            }
+            while (!StringsKt__StringsJVMKt.regionMatches((String) charSequence2, 0, (String) charSequence, first, charSequence2.length(), z)) {
+                if (first == last) {
+                    return -1;
+                }
+                first += step;
+            }
+            return first;
+        }
+        int first2 = downTo.getFirst();
+        int last2 = downTo.getLast();
+        int step2 = downTo.getStep();
+        if ((step2 <= 0 || first2 > last2) && (step2 >= 0 || last2 > first2)) {
+            return -1;
+        }
+        while (!regionMatchesImpl(charSequence2, 0, charSequence, first2, charSequence2.length(), z)) {
+            if (first2 == last2) {
+                return -1;
+            }
+            first2 += step2;
+        }
+        return first2;
+    }
+
+    public static final Pair findAnyOf$StringsKt__StringsKt(CharSequence charSequence, Collection collection, int i, boolean z, boolean z2) {
+        int coerceAtMost;
+        IntProgression downTo;
+        Object obj;
+        Object obj2;
+        int coerceAtLeast;
+        if (!z && collection.size() == 1) {
+            String str = (String) CollectionsKt___CollectionsKt.single(collection);
+            int indexOf$default = !z2 ? indexOf$default(charSequence, str, i, false, 4, (Object) null) : lastIndexOf$default(charSequence, str, i, false, 4, (Object) null);
+            if (indexOf$default < 0) {
+                return null;
+            }
+            return TuplesKt.to(Integer.valueOf(indexOf$default), str);
+        }
+        if (z2) {
+            coerceAtMost = RangesKt___RangesKt.coerceAtMost(i, getLastIndex(charSequence));
+            downTo = RangesKt___RangesKt.downTo(coerceAtMost, 0);
+        } else {
+            coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(i, 0);
+            downTo = new IntRange(coerceAtLeast, charSequence.length());
+        }
+        if (charSequence instanceof String) {
+            int first = downTo.getFirst();
+            int last = downTo.getLast();
+            int step = downTo.getStep();
+            if ((step > 0 && first <= last) || (step < 0 && last <= first)) {
+                while (true) {
+                    Iterator it = collection.iterator();
+                    while (true) {
+                        if (!it.hasNext()) {
+                            obj2 = null;
+                            break;
+                        }
+                        obj2 = it.next();
+                        String str2 = (String) obj2;
+                        if (StringsKt__StringsJVMKt.regionMatches(str2, 0, (String) charSequence, first, str2.length(), z)) {
+                            break;
+                        }
+                    }
+                    String str3 = (String) obj2;
+                    if (str3 == null) {
+                        if (first == last) {
+                            break;
+                        }
+                        first += step;
+                    } else {
+                        return TuplesKt.to(Integer.valueOf(first), str3);
+                    }
+                }
+            }
+        } else {
+            int first2 = downTo.getFirst();
+            int last2 = downTo.getLast();
+            int step2 = downTo.getStep();
+            if ((step2 > 0 && first2 <= last2) || (step2 < 0 && last2 <= first2)) {
+                while (true) {
+                    Iterator it2 = collection.iterator();
+                    while (true) {
+                        if (!it2.hasNext()) {
+                            obj = null;
+                            break;
+                        }
+                        obj = it2.next();
+                        String str4 = (String) obj;
+                        if (regionMatchesImpl(str4, 0, charSequence, first2, str4.length(), z)) {
+                            break;
+                        }
+                    }
+                    String str5 = (String) obj;
+                    if (str5 == null) {
+                        if (first2 == last2) {
+                            break;
+                        }
+                        first2 += step2;
+                    } else {
+                        return TuplesKt.to(Integer.valueOf(first2), str5);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public static /* synthetic */ int indexOf$default(CharSequence charSequence, char c, int i, boolean z, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            i = 0;
+        }
+        if ((i2 & 4) != 0) {
+            z = false;
+        }
+        return indexOf(charSequence, c, i, z);
+    }
+
+    public static final int indexOf(CharSequence charSequence, char c, int i, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        if (z || !(charSequence instanceof String)) {
+            return indexOfAny(charSequence, new char[]{c}, i, z);
+        }
+        return ((String) charSequence).indexOf(c, i);
+    }
+
+    public static /* synthetic */ int indexOf$default(CharSequence charSequence, String str, int i, boolean z, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            i = 0;
+        }
+        if ((i2 & 4) != 0) {
+            z = false;
+        }
+        return indexOf(charSequence, str, i, z);
+    }
+
+    public static final int indexOf(CharSequence charSequence, String string, int i, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(string, "string");
+        if (z || !(charSequence instanceof String)) {
+            return indexOf$StringsKt__StringsKt$default(charSequence, string, i, charSequence.length(), z, false, 16, null);
+        }
+        return ((String) charSequence).indexOf(string, i);
+    }
+
+    public static /* synthetic */ int lastIndexOf$default(CharSequence charSequence, char c, int i, boolean z, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            i = getLastIndex(charSequence);
+        }
+        if ((i2 & 4) != 0) {
+            z = false;
+        }
+        return lastIndexOf(charSequence, c, i, z);
+    }
+
+    public static final int lastIndexOf(CharSequence charSequence, char c, int i, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        if (z || !(charSequence instanceof String)) {
+            return lastIndexOfAny(charSequence, new char[]{c}, i, z);
+        }
+        return ((String) charSequence).lastIndexOf(c, i);
+    }
+
+    public static /* synthetic */ int lastIndexOf$default(CharSequence charSequence, String str, int i, boolean z, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            i = getLastIndex(charSequence);
+        }
+        if ((i2 & 4) != 0) {
+            z = false;
+        }
+        return lastIndexOf(charSequence, str, i, z);
+    }
+
+    public static final int lastIndexOf(CharSequence charSequence, String string, int i, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(string, "string");
+        if (z || !(charSequence instanceof String)) {
+            return indexOf$StringsKt__StringsKt(charSequence, string, i, 0, z, true);
+        }
+        return ((String) charSequence).lastIndexOf(string, i);
+    }
+
+    public static /* synthetic */ boolean contains$default(CharSequence charSequence, CharSequence charSequence2, boolean z, int i, Object obj) {
+        if ((i & 2) != 0) {
+            z = false;
+        }
+        return contains(charSequence, charSequence2, z);
+    }
+
+    public static boolean contains(CharSequence charSequence, CharSequence other, boolean z) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(other, "other");
+        if (other instanceof String) {
+            if (indexOf$default(charSequence, (String) other, 0, z, 2, (Object) null) < 0) {
+                return false;
+            }
+        } else if (indexOf$StringsKt__StringsKt$default(charSequence, other, 0, charSequence.length(), z, false, 16, null) < 0) {
+            return false;
+        }
+        return true;
+    }
+
+    public static /* synthetic */ Sequence rangesDelimitedBy$StringsKt__StringsKt$default(CharSequence charSequence, char[] cArr, int i, boolean z, int i2, int i3, Object obj) {
+        if ((i3 & 2) != 0) {
+            i = 0;
+        }
+        if ((i3 & 4) != 0) {
+            z = false;
+        }
+        if ((i3 & 8) != 0) {
+            i2 = 0;
+        }
+        return rangesDelimitedBy$StringsKt__StringsKt(charSequence, cArr, i, z, i2);
+    }
+
+    public static final Sequence rangesDelimitedBy$StringsKt__StringsKt(CharSequence charSequence, final char[] cArr, int i, final boolean z, int i2) {
+        requireNonNegativeLimit(i2);
+        return new DelimitedRangesSequence(charSequence, i, i2, new Function2() { // from class: kotlin.text.StringsKt__StringsKt$rangesDelimitedBy$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(2);
+            }
+
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                return invoke((CharSequence) obj, ((Number) obj2).intValue());
+            }
+
+            public final Pair invoke(CharSequence $receiver, int i3) {
+                Intrinsics.checkNotNullParameter($receiver, "$this$$receiver");
+                int indexOfAny = StringsKt__StringsKt.indexOfAny($receiver, cArr, i3, z);
+                if (indexOfAny < 0) {
+                    return null;
+                }
+                return TuplesKt.to(Integer.valueOf(indexOfAny), 1);
+            }
+        });
+    }
+
+    public static /* synthetic */ Sequence rangesDelimitedBy$StringsKt__StringsKt$default(CharSequence charSequence, String[] strArr, int i, boolean z, int i2, int i3, Object obj) {
+        if ((i3 & 2) != 0) {
+            i = 0;
+        }
+        if ((i3 & 4) != 0) {
+            z = false;
+        }
+        if ((i3 & 8) != 0) {
+            i2 = 0;
+        }
+        return rangesDelimitedBy$StringsKt__StringsKt(charSequence, strArr, i, z, i2);
+    }
+
+    public static final Sequence rangesDelimitedBy$StringsKt__StringsKt(CharSequence charSequence, String[] strArr, int i, final boolean z, int i2) {
+        final List asList;
+        requireNonNegativeLimit(i2);
+        asList = ArraysKt___ArraysJvmKt.asList(strArr);
+        return new DelimitedRangesSequence(charSequence, i, i2, new Function2() { // from class: kotlin.text.StringsKt__StringsKt$rangesDelimitedBy$2
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(2);
+            }
+
+            @Override // kotlin.jvm.functions.Function2
+            public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
+                return invoke((CharSequence) obj, ((Number) obj2).intValue());
+            }
+
+            public final Pair invoke(CharSequence $receiver, int i3) {
+                Pair findAnyOf$StringsKt__StringsKt;
+                Intrinsics.checkNotNullParameter($receiver, "$this$$receiver");
+                findAnyOf$StringsKt__StringsKt = StringsKt__StringsKt.findAnyOf$StringsKt__StringsKt($receiver, asList, i3, z, false);
+                if (findAnyOf$StringsKt__StringsKt != null) {
+                    return TuplesKt.to(findAnyOf$StringsKt__StringsKt.getFirst(), Integer.valueOf(((String) findAnyOf$StringsKt__StringsKt.getSecond()).length()));
+                }
+                return null;
+            }
+        });
+    }
+
+    public static final void requireNonNegativeLimit(int i) {
+        if (i >= 0) {
+            return;
+        }
+        throw new IllegalArgumentException(("Limit must be non-negative, but was " + i).toString());
+    }
+
+    public static /* synthetic */ Sequence splitToSequence$default(CharSequence charSequence, String[] strArr, boolean z, int i, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            z = false;
+        }
+        if ((i2 & 4) != 0) {
+            i = 0;
+        }
+        return splitToSequence(charSequence, strArr, z, i);
+    }
+
+    public static final Sequence splitToSequence(final CharSequence charSequence, String[] delimiters, boolean z, int i) {
+        Sequence map;
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(delimiters, "delimiters");
+        map = SequencesKt___SequencesKt.map(rangesDelimitedBy$StringsKt__StringsKt$default(charSequence, delimiters, 0, z, i, 2, (Object) null), new Function1() { // from class: kotlin.text.StringsKt__StringsKt$splitToSequence$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public final String invoke(IntRange it) {
+                Intrinsics.checkNotNullParameter(it, "it");
+                return StringsKt__StringsKt.substring(charSequence, it);
+            }
+        });
+        return map;
+    }
+
+    public static /* synthetic */ List split$default(CharSequence charSequence, String[] strArr, boolean z, int i, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            z = false;
+        }
+        if ((i2 & 4) != 0) {
+            i = 0;
+        }
+        return split(charSequence, strArr, z, i);
+    }
+
+    public static final List split(CharSequence charSequence, String[] delimiters, boolean z, int i) {
+        Iterable asIterable;
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(delimiters, "delimiters");
+        if (delimiters.length == 1) {
+            String str = delimiters[0];
+            if (str.length() != 0) {
+                return split$StringsKt__StringsKt(charSequence, str, z, i);
+            }
+        }
+        asIterable = SequencesKt___SequencesKt.asIterable(rangesDelimitedBy$StringsKt__StringsKt$default(charSequence, delimiters, 0, z, i, 2, (Object) null));
+        ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(asIterable, 10));
+        Iterator it = asIterable.iterator();
+        while (it.hasNext()) {
+            arrayList.add(substring(charSequence, (IntRange) it.next()));
+        }
+        return arrayList;
+    }
+
+    public static /* synthetic */ List split$default(CharSequence charSequence, char[] cArr, boolean z, int i, int i2, Object obj) {
+        if ((i2 & 2) != 0) {
+            z = false;
+        }
+        if ((i2 & 4) != 0) {
+            i = 0;
+        }
+        return split(charSequence, cArr, z, i);
+    }
+
+    public static final List split(CharSequence charSequence, char[] delimiters, boolean z, int i) {
+        Iterable asIterable;
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        Intrinsics.checkNotNullParameter(delimiters, "delimiters");
+        if (delimiters.length == 1) {
+            return split$StringsKt__StringsKt(charSequence, String.valueOf(delimiters[0]), z, i);
+        }
+        asIterable = SequencesKt___SequencesKt.asIterable(rangesDelimitedBy$StringsKt__StringsKt$default(charSequence, delimiters, 0, z, i, 2, (Object) null));
+        ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(asIterable, 10));
+        Iterator it = asIterable.iterator();
+        while (it.hasNext()) {
+            arrayList.add(substring(charSequence, (IntRange) it.next()));
+        }
+        return arrayList;
+    }
+
+    public static final List split$StringsKt__StringsKt(CharSequence charSequence, String str, boolean z, int i) {
+        requireNonNegativeLimit(i);
+        int i2 = 0;
+        int indexOf = indexOf(charSequence, str, 0, z);
+        if (indexOf == -1 || i == 1) {
+            return CollectionsKt__CollectionsJVMKt.listOf(charSequence.toString());
+        }
+        boolean z2 = i > 0;
+        ArrayList arrayList = new ArrayList(z2 ? RangesKt___RangesKt.coerceAtMost(i, 10) : 10);
+        do {
+            arrayList.add(charSequence.subSequence(i2, indexOf).toString());
+            i2 = str.length() + indexOf;
+            if (z2 && arrayList.size() == i - 1) {
+                break;
+            }
+            indexOf = indexOf(charSequence, str, i2, z);
+        } while (indexOf != -1);
+        arrayList.add(charSequence.subSequence(i2, charSequence.length()).toString());
+        return arrayList;
+    }
+
+    public static Sequence lineSequence(CharSequence charSequence) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        return splitToSequence$default(charSequence, new String[]{"\r\n", "\n", "\r"}, false, 0, 6, null);
+    }
+
+    public static final List lines(CharSequence charSequence) {
+        List list;
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        list = SequencesKt___SequencesKt.toList(lineSequence(charSequence));
+        return list;
+    }
+}

decompiled/sources/kotlin/text/StringsKt___StringsJvmKt.java

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

decompiled/sources/kotlin/text/StringsKt___StringsKt.java

@@ -0,0 +1,40 @@
+package kotlin.text;
+
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.RangesKt___RangesKt;
+
+/* loaded from: classes5.dex */
+public abstract class StringsKt___StringsKt extends StringsKt___StringsJvmKt {
+    public static char last(CharSequence charSequence) {
+        Intrinsics.checkNotNullParameter(charSequence, "<this>");
+        if (charSequence.length() == 0) {
+            throw new NoSuchElementException("Char sequence is empty.");
+        }
+        return charSequence.charAt(StringsKt__StringsKt.getLastIndex(charSequence));
+    }
+
+    public static final String drop(String str, int i) {
+        int coerceAtMost;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        if (i < 0) {
+            throw new IllegalArgumentException(("Requested character count " + i + " is less than zero.").toString());
+        }
+        coerceAtMost = RangesKt___RangesKt.coerceAtMost(i, str.length());
+        String substring = str.substring(coerceAtMost);
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+
+    public static String take(String str, int i) {
+        int coerceAtMost;
+        Intrinsics.checkNotNullParameter(str, "<this>");
+        if (i < 0) {
+            throw new IllegalArgumentException(("Requested character count " + i + " is less than zero.").toString());
+        }
+        coerceAtMost = RangesKt___RangesKt.coerceAtMost(i, str.length());
+        String substring = str.substring(0, coerceAtMost);
+        Intrinsics.checkNotNullExpressionValue(substring, "substring(...)");
+        return substring;
+    }
+}