package X6;

import com.google.android.gms.internal.measurement.C1;
import com.google.android.gms.internal.measurement.X1;
import d5.AbstractC0844a;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public abstract class e extends n {
    public static boolean N(CharSequence charSequence, char c3) {
        P6.g.e(charSequence, "<this>");
        return S(charSequence, c3, 0, 2) >= 0;
    }

    public static boolean O(CharSequence charSequence, String str) {
        P6.g.e(charSequence, "<this>");
        return T(charSequence, str, 0, 2) >= 0;
    }

    public static boolean P(String str, char c3) {
        return str.length() > 0 && X1.k(str.charAt(Q(str)), c3, false);
    }

    public static final int Q(CharSequence charSequence) {
        P6.g.e(charSequence, "<this>");
        return charSequence.length() - 1;
    }

    public static final int R(CharSequence charSequence, String str, int i, boolean z8) {
        P6.g.e(charSequence, "<this>");
        P6.g.e(str, "string");
        if (!z8 && (charSequence instanceof String)) {
            return ((String) charSequence).indexOf(str, i);
        }
        int length = charSequence.length();
        if (i < 0) {
            i = 0;
        }
        int length2 = charSequence.length();
        if (length > length2) {
            length = length2;
        }
        U6.c cVar = new U6.c(i, length, 1);
        boolean z9 = charSequence instanceof String;
        int i5 = cVar.f6799s;
        int i8 = cVar.f6798r;
        int i9 = cVar.f6797q;
        if (!z9 || !AbstractC0844a.w(str)) {
            boolean z10 = z8;
            if ((i5 <= 0 || i9 > i8) && (i5 >= 0 || i8 > i9)) {
                return -1;
            }
            while (true) {
                CharSequence charSequence2 = charSequence;
                boolean z11 = z10;
                z10 = z11;
                if (Y(str, 0, charSequence2, i9, str.length(), z11)) {
                    return i9;
                }
                if (i9 == i8) {
                    return -1;
                }
                i9 += i5;
                charSequence = charSequence2;
            }
        } else {
            if ((i5 <= 0 || i9 > i8) && (i5 >= 0 || i8 > i9)) {
                return -1;
            }
            int i10 = i9;
            while (true) {
                String str2 = str;
                boolean z12 = z8;
                if (n.J(0, i10, str.length(), str2, (String) charSequence, z12)) {
                    return i10;
                }
                if (i10 == i8) {
                    return -1;
                }
                i10 += i5;
                str = str2;
                z8 = z12;
            }
        }
    }

    public static int S(CharSequence charSequence, char c3, int i, int i5) {
        if ((i5 & 2) != 0) {
            i = 0;
        }
        P6.g.e(charSequence, "<this>");
        return !(charSequence instanceof String) ? U(charSequence, new char[]{c3}, i, false) : ((String) charSequence).indexOf(c3, i);
    }

    public static /* synthetic */ int T(CharSequence charSequence, String str, int i, int i5) {
        if ((i5 & 2) != 0) {
            i = 0;
        }
        return R(charSequence, str, i, false);
    }

    public static final int U(CharSequence charSequence, char[] cArr, int i, boolean z8) {
        P6.g.e(charSequence, "<this>");
        if (!z8 && cArr.length == 1 && (charSequence instanceof String)) {
            return ((String) charSequence).indexOf(B6.j.O(cArr), i);
        }
        if (i < 0) {
            i = 0;
        }
        int iQ = Q(charSequence);
        if (i > iQ) {
            return -1;
        }
        while (true) {
            char cCharAt = charSequence.charAt(i);
            for (char c3 : cArr) {
                if (X1.k(c3, cCharAt, z8)) {
                    return i;
                }
            }
            if (i == iQ) {
                return -1;
            }
            i++;
        }
    }

    public static boolean V(CharSequence charSequence) {
        P6.g.e(charSequence, "<this>");
        for (int i = 0; i < charSequence.length(); i++) {
            if (!X1.s(charSequence.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public static int W(CharSequence charSequence, char c3, int i, int i5) {
        if ((i5 & 2) != 0) {
            i = Q(charSequence);
        }
        P6.g.e(charSequence, "<this>");
        if (charSequence instanceof String) {
            return ((String) charSequence).lastIndexOf(c3, i);
        }
        char[] cArr = {c3};
        if (charSequence instanceof String) {
            return ((String) charSequence).lastIndexOf(B6.j.O(cArr), i);
        }
        int iQ = Q(charSequence);
        if (i > iQ) {
            i = iQ;
        }
        while (-1 < i) {
            if (X1.k(cArr[0], charSequence.charAt(i), false)) {
                return i;
            }
            i--;
        }
        return -1;
    }

    public static String X(int i, String str) {
        CharSequence charSequenceSubSequence;
        P6.g.e(str, "<this>");
        if (i < 0) {
            throw new IllegalArgumentException(I1.a.k(i, "Desired length ", " is less than zero."));
        }
        if (i <= str.length()) {
            charSequenceSubSequence = str.subSequence(0, str.length());
        } else {
            StringBuilder sb = new StringBuilder(i);
            int length = i - str.length();
            int i5 = 1;
            if (1 <= length) {
                while (true) {
                    sb.append('0');
                    if (i5 == length) {
                        break;
                    }
                    i5++;
                }
            }
            sb.append((CharSequence) str);
            charSequenceSubSequence = sb;
        }
        return charSequenceSubSequence.toString();
    }

    public static final boolean Y(String str, int i, CharSequence charSequence, int i5, int i8, boolean z8) {
        P6.g.e(str, "<this>");
        P6.g.e(charSequence, "other");
        if (i5 >= 0 && i >= 0 && i <= str.length() - i8 && i5 <= charSequence.length() - i8) {
            for (int i9 = 0; i9 < i8; i9++) {
                if (X1.k(str.charAt(i + i9), charSequence.charAt(i5 + i9), z8)) {
                }
            }
            return true;
        }
        return false;
    }

    public static String Z(String str, String str2) {
        if (!n.M(str, str2, false)) {
            return str;
        }
        String strSubstring = str.substring(str2.length());
        P6.g.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static final List a0(CharSequence charSequence, String str) {
        int iR = R(charSequence, str, 0, false);
        if (iR == -1) {
            return C1.C(charSequence.toString());
        }
        ArrayList arrayList = new ArrayList(10);
        int length = 0;
        do {
            arrayList.add(charSequence.subSequence(length, iR).toString());
            length = str.length() + iR;
            iR = R(charSequence, str, length, false);
        } while (iR != -1);
        arrayList.add(charSequence.subSequence(length, charSequence.length()).toString());
        return arrayList;
    }

    public static List b0(CharSequence charSequence, String[] strArr) {
        P6.g.e(charSequence, "<this>");
        if (strArr.length == 1) {
            String str = strArr[0];
            if (str.length() != 0) {
                return a0(charSequence, str);
            }
        }
        W6.l lVar = new W6.l(new W6.f(charSequence, new o(0, B6.j.D(strArr))));
        ArrayList arrayList = new ArrayList(B6.m.a0(lVar));
        Iterator it = lVar.iterator();
        while (true) {
            b bVar = (b) it;
            if (!bVar.hasNext()) {
                return arrayList;
            }
            U6.c cVar = (U6.c) bVar.next();
            P6.g.e(cVar, "range");
            arrayList.add(charSequence.subSequence(cVar.f6797q, cVar.f6798r + 1).toString());
        }
    }

    public static List c0(String str, char[] cArr) {
        P6.g.e(str, "<this>");
        if (cArr.length == 1) {
            return a0(str, String.valueOf(cArr[0]));
        }
        W6.l lVar = new W6.l(new W6.f(str, new o(1, cArr)));
        ArrayList arrayList = new ArrayList(B6.m.a0(lVar));
        Iterator it = lVar.iterator();
        while (true) {
            b bVar = (b) it;
            if (!bVar.hasNext()) {
                return arrayList;
            }
            U6.c cVar = (U6.c) bVar.next();
            P6.g.e(cVar, "range");
            arrayList.add(str.subSequence(cVar.f6797q, cVar.f6798r + 1).toString());
        }
    }

    public static boolean d0(String str, char c3) {
        P6.g.e(str, "<this>");
        return str.length() > 0 && X1.k(str.charAt(0), c3, false);
    }

    public static String e0(String str, char c3) {
        int iS = S(str, c3, 0, 6);
        if (iS == -1) {
            return str;
        }
        String strSubstring = str.substring(iS + 1, str.length());
        P6.g.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String f0(String str, String str2) {
        P6.g.e(str2, "delimiter");
        int iT = T(str, str2, 0, 6);
        if (iT == -1) {
            return str;
        }
        String strSubstring = str.substring(str2.length() + iT, str.length());
        P6.g.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String g0(String str, char c3, String str2) {
        int iW = W(str, c3, 0, 6);
        if (iW == -1) {
            return str2;
        }
        String strSubstring = str.substring(iW + 1, str.length());
        P6.g.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String h0(String str, char c3) {
        P6.g.e(str, "<this>");
        P6.g.e(str, "missingDelimiterValue");
        int iW = W(str, c3, 0, 6);
        if (iW == -1) {
            return str;
        }
        String strSubstring = str.substring(0, iW);
        P6.g.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static String i0(int i, String str) {
        P6.g.e(str, "<this>");
        if (i < 0) {
            throw new IllegalArgumentException(I1.a.k(i, "Requested character count ", " is less than zero.").toString());
        }
        int length = str.length();
        if (i > length) {
            i = length;
        }
        String strSubstring = str.substring(0, i);
        P6.g.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    public static CharSequence j0(CharSequence charSequence) {
        P6.g.e(charSequence, "<this>");
        int length = charSequence.length() - 1;
        int i = 0;
        boolean z8 = false;
        while (i <= length) {
            boolean zS = X1.s(charSequence.charAt(!z8 ? i : length));
            if (z8) {
                if (!zS) {
                    break;
                }
                length--;
            } else if (zS) {
                i++;
            } else {
                z8 = true;
            }
        }
        return charSequence.subSequence(i, length + 1);
    }
}