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.
2363 lines
101 KiB
Java
2363 lines
101 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
public class o {
|
|
static boolean a;
|
|
static boolean b;
|
|
static boolean c;
|
|
static int d;
|
|
static int[] e;
|
|
static char[][] f;
|
|
static byte[][][] g;
|
|
static char[][] h;
|
|
static byte[][][] i;
|
|
static char[][] j;
|
|
static int[] k;
|
|
static String[] l;
|
|
|
|
public static void a(n n2, n n3, n n4, n n5) {
|
|
o.b(n3);
|
|
o.c(n4);
|
|
o.d(n2);
|
|
o.a(n5);
|
|
}
|
|
|
|
public static void a(n n2) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
int n3 = n2.c();
|
|
j = new char[n3][];
|
|
k = new int[n3];
|
|
int n4 = 0;
|
|
while (n4 < n3) {
|
|
block3: {
|
|
o.k[n4] = n2.a();
|
|
char[] cArray = new char[n2.a()];
|
|
for (int i2 = 0; i2 < cArray.length; ++i2) {
|
|
cArray[i2] = (char)n2.a();
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block3;
|
|
}
|
|
o.j[n4] = cArray;
|
|
++n4;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public static void b(n n2) {
|
|
int n3 = n2.c();
|
|
f = new char[n3][];
|
|
g = new byte[n3][][];
|
|
o.a(n2, f, g);
|
|
}
|
|
|
|
public static void c(n n2) {
|
|
int n3 = n2.c();
|
|
h = new char[n3][];
|
|
i = new byte[n3][][];
|
|
o.a(n2, h, i);
|
|
}
|
|
|
|
public static void d(n n2) {
|
|
e = new int[n2.c()];
|
|
for (int i2 = 0; i2 < e.length; ++i2) {
|
|
o.e[i2] = n2.b();
|
|
if (!q.d) continue;
|
|
}
|
|
}
|
|
|
|
public static void a(n n2, char[][] cArray, byte[][][] byArray) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
int n3 = 0;
|
|
while (n3 < cArray.length) {
|
|
block7: {
|
|
block6: {
|
|
char[] cArray2 = new char[n2.a()];
|
|
for (int i2 = 0; i2 < cArray2.length; ++i2) {
|
|
cArray2[i2] = (char)n2.a();
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block6;
|
|
}
|
|
cArray[n3] = cArray2;
|
|
}
|
|
byte[][] byArray2 = new byte[n2.c()][2];
|
|
for (int i3 = 0; i3 < byArray2.length; ++i3) {
|
|
byArray2[i3][0] = (byte)n2.a();
|
|
byArray2[i3][1] = (byte)n2.a();
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
if (byArray2.length > 0) {
|
|
byArray[n3] = byArray2;
|
|
}
|
|
++n3;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public static String a(String string) {
|
|
int n2;
|
|
char[] cArray;
|
|
block5: {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
cArray = string.toLowerCase().toCharArray();
|
|
o.d(cArray);
|
|
o.b(cArray);
|
|
o.c(cArray);
|
|
o.e(cArray);
|
|
int n3 = 0;
|
|
while (n3 < l.length) {
|
|
block6: {
|
|
n2 = -1;
|
|
if (bl) break block5;
|
|
int n4 = n2;
|
|
while ((n4 = string.indexOf(l[n3], n4 + 1)) != -1) {
|
|
char[] cArray2 = l[n3].toCharArray();
|
|
for (int i2 = 0; i2 < cArray2.length; ++i2) {
|
|
cArray[i2 + n4] = cArray2[i2];
|
|
if (!bl && !bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block6;
|
|
}
|
|
}
|
|
++n3;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
n2 = c ? 1 : 0;
|
|
}
|
|
if (n2 != 0) {
|
|
o.a(string.toCharArray(), cArray);
|
|
o.a(cArray);
|
|
}
|
|
return new String(cArray);
|
|
}
|
|
|
|
public static void a(char[] cArray, char[] cArray2) {
|
|
boolean bl = q.d;
|
|
for (int i2 = 0; i2 < cArray.length; ++i2) {
|
|
block4: {
|
|
int n2;
|
|
char[] cArray3;
|
|
char c2;
|
|
block3: {
|
|
c2 = cArray2[i2];
|
|
if (bl) break block3;
|
|
if (c2 == '*') continue;
|
|
cArray3 = cArray;
|
|
n2 = i2;
|
|
if (bl) break block4;
|
|
c2 = (char)(o.g(cArray3[n2]) ? 1 : 0);
|
|
}
|
|
if (c2 == '\u0000') continue;
|
|
cArray3 = cArray2;
|
|
n2 = i2;
|
|
}
|
|
cArray3[n2] = cArray[i2];
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public static void a(char[] cArray) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
boolean bl3 = true;
|
|
for (int i2 = 0; i2 < cArray.length; ++i2) {
|
|
char c2 = cArray[i2];
|
|
boolean bl4 = o.d(c2);
|
|
if (!bl) {
|
|
if (bl4) {
|
|
boolean bl5 = bl3;
|
|
if (!bl) {
|
|
if (bl5) {
|
|
boolean bl6 = o.f(c2);
|
|
if (!bl) {
|
|
if (!bl6) continue;
|
|
bl6 = bl3 = false;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
bl5 = o.g(c2);
|
|
}
|
|
if (!bl5) continue;
|
|
cArray[i2] = (char)(c2 + 97 - 65);
|
|
if (!bl) continue;
|
|
}
|
|
bl4 = true;
|
|
}
|
|
bl3 = bl4;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public static void b(char[] cArray) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
int n2 = 0;
|
|
while (n2 < 2) {
|
|
block3: {
|
|
for (int i2 = f.length - 1; i2 >= 0; --i2) {
|
|
o.a(cArray, f[i2], g[i2]);
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block3;
|
|
}
|
|
++n2;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public static void c(char[] cArray) {
|
|
for (int i2 = h.length - 1; i2 >= 0; --i2) {
|
|
o.a(cArray, h[i2], i[i2]);
|
|
if (!q.d) continue;
|
|
}
|
|
}
|
|
|
|
public static void d(char[] cArray) {
|
|
char[] cArray2 = (char[])cArray.clone();
|
|
char[] cArray3 = new char[]{'d', 'o', 't'};
|
|
o.a(cArray2, cArray3, (byte[][])null);
|
|
char[] cArray4 = (char[])cArray.clone();
|
|
char[] cArray5 = new char[]{'s', 'l', 'a', 's', 'h'};
|
|
o.a(cArray4, cArray5, (byte[][])null);
|
|
for (int i2 = 0; i2 < j.length; ++i2) {
|
|
o.a(cArray, cArray2, cArray4, j[i2], k[i2]);
|
|
if (!q.d) continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Exception decompiling
|
|
*/
|
|
public static void a(char[] var0, char[] var1_1, char[] var2_2, char[] var3_3, int var4_4) {
|
|
/*
|
|
* This method has failed to decompile. When submitting a bug report, please provide this stack trace, and (if you hold appropriate legal rights) the relevant class file.
|
|
*
|
|
* org.benf.cfr.reader.util.ConfusedCFRException: Statement already marked as first in another block
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.Op03SimpleStatement.markFirstStatementInBlock(Op03SimpleStatement.java:461)
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.op3rewriters.Misc.markWholeBlock(Misc.java:251)
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.op3rewriters.ConditionalRewriter.considerAsSimpleIf(ConditionalRewriter.java:673)
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.op3rewriters.ConditionalRewriter.identifyNonjumpingConditionals(ConditionalRewriter.java:56)
|
|
* at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisInner(CodeAnalyser.java:722)
|
|
* at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisOrWrapFail(CodeAnalyser.java:278)
|
|
* at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysis(CodeAnalyser.java:201)
|
|
* at org.benf.cfr.reader.entities.attributes.AttributeCode.analyse(AttributeCode.java:94)
|
|
* at org.benf.cfr.reader.entities.Method.analyse(Method.java:531)
|
|
* at org.benf.cfr.reader.entities.ClassFile.analyseMid(ClassFile.java:1055)
|
|
* at org.benf.cfr.reader.entities.ClassFile.analyseTop(ClassFile.java:942)
|
|
* at org.benf.cfr.reader.Driver.doJarVersionTypes(Driver.java:257)
|
|
* at org.benf.cfr.reader.Driver.doJar(Driver.java:139)
|
|
* at org.benf.cfr.reader.CfrDriverImpl.analyse(CfrDriverImpl.java:76)
|
|
* at org.benf.cfr.reader.Main.main(Main.java:54)
|
|
*/
|
|
throw new IllegalStateException("Decompilation failed");
|
|
}
|
|
|
|
public static int a(char[] cArray, char[] cArray2, int n2) {
|
|
int n3;
|
|
boolean bl;
|
|
block16: {
|
|
int n4;
|
|
int n5;
|
|
block15: {
|
|
int n6;
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
int n7 = n2;
|
|
if (!bl) {
|
|
if (n7 == 0) {
|
|
return 2;
|
|
}
|
|
n7 = n5 = n2 - 1;
|
|
}
|
|
while (n5 >= 0) {
|
|
block19: {
|
|
int n8;
|
|
block17: {
|
|
block18: {
|
|
n6 = o.b(cArray[n5]);
|
|
if (bl) break block15;
|
|
if (!bl) {
|
|
if (n6 == 0 && !bl) break;
|
|
n8 = cArray[n5];
|
|
}
|
|
if (bl) break block17;
|
|
if (n8 == 44) break block18;
|
|
n8 = cArray[n5];
|
|
if (bl) break block17;
|
|
if (n8 != 46) break block19;
|
|
}
|
|
n8 = 3;
|
|
}
|
|
return n8;
|
|
}
|
|
--n5;
|
|
if (!bl) continue;
|
|
}
|
|
n5 = 0;
|
|
n6 = n4 = n2 - 1;
|
|
}
|
|
while (n4 >= 0) {
|
|
n3 = o.b(cArray2[n4]) ? 1 : 0;
|
|
if (!bl) {
|
|
char c2;
|
|
if (!bl) {
|
|
if (n3 == 0 && !bl) break;
|
|
c2 = cArray2[n4];
|
|
}
|
|
if (c2 == '*') {
|
|
++n5;
|
|
}
|
|
--n4;
|
|
if (!bl) continue;
|
|
}
|
|
break block16;
|
|
}
|
|
n3 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n3 >= 3) {
|
|
return 4;
|
|
}
|
|
n3 = o.b(cArray[n2 - 1]) ? 1 : 0;
|
|
}
|
|
if (!bl) {
|
|
n3 = n3 == 0 ? 0 : 1;
|
|
}
|
|
return n3;
|
|
}
|
|
|
|
public static int b(char[] cArray, char[] cArray2, int n2) {
|
|
int n3;
|
|
boolean bl;
|
|
block17: {
|
|
int n4;
|
|
int n5;
|
|
block16: {
|
|
int n6;
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
int n7 = n2 + 1;
|
|
int n8 = cArray.length;
|
|
if (!bl) {
|
|
if (n7 == n8) {
|
|
return 2;
|
|
}
|
|
n7 = n2;
|
|
n8 = 1;
|
|
}
|
|
for (n5 = (v191458) + (v191459); n5 < cArray.length; ++n5) {
|
|
n6 = o.b(cArray[n5]);
|
|
if (!bl) {
|
|
int n9;
|
|
if (!bl) {
|
|
if (n6 == 0 && !bl) break;
|
|
n9 = cArray[n5];
|
|
}
|
|
if (!bl) {
|
|
if (n9 != 92) {
|
|
n9 = cArray[n5];
|
|
if (!bl) {
|
|
if (n9 != 47) continue;
|
|
}
|
|
} else {
|
|
n9 = 3;
|
|
}
|
|
}
|
|
return n9;
|
|
}
|
|
break block16;
|
|
}
|
|
n5 = 0;
|
|
n6 = n4 = n2 + 1;
|
|
}
|
|
while (n4 < cArray.length) {
|
|
n3 = o.b(cArray2[n4]) ? 1 : 0;
|
|
if (!bl) {
|
|
char c2;
|
|
if (!bl) {
|
|
if (n3 == 0 && !bl) break;
|
|
c2 = cArray2[n4];
|
|
}
|
|
if (c2 == '*') {
|
|
++n5;
|
|
}
|
|
++n4;
|
|
if (!bl) continue;
|
|
}
|
|
break block17;
|
|
}
|
|
n3 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n3 >= 5) {
|
|
return 4;
|
|
}
|
|
n3 = o.b(cArray[n2 + 1]) ? 1 : 0;
|
|
}
|
|
if (!bl) {
|
|
n3 = n3 == 0 ? 0 : 1;
|
|
}
|
|
return n3;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
* Could not resolve type clashes
|
|
*/
|
|
public static void a(char[] var0, char[] var1_1, byte[][] var2_2) {
|
|
var16_3 = q.d;
|
|
var3_4 = false;
|
|
v0 = var1_1.length;
|
|
if (!var16_3) {
|
|
if (v0 > var0.length) {
|
|
return;
|
|
}
|
|
v0 = 0;
|
|
}
|
|
var4_5 = v0;
|
|
block0: while (true) {
|
|
v1 = var4_5;
|
|
v2 = var0.length - var1_1.length;
|
|
block1: while (v1 <= v2) {
|
|
block78: {
|
|
block104: {
|
|
block81: {
|
|
block82: {
|
|
block70: {
|
|
block92: {
|
|
block93: {
|
|
block90: {
|
|
block91: {
|
|
block88: {
|
|
block89: {
|
|
block87: {
|
|
block85: {
|
|
block86: {
|
|
block83: {
|
|
block84: {
|
|
block79: {
|
|
block80: {
|
|
block77: {
|
|
block69: {
|
|
var5_6 = var4_5;
|
|
var6_7 = 0;
|
|
var7_8 = 0;
|
|
while (var5_6 < var0.length) {
|
|
block75: {
|
|
block76: {
|
|
block74: {
|
|
block73: {
|
|
block72: {
|
|
var8_9 = 0;
|
|
var9_10 = var0[var5_6];
|
|
var10_11 = 0;
|
|
v3 = var5_6 + 1;
|
|
v4 = var0.length;
|
|
if (var16_3) break block69;
|
|
if (var16_3) break block72;
|
|
if (v3 < v4) {
|
|
var10_11 = var0[var5_6 + 1];
|
|
}
|
|
v3 = var6_7;
|
|
if (var16_3) break block73;
|
|
v5 = var1_1.length;
|
|
}
|
|
if (v3 < v5) {
|
|
v3 = var8_9 = o.b(var1_1[var6_7], (char)var9_10, (char)var10_11);
|
|
if (!var16_3) {
|
|
if (v3 > 0) {
|
|
var5_6 += var8_9;
|
|
++var6_7;
|
|
if (!var16_3) continue;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 4 sources
|
|
|
|
{
|
|
v3 = var6_7;
|
|
}
|
|
}
|
|
if (!var16_3) {
|
|
if (v3 == 0 && !var16_3) break;
|
|
v3 = var8_9 = o.b(var1_1[var6_7 - 1], (char)var9_10, (char)var10_11);
|
|
}
|
|
if (!var16_3) {
|
|
if (v3 > 0) {
|
|
var5_6 += var8_9;
|
|
if (!var16_3) continue;
|
|
}
|
|
v3 = var6_7;
|
|
}
|
|
v4 = var1_1.length;
|
|
if (var16_3) break block69;
|
|
if (v3 >= v4) break;
|
|
v6 = o.c((char)var9_10);
|
|
if (!var16_3) {
|
|
if (v6 == 0 && !var16_3) break;
|
|
v6 = o.b((char)var9_10);
|
|
}
|
|
if (var16_3) break block74;
|
|
if (v6 == 0) break block75;
|
|
v6 = var9_10;
|
|
}
|
|
if (var16_3) break block76;
|
|
if (v6 == 39) break block75;
|
|
v6 = 1;
|
|
}
|
|
var7_8 = v6;
|
|
}
|
|
++var5_6;
|
|
if (!var16_3) continue;
|
|
}
|
|
v3 = var6_7;
|
|
if (var16_3) break block77;
|
|
v4 = var1_1.length;
|
|
}
|
|
if (v3 < v4) break block78;
|
|
v3 = 1;
|
|
}
|
|
var8_9 = v3;
|
|
v7 = var7_8;
|
|
if (var16_3) break block79;
|
|
if (v7 != 0) break block80;
|
|
var9_10 = 32;
|
|
v8 = var4_5 - 1;
|
|
if (!var16_3) {
|
|
if (v8 >= 0) {
|
|
var9_10 = var0[var4_5 - 1];
|
|
}
|
|
v8 = 32;
|
|
}
|
|
var10_11 = v8;
|
|
v9 = var5_6;
|
|
if (!var16_3) {
|
|
if (v9 < var0.length) {
|
|
var10_11 = var0[var5_6];
|
|
}
|
|
v9 = o.a((char)var9_10);
|
|
}
|
|
var11_12 = v9;
|
|
v10 = o.a((char)var10_11);
|
|
if (var16_3) break block81;
|
|
var12_13 = v10;
|
|
if (var2_2 == null) break block82;
|
|
v10 = (int)o.a(var2_2, (byte)var11_12, (byte)var12_13);
|
|
if (var16_3) break block81;
|
|
if (v10 == 0) break block82;
|
|
var8_9 = 0;
|
|
if (!var16_3) break block82;
|
|
}
|
|
v7 = 0;
|
|
}
|
|
var9_10 = v7;
|
|
var10_11 = 0;
|
|
v11 = var4_5 - 1;
|
|
if (var16_3) break block83;
|
|
if (v11 < 0) break block84;
|
|
v12 = (int)o.b(var0[var4_5 - 1]);
|
|
if (var16_3) break block85;
|
|
if (v12 == 0) break block86;
|
|
v12 = var0[var4_5 - 1];
|
|
v13 = 39;
|
|
if (var16_3) break block87;
|
|
if (v12 == v13) break block86;
|
|
}
|
|
v11 = 1;
|
|
}
|
|
var9_10 = v11;
|
|
}
|
|
v12 = var5_6;
|
|
}
|
|
if (var16_3) break block88;
|
|
v13 = var0.length;
|
|
}
|
|
if (v12 >= v13) break block89;
|
|
v14 = (int)o.b(var0[var5_6]);
|
|
if (var16_3) break block90;
|
|
if (v14 == 0) break block91;
|
|
v14 = var0[var5_6];
|
|
if (var16_3) break block90;
|
|
if (v14 == 39) break block91;
|
|
}
|
|
v12 = 1;
|
|
}
|
|
var10_11 = v12;
|
|
}
|
|
v14 = var9_10;
|
|
}
|
|
if (var16_3) break block92;
|
|
if (v14 == 0) break block93;
|
|
v10 = var10_11;
|
|
if (var16_3) break block81;
|
|
if (v10 != 0) break block82;
|
|
}
|
|
v14 = 0;
|
|
}
|
|
var11_12 = v14;
|
|
var12_13 = var4_5 - 2;
|
|
v15 = var9_10;
|
|
if (var16_3) ** GOTO lbl155
|
|
if (v15 != 0) {
|
|
var12_13 = var4_5;
|
|
}
|
|
do {
|
|
block95: {
|
|
block103: {
|
|
block102: {
|
|
block98: {
|
|
block99: {
|
|
block100: {
|
|
block101: {
|
|
block71: {
|
|
block96: {
|
|
block97: {
|
|
block94: {
|
|
v15 = var11_12;
|
|
lbl155:
|
|
// 2 sources
|
|
|
|
if (v15 != 0) break;
|
|
v10 = var12_13;
|
|
if (var16_3) break block70;
|
|
v2 = var5_6;
|
|
if (var16_3) continue block1;
|
|
if (v10 >= v2) break;
|
|
v16 = var12_13;
|
|
if (var16_3) break block94;
|
|
if (v16 < 0) break block95;
|
|
v16 = (int)o.b(var0[var12_13]);
|
|
}
|
|
if (var16_3) break block96;
|
|
if (v16 == 0) break block97;
|
|
v16 = var0[var12_13];
|
|
if (var16_3) break block96;
|
|
if (v16 != 39) break block95;
|
|
}
|
|
v16 = 3;
|
|
}
|
|
var13_14 = new char[v16];
|
|
for (var14_15 = 0; var14_15 < 3; ++var14_15) {
|
|
v17 = var12_13 + var14_15;
|
|
if (!var16_3) {
|
|
v2 = var0.length;
|
|
if (var16_3) continue block1;
|
|
if (v17 >= v2) break;
|
|
v18 = var0;
|
|
v19 = var12_13 + var14_15;
|
|
if (!var16_3) {
|
|
if (o.b(v18[v19])) {
|
|
v18 = var0;
|
|
v19 = var12_13 + var14_15;
|
|
if (!var16_3) {
|
|
if (v18[v19] != '\'' && !var16_3) break;
|
|
}
|
|
} else {
|
|
v18 = var13_14;
|
|
v19 = var14_15;
|
|
}
|
|
}
|
|
v18[v19] = var0[var12_13 + var14_15];
|
|
if (!var16_3) continue;
|
|
}
|
|
break block71;
|
|
}
|
|
v17 = 1;
|
|
}
|
|
var15_16 = v17;
|
|
v20 = var14_15;
|
|
if (!var16_3) {
|
|
if (v20 == 0) {
|
|
var15_16 = 0;
|
|
}
|
|
v20 = var14_15;
|
|
}
|
|
if (var16_3) break block98;
|
|
if (v20 >= 3) break block99;
|
|
v20 = var12_13 - 1;
|
|
if (var16_3) break block98;
|
|
if (v20 < 0) break block99;
|
|
v21 = o.b(var0[var12_13 - 1]);
|
|
if (var16_3) break block100;
|
|
if (!v21) break block101;
|
|
v20 = var0[var12_13 - 1];
|
|
if (var16_3) break block98;
|
|
if (v20 != 39) break block99;
|
|
}
|
|
v21 = false;
|
|
}
|
|
var15_16 = (int)v21;
|
|
}
|
|
v20 = var15_16;
|
|
}
|
|
if (var16_3) break block102;
|
|
if (v20 == 0) break block95;
|
|
v20 = (int)o.f(var13_14);
|
|
}
|
|
if (var16_3) break block103;
|
|
if (v20 != 0) break block95;
|
|
v20 = 1;
|
|
}
|
|
var11_12 = v20;
|
|
}
|
|
++var12_13;
|
|
} while (!var16_3);
|
|
v10 = var11_12;
|
|
}
|
|
if (var16_3) break block81;
|
|
if (v10 == 0) {
|
|
var8_9 = 0;
|
|
}
|
|
}
|
|
v10 = var8_9;
|
|
}
|
|
if (var16_3) break block104;
|
|
if (v10 == 0) break block78;
|
|
v10 = var9_10 = var4_5;
|
|
}
|
|
while (var9_10 < var5_6) {
|
|
var0[var9_10] = 42;
|
|
++var9_10;
|
|
if (var16_3) continue block0;
|
|
if (!var16_3) continue;
|
|
}
|
|
}
|
|
++var4_5;
|
|
if (!var16_3) continue block0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public static boolean a(byte[][] var0, byte var1_1, byte var2_2) {
|
|
block15: {
|
|
var6_3 = q.d;
|
|
var3_4 = 0;
|
|
v0 = var0[0][0];
|
|
v1 = var1_1;
|
|
if (!var6_3) {
|
|
if (v0 == v1) {
|
|
v0 = var0[0][1];
|
|
v1 = var2_2;
|
|
if (!var6_3) {
|
|
if (v0 == v1) {
|
|
return true;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0.length;
|
|
v1 = 1;
|
|
}
|
|
}
|
|
var4_5 = v0 - v1;
|
|
v2 = var0[var4_5][0];
|
|
v3 = var1_1;
|
|
if (var6_3) ** GOTO lbl30
|
|
if (v2 != v3) break block15;
|
|
v2 = var0[var4_5][1];
|
|
v3 = var2_2;
|
|
if (!var6_3) {
|
|
if (v2 == v3) {
|
|
return true;
|
|
} else {
|
|
** GOTO lbl26
|
|
}
|
|
}
|
|
** GOTO lbl30
|
|
}
|
|
block0: while (true) {
|
|
block16: {
|
|
v2 = var3_4 + var4_5;
|
|
v3 = 2;
|
|
lbl30:
|
|
// 3 sources
|
|
|
|
if (var0[var5_6 = v2 / v3][0] != var1_1) break block16;
|
|
v4 = var0[var5_6][1];
|
|
v5 = var2_2;
|
|
if (!var6_3) {
|
|
if (v4 == v5) {
|
|
return true;
|
|
} else {
|
|
** GOTO lbl37
|
|
}
|
|
}
|
|
** GOTO lbl42
|
|
}
|
|
v4 = var1_1;
|
|
do {
|
|
block21: {
|
|
block19: {
|
|
block20: {
|
|
block17: {
|
|
block18: {
|
|
if (var6_3) break block17;
|
|
v5 = var0[var5_6][0];
|
|
lbl42:
|
|
// 2 sources
|
|
|
|
if (v4 < v5) break block18;
|
|
v6 = var1_1;
|
|
if (var6_3) break block19;
|
|
if (v6 != var0[var5_6][0]) break block20;
|
|
v6 = var2_2;
|
|
if (var6_3) break block19;
|
|
if (v6 >= var0[var5_6][1]) break block20;
|
|
}
|
|
v4 = var5_6;
|
|
}
|
|
var4_5 = v4;
|
|
if (!var6_3) break block21;
|
|
}
|
|
v6 = var5_6;
|
|
}
|
|
var3_4 = v6;
|
|
}
|
|
v7 = var3_4;
|
|
if (var6_3) break block0;
|
|
if (v7 != var4_5 && var3_4 + 1 != var4_5) continue block0;
|
|
v7 = 0;
|
|
} while (var6_3);
|
|
break;
|
|
}
|
|
return (boolean)v7;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static int a(char var0, char var1_1, char var2_2) {
|
|
block35: {
|
|
block36: {
|
|
var3_3 = q.d;
|
|
v0 = var0;
|
|
v1 = var1_1;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
}
|
|
v0 = var0;
|
|
v1 = 101;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v0 = var1_1;
|
|
v1 = 51;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0;
|
|
v1 = 116;
|
|
}
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v2 = var1_1;
|
|
if (var3_3 != false) return v2;
|
|
if (v2 == 55) return 1;
|
|
v0 = var1_1;
|
|
v1 = 43;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0;
|
|
v1 = 97;
|
|
}
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v3 = var1_1;
|
|
if (var3_3 != false) return v3;
|
|
if (v3 == 52) return 1;
|
|
v0 = var1_1;
|
|
v1 = 64;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0;
|
|
v1 = 111;
|
|
}
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v0 = var1_1;
|
|
v1 = 48;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0;
|
|
v1 = 105;
|
|
}
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v0 = var1_1;
|
|
v1 = 49;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0;
|
|
v1 = 115;
|
|
}
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v0 = var1_1;
|
|
v1 = 53;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0;
|
|
v1 = 102;
|
|
}
|
|
}
|
|
if (var3_3) break block35;
|
|
if (v0 != v1) break block36;
|
|
v0 = var1_1;
|
|
v1 = 112;
|
|
if (var3_3) break block35;
|
|
if (v0 == v1) {
|
|
v0 = var2_2;
|
|
v1 = 104;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 2;
|
|
} else {
|
|
** GOTO lbl88
|
|
}
|
|
} else {
|
|
** GOTO lbl87
|
|
}
|
|
}
|
|
break block36;
|
|
lbl87:
|
|
// 2 sources
|
|
|
|
break block35;
|
|
}
|
|
v0 = var0;
|
|
if (var3_3 != false) return v0;
|
|
v1 = 103;
|
|
}
|
|
if (v0 != v1) return 0;
|
|
v0 = var1_1;
|
|
if (var3_3 != false) return v0;
|
|
if (v0 == 57) return 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static int b(char var0, char var1_1, char var2_2) {
|
|
block106: {
|
|
block107: {
|
|
block104: {
|
|
block105: {
|
|
var3_3 = q.d;
|
|
v0 = var0;
|
|
v1 = 42;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = var1_1;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 1;
|
|
}
|
|
v0 = var0;
|
|
v1 = 97;
|
|
}
|
|
if (var3_3) break block104;
|
|
if (v0 < v1) break block105;
|
|
v0 = var0;
|
|
v1 = 122;
|
|
if (var3_3) break block104;
|
|
if (v0 <= v1) {
|
|
v0 = var0;
|
|
v1 = 101;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v2 = var1_1;
|
|
if (var3_3 != false) return v2;
|
|
if (v2 == 51) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 116;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v3 = var1_1;
|
|
if (var3_3 != false) return v3;
|
|
if (v3 == 55) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 97;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v4 = var1_1;
|
|
v5 = 52;
|
|
if (!var3_3) {
|
|
if (v4 == v5) return 1;
|
|
v4 = var1_1;
|
|
if (var3_3 != false) return v4;
|
|
v5 = 64;
|
|
}
|
|
if (v4 == v5) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 111;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v6 = var1_1;
|
|
if (var3_3 != false) return v6;
|
|
if (v6 == 48) return 1;
|
|
v7 = var1_1;
|
|
v8 = 42;
|
|
if (!var3_3) {
|
|
if (v7 == v8) {
|
|
return 1;
|
|
}
|
|
v7 = var1_1;
|
|
if (var3_3 != false) return v7;
|
|
v8 = 40;
|
|
}
|
|
if (v7 != v8) return 0;
|
|
v7 = var2_2;
|
|
if (var3_3 != false) return v7;
|
|
if (v7 == 41) return 2;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 105;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v9 = var1_1;
|
|
v10 = 121;
|
|
if (!var3_3) {
|
|
if (v9 == v10) return 1;
|
|
v9 = var1_1;
|
|
v10 = 108;
|
|
}
|
|
if (!var3_3) {
|
|
if (v9 == v10) return 1;
|
|
v9 = var1_1;
|
|
v10 = 106;
|
|
}
|
|
if (!var3_3) {
|
|
if (v9 == v10) return 1;
|
|
v9 = var1_1;
|
|
v10 = 49;
|
|
}
|
|
if (!var3_3) {
|
|
if (v9 == v10) return 1;
|
|
v9 = var1_1;
|
|
v10 = 33;
|
|
}
|
|
if (!var3_3) {
|
|
if (v9 == v10) return 1;
|
|
v9 = var1_1;
|
|
v10 = 58;
|
|
}
|
|
if (!var3_3) {
|
|
if (v9 == v10) return 1;
|
|
v9 = var1_1;
|
|
if (var3_3 != false) return v9;
|
|
v10 = 59;
|
|
}
|
|
if (v9 == v10) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 110;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 115;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v11 = var1_1;
|
|
v12 = 53;
|
|
if (!var3_3) {
|
|
if (v11 == v12) return 1;
|
|
v11 = var1_1;
|
|
v12 = 122;
|
|
}
|
|
if (!var3_3) {
|
|
if (v11 == v12) return 1;
|
|
v11 = var1_1;
|
|
if (var3_3 != false) return v11;
|
|
v12 = 36;
|
|
}
|
|
if (v11 == v12) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 114;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 104;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 108;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v13 = var1_1;
|
|
if (var3_3 != false) return v13;
|
|
if (v13 == 49) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 100;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 99;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v14 = var1_1;
|
|
if (var3_3 != false) return v14;
|
|
if (v14 == 40) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 117;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v15 = var1_1;
|
|
if (var3_3 != false) return v15;
|
|
if (v15 == 118) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 109;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 102;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v16 = var1_1;
|
|
if (var3_3 != false) return v16;
|
|
if (v16 != 112) return 0;
|
|
v16 = var2_2;
|
|
if (var3_3 != false) return v16;
|
|
if (v16 == 104) return 2;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 112;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 103;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v17 = var1_1;
|
|
v18 = 57;
|
|
if (!var3_3) {
|
|
if (v17 == v18) return 1;
|
|
v17 = var1_1;
|
|
if (var3_3 != false) return v17;
|
|
v18 = 54;
|
|
}
|
|
if (v17 == v18) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 119;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v19 = var1_1;
|
|
if (var3_3 != false) return v19;
|
|
if (v19 != 118) return 0;
|
|
v19 = var2_2;
|
|
if (var3_3 != false) return v19;
|
|
if (v19 == 118) return 2;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 121;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 98;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v20 = var1_1;
|
|
if (var3_3 != false) return v20;
|
|
if (v20 != 49) return 0;
|
|
v20 = var2_2;
|
|
if (var3_3 != false) return v20;
|
|
if (v20 == 51) return 2;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 118;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 107;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 120;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v21 = var1_1;
|
|
if (var3_3 != false) return v21;
|
|
if (v21 != 41) return 0;
|
|
v21 = var2_2;
|
|
if (var3_3 != false) return v21;
|
|
if (v21 == 40) return 2;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 106;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 113;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 122;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
} else {
|
|
** GOTO lbl262
|
|
}
|
|
} else {
|
|
** GOTO lbl261
|
|
}
|
|
}
|
|
break block105;
|
|
lbl261:
|
|
// 2 sources
|
|
|
|
break block104;
|
|
}
|
|
v0 = var0;
|
|
v1 = 48;
|
|
}
|
|
if (var3_3) break block106;
|
|
if (v0 < v1) break block107;
|
|
v0 = var0;
|
|
v1 = 57;
|
|
if (var3_3) break block106;
|
|
if (v0 <= v1) {
|
|
v0 = var0;
|
|
v1 = 48;
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v22 = var1_1;
|
|
if (var3_3 != false) return v22;
|
|
if (v22 == 111) return 1;
|
|
v23 = var1_1;
|
|
v24 = 79;
|
|
if (!var3_3) {
|
|
if (v23 == v24) {
|
|
return 1;
|
|
}
|
|
v23 = var1_1;
|
|
if (var3_3 != false) return v23;
|
|
v24 = 40;
|
|
}
|
|
if (v23 != v24) return 0;
|
|
v23 = var2_2;
|
|
if (var3_3 != false) return v23;
|
|
if (v23 == 41) return 2;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 49;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v25 = var1_1;
|
|
if (var3_3 != false) return v25;
|
|
if (v25 == 108) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 50;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 51;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 52;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 53;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 54;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 55;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 56;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 57;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
} else {
|
|
** GOTO lbl342
|
|
}
|
|
} else {
|
|
** GOTO lbl341
|
|
}
|
|
}
|
|
break block107;
|
|
lbl341:
|
|
// 2 sources
|
|
|
|
break block106;
|
|
}
|
|
v0 = var0;
|
|
v1 = 45;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 44;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v26 = var1_1;
|
|
if (var3_3 != false) return v26;
|
|
if (v26 == 46) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 46;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v27 = var1_1;
|
|
if (var3_3 != false) return v27;
|
|
if (v27 == 44) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 40;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 41;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
v1 = 33;
|
|
}
|
|
if (!var3_3) {
|
|
if (v0 == v1) {
|
|
v28 = var1_1;
|
|
if (var3_3 != false) return v28;
|
|
if (v28 == 105) return 1;
|
|
return 0;
|
|
}
|
|
v0 = var0;
|
|
if (var3_3 != false) return v0;
|
|
v1 = 39;
|
|
}
|
|
if (v0 == v1) return 0;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public static byte a(char var0) {
|
|
block14: {
|
|
block13: {
|
|
var1_1 = q.d;
|
|
v0 = var0;
|
|
v1 = 97;
|
|
if (!var1_1) {
|
|
if (v0 >= v1) {
|
|
v0 = var0;
|
|
v1 = 122;
|
|
if (!var1_1) {
|
|
if (v0 <= v1) {
|
|
return (byte)(var0 - 97 + 1);
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var0;
|
|
v1 = 39;
|
|
}
|
|
}
|
|
if (var1_1) break block13;
|
|
if (v0 == v1) {
|
|
return 28;
|
|
}
|
|
v0 = var0;
|
|
if (var1_1) break block14;
|
|
v1 = 48;
|
|
}
|
|
if (v0 >= v1) {
|
|
v0 = var0;
|
|
if (!var1_1) {
|
|
if (v0 <= 57) {
|
|
return (byte)(var0 - 48 + 29);
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = 27;
|
|
}
|
|
}
|
|
return (byte)v0;
|
|
}
|
|
|
|
public static void e(char[] cArray) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
int n2 = 0;
|
|
int n3 = 0;
|
|
int n4 = 0;
|
|
int n5 = 0;
|
|
block0: while (true) {
|
|
int n6 = o.a(cArray, n3);
|
|
int n7 = -1;
|
|
block1: while (n6 != n7) {
|
|
block22: {
|
|
int n8;
|
|
block25: {
|
|
block24: {
|
|
block21: {
|
|
int n9;
|
|
block23: {
|
|
int n10;
|
|
int n11;
|
|
block20: {
|
|
int n12 = 0;
|
|
for (n11 = n3; n11 >= 0; ++n11) {
|
|
n10 = n11;
|
|
if (!bl) {
|
|
n7 = n2;
|
|
if (bl) continue block1;
|
|
if (n10 >= n7) break;
|
|
n10 = n12;
|
|
if (!bl) {
|
|
if (n10 != 0) break;
|
|
boolean bl3 = o.b(cArray[n11]);
|
|
if (!bl) {
|
|
if (bl3) continue;
|
|
bl3 = o.c(cArray[n11]);
|
|
}
|
|
if (!bl) {
|
|
if (bl3) continue;
|
|
bl3 = true;
|
|
}
|
|
n12 = bl3 ? 1 : 0;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
break block20;
|
|
}
|
|
n10 = n12;
|
|
}
|
|
if (!bl) {
|
|
if (n10 != 0) {
|
|
n4 = 0;
|
|
}
|
|
n10 = n4;
|
|
}
|
|
if (!bl) {
|
|
if (n10 == 0) {
|
|
n5 = n2;
|
|
}
|
|
n3 = o.b(cArray, n2);
|
|
n11 = 0;
|
|
n10 = n8 = n2;
|
|
}
|
|
while (n8 < n3) {
|
|
n11 = n11 * 10 + cArray[n8] - 48;
|
|
++n8;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block21;
|
|
}
|
|
n9 = n11;
|
|
if (bl) break block21;
|
|
if (n9 > 255) break block23;
|
|
n9 = n3 - n2;
|
|
if (bl) break block21;
|
|
if (n9 <= 8) break block24;
|
|
}
|
|
n9 = n4 = 0;
|
|
}
|
|
if (!bl) break block25;
|
|
}
|
|
++n4;
|
|
}
|
|
if (n4 != 4) continue block0;
|
|
for (n8 = n5; n8 < n3; ++n8) {
|
|
cArray[n8] = 42;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block22;
|
|
}
|
|
n4 = 0;
|
|
}
|
|
if (bl) break block0;
|
|
continue block0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static int a(char[] cArray, int n2) {
|
|
int n3;
|
|
block3: {
|
|
boolean bl = q.d;
|
|
for (int i2 = n2; i2 < cArray.length; ++i2) {
|
|
int n4;
|
|
block5: {
|
|
int n5;
|
|
block4: {
|
|
n3 = i2;
|
|
if (bl || bl) break block3;
|
|
if (n3 < 0) break;
|
|
n4 = cArray[i2];
|
|
n5 = 48;
|
|
if (bl) break block4;
|
|
if (n4 < n5) continue;
|
|
n4 = cArray[i2];
|
|
if (bl) break block5;
|
|
n5 = 57;
|
|
}
|
|
if (n4 > n5) continue;
|
|
n4 = i2;
|
|
}
|
|
return n4;
|
|
}
|
|
n3 = -1;
|
|
}
|
|
return n3;
|
|
}
|
|
|
|
public static int b(char[] cArray, int n2) {
|
|
int n3;
|
|
block6: {
|
|
boolean bl = q.d;
|
|
for (int i2 = n2; i2 < cArray.length; ++i2) {
|
|
n3 = i2;
|
|
if (!bl && !bl) {
|
|
if (n3 < 0) break;
|
|
int n4 = cArray[i2];
|
|
if (!bl) {
|
|
if (n4 >= 48) {
|
|
n4 = cArray[i2];
|
|
if (!bl) {
|
|
if (n4 <= 57) continue;
|
|
}
|
|
} else {
|
|
n4 = i2;
|
|
}
|
|
}
|
|
return n4;
|
|
}
|
|
break block6;
|
|
}
|
|
n3 = cArray.length;
|
|
}
|
|
return n3;
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static boolean b(char c2) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = o.d(c2);
|
|
if (!bl) {
|
|
if (bl2) return false;
|
|
bl2 = o.e(c2);
|
|
}
|
|
if (bl) return bl2;
|
|
if (bl2) return false;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static boolean c(char c2) {
|
|
boolean bl = q.d;
|
|
int n2 = c2;
|
|
if (bl) return n2 != 0;
|
|
if (n2 < 97) return 1 != 0;
|
|
int n3 = c2;
|
|
int n4 = 122;
|
|
if (!bl) {
|
|
if (n3 > n4) {
|
|
return 1 != 0;
|
|
}
|
|
n3 = c2;
|
|
if (bl) return n3 != 0;
|
|
n4 = 118;
|
|
}
|
|
if (n3 == n4) return 1 != 0;
|
|
n3 = c2;
|
|
if (bl) return n3 != 0;
|
|
if (n3 == 120) return 1 != 0;
|
|
n3 = c2;
|
|
if (bl) return n3 != 0;
|
|
if (n3 == 106) return 1 != 0;
|
|
n3 = c2;
|
|
if (bl) return n3 != 0;
|
|
if (n3 == 113) return 1 != 0;
|
|
n3 = c2;
|
|
if (bl) return n3 != 0;
|
|
if (n3 != 122) return 0 != 0;
|
|
return 1 != 0;
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static boolean d(char n2) {
|
|
boolean bl = q.d;
|
|
int n3 = n2;
|
|
int n4 = 97;
|
|
if (!bl) {
|
|
if (n3 >= n4) {
|
|
n3 = n2;
|
|
if (bl) return n3 != 0;
|
|
if (n3 <= 122) return 1 != 0;
|
|
}
|
|
n3 = n2;
|
|
n4 = 65;
|
|
}
|
|
if (!bl) {
|
|
if (n3 < n4) return 0 != 0;
|
|
n3 = n2;
|
|
if (bl) return n3 != 0;
|
|
n4 = 90;
|
|
}
|
|
if (n3 > n4) return 0 != 0;
|
|
return 1 != 0;
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static boolean e(char c2) {
|
|
boolean bl = q.d;
|
|
int n2 = c2;
|
|
int n3 = 48;
|
|
if (!bl) {
|
|
if (n2 < n3) return 0 != 0;
|
|
n2 = c2;
|
|
if (bl) return n2 != 0;
|
|
n3 = 57;
|
|
}
|
|
if (n2 > n3) return 0 != 0;
|
|
return 1 != 0;
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static boolean f(char c2) {
|
|
boolean bl = q.d;
|
|
int n2 = c2;
|
|
int n3 = 97;
|
|
if (!bl) {
|
|
if (n2 < n3) return 0 != 0;
|
|
n2 = c2;
|
|
if (bl) return n2 != 0;
|
|
n3 = 122;
|
|
}
|
|
if (n2 > n3) return 0 != 0;
|
|
return 1 != 0;
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public static boolean g(char c2) {
|
|
boolean bl = q.d;
|
|
int n2 = c2;
|
|
int n3 = 65;
|
|
if (!bl) {
|
|
if (n2 < n3) return 0 != 0;
|
|
n2 = c2;
|
|
if (bl) return n2 != 0;
|
|
n3 = 90;
|
|
}
|
|
if (n2 > n3) return 0 != 0;
|
|
return 1 != 0;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
* Could not resolve type clashes
|
|
*/
|
|
public static boolean f(char[] var0) {
|
|
block20: {
|
|
block18: {
|
|
block19: {
|
|
block17: {
|
|
var7_1 = q.d;
|
|
var1_2 = false;
|
|
var2_3 = 1;
|
|
for (var3_4 = 0; var3_4 < var0.length; ++var3_4) {
|
|
v0 = o.e(var0[var3_4]);
|
|
if (!var7_1) {
|
|
if (!var7_1) {
|
|
if (v0 != 0) continue;
|
|
v1 = var0[var3_4];
|
|
}
|
|
if (!var7_1) {
|
|
if (v1 == false) continue;
|
|
v1 = '\u0000';
|
|
}
|
|
var2_3 = v1;
|
|
if (!var7_1) continue;
|
|
}
|
|
break block17;
|
|
}
|
|
v0 = var2_3;
|
|
}
|
|
if (!var7_1) {
|
|
if (v0 != 0) {
|
|
return true;
|
|
}
|
|
var3_4 = o.g(var0);
|
|
v0 = 0;
|
|
}
|
|
var4_5 = v0;
|
|
var5_6 = o.e.length - 1;
|
|
v2 = var3_4;
|
|
if (var7_1) break block18;
|
|
if (v2 == o.e[0]) break block19;
|
|
v3 = var3_4;
|
|
v4 = o.e[var5_6];
|
|
if (var7_1) ** GOTO lbl40
|
|
if (v3 != v4) break block20;
|
|
}
|
|
v2 = 1;
|
|
}
|
|
return (boolean)v2;
|
|
}
|
|
block1: while (true) {
|
|
v3 = var4_5 + var5_6;
|
|
v4 = 2;
|
|
lbl40:
|
|
// 2 sources
|
|
|
|
if (var3_4 == o.e[var6_7 = v3 / v4]) {
|
|
return true;
|
|
}
|
|
v5 = var3_4;
|
|
do {
|
|
block23: {
|
|
block21: {
|
|
block22: {
|
|
if (var7_1) break block21;
|
|
if (v5 >= o.e[var6_7]) break block22;
|
|
var5_6 = var6_7;
|
|
if (!var7_1) break block23;
|
|
}
|
|
v5 = var6_7;
|
|
}
|
|
var4_5 = v5;
|
|
}
|
|
v6 = var4_5;
|
|
if (var7_1) break block1;
|
|
if (v6 != var5_6 && var4_5 + 1 != var5_6) continue block1;
|
|
v6 = 0;
|
|
} while (var7_1);
|
|
break;
|
|
}
|
|
return (boolean)v6;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public static int g(char[] var0) {
|
|
block17: {
|
|
var5_1 = q.d;
|
|
var1_2 = false;
|
|
v0 = var0.length;
|
|
if (!var5_1) {
|
|
if (v0 > 6) {
|
|
return 0;
|
|
}
|
|
v0 = 0;
|
|
}
|
|
var2_3 = v0;
|
|
for (var3_4 = 0; var3_4 < var0.length; ++var3_4) {
|
|
block19: {
|
|
block18: {
|
|
v1 = var4_5 = var0[var0.length - var3_4 - 1];
|
|
if (var5_1) break block17;
|
|
v2 = 97;
|
|
if (!var5_1) {
|
|
if (v1 >= v2) {
|
|
v3 = var4_5;
|
|
v2 = 122;
|
|
if (!var5_1) {
|
|
if (v3 <= v2) {
|
|
var2_3 = var2_3 * 38 + (var4_5 - 97 + 1);
|
|
if (!var5_1) continue;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 4 sources
|
|
|
|
{
|
|
v3 = var4_5;
|
|
v2 = 39;
|
|
}
|
|
}
|
|
if (var5_1) break block18;
|
|
if (v3 == v2) {
|
|
var2_3 = var2_3 * 38 + 27;
|
|
if (!var5_1) continue;
|
|
}
|
|
v3 = var4_5;
|
|
if (var5_1) break block19;
|
|
v2 = 48;
|
|
}
|
|
if (v3 >= v2) {
|
|
v3 = var4_5;
|
|
if (!var5_1) {
|
|
if (v3 <= 57) {
|
|
var2_3 = var2_3 * 38 + (var4_5 - 48 + 28);
|
|
if (!var5_1) continue;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 4 sources
|
|
|
|
{
|
|
v3 = var4_5;
|
|
}
|
|
}
|
|
if (!var5_1) {
|
|
if (v3 == 0) continue;
|
|
v3 = 0;
|
|
}
|
|
return v3;
|
|
}
|
|
v1 = var2_3;
|
|
}
|
|
return v1;
|
|
}
|
|
|
|
/*
|
|
* Handled impossible loop by duplicating code
|
|
* Enabled aggressive block sorting
|
|
*/
|
|
static {
|
|
char[] cArray;
|
|
String[] stringArray;
|
|
block54: {
|
|
int n2;
|
|
int n3;
|
|
char[] cArray2;
|
|
int n4;
|
|
block53: {
|
|
char[] cArray3;
|
|
Object var0;
|
|
block52: {
|
|
int n5;
|
|
int n6;
|
|
char[] cArray4;
|
|
block51: {
|
|
char[] cArray5;
|
|
block50: {
|
|
int n7;
|
|
int n8;
|
|
char[] cArray6;
|
|
block49: {
|
|
char[] cArray7;
|
|
block48: {
|
|
int n9;
|
|
int n10;
|
|
char[] cArray8;
|
|
block47: {
|
|
char[] cArray9;
|
|
block46: {
|
|
int n11;
|
|
int n12;
|
|
char[] cArray10;
|
|
block45: {
|
|
c = true;
|
|
d = 3;
|
|
stringArray = new String[5];
|
|
var0 = null;
|
|
char[] cArray11 = "h\u0015fj".toCharArray();
|
|
n4 = 0;
|
|
int n13 = cArray11.length;
|
|
cArray10 = cArray11;
|
|
n12 = n13;
|
|
if (n13 <= 1) break block45;
|
|
cArray9 = cArray10;
|
|
n11 = n12;
|
|
if (n12 <= n4) break block46;
|
|
}
|
|
do {
|
|
char[] cArray12 = cArray10;
|
|
char[] cArray13 = cArray10;
|
|
int n14 = n4;
|
|
while (true) {
|
|
int n15;
|
|
char c2 = cArray12[n14];
|
|
switch (n4 % 5) {
|
|
case 0: {
|
|
n15 = 11;
|
|
break;
|
|
}
|
|
case 1: {
|
|
n15 = 122;
|
|
break;
|
|
}
|
|
case 2: {
|
|
n15 = 9;
|
|
break;
|
|
}
|
|
case 3: {
|
|
n15 = 1;
|
|
break;
|
|
}
|
|
default: {
|
|
n15 = 94;
|
|
}
|
|
}
|
|
cArray12[n14] = (char)(c2 ^ n15);
|
|
++n4;
|
|
cArray10 = cArray13;
|
|
n12 = n12;
|
|
if (n12 != 0) break;
|
|
cArray13 = cArray10;
|
|
n11 = n12;
|
|
n14 = n12;
|
|
cArray12 = cArray10;
|
|
}
|
|
cArray9 = cArray10;
|
|
n11 = n12;
|
|
} while (n12 > n4);
|
|
}
|
|
stringArray[0] = new String(cArray9).intern();
|
|
var0 = null;
|
|
char[] cArray14 = "h\u0015fjyx".toCharArray();
|
|
n4 = 0;
|
|
int n16 = cArray14.length;
|
|
cArray8 = cArray14;
|
|
n10 = n16;
|
|
if (n16 <= 1) break block47;
|
|
cArray7 = cArray8;
|
|
n9 = n10;
|
|
if (n10 <= n4) break block48;
|
|
}
|
|
do {
|
|
char[] cArray15 = cArray8;
|
|
char[] cArray16 = cArray8;
|
|
int n17 = n4;
|
|
while (true) {
|
|
int n18;
|
|
char c3 = cArray15[n17];
|
|
switch (n4 % 5) {
|
|
case 0: {
|
|
n18 = 11;
|
|
break;
|
|
}
|
|
case 1: {
|
|
n18 = 122;
|
|
break;
|
|
}
|
|
case 2: {
|
|
n18 = 9;
|
|
break;
|
|
}
|
|
case 3: {
|
|
n18 = 1;
|
|
break;
|
|
}
|
|
default: {
|
|
n18 = 94;
|
|
}
|
|
}
|
|
cArray15[n17] = (char)(c3 ^ n18);
|
|
++n4;
|
|
cArray8 = cArray16;
|
|
n10 = n10;
|
|
if (n10 != 0) break;
|
|
cArray16 = cArray8;
|
|
n9 = n10;
|
|
n17 = n10;
|
|
cArray15 = cArray8;
|
|
}
|
|
cArray7 = cArray8;
|
|
n9 = n10;
|
|
} while (n10 > n4);
|
|
}
|
|
stringArray[1] = new String(cArray7).intern();
|
|
var0 = null;
|
|
char[] cArray17 = "h\u0015fj-".toCharArray();
|
|
n4 = 0;
|
|
int n19 = cArray17.length;
|
|
cArray6 = cArray17;
|
|
n8 = n19;
|
|
if (n19 <= 1) break block49;
|
|
cArray5 = cArray6;
|
|
n7 = n8;
|
|
if (n8 <= n4) break block50;
|
|
}
|
|
do {
|
|
char[] cArray18 = cArray6;
|
|
char[] cArray19 = cArray6;
|
|
int n20 = n4;
|
|
while (true) {
|
|
int n21;
|
|
char c4 = cArray18[n20];
|
|
switch (n4 % 5) {
|
|
case 0: {
|
|
n21 = 11;
|
|
break;
|
|
}
|
|
case 1: {
|
|
n21 = 122;
|
|
break;
|
|
}
|
|
case 2: {
|
|
n21 = 9;
|
|
break;
|
|
}
|
|
case 3: {
|
|
n21 = 1;
|
|
break;
|
|
}
|
|
default: {
|
|
n21 = 94;
|
|
}
|
|
}
|
|
cArray18[n20] = (char)(c4 ^ n21);
|
|
++n4;
|
|
cArray6 = cArray19;
|
|
n8 = n8;
|
|
if (n8 != 0) break;
|
|
cArray19 = cArray6;
|
|
n7 = n8;
|
|
n20 = n8;
|
|
cArray18 = cArray6;
|
|
}
|
|
cArray5 = cArray6;
|
|
n7 = n8;
|
|
} while (n8 > n4);
|
|
}
|
|
stringArray[2] = new String(cArray5).intern();
|
|
var0 = null;
|
|
char[] cArray20 = "x\u001flj-".toCharArray();
|
|
n4 = 0;
|
|
int n22 = cArray20.length;
|
|
cArray4 = cArray20;
|
|
n6 = n22;
|
|
if (n22 <= 1) break block51;
|
|
cArray3 = cArray4;
|
|
n5 = n6;
|
|
if (n6 <= n4) break block52;
|
|
}
|
|
do {
|
|
char[] cArray21 = cArray4;
|
|
char[] cArray22 = cArray4;
|
|
int n23 = n4;
|
|
while (true) {
|
|
int n24;
|
|
char c5 = cArray21[n23];
|
|
switch (n4 % 5) {
|
|
case 0: {
|
|
n24 = 11;
|
|
break;
|
|
}
|
|
case 1: {
|
|
n24 = 122;
|
|
break;
|
|
}
|
|
case 2: {
|
|
n24 = 9;
|
|
break;
|
|
}
|
|
case 3: {
|
|
n24 = 1;
|
|
break;
|
|
}
|
|
default: {
|
|
n24 = 94;
|
|
}
|
|
}
|
|
cArray21[n23] = (char)(c5 ^ n24);
|
|
++n4;
|
|
cArray4 = cArray22;
|
|
n6 = n6;
|
|
if (n6 != 0) break;
|
|
cArray22 = cArray4;
|
|
n5 = n6;
|
|
n23 = n6;
|
|
cArray21 = cArray4;
|
|
}
|
|
cArray3 = cArray4;
|
|
n5 = n6;
|
|
} while (n6 > n4);
|
|
}
|
|
stringArray[3] = new String(cArray3).intern();
|
|
var0 = null;
|
|
char[] cArray23 = "x\u0012ld*".toCharArray();
|
|
n4 = 0;
|
|
int n25 = cArray23.length;
|
|
cArray2 = cArray23;
|
|
n3 = n25;
|
|
if (n25 <= 1) break block53;
|
|
cArray = cArray2;
|
|
n2 = n3;
|
|
if (n3 <= n4) break block54;
|
|
}
|
|
do {
|
|
char[] cArray24 = cArray2;
|
|
char[] cArray25 = cArray2;
|
|
int n26 = n4;
|
|
while (true) {
|
|
int n27;
|
|
char c6 = cArray24[n26];
|
|
switch (n4 % 5) {
|
|
case 0: {
|
|
n27 = 11;
|
|
break;
|
|
}
|
|
case 1: {
|
|
n27 = 122;
|
|
break;
|
|
}
|
|
case 2: {
|
|
n27 = 9;
|
|
break;
|
|
}
|
|
case 3: {
|
|
n27 = 1;
|
|
break;
|
|
}
|
|
default: {
|
|
n27 = 94;
|
|
}
|
|
}
|
|
cArray24[n26] = (char)(c6 ^ n27);
|
|
++n4;
|
|
cArray2 = cArray25;
|
|
n3 = n3;
|
|
if (n3 != 0) break;
|
|
cArray25 = cArray2;
|
|
n2 = n3;
|
|
n26 = n3;
|
|
cArray24 = cArray2;
|
|
}
|
|
cArray = cArray2;
|
|
n2 = n3;
|
|
} while (n3 > n4);
|
|
}
|
|
stringArray[4] = new String(cArray).intern();
|
|
l = stringArray;
|
|
}
|
|
}
|
|
|