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;

/* renamed from: ˎᵺˉᵱ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public abstract class AbstractC1789 extends AbstractC0436 {
    /* renamed from: ʽᵙᵕ, reason: contains not printable characters */
    public static String m5055(String str, char c, String str2) {
        int iM5058 = m5058(str, c, 0, 6);
        return iM5058 == -1 ? str2 : str.substring(0, iM5058);
    }

    /* renamed from: ʽᵢˊ, reason: contains not printable characters */
    public static int m5056(CharSequence charSequence, String str, int i, boolean z) {
        return (z || !(charSequence instanceof String)) ? m5069(charSequence, str, i, charSequence.length(), z, false) : ((String) charSequence).indexOf(str, i);
    }

    /* renamed from: ʾˋˊᵽ, reason: contains not printable characters */
    public static final int m5057(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 iM5086 = m5086(charSequence);
        if (i > iM5086) {
            return -1;
        }
        while (true) {
            char cCharAt = charSequence.charAt(i);
            for (char c : cArr) {
                if (ˉˇʨ.ᵯٴᵦ(c, cCharAt, z)) {
                    return i;
                }
            }
            if (i == iM5086) {
                return -1;
            }
            i++;
        }
    }

    /* renamed from: ʿᵘˆ, reason: contains not printable characters */
    public static int m5058(CharSequence charSequence, char c, int i, int i2) {
        if ((i2 & 2) != 0) {
            i = 0;
        }
        return !(charSequence instanceof String) ? m5057(charSequence, new char[]{c}, i, false) : ((String) charSequence).indexOf(c, i);
    }

    /* renamed from: ˁᵳˉ, reason: contains not printable characters */
    public static String m5059(String str, String str2, String str3) {
        int iM5082 = m5082(str, str2, 0, false, 6);
        return iM5082 == -1 ? str3 : str.substring(str2.length() + iM5082, str.length());
    }

    /* renamed from: ˆʕ, reason: contains not printable characters */
    public static String m5060(String str, String str2) {
        return AbstractC0436.m2049(str, str2, false) ? str.substring(str2.length()) : str;
    }

    /* renamed from: ˆᵪᵵ, reason: contains not printable characters */
    public static StringBuilder m5061(String str) {
        return new StringBuilder((CharSequence) str).reverse();
    }

    /* renamed from: ˆᵴᵜˏ, reason: contains not printable characters */
    public static boolean m5062(CharSequence charSequence, char c) {
        return m5058(charSequence, c, 0, 2) >= 0;
    }

    /* renamed from: ˈᵫˊˉ, reason: contains not printable characters */
    public static String m5063(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();
    }

    /* renamed from: ˉᵴﹶ, reason: contains not printable characters */
    public static int m5064(String str, char c, int i, int i2) {
        if ((i2 & 2) != 0) {
            i = m5086(str);
        }
        return str.lastIndexOf(c, i);
    }

    /* renamed from: ˎᵶᵹ, reason: contains not printable characters */
    public static CharSequence m5065(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;
    }

    /* renamed from: ᵎʾ, reason: contains not printable characters */
    public static char m5066(CharSequence charSequence) {
        if (charSequence.length() != 0) {
            return charSequence.charAt(m5086(charSequence));
        }
        throw new NoSuchElementException("Char sequence is empty.");
    }

    /* renamed from: ᵔᵨ, reason: contains not printable characters */
    public static List m5067(String str, char[] cArr) {
        if (cArr.length == 1) {
            return m5085(str, String.valueOf(cArr[0]));
        }
        C2019 c2019 = new C2019(2, m5075(str, cArr));
        ArrayList arrayList = new ArrayList(AbstractC3869.m8517(c2019, 10));
        Iterator it = c2019.iterator();
        while (true) {
            C4998 c4998 = (C4998) it;
            if (!c4998.hasNext()) {
                return arrayList;
            }
            C1521 c1521 = (C1521) c4998.next();
            arrayList.add(str.subSequence(c1521.f16358, c1521.f16357 + 1).toString());
        }
    }

    /* renamed from: ᵛˎ, reason: contains not printable characters */
    public static String m5068(String str, char c, String str2) {
        int iM5064 = m5064(str, c, 0, 6);
        return iM5064 == -1 ? str2 : str.substring(iM5064 + 1, str.length());
    }

    /* renamed from: ᵠᵪˀᵻ, reason: contains not printable characters */
    public static final int m5069(CharSequence charSequence, CharSequence charSequence2, int i, int i2, boolean z, boolean z2) {
        C4375 c4375;
        CharSequence charSequence3 = charSequence2;
        int i3 = i;
        int i4 = i2;
        if (z2) {
            int iM5086 = m5086(charSequence);
            if (i3 > iM5086) {
                i3 = iM5086;
            }
            if (i4 < 0) {
                i4 = 0;
            }
            c4375 = new C4375(i3, i4, -1);
        } else {
            if (i3 < 0) {
                i3 = 0;
            }
            int length = charSequence.length();
            if (i4 > length) {
                i4 = length;
            }
            c4375 = new C1521(i3, i4, 1);
        }
        boolean z3 = charSequence instanceof String;
        int i5 = c4375.f16359;
        int i6 = c4375.f16357;
        int i7 = c4375.f16358;
        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 (!m5091(charSequence3, 0, charSequence, i9, charSequence3.length(), z)) {
                if (i9 != i6) {
                    i9 += i5;
                    charSequence3 = charSequence2;
                }
            }
            return i9;
        }
        return -1;
    }

    /* renamed from: ᵠᵳ, reason: contains not printable characters */
    public static String m5070(String str, String str2) {
        int iM5082 = m5082(str, str2, 0, false, 6);
        return iM5082 == -1 ? str : str.substring(0, iM5082);
    }

    /* renamed from: ᵣᵟᵔ, reason: contains not printable characters */
    public static String m5071(int i, String str) {
        if (i < 0) {
            ᵹˉᵞ.ᵸˑ(AbstractC3915.m8596(i, "Requested character count ", " is less than zero."));
            return null;
        }
        int length = str.length() - i;
        if (length < 0) {
            length = 0;
        }
        return m5088(length, str);
    }

    /* renamed from: ᵤʟᵟ, reason: contains not printable characters */
    public static String m5072(String str, String str2) {
        int iM5094 = m5094(6, str, str2);
        return iM5094 == -1 ? str : str.substring(str2.length() + iM5094, str.length());
    }

    /* renamed from: ᵤᵼˑʠ, reason: contains not printable characters */
    public static boolean m5073(CharSequence charSequence, CharSequence charSequence2, boolean z) {
        if (charSequence2 instanceof String) {
            if (m5082(charSequence, (String) charSequence2, 0, z, 2) >= 0) {
                return true;
            }
        } else if (m5069(charSequence, charSequence2, 0, charSequence.length(), z, false) >= 0) {
            return true;
        }
        return false;
    }

    /* renamed from: ᵥʩᵩˑ, reason: contains not printable characters */
    public static boolean m5074(CharSequence charSequence, char c) {
        return charSequence.length() > 0 && ˉˇʨ.ᵯٴᵦ(charSequence.charAt(m5086(charSequence)), c, false);
    }

    /* renamed from: ᵦᵳˎ, reason: contains not printable characters */
    public static C4540 m5075(CharSequence charSequence, char[] cArr) {
        return new C4540(charSequence, new ˊᵷ(10, cArr), 0);
    }

    /* renamed from: ᵦᵽᵢ, reason: contains not printable characters */
    public static boolean m5076(String str, char c) {
        return str.length() > 0 && ˉˇʨ.ᵯٴᵦ(str.charAt(0), c, false);
    }

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

    /* renamed from: ᵪᵛʿ, reason: contains not printable characters */
    public static String m5078(int i, String str) {
        CharSequence charSequenceSubSequence;
        if (i < 0) {
            ᵹˉᵞ.ˌᵜᵹᵩ(AbstractC3915.m8596(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();
    }

    /* renamed from: ᵭˇʾ, reason: contains not printable characters */
    public static CharSequence m5079(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);
    }

    /* renamed from: ᵮᴵˊ, reason: contains not printable characters */
    public static StringBuilder m5080(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;
    }

    /* renamed from: ᵯᵽ, reason: contains not printable characters */
    public static String m5081(String str, String str2) {
        return AbstractC0436.m2047(str, str2, false) ? str.substring(0, str.length() - str2.length()) : str;
    }

    /* renamed from: ᵰʖʢ, reason: contains not printable characters */
    public static /* synthetic */ int m5082(CharSequence charSequence, String str, int i, boolean z, int i2) {
        if ((i2 & 2) != 0) {
            i = 0;
        }
        if ((i2 & 4) != 0) {
            z = false;
        }
        return m5056(charSequence, str, i, z);
    }

    /* renamed from: ᵰᵷᵹˆ, reason: contains not printable characters */
    public static List m5083(CharSequence charSequence, String[] strArr) {
        int i = 0;
        if (strArr.length == 1) {
            String str = strArr[0];
            if (str.length() != 0) {
                return m5085(charSequence, str);
            }
        }
        C2019 c2019 = new C2019(2, new C4540(charSequence, new ˌᵙ(1, Arrays.asList(strArr)), i));
        ArrayList arrayList = new ArrayList(AbstractC3869.m8517(c2019, 10));
        Iterator it = c2019.iterator();
        while (true) {
            C4998 c4998 = (C4998) it;
            if (!c4998.hasNext()) {
                return arrayList;
            }
            C1521 c1521 = (C1521) c4998.next();
            arrayList.add(charSequence.subSequence(c1521.f16358, c1521.f16357 + 1).toString());
        }
    }

    /* renamed from: ᵱˑᵲ, reason: contains not printable characters */
    public static String m5084(String str, char c, String str2) {
        int iM5058 = m5058(str, c, 0, 6);
        return iM5058 == -1 ? str2 : str.substring(iM5058 + 1, str.length());
    }

    /* renamed from: ᵲʟᵹ, reason: contains not printable characters */
    public static final List m5085(CharSequence charSequence, String str) {
        int iM5056 = m5056(charSequence, str, 0, false);
        if (iM5056 == -1) {
            return Collections.singletonList(charSequence.toString());
        }
        ArrayList arrayList = new ArrayList(10);
        int length = 0;
        do {
            arrayList.add(charSequence.subSequence(length, iM5056).toString());
            length = str.length() + iM5056;
            iM5056 = m5056(charSequence, str, length, false);
        } while (iM5056 != -1);
        arrayList.add(charSequence.subSequence(length, charSequence.length()).toString());
        return arrayList;
    }

    /* renamed from: ᵲᵟ, reason: contains not printable characters */
    public static int m5086(CharSequence charSequence) {
        return charSequence.length() - 1;
    }

    /* renamed from: ᵲᵰⁱ, reason: contains not printable characters */
    public static ArrayList m5087(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;
    }

    /* renamed from: ᵲᵳ, reason: contains not printable characters */
    public static String m5088(int i, String str) {
        if (i < 0) {
            ᵹˉᵞ.ᵸˑ(AbstractC3915.m8596(i, "Requested character count ", " is less than zero."));
            return null;
        }
        int length = str.length();
        if (i > length) {
            i = length;
        }
        return str.substring(0, i);
    }

    /* renamed from: ᵳʼ, reason: contains not printable characters */
    public static String m5089(String str, String str2) {
        int iM5094 = m5094(6, str, str2);
        return iM5094 == -1 ? str : str.substring(0, iM5094);
    }

    /* renamed from: ᵳᵮ, reason: contains not printable characters */
    public static String m5090(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();
    }

    /* renamed from: ᵳᵮᵸ, reason: contains not printable characters */
    public static final boolean m5091(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;
    }

    /* renamed from: ᵴᵯᵴⁱ, reason: contains not printable characters */
    public static List m5092(String str) {
        C5268 c5268 = new C5268(str);
        if (!c5268.hasNext()) {
            return C3035.f11677;
        }
        Object next = c5268.next();
        if (!c5268.hasNext()) {
            return Collections.singletonList(next);
        }
        ArrayList arrayList = new ArrayList();
        arrayList.add(next);
        while (c5268.hasNext()) {
            arrayList.add(c5268.next());
        }
        return arrayList;
    }

    /* renamed from: ᵷʚᵶᵿ, reason: contains not printable characters */
    public static String m5093(String str, char c) {
        int iM5064 = m5064(str, c, 0, 6);
        return iM5064 == -1 ? str : str.substring(0, iM5064);
    }

    /* renamed from: ᵷᵦﹳ, reason: contains not printable characters */
    public static int m5094(int i, String str, String str2) {
        return str.lastIndexOf(str2, (i & 2) != 0 ? m5086(str) : 0);
    }

    /* renamed from: ᵺᵜᵰ, reason: contains not printable characters */
    public static boolean m5095(CharSequence charSequence) {
        for (int i = 0; i < charSequence.length(); i++) {
            if (!ˉˇʨ.ᵿʗᵝʽ(charSequence.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /* renamed from: ﹶـ, reason: contains not printable characters */
    public static String m5097(int i, String str) {
        if (i < 0) {
            ᵹˉᵞ.ᵸˑ(AbstractC3915.m8596(i, "Requested character count ", " is less than zero."));
            return null;
        }
        int length = str.length();
        if (i > length) {
            i = length;
        }
        return str.substring(i);
    }
}