package io.netty.util;

import com.seewo.sdk.model.SDKKeyboardCode;
import io.netty.util.ByteProcessor;
import io.netty.util.internal.EmptyArrays;
import io.netty.util.internal.InternalThreadLocalMap;
import io.netty.util.internal.MathUtil;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
public final class AsciiString implements CharSequence, Comparable<CharSequence> {
    public static final int INDEX_NOT_FOUND = -1;
    private static final char MAX_CHAR_VALUE = 255;
    private int hash;
    private final int length;
    private final int offset;
    private String string;
    private final byte[] value;
    public static final AsciiString EMPTY_STRING = new AsciiString("");
    public static final HashingStrategy<CharSequence> CASE_INSENSITIVE_HASHER = new HashingStrategy<CharSequence>() { // from class: io.netty.util.AsciiString.1
        @Override // io.netty.util.HashingStrategy
        public boolean equals(CharSequence charSequence, CharSequence charSequence2) {
            return AsciiString.contentEqualsIgnoreCase(charSequence, charSequence2);
        }

        @Override // io.netty.util.HashingStrategy
        public int hashCode(CharSequence charSequence) {
            return AsciiString.hashCode(charSequence);
        }
    };
    public static final HashingStrategy<CharSequence> CASE_SENSITIVE_HASHER = new HashingStrategy<CharSequence>() { // from class: io.netty.util.AsciiString.2
        @Override // io.netty.util.HashingStrategy
        public boolean equals(CharSequence charSequence, CharSequence charSequence2) {
            return AsciiString.contentEquals(charSequence, charSequence2);
        }

        @Override // io.netty.util.HashingStrategy
        public int hashCode(CharSequence charSequence) {
            return AsciiString.hashCode(charSequence);
        }
    };

    private static final class AsciiCaseInsensitiveCharEqualityComparator implements CharEqualityComparator {
        static final AsciiCaseInsensitiveCharEqualityComparator INSTANCE = new AsciiCaseInsensitiveCharEqualityComparator();

        private AsciiCaseInsensitiveCharEqualityComparator() {
        }

        @Override // io.netty.util.AsciiString.CharEqualityComparator
        public boolean equals(char c2, char c3) {
            return AsciiString.equalsIgnoreCase(c2, c3);
        }
    }

    private interface CharEqualityComparator {
        boolean equals(char c2, char c3);
    }

    private static final class DefaultCharEqualityComparator implements CharEqualityComparator {
        static final DefaultCharEqualityComparator INSTANCE = new DefaultCharEqualityComparator();

        private DefaultCharEqualityComparator() {
        }

        @Override // io.netty.util.AsciiString.CharEqualityComparator
        public boolean equals(char c2, char c3) {
            return c2 == c3;
        }
    }

    private static final class GeneralCaseInsensitiveCharEqualityComparator implements CharEqualityComparator {
        static final GeneralCaseInsensitiveCharEqualityComparator INSTANCE = new GeneralCaseInsensitiveCharEqualityComparator();

        private GeneralCaseInsensitiveCharEqualityComparator() {
        }

        @Override // io.netty.util.AsciiString.CharEqualityComparator
        public boolean equals(char c2, char c3) {
            return Character.toUpperCase(c2) == Character.toUpperCase(c3) || Character.toLowerCase(c2) == Character.toLowerCase(c3);
        }
    }

    public AsciiString(byte[] bArr) {
        this(bArr, true);
    }

    public static char b2c(byte b2) {
        return (char) (b2 & 255);
    }

    public static byte c2b(char c2) {
        if (c2 > 255) {
            c2 = '?';
        }
        return (byte) c2;
    }

    public static boolean containsAllContentEqualsIgnoreCase(Collection<CharSequence> collection, Collection<CharSequence> collection2) {
        Iterator<CharSequence> it = collection2.iterator();
        while (it.hasNext()) {
            if (!containsContentEqualsIgnoreCase(collection, it.next())) {
                return false;
            }
        }
        return true;
    }

    public static boolean containsContentEqualsIgnoreCase(Collection<CharSequence> collection, CharSequence charSequence) {
        Iterator<CharSequence> it = collection.iterator();
        while (it.hasNext()) {
            if (contentEqualsIgnoreCase(charSequence, it.next())) {
                return true;
            }
        }
        return false;
    }

    public static boolean containsIgnoreCase(CharSequence charSequence, CharSequence charSequence2) {
        return contains(charSequence, charSequence2, AsciiCaseInsensitiveCharEqualityComparator.INSTANCE);
    }

    private static boolean equalsIgnoreCase(byte b2, byte b3) {
        return b2 == b3 || toLowerCase(b2) == toLowerCase(b3);
    }

    private int forEachByte0(int i2, int i3, ByteProcessor byteProcessor) throws Exception {
        int i4 = this.offset;
        int i5 = i4 + i2 + i3;
        for (int i6 = i4 + i2; i6 < i5; i6++) {
            if (!byteProcessor.process(this.value[i6])) {
                return i6 - this.offset;
            }
        }
        return -1;
    }

    private int forEachByteDesc0(int i2, int i3, ByteProcessor byteProcessor) throws Exception {
        int i4 = this.offset;
        int i5 = i4 + i2;
        for (int i6 = ((i4 + i2) + i3) - 1; i6 >= i5; i6--) {
            if (!byteProcessor.process(this.value[i6])) {
                return i6 - this.offset;
            }
        }
        return -1;
    }

    public static int indexOfIgnoreCase(CharSequence charSequence, CharSequence charSequence2, int i2) {
        if (charSequence != null && charSequence2 != null) {
            if (i2 < 0) {
                i2 = 0;
            }
            int length = charSequence2.length();
            int length2 = (charSequence.length() - length) + 1;
            if (i2 > length2) {
                return -1;
            }
            if (length == 0) {
                return i2;
            }
            while (i2 < length2) {
                if (regionMatches(charSequence, true, i2, charSequence2, 0, length)) {
                    return i2;
                }
                i2++;
            }
        }
        return -1;
    }

    public static int indexOfIgnoreCaseAscii(CharSequence charSequence, CharSequence charSequence2, int i2) {
        if (charSequence != null && charSequence2 != null) {
            if (i2 < 0) {
                i2 = 0;
            }
            int length = charSequence2.length();
            int length2 = (charSequence.length() - length) + 1;
            if (i2 > length2) {
                return -1;
            }
            if (length == 0) {
                return i2;
            }
            while (i2 < length2) {
                if (regionMatchesAscii(charSequence, true, i2, charSequence2, 0, length)) {
                    return i2;
                }
                i2++;
            }
        }
        return -1;
    }

    private static boolean isLowerCase(byte b2) {
        return b2 >= 97 && b2 <= 122;
    }

    public static boolean isUpperCase(byte b2) {
        return b2 >= 65 && b2 <= 90;
    }

    public static boolean isUpperCase(char c2) {
        return c2 >= 'A' && c2 <= 'Z';
    }

    public static AsciiString of(CharSequence charSequence) {
        return charSequence.getClass() == AsciiString.class ? (AsciiString) charSequence : new AsciiString(charSequence);
    }

    public static boolean regionMatchesAscii(CharSequence charSequence, boolean z, int i2, CharSequence charSequence2, int i3, int i4) {
        if (charSequence == null || charSequence2 == null) {
            return false;
        }
        if (!z && (charSequence instanceof String) && (charSequence2 instanceof String)) {
            return ((String) charSequence).regionMatches(false, i2, (String) charSequence2, i3, i4);
        }
        if (charSequence instanceof AsciiString) {
            return ((AsciiString) charSequence).regionMatches(z, i2, charSequence2, i3, i4);
        }
        return regionMatchesCharSequences(charSequence, i2, charSequence2, i3, i4, z ? AsciiCaseInsensitiveCharEqualityComparator.INSTANCE : DefaultCharEqualityComparator.INSTANCE);
    }

    private static boolean regionMatchesCharSequences(CharSequence charSequence, int i2, CharSequence charSequence2, int i3, int i4, CharEqualityComparator charEqualityComparator) {
        if (i2 < 0 || i4 > charSequence.length() - i2 || i3 < 0 || i4 > charSequence2.length() - i3) {
            return false;
        }
        int i5 = i4 + i2;
        while (i2 < i5) {
            int i6 = i2 + 1;
            int i7 = i3 + 1;
            if (!charEqualityComparator.equals(charSequence.charAt(i2), charSequence2.charAt(i3))) {
                return false;
            }
            i2 = i6;
            i3 = i7;
        }
        return true;
    }

    private static AsciiString[] toAsciiStringArray(String[] strArr) {
        AsciiString[] asciiStringArr = new AsciiString[strArr.length];
        for (int i2 = 0; i2 < strArr.length; i2++) {
            asciiStringArr[i2] = new AsciiString(strArr[i2]);
        }
        return asciiStringArr;
    }

    public byte[] array() {
        return this.value;
    }

    public void arrayChanged() {
        this.string = null;
        this.hash = 0;
    }

    public int arrayOffset() {
        return this.offset;
    }

    public byte byteAt(int i2) {
        if (i2 >= 0 && i2 < this.length) {
            return PlatformDependent.hasUnsafe() ? PlatformDependent.getByte(this.value, i2 + this.offset) : this.value[i2 + this.offset];
        }
        throw new IndexOutOfBoundsException("index: " + i2 + " must be in the range [0," + this.length + ")");
    }

    @Override // java.lang.CharSequence
    public char charAt(int i2) {
        return b2c(byteAt(i2));
    }

    public AsciiString concat(CharSequence charSequence) {
        int length = length();
        int length2 = charSequence.length();
        if (length2 == 0) {
            return this;
        }
        if (charSequence.getClass() == AsciiString.class) {
            AsciiString asciiString = (AsciiString) charSequence;
            if (isEmpty()) {
                return asciiString;
            }
            byte[] bArr = new byte[length + length2];
            System.arraycopy(this.value, arrayOffset(), bArr, 0, length);
            System.arraycopy(asciiString.value, asciiString.arrayOffset(), bArr, length, length2);
            return new AsciiString(bArr, false);
        }
        if (isEmpty()) {
            return new AsciiString(charSequence);
        }
        int i2 = length2 + length;
        byte[] bArr2 = new byte[i2];
        System.arraycopy(this.value, arrayOffset(), bArr2, 0, length);
        int i3 = 0;
        while (length < i2) {
            bArr2[length] = c2b(charSequence.charAt(i3));
            length++;
            i3++;
        }
        return new AsciiString(bArr2, false);
    }

    public boolean contains(CharSequence charSequence) {
        return indexOf(charSequence) >= 0;
    }

    public boolean contentEquals(CharSequence charSequence) {
        if (charSequence == null || charSequence.length() != length()) {
            return false;
        }
        if (charSequence.getClass() == AsciiString.class) {
            return equals(charSequence);
        }
        int iArrayOffset = arrayOffset();
        for (int i2 = 0; i2 < charSequence.length(); i2++) {
            if (b2c(this.value[iArrayOffset]) != charSequence.charAt(i2)) {
                return false;
            }
            iArrayOffset++;
        }
        return true;
    }

    public boolean contentEqualsIgnoreCase(CharSequence charSequence) {
        if (charSequence == null || charSequence.length() != length()) {
            return false;
        }
        if (charSequence.getClass() != AsciiString.class) {
            int iArrayOffset = arrayOffset();
            int i2 = 0;
            while (iArrayOffset < length()) {
                if (!equalsIgnoreCase(b2c(this.value[iArrayOffset]), charSequence.charAt(i2))) {
                    return false;
                }
                iArrayOffset++;
                i2++;
            }
            return true;
        }
        AsciiString asciiString = (AsciiString) charSequence;
        int iArrayOffset2 = arrayOffset();
        int iArrayOffset3 = asciiString.arrayOffset();
        while (iArrayOffset2 < length()) {
            if (!equalsIgnoreCase(this.value[iArrayOffset2], asciiString.value[iArrayOffset3])) {
                return false;
            }
            iArrayOffset2++;
            iArrayOffset3++;
        }
        return true;
    }

    public void copy(int i2, byte[] bArr, int i3, int i4) {
        if (!MathUtil.isOutOfBounds(i2, i4, length())) {
            System.arraycopy(this.value, i2 + this.offset, ObjectUtil.checkNotNull(bArr, "dst"), i3, i4);
            return;
        }
        throw new IndexOutOfBoundsException("expected: 0 <= srcIdx(" + i2 + ") <= srcIdx + length(" + i4 + ") <= srcLen(" + length() + ')');
    }

    public boolean endsWith(CharSequence charSequence) {
        int length = charSequence.length();
        return regionMatches(length() - length, charSequence, 0, length);
    }

    public boolean equals(Object obj) {
        if (obj == null || obj.getClass() != AsciiString.class) {
            return false;
        }
        if (this == obj) {
            return true;
        }
        AsciiString asciiString = (AsciiString) obj;
        return length() == asciiString.length() && hashCode() == asciiString.hashCode() && PlatformDependent.equals(array(), arrayOffset(), asciiString.array(), asciiString.arrayOffset(), length());
    }

    public int forEachByte(ByteProcessor byteProcessor) throws Exception {
        return forEachByte0(0, length(), byteProcessor);
    }

    public int forEachByteDesc(ByteProcessor byteProcessor) throws Exception {
        return forEachByteDesc0(0, length(), byteProcessor);
    }

    public int hashCode() {
        if (this.hash == 0) {
            this.hash = PlatformDependent.hashCodeAscii(this.value, this.offset, this.length);
        }
        return this.hash;
    }

    public int indexOf(CharSequence charSequence) {
        return indexOf(charSequence, 0);
    }

    public boolean isEmpty() {
        return this.length == 0;
    }

    public boolean isEntireArrayUsed() {
        return this.offset == 0 && this.length == this.value.length;
    }

    public int lastIndexOf(CharSequence charSequence) {
        return lastIndexOf(charSequence, length());
    }

    @Override // java.lang.CharSequence
    public int length() {
        return this.length;
    }

    public boolean matches(String str) {
        return Pattern.matches(str, this);
    }

    public boolean parseBoolean() {
        return this.length >= 1 && this.value[this.offset] != 0;
    }

    public char parseChar() {
        return parseChar(0);
    }

    public double parseDouble() {
        return parseDouble(0, length());
    }

    public float parseFloat() {
        return parseFloat(0, length());
    }

    public int parseInt() {
        return parseInt(0, length(), 10);
    }

    public long parseLong() {
        return parseLong(0, length(), 10);
    }

    public short parseShort() {
        return parseShort(0, length(), 10);
    }

    public boolean regionMatches(int i2, CharSequence charSequence, int i3, int i4) {
        if (charSequence == null) {
            throw new NullPointerException("string");
        }
        if (i3 >= 0 && charSequence.length() - i3 >= i4) {
            int length = length();
            if (i2 >= 0 && length - i2 >= i4) {
                if (i4 <= 0) {
                    return true;
                }
                int i5 = i4 + i3;
                int iArrayOffset = i2 + arrayOffset();
                while (i3 < i5) {
                    if (b2c(this.value[iArrayOffset]) != charSequence.charAt(i3)) {
                        return false;
                    }
                    i3++;
                    iArrayOffset++;
                }
                return true;
            }
        }
        return false;
    }

    public AsciiString replace(char c2, char c3) throws Throwable {
        if (c2 > 255) {
            return this;
        }
        byte bC2b = c2b(c2);
        try {
            if (forEachByte(new ByteProcessor.IndexOfProcessor(bC2b)) == -1) {
                return this;
            }
            byte bC2b2 = c2b(c3);
            int length = length();
            byte[] bArr = new byte[length];
            int iArrayOffset = arrayOffset();
            int i2 = 0;
            while (i2 < length) {
                byte b2 = this.value[iArrayOffset];
                if (b2 == bC2b) {
                    b2 = bC2b2;
                }
                bArr[i2] = b2;
                i2++;
                iArrayOffset++;
            }
            return new AsciiString(bArr, false);
        } catch (Exception e2) {
            PlatformDependent.throwException(e2);
            return this;
        }
    }

    public AsciiString[] split(String str, int i2) {
        return toAsciiStringArray(Pattern.compile(str).split(this, i2));
    }

    public boolean startsWith(CharSequence charSequence) {
        return startsWith(charSequence, 0);
    }

    public byte[] toByteArray() {
        return toByteArray(0, length());
    }

    public char[] toCharArray() {
        return toCharArray(0, length());
    }

    public AsciiString toLowerCase() {
        boolean z;
        int length = length() + arrayOffset();
        int iArrayOffset = arrayOffset();
        while (true) {
            if (iArrayOffset >= length) {
                z = true;
                break;
            }
            byte b2 = this.value[iArrayOffset];
            if (b2 >= 65 && b2 <= 90) {
                z = false;
                break;
            }
            iArrayOffset++;
        }
        if (z) {
            return this;
        }
        int length2 = length();
        byte[] bArr = new byte[length2];
        int iArrayOffset2 = arrayOffset();
        int i2 = 0;
        while (i2 < length2) {
            bArr[i2] = toLowerCase(this.value[iArrayOffset2]);
            i2++;
            iArrayOffset2++;
        }
        return new AsciiString(bArr, false);
    }

    @Override // java.lang.CharSequence
    public String toString() {
        String str = this.string;
        if (str != null) {
            return str;
        }
        String string = toString(0);
        this.string = string;
        return string;
    }

    public AsciiString toUpperCase() {
        boolean z;
        int length = length() + arrayOffset();
        int iArrayOffset = arrayOffset();
        while (true) {
            if (iArrayOffset >= length) {
                z = true;
                break;
            }
            byte b2 = this.value[iArrayOffset];
            if (b2 >= 97 && b2 <= 122) {
                z = false;
                break;
            }
            iArrayOffset++;
        }
        if (z) {
            return this;
        }
        int length2 = length();
        byte[] bArr = new byte[length2];
        int iArrayOffset2 = arrayOffset();
        int i2 = 0;
        while (i2 < length2) {
            bArr[i2] = toUpperCase(this.value[iArrayOffset2]);
            i2++;
            iArrayOffset2++;
        }
        return new AsciiString(bArr, false);
    }

    public AsciiString trim() {
        int iArrayOffset = arrayOffset();
        int iArrayOffset2 = (arrayOffset() + length()) - 1;
        while (iArrayOffset <= iArrayOffset2 && this.value[iArrayOffset] <= 32) {
            iArrayOffset++;
        }
        int i2 = iArrayOffset2;
        while (i2 >= iArrayOffset && this.value[i2] <= 32) {
            i2--;
        }
        return (iArrayOffset == 0 && i2 == iArrayOffset2) ? this : new AsciiString(this.value, iArrayOffset, (i2 - iArrayOffset) + 1, false);
    }

    public AsciiString(byte[] bArr, boolean z) {
        this(bArr, 0, bArr.length, z);
    }

    public static boolean contains(CharSequence charSequence, CharSequence charSequence2) {
        return contains(charSequence, charSequence2, DefaultCharEqualityComparator.INSTANCE);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static boolean equalsIgnoreCase(char c2, char c3) {
        return c2 == c3 || toLowerCase(c2) == toLowerCase(c3);
    }

    @Override // java.lang.Comparable
    public int compareTo(CharSequence charSequence) {
        int i2 = 0;
        if (this == charSequence) {
            return 0;
        }
        int length = length();
        int length2 = charSequence.length();
        int iMin = Math.min(length, length2);
        int iArrayOffset = arrayOffset();
        while (i2 < iMin) {
            int iB2c = b2c(this.value[iArrayOffset]) - charSequence.charAt(i2);
            if (iB2c != 0) {
                return iB2c;
            }
            i2++;
            iArrayOffset++;
        }
        return length - length2;
    }

    public int forEachByte(int i2, int i3, ByteProcessor byteProcessor) throws Exception {
        if (!MathUtil.isOutOfBounds(i2, i3, length())) {
            return forEachByte0(i2, i3, byteProcessor);
        }
        throw new IndexOutOfBoundsException("expected: 0 <= index(" + i2 + ") <= start + length(" + i3 + ") <= length(" + length() + ')');
    }

    public int forEachByteDesc(int i2, int i3, ByteProcessor byteProcessor) throws Exception {
        if (!MathUtil.isOutOfBounds(i2, i3, length())) {
            return forEachByteDesc0(i2, i3, byteProcessor);
        }
        throw new IndexOutOfBoundsException("expected: 0 <= index(" + i2 + ") <= start + length(" + i3 + ") <= length(" + length() + ')');
    }

    /* JADX WARN: Code restructure failed: missing block: B:33:0x0057, code lost:
    
        return -1;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public int indexOf(java.lang.CharSequence r10, int r11) throws java.lang.Throwable {
        /*
            r9 = this;
            r0 = 0
            if (r11 >= 0) goto L4
            r11 = r0
        L4:
            int r1 = r9.length()
            int r2 = r10.length()
            if (r2 > 0) goto L13
            if (r11 >= r1) goto L11
            goto L12
        L11:
            r11 = r1
        L12:
            return r11
        L13:
            int r3 = r1 - r11
            r4 = -1
            if (r2 <= r3) goto L19
            return r4
        L19:
            char r3 = r10.charAt(r0)
            r5 = 255(0xff, float:3.57E-43)
            if (r3 <= r5) goto L22
            return r4
        L22:
            io.netty.util.ByteProcessor$IndexOfProcessor r5 = new io.netty.util.ByteProcessor$IndexOfProcessor
            byte r3 = (byte) r3
            r5.<init>(r3)
        L28:
            int r3 = r1 - r11
            int r11 = r9.forEachByte(r11, r3, r5)     // Catch: java.lang.Exception -> L58
            if (r11 == r4) goto L57
            int r3 = r2 + r11
            if (r3 <= r1) goto L35
            goto L57
        L35:
            r6 = r11
            r3 = r0
        L37:
            int r3 = r3 + 1
            if (r3 >= r2) goto L51
            byte[] r7 = r9.value     // Catch: java.lang.Exception -> L58
            int r6 = r6 + 1
            int r8 = r9.arrayOffset()     // Catch: java.lang.Exception -> L58
            int r8 = r8 + r6
            r7 = r7[r8]     // Catch: java.lang.Exception -> L58
            char r7 = b2c(r7)     // Catch: java.lang.Exception -> L58
            char r8 = r10.charAt(r3)     // Catch: java.lang.Exception -> L58
            if (r7 != r8) goto L51
            goto L37
        L51:
            if (r3 != r2) goto L54
            return r11
        L54:
            int r11 = r11 + 1
            goto L28
        L57:
            return r4
        L58:
            r10 = move-exception
            io.netty.util.internal.PlatformDependent.throwException(r10)
            return r4
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.AsciiString.indexOf(java.lang.CharSequence, int):int");
    }

    public int lastIndexOf(CharSequence charSequence, int i2) throws Throwable {
        int length = length();
        int length2 = charSequence.length();
        if (length2 <= length && i2 >= 0) {
            if (length2 <= 0) {
                return i2 < length ? i2 : length;
            }
            int iMin = Math.min(i2, length - length2);
            char cCharAt = charSequence.charAt(0);
            if (cCharAt > 255) {
                return -1;
            }
            ByteProcessor.IndexOfProcessor indexOfProcessor = new ByteProcessor.IndexOfProcessor((byte) cCharAt);
            while (true) {
                try {
                    int iForEachByteDesc = forEachByteDesc(iMin, length - iMin, indexOfProcessor);
                    if (iForEachByteDesc == -1) {
                        return -1;
                    }
                    int i3 = iForEachByteDesc;
                    int i4 = 0;
                    do {
                        i4++;
                        if (i4 >= length2) {
                            break;
                        }
                        i3++;
                    } while (b2c(this.value[arrayOffset() + i3]) == charSequence.charAt(i4));
                    if (i4 == length2) {
                        return iForEachByteDesc;
                    }
                    iMin = iForEachByteDesc - 1;
                } catch (Exception e2) {
                    PlatformDependent.throwException(e2);
                }
            }
        }
        return -1;
    }

    public char parseChar(int i2) {
        if (i2 + 1 < length()) {
            int i3 = i2 + this.offset;
            return (char) (b2c(this.value[i3 + 1]) | (b2c(this.value[i3]) << '\b'));
        }
        throw new IndexOutOfBoundsException("2 bytes required to convert to character. index " + i2 + " would go out of bounds.");
    }

    public double parseDouble(int i2, int i3) {
        return Double.parseDouble(toString(i2, i3));
    }

    public float parseFloat(int i2, int i3) {
        return Float.parseFloat(toString(i2, i3));
    }

    public int parseInt(int i2) {
        return parseInt(0, length(), i2);
    }

    public long parseLong(int i2) {
        return parseLong(0, length(), i2);
    }

    public short parseShort(int i2) {
        return parseShort(0, length(), i2);
    }

    public AsciiString[] split(char c2) {
        ArrayList arrayList = InternalThreadLocalMap.get().arrayList();
        int length = length();
        int i2 = 0;
        for (int i3 = 0; i3 < length; i3++) {
            if (charAt(i3) == c2) {
                if (i2 == i3) {
                    arrayList.add(EMPTY_STRING);
                } else {
                    arrayList.add(new AsciiString(this.value, arrayOffset() + i2, i3 - i2, false));
                }
                i2 = i3 + 1;
            }
        }
        if (i2 == 0) {
            arrayList.add(this);
        } else if (i2 != length) {
            arrayList.add(new AsciiString(this.value, arrayOffset() + i2, length - i2, false));
        } else {
            for (int size = arrayList.size() - 1; size >= 0 && ((AsciiString) arrayList.get(size)).isEmpty(); size--) {
                arrayList.remove(size);
            }
        }
        return (AsciiString[]) arrayList.toArray(new AsciiString[arrayList.size()]);
    }

    public boolean startsWith(CharSequence charSequence, int i2) {
        return regionMatches(i2, charSequence, 0, charSequence.length());
    }

    public AsciiString subSequence(int i2) {
        return subSequence(i2, length());
    }

    public byte[] toByteArray(int i2, int i3) {
        byte[] bArr = this.value;
        int i4 = this.offset;
        return Arrays.copyOfRange(bArr, i2 + i4, i3 + i4);
    }

    public char[] toCharArray(int i2, int i3) {
        int i4 = i3 - i2;
        if (i4 == 0) {
            return EmptyArrays.EMPTY_CHARS;
        }
        if (!MathUtil.isOutOfBounds(i2, i4, length())) {
            char[] cArr = new char[i4];
            int i5 = 0;
            int iArrayOffset = i2 + arrayOffset();
            while (i5 < i4) {
                cArr[i5] = b2c(this.value[iArrayOffset]);
                i5++;
                iArrayOffset++;
            }
            return cArr;
        }
        throw new IndexOutOfBoundsException("expected: 0 <= start(" + i2 + ") <= srcIdx + length(" + i4 + ") <= srcLen(" + length() + ')');
    }

    public AsciiString(byte[] bArr, int i2, int i3, boolean z) {
        if (z) {
            this.value = Arrays.copyOfRange(bArr, i2, i2 + i3);
            this.offset = 0;
        } else if (!MathUtil.isOutOfBounds(i2, i3, bArr.length)) {
            this.value = bArr;
            this.offset = i2;
        } else {
            throw new IndexOutOfBoundsException("expected: 0 <= start(" + i2 + ") <= start + length(" + i3 + ") <= value.length(" + bArr.length + ')');
        }
        this.length = i3;
    }

    private static boolean contains(CharSequence charSequence, CharSequence charSequence2, CharEqualityComparator charEqualityComparator) {
        if (charSequence != null && charSequence2 != null && charSequence.length() >= charSequence2.length()) {
            if (charSequence2.length() == 0) {
                return true;
            }
            int i2 = 0;
            for (int i3 = 0; i3 < charSequence.length(); i3++) {
                if (charEqualityComparator.equals(charSequence2.charAt(i2), charSequence.charAt(i3))) {
                    i2++;
                    if (i2 == charSequence2.length()) {
                        return true;
                    }
                } else {
                    if (charSequence.length() - i3 < charSequence2.length()) {
                        return false;
                    }
                    i2 = 0;
                }
            }
        }
        return false;
    }

    public int parseInt(int i2, int i3) {
        return parseInt(i2, i3, 10);
    }

    public long parseLong(int i2, int i3) {
        return parseLong(i2, i3, 10);
    }

    public short parseShort(int i2, int i3) {
        return parseShort(i2, i3, 10);
    }

    @Override // java.lang.CharSequence
    public AsciiString subSequence(int i2, int i3) {
        return subSequence(i2, i3, true);
    }

    public String toString(int i2) {
        return toString(i2, length());
    }

    public static int hashCode(CharSequence charSequence) {
        if (charSequence == null) {
            return 0;
        }
        if (charSequence.getClass() == AsciiString.class) {
            return charSequence.hashCode();
        }
        return PlatformDependent.hashCodeAscii(charSequence);
    }

    public void copy(int i2, char[] cArr, int i3, int i4) {
        if (cArr != null) {
            if (!MathUtil.isOutOfBounds(i2, i4, length())) {
                int i5 = i4 + i3;
                int iArrayOffset = i2 + arrayOffset();
                while (i3 < i5) {
                    cArr[i3] = b2c(this.value[iArrayOffset]);
                    i3++;
                    iArrayOffset++;
                }
                return;
            }
            throw new IndexOutOfBoundsException("expected: 0 <= srcIdx(" + i2 + ") <= srcIdx + length(" + i4 + ") <= srcLen(" + length() + ')');
        }
        throw new NullPointerException("dst");
    }

    public int parseInt(int i2, int i3, int i4) {
        if (i4 < 2 || i4 > 36) {
            throw new NumberFormatException();
        }
        if (i2 != i3) {
            boolean z = byteAt(i2) == 45;
            if (z) {
                int i5 = i2 + 1;
                if (i5 == i3) {
                    throw new NumberFormatException(subSequence(i2, i3, false).toString());
                }
                i2 = i5;
            }
            return parseInt(i2, i3, i4, z);
        }
        throw new NumberFormatException();
    }

    public long parseLong(int i2, int i3, int i4) {
        if (i4 < 2 || i4 > 36) {
            throw new NumberFormatException();
        }
        if (i2 != i3) {
            boolean z = byteAt(i2) == 45;
            if (z) {
                int i5 = i2 + 1;
                if (i5 == i3) {
                    throw new NumberFormatException(subSequence(i2, i3, false).toString());
                }
                i2 = i5;
            }
            return parseLong(i2, i3, i4, z);
        }
        throw new NumberFormatException();
    }

    public short parseShort(int i2, int i3, int i4) {
        int i5 = parseInt(i2, i3, i4);
        short s = (short) i5;
        if (s == i5) {
            return s;
        }
        throw new NumberFormatException(subSequence(i2, i3, false).toString());
    }

    public AsciiString subSequence(int i2, int i3, boolean z) {
        int i4 = i3 - i2;
        if (!MathUtil.isOutOfBounds(i2, i4, length())) {
            if (i2 == 0 && i3 == length()) {
                return this;
            }
            if (i3 == i2) {
                return EMPTY_STRING;
            }
            return new AsciiString(this.value, i2 + this.offset, i4, z);
        }
        throw new IndexOutOfBoundsException("expected: 0 <= start(" + i2 + ") <= end (" + i3 + ") <= length(" + length() + ')');
    }

    public String toString(int i2, int i3) {
        int i4 = i3 - i2;
        if (i4 == 0) {
            return "";
        }
        if (!MathUtil.isOutOfBounds(i2, i4, length())) {
            return new String(this.value, 0, i2 + this.offset, i4);
        }
        throw new IndexOutOfBoundsException("expected: 0 <= start(" + i2 + ") <= srcIdx + length(" + i4 + ") <= srcLen(" + length() + ')');
    }

    public static boolean contentEquals(CharSequence charSequence, CharSequence charSequence2) {
        if (charSequence == null || charSequence2 == null) {
            return charSequence == charSequence2;
        }
        if (charSequence.getClass() == AsciiString.class) {
            return ((AsciiString) charSequence).contentEquals(charSequence2);
        }
        if (charSequence2.getClass() == AsciiString.class) {
            return ((AsciiString) charSequence2).contentEquals(charSequence);
        }
        if (charSequence.length() != charSequence2.length()) {
            return false;
        }
        for (int i2 = 0; i2 < charSequence.length(); i2++) {
            if (charSequence.charAt(i2) != charSequence2.charAt(i2)) {
                return false;
            }
        }
        return true;
    }

    public boolean regionMatches(boolean z, int i2, CharSequence charSequence, int i3, int i4) {
        if (!z) {
            return regionMatches(i2, charSequence, i3, i4);
        }
        if (charSequence != null) {
            int length = length();
            if (i2 < 0 || i4 > length - i2 || i3 < 0 || i4 > charSequence.length() - i3) {
                return false;
            }
            int iArrayOffset = i2 + arrayOffset();
            int i5 = i4 + iArrayOffset;
            while (iArrayOffset < i5) {
                int i6 = iArrayOffset + 1;
                char cB2c = b2c(this.value[iArrayOffset]);
                int i7 = i3 + 1;
                if (!equalsIgnoreCase(cB2c, charSequence.charAt(i3))) {
                    return false;
                }
                i3 = i7;
                iArrayOffset = i6;
            }
            return true;
        }
        throw new NullPointerException("string");
    }

    public static boolean contentEqualsIgnoreCase(CharSequence charSequence, CharSequence charSequence2) {
        if (charSequence == null || charSequence2 == null) {
            return charSequence == charSequence2;
        }
        if (charSequence.getClass() == AsciiString.class) {
            return ((AsciiString) charSequence).contentEqualsIgnoreCase(charSequence2);
        }
        if (charSequence2.getClass() == AsciiString.class) {
            return ((AsciiString) charSequence2).contentEqualsIgnoreCase(charSequence);
        }
        if (charSequence.length() != charSequence2.length()) {
            return false;
        }
        int i2 = 0;
        int i3 = 0;
        while (i2 < charSequence.length()) {
            if (!equalsIgnoreCase(charSequence.charAt(i2), charSequence2.charAt(i3))) {
                return false;
            }
            i2++;
            i3++;
        }
        return true;
    }

    private static byte toLowerCase(byte b2) {
        return isUpperCase(b2) ? (byte) (b2 + SDKKeyboardCode.FUNCTION_KEY_BOARD_3) : b2;
    }

    private static byte toUpperCase(byte b2) {
        return isLowerCase(b2) ? (byte) (b2 - 32) : b2;
    }

    private int parseInt(int i2, int i3, int i4, boolean z) {
        int i5 = Integer.MIN_VALUE / i4;
        int i6 = i2;
        int i7 = 0;
        while (i6 < i3) {
            int i8 = i6 + 1;
            int iDigit = Character.digit((char) (this.value[i6 + this.offset] & 255), i4);
            if (iDigit == -1) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
            if (i5 > i7) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
            int i9 = (i7 * i4) - iDigit;
            if (i9 > i7) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
            i7 = i9;
            i6 = i8;
        }
        if (z || (i7 = -i7) >= 0) {
            return i7;
        }
        throw new NumberFormatException(subSequence(i2, i3, false).toString());
    }

    private long parseLong(int i2, int i3, int i4, boolean z) {
        long j2 = i4;
        long j3 = Long.MIN_VALUE / j2;
        int i5 = i2;
        long j4 = 0;
        while (i5 < i3) {
            int i6 = i5 + 1;
            int iDigit = Character.digit((char) (this.value[i5 + this.offset] & 255), i4);
            if (iDigit == -1) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
            if (j3 > j4) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
            long j5 = (j4 * j2) - ((long) iDigit);
            if (j5 > j4) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
            j4 = j5;
            i5 = i6;
        }
        if (!z) {
            j4 = -j4;
            if (j4 < 0) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
        }
        return j4;
    }

    private static char toLowerCase(char c2) {
        return isUpperCase(c2) ? (char) (c2 + ' ') : c2;
    }

    public int indexOf(char c2, int i2) throws Throwable {
        if (i2 < 0) {
            i2 = 0;
        }
        int length = length();
        if (c2 > 255) {
            return -1;
        }
        try {
            return forEachByte(i2, length - i2, new ByteProcessor.IndexOfProcessor((byte) c2));
        } catch (Exception e2) {
            PlatformDependent.throwException(e2);
            return -1;
        }
    }

    public AsciiString(ByteBuffer byteBuffer) {
        this(byteBuffer, true);
    }

    public AsciiString(ByteBuffer byteBuffer, boolean z) {
        this(byteBuffer, byteBuffer.position(), byteBuffer.remaining(), z);
    }

    public static int indexOf(CharSequence charSequence, char c2, int i2) {
        if (charSequence instanceof String) {
            return ((String) charSequence).indexOf(c2, i2);
        }
        if (charSequence instanceof AsciiString) {
            return ((AsciiString) charSequence).indexOf(c2, i2);
        }
        if (charSequence == null) {
            return -1;
        }
        int length = charSequence.length();
        if (i2 < 0) {
            i2 = 0;
        }
        while (i2 < length) {
            if (charSequence.charAt(i2) == c2) {
                return i2;
            }
            i2++;
        }
        return -1;
    }

    public static boolean regionMatches(CharSequence charSequence, boolean z, int i2, CharSequence charSequence2, int i3, int i4) {
        if (charSequence == null || charSequence2 == null) {
            return false;
        }
        if ((charSequence instanceof String) && (charSequence2 instanceof String)) {
            return ((String) charSequence).regionMatches(z, i2, (String) charSequence2, i3, i4);
        }
        if (charSequence instanceof AsciiString) {
            return ((AsciiString) charSequence).regionMatches(z, i2, charSequence2, i3, i4);
        }
        return regionMatchesCharSequences(charSequence, i2, charSequence2, i3, i4, z ? GeneralCaseInsensitiveCharEqualityComparator.INSTANCE : DefaultCharEqualityComparator.INSTANCE);
    }

    public AsciiString(ByteBuffer byteBuffer, int i2, int i3, boolean z) {
        if (!MathUtil.isOutOfBounds(i2, i3, byteBuffer.capacity())) {
            if (!byteBuffer.hasArray()) {
                this.value = new byte[i3];
                int iPosition = byteBuffer.position();
                byteBuffer.get(this.value, 0, i3);
                byteBuffer.position(iPosition);
                this.offset = 0;
            } else if (z) {
                int iArrayOffset = byteBuffer.arrayOffset() + i2;
                this.value = Arrays.copyOfRange(byteBuffer.array(), iArrayOffset, iArrayOffset + i3);
                this.offset = 0;
            } else {
                this.value = byteBuffer.array();
                this.offset = i2;
            }
            this.length = i3;
            return;
        }
        throw new IndexOutOfBoundsException("expected: 0 <= start(" + i2 + ") <= start + length(" + i3 + ") <= value.capacity(" + byteBuffer.capacity() + ')');
    }

    public AsciiString(char[] cArr) {
        this(cArr, 0, cArr.length);
    }

    public AsciiString(char[] cArr, int i2, int i3) {
        if (!MathUtil.isOutOfBounds(i2, i3, cArr.length)) {
            this.value = new byte[i3];
            int i4 = 0;
            while (i4 < i3) {
                this.value[i4] = c2b(cArr[i2]);
                i4++;
                i2++;
            }
            this.offset = 0;
            this.length = i3;
            return;
        }
        throw new IndexOutOfBoundsException("expected: 0 <= start(" + i2 + ") <= start + length(" + i3 + ") <= value.length(" + cArr.length + ')');
    }

    public AsciiString(char[] cArr, Charset charset) {
        this(cArr, charset, 0, cArr.length);
    }

    public AsciiString(char[] cArr, Charset charset, int i2, int i3) {
        CharBuffer charBufferWrap = CharBuffer.wrap(cArr, i2, i3);
        CharsetEncoder charsetEncoderEncoder = CharsetUtil.encoder(charset);
        ByteBuffer byteBufferAllocate = ByteBuffer.allocate((int) (charsetEncoderEncoder.maxBytesPerChar() * i3));
        charsetEncoderEncoder.encode(charBufferWrap, byteBufferAllocate, true);
        int iArrayOffset = byteBufferAllocate.arrayOffset();
        byte[] bArrCopyOfRange = Arrays.copyOfRange(byteBufferAllocate.array(), iArrayOffset, byteBufferAllocate.position() + iArrayOffset);
        this.value = bArrCopyOfRange;
        this.offset = 0;
        this.length = bArrCopyOfRange.length;
    }

    public AsciiString(CharSequence charSequence) {
        this(charSequence, 0, charSequence.length());
    }

    public AsciiString(CharSequence charSequence, int i2, int i3) {
        if (!MathUtil.isOutOfBounds(i2, i3, charSequence.length())) {
            this.value = new byte[i3];
            int i4 = 0;
            while (i4 < i3) {
                this.value[i4] = c2b(charSequence.charAt(i2));
                i4++;
                i2++;
            }
            this.offset = 0;
            this.length = i3;
            return;
        }
        throw new IndexOutOfBoundsException("expected: 0 <= start(" + i2 + ") <= start + length(" + i3 + ") <= value.length(" + charSequence.length() + ')');
    }

    public AsciiString(CharSequence charSequence, Charset charset) {
        this(charSequence, charset, 0, charSequence.length());
    }

    public AsciiString(CharSequence charSequence, Charset charset, int i2, int i3) {
        CharBuffer charBufferWrap = CharBuffer.wrap(charSequence, i2, i2 + i3);
        CharsetEncoder charsetEncoderEncoder = CharsetUtil.encoder(charset);
        ByteBuffer byteBufferAllocate = ByteBuffer.allocate((int) (charsetEncoderEncoder.maxBytesPerChar() * i3));
        charsetEncoderEncoder.encode(charBufferWrap, byteBufferAllocate, true);
        int iArrayOffset = byteBufferAllocate.arrayOffset();
        byte[] bArrCopyOfRange = Arrays.copyOfRange(byteBufferAllocate.array(), iArrayOffset, byteBufferAllocate.position() + iArrayOffset);
        this.value = bArrCopyOfRange;
        this.offset = 0;
        this.length = bArrCopyOfRange.length;
    }
}