SBoT 1.0 decompiled with jad 1.5.8e

Same SBoT.jar, decompiled with jad instead of CFR for comparison -- jad
is the same decompiler the community used on RSC client dumps back in
2004 (see DeobedMC201.rar). A few methods didn't fully resolve (jad is
much less capable than CFR on complex control flow); those are marked
inline where jad gave up.

BoneBury.java

@@ -1,37 +1,46 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- * 
+// Decompiler options: packimports(3) 
- * Could not load the following classes:
+// Source File Name:   BoneBury.java
- *  Script
+
- *  mudclient
+
- */
+public class BoneBury extends Script
-public class BoneBury
+{
-extends Script {
+
-    public BoneBury(mudclient mudclient2) {
+    public BoneBury(mudclient mudclient)
-        super(mudclient2);
+    {
+        super(mudclient);
     }
 
-    public String[] getCommands() {
+    public String[] getCommands()
-        return new String[]{"bones"};
+    {
+        return (new String[] {
+            "bones"
+        });
     }
 
-    public void start(String string, String[] stringArray) {
+    public void start(String s, String as[])
-        while (this.Running()) {
+    {
-            if (this.Fatigue() > 95 && !this.Sleeping()) {
+        while(Running()) 
-                this.DisplayMessage("@gre@SBoT: @whi@Sleeping", 3);
+        {
-                this.Use(this.FindInv(1263));
+            if(Fatigue() > 95 && !Sleeping())
-                this.Wait(5000);
+            {
+                DisplayMessage("@gre@SBoT: @whi@Sleeping", 3);
+                Use(FindInv(1263));
+                Wait(5000);
             }
-            while (this.GetNearestItem(20) != null && this.InvCount() < 30) {
+            for(; GetNearestItem(20) != null && InvCount() < 30; Wait(1000))
-                int[] nArray = this.GetNearestItem(20);
+            {
-                this.TakeItem(nArray[0], nArray[1], 20);
+                int ai[] = GetNearestItem(20);
-                this.Wait(1000);
+                TakeItem(ai[0], ai[1], 20);
             }
-            while (this.InvCount() > 2) {
+
-                this.Use(this.FindInv(20));
+            while(InvCount() > 2) 
-                this.Wait(1000);
+            {
+                Use(FindInv(20));
+                Wait(1000);
             }
         }
-        this.DisplayMessage("@red@STOPPED", 3);
+        DisplayMessage("@red@STOPPED", 3);
     }
 }

GuildFish.java

@@ -1,41 +1,49 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- * 
+// Decompiler options: packimports(3) 
- * Could not load the following classes:
+// Source File Name:   GuildFish.java
- *  Script
+
- *  mudclient
+
- */
+public class GuildFish extends Script
-public class GuildFish
+{
-extends Script {
+
-    public GuildFish(mudclient mudclient2) {
+    public GuildFish(mudclient mudclient)
-        super(mudclient2);
+    {
+        super(mudclient);
     }
 
-    public String[] getCommands() {
+    public String[] getCommands()
-        return new String[]{"guildfishing"};
+    {
+        return (new String[] {
+            "guildfishing"
+        });
     }
 
-    public void start(String string, String string2) {
+    public void start(String s, String s1)
-        this.CheckFighters(false);
+    {
-        this.DisplayMessage("@gre@SBoT: @whi@GuildFisher-TrapperJ", 3);
+        CheckFighters(false);
-        while (this.Running()) {
+        DisplayMessage("@gre@SBoT: @whi@GuildFisher-TrapperJ", 3);
-            if (this.GetY() >= 3000 || this.InvCount(372) <= 25) continue;
+        do
-            this.WalkEmpty(604, 503, 603, 503);
+        {
-            this.Wait(7000);
+            if(!Running())
+                break;
+            if(GetY() < 3000 && InvCount(372) > 25)
+            {
+                WalkEmpty(604, 503, 603, 503);
+                Wait(7000);
                 long l = System.currentTimeMillis();
-            int n = this.GetNearestNPC(369);
+                int i = GetNearestNPC(369);
-            this.TalkToNPC(n);
+                TalkToNPC(i);
-            while (System.currentTimeMillis() - l <= 5000L && !this.QuestMenu()) {
+                for(; System.currentTimeMillis() - l <= 5000L && !QuestMenu(); Wait(1));
-                this.Wait(1);
+                Wait(1000);
+                Answer(1);
+                Wait(1000);
+                Answer(1);
+                Wait(1000);
+                Answer(5);
+                Wait(1000);
             }
-            this.Wait(1000);
+        } while(true);
-            this.Answer(1);
+        DisplayMessage("@gre@SBoT: @whi@Guild Miner - @red@STOPPED", 3);
-            this.Wait(1000);
-            this.Answer(1);
-            this.Wait(1000);
-            this.Answer(5);
-            this.Wait(1000);
-        }
-        this.DisplayMessage("@gre@SBoT: @whi@Guild Miner - @red@STOPPED", 3);
     }
 }

GuildFisher.java

@@ -1,74 +1,84 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- * 
+// Decompiler options: packimports(3) 
- * Could not load the following classes:
+// Source File Name:   GuildFisher.java
- *  Script
+
- *  mudclient
+
- */
+public class GuildFisher extends Script
-public class GuildFisher
+{
-extends Script {
+
-    public GuildFisher(mudclient mudclient2) {
+    public GuildFisher(mudclient mudclient)
-        super(mudclient2);
+    {
+        super(mudclient);
     }
 
-    public String[] getCommands() {
+    public String[] getCommands()
-        return new String[]{"guildfish"};
+    {
+        return (new String[] {
+            "guildfish"
+        });
     }
 
-    public void start(String string, String string2) {
+    public void start(String s, String s1)
-        this.DisplayMessage("@gre@SBoT: @whi@GuildFisher - RichyT", 3);
+    {
-        while (this.Running()) {
+        DisplayMessage("@gre@SBoT: @whi@GuildFisher - RichyT", 3);
-            while (this.InvCount() < 30) {
+        for(; Running(); Walk(593, 502))
-                if (this.Fatigue() > 85 && !this.Sleeping()) {
+        {
-                    this.DisplayMessage("@gre@SBoT: @whi@Sleeping", 3);
+            do
-                    this.Use(this.FindInv(1263));
+            {
-                    this.Wait(5000);
+                if(InvCount() >= 30)
+                    break;
+                if(Fatigue() > 85 && !Sleeping())
+                {
+                    DisplayMessage("@gre@SBoT: @whi@Sleeping", 3);
+                    Use(FindInv(1263));
+                    Wait(5000);
                 }
-                if (this.Sleeping()) continue;
+                if(!Sleeping())
-                this.AtObject(589, 501);
+                {
-                this.Wait(1000);
+                    AtObject(589, 501);
+                    Wait(1000);
                 }
-            this.Walk(601, 504);
+            } while(true);
-            while (this.DoorAt(603, 506, 3) == 1) {
+            Walk(601, 504);
-                this.Walk(602, 506);
+            for(; DoorAt(603, 506, 3) == 1; Wait(2000))
-                this.OpenDoor(603, 506, 3);
+            {
-                this.Wait(5000);
+                Walk(602, 506);
-                this.WalkNoWait(603, 505);
+                OpenDoor(603, 506, 3);
-                this.Wait(2000);
+                Wait(5000);
+                WalkNoWait(603, 505);
             }
-            this.WalkEmpty(602, 502, 605, 505);
+
-            while (this.InvCount(372) > 0) {
+            WalkEmpty(602, 502, 605, 505);
-                long l;
+            for(; InvCount(372) > 0; Wait(2500))
-                while (!this.QuestMenu()) {
+            {
-                    l = System.currentTimeMillis();
+                while(!QuestMenu()) 
-                    int n = this.GetNearestNPC(369);
+                {
-                    this.TalkToNPC(n);
+                    long l = System.currentTimeMillis();
-                    while (System.currentTimeMillis() - l <= 5000L && !this.QuestMenu()) {
+                    int i = GetNearestNPC(369);
-                        this.Wait(1);
+                    TalkToNPC(i);
+                    while(System.currentTimeMillis() - l <= 5000L && !QuestMenu()) 
+                        Wait(1);
                 }
+                long l1 = System.currentTimeMillis();
+                Answer(1);
+                for(; !QuestMenu() && System.currentTimeMillis() - l1 <= 5000L; Wait(10));
+                l1 = System.currentTimeMillis();
+                Answer(1);
+                for(; !QuestMenu() && System.currentTimeMillis() - l1 <= 5000L; Wait(10));
+                Answer(4);
             }
-                l = System.currentTimeMillis();
+
-                this.Answer(1);
+            for(; DoorAt(603, 506, 3) == 1; Wait(2000))
-                while (!this.QuestMenu() && System.currentTimeMillis() - l <= 5000L) {
+            {
-                    this.Wait(10);
+                Walk(604, 506);
+                OpenDoor(603, 506, 3);
+                Wait(5000);
+                WalkNoWait(602, 506);
             }
-                l = System.currentTimeMillis();
+
-                this.Answer(1);
-                while (!this.QuestMenu() && System.currentTimeMillis() - l <= 5000L) {
-                    this.Wait(10);
         }
-                this.Answer(4);
+
-                this.Wait(2500);
+        DisplayMessage("@red@STOPPED", 3);
-            }
-            while (this.DoorAt(603, 506, 3) == 1) {
-                this.Walk(604, 506);
-                this.OpenDoor(603, 506, 3);
-                this.Wait(5000);
-                this.WalkNoWait(602, 506);
-                this.Wait(2000);
-            }
-            this.Walk(593, 502);
-        }
-        this.DisplayMessage("@red@STOPPED", 3);
     }
 }

c.java

@@ -1,169 +1,184 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-import java.awt.Event;
+// Source File Name:   c.java
-import java.awt.Frame;
+
-import java.awt.Graphics;
+import java.awt.*;
+
+public class c extends Frame
+{
+
+    public c(a a1, int i, int j, String s, boolean flag, boolean flag1)
+    {
+        boolean flag2;
+        flag2 = q.d;
+        super();
+        d = 28;
+        a = i;
+        b = j;
+        this;
+        if(flag2) goto _L2; else goto _L1
+_L1:
+        a1;
+        e;
+        if(!flag1) goto _L4; else goto _L3
+_L3:
+        d = 48;
+        if(!flag2) goto _L5; else goto _L4
+_L4:
+        this;
+_L2:
+        28;
+        d;
+_L5:
+        setTitle(s);
+        setResizable(flag);
+        show();
+        toFront();
+        resize(a, b);
+        f = getGraphics();
+        return;
+    }
+
+    public Graphics getGraphics()
+    {
+        Graphics g = super.getGraphics();
+        g.translate(0, 24);
+        return g;
+    }
+
+    public void resize(int i, int j)
+    {
+        super.resize(i, j + d);
+    }
+
+    public boolean handleEvent(Event event)
+    {
+        boolean flag1;
+        flag1 = q.d;
+        boolean flag = false;
+        event.id;
+        401;
+        if(flag1) goto _L2; else goto _L1
+_L1:
+        JVM INSTR icmpne 37;
+           goto _L3 _L4
+_L3:
+        e.keyDown(event, event.key);
+        if(!flag1) goto _L5; else goto _L4
+_L4:
+        event.id;
+        '\u0192';
+_L2:
+        if(flag1) goto _L7; else goto _L6
+_L6:
+        JVM INSTR icmpne 68;
+           goto _L8 _L9
+_L8:
+        e.keyUp(event, event.key);
+        if(!flag1) goto _L5; else goto _L9
+_L9:
+        event.id;
+        '\u01F5';
+_L7:
+        if(flag1) goto _L11; else goto _L10
+_L10:
+        JVM INSTR icmpne 106;
+           goto _L12 _L13
+_L12:
+        e.mouseDown(event, event.x, event.y - 24);
+        if(!flag1) goto _L5; else goto _L13
+_L13:
+        event.id;
+        '\u01FA';
+_L11:
+        if(flag1) goto _L15; else goto _L14
+_L14:
+        JVM INSTR icmpne 144;
+           goto _L16 _L17
+_L16:
+        e.mouseDrag(event, event.x, event.y - 24);
+        if(!flag1) goto _L5; else goto _L17
+_L17:
+        event.id;
+        '\u01F6';
+_L15:
+        if(flag1) goto _L19; else goto _L18
+_L18:
+        JVM INSTR icmpne 182;
+           goto _L20 _L21
+_L20:
+        e.mouseUp(event, event.x, event.y - 24);
+        if(!flag1) goto _L5; else goto _L21
+_L21:
+        event.id;
+        '\u01F7';
+_L19:
+        if(flag1) goto _L23; else goto _L22
+_L22:
+        JVM INSTR icmpne 220;
+           goto _L24 _L25
+_L24:
+        e.mouseMove(event, event.x, event.y - 24);
+        if(!flag1) goto _L5; else goto _L25
+_L25:
+        event.id;
+        '\311';
+_L23:
+        if(flag1) goto _L27; else goto _L26
+_L26:
+        JVM INSTR icmpne 245;
+           goto _L28 _L29
+_L28:
+        e.destroy();
+        if(!flag1) goto _L5; else goto _L29
+_L29:
+        event.id;
+        '\u03E9';
+_L27:
+        if(flag1) goto _L31; else goto _L30
+_L30:
+        JVM INSTR icmpne 276;
+           goto _L32 _L33
+_L32:
+        e.action(event, event.target);
+        if(!flag1) goto _L5; else goto _L33
+_L33:
+        event.id;
+        '\u0193';
+_L31:
+        if(flag1) goto _L35; else goto _L34
+_L34:
+        JVM INSTR icmpne 307;
+           goto _L36 _L37
+_L36:
+        e.keyDown(event, event.key);
+        if(!flag1) goto _L5; else goto _L37
+_L37:
+        event.id;
+        if(flag1) goto _L39; else goto _L38
+_L38:
+        '\u0194';
+_L35:
+        JVM INSTR icmpne 334;
+           goto _L40 _L5
+_L40:
+        e.keyUp(event, event.key);
+_L5:
+        true;
+_L39:
+        return;
+    }
+
+    public final void paint(Graphics g)
+    {
+        e.paint(g);
+    }
 
-public class c
-extends Frame {
     int a;
     int b;
     int c;
     int d;
     a e;
     Graphics f;
-
-    public c(a a2, int n2, int n3, String string, boolean bl, boolean bl2) {
-        block4: {
-            block2: {
-                c c2;
-                block3: {
-                    boolean bl3 = q.d;
-                    this.d = 28;
-                    this.a = n2;
-                    this.b = n3;
-                    c2 = this;
-                    if (bl3) break block2;
-                    c2.e = a2;
-                    if (!bl2) break block3;
-                    this.d = 48;
-                    if (!bl3) break block4;
 }
-                c2 = this;
-            }
-            c2.d = 28;
-        }
-        this.setTitle(string);
-        this.setResizable(bl);
-        this.show();
-        this.toFront();
-        this.resize(this.a, this.b);
-        this.f = this.getGraphics();
-    }
-
-    public Graphics getGraphics() {
-        Graphics graphics = super.getGraphics();
-        graphics.translate(0, 24);
-        return graphics;
-    }
-
-    public void resize(int n2, int n3) {
-        super.resize(n2, n3 + this.d);
-    }
-
-    public boolean handleEvent(Event event) {
-        int n2;
-        block23: {
-            block6: {
-                int n3;
-                block21: {
-                    boolean bl;
-                    block22: {
-                        block19: {
-                            block20: {
-                                block17: {
-                                    block18: {
-                                        block15: {
-                                            block16: {
-                                                block13: {
-                                                    block14: {
-                                                        block11: {
-                                                            block12: {
-                                                                block9: {
-                                                                    block10: {
-                                                                        block7: {
-                                                                            block8: {
-                                                                                block4: {
-                                                                                    block5: {
-                                                                                        bl = q.d;
-                                                                                        boolean bl2 = false;
-                                                                                        n2 = event.id;
-                                                                                        n3 = 401;
-                                                                                        if (bl) break block4;
-                                                                                        if (n2 != n3) break block5;
-                                                                                        this.e.keyDown(event, event.key);
-                                                                                        if (!bl) break block6;
-                                                                                    }
-                                                                                    n2 = event.id;
-                                                                                    n3 = 402;
-                                                                                }
-                                                                                if (bl) break block7;
-                                                                                if (n2 != n3) break block8;
-                                                                                this.e.keyUp(event, event.key);
-                                                                                if (!bl) break block6;
-                                                                            }
-                                                                            n2 = event.id;
-                                                                            n3 = 501;
-                                                                        }
-                                                                        if (bl) break block9;
-                                                                        if (n2 != n3) break block10;
-                                                                        this.e.mouseDown(event, event.x, event.y - 24);
-                                                                        if (!bl) break block6;
-                                                                    }
-                                                                    n2 = event.id;
-                                                                    n3 = 506;
-                                                                }
-                                                                if (bl) break block11;
-                                                                if (n2 != n3) break block12;
-                                                                this.e.mouseDrag(event, event.x, event.y - 24);
-                                                                if (!bl) break block6;
-                                                            }
-                                                            n2 = event.id;
-                                                            n3 = 502;
-                                                        }
-                                                        if (bl) break block13;
-                                                        if (n2 != n3) break block14;
-                                                        this.e.mouseUp(event, event.x, event.y - 24);
-                                                        if (!bl) break block6;
-                                                    }
-                                                    n2 = event.id;
-                                                    n3 = 503;
-                                                }
-                                                if (bl) break block15;
-                                                if (n2 != n3) break block16;
-                                                this.e.mouseMove(event, event.x, event.y - 24);
-                                                if (!bl) break block6;
-                                            }
-                                            n2 = event.id;
-                                            n3 = 201;
-                                        }
-                                        if (bl) break block17;
-                                        if (n2 != n3) break block18;
-                                        this.e.destroy();
-                                        if (!bl) break block6;
-                                    }
-                                    n2 = event.id;
-                                    n3 = 1001;
-                                }
-                                if (bl) break block19;
-                                if (n2 != n3) break block20;
-                                this.e.action(event, event.target);
-                                if (!bl) break block6;
-                            }
-                            n2 = event.id;
-                            n3 = 403;
-                        }
-                        if (bl) break block21;
-                        if (n2 != n3) break block22;
-                        this.e.keyDown(event, event.key);
-                        if (!bl) break block6;
-                    }
-                    n2 = event.id;
-                    if (bl) break block23;
-                    n3 = 404;
-                }
-                if (n2 == n3) {
-                    this.e.keyUp(event, event.key);
-                }
-            }
-            n2 = 1;
-        }
-        return n2 != 0;
-    }
-
-    public final void paint(Graphics graphics) {
-        this.e.paint(graphics);
-    }
-}
-

d.java

@@ -1,58 +1,71 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- * 
+// Decompiler options: packimports(3) 
- * Could not load the following classes:
+// Source File Name:   d.java
- *  sun.audio.AudioPlayer
+
- */
 import java.io.InputStream;
 import sun.audio.AudioPlayer;
 
-public class d
+public class d extends InputStream
-extends InputStream {
+{
-    byte[] a;
+
+    public d()
+    {
+        AudioPlayer.player.start(this);
+    }
+
+    public void a()
+    {
+        AudioPlayer.player.stop(this);
+    }
+
+    public void a(byte abyte0[], int i, int j)
+    {
+        a = abyte0;
+        b = i;
+        c = i + j;
+    }
+
+    public int read(byte abyte0[], int i, int j)
+    {
+        int k;
+        boolean flag1;
+        flag1 = q.d;
+        boolean flag = false;
+        k = 0;
+_L6:
+        if(k >= j)
+            break; /* Loop/switch isn't completed */
+        b;
+        if(flag1) goto _L2; else goto _L1
+_L1:
+        c;
+        JVM INSTR icmpge 60;
+           goto _L3 _L4
+_L3:
+        break MISSING_BLOCK_LABEL_33;
+_L4:
+        break MISSING_BLOCK_LABEL_60;
+        abyte0[i + k] = a[b++];
+        if(!flag1)
+            break MISSING_BLOCK_LABEL_67;
+        abyte0[i + k] = -1;
+        k++;
+        if(!flag1) goto _L6; else goto _L5
+_L5:
+        j;
+_L2:
+        return;
+    }
+
+    public int read()
+    {
+        byte abyte0[] = new byte[1];
+        read(abyte0, 0, 1);
+        return abyte0[0];
+    }
+
+    byte a[];
     int b;
     int c;
-
-    public d() {
-        AudioPlayer.player.start((InputStream)this);
 }
-
-    public void a() {
-        AudioPlayer.player.stop((InputStream)this);
-    }
-
-    public void a(byte[] byArray, int n2, int n3) {
-        this.a = byArray;
-        this.b = n2;
-        this.c = n2 + n3;
-    }
-
-    public int read(byte[] byArray, int n2, int n3) {
-        int n4;
-        block3: {
-            boolean bl = q.d;
-            boolean bl2 = false;
-            for (int i2 = 0; i2 < n3; ++i2) {
-                n4 = this.b;
-                if (!bl) {
-                    if (n4 < this.c) {
-                        byArray[n2 + i2] = this.a[this.b++];
-                        if (!bl) continue;
-                    }
-                    byArray[n2 + i2] = -1;
-                    if (!bl) continue;
-                }
-                break block3;
-            }
-            n4 = n3;
-        }
-        return n4;
-    }
-
-    public int read() {
-        byte[] byArray = new byte[1];
-        this.read(byArray, 0, 1);
-        return byArray[0];
-    }
-}
-

e.java

@@ -1,7 +1,32 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-class e {
+// Source File Name:   e.java
+
+
+class e
+{
+
+    e()
+    {
+        boolean flag = false;
+        D = new int[256];
+        F = new int[257];
+        G = new int[257];
+        J = new boolean[256];
+        K = new boolean[16];
+        L = new byte[256];
+        M = new byte[4096];
+        N = new int[16];
+        O = new byte[18002];
+        P = new byte[18002];
+        Q = new byte[6][258];
+        R = new int[6][258];
+        S = new int[6][258];
+        T = new int[6][258];
+        U = new int[6];
+    }
+
     final int a = 4096;
     final int b = 16;
     final int c = 258;
@@ -11,12 +36,12 @@ class e {
     final int g = 50;
     final int h = 4;
     final int i = 18002;
-    byte[] j;
+    byte j[];
     int k;
     int l;
     int m;
     int n;
-    byte[] o;
+    byte o[];
     int p;
     int q;
     int r;
@@ -31,43 +56,23 @@ class e {
     int A;
     int B;
     int C;
-    int[] D;
+    int D[];
     int E;
-    int[] F;
+    int F[];
-    int[] G;
+    int G[];
-    public static int[] H;
+    public static int H[];
     int I;
-    boolean[] J;
+    boolean J[];
-    boolean[] K;
+    boolean K[];
-    byte[] L;
+    byte L[];
-    byte[] M;
+    byte M[];
-    int[] N;
+    int N[];
-    byte[] O;
+    byte O[];
-    byte[] P;
+    byte P[];
-    byte[][] Q;
+    byte Q[][];
-    int[][] R;
+    int R[][];
-    int[][] S;
+    int S[][];
-    int[][] T;
+    int T[][];
-    int[] U;
+    int U[];
     int V;
-
-    e() {
-        boolean bl = false;
-        this.D = new int[256];
-        this.F = new int[257];
-        this.G = new int[257];
-        this.J = new boolean[256];
-        this.K = new boolean[16];
-        this.L = new byte[256];
-        this.M = new byte[4096];
-        this.N = new int[16];
-        this.O = new byte[18002];
-        this.P = new byte[18002];
-        this.Q = new byte[6][258];
-        this.R = new int[6][258];
-        this.S = new int[6][258];
-        this.T = new int[6][258];
-        this.U = new int[6];
 }
-}
-

g.java

@@ -1,7 +1,18 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-public class g {
+// Source File Name:   g.java
+
+
+public class g
+{
+
+    public g()
+    {
+        o = false;
+        q = -1;
+    }
+
     protected int a;
     protected int b;
     protected int c;
@@ -16,8 +27,7 @@ public class g {
     protected int l;
     protected int m;
     protected int n;
-    protected boolean o = false;
+    protected boolean o;
     protected int p;
-    protected int q = -1;
+    protected int q;
 }
-

i.java

@@ -1,50 +1,74 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
+// Source File Name:   i.java
+
 import java.awt.Component;
 
-public final class i
+public final class i extends h
-extends h {
+{
+
+    public i(int j, int k, int l, Component component)
+    {
+        super(j, k, l, component);
+        boolean flag = false;
+    }
+
+    public final void a(int j, int k, int l, int i1, int j1, int k1, int l1)
+    {
+        boolean flag = q.d;
+        j1;
+        50000;
+        if(flag) goto _L2; else goto _L1
+_L1:
+        JVM INSTR icmplt 39;
+           goto _L3 _L4
+_L3:
+        break MISSING_BLOCK_LABEL_17;
+_L4:
+        break MISSING_BLOCK_LABEL_39;
+        Q.a(j, k, l, i1, j1 - 50000, k1, l1);
+        return;
+        j1;
+        40000;
+_L2:
+        if(flag) goto _L6; else goto _L5
+_L5:
+        JVM INSTR icmplt 73;
+           goto _L7 _L8
+_L7:
+        break MISSING_BLOCK_LABEL_51;
+_L8:
+        break MISSING_BLOCK_LABEL_73;
+        Q.b(j, k, l, i1, j1 - 40000, k1, l1);
+        return;
+        j1;
+        '\u4E20';
+_L6:
+        if(flag) goto _L10; else goto _L9
+_L9:
+        JVM INSTR icmplt 109;
+           goto _L11 _L12
+_L11:
+        break MISSING_BLOCK_LABEL_86;
+_L12:
+        break MISSING_BLOCK_LABEL_109;
+        Q.d(j, k, l, i1, j1 - 20000, k1, l1);
+        return;
+        j1;
+        '\u1388';
+_L10:
+        JVM INSTR icmplt 140;
+           goto _L13 _L14
+_L13:
+        break MISSING_BLOCK_LABEL_117;
+_L14:
+        break MISSING_BLOCK_LABEL_140;
+        Q.c(j, k, l, i1, j1 - 5000, k1, l1);
+        return;
+        super.f(j, k, l, i1, j1);
+        return;
+    }
+
     public mudclient Q;
-
-    public i(int n2, int n3, int n4, Component component) {
-        super(n2, n3, n4, component);
-        boolean bl = false;
 }
-
-    public final void a(int n2, int n3, int n4, int n5, int n6, int n7, int n8) {
-        boolean bl = q.d;
-        int n9 = n6;
-        int n10 = 50000;
-        if (!bl) {
-            if (n9 >= n10) {
-                this.Q.a(n2, n3, n4, n5, n6 - 50000, n7, n8);
-                return;
-            }
-            n9 = n6;
-            n10 = 40000;
-        }
-        if (!bl) {
-            if (n9 >= n10) {
-                this.Q.b(n2, n3, n4, n5, n6 - 40000, n7, n8);
-                return;
-            }
-            n9 = n6;
-            n10 = 20000;
-        }
-        if (!bl) {
-            if (n9 >= n10) {
-                this.Q.d(n2, n3, n4, n5, n6 - 20000, n7, n8);
-                return;
-            }
-            n9 = n6;
-            n10 = 5000;
-        }
-        if (n9 >= n10) {
-            this.Q.c(n2, n3, n4, n5, n6 - 5000, n7, n8);
-            return;
-        }
-        super.f(n2, n3, n4, n5, n6);
-    }
-}
-

j.java

@@ -1,234 +1,329 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-public class j {
+// Source File Name:   j.java
-    public static byte[] a = new byte[100];
-    public static char[] b = new char[100];
-    private static char[] c = new char[]{' ', 'e', 't', 'a', 'o', 'i', 'h', 'n', 's', 'r', 'd', 'l', 'u', 'm', 'w', 'c', 'y', 'f', 'g', 'p', 'b', 'v', 'k', 'x', 'j', 'q', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ' ', '!', '?', '.', ',', ':', ';', '(', ')', '-', '&', '*', '\\', '\'', '@', '#', '+', '=', '\u00a3', '$', '%', '\"', '[', ']'};
 
-    /*
-     * Unable to fully structure code
-     */
-    public static String a(byte[] var0, int var1_1, int var2_2) {
-        var9_3 = q.d;
-        var3_4 = false;
-        try {
-            var4_5 = 0;
-            var5_7 = -1;
-            for (var6_8 = 0; var6_8 < var2_2; ++var6_8) {
-                block24: {
-                    block20: {
-                        block21: {
-                            block22: {
-                                block23: {
-                                    var7_9 = var0[var1_1++] & 255;
-                                    var8_10 = var7_9 >> 4 & 15;
-                                    v0 = var5_7;
-                                    if (var9_3) break block20;
-                                    v1 = -1;
-                                    if (var9_3) ** GOTO lbl49
-                                    if (v0 != v1) break block21;
-                                    v2 = var8_10;
-                                    if (var9_3) break block22;
-                                    if (v2 >= 13) break block23;
-                                    j.b[var4_5++] = j.c[var8_10];
-                                    if (!var9_3) break block24;
-                                }
-                                v2 = var5_7 = var8_10;
-                            }
-                            if (!var9_3) break block24;
-                        }
-                        j.b[var4_5++] = j.c[(var5_7 << 4) + var8_10 - 195];
-                        v0 = -1;
-                    }
-                    var5_7 = v0;
-                }
-                var8_10 = var7_9 & 15;
-                v3 = var5_7;
-                if (!var9_3) {
-                    if (v3 == -1) {
-                        v4 = var8_10;
-                        if (!var9_3) {
-                            if (v4 < 13) {
-                                j.b[var4_5++] = j.c[var8_10];
-                                if (!var9_3) continue;
-                            }
-                            v4 = var5_7 = var8_10;
-                        }
-                        if (!var9_3) continue;
-                    }
-                    j.b[var4_5++] = j.c[(var5_7 << 4) + var8_10 - 195];
-                    v3 = -1;
-                }
-                var5_7 = v3;
-                if (!var9_3) continue;
-            }
-            var6_8 = 1;
-            var7_9 = 0;
-            do {
-                block33: {
-                    block31: {
-                        block32: {
-                            block30: {
-                                block28: {
-                                    block29: {
-                                        block27: {
-                                            block25: {
-                                                block26: {
-                                                    v5 = var7_9;
-                                                    v1 = var4_5;
-lbl49:
-                                                    // 2 sources
 
-                                                    if (v5 >= v1) break;
+public class j
-                                                    var8_10 = j.b[var7_9];
+{
-                                                    v6 = var7_9;
+
-                                                    v7 = 4;
+    public j()
-                                                    if (var9_3) break block25;
+    {
-                                                    if (v6 <= v7) break block26;
-                                                    v6 = var8_10;
-                                                    v7 = 64;
-                                                    if (var9_3) break block25;
-                                                    if (v6 == v7) {
-                                                        j.b[var7_9] = 32;
     }
-                                                }
+
-                                                v6 = var8_10;
+    public static String a(byte abyte0[], int i, int k)
-                                                if (var9_3) break block27;
+    {
-                                                v7 = 37;
+        boolean flag1;
-                                            }
+        flag1 = q.d;
-                                            if (v6 == v7) {
+        boolean flag = false;
-                                                j.b[var7_9] = 32;
+        int l;
-                                            }
+        int i1;
-                                            v6 = var6_8;
+        int j1;
-                                        }
+        l = 0;
-                                        if (var9_3) break block28;
+        i1 = -1;
-                                        if (v6 == 0) break block29;
+        j1 = 0;
-                                        v6 = var8_10;
+_L22:
-                                        v8 = 97;
+        int k1;
-                                        if (var9_3) break block30;
+        int l1;
-                                        if (v6 < v8) break block29;
+        if(j1 >= k)
-                                        v6 = var8_10;
+            break; /* Loop/switch isn't completed */
-                                        v8 = 122;
+        k1 = abyte0[i++] & 0xff;
-                                        if (var9_3) break block30;
+        l1 = k1 >> 4 & 0xf;
-                                        if (v6 <= v8) {
+        i1;
-                                            v9 = var7_9;
+        if(flag1) goto _L2; else goto _L1
-                                            j.b[v9] = (char)(j.b[v9] + 65504);
+_L1:
-                                            var6_8 = 0;
+        -1;
-                                        }
+        if(flag1) goto _L4; else goto _L3
-                                    }
+_L3:
-                                    v6 = var8_10;
+        JVM INSTR icmpne 100;
-                                }
+           goto _L5 _L6
-                                if (var9_3) break block31;
+_L5:
-                                v8 = 46;
+        l1;
-                            }
+        if(flag1) goto _L8; else goto _L7
-                            if (v6 == v8) break block32;
+_L7:
-                            v6 = var8_10;
+        13;
-                            if (var9_3) break block31;
+        JVM INSTR icmpge 91;
-                            if (v6 != 33) break block33;
+           goto _L9 _L10
-                        }
+_L9:
-                        v6 = 1;
+        b[l++] = c[l1];
-                    }
+        if(!flag1) goto _L11; else goto _L10
-                    var6_8 = v6;
+_L10:
-                }
+        l1;
-                ++var7_9;
+_L8:
-            } while (!var9_3);
+        i1;
-            return new String(j.b, 0, var4_5);
+        if(!flag1) goto _L11; else goto _L6
-        }
+_L6:
-        catch (Exception var4_6) {
+        b[l++] = c[((i1 << 4) + l1) - 195];
+        -1;
+_L2:
+        i1;
+_L11:
+        l1 = k1 & 0xf;
+        i1;
+        if(flag1) goto _L13; else goto _L12
+_L12:
+        -1;
+        JVM INSTR icmpne 186;
+           goto _L14 _L15
+_L14:
+        l1;
+        if(flag1) goto _L17; else goto _L16
+_L16:
+        13;
+        JVM INSTR icmpge 177;
+           goto _L18 _L19
+_L18:
+        b[l++] = c[l1];
+        if(!flag1) goto _L20; else goto _L19
+_L19:
+        l1;
+_L17:
+        i1;
+        if(!flag1) goto _L20; else goto _L15
+_L15:
+        b[l++] = c[((i1 << 4) + l1) - 195];
+        -1;
+_L13:
+        i1;
+_L20:
+        j1++;
+        if(!flag1) goto _L22; else goto _L21
+_L21:
+        j1 = 1;
+        k1 = 0;
+_L51:
+        k1;
+        l;
+_L4:
+        JVM INSTR icmpge 377;
+           goto _L23 _L24
+_L24:
+        break; /* Loop/switch isn't completed */
+_L23:
+        l1 = b[k1];
+        k1;
+        4;
+        if(flag1) goto _L26; else goto _L25
+_L25:
+        JVM INSTR icmple 273;
+           goto _L27 _L28
+_L27:
+        l1;
+        '@';
+        if(flag1) goto _L26; else goto _L29
+_L29:
+        JVM INSTR icmpne 273;
+           goto _L30 _L28
+_L30:
+        b[k1] = ' ';
+_L28:
+        l1;
+        if(flag1) goto _L32; else goto _L31
+_L31:
+        37;
+_L26:
+        JVM INSTR icmpne 293;
+           goto _L33 _L34
+_L33:
+        b[k1] = ' ';
+_L34:
+        j1;
+_L32:
+        if(flag1) goto _L36; else goto _L35
+_L35:
+        JVM INSTR ifeq 342;
+           goto _L37 _L38
+_L37:
+        l1;
+        'a';
+        if(flag1) goto _L40; else goto _L39
+_L39:
+        JVM INSTR icmplt 342;
+           goto _L41 _L38
+_L41:
+        l1;
+        'z';
+        if(flag1) goto _L40; else goto _L42
+_L42:
+        JVM INSTR icmpgt 342;
+           goto _L43 _L38
+_L43:
+        b[k1] += '\uFFE0';
+        j1 = 0;
+_L38:
+        l1;
+_L36:
+        if(flag1) goto _L45; else goto _L44
+_L44:
+        46;
+_L40:
+        JVM INSTR icmpeq 366;
+           goto _L46 _L47
+_L46:
+        l1;
+        if(flag1) goto _L45; else goto _L48
+_L48:
+        '!';
+        JVM INSTR icmpne 369;
+           goto _L47 _L49
+_L47:
+        true;
+_L45:
+        j1;
+_L49:
+        k1++;
+        if(!flag1) goto _L51; else goto _L50
+_L50:
+        return new String(b, 0, l);
+        Exception exception;
+        exception;
         return ".";
     }
+
+    public static int a(String s)
+    {
+        boolean flag1;
+        flag1 = q.d;
+        boolean flag = false;
+        s.length();
+        if(flag1) goto _L2; else goto _L1
+_L1:
+        80;
+        JVM INSTR icmple 29;
+           goto _L3 _L4
+_L3:
+        break MISSING_BLOCK_LABEL_21;
+_L4:
+        break MISSING_BLOCK_LABEL_29;
+        s = s.substring(0, 80);
+        s = s.toLowerCase();
+        false;
+_L2:
+        int i;
+        i;
+        int k;
+        int l;
+        k = -1;
+        l = 0;
+_L34:
+        char c1;
+        int i1;
+        if(l >= s.length())
+            break; /* Loop/switch isn't completed */
+        c1 = s.charAt(l);
+        i1 = 0;
+        0;
+        if(flag1) goto _L6; else goto _L5
+_L5:
+        int j1;
+        j1;
+_L15:
+        if(j1 >= c.length)
+            break; /* Loop/switch isn't completed */
+        c1;
+        if(flag1) goto _L8; else goto _L7
+_L7:
+        c[j1];
+        if(flag1) goto _L10; else goto _L9
+_L9:
+        JVM INSTR icmpeq 104;
+           goto _L11 _L12
+_L11:
+        if(!flag1) goto _L13; else goto _L12
+_L12:
+        j1;
+_L8:
+        i1;
+        if(!flag1)
+            break; /* Loop/switch isn't completed */
+_L13:
+        j1++;
+        if(!flag1) goto _L15; else goto _L14
+_L14:
+        i1;
+        0xc;
+_L10:
+        if(flag1) goto _L17; else goto _L16
+_L16:
+        JVM INSTR icmple 141;
+           goto _L18 _L19
+_L18:
+        break MISSING_BLOCK_LABEL_133;
+_L19:
+        break MISSING_BLOCK_LABEL_141;
+        i1 += 195;
+        k;
+        -1;
+_L17:
+        if(flag1) goto _L21; else goto _L20
+_L20:
+        JVM INSTR icmpne 187;
+           goto _L22 _L23
+_L22:
+        i1;
+        if(flag1) goto _L25; else goto _L24
+_L24:
+        13;
+        JVM INSTR icmpge 171;
+           goto _L26 _L27
+_L26:
+        i1;
+_L25:
+        k;
+        if(!flag1) goto _L28; else goto _L27
+_L27:
+        a[i++] = (byte)i1;
+        if(!flag1) goto _L28; else goto _L23
+_L23:
+        i1;
+        13;
+_L21:
+        if(flag1) goto _L30; else goto _L29
+_L29:
+        JVM INSTR icmpge 221;
+           goto _L31 _L32
+_L31:
+        a[i++] = (byte)((k << 4) + i1);
+        k = -1;
+        if(!flag1) goto _L28; else goto _L32
+_L32:
+        a[i++] = (byte)((k << 4) + (i1 >> 4));
+        i1;
+        15;
+_L30:
+        JVM INSTR iand ;
+        k;
+_L28:
+        l++;
+        if(!flag1) goto _L34; else goto _L33
+_L33:
+        k;
+_L6:
+        if(flag1) goto _L36; else goto _L35
+_L35:
+        -1;
+        JVM INSTR icmpeq 274;
+           goto _L37 _L38
+_L37:
+        break MISSING_BLOCK_LABEL_262;
+_L38:
+        break MISSING_BLOCK_LABEL_274;
+        a[i++] = (byte)(k << 4);
+        i;
+_L36:
+        return;
     }
 
-    public static int a(String string) {
+    public static byte a[] = new byte[100];
-        int n2;
+    public static char b[] = new char[100];
-        int n3;
+    private static char c[] = {
-        int n4;
+        ' ', 'e', 't', 'a', 'o', 'i', 'h', 'n', 's', 'r', 
-        boolean bl;
+        'd', 'l', 'u', 'm', 'w', 'c', 'y', 'f', 'g', 'p', 
-        block16: {
+        'b', 'v', 'k', 'x', 'j', 'q', 'z', '0', '1', '2', 
-            bl = q.d;
+        '3', '4', '5', '6', '7', '8', '9', ' ', '!', '?', 
-            boolean bl2 = false;
+        '.', ',', ':', ';', '(', ')', '-', '&', '*', '\\', 
-            int n5 = string.length();
+        '\'', '@', '#', '+', '=', '\243', '$', '%', '"', '[', 
-            if (!bl) {
+        ']'
-                if (n5 > 80) {
+    };
-                    string = string.substring(0, 80);
-                }
-                string = string.toLowerCase();
-                n5 = 0;
-            }
-            n4 = n5;
-            n3 = -1;
-            for (int i2 = 0; i2 < string.length(); ++i2) {
-                int n6;
-                int n7;
-                int n8;
-                block18: {
-                    block19: {
-                        block21: {
-                            block20: {
-                                block17: {
-                                    int n9 = string.charAt(i2);
-                                    n8 = 0;
-                                    n2 = 0;
-                                    if (bl) break block16;
-                                    for (int i3 = v172397; i3 < c.length; ++i3) {
-                                        int n10 = n9;
-                                        if (!bl) {
-                                            n7 = c[i3];
-                                            if (bl) break block17;
-                                            if (n10 != n7 && !bl) continue;
-                                            n10 = n8 = i3;
-                                        }
-                                        if (!bl) break;
-                                        if (!bl) continue;
-                                    }
-                                    n6 = n8;
-                                    n7 = 12;
-                                }
-                                if (!bl) {
-                                    if (n6 > n7) {
-                                        n8 += 195;
-                                    }
-                                    n6 = n3;
-                                    n7 = -1;
-                                }
-                                if (bl) break block18;
-                                if (n6 != n7) break block19;
-                                int n11 = n8;
-                                if (bl) break block20;
-                                if (n11 >= 13) break block21;
-                                n11 = n3 = n8;
-                            }
-                            if (!bl) continue;
-                        }
-                        j.a[n4++] = (byte)n8;
-                        if (!bl) continue;
-                    }
-                    n6 = n8;
-                    n7 = 13;
-                }
-                if (!bl) {
-                    if (n6 < n7) {
-                        j.a[n4++] = (byte)((n3 << 4) + n8);
-                        n3 = -1;
-                        if (!bl) continue;
-                    }
-                    j.a[n4++] = (byte)((n3 << 4) + (n8 >> 4));
-                    n6 = n8;
-                    n7 = 15;
-                }
-                n3 = n6 & n7;
-                if (!bl) continue;
-            }
-            n2 = n3;
-        }
-        if (!bl) {
-            if (n2 != -1) {
-                j.a[n4++] = (byte)(n3 << 4);
-            }
-            n2 = n4;
-        }
-        return n2;
-    }
-}
 
+}

k.java

@@ -1,7 +1,16 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-public class k {
+// Source File Name:   k.java
+
+
+public class k
+{
+
+    public k()
+    {
+    }
+
     public static int a = 196;
     public static int b = 196;
     public static int c = 85;
@@ -12,5 +21,5 @@ public class k {
     public static int h = 24;
     public static int i = 1;
     public static int j = 2;
-}
 
+}

m.java

@@ -1,206 +1,264 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-public final class m {
+// Source File Name:   m.java
+
+
+public final class m
+{
+
+    public m(int ai[])
+    {
+label0:
+        {
+            boolean flag = q.d;
+            super();
+            c = new int[256];
+            b = new int[256];
+            int i = 0;
+            do
+            {
+                if(i >= ai.length)
+                    break;
+                b[i] = ai[i];
+                i++;
+                if(flag)
+                    break label0;
+            } while(!flag);
+            c();
+        }
+    }
+
+    public final int a()
+    {
+        a--;
+        if(q.d) goto _L2; else goto _L1
+_L1:
+        JVM INSTR ifne 31;
+           goto _L3 _L4
+_L3:
+        break MISSING_BLOCK_LABEL_20;
+_L4:
+        break MISSING_BLOCK_LABEL_31;
+        b();
+        a = 255;
+        b[a];
+_L2:
+        return;
+    }
+
+    private final void b()
+    {
+        boolean flag1 = q.d;
+        boolean flag = false;
+        e += ++f;
+        int i = 0;
+        do
+        {
+            if(i >= 256)
+                break;
+            int j = c[i];
+            if(!flag1)
+            {
+                switch(i & 3)
+                {
+                default:
+                    break;
+
+                case 0: // '\0'
+                    d ^= d << 13;
+                    if(!flag1)
+                        break;
+                    // fall through
+
+                case 1: // '\001'
+                    d ^= d >>> 6;
+                    if(!flag1)
+                        break;
+                    // fall through
+
+                case 2: // '\002'
+                    d ^= d << 2;
+                    if(!flag1)
+                        break;
+                    // fall through
+
+                case 3: // '\003'
+                    d ^= d >>> 16;
+                    break;
+                }
+                d += c[i + 128 & 0xff];
+            }
+            int k;
+            c[i] = k = c[(j & 0x3fc) >> 2] + d + e;
+            b[i] = e = c[(k >> 8 & 0x3fc) >> 2] + j;
+            i++;
+        } while(!flag1);
+    }
+
+    private final void c()
+    {
+        int i;
+        int j;
+        int k;
+        int l;
+        int i1;
+        int j1;
+        int k1;
+        int l1;
+        int i2;
+        boolean flag1;
+label0:
+        {
+            flag1 = q.d;
+            boolean flag = false;
+            l1 = i = j = k = l = i1 = j1 = k1 = 0x9e3779b9;
+            i2 = 0;
+            do
+            {
+                if(i2 >= 4)
+                    break;
+                l1 ^= i << 11;
+                k += l1;
+                i += j;
+                i ^= j >>> 2;
+                l += i;
+                j += k;
+                j ^= k << 8;
+                i1 += j;
+                k += l;
+                k ^= l >>> 16;
+                j1 += k;
+                l += i1;
+                l ^= i1 << 10;
+                k1 += l;
+                i1 += j1;
+                i1 ^= j1 >>> 4;
+                l1 += i1;
+                j1 += k1;
+                j1 ^= k1 << 8;
+                i += j1;
+                k1 += l1;
+                k1 ^= l1 >>> 9;
+                j += k1;
+                l1 += i;
+                i2++;
+                if(flag1)
+                    break label0;
+            } while(!flag1);
+            i2 = 0;
+        }
+label1:
+        {
+            do
+            {
+                if(i2 >= 256)
+                    break;
+                l1 += b[i2];
+                i += b[i2 + 1];
+                j += b[i2 + 2];
+                k += b[i2 + 3];
+                l += b[i2 + 4];
+                i1 += b[i2 + 5];
+                j1 += b[i2 + 6];
+                k1 += b[i2 + 7];
+                l1 ^= i << 11;
+                k += l1;
+                i += j;
+                i ^= j >>> 2;
+                l += i;
+                j += k;
+                j ^= k << 8;
+                i1 += j;
+                k += l;
+                k ^= l >>> 16;
+                j1 += k;
+                l += i1;
+                l ^= i1 << 10;
+                k1 += l;
+                i1 += j1;
+                i1 ^= j1 >>> 4;
+                l1 += i1;
+                j1 += k1;
+                j1 ^= k1 << 8;
+                i += j1;
+                k1 += l1;
+                k1 ^= l1 >>> 9;
+                j += k1;
+                l1 += i;
+                c[i2] = l1;
+                c[i2 + 1] = i;
+                c[i2 + 2] = j;
+                c[i2 + 3] = k;
+                c[i2 + 4] = l;
+                c[i2 + 5] = i1;
+                c[i2 + 6] = j1;
+                c[i2 + 7] = k1;
+                i2 += 8;
+                if(flag1)
+                    break label1;
+            } while(!flag1);
+            i2 = 0;
+        }
+label2:
+        {
+            do
+            {
+                if(i2 >= 256)
+                    break;
+                l1 += c[i2];
+                i += c[i2 + 1];
+                j += c[i2 + 2];
+                k += c[i2 + 3];
+                l += c[i2 + 4];
+                i1 += c[i2 + 5];
+                j1 += c[i2 + 6];
+                k1 += c[i2 + 7];
+                l1 ^= i << 11;
+                k += l1;
+                i += j;
+                i ^= j >>> 2;
+                l += i;
+                j += k;
+                j ^= k << 8;
+                i1 += j;
+                k += l;
+                k ^= l >>> 16;
+                j1 += k;
+                l += i1;
+                l ^= i1 << 10;
+                k1 += l;
+                i1 += j1;
+                i1 ^= j1 >>> 4;
+                l1 += i1;
+                j1 += k1;
+                j1 ^= k1 << 8;
+                i += j1;
+                k1 += l1;
+                k1 ^= l1 >>> 9;
+                j += k1;
+                l1 += i;
+                c[i2] = l1;
+                c[i2 + 1] = i;
+                c[i2 + 2] = j;
+                c[i2 + 3] = k;
+                c[i2 + 4] = l;
+                c[i2 + 5] = i1;
+                c[i2 + 6] = j1;
+                c[i2 + 7] = k1;
+                i2 += 8;
+                if(flag1)
+                    break label2;
+            } while(!flag1);
+            b();
+            a = 256;
+        }
+    }
+
     private int a;
-    private int[] b;
+    private int b[];
-    private int[] c;
+    private int c[];
     private int d;
     private int e;
     private int f;
-
-    public m(int[] nArray) {
-        block2: {
-            boolean bl = q.d;
-            this.c = new int[256];
-            this.b = new int[256];
-            for (int i2 = 0; i2 < nArray.length; ++i2) {
-                this.b[i2] = nArray[i2];
-                if (!bl) {
-                    if (!bl) continue;
 }
-                break block2;
-            }
-            this.c();
-        }
-    }
-
-    public final int a() {
-        int n2 = this.a;
-        int n3 = n2;
-        this.a = n2 - 1;
-        if (!q.d) {
-            if (n3 == 0) {
-                this.b();
-                this.a = 255;
-            }
-            n3 = this.b[this.a];
-        }
-        return n3;
-    }
-
-    private final void b() {
-        boolean bl = q.d;
-        boolean bl2 = false;
-        this.e += ++this.f;
-        for (int i2 = 0; i2 < 256; ++i2) {
-            int n2;
-            int n3 = this.c[i2];
-            if (!bl) {
-                switch (i2 & 3) {
-                    case 0: {
-                        this.d ^= this.d << 13;
-                        if (!bl) break;
-                    }
-                    case 1: {
-                        this.d ^= this.d >>> 6;
-                        if (!bl) break;
-                    }
-                    case 2: {
-                        this.d ^= this.d << 2;
-                        if (!bl) break;
-                    }
-                    case 3: {
-                        this.d ^= this.d >>> 16;
-                    }
-                }
-                this.d += this.c[i2 + 128 & 0xFF];
-            }
-            this.c[i2] = n2 = this.c[(n3 & 0x3FC) >> 2] + this.d + this.e;
-            this.b[i2] = this.e = this.c[(n2 >> 8 & 0x3FC) >> 2] + n3;
-            if (!bl) continue;
-        }
-    }
-
-    private final void c() {
-        block8: {
-            int n2;
-            int n3;
-            int n4;
-            int n5;
-            int n6;
-            int n7;
-            int n8;
-            int n9;
-            int n10;
-            boolean bl;
-            block7: {
-                block6: {
-                    bl = q.d;
-                    boolean bl2 = false;
-                    n10 = -1640531527;
-                    n9 = -1640531527;
-                    n8 = -1640531527;
-                    n7 = -1640531527;
-                    n6 = -1640531527;
-                    n5 = -1640531527;
-                    n4 = -1640531527;
-                    n3 = -1640531527;
-                    for (n2 = 0; n2 < 4; ++n2) {
-                        n6 += (n3 ^= n4 << 11);
-                        n4 += n5;
-                        n7 += (n4 ^= n5 >>> 2);
-                        n5 += n6;
-                        n8 += (n5 ^= n6 << 8);
-                        n6 += n7;
-                        n9 += (n6 ^= n7 >>> 16);
-                        n7 += n8;
-                        n10 += (n7 ^= n8 << 10);
-                        n8 += n9;
-                        n3 += (n8 ^= n9 >>> 4);
-                        n9 += n10;
-                        n4 += (n9 ^= n10 << 8);
-                        n10 += n3;
-                        n5 += (n10 ^= n3 >>> 9);
-                        n3 += n4;
-                        if (!bl) {
-                            if (!bl) continue;
-                        }
-                        break block6;
-                    }
-                    n2 = 0;
-                }
-                while (n2 < 256) {
-                    n3 += this.b[n2];
-                    n4 += this.b[n2 + 1];
-                    n5 += this.b[n2 + 2];
-                    n6 += this.b[n2 + 3];
-                    n7 += this.b[n2 + 4];
-                    n8 += this.b[n2 + 5];
-                    n9 += this.b[n2 + 6];
-                    n10 += this.b[n2 + 7];
-                    n6 += (n3 ^= n4 << 11);
-                    n4 += n5;
-                    n7 += (n4 ^= n5 >>> 2);
-                    n5 += n6;
-                    n8 += (n5 ^= n6 << 8);
-                    n6 += n7;
-                    n9 += (n6 ^= n7 >>> 16);
-                    n7 += n8;
-                    n10 += (n7 ^= n8 << 10);
-                    n8 += n9;
-                    n3 += (n8 ^= n9 >>> 4);
-                    n9 += n10;
-                    n4 += (n9 ^= n10 << 8);
-                    n10 += n3;
-                    n5 += (n10 ^= n3 >>> 9);
-                    this.c[n2] = n3 += n4;
-                    this.c[n2 + 1] = n4;
-                    this.c[n2 + 2] = n5;
-                    this.c[n2 + 3] = n6;
-                    this.c[n2 + 4] = n7;
-                    this.c[n2 + 5] = n8;
-                    this.c[n2 + 6] = n9;
-                    this.c[n2 + 7] = n10;
-                    n2 += 8;
-                    if (!bl) {
-                        if (!bl) continue;
-                    }
-                    break block7;
-                }
-                n2 = 0;
-            }
-            while (n2 < 256) {
-                n3 += this.c[n2];
-                n4 += this.c[n2 + 1];
-                n5 += this.c[n2 + 2];
-                n6 += this.c[n2 + 3];
-                n7 += this.c[n2 + 4];
-                n8 += this.c[n2 + 5];
-                n9 += this.c[n2 + 6];
-                n10 += this.c[n2 + 7];
-                n6 += (n3 ^= n4 << 11);
-                n4 += n5;
-                n7 += (n4 ^= n5 >>> 2);
-                n5 += n6;
-                n8 += (n5 ^= n6 << 8);
-                n6 += n7;
-                n9 += (n6 ^= n7 >>> 16);
-                n7 += n8;
-                n10 += (n7 ^= n8 << 10);
-                n8 += n9;
-                n3 += (n8 ^= n9 >>> 4);
-                n9 += n10;
-                n4 += (n9 ^= n10 << 8);
-                n10 += n3;
-                n5 += (n10 ^= n3 >>> 9);
-                this.c[n2] = n3 += n4;
-                this.c[n2 + 1] = n4;
-                this.c[n2 + 2] = n5;
-                this.c[n2 + 3] = n6;
-                this.c[n2 + 4] = n7;
-                this.c[n2 + 5] = n8;
-                this.c[n2 + 6] = n9;
-                this.c[n2 + 7] = n10;
-                n2 += 8;
-                if (!bl) {
-                    if (!bl) continue;
-                }
-                break block8;
-            }
-            this.b();
-            this.a = 256;
-        }
-    }
-}
-

n.java

@@ -1,79 +1,107 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
+// Source File Name:   n.java
+
 import java.math.BigInteger;
 import java.util.zip.CRC32;
 
-public class n {
+public class n
-    public byte[] a;
+{
+
+    private n()
+    {
+    }
+
+    public n(byte abyte0[])
+    {
+        a = abyte0;
+        b = 0;
+    }
+
+    public void a(int i)
+    {
+        a[b++] = (byte)i;
+    }
+
+    public void b(int i)
+    {
+        a[b++] = (byte)(i >> 24);
+        a[b++] = (byte)(i >> 16);
+        a[b++] = (byte)(i >> 8);
+        a[b++] = (byte)i;
+    }
+
+    public void a(String s)
+    {
+        s.getBytes(0, s.length(), a, b);
+        b += s.length();
+        a[b++] = 10;
+    }
+
+    public void a(byte abyte0[], int i, int j)
+    {
+        int k = i;
+        do
+        {
+            if(k >= i + j)
+                break;
+            a[b++] = abyte0[k];
+            k++;
+        } while(!q.d);
+    }
+
+    public int a()
+    {
+        return a[b++] & 0xff;
+    }
+
+    public int b()
+    {
+        b += 2;
+        return ((a[b - 2] & 0xff) << 8) + (a[b - 1] & 0xff);
+    }
+
+    public int c()
+    {
+        b += 4;
+        return ((a[b - 4] & 0xff) << 24) + ((a[b - 3] & 0xff) << 16) + ((a[b - 2] & 0xff) << 8) + (a[b - 1] & 0xff);
+    }
+
+    public void b(byte abyte0[], int i, int j)
+    {
+        int k = i;
+        do
+        {
+            if(k >= i + j)
+                break;
+            abyte0[k] = a[b++];
+            k++;
+        } while(!q.d);
+    }
+
+    public void a(BigInteger biginteger, BigInteger biginteger1)
+    {
+        int i = b;
+        b = 0;
+        byte abyte0[] = new byte[i];
+        b(abyte0, 0, i);
+        BigInteger biginteger2 = new BigInteger(abyte0);
+        BigInteger biginteger3 = biginteger2.modPow(biginteger, biginteger1);
+        byte abyte1[] = biginteger3.toByteArray();
+        b = 0;
+        a(abyte1.length);
+        a(abyte1, 0, abyte1.length);
+    }
+
+    public byte a[];
     public int b;
     static CRC32 c = new CRC32();
-    private static final int[] d = new int[]{0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, Short.MAX_VALUE, 65535, 131071, 262143, 524287, 1048575, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, Integer.MAX_VALUE, -1};
+    private static final int d[] = {
+        0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 
+        1023, 2047, 4095, 8191, 16383, 32767, 65535, 0x1ffff, 0x3ffff, 0x7ffff, 
+        0xfffff, 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff, 0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff, 0x1fffffff, 
+        0x3fffffff, 0x7fffffff, -1
+    };
 
-    private n() {
 }
-
-    public n(byte[] byArray) {
-        this.a = byArray;
-        this.b = 0;
-    }
-
-    public void a(int n2) {
-        this.a[this.b++] = (byte)n2;
-    }
-
-    public void b(int n2) {
-        this.a[this.b++] = (byte)(n2 >> 24);
-        this.a[this.b++] = (byte)(n2 >> 16);
-        this.a[this.b++] = (byte)(n2 >> 8);
-        this.a[this.b++] = (byte)n2;
-    }
-
-    public void a(String string) {
-        string.getBytes(0, string.length(), this.a, this.b);
-        this.b += string.length();
-        this.a[this.b++] = 10;
-    }
-
-    public void a(byte[] byArray, int n2, int n3) {
-        for (int i2 = n2; i2 < n2 + n3; ++i2) {
-            this.a[this.b++] = byArray[i2];
-            if (!q.d) continue;
-        }
-    }
-
-    public int a() {
-        return this.a[this.b++] & 0xFF;
-    }
-
-    public int b() {
-        this.b += 2;
-        return ((this.a[this.b - 2] & 0xFF) << 8) + (this.a[this.b - 1] & 0xFF);
-    }
-
-    public int c() {
-        this.b += 4;
-        return ((this.a[this.b - 4] & 0xFF) << 24) + ((this.a[this.b - 3] & 0xFF) << 16) + ((this.a[this.b - 2] & 0xFF) << 8) + (this.a[this.b - 1] & 0xFF);
-    }
-
-    public void b(byte[] byArray, int n2, int n3) {
-        for (int i2 = n2; i2 < n2 + n3; ++i2) {
-            byArray[i2] = this.a[this.b++];
-            if (!q.d) continue;
-        }
-    }
-
-    public void a(BigInteger bigInteger, BigInteger bigInteger2) {
-        int n2 = this.b;
-        this.b = 0;
-        byte[] byArray = new byte[n2];
-        this.b(byArray, 0, n2);
-        BigInteger bigInteger3 = new BigInteger(byArray);
-        BigInteger bigInteger4 = bigInteger3.modPow(bigInteger, bigInteger2);
-        byte[] byArray2 = bigInteger4.toByteArray();
-        this.b = 0;
-        this.a(byArray2.length);
-        this.a(byArray2, 0, byArray2.length);
-    }
-}
-

p.java

@@ -1,10 +1,18 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-public class p {
+// Source File Name:   p.java
+
+
+public class p
+{
+
+    public p()
+    {
+    }
+
     int a;
     int b;
     int c;
     int d;
 }
-

r.java

@@ -1,113 +1,99 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- * 
+// Decompiler options: packimports(3) 
- * Could not load the following classes:
+
- *  ahd
- *  java.applet.Applet
- */
 import java.applet.Applet;
 import java.net.Socket;
 
-public class r {
+public class r
+{
+
+    public static final void a(String s, byte abyte0[])
+    {
+        i[h] = s;
+        j[h] = abyte0;
+        h++;
+    }
+
+    public static final byte[] a(String s)
+    {
+        boolean flag = false;
+        return null;
+    }
+
+    public static final Socket a(int k)
+    {
+        c = k;
+        if(!q.d) goto _L2; else goto _L1
+_L1:
+        try
+        {
+            Thread.sleep(100L);
+        }
+        catch(Exception _ex) { }
+_L2:
+        if(c == 0)
+            return d;
+        if(true) goto _L1; else goto _L3
+_L3:
+    }
+
+    public static final void a(Runnable runnable)
+    {
+        runnable;
+        if(q.d) goto _L2; else goto _L1
+_L1:
+        e;
+        if(ahd.anl == 0) goto _L4; else goto _L3
+_L3:
+        try
+        {
+            Thread.sleep(100L);
+        }
+        catch(Exception _ex) { }
+_L4:
+        e;
+_L2:
+        JVM INSTR ifnonnull 16;
+           goto _L5 _L3
+_L5:
+    }
+
+    public static final String b(String s)
+    {
+        s;
+        if(q.d) goto _L2; else goto _L1
+_L1:
+        f;
+        if(ahd.anl == 0) goto _L4; else goto _L3
+_L3:
+        try
+        {
+            Thread.sleep(100L);
+        }
+        catch(Exception _ex) { }
+_L4:
+        f;
+_L2:
+        JVM INSTR ifnonnull 16;
+           goto _L5 _L3
+_L5:
+        return g;
+    }
+
+    public r()
+    {
+    }
+
     public static Applet a;
     public static int b;
     static int c;
     static Socket d;
-    static Runnable e;
+    static Runnable e = null;
-    static String f;
+    static String f = null;
     static String g;
     static int h;
-    private static String[] i;
+    private static String i[] = new String[50];
-    private static byte[][] j;
+    private static byte j[][] = new byte[50][];
 
-    public static final void a(String string, byte[] byArray) {
-        r.i[r.h] = string;
-        r.j[r.h] = byArray;
-        ++h;
 }
-
-    public static final byte[] a(String string) {
-        boolean bl = false;
-        return null;
-    }
-
-    /*
-     * Handled impossible loop by adding 'first' condition
-     * Enabled aggressive block sorting
-     * Enabled unnecessary exception pruning
-     * Enabled aggressive exception aggregation
-     */
-    public static final Socket a(int n2) {
-        c = n2;
-        boolean bl = true;
-        do {
-            if (bl && !(bl = false) && !q.d) continue;
-            try {
-                Thread.sleep(100L);
-            }
-            catch (Exception exception) {}
-        } while (c != 0);
-        return d;
-    }
-
-    /*
-     * Handled impossible loop by adding 'first' condition
-     * Enabled aggressive block sorting
-     * Enabled unnecessary exception pruning
-     * Enabled aggressive exception aggregation
-     */
-    public static final void a(Runnable runnable) {
-        Runnable runnable2 = runnable;
-        boolean bl = true;
-        do {
-            block5: {
-                block4: {
-                    if (!bl || (bl = false)) break block4;
-                    if (q.d) continue;
-                    e = runnable2;
-                    if (ahd.anl == 0) break block5;
-                }
-                try {
-                    Thread.sleep(100L);
-                }
-                catch (Exception exception) {}
-            }
-            runnable2 = e;
-        } while (runnable2 != null);
-    }
-
-    /*
-     * Handled impossible loop by adding 'first' condition
-     * Enabled aggressive block sorting
-     * Enabled unnecessary exception pruning
-     * Enabled aggressive exception aggregation
-     */
-    public static final String b(String string) {
-        String string2 = string;
-        boolean bl = true;
-        do {
-            block5: {
-                block4: {
-                    if (!bl || (bl = false)) break block4;
-                    if (q.d) continue;
-                    f = string2;
-                    if (ahd.anl == 0) break block5;
-                }
-                try {
-                    Thread.sleep(100L);
-                }
-                catch (Exception exception) {}
-            }
-            string2 = f;
-        } while (string2 != null);
-        return g;
-    }
-
-    static {
-        e = null;
-        f = null;
-        i = new String[50];
-        j = new byte[50][];
-    }
-}
-

v.java

@@ -1,7 +1,22 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-final class v {
+// Source File Name:   v.java
+
+
+final class v
+{
+
+    v()
+    {
+        m = new int[10];
+        n = new int[10];
+        o = new int[12];
+        x = -1;
+        G = false;
+        H = -1;
+    }
+
     public long a;
     public String b;
     public int c;
@@ -14,9 +29,9 @@ final class v {
     public int j;
     public int k;
     public int l;
-    public int[] m = new int[10];
+    public int m[];
-    public int[] n = new int[10];
+    public int n[];
-    public int[] o = new int[12];
+    public int o[];
     public String p;
     public int q;
     public int r;
@@ -25,7 +40,7 @@ final class v {
     public int u;
     public int v;
     public int w;
-    public int x = -1;
+    public int x;
     public int y;
     public int z;
     public int A;
@@ -34,11 +49,7 @@ final class v {
     public int D;
     public int E;
     public int F;
-    public boolean G = false;
+    public boolean G;
-    public int H = -1;
+    public int H;
     public int I;
-
-    v() {
 }
-}
-

w.java

@@ -1,17 +1,421 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
+// Source File Name:   w.java
+
 import java.io.IOException;
 
-public class w {
+public class w
+{
+
+    public void a(int ai[])
+    {
+        u = new m(ai);
+        v = new m(ai);
+    }
+
+    public void a()
+    {
+    }
+
+    public int b()
+        throws IOException
+    {
+        return h();
+    }
+
+    public long c()
+        throws IOException
+    {
+        long l1 = g();
+        long l2 = g();
+        long l3 = g();
+        long l4 = g();
+        return (l1 << 48) + (l2 << 32) + (l3 << 16) + l4;
+    }
+
+    public void a(int i1, int j1, byte abyte0[])
+        throws IOException
+    {
+    }
+
+    public int d()
+        throws IOException
+    {
+        return 0;
+    }
+
+    public int a(byte abyte0[])
+    {
+        boolean flag = q.d;
+        b++;
+        c;
+        if(flag) goto _L2; else goto _L1
+_L1:
+        if(c <= 0) goto _L4; else goto _L3
+_L3:
+        b;
+        if(flag) goto _L2; else goto _L5
+_L5:
+        c;
+        JVM INSTR icmple 67;
+           goto _L6 _L4
+_L6:
+        y = true;
+        C = E;
+        c += c;
+        return 0;
+_L4:
+        a;
+_L2:
+        if(flag) goto _L8; else goto _L7
+_L7:
+        JVM INSTR ifne 133;
+           goto _L9 _L10
+_L9:
+        d();
+        if(flag) goto _L8; else goto _L11
+_L11:
+        2;
+        JVM INSTR icmplt 133;
+           goto _L12 _L10
+_L12:
+        a = h();
+        a;
+        if(flag) goto _L8; else goto _L13
+_L13:
+        160;
+        JVM INSTR icmplt 133;
+           goto _L14 _L10
+_L14:
+        a = (a - 160) * 256 + h();
+_L10:
+        a;
+_L8:
+        if(flag) goto _L16; else goto _L15
+_L15:
+        JVM INSTR ifle 239;
+           goto _L17 _L18
+_L18:
+        break MISSING_BLOCK_LABEL_256;
+_L17:
+        d();
+_L16:
+        a;
+        if(flag) goto _L20; else goto _L19
+_L19:
+        JVM INSTR icmplt 239;
+           goto _L21 _L22
+_L22:
+        break MISSING_BLOCK_LABEL_256;
+_L21:
+        a;
+        '\240';
+_L20:
+        if(flag) goto _L24; else goto _L23
+_L23:
+        JVM INSTR icmplt 186;
+           goto _L25 _L26
+_L25:
+        a(a, abyte0);
+        if(!flag) goto _L27; else goto _L26
+_L26:
+        abyte0[a - 1] = (byte)h();
+        a;
+        if(flag) goto _L29; else goto _L28
+_L28:
+        true;
+_L24:
+        JVM INSTR icmple 222;
+           goto _L30 _L27
+_L30:
+        a(a - 1, abyte0);
+_L27:
+        a;
+_L29:
+        int i1;
+        i1;
+        a = 0;
+        b = 0;
+        return i1;
+        IOException ioexception;
+        ioexception;
+        y = true;
+        C = ioexception.getMessage();
+        return 0;
+    }
+
+    public void a(int i1)
+    {
+        g[e++] = (byte)(i1 >> 8);
+        g[e++] = (byte)i1;
+    }
+
+    public void b(int i1)
+    {
+        g[e++] = (byte)i1;
+    }
+
+    public void c(int i1)
+    {
+        g[e++] = (byte)(i1 >> 24);
+        g[e++] = (byte)(i1 >> 16);
+        g[e++] = (byte)(i1 >> 8);
+        g[e++] = (byte)i1;
+    }
+
+    public void a(byte abyte0[], int i1, int j1)
+    {
+        int k1 = 0;
+        do
+        {
+            if(k1 >= j1)
+                break;
+            g[e++] = abyte0[i1 + k1];
+            k1++;
+        } while(!q.d);
+    }
+
+    public int d(int i1)
+    {
+        return i1 - u.a() & 0xff;
+    }
+
+    public boolean e()
+    {
+        d;
+        if(q.d) goto _L2; else goto _L1
+_L1:
+        d > 0;
+_L2:
+        return;
+    }
+
+    public void f()
+    {
+        boolean flag = q.d;
+        this;
+        if(flag) goto _L2; else goto _L1
+_L1:
+        v;
+        JVM INSTR ifnull 52;
+           goto _L3 _L4
+_L3:
+        break MISSING_BLOCK_LABEL_15;
+_L4:
+        break MISSING_BLOCK_LABEL_52;
+        int i1 = g[d + 2] & 0xff;
+        g[d + 2] = (byte)(i1 + v.a());
+        this;
+_L2:
+        f;
+        8;
+        if(flag) goto _L6; else goto _L5
+_L5:
+        JVM INSTR icmpeq 75;
+           goto _L7 _L8
+_L7:
+        break MISSING_BLOCK_LABEL_65;
+_L8:
+        break MISSING_BLOCK_LABEL_75;
+        e++;
+        e - d;
+        2;
+_L6:
+        JVM INSTR isub ;
+        int j1;
+        j1;
+label0:
+        {
+            if(!flag)
+            {
+                if(j1 >= 160)
+                {
+                    g[d] = (byte)(160 + j1 / 256);
+                    g[d + 1] = (byte)(j1 & 0xff);
+                    if(!flag)
+                        break label0;
+                }
+                g[d] = (byte)j1;
+                e--;
+            }
+            g[d + 1] = g[e];
+        }
+        this;
+        if(flag) goto _L10; else goto _L9
+_L9:
+        A;
+        10000;
+        JVM INSTR icmpgt 235;
+           goto _L11 _L12
+_L11:
+        break MISSING_BLOCK_LABEL_193;
+_L12:
+        break MISSING_BLOCK_LABEL_235;
+        int k1 = g[d + 2] & 0xff;
+        x[k1]++;
+        z[k1] += e - d;
+        this;
+_L10:
+        e;
+        d;
+    }
+
+    public void a(long l1)
+    {
+        c((int)(l1 >> 32));
+        c((int)(l1 & -1L));
+    }
+
+    public int g()
+        throws IOException
+    {
+        int i1 = b();
+        int j1 = b();
+        return i1 * 256 + j1;
+    }
+
+    public void a(int i1, byte abyte0[])
+        throws IOException
+    {
+        a(i1, 0, abyte0);
+    }
+
+    public void e(int i1)
+    {
+        boolean flag = q.d;
+        this;
+        if(flag) goto _L2; else goto _L1
+_L1:
+        d;
+        (A * 4) / 5;
+        JVM INSTR icmple 45;
+           goto _L3 _L4
+_L3:
+        break MISSING_BLOCK_LABEL_23;
+_L4:
+        break MISSING_BLOCK_LABEL_45;
+        try
+        {
+            f(0);
+        }
+        catch(IOException ioexception)
+        {
+            y = true;
+            C = ioexception.getMessage();
+        }
+        this;
+_L2:
+        g;
+        if(flag) goto _L6; else goto _L5
+_L5:
+        JVM INSTR ifnonnull 66;
+           goto _L7 _L8
+_L7:
+        break MISSING_BLOCK_LABEL_56;
+_L8:
+        break MISSING_BLOCK_LABEL_66;
+        g = new byte[A];
+        g[d + 2] = (byte)i1;
+        g;
+_L6:
+        d + 3;
+        0;
+        JVM INSTR bastore ;
+        e = d + 3;
+        f = 8;
+        return;
+    }
+
+    public void a(String s1)
+    {
+        s1.getBytes(0, s1.length(), g, e);
+        e += s1.length();
+    }
+
+    public void f(int i1)
+        throws IOException
+    {
+        boolean flag = q.d;
+        y;
+        if(flag) goto _L2; else goto _L1
+_L1:
+        if(y)
+        {
+            d = 0;
+            e = 3;
+            y = false;
+            throw new IOException(C);
+        }
+        B++;
+        B;
+_L2:
+        if(flag) goto _L4; else goto _L3
+_L3:
+        i1;
+        JVM INSTR icmpge 65;
+           goto _L5 _L6
+_L5:
+        break MISSING_BLOCK_LABEL_64;
+_L6:
+        break MISSING_BLOCK_LABEL_65;
+        return;
+        this;
+        if(flag) goto _L8; else goto _L7
+_L7:
+        d;
+_L4:
+        JVM INSTR ifle 94;
+           goto _L9 _L10
+_L9:
+        break MISSING_BLOCK_LABEL_76;
+_L10:
+        break MISSING_BLOCK_LABEL_94;
+        B = 0;
+        b(g, 0, d);
+        d = 0;
+        this;
+_L8:
+        3;
+        e;
+    }
+
+    public void b(byte abyte0[], int i1, int j1)
+        throws IOException
+    {
+    }
+
+    public int h()
+        throws IOException
+    {
+        return 0;
+    }
+
+    public void i()
+        throws IOException
+    {
+        f();
+        f(0);
+    }
+
+    public w()
+    {
+        boolean flag = false;
+        e = 3;
+        f = 8;
+        y = false;
+        A = 5000;
+        C = "";
+    }
+
     protected int a;
     public int b;
     public int c;
     public int d;
     private int e;
     private int f;
-    public byte[] g;
+    public byte g[];
-    private static int[] h;
+    private static int h[];
     final int i = 61;
     final int j = 59;
     final int k = 42;
@@ -26,408 +430,111 @@ public class w {
     final int t = 34;
     public m u;
     public m v;
-    static char[] w;
+    static char w[];
-    public static int[] x;
+    public static int x[];
     protected boolean y;
-    public static int[] z;
+    public static int z[];
     protected int A;
     protected int B;
     protected String C;
     public static int D;
     private static String E;
 
-    public void a(int[] nArray) {
+    static 
-        this.u = new m(nArray);
-        this.v = new m(nArray);
-    }
-
-    public void a() {
-    }
-
-    public int b() throws IOException {
-        return this.h();
-    }
-
-    public long c() throws IOException {
-        long l2 = this.g();
-        long l3 = this.g();
-        long l4 = this.g();
-        long l5 = this.g();
-        return (l2 << 48) + (l3 << 32) + (l4 << 16) + l5;
-    }
-
-    public void a(int n2, int n3, byte[] byArray) throws IOException {
-    }
-
-    public int d() throws IOException {
-        return 0;
-    }
-
-    /*
-     * Unable to fully structure code
-     */
-    public int a(byte[] var1_1) {
-        block21: {
-            var3_2 = q.d;
-            try {
-                block27: {
-                    block26: {
-                        block24: {
-                            block25: {
-                                block22: {
-                                    block23: {
-                                        ++this.b;
-                                        v0 = this.c;
-                                        if (!var3_2) {
-                                            if (v0 > 0) {
-                                                v0 = this.b;
-                                                if (!var3_2) {
-                                                    if (v0 > this.c) {
-                                                        this.y = true;
-                                                        this.C = w.E;
-                                                        this.c += this.c;
-                                                        return 0;
-                                                    } else {
-                                                        ** GOTO lbl-1000
-                                                    }
-                                                }
-                                            } else lbl-1000:
-                                            // 3 sources
-
     {
-                                                v0 = this.a;
+        E = "!uwy\020:in";
-                                            }
+        break MISSING_BLOCK_LABEL_123;
-                                        }
+        local;
-                                        if (var3_2) break block22;
+        toCharArray();
-                                        if (v0 != 0) break block23;
+        JVM INSTR dup ;
-                                        v0 = this.d();
+        JVM INSTR arraylength .length;
-                                        if (var3_2) break block22;
+        JVM INSTR swap ;
-                                        if (v0 < 2) break block23;
+        int j1 = 0;
-                                        v0 = this.a = this.h();
+        JVM INSTR swap ;
-                                        if (var3_2) break block22;
+        JVM INSTR dup_x1 ;
-                                        if (v0 >= 160) {
+        1;
-                                            this.a = (this.a - 160) * 256 + this.h();
+        JVM INSTR icmpgt 102;
-                                        }
+           goto _L1 _L2
-                                    }
+_L1:
-                                    v0 = this.a;
+        JVM INSTR dup ;
-                                }
+        j1;
-                                if (!var3_2) {
+_L4:
-                                    if (v0 <= 0) break block21;
+        JVM INSTR dup2 ;
-                                    v0 = this.d();
+        JVM INSTR caload ;
-                                }
+        byte byte0;
-                                v1 = this.a;
+        switch(j1 % 5)
-                                if (!var3_2) {
+        {
-                                    if (v0 < v1) break block21;
+        case 0: // '\0'
-                                    v0 = this.a;
+            byte0 = 0x55;
-                                    v1 = 160;
+            break;
-                                }
-                                if (var3_2) break block24;
-                                if (v0 < v1) break block25;
-                                this.a(this.a, var1_1);
-                                if (!var3_2) break block26;
-                            }
-                            var1_1[this.a - 1] = (byte)this.h();
-                            v0 = this.a;
-                            if (var3_2) break block27;
-                            v1 = 1;
-                        }
-                        if (v0 > v1) {
-                            this.a(this.a - 1, var1_1);
-                        }
-                    }
-                    v0 = this.a;
-                }
-                var2_3 = v0;
-                this.a = 0;
-                this.b = 0;
-                return var2_3;
-            }
-            catch (IOException var2_4) {
-                this.y = true;
-                this.C = var2_4.getMessage();
-            }
-        }
-        return 0;
-    }
 
-    public void a(int n2) {
+        case 1: // '\001'
-        this.g[this.e++] = (byte)(n2 >> 8);
+            byte0 = 28;
-        this.g[this.e++] = (byte)n2;
+            break;
-    }
 
-    public void b(int n2) {
+        case 2: // '\002'
-        this.g[this.e++] = (byte)n2;
+            byte0 = 26;
-    }
+            break;
 
-    public void c(int n2) {
+        case 3: // '\003'
-        this.g[this.e++] = (byte)(n2 >> 24);
+            byte0 = 28;
-        this.g[this.e++] = (byte)(n2 >> 16);
+            break;
-        this.g[this.e++] = (byte)(n2 >> 8);
-        this.g[this.e++] = (byte)n2;
-    }
 
-    public void a(byte[] byArray, int n2, int n3) {
+        default:
-        for (int i2 = 0; i2 < n3; ++i2) {
+            byte0 = 61;
-            this.g[this.e++] = byArray[n2 + i2];
-            if (!q.d) continue;
-        }
-    }
-
-    public int d(int n2) {
-        return n2 - this.u.a() & 0xFF;
-    }
-
-    public boolean e() {
-        boolean bl = this.d;
-        if (!q.d) {
-            bl = bl > false;
-        }
-        return bl;
-    }
-
-    public void f() {
-        boolean bl;
-        block11: {
-            block9: {
-                int n2;
-                block10: {
-                    bl = q.d;
-                    w w2 = this;
-                    if (!bl) {
-                        if (w2.v != null) {
-                            n2 = this.g[this.d + 2] & 0xFF;
-                            this.g[this.d + 2] = (byte)(n2 + this.v.a());
-                        }
-                        w2 = this;
-                    }
-                    int n3 = w2.f;
-                    int n4 = 8;
-                    if (!bl) {
-                        if (n3 != n4) {
-                            ++this.e;
-                        }
-                        n3 = this.e - this.d;
-                        n4 = 2;
-                    }
-                    n2 = n3 - n4;
-                    if (bl) break block9;
-                    if (n2 < 160) break block10;
-                    this.g[this.d] = (byte)(160 + n2 / 256);
-                    this.g[this.d + 1] = (byte)(n2 & 0xFF);
-                    if (!bl) break block11;
-                }
-                this.g[this.d] = (byte)n2;
-                --this.e;
-            }
-            this.g[this.d + 1] = this.g[this.e];
-        }
-        w w3 = this;
-        if (!bl) {
-            if (w3.A <= 10000) {
-                int n5;
-                int n6 = n5 = this.g[this.d + 2] & 0xFF;
-                x[n6] = x[n6] + 1;
-                int n7 = n5;
-                z[n7] = z[n7] + (this.e - this.d);
-            }
-            w3 = this;
-        }
-        w3.d = this.e;
-    }
-
-    public void a(long l2) {
-        this.c((int)(l2 >> 32));
-        this.c((int)(l2 & 0xFFFFFFFFFFFFFFFFL));
-    }
-
-    public int g() throws IOException {
-        int n2 = this.b();
-        int n3 = this.b();
-        return n2 * 256 + n3;
-    }
-
-    public void a(int n2, byte[] byArray) throws IOException {
-        this.a(n2, 0, byArray);
-    }
-
-    public void e(int n2) {
-        boolean bl = q.d;
-        w w2 = this;
-        if (!bl) {
-            if (w2.d > this.A * 4 / 5) {
-                try {
-                    this.f(0);
-                }
-                catch (IOException iOException) {
-                    this.y = true;
-                    this.C = iOException.getMessage();
-                }
-            }
-            w2 = this;
-        }
-        byte[] byArray = w2.g;
-        if (!bl) {
-            if (byArray == null) {
-                this.g = new byte[this.A];
-            }
-            this.g[this.d + 2] = (byte)n2;
-            byArray = this.g;
-        }
-        byArray[this.d + 3] = 0;
-        this.e = this.d + 3;
-        this.f = 8;
-    }
-
-    public void a(String string) {
-        string.getBytes(0, string.length(), this.g, this.e);
-        this.e += string.length();
-    }
-
-    public void f(int n2) throws IOException {
-        block8: {
-            w w2;
-            int n3;
-            block7: {
-                boolean bl = q.d;
-                n3 = this.y;
-                if (!bl) {
-                    if (n3 != 0) {
-                        this.d = 0;
-                        this.e = 3;
-                        this.y = false;
-                        throw new IOException(this.C);
-                    }
-                    n3 = ++this.B;
-                }
-                if (bl) break block7;
-                if (n3 < n2) {
-                    return;
-                }
-                w2 = this;
-                if (bl) break block8;
-                n3 = w2.d;
-            }
-            if (n3 > 0) {
-                this.B = 0;
-                this.b(this.g, 0, this.d);
-            }
-            this.d = 0;
-            w2 = this;
-        }
-        w2.e = 3;
-    }
-
-    public void b(byte[] byArray, int n2, int n3) throws IOException {
-    }
-
-    public int h() throws IOException {
-        return 0;
-    }
-
-    public void i() throws IOException {
-        this.f();
-        this.f(0);
-    }
-
-    public w() {
-        boolean bl = false;
-        this.e = 3;
-        this.f = 8;
-        this.y = false;
-        this.A = 5000;
-        this.C = "";
-    }
-
-    /*
-     * Handled impossible loop by duplicating code
-     * Enabled aggressive block sorting
-     */
-    static {
-        char[] cArray;
-        block12: {
-            int n2;
-            int n3;
-            char[] cArray2;
-            int n4;
-            block11: {
-                Object var1 = null;
-                char[] cArray3 = "!uwy\u0010:in".toCharArray();
-                n4 = 0;
-                int n5 = cArray3.length;
-                cArray2 = cArray3;
-                n3 = n5;
-                if (n5 <= 1) break block11;
-                cArray = cArray2;
-                n2 = n3;
-                if (n3 <= n4) break block12;
-            }
-            do {
-                char[] cArray4 = cArray2;
-                char[] cArray5 = cArray2;
-                int n6 = n4;
-                while (true) {
-                    int n7;
-                    char c2 = cArray4[n6];
-                    switch (n4 % 5) {
-                        case 0: {
-                            n7 = 85;
             break;
         }
-                        case 1: {
+        byte0;
-                            n7 = 28;
+        JVM INSTR ixor ;
-                            break;
+        (char);
-                        }
+        JVM INSTR castore ;
-                        case 2: {
+        j1++;
-                            n7 = 26;
+        JVM INSTR swap ;
-                            break;
+        JVM INSTR dup_x1 ;
-                        }
+        JVM INSTR ifne 102;
-                        case 3: {
+           goto _L3 _L2
-                            n7 = 28;
+_L3:
-                            break;
+        JVM INSTR dup2 ;
-                        }
+        JVM INSTR swap ;
-                        default: {
+          goto _L4
-                            n7 = 61;
+_L2:
-                        }
+        JVM INSTR swap ;
-                    }
+        JVM INSTR dup_x1 ;
-                    cArray4[n6] = (char)(c2 ^ n7);
+        j1;
-                    ++n4;
+        JVM INSTR icmpgt 26;
-                    cArray2 = cArray5;
+           goto _L5 _L1
-                    n3 = n3;
+_L5:
-                    if (n3 != 0) break;
+        JVM INSTR new #169 <Class String>;
-                    cArray5 = cArray2;
+        JVM INSTR dup_x1 ;
-                    n2 = n3;
+        JVM INSTR swap ;
-                    n6 = n3;
+        String();
-                    cArray4 = cArray2;
+        intern();
-                }
+        JVM INSTR swap ;
-                cArray = cArray2;
+        JVM INSTR pop ;
-                n2 = n3;
+        JVM INSTR ret 1;
-            } while (n3 > n4);
+        h = (new int[] {
-        }
+            0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 
-        E = new String(cArray).intern();
+            1023, 2047, 4095, 8191, 16383, 32767, 65535, 0x1ffff, 0x3ffff, 0x7ffff, 
-        h = new int[]{0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, Short.MAX_VALUE, 65535, 131071, 262143, 524287, 1048575, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, Integer.MAX_VALUE, -1};
+            0xfffff, 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff, 0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff, 0x1fffffff, 
+            0x3fffffff, 0x7fffffff, -1
+        });
         x = new int[256];
         z = new int[256];
         w = new char[256];
-        int n8 = 0;
+        for(int i1 = 0; i1 < 256; i1++)
-        while (true) {
+            w[i1] = (char)i1;
-            if (n8 >= 256) {
-                w.w[61] = 61;
-                w.w[59] = 59;
-                w.w[42] = 42;
-                w.w[43] = 43;
-                w.w[44] = 44;
-                w.w[45] = 45;
-                w.w[46] = 46;
-                w.w[47] = 47;
-                w.w[92] = 92;
-                w.w[124] = 124;
-                w.w[33] = 33;
-                w.w[34] = 34;
-                return;
-            }
-            w.w[n8] = (char)n8;
-            ++n8;
-        }
-    }
-}
 
+        w[61] = '=';
+        w[59] = ';';
+        w[42] = '*';
+        w[43] = '+';
+        w[44] = ',';
+        w[45] = '-';
+        w[46] = '.';
+        w[47] = '/';
+        w[92] = '\\';
+        w[124] = '|';
+        w[33] = '!';
+        w[34] = '"';
+    }
+}

x.java

@@ -1,486 +1,378 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-import java.io.IOException;
+// Source File Name:   x.java
-import java.io.InputStream;
+
-import java.io.OutputStream;
+import java.io.*;
 import java.net.Socket;
 
-public class x
+public class x extends w
-extends w
+    implements Runnable
-implements Runnable {
+{
+
+    public x(Socket socket, a a1)
+        throws IOException
+    {
+        H = false;
+        L = true;
+        G = socket;
+        E = socket.getInputStream();
+        F = socket.getOutputStream();
+        L = false;
+        a1.a(this);
+    }
+
+    public void a()
+    {
+        boolean flag;
+        flag = q.d;
+        super.a();
+        H = true;
+        this;
+        if(flag) goto _L2; else goto _L1
+_L1:
+        E;
+        JVM INSTR ifnull 31;
+           goto _L3 _L4
+_L3:
+        E.close();
+_L4:
+        this;
+_L2:
+        if(flag) goto _L6; else goto _L5
+_L5:
+        F;
+        JVM INSTR ifnull 49;
+           goto _L7 _L8
+_L7:
+        F.close();
+_L8:
+        this;
+_L6:
+        G;
+        if(flag) goto _L10; else goto _L9
+_L9:
+        JVM INSTR ifnull 67;
+           goto _L11 _L12
+_L12:
+        break MISSING_BLOCK_LABEL_82;
+_L11:
+        G;
+_L10:
+        close();
+        break MISSING_BLOCK_LABEL_82;
+        IOException ioexception;
+        ioexception;
+        System.out.println(M[1]);
+        L = true;
+        synchronized(this)
+        {
+            notify();
+        }
+        I = null;
+        return;
+    }
+
+    public int h()
+        throws IOException
+    {
+        H;
+        if(q.d) goto _L2; else goto _L1
+_L1:
+        if(H)
+            return 0;
+        E.read();
+_L2:
+        return;
+    }
+
+    public int d()
+        throws IOException
+    {
+        H;
+        if(q.d) goto _L2; else goto _L1
+_L1:
+        if(H)
+            return 0;
+        E.available();
+_L2:
+        return;
+    }
+
+    public void a(int i, int j, byte abyte0[])
+        throws IOException
+    {
+        boolean flag1 = q.d;
+        H;
+        if(flag1) goto _L2; else goto _L1
+_L1:
+        if(H)
+            return;
+        false;
+_L2:
+        int k;
+        k;
+        boolean flag = false;
+_L8:
+        if(k >= i)
+            break; /* Loop/switch isn't completed */
+        int l = E.read(abyte0, k + j, i - k);
+        if(flag1) goto _L4; else goto _L3
+_L3:
+        JVM INSTR ifgt 70;
+           goto _L5 _L6
+_L5:
+        break MISSING_BLOCK_LABEL_57;
+_L6:
+        break MISSING_BLOCK_LABEL_70;
+        throw new IOException(M[0]);
+        k + l;
+_L4:
+        k;
+        if(!flag1) goto _L8; else goto _L7
+_L7:
+    }
+
+    public void b(byte abyte0[], int i, int j)
+        throws IOException
+    {
+        boolean flag = q.d;
+        this;
+        if(flag) goto _L2; else goto _L1
+_L1:
+        H;
+        JVM INSTR ifeq 18;
+           goto _L3 _L4
+_L3:
+        break MISSING_BLOCK_LABEL_17;
+_L4:
+        break MISSING_BLOCK_LABEL_18;
+        return;
+        this;
+_L2:
+        if(flag) goto _L6; else goto _L5
+_L5:
+        I;
+        JVM INSTR ifnonnull 39;
+           goto _L7 _L8
+_L7:
+        break MISSING_BLOCK_LABEL_30;
+_L8:
+        break MISSING_BLOCK_LABEL_39;
+        I = new byte[5000];
+        this;
+_L6:
+        JVM INSTR dup ;
+        x x1;
+        x1;
+        JVM INSTR monitorenter ;
+        int k = 0;
+_L14:
+        if(k >= j)
+            break; /* Loop/switch isn't completed */
+        I[K] = abyte0[k + i];
+        K = (K + 1) % 5000;
+        if(flag)
+            continue; /* Loop/switch isn't completed */
+        this;
+        if(flag) goto _L10; else goto _L9
+_L9:
+        K;
+        (J + 4900) % 5000;
+        JVM INSTR icmpne 124;
+           goto _L11 _L12
+_L11:
+        throw new IOException(M[3]);
+_L12:
+        k++;
+        if(!flag) goto _L14; else goto _L13
+_L13:
+        notify();
+        x1;
+_L10:
+        JVM INSTR monitorexit ;
+          goto _L15
+        Exception exception;
+        exception;
+        throw exception;
+_L15:
+    }
+
+    public void run()
+    {
+        boolean flag1;
+        flag1 = q.d;
+        boolean flag = false;
+_L15:
+        if(L)
+            break; /* Loop/switch isn't completed */
+        x x1 = this;
+        JVM INSTR monitorenter ;
+        K;
+        if(flag1) goto _L2; else goto _L1
+_L1:
+        J;
+        JVM INSTR icmpne 44;
+           goto _L3 _L4
+_L3:
+        wait();
+          goto _L4
+        InterruptedException interruptedexception;
+        interruptedexception;
+_L4:
+        L;
+_L2:
+        if(flag1) goto _L6; else goto _L5
+_L5:
+        JVM INSTR ifeq 60;
+           goto _L7 _L8
+_L7:
+        return;
+_L8:
+        J;
+_L6:
+        int j;
+        j;
+        K;
+        J;
+        if(flag1) goto _L10; else goto _L9
+_L9:
+        JVM INSTR icmplt 96;
+           goto _L11 _L12
+_L11:
+        int i = K - J;
+        if(!flag1) goto _L13; else goto _L12
+_L12:
+        '\u1388';
+        J;
+_L10:
+        JVM INSTR isub ;
+        i;
+          goto _L13
+        Exception exception;
+        exception;
+        throw exception;
+_L13:
+        if(i <= 0) goto _L15; else goto _L14
+_L14:
+        try
+        {
+            F.write(I, j, i);
+        }
+        catch(IOException ioexception)
+        {
+            super.y = true;
+            super.C = M[2] + ioexception;
+        }
+        J = (J + i) % 5000;
+        this;
+        if(flag1) goto _L17; else goto _L16
+_L16:
+        K;
+        J;
+        JVM INSTR icmpne 210;
+           goto _L18 _L15
+_L18:
+        this;
+_L17:
+        F;
+        flush();
+          goto _L15
+        IOException ioexception1;
+        ioexception1;
+        super.y = true;
+        super.C = M[2] + ioexception1;
+        if(!flag1) goto _L15; else goto _L19
+_L19:
+    }
+
     private InputStream E;
     private OutputStream F;
     private Socket G;
-    private boolean H = false;
+    private boolean H;
-    private byte[] I;
+    private byte I[];
     private int J;
     private int K;
-    private boolean L = true;
+    private boolean L;
-    private static String[] M;
+    private static String M[];
 
-    public x(Socket socket, a a2) throws IOException {
+    static 
-        this.G = socket;
+    {
-        this.E = socket.getInputStream();
+        String as[];
-        this.F = socket.getOutputStream();
+        as = new String[4];
-        this.L = false;
+        as[0] = "\005\023|";
-        a2.a(this);
+        as[1] = "\005.H3y`?V3x)2]|x4._=f";
-    }
+        as[2] = "\024+H5\177%.\0";
+        as[3] = "\")\\:n2|U*n2:V3|";
+        M = as;
+        break MISSING_BLOCK_LABEL_155;
+        local;
+        toCharArray();
+        JVM INSTR dup ;
+        JVM INSTR arraylength .length;
+        JVM INSTR swap ;
+        int i = 0;
+        JVM INSTR swap ;
+        JVM INSTR dup_x1 ;
+        1;
+        JVM INSTR icmpgt 134;
+           goto _L1 _L2
+_L1:
+        JVM INSTR dup ;
+        i;
+_L4:
+        JVM INSTR dup2 ;
+        JVM INSTR caload ;
+        byte byte0;
+        switch(i % 5)
+        {
+        case 0: // '\0'
+            byte0 = 0x40;
+            break;
 
-    /*
+        case 1: // '\001'
-     * WARNING - Removed try catching itself - possible behaviour change.
+            byte0 = 92;
-     */
+            break;
-    public void a() {
-        block11: {
-            boolean bl = q.d;
-            super.a();
-            this.H = true;
-            try {
-                x x2 = this;
-                if (!bl) {
-                    if (x2.E != null) {
-                        this.E.close();
-                    }
-                    x2 = this;
-                }
-                if (!bl) {
-                    if (x2.F != null) {
-                        this.F.close();
-                    }
-                    x2 = this;
-                }
-                Socket socket = x2.G;
-                if (!bl) {
-                    if (socket == null) break block11;
-                    socket = this.G;
-                }
-                socket.close();
-            }
-            catch (IOException iOException) {
-                System.out.println(M[1]);
-            }
-        }
-        this.L = true;
-        x x3 = this;
-        synchronized (x3) {
-            this.notify();
-        }
-        this.I = null;
-    }
 
-    public int h() throws IOException {
+        case 2: // '\002'
-        int n2 = this.H;
+            byte0 = 58;
-        if (!q.d) {
+            break;
-            if (n2 != 0) {
-                return 0;
-            }
-            n2 = this.E.read();
-        }
-        return n2;
-    }
 
-    public int d() throws IOException {
+        case 3: // '\003'
-        int n2 = this.H;
+            byte0 = 92;
-        if (!q.d) {
+            break;
-            if (n2 != 0) {
-                return 0;
-            }
-            n2 = this.E.available();
-        }
-        return n2;
-    }
 
-    public void a(int n2, int n3, byte[] byArray) throws IOException {
+        default:
-        boolean bl = q.d;
+            byte0 = 11;
-        int n4 = this.H;
-        if (!bl) {
-            if (n4 != 0) {
-                return;
-            }
-            n4 = 0;
-        }
-        int n5 = n4;
-        boolean bl2 = false;
-        while (n5 < n2) {
-            int n6 = this.E.read(byArray, n5 + n3, n2 - n5);
-            if (!bl) {
-                int n7;
-                if (n6 <= 0) {
-                    throw new IOException(M[0]);
-                }
-                n6 = n5 = n5 + n7;
-            }
-            if (!bl) continue;
-        }
-    }
-
-    /*
-     * WARNING - Removed try catching itself - possible behaviour change.
-     */
-    public void b(byte[] byArray, int n2, int n3) throws IOException {
-        boolean bl = q.d;
-        x x2 = this;
-        if (!bl) {
-            if (x2.H) {
-                return;
-            }
-            x2 = this;
-        }
-        if (!bl) {
-            if (x2.I == null) {
-                this.I = new byte[5000];
-            }
-            x2 = this;
-        }
-        x x3 = x2;
-        synchronized (x2) {
-            block11: {
-                x x4;
-                int n4 = 0;
-                while (n4 < n3) {
-                    this.I[this.K] = byArray[n4 + n2];
-                    this.K = (this.K + 1) % 5000;
-                    if (!bl) {
-                        x4 = this;
-                        if (bl) break block11;
-                        if (x4.K == (this.J + 4900) % 5000) {
-                            throw new IOException(M[3]);
-                        }
-                        ++n4;
-                    }
-                    if (!bl) continue;
-                }
-                this.notify();
-                x4 = x3;
-            }
-            // ** MonitorExit[v1] (shouldn't be in output)
-            return;
-        }
-    }
-
-    /*
-     * WARNING - Removed try catching itself - possible behaviour change.
-     */
-    public void run() {
-        boolean bl = q.d;
-        boolean bl2 = false;
-        while (!this.L) {
-            int n2;
-            int n3;
-            block21: {
-                x x2 = this;
-                synchronized (x2) {
-                    int n4;
-                    int n5;
-                    block19: {
-                        block20: {
-                            int n6 = this.K;
-                            if (!bl) {
-                                if (n6 == this.J) {
-                                    try {
-                                        this.wait();
-                                    }
-                                    catch (InterruptedException interruptedException) {
-                                        // empty catch block
-                                    }
-                                }
-                                n6 = this.L ? 1 : 0;
-                            }
-                            if (!bl) {
-                                if (n6 != 0) {
-                                    return;
-                                }
-                                n6 = this.J;
-                            }
-                            n3 = n6;
-                            n5 = this.K;
-                            n4 = this.J;
-                            if (bl) break block19;
-                            if (n5 < n4) break block20;
-                            n2 = this.K - this.J;
-                            if (!bl) break block21;
-                        }
-                        n5 = 5000;
-                        n4 = this.J;
-                    }
-                    n2 = n5 - n4;
-                }
-            }
-            if (n2 <= 0) continue;
-            try {
-                this.F.write(this.I, n3, n2);
-            }
-            catch (IOException iOException) {
-                this.y = true;
-                this.C = M[2] + iOException;
-            }
-            this.J = (this.J + n2) % 5000;
-            try {
-                x x3 = this;
-                if (!bl) {
-                    if (x3.K != this.J) continue;
-                    x3 = this;
-                }
-                x3.F.flush();
-            }
-            catch (IOException iOException) {
-                this.y = true;
-                this.C = M[2] + iOException;
-                if (!bl) continue;
-            }
-        }
-    }
-
-    /*
-     * Handled impossible loop by duplicating code
-     * Enabled aggressive block sorting
-     */
-    static {
-        char[] cArray;
-        String[] stringArray;
-        block43: {
-            int n2;
-            int n3;
-            char[] cArray2;
-            int n4;
-            block42: {
-                char[] cArray3;
-                Object var0;
-                block41: {
-                    int n5;
-                    int n6;
-                    char[] cArray4;
-                    block40: {
-                        char[] cArray5;
-                        block39: {
-                            int n7;
-                            int n8;
-                            char[] cArray6;
-                            block38: {
-                                char[] cArray7;
-                                block37: {
-                                    int n9;
-                                    int n10;
-                                    char[] cArray8;
-                                    block36: {
-                                        stringArray = new String[4];
-                                        var0 = null;
-                                        char[] cArray9 = "\u0005\u0013|".toCharArray();
-                                        n4 = 0;
-                                        int n11 = cArray9.length;
-                                        cArray8 = cArray9;
-                                        n10 = n11;
-                                        if (n11 <= 1) break block36;
-                                        cArray7 = cArray8;
-                                        n9 = n10;
-                                        if (n10 <= n4) break block37;
-                                    }
-                                    do {
-                                        char[] cArray10 = cArray8;
-                                        char[] cArray11 = cArray8;
-                                        int n12 = n4;
-                                        while (true) {
-                                            int n13;
-                                            char c2 = cArray10[n12];
-                                            switch (n4 % 5) {
-                                                case 0: {
-                                                    n13 = 64;
             break;
         }
-                                                case 1: {
+        byte0;
-                                                    n13 = 92;
+        JVM INSTR ixor ;
-                                                    break;
+        (char);
-                                                }
+        JVM INSTR castore ;
-                                                case 2: {
+        i++;
-                                                    n13 = 58;
+        JVM INSTR swap ;
-                                                    break;
+        JVM INSTR dup_x1 ;
-                                                }
+        JVM INSTR ifne 134;
-                                                case 3: {
+           goto _L3 _L2
-                                                    n13 = 92;
+_L3:
-                                                    break;
+        JVM INSTR dup2 ;
-                                                }
+        JVM INSTR swap ;
-                                                default: {
+          goto _L4
-                                                    n13 = 11;
+_L2:
+        JVM INSTR swap ;
+        JVM INSTR dup_x1 ;
+        i;
+        JVM INSTR icmpgt 57;
+           goto _L5 _L1
+_L5:
+        JVM INSTR new #157 <Class String>;
+        JVM INSTR dup_x1 ;
+        JVM INSTR swap ;
+        String();
+        intern();
+        JVM INSTR swap ;
+        JVM INSTR pop ;
+        JVM INSTR ret 0;
     }
 }
-                                            cArray10[n12] = (char)(c2 ^ n13);
-                                            ++n4;
-                                            cArray8 = cArray11;
-                                            n10 = n10;
-                                            if (n10 != 0) break;
-                                            cArray11 = cArray8;
-                                            n9 = n10;
-                                            n12 = n10;
-                                            cArray10 = cArray8;
-                                        }
-                                        cArray7 = cArray8;
-                                        n9 = n10;
-                                    } while (n10 > n4);
-                                }
-                                stringArray[0] = new String(cArray7).intern();
-                                var0 = null;
-                                char[] cArray12 = "\u0005.H3y`?V3x)2]|x4._=f".toCharArray();
-                                n4 = 0;
-                                int n14 = cArray12.length;
-                                cArray6 = cArray12;
-                                n8 = n14;
-                                if (n14 <= 1) break block38;
-                                cArray5 = cArray6;
-                                n7 = n8;
-                                if (n8 <= n4) break block39;
-                            }
-                            do {
-                                char[] cArray13 = cArray6;
-                                char[] cArray14 = cArray6;
-                                int n15 = n4;
-                                while (true) {
-                                    int n16;
-                                    char c3 = cArray13[n15];
-                                    switch (n4 % 5) {
-                                        case 0: {
-                                            n16 = 64;
-                                            break;
-                                        }
-                                        case 1: {
-                                            n16 = 92;
-                                            break;
-                                        }
-                                        case 2: {
-                                            n16 = 58;
-                                            break;
-                                        }
-                                        case 3: {
-                                            n16 = 92;
-                                            break;
-                                        }
-                                        default: {
-                                            n16 = 11;
-                                        }
-                                    }
-                                    cArray13[n15] = (char)(c3 ^ n16);
-                                    ++n4;
-                                    cArray6 = cArray14;
-                                    n8 = n8;
-                                    if (n8 != 0) break;
-                                    cArray14 = cArray6;
-                                    n7 = n8;
-                                    n15 = n8;
-                                    cArray13 = cArray6;
-                                }
-                                cArray5 = cArray6;
-                                n7 = n8;
-                            } while (n8 > n4);
-                        }
-                        stringArray[1] = new String(cArray5).intern();
-                        var0 = null;
-                        char[] cArray15 = "\u0014+H5\u007f%.\u0000".toCharArray();
-                        n4 = 0;
-                        int n17 = cArray15.length;
-                        cArray4 = cArray15;
-                        n6 = n17;
-                        if (n17 <= 1) break block40;
-                        cArray3 = cArray4;
-                        n5 = n6;
-                        if (n6 <= n4) break block41;
-                    }
-                    do {
-                        char[] cArray16 = cArray4;
-                        char[] cArray17 = cArray4;
-                        int n18 = n4;
-                        while (true) {
-                            int n19;
-                            char c4 = cArray16[n18];
-                            switch (n4 % 5) {
-                                case 0: {
-                                    n19 = 64;
-                                    break;
-                                }
-                                case 1: {
-                                    n19 = 92;
-                                    break;
-                                }
-                                case 2: {
-                                    n19 = 58;
-                                    break;
-                                }
-                                case 3: {
-                                    n19 = 92;
-                                    break;
-                                }
-                                default: {
-                                    n19 = 11;
-                                }
-                            }
-                            cArray16[n18] = (char)(c4 ^ n19);
-                            ++n4;
-                            cArray4 = cArray17;
-                            n6 = n6;
-                            if (n6 != 0) break;
-                            cArray17 = cArray4;
-                            n5 = n6;
-                            n18 = n6;
-                            cArray16 = cArray4;
-                        }
-                        cArray3 = cArray4;
-                        n5 = n6;
-                    } while (n6 > n4);
-                }
-                stringArray[2] = new String(cArray3).intern();
-                var0 = null;
-                char[] cArray18 = "\")\\:n2|U*n2:V3|".toCharArray();
-                n4 = 0;
-                int n20 = cArray18.length;
-                cArray2 = cArray18;
-                n3 = n20;
-                if (n20 <= 1) break block42;
-                cArray = cArray2;
-                n2 = n3;
-                if (n3 <= n4) break block43;
-            }
-            do {
-                char[] cArray19 = cArray2;
-                char[] cArray20 = cArray2;
-                int n21 = n4;
-                while (true) {
-                    int n22;
-                    char c5 = cArray19[n21];
-                    switch (n4 % 5) {
-                        case 0: {
-                            n22 = 64;
-                            break;
-                        }
-                        case 1: {
-                            n22 = 92;
-                            break;
-                        }
-                        case 2: {
-                            n22 = 58;
-                            break;
-                        }
-                        case 3: {
-                            n22 = 92;
-                            break;
-                        }
-                        default: {
-                            n22 = 11;
-                        }
-                    }
-                    cArray19[n21] = (char)(c5 ^ n22);
-                    ++n4;
-                    cArray2 = cArray20;
-                    n3 = n3;
-                    if (n3 != 0) break;
-                    cArray20 = cArray2;
-                    n2 = n3;
-                    n21 = n3;
-                    cArray19 = cArray2;
-                }
-                cArray = cArray2;
-                n2 = n3;
-            } while (n3 > n4);
-        }
-        stringArray[3] = new String(cArray).intern();
-        M = stringArray;
-    }
-}
-

z.java

@@ -1,677 +1,170 @@
-/*
+// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
- * Decompiled with CFR 0.152.
+// Jad home page: http://www.geocities.com/kpdus/jad.html
- */
+// Decompiler options: packimports(3) 
-public class z {
+// Source File Name:   z.java
-    public static String[] a;
-    public static int b;
 
-    public static String a() {
+
+public class z
+{
+
+    public z()
+    {
+    }
+
+    public static String a()
+    {
         return a[b - 29];
     }
 
-    public static int b() {
+    public static int b()
-        int n2;
+    {
-        block4: {
+        boolean flag = q.d;
-            block5: {
+        b;
-                int n3;
+        if(flag) goto _L2; else goto _L1
-                block2: {
+_L1:
-                    block3: {
+        29;
-                        boolean bl = q.d;
+        JVM INSTR icmpeq 52;
-                        n3 = b;
+           goto _L3 _L4
-                        if (bl) break block2;
+_L3:
-                        if (n3 == 29) break block3;
+        b;
-                        n3 = b;
+        if(flag) goto _L2; else goto _L5
-                        if (bl) break block2;
+_L5:
-                        if (n3 == 31) break block3;
+        31;
-                        n3 = b;
+        JVM INSTR icmpeq 52;
-                        if (bl) break block2;
+           goto _L6 _L4
-                        if (n3 == 33) break block3;
+_L6:
-                        n2 = b;
+        b;
-                        if (bl) break block4;
+        if(flag) goto _L2; else goto _L7
-                        if (n2 != 37) break block5;
+_L7:
-                    }
+        33;
-                    n3 = 43594;
+        JVM INSTR icmpeq 52;
-                }
+           goto _L8 _L4
-                return n3;
+_L8:
-            }
+        b;
-            n2 = 43595;
+        if(flag) goto _L10; else goto _L9
-        }
+_L9:
-        return n2;
+        37;
+        JVM INSTR icmpne 55;
+           goto _L4 _L11
+_L4:
+        43594;
+_L2:
+        return;
+_L11:
+        43595;
+_L10:
+        return;
     }
 
-    public static void a(int n2) {
+    public static void a(int i)
-        block3: {
+    {
-            int n3;
+        boolean flag = q.d;
-            block4: {
+        i;
-                int n4;
+        28;
-                block2: {
+        if(flag) goto _L2; else goto _L1
-                    boolean bl = q.d;
+_L1:
-                    n3 = n2;
+        JVM INSTR icmple 28;
-                    n4 = 28;
+           goto _L3 _L4
-                    if (bl) break block2;
+_L3:
-                    if (n3 <= n4) break block3;
+        i;
-                    n3 = n2;
+        if(flag) goto _L6; else goto _L5
-                    if (bl) break block4;
+_L5:
-                    n4 = 39;
+        39;
-                }
+_L2:
-                if (n3 >= n4) break block3;
+        JVM INSTR icmpge 28;
-                n3 = n2;
+           goto _L7 _L4
-            }
+_L7:
-            b = n3;
+        i;
-        }
+_L6:
+        b;
+_L4:
     }
 
-    /*
+    public static String a[];
-     * Handled impossible loop by duplicating code
+    public static int b;
-     * Enabled aggressive block sorting
+
-     */
+    static 
-    static {
+    {
-        char[] cArray;
+        local;
-        String[] stringArray;
+        toCharArray();
-        block109: {
+        JVM INSTR dup ;
-            int n2;
+        JVM INSTR arraylength .length;
-            int n3;
+        JVM INSTR swap ;
-            char[] cArray2;
+        int i = 0;
-            int n4;
+        JVM INSTR swap ;
-            block108: {
+        JVM INSTR dup_x1 ;
-                char[] cArray3;
+        1;
-                Object var0;
+        JVM INSTR icmpgt 94;
-                block107: {
+           goto _L1 _L2
-                    int n5;
+_L1:
-                    int n6;
+        JVM INSTR dup ;
-                    char[] cArray4;
+        i;
-                    block106: {
+_L4:
-                        char[] cArray5;
+        JVM INSTR dup2 ;
-                        block105: {
+        JVM INSTR caload ;
-                            int n7;
+        byte byte0;
-                            int n8;
+        switch(i % 5)
-                            char[] cArray6;
+        {
-                            block104: {
+        case 0: // '\0'
-                                char[] cArray7;
+            byte0 = 0x3b;
-                                block103: {
+            break;
-                                    int n9;
+
-                                    int n10;
+        case 1: // '\001'
-                                    char[] cArray8;
+            byte0 = 52;
-                                    block102: {
+            break;
-                                        char[] cArray9;
+
-                                        block101: {
+        case 2: // '\002'
-                                            int n11;
+            byte0 = 111;
-                                            int n12;
+            break;
-                                            char[] cArray10;
+
-                                            block100: {
+        case 3: // '\003'
-                                                char[] cArray11;
+            byte0 = 85;
-                                                block99: {
+            break;
-                                                    int n13;
+
-                                                    int n14;
+        default:
-                                                    char[] cArray12;
+            byte0 = 99;
-                                                    block98: {
-                                                        char[] cArray13;
-                                                        block97: {
-                                                            int n15;
-                                                            int n16;
-                                                            char[] cArray14;
-                                                            block96: {
-                                                                char[] cArray15;
-                                                                block95: {
-                                                                    int n17;
-                                                                    int n18;
-                                                                    char[] cArray16;
-                                                                    block94: {
-                                                                        char[] cArray17;
-                                                                        block93: {
-                                                                            int n19;
-                                                                            int n20;
-                                                                            char[] cArray18;
-                                                                            block92: {
-                                                                                char[] cArray19;
-                                                                                block91: {
-                                                                                    int n21;
-                                                                                    int n22;
-                                                                                    char[] cArray20;
-                                                                                    block90: {
-                                                                                        stringArray = new String[10];
-                                                                                        var0 = null;
-                                                                                        char[] cArray21 = "S@\u001b%Y\u0014\u001b\u001f=P\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
-                                                                                        n4 = 0;
-                                                                                        int n23 = cArray21.length;
-                                                                                        cArray20 = cArray21;
-                                                                                        n22 = n23;
-                                                                                        if (n23 <= 1) break block90;
-                                                                                        cArray19 = cArray20;
-                                                                                        n21 = n22;
-                                                                                        if (n22 <= n4) break block91;
-                                                                                    }
-                                                                                    do {
-                                                                                        char[] cArray22 = cArray20;
-                                                                                        char[] cArray23 = cArray20;
-                                                                                        int n24 = n4;
-                                                                                        while (true) {
-                                                                                            int n25;
-                                                                                            char c2 = cArray22[n24];
-                                                                                            switch (n4 % 5) {
-                                                                                                case 0: {
-                                                                                                    n25 = 59;
             break;
         }
-                                                                                                case 1: {
+        byte0;
-                                                                                                    n25 = 52;
+        JVM INSTR ixor ;
-                                                                                                    break;
+        (char);
-                                                                                                }
+        JVM INSTR castore ;
-                                                                                                case 2: {
+        i++;
-                                                                                                    n25 = 111;
+        JVM INSTR swap ;
-                                                                                                    break;
+        JVM INSTR dup_x1 ;
-                                                                                                }
+        JVM INSTR ifne 94;
-                                                                                                case 3: {
+           goto _L3 _L2
-                                                                                                    n25 = 85;
+_L3:
-                                                                                                    break;
+        JVM INSTR dup2 ;
-                                                                                                }
+        JVM INSTR swap ;
-                                                                                                default: {
+          goto _L4
-                                                                                                    n25 = 99;
+_L2:
-                                                                                                }
+        JVM INSTR swap ;
-                                                                                            }
+        JVM INSTR dup_x1 ;
-                                                                                            cArray22[n24] = (char)(c2 ^ n25);
+        i;
-                                                                                            ++n4;
+        JVM INSTR icmpgt 18;
-                                                                                            cArray20 = cArray23;
+           goto _L5 _L1
-                                                                                            n22 = n22;
+_L5:
-                                                                                            if (n22 != 0) break;
+        JVM INSTR new #6   <Class String>;
-                                                                                            cArray23 = cArray20;
+        JVM INSTR dup_x1 ;
-                                                                                            n21 = n22;
+        JVM INSTR swap ;
-                                                                                            n24 = n22;
+        String();
-                                                                                            cArray22 = cArray20;
+        intern();
-                                                                                        }
+        JVM INSTR swap ;
-                                                                                        cArray19 = cArray20;
+        JVM INSTR pop ;
-                                                                                        n21 = n22;
+        JVM INSTR ret 0;
-                                                                                    } while (n22 > n4);
+        String as[] = new String[10];
-                                                                                }
+        as[0] = "S@\033%Y\024\033\037=P\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                stringArray[0] = new String(cArray19).intern();
+        as[1] = "S@\033%Y\024\033\037=P\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                var0 = null;
+        as[2] = "S@\033%Y\024\033\032>R\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                char[] cArray24 = "S@\u001b%Y\u0014\u001b\u001f=P\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
+        as[3] = "S@\033%Y\024\033\032>R\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                n4 = 0;
+        as[4] = "S@\033%Y\024\033\0329P\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                int n26 = cArray24.length;
+        as[5] = "S@\033%Y\024\033\0329P\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                cArray18 = cArray24;
+        as[6] = "S@\033%Y\024\033\0329P\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                n20 = n26;
+        as[7] = "S@\033%Y\024\033\0329P\025F\032;\006HW\016%\006\025W\0008LXX\0060\rO\006@";
-                                                                                if (n26 <= 1) break block92;
+        as[8] = "S@\033%Y\024\033\f0\027\b\032\035 \r^G\f4\023^\032\f:\016\024W\003<\006U@]z";
-                                                                                cArray17 = cArray18;
+        as[9] = "S@\033%Y\024\033\f0\027\b\032\035 \r^G\f4\023^\032\f:\016\024W\003<\006U@]z";
-                                                                                n19 = n20;
+        a = as;
-                                                                                if (n20 <= n4) break block93;
-                                                                            }
-                                                                            do {
-                                                                                char[] cArray25 = cArray18;
-                                                                                char[] cArray26 = cArray18;
-                                                                                int n27 = n4;
-                                                                                while (true) {
-                                                                                    int n28;
-                                                                                    char c3 = cArray25[n27];
-                                                                                    switch (n4 % 5) {
-                                                                                        case 0: {
-                                                                                            n28 = 59;
-                                                                                            break;
-                                                                                        }
-                                                                                        case 1: {
-                                                                                            n28 = 52;
-                                                                                            break;
-                                                                                        }
-                                                                                        case 2: {
-                                                                                            n28 = 111;
-                                                                                            break;
-                                                                                        }
-                                                                                        case 3: {
-                                                                                            n28 = 85;
-                                                                                            break;
-                                                                                        }
-                                                                                        default: {
-                                                                                            n28 = 99;
-                                                                                        }
-                                                                                    }
-                                                                                    cArray25[n27] = (char)(c3 ^ n28);
-                                                                                    ++n4;
-                                                                                    cArray18 = cArray26;
-                                                                                    n20 = n20;
-                                                                                    if (n20 != 0) break;
-                                                                                    cArray26 = cArray18;
-                                                                                    n19 = n20;
-                                                                                    n27 = n20;
-                                                                                    cArray25 = cArray18;
-                                                                                }
-                                                                                cArray17 = cArray18;
-                                                                                n19 = n20;
-                                                                            } while (n20 > n4);
-                                                                        }
-                                                                        stringArray[1] = new String(cArray17).intern();
-                                                                        var0 = null;
-                                                                        char[] cArray27 = "S@\u001b%Y\u0014\u001b\u001a>R\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
-                                                                        n4 = 0;
-                                                                        int n29 = cArray27.length;
-                                                                        cArray16 = cArray27;
-                                                                        n18 = n29;
-                                                                        if (n29 <= 1) break block94;
-                                                                        cArray15 = cArray16;
-                                                                        n17 = n18;
-                                                                        if (n18 <= n4) break block95;
-                                                                    }
-                                                                    do {
-                                                                        char[] cArray28 = cArray16;
-                                                                        char[] cArray29 = cArray16;
-                                                                        int n30 = n4;
-                                                                        while (true) {
-                                                                            int n31;
-                                                                            char c4 = cArray28[n30];
-                                                                            switch (n4 % 5) {
-                                                                                case 0: {
-                                                                                    n31 = 59;
-                                                                                    break;
-                                                                                }
-                                                                                case 1: {
-                                                                                    n31 = 52;
-                                                                                    break;
-                                                                                }
-                                                                                case 2: {
-                                                                                    n31 = 111;
-                                                                                    break;
-                                                                                }
-                                                                                case 3: {
-                                                                                    n31 = 85;
-                                                                                    break;
-                                                                                }
-                                                                                default: {
-                                                                                    n31 = 99;
-                                                                                }
-                                                                            }
-                                                                            cArray28[n30] = (char)(c4 ^ n31);
-                                                                            ++n4;
-                                                                            cArray16 = cArray29;
-                                                                            n18 = n18;
-                                                                            if (n18 != 0) break;
-                                                                            cArray29 = cArray16;
-                                                                            n17 = n18;
-                                                                            n30 = n18;
-                                                                            cArray28 = cArray16;
-                                                                        }
-                                                                        cArray15 = cArray16;
-                                                                        n17 = n18;
-                                                                    } while (n18 > n4);
-                                                                }
-                                                                stringArray[2] = new String(cArray15).intern();
-                                                                var0 = null;
-                                                                char[] cArray30 = "S@\u001b%Y\u0014\u001b\u001a>R\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
-                                                                n4 = 0;
-                                                                int n32 = cArray30.length;
-                                                                cArray14 = cArray30;
-                                                                n16 = n32;
-                                                                if (n32 <= 1) break block96;
-                                                                cArray13 = cArray14;
-                                                                n15 = n16;
-                                                                if (n16 <= n4) break block97;
-                                                            }
-                                                            do {
-                                                                char[] cArray31 = cArray14;
-                                                                char[] cArray32 = cArray14;
-                                                                int n33 = n4;
-                                                                while (true) {
-                                                                    int n34;
-                                                                    char c5 = cArray31[n33];
-                                                                    switch (n4 % 5) {
-                                                                        case 0: {
-                                                                            n34 = 59;
-                                                                            break;
-                                                                        }
-                                                                        case 1: {
-                                                                            n34 = 52;
-                                                                            break;
-                                                                        }
-                                                                        case 2: {
-                                                                            n34 = 111;
-                                                                            break;
-                                                                        }
-                                                                        case 3: {
-                                                                            n34 = 85;
-                                                                            break;
-                                                                        }
-                                                                        default: {
-                                                                            n34 = 99;
-                                                                        }
-                                                                    }
-                                                                    cArray31[n33] = (char)(c5 ^ n34);
-                                                                    ++n4;
-                                                                    cArray14 = cArray32;
-                                                                    n16 = n16;
-                                                                    if (n16 != 0) break;
-                                                                    cArray32 = cArray14;
-                                                                    n15 = n16;
-                                                                    n33 = n16;
-                                                                    cArray31 = cArray14;
-                                                                }
-                                                                cArray13 = cArray14;
-                                                                n15 = n16;
-                                                            } while (n16 > n4);
-                                                        }
-                                                        stringArray[3] = new String(cArray13).intern();
-                                                        var0 = null;
-                                                        char[] cArray33 = "S@\u001b%Y\u0014\u001b\u001a9P\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
-                                                        n4 = 0;
-                                                        int n35 = cArray33.length;
-                                                        cArray12 = cArray33;
-                                                        n14 = n35;
-                                                        if (n35 <= 1) break block98;
-                                                        cArray11 = cArray12;
-                                                        n13 = n14;
-                                                        if (n14 <= n4) break block99;
-                                                    }
-                                                    do {
-                                                        char[] cArray34 = cArray12;
-                                                        char[] cArray35 = cArray12;
-                                                        int n36 = n4;
-                                                        while (true) {
-                                                            int n37;
-                                                            char c6 = cArray34[n36];
-                                                            switch (n4 % 5) {
-                                                                case 0: {
-                                                                    n37 = 59;
-                                                                    break;
-                                                                }
-                                                                case 1: {
-                                                                    n37 = 52;
-                                                                    break;
-                                                                }
-                                                                case 2: {
-                                                                    n37 = 111;
-                                                                    break;
-                                                                }
-                                                                case 3: {
-                                                                    n37 = 85;
-                                                                    break;
-                                                                }
-                                                                default: {
-                                                                    n37 = 99;
-                                                                }
-                                                            }
-                                                            cArray34[n36] = (char)(c6 ^ n37);
-                                                            ++n4;
-                                                            cArray12 = cArray35;
-                                                            n14 = n14;
-                                                            if (n14 != 0) break;
-                                                            cArray35 = cArray12;
-                                                            n13 = n14;
-                                                            n36 = n14;
-                                                            cArray34 = cArray12;
-                                                        }
-                                                        cArray11 = cArray12;
-                                                        n13 = n14;
-                                                    } while (n14 > n4);
-                                                }
-                                                stringArray[4] = new String(cArray11).intern();
-                                                var0 = null;
-                                                char[] cArray36 = "S@\u001b%Y\u0014\u001b\u001a9P\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
-                                                n4 = 0;
-                                                int n38 = cArray36.length;
-                                                cArray10 = cArray36;
-                                                n12 = n38;
-                                                if (n38 <= 1) break block100;
-                                                cArray9 = cArray10;
-                                                n11 = n12;
-                                                if (n12 <= n4) break block101;
-                                            }
-                                            do {
-                                                char[] cArray37 = cArray10;
-                                                char[] cArray38 = cArray10;
-                                                int n39 = n4;
-                                                while (true) {
-                                                    int n40;
-                                                    char c7 = cArray37[n39];
-                                                    switch (n4 % 5) {
-                                                        case 0: {
-                                                            n40 = 59;
-                                                            break;
-                                                        }
-                                                        case 1: {
-                                                            n40 = 52;
-                                                            break;
-                                                        }
-                                                        case 2: {
-                                                            n40 = 111;
-                                                            break;
-                                                        }
-                                                        case 3: {
-                                                            n40 = 85;
-                                                            break;
-                                                        }
-                                                        default: {
-                                                            n40 = 99;
-                                                        }
-                                                    }
-                                                    cArray37[n39] = (char)(c7 ^ n40);
-                                                    ++n4;
-                                                    cArray10 = cArray38;
-                                                    n12 = n12;
-                                                    if (n12 != 0) break;
-                                                    cArray38 = cArray10;
-                                                    n11 = n12;
-                                                    n39 = n12;
-                                                    cArray37 = cArray10;
-                                                }
-                                                cArray9 = cArray10;
-                                                n11 = n12;
-                                            } while (n12 > n4);
-                                        }
-                                        stringArray[5] = new String(cArray9).intern();
-                                        var0 = null;
-                                        char[] cArray39 = "S@\u001b%Y\u0014\u001b\u001a9P\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
-                                        n4 = 0;
-                                        int n41 = cArray39.length;
-                                        cArray8 = cArray39;
-                                        n10 = n41;
-                                        if (n41 <= 1) break block102;
-                                        cArray7 = cArray8;
-                                        n9 = n10;
-                                        if (n10 <= n4) break block103;
-                                    }
-                                    do {
-                                        char[] cArray40 = cArray8;
-                                        char[] cArray41 = cArray8;
-                                        int n42 = n4;
-                                        while (true) {
-                                            int n43;
-                                            char c8 = cArray40[n42];
-                                            switch (n4 % 5) {
-                                                case 0: {
-                                                    n43 = 59;
-                                                    break;
-                                                }
-                                                case 1: {
-                                                    n43 = 52;
-                                                    break;
-                                                }
-                                                case 2: {
-                                                    n43 = 111;
-                                                    break;
-                                                }
-                                                case 3: {
-                                                    n43 = 85;
-                                                    break;
-                                                }
-                                                default: {
-                                                    n43 = 99;
-                                                }
-                                            }
-                                            cArray40[n42] = (char)(c8 ^ n43);
-                                            ++n4;
-                                            cArray8 = cArray41;
-                                            n10 = n10;
-                                            if (n10 != 0) break;
-                                            cArray41 = cArray8;
-                                            n9 = n10;
-                                            n42 = n10;
-                                            cArray40 = cArray8;
-                                        }
-                                        cArray7 = cArray8;
-                                        n9 = n10;
-                                    } while (n10 > n4);
-                                }
-                                stringArray[6] = new String(cArray7).intern();
-                                var0 = null;
-                                char[] cArray42 = "S@\u001b%Y\u0014\u001b\u001a9P\u0015F\u001a;\u0006HW\u000e%\u0006\u0015W\u00008LXX\u00060\rO\u0006@".toCharArray();
-                                n4 = 0;
-                                int n44 = cArray42.length;
-                                cArray6 = cArray42;
-                                n8 = n44;
-                                if (n44 <= 1) break block104;
-                                cArray5 = cArray6;
-                                n7 = n8;
-                                if (n8 <= n4) break block105;
-                            }
-                            do {
-                                char[] cArray43 = cArray6;
-                                char[] cArray44 = cArray6;
-                                int n45 = n4;
-                                while (true) {
-                                    int n46;
-                                    char c9 = cArray43[n45];
-                                    switch (n4 % 5) {
-                                        case 0: {
-                                            n46 = 59;
-                                            break;
-                                        }
-                                        case 1: {
-                                            n46 = 52;
-                                            break;
-                                        }
-                                        case 2: {
-                                            n46 = 111;
-                                            break;
-                                        }
-                                        case 3: {
-                                            n46 = 85;
-                                            break;
-                                        }
-                                        default: {
-                                            n46 = 99;
-                                        }
-                                    }
-                                    cArray43[n45] = (char)(c9 ^ n46);
-                                    ++n4;
-                                    cArray6 = cArray44;
-                                    n8 = n8;
-                                    if (n8 != 0) break;
-                                    cArray44 = cArray6;
-                                    n7 = n8;
-                                    n45 = n8;
-                                    cArray43 = cArray6;
-                                }
-                                cArray5 = cArray6;
-                                n7 = n8;
-                            } while (n8 > n4);
-                        }
-                        stringArray[7] = new String(cArray5).intern();
-                        var0 = null;
-                        char[] cArray45 = "S@\u001b%Y\u0014\u001b\f0\u0017\b\u001a\u001d \r^G\f4\u0013^\u001a\f:\u000e\u0014W\u0003<\u0006U@]z".toCharArray();
-                        n4 = 0;
-                        int n47 = cArray45.length;
-                        cArray4 = cArray45;
-                        n6 = n47;
-                        if (n47 <= 1) break block106;
-                        cArray3 = cArray4;
-                        n5 = n6;
-                        if (n6 <= n4) break block107;
-                    }
-                    do {
-                        char[] cArray46 = cArray4;
-                        char[] cArray47 = cArray4;
-                        int n48 = n4;
-                        while (true) {
-                            int n49;
-                            char c10 = cArray46[n48];
-                            switch (n4 % 5) {
-                                case 0: {
-                                    n49 = 59;
-                                    break;
-                                }
-                                case 1: {
-                                    n49 = 52;
-                                    break;
-                                }
-                                case 2: {
-                                    n49 = 111;
-                                    break;
-                                }
-                                case 3: {
-                                    n49 = 85;
-                                    break;
-                                }
-                                default: {
-                                    n49 = 99;
-                                }
-                            }
-                            cArray46[n48] = (char)(c10 ^ n49);
-                            ++n4;
-                            cArray4 = cArray47;
-                            n6 = n6;
-                            if (n6 != 0) break;
-                            cArray47 = cArray4;
-                            n5 = n6;
-                            n48 = n6;
-                            cArray46 = cArray4;
-                        }
-                        cArray3 = cArray4;
-                        n5 = n6;
-                    } while (n6 > n4);
-                }
-                stringArray[8] = new String(cArray3).intern();
-                var0 = null;
-                char[] cArray48 = "S@\u001b%Y\u0014\u001b\f0\u0017\b\u001a\u001d \r^G\f4\u0013^\u001a\f:\u000e\u0014W\u0003<\u0006U@]z".toCharArray();
-                n4 = 0;
-                int n50 = cArray48.length;
-                cArray2 = cArray48;
-                n3 = n50;
-                if (n50 <= 1) break block108;
-                cArray = cArray2;
-                n2 = n3;
-                if (n3 <= n4) break block109;
-            }
-            do {
-                char[] cArray49 = cArray2;
-                char[] cArray50 = cArray2;
-                int n51 = n4;
-                while (true) {
-                    int n52;
-                    char c11 = cArray49[n51];
-                    switch (n4 % 5) {
-                        case 0: {
-                            n52 = 59;
-                            break;
-                        }
-                        case 1: {
-                            n52 = 52;
-                            break;
-                        }
-                        case 2: {
-                            n52 = 111;
-                            break;
-                        }
-                        case 3: {
-                            n52 = 85;
-                            break;
-                        }
-                        default: {
-                            n52 = 99;
-                        }
-                    }
-                    cArray49[n51] = (char)(c11 ^ n52);
-                    ++n4;
-                    cArray2 = cArray50;
-                    n3 = n3;
-                    if (n3 != 0) break;
-                    cArray50 = cArray2;
-                    n2 = n3;
-                    n51 = n3;
-                    cArray49 = cArray2;
-                }
-                cArray = cArray2;
-                n2 = n3;
-            } while (n3 > n4);
-        }
-        stringArray[9] = new String(cArray).intern();
-        a = stringArray;
         b = 29;
     }
 }
-