/*
 * Decompiled with CFR 0.152.
 */
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Vector;

public final class lk {
    public static final Boolean a = new Boolean(false);
    public static final Boolean b = new Boolean(true);
    private final Vector e = new Vector();
    private final StringBuffer f = new StringBuffer();
    private static Long[] c = new Long[]{new Long(0L), new Long(1L), new Long(2), new Long(3), new Long(4), new Long(5), new Long(6), new Long(7), new Long(8), new Long(9), new Long(10), new Long(11), new Long(12), new Long(13), new Long(14), new Long(15)};
    private cp d;

    public final lk a(int n) {
        return new lk((cp)this.d.b(n));
    }

    private static int a(long l) {
        if (l >= 0L) {
            int n = 1;
            while (l >= (long)128) {
                ++n;
                l >>= 7;
            }
            return n;
        }
        return 10;
    }

    private static long a(InputStream inputStream, boolean bl2) {
        int n = 0;
        int n2 = 0;
        long l = 0L;
        while (n < 10) {
            int n3 = inputStream.read();
            if (n3 != -1) {
                l |= (long)(n3 & 0x7F) << n2;
                if ((n3 & 0x80) == 0) break;
                ++n;
                n2 += 7;
                continue;
            }
            if (n == 0 && bl2) {
                return -1;
            }
            throw new IOException("EOF");
        }
        return l;
    }

    private static void a(OutputStream outputStream, long l) {
        for (int i = 0; i < 10; ++i) {
            int n = (int)(l & (long)127);
            if ((l >>>= 7) != 0L) {
                outputStream.write(n | 0x80);
                continue;
            }
            outputStream.write(n);
            break;
        }
    }

    private static long b(long l) {
        return l << 1 ^ -(l >>> 63);
    }

    public final void b(int n, String string) {
        this.b(n, (Object)string);
    }

    public final void b(int n, lk lk2) {
        this.b(n, (Object)lk2);
    }

    public final void b(int n, byte[] byArray) {
        this.b(n, (Object)byArray);
    }

    public lk(cp cp2) {
        this.d = cp2;
    }

    public final byte[] c() {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        this.a(byteArrayOutputStream);
        return byteArrayOutputStream.toByteArray();
    }

    public final int c(int n, int n2) {
        return (int)((Long)this.b(n, n2, 21)).longValue();
    }

    public final void h(int n, int n2) {
        this.b(n, (long)n2);
    }

    public final void a(int n, int n2) {
        this.a(n, this.i(n), n2);
    }

    public final void a(int n, long l) {
        this.a(n, this.i(n), l);
    }

    public final void a(int n, String string) {
        this.a(n, this.i(n), string);
    }

    public final void a(int n, lk lk2) {
        this.a(n, this.i(n), lk2);
    }

    public final void a(int n, byte[] byArray) {
        this.a(n, this.i(n), byArray);
    }

    public final String f(int n, int n2) {
        return (String)this.b(n, n2, 28);
    }

    public final lk e(int n, int n2) {
        return (lk)this.b(n, n2, 26);
    }

    public final byte[] b(int n, int n2) {
        return (byte[])this.b(n, n2, 25);
    }

    public final long d(int n, int n2) {
        return (Long)this.b(n, n2, 19);
    }

    public final int d(int n) {
        return (int)((Long)this.j(n, 21)).longValue();
    }

    public final boolean b(int n) {
        return (Boolean)this.j(n, 24);
    }

    public final long e(int n) {
        return (Long)this.j(n, 19);
    }

    public final byte[] c(int n) {
        return (byte[])this.j(n, 25);
    }

    public final lk f(int n) {
        return (lk)this.j(n, 26);
    }

    public final String g(int n) {
        return (String)this.j(n, 28);
    }

    public final lk a(InputStream inputStream) {
        this.a(inputStream, Integer.MAX_VALUE);
        return this;
    }

    public final lk a(byte[] byArray) {
        this.a(new ByteArrayInputStream(byArray), byArray.length);
        return this;
    }

    public final void a() {
        this.e.setSize(0);
        this.f.setLength(0);
    }

    private int d() {
        return this.e.size() - 1;
    }

    public final int i(int n) {
        Object e;
        if (n < this.e.size() && (e = this.e.elementAt(n)) != null) {
            if (e instanceof Vector) {
                return ((Vector)e).size();
            }
            return 1;
        }
        return 0;
    }

    public final boolean h(int n) {
        return this.i(n) > 0 || this.l(n) != null;
    }

    private boolean k(int n) {
        return (n = this.j(n)) == 33 || n == 34;
    }

    private Object l(int n) {
        switch (this.j(n)) {
            default: {
                return this.d.b(n);
            }
            case 16: 
            case 26: 
            case 27: 
        }
        return null;
    }

    private void b(int n, Object object) {
        if (this.e.size() <= n) {
            this.e.setSize(n + 1);
        }
        if (object != null) {
            this.a(n, object);
        }
        this.e.setElementAt(object, n);
    }

    private void a(int n, int n2, long l) {
        Long l2 = l >= 0L && l < (long)c.length ? c[(int)l] : new Long(l);
        this.a(n, n2, l2);
    }

    public final void b(int n, long l) {
        Long l2 = l >= 0L && l < (long)c.length ? c[(int)l] : new Long(l);
        this.b(n, l2);
    }

    public final void a(int n, boolean bl2) {
        Boolean bl3 = bl2 ? b : a;
        this.b(n, bl3);
    }

    private void a(int n, int n2, Object object) {
        this.a(n, object);
        if (this.i(n) != 0) {
            Vector<Object> vector;
            Object e = this.e.elementAt(n);
            if (!(e instanceof Vector)) {
                vector = new Vector<Object>();
                vector.addElement(e);
                this.e.setElementAt(vector, n);
            } else {
                vector = (Vector<Object>)e;
            }
            vector.insertElementAt(object, n2);
            return;
        }
        this.b(n, object);
    }

    public final void g(int n, int n2) {
        int n3 = this.i(n);
        if (n2 < n3) {
            if (n3 == 1) {
                this.e.setElementAt(null, n);
                return;
            }
            ((Vector)this.e.elementAt(n)).removeElementAt(n2);
            return;
        }
        throw new ArrayIndexOutOfBoundsException();
    }

    private Object j(int n, int n2) {
        int n3 = this.i(n);
        if (n3 == 0) {
            return this.l(n);
        }
        if (n3 <= 1) {
            return this.b(n, 0, n2);
        }
        throw new IllegalArgumentException();
    }

    private int j(int n) {
        int n2 = 16;
        if (this.d != null) {
            n2 = this.d.a(n);
        }
        if (n2 == 16 && n < this.f.length()) {
            n2 = this.f.charAt(n);
        }
        if (n2 == 16 && this.i(n) > 0) {
            Object object = this.b(n, 0, 16);
            if (!(object instanceof Long) && !(object instanceof Boolean)) {
                return 2;
            }
            return 0;
        }
        return n2;
    }

    private final int m(int n) {
        int n2 = this.j(n);
        switch (n2) {
            default: {
                throw new RuntimeException("Unsupp.Type:" + this.d + '/' + n + '/' + n2);
            }
            case 25: 
            case 27: 
            case 28: 
            case 35: 
            case 36: {
                return 2;
            }
            case 18: 
            case 23: 
            case 31: {
                return 5;
            }
            case 26: {
                return 3;
            }
            case 17: 
            case 22: 
            case 32: {
                return 1;
            }
            case 19: 
            case 20: 
            case 21: 
            case 24: 
            case 29: 
            case 30: 
            case 33: 
            case 34: {
                return 0;
            }
            case 0: 
            case 1: 
            case 2: 
            case 3: 
            case 5: 
            case 16: 
        }
        return n2;
    }

    /*
     * Recovered potentially malformed switches.  Disable with '--allowmalformedswitch false'
     * Enabled aggressive block sorting
     */
    private void a(int n, Object object) {
        int n2 = this.j(n);
        if (n2 == 16) {
            if (this.d == null) return;
        }
        if (!(object instanceof Boolean)) {
            if (!(object instanceof Long)) {
                if (!(object instanceof byte[])) {
                    if (object instanceof lk) {
                        switch (n2) {
                            case 2: 
                            case 3: 
                            case 25: 
                            case 26: 
                            case 27: {
                                if (this.d == null) return;
                                if (this.d.b(n) == null) return;
                                if (((lk)object).d == null) return;
                                if (((lk)object).d != this.d.b(n)) throw new IllegalArgumentException("Type mismatch type:" + this.d + " tag:" + n);
                                return;
                            }
                            default: {
                                throw new IllegalArgumentException("Type mismatch type:" + this.d + " tag:" + n);
                            }
                        }
                    }
                    if (!(object instanceof String)) throw new IllegalArgumentException("Type mismatch type:" + this.d + " tag:" + n);
                    switch (n2) {
                        case 2: 
                        case 25: 
                        case 28: 
                        case 36: {
                            return;
                        }
                        default: {
                            throw new IllegalArgumentException("Type mismatch type:" + this.d + " tag:" + n);
                        }
                    }
                }
                switch (n2) {
                    case 2: 
                    case 25: 
                    case 27: 
                    case 28: 
                    case 35: {
                        return;
                    }
                    default: {
                        throw new IllegalArgumentException("Type mismatch type:" + this.d + " tag:" + n);
                    }
                }
            }
            switch (n2) {
                case 0: 
                case 1: 
                case 5: 
                case 19: 
                case 20: 
                case 21: 
                case 22: 
                case 23: 
                case 24: 
                case 29: 
                case 30: 
                case 31: 
                case 32: 
                case 33: 
                case 34: {
                    return;
                }
                default: {
                    throw new IllegalArgumentException("Type mismatch type:" + this.d + " tag:" + n);
                }
            }
        }
        if (n2 == 24) return;
        if (n2 == 0) return;
        throw new IllegalArgumentException("Type mismatch type:" + this.d + " tag:" + n);
    }

    /*
     * Handled duff style switch with additional control
     * Loose catch block
     * WARNING - void declaration
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     */
    private Object b(int n, int n2, int n3) {
        void var5_14;
        if (n2 >= this.i(n)) {
            throw new ArrayIndexOutOfBoundsException();
        }
        Object e = this.e.elementAt(n);
        Vector vector = null;
        if (e instanceof Vector) {
            vector = (Vector)e;
            e = vector.elementAt(n2);
        }
        int n4 = 0;
        block16: do {
            block2 : switch (n4 == 0 ? n3 : n4) {
                case 24: {
                    n4 = 16;
                    if (e instanceof Boolean) continue block16;
                    switch ((int)((Long)e).longValue()) {
                        case 0: {
                            Boolean bl2 = a;
                            break block2;
                        }
                        case 1: {
                            Boolean bl3 = b;
                            break block2;
                        }
                    }
                    throw new IllegalArgumentException("Type mismatch");
                }
                default: {
                    throw new RuntimeException("Unsupp.Type");
                }
                case 26: 
                case 27: {
                    n4 = 16;
                    if (!(e instanceof byte[])) continue block16;
                    lk lk2 = new lk(null).a((byte[])e);
                    break;
                }
                case 28: 
                case 36: {
                    n4 = 16;
                    if (!(e instanceof byte[])) continue block16;
                    byte[] byArray = (byte[])e;
                    String string = ar.a(byArray, 0, byArray.length, true);
                    break;
                }
                case 25: 
                case 35: {
                    if (!(e instanceof String)) {
                        n4 = 16;
                        if (!(e instanceof lk)) continue block16;
                        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                        ((lk)e).a(byteArrayOutputStream);
                        byte[] byArray = byteArrayOutputStream.toByteArray();
                        break;
                    }
                    byte[] byArray = ar.a((String)e);
                    break;
                }
                case 19: 
                case 21: 
                case 22: 
                case 23: 
                case 31: 
                case 32: 
                case 33: 
                case 34: {
                    if (e instanceof Boolean) {
                        Long[] longArray = c;
                        n3 = (Boolean)e != false ? 1 : 0;
                        Long l = longArray[n3];
                        break;
                    }
                }
                case 16: {
                    Object e2 = e;
                }
            }
            break;
        } while (true);
        if (var5_14 != e && e != null) {
            if (vector != null) {
                vector.setElementAt(var5_14, n2);
                return var5_14;
            }
            this.b(n, var5_14);
        }
        return var5_14;
        catch (IOException iOException) {
            throw new RuntimeException(iOException.toString());
        }
        catch (IOException iOException) {
            throw new RuntimeException(iOException.toString());
        }
    }

    /*
     * Unable to fully structure code
     */
    public final int a(InputStream var1_1, int var2_2) {
        this.a();
        block6: while (var2_2 > 0 && (var5_5 = lk.a(var1_1, true)) != (long)-1) {
            block15: {
                var2_2 -= lk.a(var5_5);
                var3_3 = (int)var5_5 & 7;
                if (var3_3 == 4) break;
                var7_6 = (int)(var5_5 >>> 3);
                while (this.f.length() <= var7_6) {
                    this.f.append('\u0010');
                }
                this.f.setCharAt(var7_6, (char)var3_3);
                switch (var3_3) {
                    case 0: {
                        var5_5 = lk.a(var1_1, false);
                        var2_2 -= lk.a(var5_5);
                        if (this.k(var7_6)) {
                            var5_5 = var5_5 >>> 1 ^ -(var5_5 & 1L);
                        }
                        var8_7 = var5_5 >= 0L && var5_5 < (long)lk.c.length ? lk.c[(int)var5_5] : new Long(var5_5);
                        ** GOTO lbl54
                    }
                    case 3: {
                        var9_8 = this.d != null ? (cp)this.d.b(var7_6) : null;
                        var12_11(var9_8);
                        var2_2 = var8_7.a(var1_1, var2_2);
                        ** GOTO lbl54
                    }
                    case 2: {
                        var4_4 = (int)lk.a(var1_1, false);
                        var2_2 = var2_2 - lk.a(var4_4) - var4_4;
                        if (this.j(var7_6) == 27) {
                            var8_7 = new lk((cp)this.d.b(var7_6));
                            var8_7.a(var1_1, var4_4);
                        } else {
                            var10_9 = new byte[var4_4];
                            var8_7 = var10_9;
                            for (var3_3 = 0; var3_3 < var4_4; var3_3 += var11_10) {
                                var11_10 = var1_1.read(var10_9, var3_3, var4_4 - var3_3);
                                if (var11_10 > 0) {
                                    continue;
                                }
                                break block15;
                            }
                        }
                        ** GOTO lbl54
                    }
                    case 1: 
                    case 5: {
                        var5_5 = 0L;
                        var4_4 = 0;
                        var3_3 = var3_3 == 5 ? 4 : 8;
                        var2_2 -= var3_3;
                        while (true) {
                            v0 = var3_3;
                            var3_3 = v0 + -1;
                            if (v0 <= 0) break;
                            var5_5 |= (long)var1_1.read() << var4_4;
                            var4_4 += 8;
                        }
                        var8_7 = var5_5 >= 0L && var5_5 < (long)lk.c.length ? lk.c[(int)var5_5] : new Long(var5_5);
lbl54:
                        // 5 sources

                        this.a(var7_6, this.i(var7_6), var8_7);
                        continue block6;
                    }
                }
                throw new RuntimeException("Unsupp.Type" + var3_3);
            }
            throw new IOException("Unexp.EOF");
        }
        if (var2_2 < 0) {
            throw new IOException();
        }
        return var2_2;
    }

    public final void a(OutputStream outputStream) {
        for (int i = 0; i <= this.d(); ++i) {
            int n = this.i(i);
            int n2 = this.m(i);
            block7: for (int k = 0; k < n; ++k) {
                lk.a(outputStream, i << 3 | n2);
                switch (n2) {
                    case 2: {
                        int n3 = this.j(i) != 27 ? 25 : 16;
                        Object object = this.b(i, k, n3);
                        if (object instanceof byte[]) {
                            byte[] byArray = (byte[])object;
                            lk.a(outputStream, byArray.length);
                            outputStream.write(byArray);
                            continue block7;
                        }
                        lk lk2 = (lk)object;
                        lk.a(outputStream, lk2.b());
                        lk2.a(outputStream);
                        continue block7;
                    }
                    case 3: {
                        ((lk)this.b(i, k, 26)).a(outputStream);
                        lk.a(outputStream, i << 3 | 4);
                        continue block7;
                    }
                    case 1: 
                    case 5: {
                        long l = (Long)this.b(i, k, 19);
                        int n4 = n2 == 5 ? 4 : 8;
                        int n3 = 0;
                        while (n3 < n4) {
                            outputStream.write((int)(l & (long)255));
                            ++n3;
                            l >>= 8;
                        }
                        continue block7;
                    }
                    case 0: {
                        long l = (Long)this.b(i, k, 19);
                        if (this.k(i)) {
                            l = lk.b(l);
                        }
                        lk.a(outputStream, l);
                        continue block7;
                    }
                }
            }
            continue;
            throw new IllegalArgumentException();
        }
    }

    public final int b() {
        int n = 0;
        for (int i = 0; i <= this.d(); ++i) {
            for (int k = 0; k < this.i(i); ++k) {
                int n2;
                int n3 = lk.a(i << 3);
                switch (this.m(i)) {
                    default: {
                        Object object = this.b(i, k, 16);
                        n2 = object instanceof byte[] ? ((byte[])object).length : (!(object instanceof String) ? ((lk)object).b() : ar.a((String)object, null, 0));
                        n2 = n3 + lk.a(n2) + n2;
                        break;
                    }
                    case 5: {
                        n2 = n3 + 4;
                        break;
                    }
                    case 3: {
                        n2 = n3 + this.e(i, k).b() + n3;
                        break;
                    }
                    case 1: {
                        n2 = n3 + 8;
                        break;
                    }
                    case 0: {
                        long l = this.d(i, k);
                        if (this.k(i)) {
                            l = lk.b(l);
                        }
                        n2 = n3 + lk.a(l);
                    }
                }
                n += n2;
            }
        }
        return n;
    }
}