package S4;

import B.C0053c;
import a.AbstractC0872a;
import androidx.compose.runtime.external.kotlinx.collections.immutable.PersistentCollection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import n2.AbstractC2612c;
import x4.AbstractC3250p;
import x4.AbstractC3253s;

/* JADX INFO: loaded from: classes3.dex */
public abstract class p extends w {
    public static boolean D0(CharSequence charSequence, CharSequence other, boolean z6) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        kotlin.jvm.internal.o.h(other, "other");
        if (other instanceof String) {
            if (O0(charSequence, (String) other, 0, z6, 2) >= 0) {
                return true;
            }
        } else if (M0(charSequence, other, 0, charSequence.length(), z6, false) >= 0) {
            return true;
        }
        return false;
    }

    public static boolean E0(CharSequence charSequence, char c6) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        return N0(charSequence, c6, 0, 2) >= 0;
    }

    public static String G0(int i6, String str) {
        kotlin.jvm.internal.o.h(str, "<this>");
        if (i6 < 0) {
            throw new IllegalArgumentException(Z0.o.j(i6, "Requested character count ", " is less than zero.").toString());
        }
        int length = str.length();
        if (i6 > length) {
            i6 = length;
        }
        String strSubstring = str.substring(i6);
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String H0(String str) {
        int length = str.length() - 1;
        if (length < 0) {
            length = 0;
        }
        return m1(length, str);
    }

    public static boolean I0(CharSequence charSequence, String str) {
        return charSequence instanceof String ? w.s0((String) charSequence, str, false) : W0(charSequence, charSequence.length() - str.length(), str, 0, str.length(), false);
    }

    public static boolean J0(String str, char c6) {
        return str.length() > 0 && AbstractC0872a.B(str.charAt(K0(str)), c6, false);
    }

    public static int K0(CharSequence charSequence) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        return charSequence.length() - 1;
    }

    public static final int L0(CharSequence charSequence, String string, int i6, boolean z6) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        kotlin.jvm.internal.o.h(string, "string");
        return (z6 || !(charSequence instanceof String)) ? M0(charSequence, string, i6, charSequence.length(), z6, false) : ((String) charSequence).indexOf(string, i6);
    }

    public static final int M0(CharSequence charSequence, CharSequence charSequence2, int i6, int i7, boolean z6, boolean z7) {
        P4.e eVar;
        if (z7) {
            int iK0 = K0(charSequence);
            if (i6 > iK0) {
                i6 = iK0;
            }
            if (i7 < 0) {
                i7 = 0;
            }
            eVar = new P4.e(i6, i7, -1);
        } else {
            if (i6 < 0) {
                i6 = 0;
            }
            int length = charSequence.length();
            if (i7 > length) {
                i7 = length;
            }
            eVar = new P4.g(i6, i7, 1);
        }
        boolean z8 = charSequence instanceof String;
        int i8 = eVar.f5678c;
        int i9 = eVar.f5677b;
        int i10 = eVar.f5676a;
        if (!z8 || !(charSequence2 instanceof String)) {
            boolean z9 = z6;
            if ((i8 > 0 && i10 <= i9) || (i8 < 0 && i9 <= i10)) {
                while (true) {
                    CharSequence charSequence3 = charSequence;
                    CharSequence charSequence4 = charSequence2;
                    boolean z10 = z9;
                    z9 = z10;
                    if (!W0(charSequence4, 0, charSequence3, i10, charSequence2.length(), z10)) {
                        if (i10 == i9) {
                            break;
                        }
                        i10 += i8;
                        charSequence2 = charSequence4;
                        charSequence = charSequence3;
                    } else {
                        return i10;
                    }
                }
            }
        } else if ((i8 > 0 && i10 <= i9) || (i8 < 0 && i9 <= i10)) {
            int i11 = i10;
            while (true) {
                String str = (String) charSequence2;
                boolean z11 = z6;
                if (!w.v0(0, i11, str.length(), str, (String) charSequence, z11)) {
                    if (i11 == i9) {
                        break;
                    }
                    i11 += i8;
                    z6 = z11;
                } else {
                    return i11;
                }
            }
        }
        return -1;
    }

    public static int N0(CharSequence charSequence, char c6, int i6, int i7) {
        if ((i7 & 2) != 0) {
            i6 = 0;
        }
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        return !(charSequence instanceof String) ? P0(charSequence, new char[]{c6}, i6, false) : ((String) charSequence).indexOf(c6, i6);
    }

    public static /* synthetic */ int O0(CharSequence charSequence, String str, int i6, boolean z6, int i7) {
        if ((i7 & 2) != 0) {
            i6 = 0;
        }
        if ((i7 & 4) != 0) {
            z6 = false;
        }
        return L0(charSequence, str, i6, z6);
    }

    public static final int P0(CharSequence charSequence, char[] cArr, int i6, boolean z6) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        if (!z6 && cArr.length == 1 && (charSequence instanceof String)) {
            return ((String) charSequence).indexOf(AbstractC3250p.U(cArr), i6);
        }
        if (i6 < 0) {
            i6 = 0;
        }
        int iK0 = K0(charSequence);
        if (i6 > iK0) {
            return -1;
        }
        while (true) {
            char cCharAt = charSequence.charAt(i6);
            for (char c6 : cArr) {
                if (AbstractC0872a.B(c6, cCharAt, z6)) {
                    return i6;
                }
            }
            if (i6 == iK0) {
                return -1;
            }
            i6++;
        }
    }

    public static boolean Q0(CharSequence charSequence) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        for (int i6 = 0; i6 < charSequence.length(); i6++) {
            if (!AbstractC0872a.W(charSequence.charAt(i6))) {
                return false;
            }
        }
        return true;
    }

    public static char R0(CharSequence charSequence) {
        if (charSequence.length() != 0) {
            return charSequence.charAt(K0(charSequence));
        }
        throw new NoSuchElementException("Char sequence is empty.");
    }

    public static int S0(int i6, String str, String string) {
        int iK0 = (i6 & 2) != 0 ? K0(str) : 0;
        kotlin.jvm.internal.o.h(str, "<this>");
        kotlin.jvm.internal.o.h(string, "string");
        return str.lastIndexOf(string, iK0);
    }

    public static int T0(CharSequence charSequence, char c6, int i6, int i7) {
        if ((i7 & 2) != 0) {
            i6 = K0(charSequence);
        }
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        if (charSequence instanceof String) {
            return ((String) charSequence).lastIndexOf(c6, i6);
        }
        char[] cArr = {c6};
        if (charSequence instanceof String) {
            return ((String) charSequence).lastIndexOf(AbstractC3250p.U(cArr), i6);
        }
        int iK0 = K0(charSequence);
        if (i6 > iK0) {
            i6 = iK0;
        }
        while (-1 < i6) {
            if (AbstractC0872a.B(cArr[0], charSequence.charAt(i6), false)) {
                return i6;
            }
            i6--;
        }
        return -1;
    }

    public static String U0(int i6, String str) {
        CharSequence charSequenceSubSequence;
        kotlin.jvm.internal.o.h(str, "<this>");
        if (i6 < 0) {
            throw new IllegalArgumentException(Z0.o.j(i6, "Desired length ", " is less than zero."));
        }
        if (i6 <= str.length()) {
            charSequenceSubSequence = str.subSequence(0, str.length());
        } else {
            StringBuilder sb = new StringBuilder(i6);
            sb.append((CharSequence) str);
            int length = i6 - str.length();
            int i7 = 1;
            if (1 <= length) {
                while (true) {
                    sb.append(' ');
                    if (i7 == length) {
                        break;
                    }
                    i7++;
                }
            }
            charSequenceSubSequence = sb;
        }
        return charSequenceSubSequence.toString();
    }

    public static String V0(int i6, String str) {
        CharSequence charSequenceSubSequence;
        kotlin.jvm.internal.o.h(str, "<this>");
        if (i6 < 0) {
            throw new IllegalArgumentException(Z0.o.j(i6, "Desired length ", " is less than zero."));
        }
        if (i6 <= str.length()) {
            charSequenceSubSequence = str.subSequence(0, str.length());
        } else {
            StringBuilder sb = new StringBuilder(i6);
            int length = i6 - str.length();
            int i7 = 1;
            if (1 <= length) {
                while (true) {
                    sb.append('0');
                    if (i7 == length) {
                        break;
                    }
                    i7++;
                }
            }
            sb.append((CharSequence) str);
            charSequenceSubSequence = sb;
        }
        return charSequenceSubSequence.toString();
    }

    public static final boolean W0(CharSequence charSequence, int i6, CharSequence other, int i7, int i8, boolean z6) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        kotlin.jvm.internal.o.h(other, "other");
        if (i7 < 0 || i6 < 0 || i6 > charSequence.length() - i8 || i7 > other.length() - i8) {
            return false;
        }
        for (int i9 = 0; i9 < i8; i9++) {
            if (!AbstractC0872a.B(charSequence.charAt(i6 + i9), other.charAt(i7 + i9), z6)) {
                return false;
            }
        }
        return true;
    }

    public static String X0(String str, String prefix) {
        kotlin.jvm.internal.o.h(str, "<this>");
        kotlin.jvm.internal.o.h(prefix, "prefix");
        if (!w.A0(str, prefix, false)) {
            return str;
        }
        String strSubstring = str.substring(prefix.length());
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String Y0(String str, String str2) {
        if (!I0(str, str2)) {
            return str;
        }
        String strSubstring = str.substring(0, str.length() - str2.length());
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static StringBuilder Z0(CharSequence charSequence, int i6, int i7, CharSequence replacement) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        kotlin.jvm.internal.o.h(replacement, "replacement");
        if (i7 >= i6) {
            StringBuilder sb = new StringBuilder();
            sb.append(charSequence, 0, i6);
            sb.append(replacement);
            sb.append(charSequence, i7, charSequence.length());
            return sb;
        }
        throw new IndexOutOfBoundsException("End index (" + i7 + ") is less than start index (" + i6 + ").");
    }

    public static final void a1(int i6) {
        if (i6 < 0) {
            throw new IllegalArgumentException(Z0.o.l("Limit must be non-negative, but was ", i6).toString());
        }
    }

    public static final List b1(int i6, CharSequence charSequence, String str) {
        a1(i6);
        int iL0 = L0(charSequence, str, 0, false);
        if (iL0 == -1 || i6 == 1) {
            return AbstractC2612c.q(charSequence.toString());
        }
        boolean z6 = i6 > 0;
        int i7 = 10;
        if (z6 && i6 <= 10) {
            i7 = i6;
        }
        ArrayList arrayList = new ArrayList(i7);
        int length = 0;
        do {
            arrayList.add(charSequence.subSequence(length, iL0).toString());
            length = str.length() + iL0;
            if (z6 && arrayList.size() == i6 - 1) {
                break;
            }
            iL0 = L0(charSequence, str, length, false);
        } while (iL0 != -1);
        arrayList.add(charSequence.subSequence(length, charSequence.length()).toString());
        return arrayList;
    }

    public static List c1(CharSequence charSequence, char[] cArr, int i6) {
        int i7 = (i6 & 4) != 0 ? 0 : 2;
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        if (cArr.length == 1) {
            return b1(i7, charSequence, String.valueOf(cArr[0]));
        }
        a1(i7);
        R4.p pVar = new R4.p(new c(charSequence, i7, new C0053c(cArr, 10)), 0);
        ArrayList arrayList = new ArrayList(AbstractC3253s.G(pVar, 10));
        Iterator it = pVar.iterator();
        while (true) {
            b bVar = (b) it;
            if (!bVar.hasNext()) {
                return arrayList;
            }
            P4.g range = (P4.g) bVar.next();
            kotlin.jvm.internal.o.h(range, "range");
            arrayList.add(charSequence.subSequence(range.f5676a, range.f5677b + 1).toString());
        }
    }

    public static List d1(CharSequence charSequence, String[] strArr, int i6) {
        int i7 = (i6 & 4) != 0 ? 0 : 2;
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        if (strArr.length == 1) {
            String str = strArr[0];
            if (str.length() != 0) {
                return b1(i7, charSequence, str);
            }
        }
        a1(i7);
        R4.p pVar = new R4.p(new c(charSequence, i7, new C0053c(AbstractC3250p.r(strArr), 11)), 0);
        ArrayList arrayList = new ArrayList(AbstractC3253s.G(pVar, 10));
        Iterator it = pVar.iterator();
        while (true) {
            b bVar = (b) it;
            if (!bVar.hasNext()) {
                return arrayList;
            }
            P4.g range = (P4.g) bVar.next();
            kotlin.jvm.internal.o.h(range, "range");
            arrayList.add(charSequence.subSequence(range.f5676a, range.f5677b + 1).toString());
        }
    }

    public static boolean e1(String str, char c6) {
        return str.length() > 0 && AbstractC0872a.B(str.charAt(0), c6, false);
    }

    public static String f1(char c6, String str, String missingDelimiterValue) {
        kotlin.jvm.internal.o.h(str, "<this>");
        kotlin.jvm.internal.o.h(missingDelimiterValue, "missingDelimiterValue");
        int iN0 = N0(str, c6, 0, 6);
        if (iN0 == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = str.substring(iN0 + 1, str.length());
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String g1(String str, String delimiter, String str2) {
        kotlin.jvm.internal.o.h(delimiter, "delimiter");
        int iO0 = O0(str, delimiter, 0, false, 6);
        if (iO0 == -1) {
            return str2;
        }
        String strSubstring = str.substring(delimiter.length() + iO0, str.length());
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String i1(char c6, String str, String missingDelimiterValue) {
        kotlin.jvm.internal.o.h(str, "<this>");
        kotlin.jvm.internal.o.h(missingDelimiterValue, "missingDelimiterValue");
        int iT0 = T0(str, c6, 0, 6);
        if (iT0 == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = str.substring(iT0 + 1, str.length());
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String j1(char c6, String str, String missingDelimiterValue) {
        kotlin.jvm.internal.o.h(str, "<this>");
        kotlin.jvm.internal.o.h(missingDelimiterValue, "missingDelimiterValue");
        int iN0 = N0(str, c6, 0, 6);
        if (iN0 == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = str.substring(0, iN0);
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String k1(String missingDelimiterValue, String str) {
        kotlin.jvm.internal.o.h(missingDelimiterValue, "<this>");
        kotlin.jvm.internal.o.h(missingDelimiterValue, "missingDelimiterValue");
        int iO0 = O0(missingDelimiterValue, str, 0, false, 6);
        if (iO0 == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = missingDelimiterValue.substring(0, iO0);
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String l1(String missingDelimiterValue, char c6) {
        kotlin.jvm.internal.o.h(missingDelimiterValue, "<this>");
        kotlin.jvm.internal.o.h(missingDelimiterValue, "missingDelimiterValue");
        int iT0 = T0(missingDelimiterValue, c6, 0, 6);
        if (iT0 == -1) {
            return missingDelimiterValue;
        }
        String strSubstring = missingDelimiterValue.substring(0, iT0);
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String m1(int i6, String str) {
        kotlin.jvm.internal.o.h(str, "<this>");
        if (i6 < 0) {
            throw new IllegalArgumentException(Z0.o.j(i6, "Requested character count ", " is less than zero.").toString());
        }
        int length = str.length();
        if (i6 > length) {
            i6 = length;
        }
        String strSubstring = str.substring(0, i6);
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static void n1(CharSequence charSequence, PersistentCollection.Builder destination) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        kotlin.jvm.internal.o.h(destination, "destination");
        for (int i6 = 0; i6 < charSequence.length(); i6++) {
            destination.add(Character.valueOf(charSequence.charAt(i6)));
        }
    }

    public static CharSequence o1(CharSequence charSequence) {
        kotlin.jvm.internal.o.h(charSequence, "<this>");
        int length = charSequence.length() - 1;
        int i6 = 0;
        boolean z6 = false;
        while (i6 <= length) {
            boolean zW = AbstractC0872a.W(charSequence.charAt(!z6 ? i6 : length));
            if (z6) {
                if (!zW) {
                    break;
                }
                length--;
            } else if (zW) {
                i6++;
            } else {
                z6 = true;
            }
        }
        return charSequence.subSequence(i6, length + 1);
    }

    public static String p1(String str, char... cArr) {
        kotlin.jvm.internal.o.h(str, "<this>");
        int length = str.length() - 1;
        int i6 = 0;
        boolean z6 = false;
        while (i6 <= length) {
            boolean zT = AbstractC3250p.t(cArr, str.charAt(!z6 ? i6 : length));
            if (z6) {
                if (!zT) {
                    break;
                }
                length--;
            } else if (zT) {
                i6++;
            } else {
                z6 = true;
            }
        }
        return str.subSequence(i6, length + 1).toString();
    }

    public static String q1(String str, char... cArr) {
        CharSequence charSequenceSubSequence;
        kotlin.jvm.internal.o.h(str, "<this>");
        int length = str.length() - 1;
        if (length >= 0) {
            while (true) {
                int i6 = length - 1;
                if (!AbstractC3250p.t(cArr, str.charAt(length))) {
                    charSequenceSubSequence = str.subSequence(0, length + 1);
                    break;
                }
                if (i6 < 0) {
                    break;
                }
                length = i6;
            }
            charSequenceSubSequence = "";
        } else {
            charSequenceSubSequence = "";
        }
        return charSequenceSubSequence.toString();
    }

    public static CharSequence r1(String str) {
        int length = str.length();
        for (int i6 = 0; i6 < length; i6++) {
            if (!AbstractC0872a.W(str.charAt(i6))) {
                return str.subSequence(i6, str.length());
            }
        }
        return "";
    }
}