Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/k3/a.java

@@ -0,0 +1,61 @@
+package k3;
+
+import i3.l;
+import i3.o;
+import java.io.IOException;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C;
+import r3.C0576h;
+import r3.I;
+import r3.K;
+import r3.q;
+
+/* loaded from: classes3.dex */
+public abstract class a implements I {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final q f7097a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f7098b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ o f7099c;
+
+    public a(o oVar) {
+        this.f7099c = oVar;
+        this.f7097a = new q(((C) oVar.f6895d).f8245a.timeout());
+    }
+
+    public final void d() {
+        o oVar = this.f7099c;
+        int i = oVar.f6892a;
+        if (i == 6) {
+            return;
+        }
+        if (i == 5) {
+            o.i(oVar, this.f7097a);
+            oVar.f6892a = 6;
+        } else {
+            throw new IllegalStateException("state: " + oVar.f6892a);
+        }
+    }
+
+    @Override // r3.I
+    public long read(C0576h sink, long j4) {
+        o oVar = this.f7099c;
+        Intrinsics.checkNotNullParameter(sink, "sink");
+        try {
+            return ((C) oVar.f6895d).read(sink, j4);
+        } catch (IOException e4) {
+            ((l) oVar.f6894c).k();
+            this.d();
+            throw e4;
+        }
+    }
+
+    @Override // r3.I
+    public final K timeout() {
+        return this.f7097a;
+    }
+}

apk_decompiled/sources/k3/b.java

@@ -0,0 +1,73 @@
+package k3;
+
+import i3.o;
+import kotlin.jvm.internal.Intrinsics;
+import r3.B;
+import r3.C0576h;
+import r3.G;
+import r3.K;
+import r3.q;
+
+/* loaded from: classes3.dex */
+public final class b implements G {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final q f7100a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f7101b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ o f7102c;
+
+    public b(o oVar) {
+        this.f7102c = oVar;
+        this.f7100a = new q(((B) oVar.f6896e).f8242a.timeout());
+    }
+
+    @Override // r3.G, java.io.Closeable, java.lang.AutoCloseable
+    public final synchronized void close() {
+        if (this.f7101b) {
+            return;
+        }
+        this.f7101b = true;
+        ((B) this.f7102c.f6896e).Q("0\r\n\r\n");
+        o.i(this.f7102c, this.f7100a);
+        this.f7102c.f6892a = 3;
+    }
+
+    @Override // r3.G, java.io.Flushable
+    public final synchronized void flush() {
+        if (this.f7101b) {
+            return;
+        }
+        ((B) this.f7102c.f6896e).flush();
+    }
+
+    @Override // r3.G
+    public final K timeout() {
+        return this.f7100a;
+    }
+
+    @Override // r3.G
+    public final void z(C0576h source, long j4) {
+        Intrinsics.checkNotNullParameter(source, "source");
+        if (this.f7101b) {
+            throw new IllegalStateException("closed");
+        }
+        if (j4 == 0) {
+            return;
+        }
+        o oVar = this.f7102c;
+        B b4 = (B) oVar.f6896e;
+        if (b4.f8244c) {
+            throw new IllegalStateException("closed");
+        }
+        b4.f8243b.l0(j4);
+        b4.d();
+        B b5 = (B) oVar.f6896e;
+        b5.Q("\r\n");
+        b5.z(source, j4);
+        b5.Q("\r\n");
+    }
+}

apk_decompiled/sources/k3/c.java

@@ -0,0 +1,69 @@
+package k3;
+
+import e3.w;
+import i3.l;
+import i3.o;
+import java.util.concurrent.TimeUnit;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class c extends a {
+
+    /* renamed from: d, reason: collision with root package name */
+    public final w f7103d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public long f7104e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public boolean f7105f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ o f7106g;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public c(o oVar, w url) {
+        super(oVar);
+        Intrinsics.checkNotNullParameter(url, "url");
+        this.f7106g = oVar;
+        this.f7103d = url;
+        this.f7104e = -1L;
+        this.f7105f = true;
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        if (this.f7098b) {
+            return;
+        }
+        if (this.f7105f) {
+            TimeUnit timeUnit = TimeUnit.MILLISECONDS;
+            if (!f3.c.g(this)) {
+                ((l) this.f7106g.f6894c).k();
+                d();
+            }
+        }
+        this.f7098b = true;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:27:0x0066, code lost:
+    
+        if (r6 != false) goto L22;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:32:0x0095, code lost:
+    
+        if (r10.f7105f == false) goto L27;
+     */
+    @Override // k3.a, r3.I
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final long read(r3.C0576h r11, long r12) {
+        /*
+            Method dump skipped, instructions count: 253
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: k3.c.read(r3.h, long):long");
+    }
+}

apk_decompiled/sources/k3/d.java

@@ -0,0 +1,72 @@
+package k3;
+
+import C.w;
+import i3.l;
+import i3.o;
+import java.net.ProtocolException;
+import java.util.concurrent.TimeUnit;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C0576h;
+
+/* loaded from: classes3.dex */
+public final class d extends a {
+
+    /* renamed from: d, reason: collision with root package name */
+    public long f7107d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ o f7108e;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public d(o oVar, long j4) {
+        super(oVar);
+        this.f7108e = oVar;
+        this.f7107d = j4;
+        if (j4 == 0) {
+            d();
+        }
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        if (this.f7098b) {
+            return;
+        }
+        if (this.f7107d != 0) {
+            TimeUnit timeUnit = TimeUnit.MILLISECONDS;
+            if (!f3.c.g(this)) {
+                ((l) this.f7108e.f6894c).k();
+                d();
+            }
+        }
+        this.f7098b = true;
+    }
+
+    @Override // k3.a, r3.I
+    public final long read(C0576h sink, long j4) {
+        Intrinsics.checkNotNullParameter(sink, "sink");
+        if (j4 < 0) {
+            throw new IllegalArgumentException(w.l("byteCount < 0: ", j4).toString());
+        }
+        if (this.f7098b) {
+            throw new IllegalStateException("closed");
+        }
+        long j5 = this.f7107d;
+        if (j5 == 0) {
+            return -1L;
+        }
+        long read = super.read(sink, Math.min(j5, j4));
+        if (read == -1) {
+            ((l) this.f7108e.f6894c).k();
+            ProtocolException protocolException = new ProtocolException("unexpected end of stream");
+            d();
+            throw protocolException;
+        }
+        long j6 = this.f7107d - read;
+        this.f7107d = j6;
+        if (j6 == 0) {
+            d();
+        }
+        return read;
+    }
+}

apk_decompiled/sources/k3/e.java

@@ -0,0 +1,65 @@
+package k3;
+
+import i3.o;
+import kotlin.jvm.internal.Intrinsics;
+import r3.B;
+import r3.C0576h;
+import r3.G;
+import r3.K;
+import r3.q;
+
+/* loaded from: classes3.dex */
+public final class e implements G {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final q f7109a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public boolean f7110b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ o f7111c;
+
+    public e(o oVar) {
+        this.f7111c = oVar;
+        this.f7109a = new q(((B) oVar.f6896e).f8242a.timeout());
+    }
+
+    @Override // r3.G, java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        if (this.f7110b) {
+            return;
+        }
+        this.f7110b = true;
+        o oVar = this.f7111c;
+        o.i(oVar, this.f7109a);
+        oVar.f6892a = 3;
+    }
+
+    @Override // r3.G, java.io.Flushable
+    public final void flush() {
+        if (this.f7110b) {
+            return;
+        }
+        ((B) this.f7111c.f6896e).flush();
+    }
+
+    @Override // r3.G
+    public final K timeout() {
+        return this.f7109a;
+    }
+
+    @Override // r3.G
+    public final void z(C0576h source, long j4) {
+        Intrinsics.checkNotNullParameter(source, "source");
+        if (this.f7110b) {
+            throw new IllegalStateException("closed");
+        }
+        long j5 = source.f8284b;
+        byte[] bArr = f3.c.f6469a;
+        if (j4 < 0 || 0 > j5 || j5 < j4) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        ((B) this.f7111c.f6896e).z(source, j4);
+    }
+}

apk_decompiled/sources/k3/f.java

@@ -0,0 +1,44 @@
+package k3;
+
+import C.w;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C0576h;
+
+/* loaded from: classes3.dex */
+public final class f extends a {
+
+    /* renamed from: d, reason: collision with root package name */
+    public boolean f7112d;
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        if (this.f7098b) {
+            return;
+        }
+        if (!this.f7112d) {
+            d();
+        }
+        this.f7098b = true;
+    }
+
+    @Override // k3.a, r3.I
+    public final long read(C0576h sink, long j4) {
+        Intrinsics.checkNotNullParameter(sink, "sink");
+        if (j4 < 0) {
+            throw new IllegalArgumentException(w.l("byteCount < 0: ", j4).toString());
+        }
+        if (this.f7098b) {
+            throw new IllegalStateException("closed");
+        }
+        if (this.f7112d) {
+            return -1L;
+        }
+        long read = super.read(sink, j4);
+        if (read != -1) {
+            return read;
+        }
+        this.f7112d = true;
+        d();
+        return -1L;
+    }
+}