package io.netty.util;

import g.a.a.a.a;
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.Objects;
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 = cached("");
    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);
        }
    };

    public static final class AsciiCaseInsensitiveCharEqualityComparator implements CharEqualityComparator {
        public 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);
        }
    }

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

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

        private DefaultCharEqualityComparator() {
        }

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

    public static final class GeneralCaseInsensitiveCharEqualityComparator implements CharEqualityComparator {
        public 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(CharSequence charSequence) {
        this(charSequence, 0, charSequence.length());
    }

    public AsciiString(CharSequence charSequence, int i2, int i3) {
        if (MathUtil.isOutOfBounds(i2, i3, charSequence.length())) {
            StringBuilder sbI = a.I("expected: 0 <= start(", i2, ") <= start + length(", i3, ") <= value.length(");
            sbI.append(charSequence.length());
            sbI.append(')');
            throw new IndexOutOfBoundsException(sbI.toString());
        }
        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;
    }

    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;
    }

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

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

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

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

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

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

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

    public AsciiString(char[] cArr, int i2, int i3) {
        if (MathUtil.isOutOfBounds(i2, i3, cArr.length)) {
            throw new IndexOutOfBoundsException(a.w(a.I("expected: 0 <= start(", i2, ") <= start + length(", i3, ") <= value.length("), 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;
    }

    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 static char b2c(byte b2) {
        return (char) (b2 & 255);
    }

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

    private static byte c2b0(char c2) {
        return (byte) c2;
    }

    public static AsciiString cached(String str) {
        AsciiString asciiString = new AsciiString(str);
        asciiString.string = str;
        return asciiString;
    }

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

    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 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);
    }

    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 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 boolean equalsIgnoreCase(byte b2, byte b3) {
        return b2 == b3 || toLowerCase(b2) == toLowerCase(b3);
    }

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

    private int forEachByte0(int i2, int i3, ByteProcessor byteProcessor) {
        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) {
        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 hashCode(CharSequence charSequence) {
        if (charSequence == null) {
            return 0;
        }
        return charSequence.getClass() == AsciiString.class ? charSequence.hashCode() : PlatformDependent.hashCodeAscii(charSequence);
    }

    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 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);
    }

    private int parseInt(int i2, int i3, int i4, boolean z2) {
        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 (z2 || (i7 = -i7) >= 0) {
            return i7;
        }
        throw new NumberFormatException(subSequence(i2, i3, false).toString());
    }

    private long parseLong(int i2, int i3, int i4, boolean z2) {
        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 (!z2) {
            j4 = -j4;
            if (j4 < 0) {
                throw new NumberFormatException(subSequence(i2, i3, false).toString());
            }
        }
        return j4;
    }

    public static boolean regionMatches(CharSequence charSequence, boolean z2, 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(z2, i2, (String) charSequence2, i3, i4);
        }
        if (charSequence instanceof AsciiString) {
            return ((AsciiString) charSequence).regionMatches(z2, i2, charSequence2, i3, i4);
        }
        return regionMatchesCharSequences(charSequence, i2, charSequence2, i3, i4, z2 ? GeneralCaseInsensitiveCharEqualityComparator.INSTANCE : DefaultCharEqualityComparator.INSTANCE);
    }

    public static boolean regionMatchesAscii(CharSequence charSequence, boolean z2, int i2, CharSequence charSequence2, int i3, int i4) {
        if (charSequence == null || charSequence2 == null) {
            return false;
        }
        if (!z2 && (charSequence instanceof String) && (charSequence2 instanceof String)) {
            return ((String) charSequence).regionMatches(false, i2, (String) charSequence2, i3, i4);
        }
        if (charSequence instanceof AsciiString) {
            return ((AsciiString) charSequence).regionMatches(z2, i2, charSequence2, i3, i4);
        }
        return regionMatchesCharSequences(charSequence, i2, charSequence2, i3, i4, z2 ? 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;
    }

    private static byte toLowerCase(byte b2) {
        return isUpperCase(b2) ? (byte) (b2 + 32) : b2;
    }

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

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

    public static CharSequence trim(CharSequence charSequence) {
        if (charSequence.getClass() == AsciiString.class) {
            return ((AsciiString) charSequence).trim();
        }
        if (charSequence instanceof String) {
            return ((String) charSequence).trim();
        }
        int i2 = 0;
        int length = charSequence.length() - 1;
        while (i2 <= length && charSequence.charAt(i2) <= ' ') {
            i2++;
        }
        int i3 = length;
        while (i3 >= i2 && charSequence.charAt(i3) <= ' ') {
            i3--;
        }
        return (i2 == 0 && i3 == length) ? charSequence : charSequence.subSequence(i2, i3);
    }

    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) {
            throw new IndexOutOfBoundsException(a.y(a.G("index: ", i2, " must be in the range [0,"), this.length, ")"));
        }
        return PlatformDependent.hasUnsafe() ? PlatformDependent.getByte(this.value, i2 + this.offset) : this.value[i2 + this.offset];
    }

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

    @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 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;
        }
        StringBuilder sbI = a.I("expected: 0 <= srcIdx(", i2, ") <= srcIdx + length(", i4, ") <= srcLen(");
        sbI.append(length());
        sbI.append(')');
        throw new IndexOutOfBoundsException(sbI.toString());
    }

    public void copy(int i2, char[] cArr, int i3, int i4) {
        Objects.requireNonNull(cArr, "dst");
        if (MathUtil.isOutOfBounds(i2, i4, length())) {
            StringBuilder sbI = a.I("expected: 0 <= srcIdx(", i2, ") <= srcIdx + length(", i4, ") <= srcLen(");
            sbI.append(length());
            sbI.append(')');
            throw new IndexOutOfBoundsException(sbI.toString());
        }
        int i5 = i4 + i3;
        int iArrayOffset = arrayOffset() + i2;
        while (i3 < i5) {
            cArr[i3] = b2c(this.value[iArrayOffset]);
            i3++;
            iArrayOffset++;
        }
    }

    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(int i2, int i3, ByteProcessor byteProcessor) {
        if (!MathUtil.isOutOfBounds(i2, i3, length())) {
            return forEachByte0(i2, i3, byteProcessor);
        }
        StringBuilder sbI = a.I("expected: 0 <= index(", i2, ") <= start + length(", i3, ") <= length(");
        sbI.append(length());
        sbI.append(')');
        throw new IndexOutOfBoundsException(sbI.toString());
    }

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

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

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

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

    public int indexOf(char c2, int i2) {
        if (c2 > 255) {
            return -1;
        }
        if (i2 < 0) {
            i2 = 0;
        }
        byte bC2b0 = c2b0(c2);
        int i3 = this.offset;
        int i4 = i3 + i2 + this.length;
        for (int i5 = i2 + i3; i5 < i4; i5++) {
            if (this.value[i5] == bC2b0) {
                return i5 - this.offset;
            }
        }
        return -1;
    }

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

    public int indexOf(CharSequence charSequence, int i2) {
        char cCharAt;
        int length = charSequence.length();
        if (i2 < 0) {
            i2 = 0;
        }
        if (length <= 0) {
            int i3 = this.length;
            return i2 < i3 ? i2 : i3;
        }
        if (length > this.length - i2 || (cCharAt = charSequence.charAt(0)) > 255) {
            return -1;
        }
        byte bC2b0 = c2b0(cCharAt);
        int i4 = this.offset;
        int i5 = ((i4 + i2) + this.length) - length;
        for (int i6 = i2 + i4; i6 <= i5; i6++) {
            if (this.value[i6] == bC2b0) {
                int i7 = i6;
                int i8 = 0;
                do {
                    i8++;
                    if (i8 >= length) {
                        break;
                    }
                    i7++;
                } while (b2c(this.value[i7]) == charSequence.charAt(i8));
                if (i8 == length) {
                    return i6 - this.offset;
                }
            }
        }
        return -1;
    }

    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());
    }

    public int lastIndexOf(CharSequence charSequence, int i2) {
        char cCharAt;
        int length = charSequence.length();
        if (i2 < 0) {
            i2 = 0;
        }
        if (length <= 0) {
            int i3 = this.length;
            return i2 < i3 ? i2 : i3;
        }
        if (length > this.length - i2 || (cCharAt = charSequence.charAt(0)) > 255) {
            return -1;
        }
        byte bC2b0 = c2b0(cCharAt);
        int i4 = this.offset;
        int i5 = i4 + i2;
        for (int i6 = ((i4 + i2) + this.length) - length; i6 >= i5; i6--) {
            if (this.value[i6] == bC2b0) {
                int i7 = 0;
                int i8 = i6;
                do {
                    i7++;
                    if (i7 >= length) {
                        break;
                    }
                    i8++;
                } while (b2c(this.value[i8]) == charSequence.charAt(i7));
                if (i7 == length) {
                    return i6 - this.offset;
                }
            }
        }
        return -1;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    public boolean regionMatches(int i2, CharSequence charSequence, int i3, int i4) {
        Objects.requireNonNull(charSequence, "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 = arrayOffset() + i2;
                while (i3 < i5) {
                    if (b2c(this.value[iArrayOffset]) != charSequence.charAt(i3)) {
                        return false;
                    }
                    i3++;
                    iArrayOffset++;
                }
                return true;
            }
        }
        return false;
    }

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

    public AsciiString replace(char c2, char c3) {
        if (c2 > 255) {
            return this;
        }
        byte bC2b0 = c2b0(c2);
        byte bC2b = c2b(c3);
        int i2 = this.offset;
        int i3 = this.length + i2;
        while (i2 < i3) {
            if (this.value[i2] == bC2b0) {
                byte[] bArr = new byte[length()];
                byte[] bArr2 = this.value;
                int i4 = this.offset;
                System.arraycopy(bArr2, i4, bArr, 0, i2 - i4);
                bArr[i2 - this.offset] = bC2b;
                while (true) {
                    i2++;
                    if (i2 >= i3) {
                        return new AsciiString(bArr, false);
                    }
                    byte b2 = this.value[i2];
                    int i5 = i2 - this.offset;
                    if (b2 == bC2b0) {
                        b2 = bC2b;
                    }
                    bArr[i5] = b2;
                }
            } else {
                i2++;
            }
        }
        return this;
    }

    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 AsciiString[] split(String str, int i2) {
        return toAsciiStringArray(Pattern.compile(str).split(this, i2));
    }

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

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

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

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

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

    public byte[] toByteArray() {
        return toByteArray(0, 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() {
        return toCharArray(0, length());
    }

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

    public AsciiString toLowerCase() {
        boolean z2;
        int iArrayOffset = arrayOffset() + length();
        int iArrayOffset2 = arrayOffset();
        while (true) {
            if (iArrayOffset2 >= iArrayOffset) {
                z2 = true;
                break;
            }
            byte b2 = this.value[iArrayOffset2];
            if (b2 >= 65 && b2 <= 90) {
                z2 = false;
                break;
            }
            iArrayOffset2++;
        }
        if (z2) {
            return this;
        }
        int length = length();
        byte[] bArr = new byte[length];
        int iArrayOffset3 = arrayOffset();
        int i2 = 0;
        while (i2 < length) {
            bArr[i2] = toLowerCase(this.value[iArrayOffset3]);
            i2++;
            iArrayOffset3++;
        }
        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 String toString(int i2) {
        return toString(i2, 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);
        }
        StringBuilder sbI = a.I("expected: 0 <= start(", i2, ") <= srcIdx + length(", i4, ") <= srcLen(");
        sbI.append(length());
        sbI.append(')');
        throw new IndexOutOfBoundsException(sbI.toString());
    }

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

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