package defpackage;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

/* JADX INFO: renamed from: ᵩˆᵿʨ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public abstract class AbstractC3801 extends AbstractC5498 {
    /* JADX INFO: renamed from: ʽᵡᵢᵾ, reason: contains not printable characters */
    public static int m8463(CharSequence charSequence, String str, int i, boolean z) {
        return (z || !(charSequence instanceof String)) ? m8473(charSequence, str, i, charSequence.length(), z, false) : ((String) charSequence).indexOf(str, i);
    }

    /* JADX INFO: renamed from: ʿᵯᴵ, reason: contains not printable characters */
    public static CharSequence m8464(CharSequence charSequence) {
        int length = charSequence.length() - 1;
        int i = 0;
        boolean z = false;
        while (i <= length) {
            boolean z2 = ᵺᵘ.ˑˊᵲ(charSequence.charAt(!z ? i : length));
            if (z) {
                if (!z2) {
                    break;
                }
                length--;
            } else if (z2) {
                i++;
            } else {
                z = true;
            }
        }
        return charSequence.subSequence(i, length + 1);
    }

    /* JADX INFO: renamed from: ʿᵿʽᵞ, reason: contains not printable characters */
    public static List m8465(String str) {
        C5284 c5284 = new C5284(str);
        if (!c5284.hasNext()) {
            return C2808.f10794;
        }
        Object next = c5284.next();
        if (!c5284.hasNext()) {
            return Collections.singletonList(next);
        }
        ArrayList arrayList = new ArrayList();
        arrayList.add(next);
        while (c5284.hasNext()) {
            arrayList.add(c5284.next());
        }
        return arrayList;
    }

    /* JADX INFO: renamed from: ˀᵗ, reason: contains not printable characters */
    public static char m8466(CharSequence charSequence) {
        if (charSequence.length() != 0) {
            return charSequence.charAt(m8503(charSequence));
        }
        throw new NoSuchElementException("Char sequence is empty.");
    }

    /* JADX INFO: renamed from: ˀᵭ, reason: contains not printable characters */
    public static boolean m8467(CharSequence charSequence, char c) {
        return m8497(charSequence, c, 0, 2) >= 0;
    }

    /* JADX INFO: renamed from: ˁʢᵛ, reason: contains not printable characters */
    public static boolean m8468(CharSequence charSequence) {
        for (int i = 0; i < charSequence.length(); i++) {
            if (!ᵺᵘ.ˑˊᵲ(charSequence.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /* JADX INFO: renamed from: ˁˌᵩ, reason: contains not printable characters */
    public static boolean m8469(CharSequence charSequence, CharSequence charSequence2, boolean z) {
        if (charSequence2 instanceof String) {
            if (m8492(charSequence, (String) charSequence2, 0, z, 2) >= 0) {
                return true;
            }
        } else if (m8473(charSequence, charSequence2, 0, charSequence.length(), z, false) >= 0) {
            return true;
        }
        return false;
    }

    /* JADX INFO: renamed from: ˁᵺˈ, reason: contains not printable characters */
    public static CharSequence m8470(CharSequence charSequence, int i, int i2) {
        if (i2 < i) {
            ᵷᵝˎ.ᵻˈᵦʼ(i2, i, ") is less than start index (", "End index (");
            return null;
        }
        if (i2 == i) {
            return charSequence.subSequence(0, charSequence.length());
        }
        StringBuilder sb = new StringBuilder(charSequence.length() - (i2 - i));
        sb.append(charSequence, 0, i);
        sb.append(charSequence, i2, charSequence.length());
        return sb;
    }

    /* JADX INFO: renamed from: ˆˀᵯ, reason: contains not printable characters */
    public static String m8472(String str, String str2) {
        int iM8482 = m8482(6, str, str2);
        return iM8482 == -1 ? str : str.substring(0, iM8482);
    }

    /* JADX INFO: renamed from: ˈⁱᵡ, reason: contains not printable characters */
    public static final int m8473(CharSequence charSequence, CharSequence charSequence2, int i, int i2, boolean z, boolean z2) {
        C5485 c5485;
        CharSequence charSequence3 = charSequence2;
        int i3 = i;
        int i4 = i2;
        if (z2) {
            int iM8503 = m8503(charSequence);
            if (i3 > iM8503) {
                i3 = iM8503;
            }
            if (i4 < 0) {
                i4 = 0;
            }
            c5485 = new C5485(i3, i4, -1);
        } else {
            if (i3 < 0) {
                i3 = 0;
            }
            int length = charSequence.length();
            if (i4 > length) {
                i4 = length;
            }
            c5485 = new C2187(i3, i4, 1);
        }
        boolean z3 = charSequence instanceof String;
        int i5 = c5485.f20742;
        int i6 = c5485.f20743;
        int i7 = c5485.f20741;
        if (z3 && (charSequence3 instanceof String)) {
            if ((i5 > 0 && i7 <= i6) || (i5 < 0 && i6 <= i7)) {
                int i8 = i7;
                while (true) {
                    String str = (String) charSequence3;
                    String str2 = (String) charSequence;
                    int length2 = str.length();
                    if (!(!z ? str.regionMatches(0, str2, i8, length2) : str.regionMatches(z, 0, str2, i8, length2))) {
                        if (i8 == i6) {
                            break;
                        }
                        i8 += i5;
                    } else {
                        return i8;
                    }
                }
            }
        } else if ((i5 > 0 && i7 <= i6) || (i5 < 0 && i6 <= i7)) {
            int i9 = i7;
            while (!m8478(charSequence3, 0, charSequence, i9, charSequence3.length(), z)) {
                if (i9 != i6) {
                    i9 += i5;
                    charSequence3 = charSequence2;
                }
            }
            return i9;
        }
        return -1;
    }

    /* JADX INFO: renamed from: ˉˆᵗ, reason: contains not printable characters */
    public static String m8474(String str, String str2) {
        return AbstractC5498.m11136(str, str2, false) ? str.substring(str2.length()) : str;
    }

    /* JADX INFO: renamed from: ˊˌˊ, reason: contains not printable characters */
    public static final int m8475(CharSequence charSequence, char[] cArr, int i, boolean z) {
        if (!z && cArr.length == 1 && (charSequence instanceof String)) {
            int length = cArr.length;
            if (length == 0) {
                throw new NoSuchElementException("Array is empty.");
            }
            if (length == 1) {
                return ((String) charSequence).indexOf(cArr[0], i);
            }
            ᵕᵩʽᵲ.ᵮᵣᵗˈ("Array has more than one element.");
            return 0;
        }
        if (i < 0) {
            i = 0;
        }
        int iM8503 = m8503(charSequence);
        if (i > iM8503) {
            return -1;
        }
        while (true) {
            char cCharAt = charSequence.charAt(i);
            for (char c : cArr) {
                if (ᵺᵘ.ˊᵙᵾᵲ(c, cCharAt, z)) {
                    return i;
                }
            }
            if (i == iM8503) {
                return -1;
            }
            i++;
        }
    }

    /* JADX INFO: renamed from: ˊᵡᵗʨ, reason: contains not printable characters */
    public static String m8476(int i, String str) {
        if (i < 0) {
            ᵕᵩʽᵲ.ᵱᵽʡᵚ(AbstractC0793.m2876(i, "Requested character count ", " is less than zero."));
            return null;
        }
        int length = str.length() - i;
        if (length < 0) {
            length = 0;
        }
        return m8488(length, str);
    }

    /* JADX INFO: renamed from: ˊᵾʽʼ, reason: contains not printable characters */
    public static String m8477(int i, String str) {
        if (i < 0) {
            ᵕᵩʽᵲ.ᵱᵽʡᵚ(AbstractC0793.m2876(i, "Requested character count ", " is less than zero."));
            return null;
        }
        int length = str.length();
        if (i > length) {
            i = length;
        }
        return str.substring(i);
    }

    /* JADX INFO: renamed from: ˋʿᐧ, reason: contains not printable characters */
    public static final boolean m8478(CharSequence charSequence, int i, CharSequence charSequence2, int i2, int i3, boolean z) {
        if (i2 < 0 || i < 0 || i > charSequence.length() - i3 || i2 > charSequence2.length() - i3) {
            return false;
        }
        for (int i4 = 0; i4 < i3; i4++) {
            if (!ᵺᵘ.ˊᵙᵾᵲ(charSequence.charAt(i + i4), charSequence2.charAt(i2 + i4), z)) {
                return false;
            }
        }
        return true;
    }

    /* JADX INFO: renamed from: ˋᵯᵩ, reason: contains not printable characters */
    public static String m8479(String str, String str2) {
        return AbstractC5498.m11137(str, str2, false) ? str.substring(0, str.length() - str2.length()) : str;
    }

    /* JADX INFO: renamed from: ˏʜᵪ, reason: contains not printable characters */
    public static String m8480(String str, char c, String str2) {
        int iM8497 = m8497(str, c, 0, 6);
        return iM8497 == -1 ? str2 : str.substring(iM8497 + 1, str.length());
    }

    /* JADX INFO: renamed from: ˏʽˊᵰ, reason: contains not printable characters */
    public static String m8481(String str, char c) {
        int iM8497 = m8497(str, c, 0, 6);
        return iM8497 == -1 ? str : str.substring(0, iM8497);
    }

    /* JADX INFO: renamed from: ˏᵩʨ, reason: contains not printable characters */
    public static int m8482(int i, String str, String str2) {
        return str.lastIndexOf(str2, (i & 2) != 0 ? m8503(str) : 0);
    }

    /* JADX INFO: renamed from: ːᵝٴᵶ, reason: contains not printable characters */
    public static StringBuilder m8483(String str) {
        return new StringBuilder((CharSequence) str).reverse();
    }

    /* JADX INFO: renamed from: ˑʢ, reason: contains not printable characters */
    public static Character m8484(int i, String str) {
        if (i < 0 || i >= str.length()) {
            return null;
        }
        return Character.valueOf(str.charAt(i));
    }

    /* JADX INFO: renamed from: ᵕᵜʽᵰ, reason: contains not printable characters */
    public static String m8485(String str, char... cArr) {
        int length = str.length() - 1;
        int i = 0;
        boolean z = false;
        while (i <= length) {
            char cCharAt = str.charAt(!z ? i : length);
            int length2 = cArr.length;
            int i2 = 0;
            while (true) {
                if (i2 >= length2) {
                    i2 = -1;
                    break;
                }
                if (cCharAt == cArr[i2]) {
                    break;
                }
                i2++;
            }
            boolean z2 = i2 >= 0;
            if (z) {
                if (!z2) {
                    break;
                }
                length--;
            } else if (z2) {
                i++;
            } else {
                z = true;
            }
        }
        return str.subSequence(i, length + 1).toString();
    }

    /* JADX INFO: renamed from: ᵗᵭ, reason: contains not printable characters */
    public static final List m8486(CharSequence charSequence, String str) {
        int iM8463 = m8463(charSequence, str, 0, false);
        if (iM8463 == -1) {
            return Collections.singletonList(charSequence.toString());
        }
        ArrayList arrayList = new ArrayList(10);
        int length = 0;
        do {
            arrayList.add(charSequence.subSequence(length, iM8463).toString());
            length = str.length() + iM8463;
            iM8463 = m8463(charSequence, str, length, false);
        } while (iM8463 != -1);
        arrayList.add(charSequence.subSequence(length, charSequence.length()).toString());
        return arrayList;
    }

    /* JADX INFO: renamed from: ᵘᵝ, reason: contains not printable characters */
    public static String m8487(String str, String str2, String str3) {
        int iM8492 = m8492(str, str2, 0, false, 6);
        return iM8492 == -1 ? str3 : str.substring(str2.length() + iM8492, str.length());
    }

    /* JADX INFO: renamed from: ᵚᵹᵔᵜ, reason: contains not printable characters */
    public static String m8488(int i, String str) {
        if (i < 0) {
            ᵕᵩʽᵲ.ᵱᵽʡᵚ(AbstractC0793.m2876(i, "Requested character count ", " is less than zero."));
            return null;
        }
        int length = str.length();
        if (i > length) {
            i = length;
        }
        return str.substring(0, i);
    }

    /* JADX INFO: renamed from: ᵛˀˊ, reason: contains not printable characters */
    public static int m8489(String str, char c, int i, int i2) {
        if ((i2 & 2) != 0) {
            i = m8503(str);
        }
        return str.lastIndexOf(c, i);
    }

    /* JADX INFO: renamed from: ᵛˑﹳ, reason: contains not printable characters */
    public static boolean m8490(CharSequence charSequence, char c) {
        return charSequence.length() > 0 && ᵺᵘ.ˊᵙᵾᵲ(charSequence.charAt(m8503(charSequence)), c, false);
    }

    /* JADX INFO: renamed from: ᵜᵤ, reason: contains not printable characters */
    public static StringBuilder m8491(int i, int i2, String str, String str2) {
        if (i2 < i) {
            ᵷᵝˎ.ᵻˈᵦʼ(i2, i, ") is less than start index (", "End index (");
            return null;
        }
        StringBuilder sb = new StringBuilder();
        sb.append((CharSequence) str, 0, i);
        sb.append((CharSequence) str2);
        sb.append((CharSequence) str, i2, str.length());
        return sb;
    }

    /* JADX INFO: renamed from: ᵞᵛᵘ, reason: contains not printable characters */
    public static /* synthetic */ int m8492(CharSequence charSequence, String str, int i, boolean z, int i2) {
        if ((i2 & 2) != 0) {
            i = 0;
        }
        if ((i2 & 4) != 0) {
            z = false;
        }
        return m8463(charSequence, str, i, z);
    }

    /* JADX INFO: renamed from: ᵟᵴᵥ, reason: contains not printable characters */
    public static String m8493(String str, char... cArr) {
        CharSequence charSequenceSubSequence;
        int length = str.length();
        int i = 0;
        while (true) {
            if (i >= length) {
                charSequenceSubSequence = "";
                break;
            }
            char cCharAt = str.charAt(i);
            int length2 = cArr.length;
            int i2 = 0;
            while (true) {
                if (i2 >= length2) {
                    i2 = -1;
                    break;
                }
                if (cCharAt == cArr[i2]) {
                    break;
                }
                i2++;
            }
            if (i2 < 0) {
                charSequenceSubSequence = str.subSequence(i, str.length());
                break;
            }
            i++;
        }
        return charSequenceSubSequence.toString();
    }

    /* JADX INFO: renamed from: ᵡᵶ, reason: contains not printable characters */
    public static String m8494(int i, String str) {
        CharSequence charSequenceSubSequence;
        if (i < 0) {
            ᵕᵩʽᵲ.ᵮᵣᵗˈ(AbstractC0793.m2876(i, "Desired length ", " is less than zero."));
            return null;
        }
        if (i <= str.length()) {
            charSequenceSubSequence = str.subSequence(0, str.length());
        } else {
            StringBuilder sb = new StringBuilder(i);
            int length = i - str.length();
            int i2 = 1;
            if (1 <= length) {
                while (true) {
                    sb.append('0');
                    if (i2 == length) {
                        break;
                    }
                    i2++;
                }
            }
            sb.append((CharSequence) str);
            charSequenceSubSequence = sb;
        }
        return charSequenceSubSequence.toString();
    }

    /* JADX INFO: renamed from: ᵡᵶᵬʤ, reason: contains not printable characters */
    public static C4874 m8495(CharSequence charSequence, char[] cArr) {
        return new C4874(charSequence, new ˇᵤᵜˈ(10, cArr), 0);
    }

    /* JADX INFO: renamed from: ᵧᵢᵴᵸ, reason: contains not printable characters */
    public static String m8496(String str, char c) {
        int iM8489 = m8489(str, c, 0, 6);
        return iM8489 == -1 ? str : str.substring(0, iM8489);
    }

    /* JADX INFO: renamed from: ᵨˈʼﹶ, reason: contains not printable characters */
    public static int m8497(CharSequence charSequence, char c, int i, int i2) {
        if ((i2 & 2) != 0) {
            i = 0;
        }
        return !(charSequence instanceof String) ? m8475(charSequence, new char[]{c}, i, false) : ((String) charSequence).indexOf(c, i);
    }

    /* JADX INFO: renamed from: ᵫˈᵹ, reason: contains not printable characters */
    public static List m8498(CharSequence charSequence, String[] strArr) {
        int i = 0;
        if (strArr.length == 1) {
            String str = strArr[0];
            if (str.length() > 0) {
                return m8486(charSequence, str);
            }
        }
        C3586 c3586 = new C3586(2, new C4874(charSequence, new ˑᵿ(1, Arrays.asList(strArr)), i));
        ArrayList arrayList = new ArrayList(AbstractC5492.m11122(c3586, 10));
        Iterator it = c3586.iterator();
        while (true) {
            C2907 c2907 = (C2907) it;
            if (!c2907.hasNext()) {
                return arrayList;
            }
            C2187 c2187 = (C2187) c2907.next();
            arrayList.add(charSequence.subSequence(c2187.f20741, c2187.f20743 + 1).toString());
        }
    }

    /* JADX INFO: renamed from: ᵬᵦˋ, reason: contains not printable characters */
    public static boolean m8499(String str, char c) {
        return str.length() > 0 && ᵺᵘ.ˊᵙᵾᵲ(str.charAt(0), c, false);
    }

    /* JADX INFO: renamed from: ᵮᵟᵡ, reason: contains not printable characters */
    public static String m8500(String str, String str2) {
        int iM8482 = m8482(6, str, str2);
        return iM8482 == -1 ? str : str.substring(str2.length() + iM8482, str.length());
    }

    /* JADX INFO: renamed from: ᵯˇ, reason: contains not printable characters */
    public static String m8501(String str, String str2) {
        int iM8492 = m8492(str, str2, 0, false, 6);
        return iM8492 == -1 ? str : str.substring(0, iM8492);
    }

    /* JADX INFO: renamed from: ᵱᵭ, reason: contains not printable characters */
    public static ArrayList m8502(String str) {
        ArrayList arrayList = new ArrayList(str.length());
        for (int i = 0; i < str.length(); i++) {
            arrayList.add(Character.valueOf(str.charAt(i)));
        }
        return arrayList;
    }

    /* JADX INFO: renamed from: ᵵᵬᵽ, reason: contains not printable characters */
    public static int m8503(CharSequence charSequence) {
        return charSequence.length() - 1;
    }

    /* JADX INFO: renamed from: ᵵᵸᵕᵸ, reason: contains not printable characters */
    public static List m8504(String str, char[] cArr) {
        if (cArr.length == 1) {
            return m8486(str, String.valueOf(cArr[0]));
        }
        C3586 c3586 = new C3586(2, m8495(str, cArr));
        ArrayList arrayList = new ArrayList(AbstractC5492.m11122(c3586, 10));
        Iterator it = c3586.iterator();
        while (true) {
            C2907 c2907 = (C2907) it;
            if (!c2907.hasNext()) {
                return arrayList;
            }
            C2187 c2187 = (C2187) c2907.next();
            arrayList.add(str.subSequence(c2187.f20741, c2187.f20743 + 1).toString());
        }
    }

    /* JADX INFO: renamed from: ᵹʾᵢᵯ, reason: contains not printable characters */
    public static String m8505(String str, char c, String str2) {
        int iM8489 = m8489(str, c, 0, 6);
        return iM8489 == -1 ? str2 : str.substring(iM8489 + 1, str.length());
    }
}