wes
c30e839b64
Full source recovered from SBoT.jar (July 2004) plus the three bundled example scripts (BoneBury, GuildFish, GuildFisher). Class names are the original RSC-era single-letter obfuscation (a.java-z.java); mudclient.java and Script.java kept their real names since those weren't obfuscated.
625 lines
22 KiB
Java
625 lines
22 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
import java.io.BufferedInputStream;
|
|
import java.io.DataInputStream;
|
|
import java.io.EOFException;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.net.URL;
|
|
|
|
public class q {
|
|
public static URL a;
|
|
private static int[] b;
|
|
public static boolean c;
|
|
public static boolean d;
|
|
private static String A;
|
|
|
|
public static InputStream a(String string) throws IOException {
|
|
InputStream inputStream;
|
|
block4: {
|
|
URL uRL;
|
|
block2: {
|
|
block3: {
|
|
boolean bl = d;
|
|
uRL = a;
|
|
if (bl) break block2;
|
|
if (uRL != null) break block3;
|
|
inputStream = new BufferedInputStream(new FileInputStream(string));
|
|
if (!bl) break block4;
|
|
}
|
|
uRL = new URL(a, string);
|
|
}
|
|
URL uRL2 = uRL;
|
|
inputStream = uRL2.openStream();
|
|
}
|
|
return inputStream;
|
|
}
|
|
|
|
public static void a(String string, byte[] byArray, int n2) throws IOException {
|
|
InputStream inputStream = q.a(string);
|
|
DataInputStream dataInputStream = new DataInputStream(inputStream);
|
|
try {
|
|
dataInputStream.readFully(byArray, 0, n2);
|
|
}
|
|
catch (EOFException eOFException) {
|
|
// empty catch block
|
|
}
|
|
dataInputStream.close();
|
|
}
|
|
|
|
public static int a(byte by) {
|
|
return by & 0xFF;
|
|
}
|
|
|
|
public static int a(byte[] byArray, int n2) {
|
|
return ((byArray[n2] & 0xFF) << 8) + (byArray[n2 + 1] & 0xFF);
|
|
}
|
|
|
|
public static int b(byte[] byArray, int n2) {
|
|
return ((byArray[n2] & 0xFF) << 24) + ((byArray[n2 + 1] & 0xFF) << 16) + ((byArray[n2 + 2] & 0xFF) << 8) + (byArray[n2 + 3] & 0xFF);
|
|
}
|
|
|
|
public static long c(byte[] byArray, int n2) {
|
|
return (((long)q.b(byArray, n2) & 0xFFFFFFFFL) << 32) + ((long)q.b(byArray, n2 + 4) & 0xFFFFFFFFL);
|
|
}
|
|
|
|
public static int d(byte[] byArray, int n2) {
|
|
int n3;
|
|
int n4 = n3 = q.a(byArray[n2]) * 256 + q.a(byArray[n2 + 1]);
|
|
if (!d) {
|
|
if (n4 > Short.MAX_VALUE) {
|
|
n3 -= 65536;
|
|
}
|
|
n4 = n3;
|
|
}
|
|
return n4;
|
|
}
|
|
|
|
public static int e(byte[] byArray, int n2) {
|
|
int n3 = byArray[n2] & 0xFF;
|
|
int n4 = 128;
|
|
if (!d) {
|
|
if (n3 < n4) {
|
|
return byArray[n2];
|
|
}
|
|
n3 = ((byArray[n2] & 0xFF) - 128 << 24) + ((byArray[n2 + 1] & 0xFF) << 16) + ((byArray[n2 + 2] & 0xFF) << 8);
|
|
n4 = byArray[n2 + 3] & 0xFF;
|
|
}
|
|
return n3 + n4;
|
|
}
|
|
|
|
public static int a(byte[] byArray, int n2, int n3) {
|
|
int n4;
|
|
block8: {
|
|
int n5;
|
|
int n6;
|
|
block7: {
|
|
int n7;
|
|
int n8;
|
|
block6: {
|
|
boolean bl = d;
|
|
boolean bl2 = false;
|
|
n8 = n2 >> 3;
|
|
n7 = 8 - (n2 & 7);
|
|
n4 = 0;
|
|
while (n3 > n7) {
|
|
n4 += (byArray[n8++] & b[n7]) << n3 - n7;
|
|
n3 -= n7;
|
|
n7 = 8;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block6;
|
|
}
|
|
n6 = n3;
|
|
n5 = n7;
|
|
if (bl) break block7;
|
|
if (n6 != n5) break block6;
|
|
n4 += byArray[n8] & b[n7];
|
|
if (!bl) break block8;
|
|
}
|
|
n6 = n4;
|
|
n5 = byArray[n8] >> n7 - n3 & b[n3];
|
|
}
|
|
n4 = n6 + n5;
|
|
}
|
|
return n4;
|
|
}
|
|
|
|
/*
|
|
* Enabled aggressive block sorting
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static String a(String string, int n2) {
|
|
boolean bl = d;
|
|
boolean bl2 = false;
|
|
String string2 = "";
|
|
char c2 = '\u0000';
|
|
do {
|
|
block5: {
|
|
block11: {
|
|
char c3;
|
|
char c4;
|
|
char c5;
|
|
block10: {
|
|
block8: {
|
|
block9: {
|
|
block6: {
|
|
block7: {
|
|
char c6;
|
|
block3: {
|
|
block4: {
|
|
if (c2 >= n2) return string2;
|
|
c6 = c2;
|
|
if (bl) break block3;
|
|
if (c6 < string.length()) break block4;
|
|
string2 = string2 + " ";
|
|
if (!bl) break block5;
|
|
}
|
|
c6 = string.charAt(c2);
|
|
}
|
|
c4 = c5 = c6;
|
|
c3 = 'a';
|
|
if (bl) break block6;
|
|
if (c4 < c3) break block7;
|
|
c4 = c5;
|
|
c3 = 'z';
|
|
if (bl) break block6;
|
|
if (c4 > c3) break block7;
|
|
string2 = string2 + c5;
|
|
if (!bl) break block5;
|
|
}
|
|
c4 = c5;
|
|
c3 = 'A';
|
|
}
|
|
if (bl) break block8;
|
|
if (c4 < c3) break block9;
|
|
c4 = c5;
|
|
c3 = 'Z';
|
|
if (bl) break block8;
|
|
if (c4 > c3) break block9;
|
|
string2 = string2 + c5;
|
|
if (!bl) break block5;
|
|
}
|
|
c4 = c5;
|
|
c3 = '0';
|
|
}
|
|
if (bl) break block10;
|
|
if (c4 < c3) break block11;
|
|
c4 = c5;
|
|
c3 = '9';
|
|
}
|
|
if (c4 > c3) break block11;
|
|
string2 = string2 + c5;
|
|
if (!bl) break block5;
|
|
}
|
|
string2 = string2 + '_';
|
|
}
|
|
++c2;
|
|
} while (!bl);
|
|
return string2;
|
|
}
|
|
|
|
public static String a(int n2) {
|
|
return (n2 >> 24 & 0xFF) + "." + (n2 >> 16 & 0xFF) + "." + (n2 >> 8 & 0xFF) + "." + (n2 & 0xFF);
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
* Could not resolve type clashes
|
|
*/
|
|
public static long b(String var0) {
|
|
block31: {
|
|
block35: {
|
|
block34: {
|
|
block30: {
|
|
var7_1 = q.d;
|
|
var1_2 = false;
|
|
var2_3 = "";
|
|
for (var3_4 = 0; var3_4 < var0.length(); ++var3_4) {
|
|
block33: {
|
|
block32: {
|
|
var4_6 = var0.charAt(var3_4);
|
|
v0 = var4_6;
|
|
v1 = 97;
|
|
if (var7_1) break block30;
|
|
if (!var7_1) {
|
|
if (v0 >= v1) {
|
|
v2 = var4_6;
|
|
v3 = 'z';
|
|
if (!var7_1) {
|
|
if (v2 <= v3) {
|
|
var2_3 = var2_3 + var4_6;
|
|
if (!var7_1) continue;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 4 sources
|
|
|
|
{
|
|
v2 = var4_6;
|
|
v3 = 'A';
|
|
}
|
|
}
|
|
if (!var7_1) {
|
|
if (v2 >= v3) {
|
|
v2 = var4_6;
|
|
v3 = 'Z';
|
|
if (!var7_1) {
|
|
if (v2 <= v3) {
|
|
var2_3 = var2_3 + (char)(var4_6 + 97 - 65);
|
|
if (!var7_1) continue;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 4 sources
|
|
|
|
{
|
|
v2 = var4_6;
|
|
v3 = '0';
|
|
}
|
|
}
|
|
if (var7_1) break block32;
|
|
if (v2 < v3) break block33;
|
|
v2 = var4_6;
|
|
v3 = '9';
|
|
}
|
|
if (v2 <= v3) {
|
|
var2_3 = var2_3 + var4_6;
|
|
if (!var7_1) continue;
|
|
}
|
|
}
|
|
var2_3 = var2_3 + ' ';
|
|
if (!var7_1) continue;
|
|
}
|
|
v4 = var2_3 = var2_3.trim();
|
|
if (var7_1) break block34;
|
|
v0 = v4.length();
|
|
v1 = 12;
|
|
}
|
|
if (v0 <= v1) break block35;
|
|
v4 = var2_3.substring(0, 12);
|
|
}
|
|
var2_3 = v4;
|
|
}
|
|
var3_5 = 0L;
|
|
for (var5_7 = 0; var5_7 < var2_3.length(); ++var5_7) {
|
|
var6_8 = var2_3.charAt(var5_7);
|
|
v5 = var3_5 * 37L;
|
|
if (!var7_1) {
|
|
var3_5 = v5;
|
|
v6 = var6_8;
|
|
v7 = 97;
|
|
if (!var7_1) {
|
|
if (v6 >= v7) {
|
|
v6 = var6_8;
|
|
v7 = 122;
|
|
if (!var7_1) {
|
|
if (v6 <= v7) {
|
|
var3_5 += (long)(1 + var6_8 - 97);
|
|
if (!var7_1) continue;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 4 sources
|
|
|
|
{
|
|
v6 = var6_8;
|
|
v7 = 48;
|
|
}
|
|
}
|
|
if (!var7_1) {
|
|
if (v6 < v7) continue;
|
|
v6 = var6_8;
|
|
v7 = 57;
|
|
}
|
|
if (v6 > v7) continue;
|
|
var3_5 += (long)(27 + var6_8 - 48);
|
|
if (!var7_1) continue;
|
|
}
|
|
break block31;
|
|
}
|
|
v5 = var3_5;
|
|
}
|
|
return v5;
|
|
}
|
|
|
|
public static String a(long l2) {
|
|
boolean bl = d;
|
|
boolean bl2 = false;
|
|
if (l2 < 0L) {
|
|
return A;
|
|
}
|
|
String string = "";
|
|
while (l2 != 0L) {
|
|
int n2;
|
|
block9: {
|
|
int n3;
|
|
block8: {
|
|
n2 = (int)(l2 % 37L);
|
|
l2 /= 37L;
|
|
n3 = n2;
|
|
if (!bl) {
|
|
if (n3 == 0) {
|
|
string = " " + string;
|
|
if (!bl) continue;
|
|
}
|
|
n3 = n2;
|
|
}
|
|
if (bl) break block8;
|
|
if (n3 >= 27) break block9;
|
|
long l3 = l2 % 37L - 0L;
|
|
n3 = l3 == 0L ? (char)'\u0000' : (l3 < 0L ? (char)'\uffffffff' : '\u0001');
|
|
}
|
|
if (n3 == 0) {
|
|
string = (char)(n2 + 65 - 1) + string;
|
|
if (!bl) continue;
|
|
}
|
|
string = (char)(n2 + 97 - 1) + string;
|
|
if (!bl) continue;
|
|
}
|
|
string = (char)(n2 + 48 - 27) + string;
|
|
if (!bl) continue;
|
|
}
|
|
return string;
|
|
}
|
|
|
|
public static int a(String string, byte[] byArray) {
|
|
int n2;
|
|
block7: {
|
|
int n3;
|
|
int n4;
|
|
int n5;
|
|
boolean bl;
|
|
block6: {
|
|
bl = d;
|
|
boolean bl2 = false;
|
|
n5 = q.a(byArray, 0);
|
|
n4 = 0;
|
|
string = string.toUpperCase();
|
|
for (n3 = 0; n3 < string.length(); ++n3) {
|
|
n4 = n4 * 61 + string.charAt(n3) - 32;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block6;
|
|
}
|
|
n3 = 2 + n5 * 10;
|
|
}
|
|
for (int i2 = 0; i2 < n5; ++i2) {
|
|
int n6 = (byArray[i2 * 10 + 2] & 0xFF) * 0x1000000 + (byArray[i2 * 10 + 3] & 0xFF) * 65536 + (byArray[i2 * 10 + 4] & 0xFF) * 256 + (byArray[i2 * 10 + 5] & 0xFF);
|
|
int n7 = (byArray[i2 * 10 + 9] & 0xFF) * 65536 + (byArray[i2 * 10 + 10] & 0xFF) * 256 + (byArray[i2 * 10 + 11] & 0xFF);
|
|
n2 = n6;
|
|
if (!bl) {
|
|
int n8;
|
|
int n9 = n4;
|
|
if (!bl) {
|
|
if (n2 == n9) {
|
|
return n3;
|
|
}
|
|
n8 = n3;
|
|
n9 = n7;
|
|
}
|
|
n3 = n8 + n9;
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
n2 = 0;
|
|
}
|
|
return n2;
|
|
}
|
|
|
|
public static int b(String string, byte[] byArray) {
|
|
int n2;
|
|
block7: {
|
|
int n3;
|
|
int n4;
|
|
int n5;
|
|
boolean bl;
|
|
block6: {
|
|
bl = d;
|
|
boolean bl2 = false;
|
|
n5 = q.a(byArray, 0);
|
|
n4 = 0;
|
|
string = string.toUpperCase();
|
|
for (n3 = 0; n3 < string.length(); ++n3) {
|
|
n4 = n4 * 61 + string.charAt(n3) - 32;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block6;
|
|
}
|
|
n3 = 2 + n5 * 10;
|
|
}
|
|
for (int i2 = 0; i2 < n5; ++i2) {
|
|
int n6 = (byArray[i2 * 10 + 2] & 0xFF) * 0x1000000 + (byArray[i2 * 10 + 3] & 0xFF) * 65536 + (byArray[i2 * 10 + 4] & 0xFF) * 256 + (byArray[i2 * 10 + 5] & 0xFF);
|
|
int n7 = (byArray[i2 * 10 + 6] & 0xFF) * 65536 + (byArray[i2 * 10 + 7] & 0xFF) * 256 + (byArray[i2 * 10 + 8] & 0xFF);
|
|
int n8 = (byArray[i2 * 10 + 9] & 0xFF) * 65536 + (byArray[i2 * 10 + 10] & 0xFF) * 256 + (byArray[i2 * 10 + 11] & 0xFF);
|
|
n2 = n6;
|
|
if (!bl) {
|
|
int n9;
|
|
int n10 = n4;
|
|
if (!bl) {
|
|
if (n2 == n10) {
|
|
return n7;
|
|
}
|
|
n9 = n3;
|
|
n10 = n8;
|
|
}
|
|
n3 = n9 + n10;
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
n2 = 0;
|
|
}
|
|
return n2;
|
|
}
|
|
|
|
public static byte[] a(String string, int n2, byte[] byArray) {
|
|
return q.a(string, n2, byArray, null);
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static byte[] a(String string, int n2, byte[] byArray, byte[] byArray2) {
|
|
int n3;
|
|
int n4;
|
|
int n5;
|
|
boolean bl;
|
|
block12: {
|
|
bl = d;
|
|
boolean bl2 = false;
|
|
n5 = (byArray[0] & 0xFF) * 256 + (byArray[1] & 0xFF);
|
|
n4 = 0;
|
|
string = string.toUpperCase();
|
|
for (n3 = 0; n3 < string.length(); ++n3) {
|
|
n4 = n4 * 61 + string.charAt(n3) - 32;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block12;
|
|
}
|
|
n3 = 2 + n5 * 10;
|
|
}
|
|
for (int i2 = 0; i2 < n5; ++i2) {
|
|
int n6;
|
|
int n7;
|
|
block13: {
|
|
int n8;
|
|
block14: {
|
|
byte[] byArray3;
|
|
block19: {
|
|
int n9;
|
|
int n10;
|
|
block17: {
|
|
int n11;
|
|
block18: {
|
|
block16: {
|
|
byte[] byArray4;
|
|
block15: {
|
|
int n12 = (byArray[i2 * 10 + 2] & 0xFF) * 0x1000000 + (byArray[i2 * 10 + 3] & 0xFF) * 65536 + (byArray[i2 * 10 + 4] & 0xFF) * 256 + (byArray[i2 * 10 + 5] & 0xFF);
|
|
n10 = (byArray[i2 * 10 + 6] & 0xFF) * 65536 + (byArray[i2 * 10 + 7] & 0xFF) * 256 + (byArray[i2 * 10 + 8] & 0xFF);
|
|
n8 = (byArray[i2 * 10 + 9] & 0xFF) * 65536 + (byArray[i2 * 10 + 10] & 0xFF) * 256 + (byArray[i2 * 10 + 11] & 0xFF);
|
|
n7 = n12;
|
|
n6 = n4;
|
|
if (bl) break block13;
|
|
if (n7 != n6) break block14;
|
|
byArray4 = byArray2;
|
|
if (bl) break block15;
|
|
if (byArray4 != null) break block16;
|
|
byArray4 = new byte[n10 + n2];
|
|
}
|
|
byArray2 = byArray4;
|
|
}
|
|
n11 = n10;
|
|
if (bl) break block17;
|
|
if (n11 == n8) break block18;
|
|
u.a(byArray2, n10, byArray, n8, n3);
|
|
if (!bl) break block19;
|
|
}
|
|
n11 = n9 = 0;
|
|
}
|
|
while (n9 < n10) {
|
|
byArray3 = byArray2;
|
|
if (bl) return byArray3;
|
|
byArray3[n9] = byArray[n3 + n9];
|
|
++n9;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
byArray3 = byArray2;
|
|
return byArray3;
|
|
}
|
|
n7 = n3;
|
|
n6 = n8;
|
|
}
|
|
n3 = n7 + n6;
|
|
if (!bl) continue;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
* Handled impossible loop by duplicating code
|
|
* Enabled aggressive block sorting
|
|
*/
|
|
static {
|
|
char[] cArray;
|
|
block10: {
|
|
int n2;
|
|
int n3;
|
|
char[] cArray2;
|
|
int n4;
|
|
block9: {
|
|
Object var0 = null;
|
|
char[] cArray3 = "md!T8mn\b[5io".toCharArray();
|
|
n4 = 0;
|
|
int n5 = cArray3.length;
|
|
cArray2 = cArray3;
|
|
n3 = n5;
|
|
if (n5 <= 1) break block9;
|
|
cArray = cArray2;
|
|
n2 = n3;
|
|
if (n3 <= n4) break block10;
|
|
}
|
|
do {
|
|
char[] cArray4 = cArray2;
|
|
char[] cArray5 = cArray2;
|
|
int n6 = n4;
|
|
while (true) {
|
|
int n7;
|
|
char c2 = cArray4[n6];
|
|
switch (n4 % 5) {
|
|
case 0: {
|
|
n7 = 4;
|
|
break;
|
|
}
|
|
case 1: {
|
|
n7 = 10;
|
|
break;
|
|
}
|
|
case 2: {
|
|
n7 = 87;
|
|
break;
|
|
}
|
|
case 3: {
|
|
n7 = 53;
|
|
break;
|
|
}
|
|
default: {
|
|
n7 = 84;
|
|
}
|
|
}
|
|
cArray4[n6] = (char)(c2 ^ n7);
|
|
++n4;
|
|
cArray2 = cArray5;
|
|
n3 = n3;
|
|
if (n3 != 0) break;
|
|
cArray5 = cArray2;
|
|
n2 = n3;
|
|
n6 = n3;
|
|
cArray4 = cArray2;
|
|
}
|
|
cArray = cArray2;
|
|
n2 = n3;
|
|
} while (n3 > n4);
|
|
}
|
|
A = new String(cArray).intern();
|
|
a = null;
|
|
b = 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};
|
|
}
|
|
}
|
|
|