/*
 * Decompiled with CFR 0.152.
 */
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Vector;

public final class nz {
    private static final Vector a = new Vector();
    private static byte[] b;

    private static aa c() {
        return lh.k().f();
    }

    public static DataInput c(String string) {
        byte[] byArray = nz.c().g(string);
        if (byArray != null) {
            return new DataInputStream(new ByteArrayInputStream(byArray));
        }
        return null;
    }

    public static DataInput a(aa aa2, String string) {
        byte[] byArray = aa2.d(string);
        if (byArray != null) {
            return new DataInputStream(new ByteArrayInputStream(byArray));
        }
        return null;
    }

    /*
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     */
    private static void a(String string, Object object) {
        aa aa2 = lh.k().f();
        if (object == null) {
            aa2.a(string, null);
            return;
        }
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
        try {
            block8: {
                block9: {
                    if (object instanceof Boolean) break block9;
                    if (!(object instanceof String)) {
                        if (!(object instanceof Integer)) {
                            if (!(object instanceof Long)) {
                                throw new IllegalArgumentException("Bad type: " + object.getClass() + " for " + string);
                            }
                            dataOutputStream.writeLong((Long)object);
                            break block8;
                        } else {
                            dataOutputStream.writeInt((Integer)object);
                        }
                        break block8;
                    } else {
                        dataOutputStream.writeUTF((String)object);
                    }
                    break block8;
                }
                dataOutputStream.writeBoolean((Boolean)object);
            }
            aa2.a(string, byteArrayOutputStream.toByteArray());
            return;
        }
        catch (IOException iOException) {
            me.b("Writing: " + string, iOException);
            return;
        }
    }

    private static Object b(String string, int n) {
        DataInput dataInput = nz.c(string);
        if (dataInput != null) {
            try {
                switch (n) {
                    default: {
                        throw new RuntimeException("Bad class: " + n + " for " + string);
                    }
                    case 3: {
                        return dataInput.readUTF();
                    }
                    case 2: {
                        return new Long(dataInput.readLong());
                    }
                    case 1: {
                        return new Integer(dataInput.readInt());
                    }
                    case 0: 
                }
                return new Boolean(dataInput.readBoolean());
            }
            catch (IOException iOException) {}
        }
        return null;
    }

    public static int a(String string, int n) {
        if ((string = System.getProperty(string)) != null) {
            try {
                return Integer.parseInt(string, n);
            }
            catch (NumberFormatException numberFormatException) {}
        }
        return -1;
    }

    private static void b() {
        if (b != null) {
            System.gc();
            try {
                b = new byte[4096];
                return;
            }
            catch (OutOfMemoryError outOfMemoryError) {}
        }
    }

    public static void a() {
        b = null;
        System.err.println("OutOfMemory");
        for (int i = 0; i < a.size(); ++i) {
            ((nf)a.elementAt(i)).af();
        }
        System.gc();
        nz.b();
    }

    public static boolean b(String string, boolean bl2) {
        Object object = nz.b(string, 0);
        if (object != null) {
            return (Boolean)object;
        }
        return bl2;
    }

    public static long b(String string, long l) {
        Object object = nz.b(string, 2);
        if (object != null) {
            return (Long)object;
        }
        return l;
    }

    public static String b(String string) {
        return (String)nz.b(string, 3);
    }

    public static void b(nf nf2) {
        a.removeElement(nf2);
    }

    public static void a(nf nf2) {
        a.addElement(nf2);
    }

    public static DataInput a(String string) {
        return nz.a(nz.c(), string);
    }

    public static void a(String string, String string2) {
        nz.a(string, (Object)string2);
    }

    public static void a(String string, boolean bl2) {
        nz.a(string, new Boolean(bl2));
    }

    public static void a(String string, long l) {
        nz.a(string, new Long(l));
    }

    static {
        nz.b();
    }
}