package E1;

import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import kotlin.jvm.internal.y;
import o1.AbstractC0653A;
import okhttp3.HttpUrl;

/* JADX INFO: Access modifiers changed from: package-private */
/* JADX INFO: loaded from: classes.dex */
public abstract class p extends o {
    public static boolean j(String str, String suffix, boolean z2) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(suffix, "suffix");
        return !z2 ? str.endsWith(suffix) : o(str, str.length() - suffix.length(), suffix, 0, suffix.length(), true);
    }

    public static /* synthetic */ boolean k(String str, String str2, boolean z2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z2 = false;
        }
        return g.j(str, str2, z2);
    }

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

    public static Comparator m(y yVar) {
        kotlin.jvm.internal.l.e(yVar, "<this>");
        Comparator CASE_INSENSITIVE_ORDER = String.CASE_INSENSITIVE_ORDER;
        kotlin.jvm.internal.l.d(CASE_INSENSITIVE_ORDER, "CASE_INSENSITIVE_ORDER");
        return CASE_INSENSITIVE_ORDER;
    }

    public static boolean n(CharSequence charSequence) {
        kotlin.jvm.internal.l.e(charSequence, "<this>");
        if (charSequence.length() != 0) {
            Iterable iterableH = q.H(charSequence);
            if (!(iterableH instanceof Collection) || !((Collection) iterableH).isEmpty()) {
                Iterator it = iterableH.iterator();
                while (it.hasNext()) {
                    if (!b.c(charSequence.charAt(((AbstractC0653A) it).nextInt()))) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    public static final boolean o(String str, int i2, String other, int i3, int i4, boolean z2) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(other, "other");
        return !z2 ? str.regionMatches(i2, other, i3, i4) : str.regionMatches(z2, i2, other, i3, i4);
    }

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

    public static String q(CharSequence charSequence, int i2) {
        kotlin.jvm.internal.l.e(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);
        AbstractC0653A abstractC0653AD = new kotlin.ranges.i(1, i2).iterator();
        while (abstractC0653AD.hasNext()) {
            abstractC0653AD.nextInt();
            sb.append(charSequence);
        }
        String string = sb.toString();
        kotlin.jvm.internal.l.b(string);
        return string;
    }

    public static final String r(String str, char c2, char c3, boolean z2) {
        kotlin.jvm.internal.l.e(str, "<this>");
        if (!z2) {
            String strReplace = str.replace(c2, c3);
            kotlin.jvm.internal.l.d(strReplace, "replace(...)");
            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, c2, z2)) {
                cCharAt = c3;
            }
            sb.append(cCharAt);
        }
        String string = sb.toString();
        kotlin.jvm.internal.l.d(string, "toString(...)");
        return string;
    }

    public static final String s(String str, String oldValue, String newValue, boolean z2) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(oldValue, "oldValue");
        kotlin.jvm.internal.l.e(newValue, "newValue");
        int i2 = 0;
        int iK = q.K(str, oldValue, 0, z2);
        if (iK < 0) {
            return str;
        }
        int length = oldValue.length();
        int iB = kotlin.ranges.m.b(length, 1);
        int length2 = (str.length() - length) + newValue.length();
        if (length2 < 0) {
            throw new OutOfMemoryError();
        }
        StringBuilder sb = new StringBuilder(length2);
        do {
            sb.append((CharSequence) str, i2, iK);
            sb.append(newValue);
            i2 = iK + length;
            if (iK >= str.length()) {
                break;
            }
            iK = q.K(str, oldValue, iK + iB, z2);
        } while (iK > 0);
        sb.append((CharSequence) str, i2, str.length());
        String string = sb.toString();
        kotlin.jvm.internal.l.d(string, "toString(...)");
        return string;
    }

    public static /* synthetic */ String t(String str, char c2, char c3, boolean z2, int i2, Object obj) {
        if ((i2 & 4) != 0) {
            z2 = false;
        }
        return r(str, c2, c3, z2);
    }

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

    public static boolean v(String str, String prefix, int i2, boolean z2) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(prefix, "prefix");
        return !z2 ? str.startsWith(prefix, i2) : o(str, i2, prefix, 0, prefix.length(), z2);
    }

    public static boolean w(String str, String prefix, boolean z2) {
        kotlin.jvm.internal.l.e(str, "<this>");
        kotlin.jvm.internal.l.e(prefix, "prefix");
        return !z2 ? str.startsWith(prefix) : o(str, 0, prefix, 0, prefix.length(), z2);
    }

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

    public static /* synthetic */ boolean y(String str, String str2, boolean z2, int i2, Object obj) {
        if ((i2 & 2) != 0) {
            z2 = false;
        }
        return g.w(str, str2, z2);
    }
}