package j.u0;

import j.k0.e0;
import j.p0.d.g0;
import java.util.Comparator;
import okhttp3.HttpUrl;

/* JADX INFO: Access modifiers changed from: package-private */
/* JADX INFO: compiled from: StringsJVM.kt */
/* JADX INFO: loaded from: classes.dex */
public class q extends p {
    public static boolean A(String str, String str2, int i2, boolean z) {
        j.p0.d.r.f(str, "<this>");
        j.p0.d.r.f(str2, "prefix");
        return !z ? str.startsWith(str2, i2) : t(str, i2, str2, 0, str2.length(), z);
    }

    public static boolean B(String str, String str2, boolean z) {
        j.p0.d.r.f(str, "<this>");
        j.p0.d.r.f(str2, "prefix");
        return !z ? str.startsWith(str2) : t(str, 0, str2, 0, str2.length(), z);
    }

    public static /* synthetic */ boolean C(String str, String str2, int i2, boolean z, int i3, Object obj) {
        if ((i3 & 4) != 0) {
            z = false;
        }
        return A(str, str2, i2, z);
    }

    public static /* synthetic */ boolean D(String str, String str2, boolean z, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z = false;
        }
        return B(str, str2, z);
    }

    public static final boolean o(String str, String str2, boolean z) {
        j.p0.d.r.f(str, "<this>");
        j.p0.d.r.f(str2, "suffix");
        return !z ? str.endsWith(str2) : t(str, str.length() - str2.length(), str2, 0, str2.length(), true);
    }

    public static /* synthetic */ boolean p(String str, String str2, boolean z, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z = false;
        }
        return o(str, str2, z);
    }

    public static boolean q(String str, String str2, boolean z) {
        return str == null ? str2 == null : !z ? str.equals(str2) : str.equalsIgnoreCase(str2);
    }

    public static Comparator<String> r(g0 g0Var) {
        j.p0.d.r.f(g0Var, "<this>");
        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
        j.p0.d.r.e(comparator, "CASE_INSENSITIVE_ORDER");
        return comparator;
    }

    /* JADX WARN: Removed duplicated region for block: B:21:? A[RETURN, SYNTHETIC] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static boolean s(java.lang.CharSequence r4) {
        /*
            java.lang.String r0 = "<this>"
            j.p0.d.r.f(r4, r0)
            int r0 = r4.length()
            r1 = 0
            r2 = 1
            if (r0 == 0) goto L3e
            j.r0.h r0 = j.u0.r.M(r4)
            boolean r3 = r0 instanceof java.util.Collection
            if (r3 == 0) goto L20
            r3 = r0
            java.util.Collection r3 = (java.util.Collection) r3
            boolean r3 = r3.isEmpty()
            if (r3 == 0) goto L20
        L1e:
            r4 = r2
            goto L3c
        L20:
            java.util.Iterator r0 = r0.iterator()
        L24:
            boolean r3 = r0.hasNext()
            if (r3 == 0) goto L1e
            r3 = r0
            j.k0.e0 r3 = (j.k0.e0) r3
            int r3 = r3.b()
            char r3 = r4.charAt(r3)
            boolean r3 = j.u0.b.c(r3)
            if (r3 != 0) goto L24
            r4 = r1
        L3c:
            if (r4 == 0) goto L3f
        L3e:
            r1 = r2
        L3f:
            return r1
        */
        throw new UnsupportedOperationException("Method not decompiled: j.u0.q.s(java.lang.CharSequence):boolean");
    }

    public static boolean t(String str, int i2, String str2, int i3, int i4, boolean z) {
        j.p0.d.r.f(str, "<this>");
        j.p0.d.r.f(str2, "other");
        return !z ? str.regionMatches(i2, str2, i3, i4) : str.regionMatches(z, i2, str2, i3, i4);
    }

    public static /* synthetic */ boolean u(String str, int i2, String str2, int i3, int i4, boolean z, int i5, Object obj) {
        if ((i5 & 16) != 0) {
            z = false;
        }
        return t(str, i2, str2, i3, i4, z);
    }

    public static String v(CharSequence charSequence, int i2) {
        j.p0.d.r.f(charSequence, "<this>");
        if (!(i2 >= 0)) {
            throw new IllegalArgumentException(("Count 'n' must be non-negative, but was " + i2 + '.').toString());
        }
        if (i2 == 0) {
            return HttpUrl.FRAGMENT_ENCODE_SET;
        }
        if (i2 == 1) {
            return charSequence.toString();
        }
        int length = charSequence.length();
        if (length == 0) {
            return HttpUrl.FRAGMENT_ENCODE_SET;
        }
        if (length == 1) {
            char cCharAt = charSequence.charAt(0);
            char[] cArr = new char[i2];
            for (int i3 = 0; i3 < i2; i3++) {
                cArr[i3] = cCharAt;
            }
            return new String(cArr);
        }
        StringBuilder sb = new StringBuilder(charSequence.length() * i2);
        e0 e0VarE = new j.r0.h(1, i2).iterator();
        while (e0VarE.hasNext()) {
            e0VarE.b();
            sb.append(charSequence);
        }
        String string = sb.toString();
        j.p0.d.r.e(string, "{\n                    va…tring()\n                }");
        return string;
    }

    public static final String w(String str, char c, char c2, boolean z) {
        j.p0.d.r.f(str, "<this>");
        if (!z) {
            String strReplace = str.replace(c, c2);
            j.p0.d.r.e(strReplace, "this as java.lang.String…replace(oldChar, newChar)");
            return strReplace;
        }
        StringBuilder sb = new StringBuilder(str.length());
        for (int i2 = 0; i2 < str.length(); i2++) {
            char cCharAt = str.charAt(i2);
            if (c.d(cCharAt, c, z)) {
                cCharAt = c2;
            }
            sb.append(cCharAt);
        }
        String string = sb.toString();
        j.p0.d.r.e(string, "StringBuilder(capacity).…builderAction).toString()");
        return string;
    }

    public static final String x(String str, String str2, String str3, boolean z) {
        j.p0.d.r.f(str, "<this>");
        j.p0.d.r.f(str2, "oldValue");
        j.p0.d.r.f(str3, "newValue");
        int i2 = 0;
        int iP = r.P(str, str2, 0, z);
        if (iP < 0) {
            return str;
        }
        int length = str2.length();
        int iB = j.r0.n.b(length, 1);
        int length2 = (str.length() - length) + str3.length();
        if (length2 < 0) {
            throw new OutOfMemoryError();
        }
        StringBuilder sb = new StringBuilder(length2);
        do {
            sb.append((CharSequence) str, i2, iP);
            sb.append(str3);
            i2 = iP + length;
            if (iP >= str.length()) {
                break;
            }
            iP = r.P(str, str2, iP + iB, z);
        } while (iP > 0);
        sb.append((CharSequence) str, i2, str.length());
        String string = sb.toString();
        j.p0.d.r.e(string, "stringBuilder.append(this, i, length).toString()");
        return string;
    }

    public static /* synthetic */ String y(String str, char c, char c2, boolean z, int i2, Object obj) {
        if ((i2 & 4) != 0) {
            z = false;
        }
        return w(str, c, c2, z);
    }

    public static /* synthetic */ String z(String str, String str2, String str3, boolean z, int i2, Object obj) {
        if ((i2 & 4) != 0) {
            z = false;
        }
        return x(str, str2, str3, z);
    }
}