package com.mbridge.msdk.thrid.okio;
import com.kwai.video.player.KsMediaMeta;
import com.mbridge.msdk.playercommon.exoplayer2.C;
import com.sigmob.sdk.archives.tar.e;
import com.umeng.analytics.pro.cb;
import java.io.Closeable;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.nio.charset.Charset;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import kotlin.UByte;
import kotlin.jvm.internal.ByteCompanionObject;
import kotlin.text.Typography;
import okhttp3.internal.connection.RealConnection;
import okio.Utf8;
import okio.internal.BufferKt;
public final class Buffer implements BufferedSource, BufferedSink, Cloneable, ByteChannel {
private static final byte[] DIGITS = {e.H, e.I, e.J, e.f133K, e.L, e.M, e.N, e.O, 56, 57, 97, 98, 99, 100, 101, 102};
static final int REPLACEMENT_CHARACTER = 65533;
Segment head;
long size;
@Override // com.mbridge.msdk.thrid.okio.BufferedSink, com.mbridge.msdk.thrid.okio.BufferedSource
public Buffer buffer() {
return this;
}
@Override // java.lang.AutoCloseable, com.mbridge.msdk.thrid.okio.Sink, java.io.Closeable, com.mbridge.msdk.thrid.okio.Source, java.nio.channels.Channel
public void close() {
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public BufferedSink emit() {
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer emitCompleteSegments() {
return this;
}
@Override // com.mbridge.msdk.thrid.okio.Sink, com.mbridge.msdk.thrid.okio.BufferedSink, java.io.Flushable
public void flush() {
}
public boolean isOpen() {
return true;
}
public final long size() {
return this.size;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public OutputStream outputStream() {
return new OutputStream() {
/* class com.mbridge.msdk.thrid.okio.Buffer.AnonymousClass1 */
@Override // java.io.OutputStream, java.io.Closeable, java.lang.AutoCloseable
public void close() {
}
@Override // java.io.OutputStream, java.io.Flushable
public void flush() {
}
@Override // java.io.OutputStream
public void write(int i) {
Buffer.this.writeByte((int) ((byte) i));
}
@Override // java.io.OutputStream
public void write(byte[] bArr, int i, int i2) {
Buffer.this.write(bArr, i, i2);
}
public String toString() {
return Buffer.this + ".outputStream()";
}
};
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public boolean exhausted() {
return this.size == 0;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public void require(long j) throws EOFException {
if (this.size < j) {
throw new EOFException();
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public boolean request(long j) {
return this.size >= j;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public InputStream inputStream() {
return new InputStream() {
/* class com.mbridge.msdk.thrid.okio.Buffer.AnonymousClass2 */
@Override // java.io.Closeable, java.lang.AutoCloseable, java.io.InputStream
public void close() {
}
@Override // java.io.InputStream
public int read() {
if (Buffer.this.size > 0) {
return Buffer.this.readByte() & UByte.MAX_VALUE;
}
return -1;
}
@Override // java.io.InputStream
public int read(byte[] bArr, int i, int i2) {
return Buffer.this.read(bArr, i, i2);
}
@Override // java.io.InputStream
public int available() {
return (int) Math.min(Buffer.this.size, 2147483647L);
}
public String toString() {
return Buffer.this + ".inputStream()";
}
};
}
public final Buffer copyTo(OutputStream outputStream) throws IOException {
return copyTo(outputStream, 0, this.size);
}
public final Buffer copyTo(OutputStream outputStream, long j, long j2) throws IOException {
if (outputStream != null) {
Util.checkOffsetAndCount(this.size, j, j2);
if (j2 == 0) {
return this;
}
Segment segment = this.head;
while (j >= ((long) (segment.limit - segment.pos))) {
j -= (long) (segment.limit - segment.pos);
segment = segment.next;
}
while (j2 > 0) {
int i = (int) (((long) segment.pos) + j);
int min = (int) Math.min((long) (segment.limit - i), j2);
outputStream.write(segment.data, i, min);
j2 -= (long) min;
segment = segment.next;
j = 0;
}
return this;
}
throw new IllegalArgumentException("out == null");
}
public final Buffer copyTo(Buffer buffer, long j, long j2) {
if (buffer != null) {
Util.checkOffsetAndCount(this.size, j, j2);
if (j2 == 0) {
return this;
}
buffer.size += j2;
Segment segment = this.head;
while (j >= ((long) (segment.limit - segment.pos))) {
j -= (long) (segment.limit - segment.pos);
segment = segment.next;
}
while (j2 > 0) {
Segment sharedCopy = segment.sharedCopy();
sharedCopy.pos = (int) (((long) sharedCopy.pos) + j);
sharedCopy.limit = Math.min(sharedCopy.pos + ((int) j2), sharedCopy.limit);
Segment segment2 = buffer.head;
if (segment2 == null) {
sharedCopy.prev = sharedCopy;
sharedCopy.next = sharedCopy;
buffer.head = sharedCopy;
} else {
segment2.prev.push(sharedCopy);
}
j2 -= (long) (sharedCopy.limit - sharedCopy.pos);
segment = segment.next;
j = 0;
}
return this;
}
throw new IllegalArgumentException("out == null");
}
public final Buffer writeTo(OutputStream outputStream) throws IOException {
return writeTo(outputStream, this.size);
}
public final Buffer writeTo(OutputStream outputStream, long j) throws IOException {
if (outputStream != null) {
Util.checkOffsetAndCount(this.size, 0, j);
Segment segment = this.head;
while (j > 0) {
int min = (int) Math.min(j, (long) (segment.limit - segment.pos));
outputStream.write(segment.data, segment.pos, min);
segment.pos += min;
long j2 = (long) min;
this.size -= j2;
j -= j2;
if (segment.pos == segment.limit) {
Segment pop = segment.pop();
this.head = pop;
SegmentPool.recycle(segment);
segment = pop;
}
}
return this;
}
throw new IllegalArgumentException("out == null");
}
public final Buffer readFrom(InputStream inputStream) throws IOException {
readFrom(inputStream, Long.MAX_VALUE, true);
return this;
}
public final Buffer readFrom(InputStream inputStream, long j) throws IOException {
if (j >= 0) {
readFrom(inputStream, j, false);
return this;
}
throw new IllegalArgumentException("byteCount < 0: " + j);
}
private void readFrom(InputStream inputStream, long j, boolean z) throws IOException {
if (inputStream != null) {
while (true) {
if (j > 0 || z) {
Segment writableSegment = writableSegment(1);
int read = inputStream.read(writableSegment.data, writableSegment.limit, (int) Math.min(j, (long) (8192 - writableSegment.limit)));
if (read != -1) {
writableSegment.limit += read;
long j2 = (long) read;
this.size += j2;
j -= j2;
} else if (!z) {
throw new EOFException();
} else {
return;
}
} else {
return;
}
}
} else {
throw new IllegalArgumentException("in == null");
}
}
public final long completeSegmentByteCount() {
long j = this.size;
if (j == 0) {
return 0;
}
Segment segment = this.head.prev;
return (segment.limit >= 8192 || !segment.owner) ? j : j - ((long) (segment.limit - segment.pos));
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public byte readByte() {
if (this.size != 0) {
Segment segment = this.head;
int i = segment.pos;
int i2 = segment.limit;
int i3 = i + 1;
byte b = segment.data[i];
this.size--;
if (i3 == i2) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i3;
}
return b;
}
throw new IllegalStateException("size == 0");
}
public final byte getByte(long j) {
Util.checkOffsetAndCount(this.size, j, 1);
long j2 = this.size;
if (j2 - j > j) {
Segment segment = this.head;
while (true) {
long j3 = (long) (segment.limit - segment.pos);
if (j < j3) {
return segment.data[segment.pos + ((int) j)];
}
j -= j3;
segment = segment.next;
}
} else {
long j4 = j - j2;
Segment segment2 = this.head;
do {
segment2 = segment2.prev;
j4 += (long) (segment2.limit - segment2.pos);
} while (j4 < 0);
return segment2.data[segment2.pos + ((int) j4)];
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public short readShort() {
if (this.size >= 2) {
Segment segment = this.head;
int i = segment.pos;
int i2 = segment.limit;
if (i2 - i < 2) {
return (short) (((readByte() & UByte.MAX_VALUE) << 8) | (readByte() & UByte.MAX_VALUE));
}
byte[] bArr = segment.data;
int i3 = i + 1;
int i4 = i3 + 1;
int i5 = ((bArr[i] & UByte.MAX_VALUE) << 8) | (bArr[i3] & UByte.MAX_VALUE);
this.size -= 2;
if (i4 == i2) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i4;
}
return (short) i5;
}
throw new IllegalStateException("size < 2: " + this.size);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public int readInt() {
if (this.size >= 4) {
Segment segment = this.head;
int i = segment.pos;
int i2 = segment.limit;
if (i2 - i < 4) {
return ((readByte() & UByte.MAX_VALUE) << 24) | ((readByte() & UByte.MAX_VALUE) << 16) | ((readByte() & UByte.MAX_VALUE) << 8) | (readByte() & UByte.MAX_VALUE);
}
byte[] bArr = segment.data;
int i3 = i + 1;
int i4 = i3 + 1;
int i5 = ((bArr[i] & UByte.MAX_VALUE) << 24) | ((bArr[i3] & UByte.MAX_VALUE) << 16);
int i6 = i4 + 1;
int i7 = i5 | ((bArr[i4] & UByte.MAX_VALUE) << 8);
int i8 = i6 + 1;
int i9 = i7 | (bArr[i6] & UByte.MAX_VALUE);
this.size -= 4;
if (i8 == i2) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i8;
}
return i9;
}
throw new IllegalStateException("size < 4: " + this.size);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long readLong() {
if (this.size >= 8) {
Segment segment = this.head;
int i = segment.pos;
int i2 = segment.limit;
if (i2 - i < 8) {
return ((((long) readInt()) & 4294967295L) << 32) | (4294967295L & ((long) readInt()));
}
byte[] bArr = segment.data;
int i3 = i + 1;
int i4 = i3 + 1;
int i5 = i4 + 1;
int i6 = i5 + 1;
int i7 = i6 + 1;
int i8 = i7 + 1;
int i9 = i8 + 1;
int i10 = i9 + 1;
long j = (((long) bArr[i9]) & 255) | ((((long) bArr[i]) & 255) << 56) | ((((long) bArr[i3]) & 255) << 48) | ((((long) bArr[i4]) & 255) << 40) | ((((long) bArr[i5]) & 255) << 32) | ((((long) bArr[i6]) & 255) << 24) | ((((long) bArr[i7]) & 255) << 16) | ((((long) bArr[i8]) & 255) << 8);
this.size -= 8;
if (i10 == i2) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i10;
}
return j;
}
throw new IllegalStateException("size < 8: " + this.size);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public short readShortLe() {
return Util.reverseBytesShort(readShort());
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public int readIntLe() {
return Util.reverseBytesInt(readInt());
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long readLongLe() {
return Util.reverseBytesLong(readLong());
}
/* JADX WARNING: Code restructure failed: missing block: B:37:0x00bf, code lost:
if (r8 == false) goto L_0x00c2;
*/
/* JADX WARNING: Code restructure failed: missing block: B:51:?, code lost:
return -r3;
*/
/* JADX WARNING: Code restructure failed: missing block: B:52:?, code lost:
return r3;
*/
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long readDecimalLong() {
byte b;
long j = 0;
if (this.size != 0) {
long j2 = BufferKt.OVERFLOW_ZONE;
long j3 = -7;
int i = 0;
boolean z = false;
boolean z2 = false;
loop0:
while (true) {
Segment segment = this.head;
byte[] bArr = segment.data;
int i2 = segment.pos;
int i3 = segment.limit;
while (true) {
if (i2 >= i3) {
break;
}
b = bArr[i2];
if (b >= 48 && b <= 57) {
int i4 = 48 - b;
int i5 = (j > j2 ? 1 : (j == j2 ? 0 : -1));
if (i5 < 0 || (i5 == 0 && ((long) i4) < j3)) {
Buffer writeByte = new Buffer().writeDecimalLong(j).writeByte((int) b);
} else {
j = (j * 10) + ((long) i4);
}
} else if (b == 45 && i == 0) {
j3--;
z = true;
} else if (i != 0) {
z2 = true;
} else {
throw new NumberFormatException("Expected leading [0-9] or '-' character but was 0x" + Integer.toHexString(b));
}
i2++;
i++;
j2 = BufferKt.OVERFLOW_ZONE;
}
if (i2 == i3) {
this.head = segment.pop();
SegmentPool.recycle(segment);
} else {
segment.pos = i2;
}
if (z2 || this.head == null) {
this.size -= (long) i;
} else {
j2 = BufferKt.OVERFLOW_ZONE;
}
}
Buffer writeByte2 = new Buffer().writeDecimalLong(j).writeByte((int) b);
if (!z) {
writeByte2.readByte();
}
throw new NumberFormatException("Number too large: " + writeByte2.readUtf8());
}
throw new IllegalStateException("size == 0");
}
/* JADX WARNING: Code restructure failed: missing block: B:30:0x0091, code lost:
if (r8 != r9) goto L_0x009d;
*/
/* JADX WARNING: Code restructure failed: missing block: B:31:0x0093, code lost:
r15.head = r6.pop();
com.mbridge.msdk.thrid.okio.SegmentPool.recycle(r6);
*/
/* JADX WARNING: Code restructure failed: missing block: B:32:0x009d, code lost:
r6.pos = r8;
*/
/* JADX WARNING: Code restructure failed: missing block: B:33:0x009f, code lost:
if (r1 != false) goto L_0x00a5;
*/
/* JADX WARNING: Removed duplicated region for block: B:27:0x0074 */
/* JADX WARNING: Removed duplicated region for block: B:42:0x0076 A[SYNTHETIC] */
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long readHexadecimalUnsignedLong() {
int i;
int i2;
if (this.size != 0) {
int i3 = 0;
long j = 0;
boolean z = false;
do {
Segment segment = this.head;
byte[] bArr = segment.data;
int i4 = segment.pos;
int i5 = segment.limit;
while (true) {
if (i4 >= i5) {
break;
}
byte b = bArr[i4];
if (b < 48 || b > 57) {
if (b >= 97 && b <= 102) {
i2 = b - 97;
} else if (b >= 65 && b <= 70) {
i2 = b - 65;
} else if (i3 == 0) {
z = true;
} else {
throw new NumberFormatException("Expected leading [0-9a-fA-F] character but was 0x" + Integer.toHexString(b));
}
i = i2 + 10;
} else {
i = b - 48;
}
if ((-1152921504606846976L & j) == 0) {
j = (j << 4) | ((long) i);
i4++;
i3++;
} else {
Buffer writeByte = new Buffer().writeHexadecimalUnsignedLong(j).writeByte((int) b);
throw new NumberFormatException("Number too large: " + writeByte.readUtf8());
}
}
if (i3 == 0) {
}
} while (this.head != null);
this.size -= (long) i3;
return j;
}
throw new IllegalStateException("size == 0");
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public ByteString readByteString() {
return new ByteString(readByteArray());
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public ByteString readByteString(long j) throws EOFException {
return new ByteString(readByteArray(j));
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public int select(Options options) {
int selectPrefix = selectPrefix(options, false);
if (selectPrefix == -1) {
return -1;
}
try {
skip((long) options.byteStrings[selectPrefix].size());
return selectPrefix;
} catch (EOFException unused) {
throw new AssertionError();
}
}
/* access modifiers changed from: package-private */
public int selectPrefix(Options options, boolean z) {
int i;
int i2;
int i3;
Segment segment;
int i4;
Segment segment2 = this.head;
int i5 = -2;
if (segment2 != null) {
byte[] bArr = segment2.data;
int i6 = segment2.pos;
int i7 = segment2.limit;
int[] iArr = options.trie;
Segment segment3 = segment2;
int i8 = 0;
int i9 = -1;
loop0:
while (true) {
int i10 = i8 + 1;
int i11 = iArr[i8];
int i12 = i10 + 1;
int i13 = iArr[i10];
if (i13 != -1) {
i9 = i13;
}
if (segment3 == null) {
break;
}
if (i11 < 0) {
int i14 = i12 + (i11 * -1);
while (true) {
int i15 = i6 + 1;
int i16 = i12 + 1;
if ((bArr[i6] & UByte.MAX_VALUE) != iArr[i12]) {
return i9;
}
boolean z2 = i16 == i14;
if (i15 == i7) {
Segment segment4 = segment3.next;
i4 = segment4.pos;
byte[] bArr2 = segment4.data;
i3 = segment4.limit;
if (segment4 != segment2) {
segment = segment4;
bArr = bArr2;
} else if (!z2) {
break loop0;
} else {
bArr = bArr2;
segment = null;
}
} else {
i3 = i7;
i4 = i15;
segment = segment3;
}
if (z2) {
i = iArr[i16];
i2 = i4;
i7 = i3;
segment3 = segment;
break;
}
i6 = i4;
i7 = i3;
i12 = i16;
segment3 = segment;
}
} else {
int i17 = i6 + 1;
int i18 = bArr[i6] & UByte.MAX_VALUE;
int i19 = i12 + i11;
while (i12 != i19) {
if (i18 == iArr[i12]) {
i = iArr[i12 + i11];
if (i17 == i7) {
segment3 = segment3.next;
i2 = segment3.pos;
bArr = segment3.data;
i7 = segment3.limit;
if (segment3 == segment2) {
segment3 = null;
}
} else {
i2 = i17;
}
} else {
i12++;
}
}
return i9;
}
if (i >= 0) {
return i;
}
i8 = -i;
i6 = i2;
i5 = -2;
}
return z ? i5 : i9;
} else if (z) {
return -2;
} else {
return options.indexOf(ByteString.EMPTY);
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public void readFully(Buffer buffer, long j) throws EOFException {
long j2 = this.size;
if (j2 >= j) {
buffer.write(this, j);
} else {
buffer.write(this, j2);
throw new EOFException();
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long readAll(Sink sink) throws IOException {
long j = this.size;
if (j > 0) {
sink.write(this, j);
}
return j;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public String readUtf8() {
try {
return readString(this.size, Util.UTF_8);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public String readUtf8(long j) throws EOFException {
return readString(j, Util.UTF_8);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public String readString(Charset charset) {
try {
return readString(this.size, charset);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public String readString(long j, Charset charset) throws EOFException {
Util.checkOffsetAndCount(this.size, 0, j);
if (charset == null) {
throw new IllegalArgumentException("charset == null");
} else if (j > 2147483647L) {
throw new IllegalArgumentException("byteCount > Integer.MAX_VALUE: " + j);
} else if (j == 0) {
return "";
} else {
Segment segment = this.head;
if (((long) segment.pos) + j > ((long) segment.limit)) {
return new String(readByteArray(j), charset);
}
String str = new String(segment.data, segment.pos, (int) j, charset);
segment.pos = (int) (((long) segment.pos) + j);
this.size -= j;
if (segment.pos == segment.limit) {
this.head = segment.pop();
SegmentPool.recycle(segment);
}
return str;
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public String readUtf8Line() throws EOFException {
long indexOf = indexOf((byte) 10);
if (indexOf != -1) {
return readUtf8Line(indexOf);
}
long j = this.size;
if (j != 0) {
return readUtf8(j);
}
return null;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public String readUtf8LineStrict() throws EOFException {
return readUtf8LineStrict(Long.MAX_VALUE);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public String readUtf8LineStrict(long j) throws EOFException {
if (j >= 0) {
long j2 = Long.MAX_VALUE;
if (j != Long.MAX_VALUE) {
j2 = j + 1;
}
long indexOf = indexOf((byte) 10, 0, j2);
if (indexOf != -1) {
return readUtf8Line(indexOf);
}
if (j2 < size() && getByte(j2 - 1) == 13 && getByte(j2) == 10) {
return readUtf8Line(j2);
}
Buffer buffer = new Buffer();
copyTo(buffer, 0, Math.min(32L, size()));
throw new EOFException("\\n not found: limit=" + Math.min(size(), j) + " content=" + buffer.readByteString().hex() + Typography.ellipsis);
}
throw new IllegalArgumentException("limit < 0: " + j);
}
/* access modifiers changed from: package-private */
public String readUtf8Line(long j) throws EOFException {
if (j > 0) {
long j2 = j - 1;
if (getByte(j2) == 13) {
String readUtf8 = readUtf8(j2);
skip(2);
return readUtf8;
}
}
String readUtf82 = readUtf8(j);
skip(1);
return readUtf82;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public int readUtf8CodePoint() throws EOFException {
int i;
int i2;
int i3;
if (this.size != 0) {
byte b = getByte(0);
if ((b & ByteCompanionObject.MIN_VALUE) == 0) {
i3 = b & ByteCompanionObject.MAX_VALUE;
i2 = 1;
i = 0;
} else if ((b & 224) == 192) {
i3 = b & 31;
i2 = 2;
i = 128;
} else if ((b & 240) == 224) {
i3 = b & cb.m;
i2 = 3;
i = 2048;
} else if ((b & 248) == 240) {
i3 = b & 7;
i2 = 4;
i = 65536;
} else {
skip(1);
return 65533;
}
long j = (long) i2;
if (this.size >= j) {
for (int i4 = 1; i4 < i2; i4++) {
long j2 = (long) i4;
byte b2 = getByte(j2);
if ((b2 & 192) == 128) {
i3 = (i3 << 6) | (b2 & Utf8.REPLACEMENT_BYTE);
} else {
skip(j2);
return 65533;
}
}
skip(j);
if (i3 > 1114111) {
return 65533;
}
if ((i3 < 55296 || i3 > 57343) && i3 >= i) {
return i3;
}
return 65533;
}
throw new EOFException("size < " + i2 + ": " + this.size + " (to read code point prefixed 0x" + Integer.toHexString(b) + ")");
}
throw new EOFException();
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public byte[] readByteArray() {
try {
return readByteArray(this.size);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public byte[] readByteArray(long j) throws EOFException {
Util.checkOffsetAndCount(this.size, 0, j);
if (j <= 2147483647L) {
byte[] bArr = new byte[((int) j)];
readFully(bArr);
return bArr;
}
throw new IllegalArgumentException("byteCount > Integer.MAX_VALUE: " + j);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public int read(byte[] bArr) {
return read(bArr, 0, bArr.length);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public void readFully(byte[] bArr) throws EOFException {
int i = 0;
while (i < bArr.length) {
int read = read(bArr, i, bArr.length - i);
if (read != -1) {
i += read;
} else {
throw new EOFException();
}
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public int read(byte[] bArr, int i, int i2) {
Util.checkOffsetAndCount((long) bArr.length, (long) i, (long) i2);
Segment segment = this.head;
if (segment == null) {
return -1;
}
int min = Math.min(i2, segment.limit - segment.pos);
System.arraycopy(segment.data, segment.pos, bArr, i, min);
segment.pos += min;
this.size -= (long) min;
if (segment.pos == segment.limit) {
this.head = segment.pop();
SegmentPool.recycle(segment);
}
return min;
}
@Override // java.nio.channels.ReadableByteChannel
public int read(ByteBuffer byteBuffer) throws IOException {
Segment segment = this.head;
if (segment == null) {
return -1;
}
int min = Math.min(byteBuffer.remaining(), segment.limit - segment.pos);
byteBuffer.put(segment.data, segment.pos, min);
segment.pos += min;
this.size -= (long) min;
if (segment.pos == segment.limit) {
this.head = segment.pop();
SegmentPool.recycle(segment);
}
return min;
}
public final void clear() {
try {
skip(this.size);
} catch (EOFException e) {
throw new AssertionError(e);
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public void skip(long j) throws EOFException {
while (j > 0) {
Segment segment = this.head;
if (segment != null) {
int min = (int) Math.min(j, (long) (segment.limit - this.head.pos));
long j2 = (long) min;
this.size -= j2;
j -= j2;
this.head.pos += min;
if (this.head.pos == this.head.limit) {
Segment segment2 = this.head;
this.head = segment2.pop();
SegmentPool.recycle(segment2);
}
} else {
throw new EOFException();
}
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer write(ByteString byteString) {
if (byteString != null) {
byteString.write(this);
return this;
}
throw new IllegalArgumentException("byteString == null");
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeUtf8(String str) {
return writeUtf8(str, 0, str.length());
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeUtf8(String str, int i, int i2) {
char c;
if (str == null) {
throw new IllegalArgumentException("string == null");
} else if (i < 0) {
throw new IllegalArgumentException("beginIndex < 0: " + i);
} else if (i2 < i) {
throw new IllegalArgumentException("endIndex < beginIndex: " + i2 + " < " + i);
} else if (i2 <= str.length()) {
while (i < i2) {
char charAt = str.charAt(i);
if (charAt < 128) {
Segment writableSegment = writableSegment(1);
byte[] bArr = writableSegment.data;
int i3 = writableSegment.limit - i;
int min = Math.min(i2, 8192 - i3);
int i4 = i + 1;
bArr[i + i3] = (byte) charAt;
while (i4 < min) {
char charAt2 = str.charAt(i4);
if (charAt2 >= 128) {
break;
}
bArr[i4 + i3] = (byte) charAt2;
i4++;
}
int i5 = (i3 + i4) - writableSegment.limit;
writableSegment.limit += i5;
this.size += (long) i5;
i = i4;
} else {
if (charAt < 2048) {
writeByte((charAt >> 6) | 192);
writeByte((charAt & '?') | 128);
} else if (charAt < 55296 || charAt > 57343) {
writeByte((charAt >> '\f') | 224);
writeByte(((charAt >> 6) & 63) | 128);
writeByte((charAt & '?') | 128);
} else {
int i6 = i + 1;
if (i6 < i2) {
c = str.charAt(i6);
} else {
c = 0;
}
if (charAt > 56319 || c < 56320 || c > 57343) {
writeByte(63);
i = i6;
} else {
int i7 = (((charAt & 10239) << 10) | (9215 & c)) + 65536;
writeByte((i7 >> 18) | 240);
writeByte(((i7 >> 12) & 63) | 128);
writeByte(((i7 >> 6) & 63) | 128);
writeByte((i7 & 63) | 128);
i += 2;
}
}
i++;
}
}
return this;
} else {
throw new IllegalArgumentException("endIndex > string.length: " + i2 + " > " + str.length());
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeUtf8CodePoint(int i) {
if (i < 128) {
writeByte(i);
} else if (i < 2048) {
writeByte((i >> 6) | 192);
writeByte((i & 63) | 128);
} else if (i < 65536) {
if (i < 55296 || i > 57343) {
writeByte((i >> 12) | 224);
writeByte(((i >> 6) & 63) | 128);
writeByte((i & 63) | 128);
} else {
writeByte(63);
}
} else if (i <= 1114111) {
writeByte((i >> 18) | 240);
writeByte(((i >> 12) & 63) | 128);
writeByte(((i >> 6) & 63) | 128);
writeByte((i & 63) | 128);
} else {
throw new IllegalArgumentException("Unexpected code point: " + Integer.toHexString(i));
}
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeString(String str, Charset charset) {
return writeString(str, 0, str.length(), charset);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeString(String str, int i, int i2, Charset charset) {
if (str == null) {
throw new IllegalArgumentException("string == null");
} else if (i < 0) {
throw new IllegalAccessError("beginIndex < 0: " + i);
} else if (i2 < i) {
throw new IllegalArgumentException("endIndex < beginIndex: " + i2 + " < " + i);
} else if (i2 > str.length()) {
throw new IllegalArgumentException("endIndex > string.length: " + i2 + " > " + str.length());
} else if (charset == null) {
throw new IllegalArgumentException("charset == null");
} else if (charset.equals(Util.UTF_8)) {
return writeUtf8(str, i, i2);
} else {
byte[] bytes = str.substring(i, i2).getBytes(charset);
return write(bytes, 0, bytes.length);
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer write(byte[] bArr) {
if (bArr != null) {
return write(bArr, 0, bArr.length);
}
throw new IllegalArgumentException("source == null");
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer write(byte[] bArr, int i, int i2) {
if (bArr != null) {
long j = (long) i2;
Util.checkOffsetAndCount((long) bArr.length, (long) i, j);
int i3 = i2 + i;
while (i < i3) {
Segment writableSegment = writableSegment(1);
int min = Math.min(i3 - i, 8192 - writableSegment.limit);
System.arraycopy(bArr, i, writableSegment.data, writableSegment.limit, min);
i += min;
writableSegment.limit += min;
}
this.size += j;
return this;
}
throw new IllegalArgumentException("source == null");
}
@Override // java.nio.channels.WritableByteChannel
public int write(ByteBuffer byteBuffer) throws IOException {
if (byteBuffer != null) {
int remaining = byteBuffer.remaining();
int i = remaining;
while (i > 0) {
Segment writableSegment = writableSegment(1);
int min = Math.min(i, 8192 - writableSegment.limit);
byteBuffer.get(writableSegment.data, writableSegment.limit, min);
i -= min;
writableSegment.limit += min;
}
this.size += (long) remaining;
return remaining;
}
throw new IllegalArgumentException("source == null");
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public long writeAll(Source source) throws IOException {
if (source != null) {
long j = 0;
while (true) {
long read = source.read(this, KsMediaMeta.AV_CH_TOP_FRONT_CENTER);
if (read == -1) {
return j;
}
j += read;
}
} else {
throw new IllegalArgumentException("source == null");
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public BufferedSink write(Source source, long j) throws IOException {
while (j > 0) {
long read = source.read(this, j);
if (read != -1) {
j -= read;
} else {
throw new EOFException();
}
}
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeByte(int i) {
Segment writableSegment = writableSegment(1);
byte[] bArr = writableSegment.data;
int i2 = writableSegment.limit;
writableSegment.limit = i2 + 1;
bArr[i2] = (byte) i;
this.size++;
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeShort(int i) {
Segment writableSegment = writableSegment(2);
byte[] bArr = writableSegment.data;
int i2 = writableSegment.limit;
int i3 = i2 + 1;
bArr[i2] = (byte) ((i >>> 8) & 255);
bArr[i3] = (byte) (i & 255);
writableSegment.limit = i3 + 1;
this.size += 2;
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeShortLe(int i) {
return writeShort((int) Util.reverseBytesShort((short) i));
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeInt(int i) {
Segment writableSegment = writableSegment(4);
byte[] bArr = writableSegment.data;
int i2 = writableSegment.limit;
int i3 = i2 + 1;
bArr[i2] = (byte) ((i >>> 24) & 255);
int i4 = i3 + 1;
bArr[i3] = (byte) ((i >>> 16) & 255);
int i5 = i4 + 1;
bArr[i4] = (byte) ((i >>> 8) & 255);
bArr[i5] = (byte) (i & 255);
writableSegment.limit = i5 + 1;
this.size += 4;
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeIntLe(int i) {
return writeInt(Util.reverseBytesInt(i));
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeLong(long j) {
Segment writableSegment = writableSegment(8);
byte[] bArr = writableSegment.data;
int i = writableSegment.limit;
int i2 = i + 1;
bArr[i] = (byte) ((int) ((j >>> 56) & 255));
int i3 = i2 + 1;
bArr[i2] = (byte) ((int) ((j >>> 48) & 255));
int i4 = i3 + 1;
bArr[i3] = (byte) ((int) ((j >>> 40) & 255));
int i5 = i4 + 1;
bArr[i4] = (byte) ((int) ((j >>> 32) & 255));
int i6 = i5 + 1;
bArr[i5] = (byte) ((int) ((j >>> 24) & 255));
int i7 = i6 + 1;
bArr[i6] = (byte) ((int) ((j >>> 16) & 255));
int i8 = i7 + 1;
bArr[i7] = (byte) ((int) ((j >>> 8) & 255));
bArr[i8] = (byte) ((int) (j & 255));
writableSegment.limit = i8 + 1;
this.size += 8;
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeLongLe(long j) {
return writeLong(Util.reverseBytesLong(j));
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeDecimalLong(long j) {
int i = (j > 0 ? 1 : (j == 0 ? 0 : -1));
if (i == 0) {
return writeByte(48);
}
boolean z = false;
int i2 = 1;
if (i < 0) {
j = -j;
if (j < 0) {
return writeUtf8("-9223372036854775808");
}
z = true;
}
if (j >= 100000000) {
i2 = j < 1000000000000L ? j < RealConnection.IDLE_CONNECTION_HEALTHY_NS ? j < C.NANOS_PER_SECOND ? 9 : 10 : j < 100000000000L ? 11 : 12 : j < 1000000000000000L ? j < 10000000000000L ? 13 : j < 100000000000000L ? 14 : 15 : j < 100000000000000000L ? j < 10000000000000000L ? 16 : 17 : j < 1000000000000000000L ? 18 : 19;
} else if (j >= 10000) {
i2 = j < 1000000 ? j < 100000 ? 5 : 6 : j < 10000000 ? 7 : 8;
} else if (j >= 100) {
i2 = j < 1000 ? 3 : 4;
} else if (j >= 10) {
i2 = 2;
}
if (z) {
i2++;
}
Segment writableSegment = writableSegment(i2);
byte[] bArr = writableSegment.data;
int i3 = writableSegment.limit + i2;
while (j != 0) {
i3--;
bArr[i3] = DIGITS[(int) (j % 10)];
j /= 10;
}
if (z) {
bArr[i3 - 1] = 45;
}
writableSegment.limit += i2;
this.size += (long) i2;
return this;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSink
public Buffer writeHexadecimalUnsignedLong(long j) {
if (j == 0) {
return writeByte(48);
}
int numberOfTrailingZeros = (Long.numberOfTrailingZeros(Long.highestOneBit(j)) / 4) + 1;
Segment writableSegment = writableSegment(numberOfTrailingZeros);
byte[] bArr = writableSegment.data;
int i = writableSegment.limit;
for (int i2 = (writableSegment.limit + numberOfTrailingZeros) - 1; i2 >= i; i2--) {
bArr[i2] = DIGITS[(int) (15 & j)];
j >>>= 4;
}
writableSegment.limit += numberOfTrailingZeros;
this.size += (long) numberOfTrailingZeros;
return this;
}
/* access modifiers changed from: package-private */
public Segment writableSegment(int i) {
if (i < 1 || i > 8192) {
throw new IllegalArgumentException();
}
Segment segment = this.head;
if (segment == null) {
Segment take = SegmentPool.take();
this.head = take;
take.prev = take;
take.next = take;
return take;
}
Segment segment2 = segment.prev;
return (segment2.limit + i > 8192 || !segment2.owner) ? segment2.push(SegmentPool.take()) : segment2;
}
@Override // com.mbridge.msdk.thrid.okio.Sink
public void write(Buffer buffer, long j) {
if (buffer == null) {
throw new IllegalArgumentException("source == null");
} else if (buffer != this) {
Util.checkOffsetAndCount(buffer.size, 0, j);
while (j > 0) {
if (j < ((long) (buffer.head.limit - buffer.head.pos))) {
Segment segment = this.head;
Segment segment2 = segment != null ? segment.prev : null;
if (segment2 != null && segment2.owner) {
if ((((long) segment2.limit) + j) - ((long) (segment2.shared ? 0 : segment2.pos)) <= KsMediaMeta.AV_CH_TOP_FRONT_CENTER) {
buffer.head.writeTo(segment2, (int) j);
buffer.size -= j;
this.size += j;
return;
}
}
buffer.head = buffer.head.split((int) j);
}
Segment segment3 = buffer.head;
long j2 = (long) (segment3.limit - segment3.pos);
buffer.head = segment3.pop();
Segment segment4 = this.head;
if (segment4 == null) {
this.head = segment3;
segment3.prev = segment3;
segment3.next = segment3;
} else {
segment4.prev.push(segment3).compact();
}
buffer.size -= j2;
this.size += j2;
j -= j2;
}
} else {
throw new IllegalArgumentException("source == this");
}
}
@Override // com.mbridge.msdk.thrid.okio.Source
public long read(Buffer buffer, long j) {
if (buffer == null) {
throw new IllegalArgumentException("sink == null");
} else if (j >= 0) {
long j2 = this.size;
if (j2 == 0) {
return -1;
}
if (j > j2) {
j = j2;
}
buffer.write(this, j);
return j;
} else {
throw new IllegalArgumentException("byteCount < 0: " + j);
}
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long indexOf(byte b) {
return indexOf(b, 0, Long.MAX_VALUE);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long indexOf(byte b, long j) {
return indexOf(b, j, Long.MAX_VALUE);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long indexOf(byte b, long j, long j2) {
Segment segment;
long j3 = 0;
if (j < 0 || j2 < j) {
throw new IllegalArgumentException(String.format("size=%s fromIndex=%s toIndex=%s", Long.valueOf(this.size), Long.valueOf(j), Long.valueOf(j2)));
}
long j4 = this.size;
long j5 = j2 > j4 ? j4 : j2;
if (j == j5 || (segment = this.head) == null) {
return -1;
}
if (j4 - j < j) {
while (j4 > j) {
segment = segment.prev;
j4 -= (long) (segment.limit - segment.pos);
}
} else {
while (true) {
long j6 = ((long) (segment.limit - segment.pos)) + j3;
if (j6 >= j) {
break;
}
segment = segment.next;
j3 = j6;
}
j4 = j3;
}
long j7 = j;
while (j4 < j5) {
byte[] bArr = segment.data;
int min = (int) Math.min((long) segment.limit, (((long) segment.pos) + j5) - j4);
for (int i = (int) ((((long) segment.pos) + j7) - j4); i < min; i++) {
if (bArr[i] == b) {
return ((long) (i - segment.pos)) + j4;
}
}
j4 += (long) (segment.limit - segment.pos);
segment = segment.next;
j7 = j4;
}
return -1;
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long indexOf(ByteString byteString) throws IOException {
return indexOf(byteString, 0);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long indexOf(ByteString byteString, long j) throws IOException {
byte[] bArr;
if (byteString.size() != 0) {
long j2 = 0;
if (j >= 0) {
Segment segment = this.head;
long j3 = -1;
if (segment == null) {
return -1;
}
long j4 = this.size;
if (j4 - j < j) {
while (j4 > j) {
segment = segment.prev;
j4 -= (long) (segment.limit - segment.pos);
}
} else {
while (true) {
long j5 = ((long) (segment.limit - segment.pos)) + j2;
if (j5 >= j) {
break;
}
segment = segment.next;
j2 = j5;
}
j4 = j2;
}
byte b = byteString.getByte(0);
int size2 = byteString.size();
long j6 = 1 + (this.size - ((long) size2));
long j7 = j;
Segment segment2 = segment;
long j8 = j4;
while (j8 < j6) {
byte[] bArr2 = segment2.data;
int min = (int) Math.min((long) segment2.limit, (((long) segment2.pos) + j6) - j8);
int i = (int) ((((long) segment2.pos) + j7) - j8);
while (i < min) {
if (bArr2[i] == b) {
bArr = bArr2;
if (rangeEquals(segment2, i + 1, byteString, 1, size2)) {
return ((long) (i - segment2.pos)) + j8;
}
} else {
bArr = bArr2;
}
i++;
bArr2 = bArr;
}
j8 += (long) (segment2.limit - segment2.pos);
segment2 = segment2.next;
j7 = j8;
j3 = -1;
}
return j3;
}
throw new IllegalArgumentException("fromIndex < 0");
}
throw new IllegalArgumentException("bytes is empty");
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long indexOfElement(ByteString byteString) {
return indexOfElement(byteString, 0);
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public long indexOfElement(ByteString byteString, long j) {
int i;
int i2;
long j2 = 0;
if (j >= 0) {
Segment segment = this.head;
if (segment == null) {
return -1;
}
long j3 = this.size;
if (j3 - j < j) {
while (j3 > j) {
segment = segment.prev;
j3 -= (long) (segment.limit - segment.pos);
}
} else {
while (true) {
long j4 = ((long) (segment.limit - segment.pos)) + j2;
if (j4 >= j) {
break;
}
segment = segment.next;
j2 = j4;
}
j3 = j2;
}
if (byteString.size() == 2) {
byte b = byteString.getByte(0);
byte b2 = byteString.getByte(1);
while (j3 < this.size) {
byte[] bArr = segment.data;
i = (int) ((((long) segment.pos) + j) - j3);
int i3 = segment.limit;
while (i < i3) {
byte b3 = bArr[i];
if (b3 == b || b3 == b2) {
i2 = segment.pos;
} else {
i++;
}
}
j3 += (long) (segment.limit - segment.pos);
segment = segment.next;
j = j3;
}
return -1;
}
byte[] internalArray = byteString.internalArray();
while (j3 < this.size) {
byte[] bArr2 = segment.data;
i = (int) ((((long) segment.pos) + j) - j3);
int i4 = segment.limit;
while (i < i4) {
byte b4 = bArr2[i];
for (byte b5 : internalArray) {
if (b4 == b5) {
i2 = segment.pos;
}
}
i++;
}
j3 += (long) (segment.limit - segment.pos);
segment = segment.next;
j = j3;
}
return -1;
return ((long) (i - i2)) + j3;
}
throw new IllegalArgumentException("fromIndex < 0");
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public boolean rangeEquals(long j, ByteString byteString) {
return rangeEquals(j, byteString, 0, byteString.size());
}
@Override // com.mbridge.msdk.thrid.okio.BufferedSource
public boolean rangeEquals(long j, ByteString byteString, int i, int i2) {
if (j < 0 || i < 0 || i2 < 0 || this.size - j < ((long) i2) || byteString.size() - i < i2) {
return false;
}
for (int i3 = 0; i3 < i2; i3++) {
if (getByte(((long) i3) + j) != byteString.getByte(i + i3)) {
return false;
}
}
return true;
}
private boolean rangeEquals(Segment segment, int i, ByteString byteString, int i2, int i3) {
int i4 = segment.limit;
byte[] bArr = segment.data;
while (i2 < i3) {
if (i == i4) {
segment = segment.next;
byte[] bArr2 = segment.data;
bArr = bArr2;
i = segment.pos;
i4 = segment.limit;
}
if (bArr[i] != byteString.getByte(i2)) {
return false;
}
i++;
i2++;
}
return true;
}
@Override // com.mbridge.msdk.thrid.okio.Sink, com.mbridge.msdk.thrid.okio.Source
public Timeout timeout() {
return Timeout.NONE;
}
/* access modifiers changed from: package-private */
public List<Integer> segmentSizes() {
if (this.head == null) {
return Collections.emptyList();
}
ArrayList arrayList = new ArrayList();
arrayList.add(Integer.valueOf(this.head.limit - this.head.pos));
Segment segment = this.head;
while (true) {
segment = segment.next;
if (segment == this.head) {
return arrayList;
}
arrayList.add(Integer.valueOf(segment.limit - segment.pos));
}
}
public final ByteString md5() {
return digest("MD5");
}
public final ByteString sha1() {
return digest("SHA-1");
}
public final ByteString sha256() {
return digest("SHA-256");
}
public final ByteString sha512() {
return digest("SHA-512");
}
private ByteString digest(String str) {
try {
MessageDigest instance = MessageDigest.getInstance(str);
Segment segment = this.head;
if (segment != null) {
instance.update(segment.data, this.head.pos, this.head.limit - this.head.pos);
Segment segment2 = this.head;
while (true) {
segment2 = segment2.next;
if (segment2 == this.head) {
break;
}
instance.update(segment2.data, segment2.pos, segment2.limit - segment2.pos);
}
}
return ByteString.of(instance.digest());
} catch (NoSuchAlgorithmException unused) {
throw new AssertionError();
}
}
public final ByteString hmacSha1(ByteString byteString) {
return hmac("HmacSHA1", byteString);
}
public final ByteString hmacSha256(ByteString byteString) {
return hmac("HmacSHA256", byteString);
}
public final ByteString hmacSha512(ByteString byteString) {
return hmac("HmacSHA512", byteString);
}
private ByteString hmac(String str, ByteString byteString) {
try {
Mac instance = Mac.getInstance(str);
instance.init(new SecretKeySpec(byteString.toByteArray(), str));
Segment segment = this.head;
if (segment != null) {
instance.update(segment.data, this.head.pos, this.head.limit - this.head.pos);
Segment segment2 = this.head;
while (true) {
segment2 = segment2.next;
if (segment2 == this.head) {
break;
}
instance.update(segment2.data, segment2.pos, segment2.limit - segment2.pos);
}
}
return ByteString.of(instance.doFinal());
} catch (NoSuchAlgorithmException unused) {
throw new AssertionError();
} catch (InvalidKeyException e) {
throw new IllegalArgumentException(e);
}
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Buffer)) {
return false;
}
Buffer buffer = (Buffer) obj;
long j = this.size;
if (j != buffer.size) {
return false;
}
long j2 = 0;
if (j == 0) {
return true;
}
Segment segment = this.head;
Segment segment2 = buffer.head;
int i = segment.pos;
int i2 = segment2.pos;
while (j2 < this.size) {
long min = (long) Math.min(segment.limit - i, segment2.limit - i2);
int i3 = 0;
while (((long) i3) < min) {
int i4 = i + 1;
int i5 = i2 + 1;
if (segment.data[i] != segment2.data[i2]) {
return false;
}
i3++;
i = i4;
i2 = i5;
}
if (i == segment.limit) {
segment = segment.next;
i = segment.pos;
}
if (i2 == segment2.limit) {
segment2 = segment2.next;
i2 = segment2.pos;
}
j2 += min;
}
return true;
}
public int hashCode() {
Segment segment = this.head;
if (segment == null) {
return 0;
}
int i = 1;
do {
int i2 = segment.limit;
for (int i3 = segment.pos; i3 < i2; i3++) {
i = (i * 31) + segment.data[i3];
}
segment = segment.next;
} while (segment != this.head);
return i;
}
public String toString() {
return snapshot().toString();
}
@Override // java.lang.Object
public Buffer clone() {
Buffer buffer = new Buffer();
if (this.size == 0) {
return buffer;
}
Segment sharedCopy = this.head.sharedCopy();
buffer.head = sharedCopy;
sharedCopy.prev = sharedCopy;
sharedCopy.next = sharedCopy;
Segment segment = this.head;
while (true) {
segment = segment.next;
if (segment != this.head) {
buffer.head.prev.push(segment.sharedCopy());
} else {
buffer.size = this.size;
return buffer;
}
}
}
public final ByteString snapshot() {
long j = this.size;
if (j <= 2147483647L) {
return snapshot((int) j);
}
throw new IllegalArgumentException("size > Integer.MAX_VALUE: " + this.size);
}
public final ByteString snapshot(int i) {
if (i == 0) {
return ByteString.EMPTY;
}
return new SegmentedByteString(this, i);
}
public final UnsafeCursor readUnsafe() {
return readUnsafe(new UnsafeCursor());
}
public final UnsafeCursor readUnsafe(UnsafeCursor unsafeCursor) {
if (unsafeCursor.buffer == null) {
unsafeCursor.buffer = this;
unsafeCursor.readWrite = false;
return unsafeCursor;
}
throw new IllegalStateException("already attached to a buffer");
}
public final UnsafeCursor readAndWriteUnsafe() {
return readAndWriteUnsafe(new UnsafeCursor());
}
public final UnsafeCursor readAndWriteUnsafe(UnsafeCursor unsafeCursor) {
if (unsafeCursor.buffer == null) {
unsafeCursor.buffer = this;
unsafeCursor.readWrite = true;
return unsafeCursor;
}
throw new IllegalStateException("already attached to a buffer");
}
public static final class UnsafeCursor implements Closeable {
public Buffer buffer;
public byte[] data;
public int end = -1;
public long offset = -1;
public boolean readWrite;
private Segment segment;
public int start = -1;
public final int next() {
if (this.offset != this.buffer.size) {
long j = this.offset;
if (j == -1) {
return seek(0);
}
return seek(j + ((long) (this.end - this.start)));
}
throw new IllegalStateException();
}
public final int seek(long j) {
int i = (j > -1 ? 1 : (j == -1 ? 0 : -1));
if (i < 0 || j > this.buffer.size) {
throw new ArrayIndexOutOfBoundsException(String.format("offset=%s > size=%s", Long.valueOf(j), Long.valueOf(this.buffer.size)));
} else if (i == 0 || j == this.buffer.size) {
this.segment = null;
this.offset = j;
this.data = null;
this.start = -1;
this.end = -1;
return -1;
} else {
long j2 = 0;
long j3 = this.buffer.size;
Segment segment2 = this.buffer.head;
Segment segment3 = this.buffer.head;
Segment segment4 = this.segment;
if (segment4 != null) {
long j4 = this.offset - ((long) (this.start - segment4.pos));
if (j4 > j) {
segment3 = this.segment;
j3 = j4;
} else {
segment2 = this.segment;
j2 = j4;
}
}
if (j3 - j > j - j2) {
while (j >= ((long) (segment2.limit - segment2.pos)) + j2) {
j2 += (long) (segment2.limit - segment2.pos);
segment2 = segment2.next;
}
} else {
while (j3 > j) {
segment3 = segment3.prev;
j3 -= (long) (segment3.limit - segment3.pos);
}
j2 = j3;
segment2 = segment3;
}
if (this.readWrite && segment2.shared) {
Segment unsharedCopy = segment2.unsharedCopy();
if (this.buffer.head == segment2) {
this.buffer.head = unsharedCopy;
}
segment2 = segment2.push(unsharedCopy);
segment2.prev.pop();
}
this.segment = segment2;
this.offset = j;
this.data = segment2.data;
this.start = segment2.pos + ((int) (j - j2));
int i2 = segment2.limit;
this.end = i2;
return i2 - this.start;
}
}
public final long resizeBuffer(long j) {
Buffer buffer2 = this.buffer;
if (buffer2 == null) {
throw new IllegalStateException("not attached to a buffer");
} else if (this.readWrite) {
long j2 = buffer2.size;
int i = (j > j2 ? 1 : (j == j2 ? 0 : -1));
if (i <= 0) {
if (j >= 0) {
long j3 = j2 - j;
while (true) {
if (j3 <= 0) {
break;
}
Segment segment2 = this.buffer.head.prev;
long j4 = (long) (segment2.limit - segment2.pos);
if (j4 > j3) {
segment2.limit = (int) (((long) segment2.limit) - j3);
break;
}
this.buffer.head = segment2.pop();
SegmentPool.recycle(segment2);
j3 -= j4;
}
this.segment = null;
this.offset = j;
this.data = null;
this.start = -1;
this.end = -1;
} else {
throw new IllegalArgumentException("newSize < 0: " + j);
}
} else if (i > 0) {
long j5 = j - j2;
boolean z = true;
while (j5 > 0) {
Segment writableSegment = this.buffer.writableSegment(1);
int min = (int) Math.min(j5, (long) (8192 - writableSegment.limit));
writableSegment.limit += min;
j5 -= (long) min;
if (z) {
this.segment = writableSegment;
this.offset = j2;
this.data = writableSegment.data;
this.start = writableSegment.limit - min;
this.end = writableSegment.limit;
z = false;
}
}
}
this.buffer.size = j;
return j2;
} else {
throw new IllegalStateException("resizeBuffer() only permitted for read/write buffers");
}
}
public final long expandBuffer(int i) {
if (i <= 0) {
throw new IllegalArgumentException("minByteCount <= 0: " + i);
} else if (i <= 8192) {
Buffer buffer2 = this.buffer;
if (buffer2 == null) {
throw new IllegalStateException("not attached to a buffer");
} else if (this.readWrite) {
long j = buffer2.size;
Segment writableSegment = this.buffer.writableSegment(i);
int i2 = 8192 - writableSegment.limit;
writableSegment.limit = 8192;
long j2 = (long) i2;
this.buffer.size = j + j2;
this.segment = writableSegment;
this.offset = j;
this.data = writableSegment.data;
this.start = 8192 - i2;
this.end = 8192;
return j2;
} else {
throw new IllegalStateException("expandBuffer() only permitted for read/write buffers");
}
} else {
throw new IllegalArgumentException("minByteCount > Segment.SIZE: " + i);
}
}
@Override // java.io.Closeable, java.lang.AutoCloseable
public void close() {
if (this.buffer != null) {
this.buffer = null;
this.segment = null;
this.offset = -1;
this.data = null;
this.start = -1;
this.end = -1;
return;
}
throw new IllegalStateException("not attached to a buffer");
}
}
}