package E1;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import o1.AbstractC0653A;
import o1.AbstractC0668d;
import o1.AbstractC0676l;

/* JADX INFO: Access modifiers changed from: package-private */
/* JADX INFO: loaded from: classes.dex */
public abstract class q extends p {

    static final class a extends kotlin.jvm.internal.m implements y1.p {

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        final /* synthetic */ char[] f553b;

        /* JADX INFO: renamed from: g, reason: collision with root package name */
        final /* synthetic */ boolean f554g;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        a(char[] cArr, boolean z2) {
            super(2);
            this.f553b = cArr;
            this.f554g = z2;
        }

        public final n1.k a(CharSequence $receiver, int i2) {
            kotlin.jvm.internal.l.e($receiver, "$this$$receiver");
            int iP = q.P($receiver, this.f553b, i2, this.f554g);
            if (iP < 0) {
                return null;
            }
            return n1.p.a(Integer.valueOf(iP), 1);
        }

        @Override // y1.p
        public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
            return a((CharSequence) obj, ((Number) obj2).intValue());
        }
    }

    static final class b extends kotlin.jvm.internal.m implements y1.p {

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        final /* synthetic */ List f555b;

        /* JADX INFO: renamed from: g, reason: collision with root package name */
        final /* synthetic */ boolean f556g;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        b(List list, boolean z2) {
            super(2);
            this.f555b = list;
            this.f556g = z2;
        }

        public final n1.k a(CharSequence $receiver, int i2) {
            kotlin.jvm.internal.l.e($receiver, "$this$$receiver");
            n1.k kVarG = q.G($receiver, this.f555b, i2, this.f556g, false);
            if (kVarG != null) {
                return n1.p.a(kVarG.c(), Integer.valueOf(((String) kVarG.d()).length()));
            }
            return null;
        }

        @Override // y1.p
        public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
            return a((CharSequence) obj, ((Number) obj2).intValue());
        }
    }

    static final class c extends kotlin.jvm.internal.m implements y1.l {

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        final /* synthetic */ CharSequence f557b;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        c(CharSequence charSequence) {
            super(1);
            this.f557b = charSequence;
        }

        @Override // y1.l
        /* JADX INFO: renamed from: a, reason: merged with bridge method [inline-methods] */
        public final String invoke(kotlin.ranges.i it) {
            kotlin.jvm.internal.l.e(it, "it");
            return q.q0(this.f557b, it);
        }
    }

    public static final boolean A(CharSequence charSequence, char c2, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        return g.N(charSequence, c2, 0, z2, 2, null) >= 0;
    }

    public static final boolean B(CharSequence charSequence, CharSequence other, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(other, "other");
        if (other instanceof String) {
            if (g.O(charSequence, (String) other, 0, z2, 2, null) < 0) {
                return false;
            }
        } else if (M(charSequence, other, 0, charSequence.length(), z2, false, 16, null) < 0) {
            return false;
        }
        return true;
    }

    public static /* synthetic */ boolean C(CharSequence charSequence, char c2, boolean z2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z2 = false;
        }
        return A(charSequence, c2, z2);
    }

    public static /* synthetic */ boolean D(CharSequence charSequence, CharSequence charSequence2, boolean z2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z2 = false;
        }
        return B(charSequence, charSequence2, z2);
    }

    public static final boolean E(CharSequence charSequence, CharSequence suffix, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(suffix, "suffix");
        return (!z2 && (charSequence instanceof String) && (suffix instanceof String)) ? g.k((String) charSequence, (String) suffix, false, 2, null) : b0(charSequence, charSequence.length() - suffix.length(), suffix, 0, suffix.length(), z2);
    }

    public static /* synthetic */ boolean F(CharSequence charSequence, CharSequence charSequence2, boolean z2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z2 = false;
        }
        return E(charSequence, charSequence2, z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final n1.k G(CharSequence charSequence, Collection collection, int i2, boolean z2, boolean z3) {
        Object next;
        Object next2;
        if (!z2 && collection.size() == 1) {
            String str = (String) AbstractC0676l.J(collection);
            int iO = !z3 ? g.O(charSequence, str, i2, false, 4, null) : g.T(charSequence, str, i2, false, 4, null);
            if (iO < 0) {
                return null;
            }
            return n1.p.a(Integer.valueOf(iO), str);
        }
        kotlin.ranges.g iVar = !z3 ? new kotlin.ranges.i(kotlin.ranges.m.b(i2, 0), charSequence.length()) : kotlin.ranges.m.g(kotlin.ranges.m.d(i2, I(charSequence)), 0);
        if (charSequence instanceof String) {
            int iA = iVar.a();
            int iB = iVar.b();
            int iC = iVar.c();
            if ((iC > 0 && iA <= iB) || (iC < 0 && iB <= iA)) {
                while (true) {
                    Iterator it = collection.iterator();
                    while (true) {
                        if (!it.hasNext()) {
                            next2 = null;
                            break;
                        }
                        next2 = it.next();
                        String str2 = (String) next2;
                        if (p.o(str2, 0, (String) charSequence, iA, str2.length(), z2)) {
                            break;
                        }
                    }
                    String str3 = (String) next2;
                    if (str3 == null) {
                        if (iA == iB) {
                            break;
                        }
                        iA += iC;
                    } else {
                        return n1.p.a(Integer.valueOf(iA), str3);
                    }
                }
            }
        } else {
            int iA2 = iVar.a();
            int iB2 = iVar.b();
            int iC2 = iVar.c();
            if ((iC2 > 0 && iA2 <= iB2) || (iC2 < 0 && iB2 <= iA2)) {
                while (true) {
                    Iterator it2 = collection.iterator();
                    while (true) {
                        if (!it2.hasNext()) {
                            next = null;
                            break;
                        }
                        next = it2.next();
                        String str4 = (String) next;
                        if (b0(str4, 0, charSequence, iA2, str4.length(), z2)) {
                            break;
                        }
                    }
                    String str5 = (String) next;
                    if (str5 == null) {
                        if (iA2 == iB2) {
                            break;
                        }
                        iA2 += iC2;
                    } else {
                        return n1.p.a(Integer.valueOf(iA2), str5);
                    }
                }
            }
        }
        return null;
    }

    public static final kotlin.ranges.i H(CharSequence charSequence) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        return new kotlin.ranges.i(0, charSequence.length() - 1);
    }

    public static final int I(CharSequence charSequence) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        return charSequence.length() - 1;
    }

    public static final int J(CharSequence charSequence, char c2, int i2, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        return (z2 || !(charSequence instanceof String)) ? P(charSequence, new char[]{c2}, i2, z2) : ((String) charSequence).indexOf(c2, i2);
    }

    public static final int K(CharSequence charSequence, String string, int i2, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(string, "string");
        return (z2 || !(charSequence instanceof String)) ? M(charSequence, string, i2, charSequence.length(), z2, false, 16, null) : ((String) charSequence).indexOf(string, i2);
    }

    private static final int L(CharSequence charSequence, CharSequence charSequence2, int i2, int i3, boolean z2, boolean z3) {
        kotlin.ranges.g iVar = !z3 ? new kotlin.ranges.i(kotlin.ranges.m.b(i2, 0), kotlin.ranges.m.d(i3, charSequence.length())) : kotlin.ranges.m.g(kotlin.ranges.m.d(i2, I(charSequence)), kotlin.ranges.m.b(i3, 0));
        if ((charSequence instanceof String) && (charSequence2 instanceof String)) {
            int iA = iVar.a();
            int iB = iVar.b();
            int iC = iVar.c();
            if ((iC <= 0 || iA > iB) && (iC >= 0 || iB > iA)) {
                return -1;
            }
            while (!p.o((String) charSequence2, 0, (String) charSequence, iA, charSequence2.length(), z2)) {
                if (iA == iB) {
                    return -1;
                }
                iA += iC;
            }
            return iA;
        }
        int iA2 = iVar.a();
        int iB2 = iVar.b();
        int iC2 = iVar.c();
        if ((iC2 <= 0 || iA2 > iB2) && (iC2 >= 0 || iB2 > iA2)) {
            return -1;
        }
        while (!b0(charSequence2, 0, charSequence, iA2, charSequence2.length(), z2)) {
            if (iA2 == iB2) {
                return -1;
            }
            iA2 += iC2;
        }
        return iA2;
    }

    static /* synthetic */ int M(CharSequence charSequence, CharSequence charSequence2, int i2, int i3, boolean z2, boolean z3, int i4, Object obj) {
        if ((i4 & 16) != 0) {
            z3 = false;
        }
        return L(charSequence, charSequence2, i2, i3, z2, z3);
    }

    public static /* synthetic */ int N(CharSequence charSequence, char c2, int i2, boolean z2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            i2 = 0;
        }
        if ((i3 & 4) != 0) {
            z2 = false;
        }
        return J(charSequence, c2, i2, z2);
    }

    public static /* synthetic */ int O(CharSequence charSequence, String str, int i2, boolean z2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            i2 = 0;
        }
        if ((i3 & 4) != 0) {
            z2 = false;
        }
        return K(charSequence, str, i2, z2);
    }

    public static final int P(CharSequence charSequence, char[] chars, int i2, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(chars, "chars");
        if (!z2 && chars.length == 1 && (charSequence instanceof String)) {
            return ((String) charSequence).indexOf(AbstractC0668d.A(chars), i2);
        }
        AbstractC0653A it = new kotlin.ranges.i(kotlin.ranges.m.b(i2, 0), I(charSequence)).iterator();
        while (it.hasNext()) {
            int iNextInt = it.nextInt();
            char cCharAt = charSequence.charAt(iNextInt);
            for (char c2 : chars) {
                if (E1.c.d(c2, cCharAt, z2)) {
                    return iNextInt;
                }
            }
        }
        return -1;
    }

    public static final int Q(CharSequence charSequence, char c2, int i2, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        return (z2 || !(charSequence instanceof String)) ? U(charSequence, new char[]{c2}, i2, z2) : ((String) charSequence).lastIndexOf(c2, i2);
    }

    public static final int R(CharSequence charSequence, String string, int i2, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(string, "string");
        return (z2 || !(charSequence instanceof String)) ? L(charSequence, string, i2, 0, z2, true) : ((String) charSequence).lastIndexOf(string, i2);
    }

    public static /* synthetic */ int S(CharSequence charSequence, char c2, int i2, boolean z2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            i2 = I(charSequence);
        }
        if ((i3 & 4) != 0) {
            z2 = false;
        }
        return Q(charSequence, c2, i2, z2);
    }

    public static /* synthetic */ int T(CharSequence charSequence, String str, int i2, boolean z2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            i2 = I(charSequence);
        }
        if ((i3 & 4) != 0) {
            z2 = false;
        }
        return R(charSequence, str, i2, z2);
    }

    public static final int U(CharSequence charSequence, char[] chars, int i2, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(chars, "chars");
        if (!z2 && chars.length == 1 && (charSequence instanceof String)) {
            return ((String) charSequence).lastIndexOf(AbstractC0668d.A(chars), i2);
        }
        for (int iD = kotlin.ranges.m.d(i2, I(charSequence)); -1 < iD; iD--) {
            char cCharAt = charSequence.charAt(iD);
            for (char c2 : chars) {
                if (E1.c.d(c2, cCharAt, z2)) {
                    return iD;
                }
            }
        }
        return -1;
    }

    public static final D1.f V(CharSequence charSequence) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        return n0(charSequence, new String[]{"\r\n", "\n", "\r"}, false, 0, 6, null);
    }

    public static final List W(CharSequence charSequence) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        return D1.i.l(V(charSequence));
    }

    private static final D1.f X(CharSequence charSequence, char[] cArr, int i2, boolean z2, int i3) {
        g0(i3);
        return new e(charSequence, i2, i3, new a(cArr, z2));
    }

    private static final D1.f Y(CharSequence charSequence, String[] strArr, int i2, boolean z2, int i3) {
        g0(i3);
        return new e(charSequence, i2, i3, new b(AbstractC0668d.b(strArr), z2));
    }

    static /* synthetic */ D1.f Z(CharSequence charSequence, char[] cArr, int i2, boolean z2, int i3, int i4, Object obj) {
        if ((i4 & 2) != 0) {
            i2 = 0;
        }
        if ((i4 & 4) != 0) {
            z2 = false;
        }
        if ((i4 & 8) != 0) {
            i3 = 0;
        }
        return X(charSequence, cArr, i2, z2, i3);
    }

    static /* synthetic */ D1.f a0(CharSequence charSequence, String[] strArr, int i2, boolean z2, int i3, int i4, Object obj) {
        if ((i4 & 2) != 0) {
            i2 = 0;
        }
        if ((i4 & 4) != 0) {
            z2 = false;
        }
        if ((i4 & 8) != 0) {
            i3 = 0;
        }
        return Y(charSequence, strArr, i2, z2, i3);
    }

    public static final boolean b0(CharSequence charSequence, int i2, CharSequence other, int i3, int i4, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(other, "other");
        if (i3 < 0 || i2 < 0 || i2 > charSequence.length() - i4 || i3 > other.length() - i4) {
            return false;
        }
        for (int i5 = 0; i5 < i4; i5++) {
            if (!E1.c.d(charSequence.charAt(i2 + i5), other.charAt(i3 + i5), z2)) {
                return false;
            }
        }
        return true;
    }

    public static String c0(String str, CharSequence prefix) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(prefix, "prefix");
        if (!p0(str, prefix, false, 2, null)) {
            return str;
        }
        String strSubstring = str.substring(prefix.length());
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String d0(String str, CharSequence suffix) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(suffix, "suffix");
        if (!F(str, suffix, false, 2, null)) {
            return str;
        }
        String strSubstring = str.substring(0, str.length() - suffix.length());
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String e0(String str, CharSequence delimiter) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(delimiter, "delimiter");
        return f0(str, delimiter, delimiter);
    }

    public static final String f0(String str, CharSequence prefix, CharSequence suffix) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(prefix, "prefix");
        kotlin.jvm.internal.l.e(suffix, "suffix");
        if (str.length() < prefix.length() + suffix.length() || !p0(str, prefix, false, 2, null) || !F(str, suffix, false, 2, null)) {
            return str;
        }
        String strSubstring = str.substring(prefix.length(), str.length() - suffix.length());
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static final void g0(int i2) {
        if (i2 >= 0) {
            return;
        }
        throw new IllegalArgumentException(("Limit must be non-negative, but was " + i2).toString());
    }

    public static final List h0(CharSequence charSequence, char[] delimiters, boolean z2, int i2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(delimiters, "delimiters");
        if (delimiters.length == 1) {
            return j0(charSequence, String.valueOf(delimiters[0]), z2, i2);
        }
        Iterable iterableF = D1.i.f(Z(charSequence, delimiters, 0, z2, i2, 2, null));
        ArrayList arrayList = new ArrayList(AbstractC0676l.o(iterableF, 10));
        Iterator it = iterableF.iterator();
        while (it.hasNext()) {
            arrayList.add(q0(charSequence, (kotlin.ranges.i) it.next()));
        }
        return arrayList;
    }

    public static final List i0(CharSequence charSequence, String[] delimiters, boolean z2, int i2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(delimiters, "delimiters");
        if (delimiters.length == 1) {
            String str = delimiters[0];
            if (str.length() != 0) {
                return j0(charSequence, str, z2, i2);
            }
        }
        Iterable iterableF = D1.i.f(a0(charSequence, delimiters, 0, z2, i2, 2, null));
        ArrayList arrayList = new ArrayList(AbstractC0676l.o(iterableF, 10));
        Iterator it = iterableF.iterator();
        while (it.hasNext()) {
            arrayList.add(q0(charSequence, (kotlin.ranges.i) it.next()));
        }
        return arrayList;
    }

    private static final List j0(CharSequence charSequence, String str, boolean z2, int i2) {
        g0(i2);
        int length = 0;
        int iK = K(charSequence, str, 0, z2);
        if (iK == -1 || i2 == 1) {
            return AbstractC0676l.b(charSequence.toString());
        }
        boolean z3 = i2 > 0;
        ArrayList arrayList = new ArrayList(z3 ? kotlin.ranges.m.d(i2, 10) : 10);
        do {
            arrayList.add(charSequence.subSequence(length, iK).toString());
            length = str.length() + iK;
            if (z3 && arrayList.size() == i2 - 1) {
                break;
            }
            iK = K(charSequence, str, length, z2);
        } while (iK != -1);
        arrayList.add(charSequence.subSequence(length, charSequence.length()).toString());
        return arrayList;
    }

    public static /* synthetic */ List k0(CharSequence charSequence, char[] cArr, boolean z2, int i2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            z2 = false;
        }
        if ((i3 & 4) != 0) {
            i2 = 0;
        }
        return h0(charSequence, cArr, z2, i2);
    }

    public static /* synthetic */ List l0(CharSequence charSequence, String[] strArr, boolean z2, int i2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            z2 = false;
        }
        if ((i3 & 4) != 0) {
            i2 = 0;
        }
        return i0(charSequence, strArr, z2, i2);
    }

    public static final D1.f m0(CharSequence charSequence, String[] delimiters, boolean z2, int i2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(delimiters, "delimiters");
        return D1.i.k(a0(charSequence, delimiters, 0, z2, i2, 2, null), new c(charSequence));
    }

    public static /* synthetic */ D1.f n0(CharSequence charSequence, String[] strArr, boolean z2, int i2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            z2 = false;
        }
        if ((i3 & 4) != 0) {
            i2 = 0;
        }
        return m0(charSequence, strArr, z2, i2);
    }

    public static final boolean o0(CharSequence charSequence, CharSequence prefix, boolean z2) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(prefix, "prefix");
        return (!z2 && (charSequence instanceof String) && (prefix instanceof String)) ? g.y((String) charSequence, (String) prefix, false, 2, null) : b0(charSequence, 0, prefix, 0, prefix.length(), z2);
    }

    public static /* synthetic */ boolean p0(CharSequence charSequence, CharSequence charSequence2, boolean z2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z2 = false;
        }
        return o0(charSequence, charSequence2, z2);
    }

    public static final String q0(CharSequence charSequence, kotlin.ranges.i range) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        kotlin.jvm.internal.l.e(range, "range");
        return charSequence.subSequence(range.getStart().intValue(), range.getEndInclusive().intValue() + 1).toString();
    }

    public static final String r0(String str, char c2, String missingDelimiterValue) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(missingDelimiterValue, "missingDelimiterValue");
        int iN = g.N(str, c2, 0, false, 6, null);
        if (iN == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = str.substring(iN + 1, str.length());
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String s0(String str, String delimiter, String missingDelimiterValue) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(delimiter, "delimiter");
        kotlin.jvm.internal.l.e(missingDelimiterValue, "missingDelimiterValue");
        int iO = g.O(str, delimiter, 0, false, 6, null);
        if (iO == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = str.substring(iO + delimiter.length(), str.length());
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static /* synthetic */ String t0(String str, char c2, String str2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            str2 = str;
        }
        return r0(str, c2, str2);
    }

    public static /* synthetic */ String u0(String str, String str2, String str3, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            str3 = str;
        }
        return g.s0(str, str2, str3);
    }

    public static final String v0(String str, char c2, String missingDelimiterValue) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(missingDelimiterValue, "missingDelimiterValue");
        int iS = g.S(str, c2, 0, false, 6, null);
        if (iS == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = str.substring(iS + 1, str.length());
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static /* synthetic */ String w0(String str, char c2, String str2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            str2 = str;
        }
        return v0(str, c2, str2);
    }

    public static String x0(String str, String delimiter, String missingDelimiterValue) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(delimiter, "delimiter");
        kotlin.jvm.internal.l.e(missingDelimiterValue, "missingDelimiterValue");
        int iO = g.O(str, delimiter, 0, false, 6, null);
        if (iO == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = str.substring(0, iO);
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static CharSequence y0(CharSequence charSequence) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        int length = charSequence.length() - 1;
        int i2 = 0;
        boolean z2 = false;
        while (i2 <= length) {
            boolean zC = E1.b.c(charSequence.charAt(!z2 ? i2 : length));
            if (z2) {
                if (!zC) {
                    break;
                }
                length--;
            } else if (zC) {
                i2++;
            } else {
                z2 = true;
            }
        }
        return charSequence.subSequence(i2, length + 1);
    }
}