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.
5870 lines
387 KiB
Java
5870 lines
387 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
public class f {
|
|
int a;
|
|
int[] b;
|
|
int[][] c;
|
|
int[] d;
|
|
public int e;
|
|
public int f;
|
|
public int g;
|
|
public int h;
|
|
public int i;
|
|
public int j;
|
|
public static int[] k;
|
|
private static int[] l;
|
|
public boolean m;
|
|
public double n;
|
|
public int o;
|
|
private boolean p;
|
|
private int q;
|
|
private int r;
|
|
private int s;
|
|
private int t;
|
|
private l[] u;
|
|
private int[] v;
|
|
private int w;
|
|
private int x;
|
|
private int y;
|
|
private int z;
|
|
private int A;
|
|
private int B;
|
|
private int C;
|
|
private int D;
|
|
private int E;
|
|
private int F;
|
|
private int G;
|
|
private int H;
|
|
private int I;
|
|
public int J;
|
|
public int K;
|
|
public l[] L;
|
|
private int[] M;
|
|
private int N;
|
|
private g[] O;
|
|
private int P;
|
|
private int[] Q;
|
|
private int[] R;
|
|
private int[] S;
|
|
private int[] T;
|
|
private int[] U;
|
|
private int[] V;
|
|
private int[] W;
|
|
public l X;
|
|
int Y;
|
|
byte[][] Z;
|
|
int[][] ab;
|
|
int[] bb;
|
|
long[] cb;
|
|
int[][] db;
|
|
boolean[] eb;
|
|
private static long fb;
|
|
int[][] gb;
|
|
int[][] hb;
|
|
private static byte[] ib;
|
|
private static int[] jb;
|
|
h kb;
|
|
public int[] lb;
|
|
p[] mb;
|
|
int nb;
|
|
int ob;
|
|
int[] pb;
|
|
int[] qb;
|
|
int[] rb;
|
|
int[] sb;
|
|
int[] tb;
|
|
int[] ub;
|
|
boolean vb;
|
|
static int wb;
|
|
static int xb;
|
|
static int yb;
|
|
static int zb;
|
|
static int Ab;
|
|
static int Bb;
|
|
int Cb;
|
|
int Db;
|
|
private static String Eb;
|
|
|
|
public f(h h2, int n2, int n3, int n4) {
|
|
int n5;
|
|
boolean bl;
|
|
block8: {
|
|
block7: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
this.a = 50;
|
|
this.b = new int[this.a];
|
|
this.c = new int[this.a][256];
|
|
this.f = 5;
|
|
this.g = 1000;
|
|
this.h = 1000;
|
|
this.i = 20;
|
|
this.j = 10;
|
|
this.m = false;
|
|
this.n = 1.1;
|
|
this.o = 1;
|
|
this.p = false;
|
|
this.t = 100;
|
|
this.u = new l[this.t];
|
|
this.v = new int[this.t];
|
|
this.w = 512;
|
|
this.x = 256;
|
|
this.y = 192;
|
|
this.z = 256;
|
|
this.A = 256;
|
|
this.B = 8;
|
|
this.C = 4;
|
|
this.pb = new int[40];
|
|
this.qb = new int[40];
|
|
this.rb = new int[40];
|
|
this.sb = new int[40];
|
|
this.tb = new int[40];
|
|
this.ub = new int[40];
|
|
this.vb = false;
|
|
this.kb = h2;
|
|
this.x = h2.a / 2;
|
|
this.y = h2.b / 2;
|
|
this.lb = h2.g;
|
|
this.J = 0;
|
|
this.K = n2;
|
|
this.L = new l[this.K];
|
|
this.M = new int[this.K];
|
|
this.N = 0;
|
|
this.O = new g[n3];
|
|
for (n5 = 0; n5 < n3; ++n5) {
|
|
this.O[n5] = new g();
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
this.P = 0;
|
|
this.X = new l(n4 * 2, n4);
|
|
this.Q = new int[n4];
|
|
this.U = new int[n4];
|
|
this.V = new int[n4];
|
|
this.R = new int[n4];
|
|
this.S = new int[n4];
|
|
this.T = new int[n4];
|
|
this.W = new int[n4];
|
|
}
|
|
if (!bl) {
|
|
if (ib == null) {
|
|
ib = new byte[17691];
|
|
}
|
|
this.D = 0;
|
|
this.E = 0;
|
|
this.F = 0;
|
|
this.G = 0;
|
|
this.H = 0;
|
|
this.I = 0;
|
|
}
|
|
for (n5 = 0; n5 < 256; ++n5) {
|
|
f.l[n5] = (int)(Math.sin((double)n5 * 0.02454369) * 32768.0);
|
|
f.l[n5 + 256] = (int)(Math.cos((double)n5 * 0.02454369) * 32768.0);
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block8;
|
|
}
|
|
n5 = 0;
|
|
}
|
|
while (n5 < 1024) {
|
|
f.k[n5] = (int)(Math.sin((double)n5 * 0.00613592315) * 32768.0);
|
|
f.k[n5 + 1024] = (int)(Math.cos((double)n5 * 0.00613592315) * 32768.0);
|
|
++n5;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public void a(l l2) {
|
|
block5: {
|
|
block4: {
|
|
if (l2 == null) {
|
|
System.out.println(Eb);
|
|
}
|
|
f f2 = this;
|
|
if (q.d) break block4;
|
|
if (f2.J >= this.K) break block5;
|
|
this.M[this.J] = 0;
|
|
f2 = this;
|
|
}
|
|
f2.L[this.J++] = l2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Enabled aggressive block sorting
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public void b(l l2) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
int n2 = 0;
|
|
block0: do {
|
|
block5: {
|
|
f f2;
|
|
block4: {
|
|
if (n2 >= this.J) return;
|
|
f2 = this;
|
|
if (bl) break block4;
|
|
if (f2.L[n2] != l2) break block5;
|
|
f2 = this;
|
|
}
|
|
--f2.J;
|
|
for (int i2 = n2; i2 < this.J; ++i2) {
|
|
this.L[i2] = this.L[i2 + 1];
|
|
this.M[i2] = this.M[i2 + 1];
|
|
if (bl) continue block0;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
++n2;
|
|
} while (!bl);
|
|
}
|
|
|
|
public void a() {
|
|
block2: {
|
|
boolean bl = q.d;
|
|
this.b();
|
|
for (int i2 = 0; i2 < this.J; ++i2) {
|
|
this.L[i2] = null;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block2;
|
|
}
|
|
this.J = 0;
|
|
}
|
|
}
|
|
|
|
public void b() {
|
|
this.P = 0;
|
|
this.X.b();
|
|
}
|
|
|
|
public void a(int n2) {
|
|
block3: {
|
|
block2: {
|
|
this.P -= n2;
|
|
this.X.b(n2, n2 * 2);
|
|
f f2 = this;
|
|
if (q.d) break block2;
|
|
if (f2.P >= 0) break block3;
|
|
f2 = this;
|
|
}
|
|
f2.P = 0;
|
|
}
|
|
}
|
|
|
|
public int a(int n2, int n3, int n4, int n5, int n6, int n7, int n8) {
|
|
this.Q[this.P] = n2;
|
|
this.R[this.P] = n3;
|
|
this.S[this.P] = n4;
|
|
this.T[this.P] = n5;
|
|
this.U[this.P] = n6;
|
|
this.V[this.P] = n7;
|
|
this.W[this.P] = 0;
|
|
int n9 = this.X.b(n3, n4, n5);
|
|
int n10 = this.X.b(n3, n4 - n7, n5);
|
|
int[] nArray = new int[]{n9, n10};
|
|
this.X.a(2, nArray, 0, 0);
|
|
this.X.G[this.P] = n8;
|
|
this.X.H[this.P++] = 0;
|
|
return this.P - 1;
|
|
}
|
|
|
|
public void b(int n2) {
|
|
this.X.H[n2] = 1;
|
|
}
|
|
|
|
public void a(int n2, int n3) {
|
|
this.W[n2] = n3;
|
|
}
|
|
|
|
public void b(int n2, int n3) {
|
|
this.q = n2 - this.z;
|
|
this.r = n3;
|
|
this.s = 0;
|
|
this.p = true;
|
|
}
|
|
|
|
public int c() {
|
|
return this.s;
|
|
}
|
|
|
|
public int[] d() {
|
|
return this.v;
|
|
}
|
|
|
|
public l[] e() {
|
|
return this.u;
|
|
}
|
|
|
|
public void a(int n2, int n3, int n4, int n5, int n6, int n7) {
|
|
this.x = n4;
|
|
this.y = n5;
|
|
this.z = n2;
|
|
this.A = n3;
|
|
this.w = n6;
|
|
this.B = n7;
|
|
this.mb = new p[n5 + n3];
|
|
for (int i2 = 0; i2 < n5 + n3; ++i2) {
|
|
this.mb[i2] = new p();
|
|
if (!q.d) continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Exception decompiling
|
|
*/
|
|
private void a(g[] var1_1, int var2_2, int var3_3) {
|
|
/*
|
|
* 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: Tried to end blocks [1[DOLOOP]], but top level block is 3[DOLOOP]
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.Op04StructuredStatement.processEndingBlocks(Op04StructuredStatement.java:435)
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.Op04StructuredStatement.buildNestedBlocks(Op04StructuredStatement.java:484)
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.Op03SimpleStatement.createInitialStructuredBlock(Op03SimpleStatement.java:736)
|
|
* at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisInner(CodeAnalyser.java:850)
|
|
* 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");
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public void a(int var1_1, g[] var2_2, int var3_3) {
|
|
block15: {
|
|
var11_4 = q.d;
|
|
var4_5 = false;
|
|
for (var5_6 = 0; var5_6 <= var3_3; ++var5_6) {
|
|
var2_2[var5_6].o = false;
|
|
var2_2[var5_6].p = var5_6;
|
|
var2_2[var5_6].q = -1;
|
|
if (!var11_4) {
|
|
if (!var11_4) continue;
|
|
}
|
|
break block15;
|
|
}
|
|
var5_6 = 0;
|
|
}
|
|
block1: while (true) {
|
|
if (var2_2[var5_6].o) {
|
|
++var5_6;
|
|
if (!var11_4) continue;
|
|
}
|
|
v0 = var5_6;
|
|
v1 = var3_3;
|
|
block2: while (true) {
|
|
if (v0 == v1) {
|
|
return;
|
|
}
|
|
var6_7 = var2_2[var5_6];
|
|
var6_7.o = true;
|
|
var7_8 = var5_6;
|
|
v2 = var8_9 = var5_6 + var1_1;
|
|
if (!var11_4) {
|
|
if (v2 >= var3_3) {
|
|
var8_9 = var3_3 - 1;
|
|
}
|
|
v2 = var9_10 = var8_9;
|
|
}
|
|
while (true) {
|
|
block16: {
|
|
block22: {
|
|
block21: {
|
|
block20: {
|
|
block19: {
|
|
block18: {
|
|
block17: {
|
|
if (var9_10 >= var7_8 + 1) ** break;
|
|
continue block1;
|
|
var10_11 = var2_2[var9_10];
|
|
if (var11_4) continue;
|
|
v0 = var6_7.a;
|
|
v1 = var10_11.c;
|
|
if (var11_4 || var11_4) continue block2;
|
|
if (v0 >= v1) break block16;
|
|
v3 = var10_11.a;
|
|
v4 = var6_7.c;
|
|
if (var11_4) break block17;
|
|
if (v3 >= v4) break block16;
|
|
v3 = var6_7.b;
|
|
v4 = var10_11.d;
|
|
}
|
|
if (var11_4) break block18;
|
|
if (v3 >= v4) break block16;
|
|
v3 = var10_11.b;
|
|
v4 = var6_7.d;
|
|
}
|
|
if (var11_4) break block19;
|
|
if (v3 >= v4) break block16;
|
|
v3 = var6_7.p;
|
|
if (var11_4) break block20;
|
|
v4 = var10_11.q;
|
|
}
|
|
if (v3 == v4) break block16;
|
|
v3 = (int)this.a(var6_7, var10_11);
|
|
}
|
|
if (var11_4) break block21;
|
|
if (v3 != 0) break block16;
|
|
v3 = (int)this.b(var10_11, var6_7);
|
|
}
|
|
if (var11_4) break block22;
|
|
if (v3 == 0) break block16;
|
|
v3 = (int)this.b(var2_2, var7_8, var9_10);
|
|
}
|
|
v5 = var2_2[var9_10];
|
|
v6 = var10_11;
|
|
if (!var11_4) {
|
|
if (v5 != v6) {
|
|
++var9_10;
|
|
}
|
|
var7_8 = this.Cb;
|
|
v5 = var10_11;
|
|
v6 = var6_7;
|
|
}
|
|
v5.q = v6.p;
|
|
}
|
|
--var9_10;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public boolean b(g[] gArray, int n2, int n3) {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
while (true) {
|
|
int n4;
|
|
block15: {
|
|
int n5;
|
|
g g2 = gArray[n2];
|
|
int n6 = n5 = n2 + 1;
|
|
while (n5 <= n3) {
|
|
block17: {
|
|
int n7;
|
|
block16: {
|
|
g g3 = gArray[n5];
|
|
n6 = this.a(g3, g2) ? 1 : 0;
|
|
if (bl) continue;
|
|
if (bl) break block16;
|
|
if (n6 == 0 && !bl) break;
|
|
gArray[n2] = g3;
|
|
gArray[n5] = g2;
|
|
n2 = n5;
|
|
if (bl) break block17;
|
|
n7 = n2;
|
|
}
|
|
if (n7 == n3) {
|
|
this.Cb = n2;
|
|
this.Db = n2 - 1;
|
|
return true;
|
|
}
|
|
++n5;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
g g4 = gArray[n3];
|
|
int n8 = n3 - 1;
|
|
while (n8 >= n2) {
|
|
block19: {
|
|
int n9;
|
|
block18: {
|
|
g g5 = gArray[n8];
|
|
n4 = this.a(g4, g5) ? 1 : 0;
|
|
if (bl) break block15;
|
|
if (bl) break block18;
|
|
if (n4 == 0 && !bl) break;
|
|
gArray[n3] = g5;
|
|
gArray[n8] = g4;
|
|
n3 = n8;
|
|
if (bl) break block19;
|
|
n9 = n2;
|
|
}
|
|
if (n9 == n3) {
|
|
this.Cb = n3 + 1;
|
|
this.Db = n3;
|
|
return true;
|
|
}
|
|
--n8;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
n4 = n2 + 1;
|
|
}
|
|
if (!bl) {
|
|
if (n4 >= n3) {
|
|
this.Cb = n2;
|
|
this.Db = n3;
|
|
return false;
|
|
}
|
|
n4 = this.b(gArray, n2 + 1, n3) ? 1 : 0;
|
|
}
|
|
if (!bl) {
|
|
if (n4 == 0) {
|
|
this.Cb = n2;
|
|
return false;
|
|
}
|
|
n4 = this.Db;
|
|
}
|
|
n3 = n4;
|
|
}
|
|
}
|
|
|
|
public void a(int n2, int n3, int n4) {
|
|
block20: {
|
|
int n5;
|
|
block19: {
|
|
int n6;
|
|
block18: {
|
|
int n7;
|
|
int n8;
|
|
int n9;
|
|
int n10;
|
|
boolean bl = q.d;
|
|
int n11 = -this.G + 1024 & 0x3FF;
|
|
int n12 = -this.H + 1024 & 0x3FF;
|
|
n5 = n10 = -this.I + 1024 & 0x3FF;
|
|
if (!bl) {
|
|
if (n5 != 0) {
|
|
n9 = k[n10];
|
|
n8 = k[n10 + 1024];
|
|
n7 = n3 * n9 + n2 * n8 >> 15;
|
|
n3 = n3 * n8 - n2 * n9 >> 15;
|
|
n2 = n7;
|
|
}
|
|
n5 = n11;
|
|
}
|
|
if (!bl) {
|
|
if (n5 != 0) {
|
|
n9 = k[n11];
|
|
n8 = k[n11 + 1024];
|
|
n7 = n3 * n8 - n4 * n9 >> 15;
|
|
n4 = n3 * n9 + n4 * n8 >> 15;
|
|
n3 = n7;
|
|
}
|
|
n5 = n12;
|
|
}
|
|
if (!bl) {
|
|
if (n5 != 0) {
|
|
n9 = k[n12];
|
|
n8 = k[n12 + 1024];
|
|
n7 = n4 * n9 + n2 * n8 >> 15;
|
|
n4 = n4 * n8 - n2 * n9 >> 15;
|
|
n2 = n7;
|
|
}
|
|
n5 = n2;
|
|
}
|
|
n6 = wb;
|
|
if (!bl) {
|
|
if (n5 < n6) {
|
|
wb = n2;
|
|
}
|
|
n5 = n2;
|
|
n6 = xb;
|
|
}
|
|
if (!bl) {
|
|
if (n5 > n6) {
|
|
xb = n2;
|
|
}
|
|
n5 = n3;
|
|
n6 = yb;
|
|
}
|
|
if (!bl) {
|
|
if (n5 < n6) {
|
|
yb = n3;
|
|
}
|
|
n5 = n3;
|
|
n6 = zb;
|
|
}
|
|
if (!bl) {
|
|
if (n5 > n6) {
|
|
zb = n3;
|
|
}
|
|
n5 = n4;
|
|
n6 = Ab;
|
|
}
|
|
if (bl) break block18;
|
|
if (n5 < n6) {
|
|
Ab = n4;
|
|
}
|
|
n5 = n4;
|
|
if (bl) break block19;
|
|
n6 = Bb;
|
|
}
|
|
if (n5 <= n6) break block20;
|
|
n5 = n4;
|
|
}
|
|
Bb = n5;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public void f() {
|
|
block79: {
|
|
block92: {
|
|
block93: {
|
|
block75: {
|
|
block74: {
|
|
var20_1 = q.d;
|
|
var1_2 = false;
|
|
this.vb = this.kb.y;
|
|
var2_3 = this.x * this.g >> this.B;
|
|
var3_4 = this.y * this.g >> this.B;
|
|
f.wb = 0;
|
|
f.xb = 0;
|
|
f.yb = 0;
|
|
f.zb = 0;
|
|
f.Ab = 0;
|
|
f.Bb = 0;
|
|
this.a(-var2_3, -var3_4, this.g);
|
|
this.a(-var2_3, var3_4, this.g);
|
|
this.a(var2_3, -var3_4, this.g);
|
|
this.a(var2_3, var3_4, this.g);
|
|
this.a(-this.x, -this.y, 0);
|
|
this.a(-this.x, this.y, 0);
|
|
this.a(this.x, -this.y, 0);
|
|
this.a(this.x, this.y, 0);
|
|
f.wb += this.D;
|
|
f.xb += this.D;
|
|
f.yb += this.E;
|
|
f.zb += this.E;
|
|
f.Ab += this.F;
|
|
f.Bb += this.F;
|
|
this.L[this.J] = this.X;
|
|
this.X.u = 2;
|
|
for (var4_5 = 0; var4_5 < this.J; ++var4_5) {
|
|
this.L[var4_5].a(this.D, this.E, this.F, this.G, this.H, this.I, this.B, this.f);
|
|
if (!var20_1) {
|
|
if (!var20_1) continue;
|
|
}
|
|
break block74;
|
|
}
|
|
this.L[this.J].a(this.D, this.E, this.F, this.G, this.H, this.I, this.B, this.f);
|
|
this.N = 0;
|
|
}
|
|
var4_5 = 0;
|
|
block1: while (true) {
|
|
v0 = var4_5;
|
|
block2: while (v0 < this.J) {
|
|
block81: {
|
|
var5_7 = this.L[var4_5];
|
|
if (var20_1) continue block1;
|
|
v1 = var5_7;
|
|
if (var20_1) break block75;
|
|
if (!v1.v) break block81;
|
|
var6_9 = 0;
|
|
block3: while (true) {
|
|
v2 = var6_9;
|
|
v3 = var5_7.i;
|
|
block4: while (v2 < v3) {
|
|
block86: {
|
|
block78: {
|
|
block91: {
|
|
block90: {
|
|
block88: {
|
|
block89: {
|
|
block77: {
|
|
block87: {
|
|
block76: {
|
|
block85: {
|
|
var7_13 = var5_7.j[var6_9];
|
|
var8_15 = var5_7.k[var6_9];
|
|
var9_18 = 0;
|
|
v0 = 0;
|
|
if (var20_1) continue block2;
|
|
var10_22 = v0;
|
|
while (var10_22 < var7_13) {
|
|
block82: {
|
|
block83: {
|
|
block84: {
|
|
var11_23 = var5_7.d[var8_15[var10_22]];
|
|
if (var20_1) break block82;
|
|
v2 = var11_23;
|
|
v3 = this.f;
|
|
if (var20_1) continue block4;
|
|
if (v2 <= v3) break block83;
|
|
v4 = var11_23;
|
|
if (var20_1) break block84;
|
|
if (v4 >= this.g && !var20_1) break block83;
|
|
v4 = var9_18 = 1;
|
|
}
|
|
if (!var20_1) break;
|
|
}
|
|
++var10_22;
|
|
}
|
|
if (!var20_1) continue;
|
|
}
|
|
v5 = var9_18;
|
|
if (var20_1) break block85;
|
|
if (v5 == 0) break block86;
|
|
var10_22 = 0;
|
|
v5 = var11_23 = 0;
|
|
}
|
|
while (var11_23 < var7_13) {
|
|
v6 = var12_24 = var5_7.e[var8_15[var11_23]];
|
|
v7 = -this.x;
|
|
if (!var20_1) {
|
|
if (!var20_1) {
|
|
if (v6 > v7) {
|
|
var10_22 |= 1;
|
|
}
|
|
v8 = var12_24;
|
|
v9 = this.x;
|
|
}
|
|
if (!var20_1) {
|
|
if (v8 < v9) {
|
|
var10_22 |= 2;
|
|
}
|
|
v8 = var10_22;
|
|
v9 = 3;
|
|
}
|
|
if (v8 == v9 && !var20_1) break;
|
|
++var11_23;
|
|
if (!var20_1) continue;
|
|
}
|
|
break block76;
|
|
}
|
|
v6 = var10_22;
|
|
if (var20_1) break block87;
|
|
v7 = 3;
|
|
}
|
|
if (v6 != v7) break block86;
|
|
var11_23 = 0;
|
|
v6 = var12_24 = 0;
|
|
}
|
|
while (var12_24 < var7_13) {
|
|
v10 = var13_29 = var5_7.f[var8_15[var12_24]];
|
|
v11 = -this.y;
|
|
if (!var20_1) {
|
|
if (!var20_1) {
|
|
if (v10 > v11) {
|
|
var11_23 |= 1;
|
|
}
|
|
v12 = var13_29;
|
|
v13 = this.y;
|
|
}
|
|
if (!var20_1) {
|
|
if (v12 < v13) {
|
|
var11_23 |= 2;
|
|
}
|
|
v12 = var11_23;
|
|
v13 = 3;
|
|
}
|
|
if (v12 == v13 && !var20_1) break;
|
|
++var12_24;
|
|
if (!var20_1) continue;
|
|
}
|
|
break block77;
|
|
}
|
|
v10 = var11_23;
|
|
v11 = 3;
|
|
}
|
|
if (v10 != v11) break block86;
|
|
var12_25 = this.O[this.N];
|
|
var12_25.g = var5_7;
|
|
var12_25.h = var6_9;
|
|
this.c(this.N);
|
|
v14 = var12_25.m;
|
|
if (var20_1) break block88;
|
|
if (v14 >= 0) break block89;
|
|
var13_29 = var5_7.l[var6_9];
|
|
if (!var20_1) break block90;
|
|
}
|
|
v14 = var5_7.m[var6_9];
|
|
}
|
|
var13_29 = v14;
|
|
}
|
|
v15 = var13_29;
|
|
if (var20_1) break block91;
|
|
if (v15 == 12345678) break block86;
|
|
v15 = 0;
|
|
}
|
|
var14_33 = v15;
|
|
for (var15_34 = 0; var15_34 < var7_13; ++var15_34) {
|
|
var14_33 += var5_7.d[var8_15[var15_34]];
|
|
if (!var20_1) {
|
|
if (!var20_1) continue;
|
|
}
|
|
break block78;
|
|
}
|
|
var12_25.i = var15_34 = var14_33 / var7_13 + 0;
|
|
var12_25.n = var13_29;
|
|
}
|
|
++this.N;
|
|
}
|
|
++var6_9;
|
|
if (!var20_1) continue block3;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
++var4_5;
|
|
if (!var20_1) continue block1;
|
|
}
|
|
break;
|
|
}
|
|
v1 = this.X;
|
|
}
|
|
var4_6 = v1;
|
|
v16 = var4_6.v;
|
|
if (var20_1) break block92;
|
|
if (v16 == 0) break block93;
|
|
var5_8 = 0;
|
|
while (var5_8 < var4_6.i) {
|
|
block94: {
|
|
block95: {
|
|
block98: {
|
|
block97: {
|
|
block96: {
|
|
var6_11 = var4_6.k[var5_8];
|
|
var7_13 = var6_11[0];
|
|
var8_16 = var4_6.e[var7_13];
|
|
var9_18 = var4_6.f[var7_13];
|
|
var10_22 = var4_6.d[var7_13];
|
|
if (var20_1) break block94;
|
|
v17 = var10_22;
|
|
v18 = this.f;
|
|
if (var20_1) ** GOTO lbl228
|
|
if (v17 <= v18) break block95;
|
|
v19 = var10_22;
|
|
v20 = this.h;
|
|
if (var20_1) break block96;
|
|
if (v19 >= v20) break block95;
|
|
v19 = this.U[var5_8] << this.B;
|
|
v20 = var10_22;
|
|
}
|
|
var11_23 = v19 / v20;
|
|
var12_26 = (this.V[var5_8] << this.B) / var10_22;
|
|
if (var20_1) break block94;
|
|
if (var8_16 - var11_23 / 2 > this.x) break block95;
|
|
v21 = var8_16 + var11_23 / 2;
|
|
v22 = -this.x;
|
|
if (var20_1) break block97;
|
|
if (v21 < v22) break block95;
|
|
v21 = var9_18 - var12_26;
|
|
v22 = this.y;
|
|
}
|
|
if (var20_1) break block98;
|
|
if (v21 > v22) break block95;
|
|
v21 = var9_18;
|
|
v22 = -this.y;
|
|
}
|
|
if (v21 >= v22) {
|
|
var13_31 = this.O[this.N];
|
|
var13_31.g = var4_6;
|
|
var13_31.h = var5_8;
|
|
this.d(this.N);
|
|
var13_31.i = (var10_22 + var4_6.d[var6_11[1]]) / 2;
|
|
++this.N;
|
|
}
|
|
}
|
|
++var5_8;
|
|
}
|
|
if (!var20_1) continue;
|
|
}
|
|
}
|
|
v16 = this.N;
|
|
}
|
|
if (!var20_1) {
|
|
if (v16 == 0) {
|
|
return;
|
|
}
|
|
this.e = this.N;
|
|
this.a(this.O, 0, this.N - 1);
|
|
this.a(100, this.O, this.N);
|
|
v16 = 0;
|
|
}
|
|
var5_8 = v16;
|
|
do {
|
|
block101: {
|
|
block80: {
|
|
block107: {
|
|
block108: {
|
|
block109: {
|
|
block110: {
|
|
block100: {
|
|
block106: {
|
|
block105: {
|
|
block104: {
|
|
block103: {
|
|
block102: {
|
|
block99: {
|
|
v17 = var5_8;
|
|
v18 = this.N;
|
|
lbl228:
|
|
// 2 sources
|
|
|
|
if (v17 >= v18) break;
|
|
var6_12 = this.O[var5_8];
|
|
var7_14 = var6_12.g;
|
|
var8_17 = var6_12.h;
|
|
if (var20_1) break block79;
|
|
v23 = var7_14;
|
|
if (var20_1) break block99;
|
|
if (v23 != this.X) break block100;
|
|
v23 = var7_14;
|
|
}
|
|
var9_20 = v23.k[var8_17];
|
|
var10_22 = var9_20[0];
|
|
var11_23 = var7_14.e[var10_22];
|
|
var12_27 = var7_14.f[var10_22];
|
|
var13_32 = var7_14.d[var10_22];
|
|
var14_33 = (this.U[var8_17] << this.B) / var13_32;
|
|
var15_34 = (this.V[var8_17] << this.B) / var13_32;
|
|
var16_35 = var12_27 - var7_14.f[var9_20[1]];
|
|
var17_36 = (var7_14.e[var9_20[1]] - var11_23) * var16_35 / var15_34;
|
|
var17_36 = var7_14.e[var9_20[1]] - var11_23;
|
|
var18_37 = var11_23 - var14_33 / 2;
|
|
var19_38 = this.A + var12_27 - var15_34;
|
|
this.kb.a(var18_37 + this.z, var19_38, var14_33, var15_34, this.Q[var8_17], var17_36, (256 << this.B) / var13_32);
|
|
if (var20_1) continue;
|
|
if (!this.p) break block101;
|
|
v24 = this.s;
|
|
v25 = this.t;
|
|
if (var20_1) break block102;
|
|
if (v24 >= v25) break block101;
|
|
var18_37 += (this.W[var8_17] << this.B) / var13_32;
|
|
if (var20_1) continue;
|
|
v24 = this.r;
|
|
v25 = var19_38;
|
|
}
|
|
if (v24 < v25) break block101;
|
|
v26 = this.r;
|
|
v27 = var19_38 + var15_34;
|
|
if (var20_1) break block103;
|
|
if (v26 > v27) break block101;
|
|
v26 = this.q;
|
|
v27 = var18_37;
|
|
}
|
|
if (var20_1) break block104;
|
|
if (v26 < v27) break block101;
|
|
v26 = this.q;
|
|
if (var20_1) break block105;
|
|
v27 = var18_37 + var14_33;
|
|
}
|
|
if (v26 > v27) break block101;
|
|
v26 = (int)var7_14.L;
|
|
}
|
|
if (var20_1) break block106;
|
|
if (v26 != 0) break block101;
|
|
v26 = var7_14.H[var8_17];
|
|
}
|
|
if (v26 != 0) break block101;
|
|
this.u[this.s] = var7_14;
|
|
this.v[this.s] = var8_17;
|
|
++this.s;
|
|
if (!var20_1) break block101;
|
|
}
|
|
var9_21 = 0;
|
|
var10_22 = 0;
|
|
var11_23 = var7_14.j[var8_17];
|
|
var12_28 = var7_14.k[var8_17];
|
|
v28 = var7_14.p[var8_17];
|
|
if (var20_1) break block107;
|
|
if (v28 == 12345678) break block108;
|
|
v29 = var6_12.m;
|
|
if (var20_1) break block109;
|
|
if (v29 >= 0) break block110;
|
|
var10_22 = var7_14.Eb - var7_14.p[var8_17];
|
|
if (!var20_1) break block108;
|
|
}
|
|
v29 = var7_14.Eb + var7_14.p[var8_17];
|
|
}
|
|
var10_22 = v29;
|
|
}
|
|
v28 = var13_32 = 0;
|
|
}
|
|
while (var13_32 < var11_23) {
|
|
block117: {
|
|
block125: {
|
|
block124: {
|
|
block122: {
|
|
block123: {
|
|
block121: {
|
|
block120: {
|
|
block118: {
|
|
block119: {
|
|
block115: {
|
|
block116: {
|
|
block111: {
|
|
block112: {
|
|
block113: {
|
|
block114: {
|
|
var14_33 = var12_28[var13_32];
|
|
this.sb[var13_32] = var7_14.b[var14_33];
|
|
this.tb[var13_32] = var7_14.c[var14_33];
|
|
this.ub[var13_32] = var7_14.d[var14_33];
|
|
v30 = var7_14.p[var8_17];
|
|
v31 = 12345678;
|
|
if (var20_1) ** GOTO lbl398
|
|
if (var20_1) break block111;
|
|
if (v30 != v31) break block112;
|
|
v32 = var6_12.m;
|
|
if (var20_1) break block113;
|
|
if (v32 >= 0) break block114;
|
|
var10_22 = var7_14.Eb - var7_14.g[var14_33] + var7_14.h[var14_33];
|
|
if (!var20_1) break block112;
|
|
}
|
|
v32 = var7_14.Eb + var7_14.g[var14_33] + var7_14.h[var14_33];
|
|
}
|
|
var10_22 = v32;
|
|
}
|
|
v33 = var7_14.d[var14_33];
|
|
if (var20_1) break block115;
|
|
v34 = this.f;
|
|
}
|
|
if (v33 < v34) break block116;
|
|
this.pb[var9_21] = var7_14.e[var14_33];
|
|
this.qb[var9_21] = var7_14.f[var14_33];
|
|
this.rb[var9_21] = var10_22;
|
|
if (!var20_1) {
|
|
if (var7_14.d[var14_33] > this.j) {
|
|
v35 = var9_21;
|
|
this.rb[v35] = this.rb[v35] + (var7_14.d[var14_33] - this.j) / this.i;
|
|
}
|
|
++var9_21;
|
|
}
|
|
if (!var20_1) break block117;
|
|
}
|
|
v33 = var13_32;
|
|
}
|
|
if (var20_1) break block118;
|
|
if (v33 != 0) break block119;
|
|
var15_34 = var12_28[var11_23 - 1];
|
|
if (!var20_1) break block120;
|
|
}
|
|
v33 = var12_28[var13_32 - 1];
|
|
}
|
|
var15_34 = v33;
|
|
}
|
|
v36 = var7_14.d[var15_34];
|
|
v37 = this.f;
|
|
if (var20_1) break block121;
|
|
if (v36 >= v37) {
|
|
var16_35 = var7_14.d[var14_33] - var7_14.d[var15_34];
|
|
var17_36 = var7_14.b[var14_33] - (var7_14.b[var14_33] - var7_14.b[var15_34]) * (var7_14.d[var14_33] - this.f) / var16_35;
|
|
var18_37 = var7_14.c[var14_33] - (var7_14.c[var14_33] - var7_14.c[var15_34]) * (var7_14.d[var14_33] - this.f) / var16_35;
|
|
this.pb[var9_21] = (var17_36 << this.B) / this.f;
|
|
this.qb[var9_21] = (var18_37 << this.B) / this.f;
|
|
this.rb[var9_21] = var10_22;
|
|
++var9_21;
|
|
}
|
|
v36 = var13_32;
|
|
if (var20_1) break block122;
|
|
v37 = var11_23 - 1;
|
|
}
|
|
if (v36 != v37) break block123;
|
|
var15_34 = var12_28[0];
|
|
if (!var20_1) break block124;
|
|
}
|
|
v36 = var12_28[var13_32 + 1];
|
|
}
|
|
var15_34 = v36;
|
|
}
|
|
v38 = var7_14.d[var15_34];
|
|
v39 = this.f;
|
|
if (var20_1) break block125;
|
|
if (v38 < v39) break block117;
|
|
v38 = var7_14.d[var14_33];
|
|
v39 = var7_14.d[var15_34];
|
|
}
|
|
var16_35 = v38 - v39;
|
|
var17_36 = var7_14.b[var14_33] - (var7_14.b[var14_33] - var7_14.b[var15_34]) * (var7_14.d[var14_33] - this.f) / var16_35;
|
|
var18_37 = var7_14.c[var14_33] - (var7_14.c[var14_33] - var7_14.c[var15_34]) * (var7_14.d[var14_33] - this.f) / var16_35;
|
|
this.pb[var9_21] = (var17_36 << this.B) / this.f;
|
|
this.qb[var9_21] = (var18_37 << this.B) / this.f;
|
|
this.rb[var9_21] = var10_22;
|
|
++var9_21;
|
|
}
|
|
++var13_32;
|
|
if (!var20_1) continue;
|
|
}
|
|
var13_32 = 0;
|
|
do {
|
|
block131: {
|
|
block132: {
|
|
block133: {
|
|
block130: {
|
|
block129: {
|
|
block128: {
|
|
block126: {
|
|
block127: {
|
|
v30 = var13_32;
|
|
v31 = var11_23;
|
|
lbl398:
|
|
// 2 sources
|
|
|
|
if (v30 >= v31) break;
|
|
v40 = this.rb[var13_32];
|
|
if (var20_1) break block80;
|
|
if (var20_1) break block126;
|
|
if (v40 >= 0) break block127;
|
|
this.rb[var13_32] = 0;
|
|
if (!var20_1) break block128;
|
|
}
|
|
v41 = this.rb[var13_32];
|
|
}
|
|
if (var20_1) break block129;
|
|
if (v41 > 255) {
|
|
this.rb[var13_32] = 255;
|
|
}
|
|
}
|
|
v41 = var6_12.n;
|
|
}
|
|
if (var20_1) break block130;
|
|
if (v41 < 0) break block131;
|
|
v42 = this.bb;
|
|
v43 = var6_12.n;
|
|
if (var20_1) break block132;
|
|
v41 = v42[v43];
|
|
}
|
|
if (v41 != 1) break block133;
|
|
v44 = var13_32;
|
|
this.rb[v44] = this.rb[v44] << 9;
|
|
if (!var20_1) break block131;
|
|
}
|
|
v42 = this.rb;
|
|
v43 = var13_32;
|
|
}
|
|
v42[v43] = v42[v43] << 6;
|
|
}
|
|
++var13_32;
|
|
} while (!var20_1);
|
|
this.a(0, 0, 0, 0, var9_21, this.pb, this.qb, this.rb, var7_14, var8_17);
|
|
if (var20_1) continue;
|
|
v40 = this.ob;
|
|
}
|
|
if (v40 > this.nb) {
|
|
this.a(0, 0, var11_23, this.sb, this.tb, this.ub, var6_12.n, var7_14);
|
|
}
|
|
}
|
|
++var5_8;
|
|
} while (!var20_1);
|
|
this.p = false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
private void a(int var1_1, int var2_2, int var3_3, int var4_4, int var5_5, int[] var6_6, int[] var7_7, int[] var8_8, l var9_9, int var10_10) {
|
|
block287: {
|
|
block294: {
|
|
block293: {
|
|
block292: {
|
|
block291: {
|
|
block290: {
|
|
block289: {
|
|
block288: {
|
|
block286: {
|
|
block245: {
|
|
block246: {
|
|
block217: {
|
|
block215: {
|
|
block216: {
|
|
block285: {
|
|
block284: {
|
|
block214: {
|
|
block247: {
|
|
block248: {
|
|
block213: {
|
|
block270: {
|
|
block269: {
|
|
block264: {
|
|
block265: {
|
|
block268: {
|
|
block266: {
|
|
block267: {
|
|
block259: {
|
|
block260: {
|
|
block263: {
|
|
block261: {
|
|
block262: {
|
|
block254: {
|
|
block255: {
|
|
block258: {
|
|
block256: {
|
|
block257: {
|
|
block249: {
|
|
block250: {
|
|
block253: {
|
|
block251: {
|
|
block252: {
|
|
block218: {
|
|
block219: {
|
|
block212: {
|
|
block236: {
|
|
block235: {
|
|
block230: {
|
|
block231: {
|
|
block234: {
|
|
block232: {
|
|
block233: {
|
|
block225: {
|
|
block226: {
|
|
block229: {
|
|
block227: {
|
|
block228: {
|
|
block220: {
|
|
block221: {
|
|
block224: {
|
|
block222: {
|
|
block223: {
|
|
var51_11 = q.d;
|
|
var11_12 = false;
|
|
v0 = var5_5;
|
|
v1 = 3;
|
|
if (var51_11) break block218;
|
|
if (v0 != v1) break block219;
|
|
var12_13 = var7_7[0] + this.A;
|
|
var13_16 = var7_7[1] + this.A;
|
|
var14_17 = var7_7[2] + this.A;
|
|
var15_18 = var6_6[0];
|
|
var16_19 = var6_6[1];
|
|
var17_20 = var6_6[2];
|
|
var18_21 = var8_8[0];
|
|
var19_22 = var8_8[1];
|
|
var20_27 = var8_8[2];
|
|
var21_28 = this.A + this.y - 1;
|
|
var22_29 = 0;
|
|
var23_30 = 0;
|
|
var24_33 = 0;
|
|
var25_34 = 0;
|
|
var26_35 = 12345678;
|
|
var27_36 = -12345678;
|
|
v2 = var14_17;
|
|
if (var51_11) break block220;
|
|
if (v2 == var12_13) break block221;
|
|
var23_30 = (var17_20 - var15_18 << 8) / (var14_17 - var12_13);
|
|
var25_34 = (var20_27 - var18_21 << 8) / (var14_17 - var12_13);
|
|
v3 = var12_13;
|
|
v4 = var14_17;
|
|
if (var51_11) break block222;
|
|
if (v3 >= v4) break block223;
|
|
var22_29 = var15_18 << 8;
|
|
var24_33 = var18_21 << 8;
|
|
var26_35 = var12_13;
|
|
var27_36 = var14_17;
|
|
if (!var51_11) break block224;
|
|
}
|
|
var22_29 = var17_20 << 8;
|
|
v3 = var20_27;
|
|
v4 = 8;
|
|
}
|
|
var24_33 = v3 << v4;
|
|
var26_35 = var14_17;
|
|
var27_36 = var12_13;
|
|
}
|
|
v2 = var26_35;
|
|
if (!var51_11) {
|
|
if (v2 < 0) {
|
|
var22_29 -= var23_30 * var26_35;
|
|
var24_33 -= var25_34 * var26_35;
|
|
var26_35 = 0;
|
|
}
|
|
v2 = var27_36;
|
|
}
|
|
if (var51_11) break block220;
|
|
if (v2 > var21_28) {
|
|
var27_36 = var21_28;
|
|
}
|
|
}
|
|
v2 = 0;
|
|
}
|
|
var28_37 = v2;
|
|
var29_38 = 0;
|
|
var30_39 = 0;
|
|
var31_40 = 0;
|
|
var32_41 = 12345678;
|
|
var33_42 = -12345678;
|
|
v5 = var13_16;
|
|
if (var51_11) break block225;
|
|
if (v5 == var12_13) break block226;
|
|
var29_38 = (var16_19 - var15_18 << 8) / (var13_16 - var12_13);
|
|
var31_40 = (var19_22 - var18_21 << 8) / (var13_16 - var12_13);
|
|
v6 = var12_13;
|
|
v7 = var13_16;
|
|
if (var51_11) break block227;
|
|
if (v6 >= v7) break block228;
|
|
var28_37 = var15_18 << 8;
|
|
var30_39 = var18_21 << 8;
|
|
var32_41 = var12_13;
|
|
var33_42 = var13_16;
|
|
if (!var51_11) break block229;
|
|
}
|
|
var28_37 = var16_19 << 8;
|
|
v6 = var19_22;
|
|
v7 = 8;
|
|
}
|
|
var30_39 = v6 << v7;
|
|
var32_41 = var13_16;
|
|
var33_42 = var12_13;
|
|
}
|
|
v5 = var32_41;
|
|
if (!var51_11) {
|
|
if (v5 < 0) {
|
|
var28_37 -= var29_38 * var32_41;
|
|
var30_39 -= var31_40 * var32_41;
|
|
var32_41 = 0;
|
|
}
|
|
v5 = var33_42;
|
|
}
|
|
if (var51_11) break block225;
|
|
if (v5 > var21_28) {
|
|
var33_42 = var21_28;
|
|
}
|
|
}
|
|
v5 = 0;
|
|
}
|
|
var34_43 = v5;
|
|
var35_44 = 0;
|
|
var36_45 = 0;
|
|
var37_46 = 0;
|
|
var38_47 = 12345678;
|
|
var39_48 = -12345678;
|
|
v8 = var14_17;
|
|
v9 = var13_16;
|
|
if (var51_11) break block230;
|
|
if (v8 == v9) break block231;
|
|
var35_44 = (var17_20 - var16_19 << 8) / (var14_17 - var13_16);
|
|
var37_46 = (var20_27 - var19_22 << 8) / (var14_17 - var13_16);
|
|
v10 = var13_16;
|
|
v11 = var14_17;
|
|
if (var51_11) break block232;
|
|
if (v10 >= v11) break block233;
|
|
var34_43 = var16_19 << 8;
|
|
var36_45 = var19_22 << 8;
|
|
var38_47 = var13_16;
|
|
var39_48 = var14_17;
|
|
if (!var51_11) break block234;
|
|
}
|
|
var34_43 = var17_20 << 8;
|
|
v10 = var20_27;
|
|
v11 = 8;
|
|
}
|
|
var36_45 = v10 << v11;
|
|
var38_47 = var14_17;
|
|
var39_48 = var13_16;
|
|
}
|
|
v8 = var38_47;
|
|
if (!var51_11) {
|
|
if (v8 < 0) {
|
|
var34_43 -= var35_44 * var38_47;
|
|
var36_45 -= var37_46 * var38_47;
|
|
var38_47 = 0;
|
|
}
|
|
v8 = var39_48;
|
|
}
|
|
v9 = var21_28;
|
|
if (var51_11) break block230;
|
|
if (v8 > v9) {
|
|
var39_48 = var21_28;
|
|
}
|
|
}
|
|
this.nb = var26_35;
|
|
v8 = var32_41;
|
|
v9 = this.nb;
|
|
}
|
|
if (!var51_11) {
|
|
if (v8 < v9) {
|
|
this.nb = var32_41;
|
|
}
|
|
v8 = var38_47;
|
|
v9 = this.nb;
|
|
}
|
|
if (!var51_11) {
|
|
if (v8 < v9) {
|
|
this.nb = var38_47;
|
|
}
|
|
this.ob = var27_36;
|
|
v8 = var33_42;
|
|
v9 = this.ob;
|
|
}
|
|
if (var51_11) break block235;
|
|
if (v8 > v9) {
|
|
this.ob = var33_42;
|
|
}
|
|
v8 = var39_48;
|
|
if (var51_11) break block236;
|
|
v9 = this.ob;
|
|
}
|
|
if (v8 > v9) {
|
|
this.ob = var39_48;
|
|
}
|
|
v8 = 0;
|
|
}
|
|
var40_49 = v8;
|
|
for (var3_3 = this.nb; var3_3 < this.ob; ++var3_3) {
|
|
block243: {
|
|
block244: {
|
|
block242: {
|
|
block240: {
|
|
block241: {
|
|
block239: {
|
|
block237: {
|
|
block238: {
|
|
v12 = var3_3;
|
|
if (var51_11) break block237;
|
|
v13 = var26_35;
|
|
if (var51_11) break block212;
|
|
if (v12 < v13) break block238;
|
|
v12 = var3_3;
|
|
if (var51_11) break block237;
|
|
if (v12 >= var27_36) break block238;
|
|
var1_1 = var2_2 = var22_29;
|
|
var4_4 = var40_49 = var24_33;
|
|
var22_29 += var23_30;
|
|
var24_33 += var25_34;
|
|
if (!var51_11) break block239;
|
|
}
|
|
var1_1 = 655360;
|
|
v12 = -655360;
|
|
}
|
|
var2_2 = v12;
|
|
}
|
|
v14 = var3_3;
|
|
v15 = var32_41;
|
|
if (var51_11) break block240;
|
|
if (v14 < v15) break block241;
|
|
v14 = var3_3;
|
|
v15 = var33_42;
|
|
if (var51_11) break block240;
|
|
if (v14 < v15) {
|
|
v16 = var28_37;
|
|
v17 = var1_1;
|
|
if (!var51_11) {
|
|
if (v16 < v17) {
|
|
var1_1 = var28_37;
|
|
var4_4 = var30_39;
|
|
}
|
|
v16 = var28_37;
|
|
v17 = var2_2;
|
|
}
|
|
if (!var51_11) {
|
|
if (v16 > v17) {
|
|
var2_2 = var28_37;
|
|
var40_49 = var30_39;
|
|
}
|
|
var28_37 += var29_38;
|
|
v16 = var30_39;
|
|
v17 = var31_40;
|
|
}
|
|
var30_39 = v16 + v17;
|
|
}
|
|
}
|
|
v14 = var3_3;
|
|
v15 = var38_47;
|
|
}
|
|
if (var51_11) break block242;
|
|
if (v14 < v15) break block243;
|
|
v14 = var3_3;
|
|
v15 = var39_48;
|
|
}
|
|
if (var51_11) break block244;
|
|
if (v14 >= v15) break block243;
|
|
v14 = var34_43;
|
|
v15 = var1_1;
|
|
}
|
|
if (!var51_11) {
|
|
if (v14 < v15) {
|
|
var1_1 = var34_43;
|
|
var4_4 = var36_45;
|
|
}
|
|
v14 = var34_43;
|
|
v15 = var2_2;
|
|
}
|
|
if (!var51_11) {
|
|
if (v14 > v15) {
|
|
var2_2 = var34_43;
|
|
var40_49 = var36_45;
|
|
}
|
|
var34_43 += var35_44;
|
|
v14 = var36_45;
|
|
v15 = var37_46;
|
|
}
|
|
var36_45 = v14 + v15;
|
|
}
|
|
var41_50 = this.mb[var3_3];
|
|
var41_50.a = var1_1;
|
|
var41_50.b = var2_2;
|
|
var41_50.c = var4_4;
|
|
var41_50.d = var40_49;
|
|
if (!var51_11) continue;
|
|
}
|
|
v18 = this.nb;
|
|
if (var51_11) break block245;
|
|
v13 = this.A - this.y;
|
|
}
|
|
if (v18 >= v13) break block246;
|
|
this.nb = this.A - this.y;
|
|
if (!var51_11) break block246;
|
|
}
|
|
v0 = var5_5;
|
|
if (var51_11) break block247;
|
|
v1 = 4;
|
|
}
|
|
if (v0 != v1) break block248;
|
|
var12_13 = var7_7[0] + this.A;
|
|
var13_16 = var7_7[1] + this.A;
|
|
var14_17 = var7_7[2] + this.A;
|
|
var15_18 = var7_7[3] + this.A;
|
|
var16_19 = var6_6[0];
|
|
var17_20 = var6_6[1];
|
|
var18_21 = var6_6[2];
|
|
var19_22 = var6_6[3];
|
|
var20_27 = var8_8[0];
|
|
var21_28 = var8_8[1];
|
|
var22_29 = var8_8[2];
|
|
var23_30 = var8_8[3];
|
|
var24_33 = this.A + this.y - 1;
|
|
var25_34 = 0;
|
|
var26_35 = 0;
|
|
var27_36 = 0;
|
|
var28_37 = 0;
|
|
var29_38 = 12345678;
|
|
var30_39 = -12345678;
|
|
v19 = var15_18;
|
|
if (var51_11) break block249;
|
|
if (v19 == var12_13) break block250;
|
|
var26_35 = (var19_22 - var16_19 << 8) / (var15_18 - var12_13);
|
|
var28_37 = (var23_30 - var20_27 << 8) / (var15_18 - var12_13);
|
|
v20 = var12_13;
|
|
v21 = var15_18;
|
|
if (var51_11) break block251;
|
|
if (v20 >= v21) break block252;
|
|
var25_34 = var16_19 << 8;
|
|
var27_36 = var20_27 << 8;
|
|
var29_38 = var12_13;
|
|
var30_39 = var15_18;
|
|
if (!var51_11) break block253;
|
|
}
|
|
var25_34 = var19_22 << 8;
|
|
v20 = var23_30;
|
|
v21 = 8;
|
|
}
|
|
var27_36 = v20 << v21;
|
|
var29_38 = var15_18;
|
|
var30_39 = var12_13;
|
|
}
|
|
v19 = var29_38;
|
|
if (!var51_11) {
|
|
if (v19 < 0) {
|
|
var25_34 -= var26_35 * var29_38;
|
|
var27_36 -= var28_37 * var29_38;
|
|
var29_38 = 0;
|
|
}
|
|
v19 = var30_39;
|
|
}
|
|
if (var51_11) break block249;
|
|
if (v19 > var24_33) {
|
|
var30_39 = var24_33;
|
|
}
|
|
}
|
|
v19 = 0;
|
|
}
|
|
var31_40 = v19;
|
|
var32_41 = 0;
|
|
var33_42 = 0;
|
|
var34_43 = 0;
|
|
var35_44 = 12345678;
|
|
var36_45 = -12345678;
|
|
v22 = var13_16;
|
|
if (var51_11) break block254;
|
|
if (v22 == var12_13) break block255;
|
|
var32_41 = (var17_20 - var16_19 << 8) / (var13_16 - var12_13);
|
|
var34_43 = (var21_28 - var20_27 << 8) / (var13_16 - var12_13);
|
|
v23 = var12_13;
|
|
v24 = var13_16;
|
|
if (var51_11) break block256;
|
|
if (v23 >= v24) break block257;
|
|
var31_40 = var16_19 << 8;
|
|
var33_42 = var20_27 << 8;
|
|
var35_44 = var12_13;
|
|
var36_45 = var13_16;
|
|
if (!var51_11) break block258;
|
|
}
|
|
var31_40 = var17_20 << 8;
|
|
v23 = var21_28;
|
|
v24 = 8;
|
|
}
|
|
var33_42 = v23 << v24;
|
|
var35_44 = var13_16;
|
|
var36_45 = var12_13;
|
|
}
|
|
v22 = var35_44;
|
|
if (!var51_11) {
|
|
if (v22 < 0) {
|
|
var31_40 -= var32_41 * var35_44;
|
|
var33_42 -= var34_43 * var35_44;
|
|
var35_44 = 0;
|
|
}
|
|
v22 = var36_45;
|
|
}
|
|
if (var51_11) break block254;
|
|
if (v22 > var24_33) {
|
|
var36_45 = var24_33;
|
|
}
|
|
}
|
|
v22 = 0;
|
|
}
|
|
var37_46 = v22;
|
|
var38_47 = 0;
|
|
var39_48 = 0;
|
|
var40_49 = 0;
|
|
var41_51 = 12345678;
|
|
var42_52 = -12345678;
|
|
v25 = var14_17;
|
|
if (var51_11) break block259;
|
|
if (v25 == var13_16) break block260;
|
|
var38_47 = (var18_21 - var17_20 << 8) / (var14_17 - var13_16);
|
|
var40_49 = (var22_29 - var21_28 << 8) / (var14_17 - var13_16);
|
|
v26 = var13_16;
|
|
v27 = var14_17;
|
|
if (var51_11) break block261;
|
|
if (v26 >= v27) break block262;
|
|
var37_46 = var17_20 << 8;
|
|
var39_48 = var21_28 << 8;
|
|
var41_51 = var13_16;
|
|
var42_52 = var14_17;
|
|
if (!var51_11) break block263;
|
|
}
|
|
var37_46 = var18_21 << 8;
|
|
v26 = var22_29;
|
|
v27 = 8;
|
|
}
|
|
var39_48 = v26 << v27;
|
|
var41_51 = var14_17;
|
|
var42_52 = var13_16;
|
|
}
|
|
v25 = var41_51;
|
|
if (!var51_11) {
|
|
if (v25 < 0) {
|
|
var37_46 -= var38_47 * var41_51;
|
|
var39_48 -= var40_49 * var41_51;
|
|
var41_51 = 0;
|
|
}
|
|
v25 = var42_52;
|
|
}
|
|
if (var51_11) break block259;
|
|
if (v25 > var24_33) {
|
|
var42_52 = var24_33;
|
|
}
|
|
}
|
|
v25 = 0;
|
|
}
|
|
var43_53 = v25;
|
|
var44_54 = 0;
|
|
var45_55 = 0;
|
|
var46_56 = 0;
|
|
var47_57 = 12345678;
|
|
var48_58 = -12345678;
|
|
v28 = var15_18;
|
|
v29 = var14_17;
|
|
if (var51_11) break block264;
|
|
if (v28 == v29) break block265;
|
|
var44_54 = (var19_22 - var18_21 << 8) / (var15_18 - var14_17);
|
|
var46_56 = (var23_30 - var22_29 << 8) / (var15_18 - var14_17);
|
|
v30 = var14_17;
|
|
v31 = var15_18;
|
|
if (var51_11) break block266;
|
|
if (v30 >= v31) break block267;
|
|
var43_53 = var18_21 << 8;
|
|
var45_55 = var22_29 << 8;
|
|
var47_57 = var14_17;
|
|
var48_58 = var15_18;
|
|
if (!var51_11) break block268;
|
|
}
|
|
var43_53 = var19_22 << 8;
|
|
v30 = var23_30;
|
|
v31 = 8;
|
|
}
|
|
var45_55 = v30 << v31;
|
|
var47_57 = var15_18;
|
|
var48_58 = var14_17;
|
|
}
|
|
v28 = var47_57;
|
|
if (!var51_11) {
|
|
if (v28 < 0) {
|
|
var43_53 -= var44_54 * var47_57;
|
|
var45_55 -= var46_56 * var47_57;
|
|
var47_57 = 0;
|
|
}
|
|
v28 = var48_58;
|
|
}
|
|
v29 = var24_33;
|
|
if (var51_11) break block264;
|
|
if (v28 > v29) {
|
|
var48_58 = var24_33;
|
|
}
|
|
}
|
|
this.nb = var29_38;
|
|
v28 = var35_44;
|
|
v29 = this.nb;
|
|
}
|
|
if (!var51_11) {
|
|
if (v28 < v29) {
|
|
this.nb = var35_44;
|
|
}
|
|
v28 = var41_51;
|
|
v29 = this.nb;
|
|
}
|
|
if (!var51_11) {
|
|
if (v28 < v29) {
|
|
this.nb = var41_51;
|
|
}
|
|
v28 = var47_57;
|
|
v29 = this.nb;
|
|
}
|
|
if (!var51_11) {
|
|
if (v28 < v29) {
|
|
this.nb = var47_57;
|
|
}
|
|
this.ob = var30_39;
|
|
v28 = var36_45;
|
|
v29 = this.ob;
|
|
}
|
|
if (!var51_11) {
|
|
if (v28 > v29) {
|
|
this.ob = var36_45;
|
|
}
|
|
v28 = var42_52;
|
|
v29 = this.ob;
|
|
}
|
|
if (var51_11) break block269;
|
|
if (v28 > v29) {
|
|
this.ob = var42_52;
|
|
}
|
|
v28 = var48_58;
|
|
if (var51_11) break block270;
|
|
v29 = this.ob;
|
|
}
|
|
if (v28 > v29) {
|
|
this.ob = var48_58;
|
|
}
|
|
v28 = 0;
|
|
}
|
|
var49_59 = v28;
|
|
for (var3_3 = this.nb; var3_3 < this.ob; ++var3_3) {
|
|
block279: {
|
|
block280: {
|
|
block278: {
|
|
block276: {
|
|
block277: {
|
|
block274: {
|
|
block275: {
|
|
block273: {
|
|
block271: {
|
|
block272: {
|
|
v32 = var3_3;
|
|
if (var51_11) break block271;
|
|
v33 = var29_38;
|
|
if (var51_11) break block213;
|
|
if (v32 < v33) break block272;
|
|
v32 = var3_3;
|
|
if (var51_11) break block271;
|
|
if (v32 >= var30_39) break block272;
|
|
var1_1 = var2_2 = var25_34;
|
|
var4_4 = var49_59 = var27_36;
|
|
var25_34 += var26_35;
|
|
var27_36 += var28_37;
|
|
if (!var51_11) break block273;
|
|
}
|
|
var1_1 = 655360;
|
|
v32 = -655360;
|
|
}
|
|
var2_2 = v32;
|
|
}
|
|
v34 = var3_3;
|
|
v35 = var35_44;
|
|
if (var51_11) break block274;
|
|
if (v34 < v35) break block275;
|
|
v34 = var3_3;
|
|
v35 = var36_45;
|
|
if (var51_11) break block274;
|
|
if (v34 < v35) {
|
|
v36 = var31_40;
|
|
v37 = var1_1;
|
|
if (!var51_11) {
|
|
if (v36 < v37) {
|
|
var1_1 = var31_40;
|
|
var4_4 = var33_42;
|
|
}
|
|
v36 = var31_40;
|
|
v37 = var2_2;
|
|
}
|
|
if (!var51_11) {
|
|
if (v36 > v37) {
|
|
var2_2 = var31_40;
|
|
var49_59 = var33_42;
|
|
}
|
|
var31_40 += var32_41;
|
|
v36 = var33_42;
|
|
v37 = var34_43;
|
|
}
|
|
var33_42 = v36 + v37;
|
|
}
|
|
}
|
|
v34 = var3_3;
|
|
v35 = var41_51;
|
|
}
|
|
if (var51_11) break block276;
|
|
if (v34 < v35) break block277;
|
|
v34 = var3_3;
|
|
v35 = var42_52;
|
|
if (var51_11) break block276;
|
|
if (v34 < v35) {
|
|
v38 = var37_46;
|
|
v39 = var1_1;
|
|
if (!var51_11) {
|
|
if (v38 < v39) {
|
|
var1_1 = var37_46;
|
|
var4_4 = var39_48;
|
|
}
|
|
v38 = var37_46;
|
|
v39 = var2_2;
|
|
}
|
|
if (!var51_11) {
|
|
if (v38 > v39) {
|
|
var2_2 = var37_46;
|
|
var49_59 = var39_48;
|
|
}
|
|
var37_46 += var38_47;
|
|
v38 = var39_48;
|
|
v39 = var40_49;
|
|
}
|
|
var39_48 = v38 + v39;
|
|
}
|
|
}
|
|
v34 = var3_3;
|
|
v35 = var47_57;
|
|
}
|
|
if (var51_11) break block278;
|
|
if (v34 < v35) break block279;
|
|
v34 = var3_3;
|
|
v35 = var48_58;
|
|
}
|
|
if (var51_11) break block280;
|
|
if (v34 >= v35) break block279;
|
|
v34 = var43_53;
|
|
v35 = var1_1;
|
|
}
|
|
if (!var51_11) {
|
|
if (v34 < v35) {
|
|
var1_1 = var43_53;
|
|
var4_4 = var45_55;
|
|
}
|
|
v34 = var43_53;
|
|
v35 = var2_2;
|
|
}
|
|
if (!var51_11) {
|
|
if (v34 > v35) {
|
|
var2_2 = var43_53;
|
|
var49_59 = var45_55;
|
|
}
|
|
var43_53 += var44_54;
|
|
v34 = var45_55;
|
|
v35 = var46_56;
|
|
}
|
|
var45_55 = v34 + v35;
|
|
}
|
|
var50_60 = this.mb[var3_3];
|
|
var50_60.a = var1_1;
|
|
var50_60.b = var2_2;
|
|
var50_60.c = var4_4;
|
|
var50_60.d = var49_59;
|
|
if (!var51_11) continue;
|
|
}
|
|
v18 = this.nb;
|
|
if (var51_11) break block245;
|
|
v33 = this.A - this.y;
|
|
}
|
|
if (v18 >= v33) break block246;
|
|
this.nb = this.A - this.y;
|
|
if (!var51_11) break block246;
|
|
}
|
|
this.nb = var7_7[0] = var7_7[0] + this.A;
|
|
this.ob = var7_7[0];
|
|
v0 = var3_3 = 1;
|
|
}
|
|
while (var3_3 < var5_5) {
|
|
block283: {
|
|
block281: {
|
|
block282: {
|
|
v40 = var3_3;
|
|
v41 = var7_7[v40] + this.A;
|
|
var7_7[v40] = v41;
|
|
v42 = var12_13 = v41;
|
|
v43 = this.nb;
|
|
if (var51_11) break block214;
|
|
if (var51_11) break block281;
|
|
if (v42 >= v43) break block282;
|
|
this.nb = var12_13;
|
|
if (!var51_11) break block283;
|
|
}
|
|
v44 = var12_13;
|
|
v45 = this.ob;
|
|
}
|
|
if (v44 > v45) {
|
|
this.ob = var12_13;
|
|
}
|
|
}
|
|
++var3_3;
|
|
if (!var51_11) continue;
|
|
}
|
|
v42 = this.nb;
|
|
v43 = this.A - this.y;
|
|
}
|
|
if (!var51_11) {
|
|
if (v42 < v43) {
|
|
this.nb = this.A - this.y;
|
|
}
|
|
v42 = this.ob;
|
|
v43 = this.A + this.y;
|
|
}
|
|
if (var51_11) break block284;
|
|
if (v42 >= v43) {
|
|
this.ob = this.A + this.y - 1;
|
|
}
|
|
v42 = this.nb;
|
|
if (var51_11) break block285;
|
|
v43 = this.ob;
|
|
}
|
|
if (v42 >= v43) {
|
|
return;
|
|
}
|
|
v42 = var3_3 = this.nb;
|
|
}
|
|
while (var3_3 < this.ob) {
|
|
var12_14 = this.mb[var3_3];
|
|
var12_14.a = 655360;
|
|
var12_14.b = -655360;
|
|
++var3_3;
|
|
if (!var51_11) continue;
|
|
}
|
|
var12_13 = var5_5 - 1;
|
|
var13_16 = var7_7[0];
|
|
var14_17 = var7_7[var12_13];
|
|
v46 = var13_16;
|
|
v47 = var14_17;
|
|
if (var51_11) ** GOTO lbl677
|
|
if (v46 >= v47) ** GOTO lbl674
|
|
var15_18 = var6_6[0] << 8;
|
|
var16_19 = (var6_6[var12_13] - var6_6[0] << 8) / (var14_17 - var13_16);
|
|
var17_20 = var8_8[0] << 8;
|
|
var18_21 = (var8_8[var12_13] - var8_8[0] << 8) / (var14_17 - var13_16);
|
|
v48 = var13_16;
|
|
if (!var51_11) {
|
|
if (v48 < 0) {
|
|
var15_18 -= var16_19 * var13_16;
|
|
var17_20 -= var18_21 * var13_16;
|
|
var13_16 = 0;
|
|
}
|
|
v48 = var14_17;
|
|
}
|
|
if (!var51_11) {
|
|
if (v48 > this.ob) {
|
|
var14_17 = this.ob;
|
|
}
|
|
v48 = var3_3 = var13_16;
|
|
}
|
|
while (var3_3 <= var14_17) {
|
|
var19_23 = this.mb[var3_3];
|
|
var19_23.a = var19_23.b = var15_18;
|
|
var19_23.c = var19_23.d = var17_20;
|
|
var15_18 += var16_19;
|
|
var17_20 += var18_21;
|
|
++var3_3;
|
|
if (!var51_11) {
|
|
if (!var51_11) continue;
|
|
}
|
|
break block215;
|
|
lbl674:
|
|
// 2 sources
|
|
|
|
v46 = var13_16;
|
|
if (var51_11) break block216;
|
|
v47 = var14_17;
|
|
lbl677:
|
|
// 2 sources
|
|
|
|
if (v46 <= v47) break;
|
|
var15_18 = var6_6[var12_13] << 8;
|
|
var16_19 = (var6_6[0] - var6_6[var12_13] << 8) / (var13_16 - var14_17);
|
|
var17_20 = var8_8[var12_13] << 8;
|
|
var18_21 = (var8_8[0] - var8_8[var12_13] << 8) / (var13_16 - var14_17);
|
|
v49 = var14_17;
|
|
if (!var51_11) {
|
|
if (v49 < 0) {
|
|
var15_18 -= var16_19 * var14_17;
|
|
var17_20 -= var18_21 * var14_17;
|
|
var14_17 = 0;
|
|
}
|
|
v49 = var13_16;
|
|
}
|
|
if (!var51_11) {
|
|
if (v49 > this.ob) {
|
|
var13_16 = this.ob;
|
|
}
|
|
v49 = var3_3 = var14_17;
|
|
}
|
|
while (var3_3 <= var13_16) {
|
|
var19_24 = this.mb[var3_3];
|
|
var19_24.a = var19_24.b = var15_18;
|
|
var19_24.c = var19_24.d = var17_20;
|
|
var15_18 += var16_19;
|
|
var17_20 += var18_21;
|
|
++var3_3;
|
|
if (!var51_11) {
|
|
if (!var51_11) continue;
|
|
}
|
|
break block215;
|
|
}
|
|
break block4;
|
|
}
|
|
v46 = 0;
|
|
}
|
|
var3_3 = v46;
|
|
}
|
|
block6: while (true) {
|
|
v50 = var3_3;
|
|
v51 = var12_13;
|
|
block7: while (v50 < v51) {
|
|
var15_18 = var3_3 + 1;
|
|
var16_19 = var7_7[var3_3];
|
|
var17_20 = var7_7[var15_18];
|
|
v18 = var16_19;
|
|
v52 = var17_20;
|
|
if (var51_11) break block217;
|
|
if (var51_11) ** GOTO lbl757
|
|
if (v18 >= v52) ** GOTO lbl755
|
|
var18_21 = var6_6[var3_3] << 8;
|
|
var19_25 = (var6_6[var15_18] - var6_6[var3_3] << 8) / (var17_20 - var16_19);
|
|
var20_27 = var8_8[var3_3] << 8;
|
|
var21_28 = (var8_8[var15_18] - var8_8[var3_3] << 8) / (var17_20 - var16_19);
|
|
v53 = var16_19;
|
|
if (!var51_11) {
|
|
if (v53 < 0) {
|
|
var18_21 -= var19_25 * var16_19;
|
|
var20_27 -= var21_28 * var16_19;
|
|
var16_19 = 0;
|
|
}
|
|
v53 = var17_20;
|
|
}
|
|
if (!var51_11) {
|
|
if (v53 > this.ob) {
|
|
var17_20 = this.ob;
|
|
}
|
|
v53 = var22_29 = var16_19;
|
|
}
|
|
while (var22_29 <= var17_20) {
|
|
var23_31 = this.mb[var22_29];
|
|
v50 = var18_21;
|
|
v51 = var23_31.a;
|
|
if (var51_11) continue block7;
|
|
if (!var51_11) {
|
|
if (v50 < v51) {
|
|
var23_31.a = var18_21;
|
|
var23_31.c = var20_27;
|
|
}
|
|
v54 = var18_21;
|
|
v55 = var23_31.b;
|
|
}
|
|
if (!var51_11) {
|
|
if (v54 > v55) {
|
|
var23_31.b = var18_21;
|
|
var23_31.d = var20_27;
|
|
}
|
|
var18_21 += var19_25;
|
|
v54 = var20_27;
|
|
v55 = var21_28;
|
|
}
|
|
var20_27 = v54 + v55;
|
|
++var22_29;
|
|
if (!var51_11) continue;
|
|
lbl755:
|
|
// 2 sources
|
|
|
|
v56 = var16_19;
|
|
v57 = var17_20;
|
|
lbl757:
|
|
// 2 sources
|
|
|
|
if (!var51_11) {
|
|
if (v56 <= v57) break;
|
|
v56 = var6_6[var15_18];
|
|
v57 = 8;
|
|
}
|
|
var18_21 = v56 << v57;
|
|
var19_26 = (var6_6[var3_3] - var6_6[var15_18] << 8) / (var16_19 - var17_20);
|
|
var20_27 = var8_8[var15_18] << 8;
|
|
var21_28 = (var8_8[var3_3] - var8_8[var15_18] << 8) / (var16_19 - var17_20);
|
|
v58 = var17_20;
|
|
if (!var51_11) {
|
|
if (v58 < 0) {
|
|
var18_21 -= var19_26 * var17_20;
|
|
var20_27 -= var21_28 * var17_20;
|
|
var17_20 = 0;
|
|
}
|
|
v58 = var16_19;
|
|
}
|
|
if (!var51_11) {
|
|
if (v58 > this.ob) {
|
|
var16_19 = this.ob;
|
|
}
|
|
v58 = var22_29 = var17_20;
|
|
}
|
|
while (var22_29 <= var16_19) {
|
|
var23_32 = this.mb[var22_29];
|
|
v50 = var18_21;
|
|
v51 = var23_32.a;
|
|
if (var51_11) continue block7;
|
|
if (!var51_11) {
|
|
if (v50 < v51) {
|
|
var23_32.a = var18_21;
|
|
var23_32.c = var20_27;
|
|
}
|
|
v59 = var18_21;
|
|
v60 = var23_32.b;
|
|
}
|
|
if (!var51_11) {
|
|
if (v59 > v60) {
|
|
var23_32.b = var18_21;
|
|
var23_32.d = var20_27;
|
|
}
|
|
var18_21 += var19_26;
|
|
v59 = var20_27;
|
|
v60 = var21_28;
|
|
}
|
|
var20_27 = v59 + v60;
|
|
++var22_29;
|
|
if (!var51_11) continue;
|
|
}
|
|
break block8;
|
|
}
|
|
++var3_3;
|
|
if (!var51_11) continue block6;
|
|
}
|
|
break;
|
|
}
|
|
v18 = this.nb;
|
|
if (var51_11) break block245;
|
|
v52 = this.A - this.y;
|
|
}
|
|
if (v18 < v52) {
|
|
this.nb = this.A - this.y;
|
|
}
|
|
}
|
|
v18 = (int)this.p;
|
|
}
|
|
if (var51_11) break block286;
|
|
if (v18 == 0) break block287;
|
|
v18 = this.s;
|
|
}
|
|
v61 = this.t;
|
|
if (var51_11) break block288;
|
|
if (v18 >= v61) break block287;
|
|
v18 = this.r;
|
|
v61 = this.nb;
|
|
}
|
|
if (var51_11) break block289;
|
|
if (v18 < v61) break block287;
|
|
v62 = this;
|
|
if (var51_11) break block290;
|
|
v18 = v62.r;
|
|
v61 = this.ob;
|
|
}
|
|
if (v18 >= v61) break block287;
|
|
v62 = this;
|
|
}
|
|
var12_15 = v62.mb[this.r];
|
|
v63 = this.q;
|
|
v64 = var12_15.a >> 8;
|
|
if (var51_11) break block291;
|
|
if (v63 < v64) break block287;
|
|
v63 = this.q;
|
|
v64 = var12_15.b >> 8;
|
|
}
|
|
if (var51_11) break block292;
|
|
if (v63 > v64) break block287;
|
|
v63 = var12_15.a;
|
|
if (var51_11) break block293;
|
|
v64 = var12_15.b;
|
|
}
|
|
if (v63 > v64) break block287;
|
|
v63 = (int)var9_9.L;
|
|
}
|
|
if (var51_11) break block294;
|
|
if (v63 != 0) break block287;
|
|
v63 = var9_9.H[var10_10];
|
|
}
|
|
if (v63 == 0) {
|
|
this.u[this.s] = var9_9;
|
|
this.v[this.s] = var10_10;
|
|
++this.s;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void a(int n2, int n3, int n4, int[] nArray, int[] nArray2, int[] nArray3, int n5, l l2) {
|
|
int n6;
|
|
int n7;
|
|
int n8;
|
|
int n9;
|
|
int n10;
|
|
int n11;
|
|
int n12;
|
|
int n13;
|
|
int n14;
|
|
int n15;
|
|
boolean bl;
|
|
block73: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
int n16 = n5;
|
|
if (!bl) {
|
|
if (n16 == -2) {
|
|
return;
|
|
}
|
|
n16 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n16 >= 0) {
|
|
int n17 = n5;
|
|
if (!bl) {
|
|
if (n17 >= this.Y) {
|
|
n5 = 0;
|
|
}
|
|
this.e(n5);
|
|
n17 = nArray[0];
|
|
}
|
|
int n18 = n17;
|
|
int n19 = nArray2[0];
|
|
int n20 = nArray3[0];
|
|
int n21 = n18 - nArray[1];
|
|
int n22 = n19 - nArray2[1];
|
|
int n23 = n20 - nArray3[1];
|
|
int n24 = nArray[--n4] - n18;
|
|
int n25 = nArray2[n4] - n19;
|
|
int n26 = nArray3[n4] - n20;
|
|
int n28 = this.bb[n5];
|
|
n28 = 1;
|
|
if (!bl) {
|
|
if (n27 == n28) {
|
|
int n29 = n24 * n19 - n25 * n18 << 12;
|
|
int n30 = n25 * n20 - n26 * n19 << 5 - this.B + 7 + 4;
|
|
int n31 = n26 * n18 - n24 * n20 << 5 - this.B + 7;
|
|
int n32 = n21 * n19 - n22 * n18 << 12;
|
|
int n33 = n22 * n20 - n23 * n19 << 5 - this.B + 7 + 4;
|
|
int n34 = n23 * n18 - n21 * n20 << 5 - this.B + 7;
|
|
int n35 = n22 * n24 - n21 * n25 << 5;
|
|
int n36 = n23 * n25 - n22 * n26 << 5 - this.B + 4;
|
|
int n37 = n21 * n26 - n23 * n24 >> this.B - 5;
|
|
int n38 = n30 >> 4;
|
|
int n39 = n33 >> 4;
|
|
int n40 = n36 >> 4;
|
|
int n41 = this.nb - this.A;
|
|
int n42 = this.w;
|
|
int n43 = this.z + this.nb * n42;
|
|
int n44 = 1;
|
|
n29 += n31 * n41;
|
|
n32 += n34 * n41;
|
|
n35 += n37 * n41;
|
|
int n45 = this.vb;
|
|
if (!bl) {
|
|
if (n45 != 0) {
|
|
int n47 = this.nb & 1;
|
|
n47 = 1;
|
|
if (!bl) {
|
|
if (n46 == n47) {
|
|
++this.nb;
|
|
n29 += n31;
|
|
n32 += n34;
|
|
n35 += n37;
|
|
n43 += n42;
|
|
}
|
|
n31 <<= 1;
|
|
n34 <<= 1;
|
|
n37 <<= 1;
|
|
int n47 = n42;
|
|
n47 = 1;
|
|
}
|
|
n42 = n46 << n47;
|
|
n44 = 2;
|
|
}
|
|
n45 = this.eb[n5];
|
|
}
|
|
if (!bl) {
|
|
if (n45 == 0) {
|
|
for (n2 = this.nb; n2 < this.ob; n2 += n44) {
|
|
int n48;
|
|
p p2 = this.mb[n2];
|
|
n3 = p2.a >> 8;
|
|
int n49 = p2.b >> 8;
|
|
int n50 = n48 = n49 - n3;
|
|
if (!bl) {
|
|
if (n50 <= 0) {
|
|
n29 += n31;
|
|
n32 += n34;
|
|
n35 += n37;
|
|
n43 += n42;
|
|
if (!bl) continue;
|
|
}
|
|
n50 = p2.c;
|
|
}
|
|
int n51 = n50;
|
|
int n52 = (p2.d - n51) / n48;
|
|
int n54 = n3;
|
|
n54 = -this.x;
|
|
if (!bl) {
|
|
if (n53 < n54) {
|
|
n51 += (-this.x - n3) * n52;
|
|
n3 = -this.x;
|
|
n48 = n49 - n3;
|
|
}
|
|
int n54 = n49;
|
|
n54 = this.x;
|
|
}
|
|
if (!bl) {
|
|
if (n53 > n54) {
|
|
int n55 = this.x;
|
|
n48 = n55 - n3;
|
|
}
|
|
f.a(this.lb, this.db[n5], 0, 0, n29 + n38 * n3, n32 + n39 * n3, n35 + n40 * n3, n30, n33, n36, n48, n43 + n3, n51, n52 << 2);
|
|
n29 += n31;
|
|
n32 += n34;
|
|
n35 += n37;
|
|
int n54 = n43;
|
|
n54 = n42;
|
|
}
|
|
n43 = n53 + n54;
|
|
if (!bl) continue;
|
|
}
|
|
return;
|
|
}
|
|
n45 = this.nb;
|
|
}
|
|
for (n2 = (int)(v74180); n2 < this.ob; n2 += n44) {
|
|
int n56;
|
|
p p3 = this.mb[n2];
|
|
n3 = p3.a >> 8;
|
|
int n57 = p3.b >> 8;
|
|
int n55 = n56 = n57 - n3;
|
|
if (!bl) {
|
|
if (n55 <= 0) {
|
|
n29 += n31;
|
|
n32 += n34;
|
|
n35 += n37;
|
|
n43 += n42;
|
|
if (!bl) continue;
|
|
}
|
|
n55 = p3.c;
|
|
}
|
|
int n59 = n55;
|
|
int n60 = (p3.d - n59) / n56;
|
|
int n61 = n3;
|
|
n61 = -this.x;
|
|
if (!bl) {
|
|
if (n58 < n61) {
|
|
n59 += (-this.x - n3) * n60;
|
|
n3 = -this.x;
|
|
n56 = n57 - n3;
|
|
}
|
|
int n61 = n57;
|
|
n61 = this.x;
|
|
}
|
|
if (!bl) {
|
|
if (n58 > n61) {
|
|
int n63 = this.x;
|
|
n56 = n63 - n3;
|
|
}
|
|
f.a(this.lb, 0, 0, 0, this.db[n5], n29 + n38 * n3, n32 + n39 * n3, n35 + n40 * n3, n30, n33, n36, n56, n43 + n3, n59, n60);
|
|
n29 += n31;
|
|
n32 += n34;
|
|
n35 += n37;
|
|
int n61 = n43;
|
|
n61 = n42;
|
|
}
|
|
n43 = n58 + n61;
|
|
if (!bl) continue;
|
|
}
|
|
return;
|
|
}
|
|
int n28 = n24 * n19 - n25 * n18;
|
|
n28 = 11;
|
|
}
|
|
int n64 = n27 << n28;
|
|
int n65 = n25 * n20 - n26 * n19 << 5 - this.B + 6 + 4;
|
|
int n66 = n26 * n18 - n24 * n20 << 5 - this.B + 6;
|
|
int n67 = n21 * n19 - n22 * n18 << 11;
|
|
int n68 = n22 * n20 - n23 * n19 << 5 - this.B + 6 + 4;
|
|
int n69 = n23 * n18 - n21 * n20 << 5 - this.B + 6;
|
|
int n70 = n22 * n24 - n21 * n25 << 5;
|
|
int n71 = n23 * n25 - n22 * n26 << 5 - this.B + 4;
|
|
int n72 = n21 * n26 - n23 * n24 >> this.B - 5;
|
|
int n73 = n65 >> 4;
|
|
int n74 = n68 >> 4;
|
|
int n75 = n71 >> 4;
|
|
int n76 = this.nb - this.A;
|
|
int n77 = this.w;
|
|
int n78 = this.z + this.nb * n77;
|
|
int n79 = 1;
|
|
n64 += n66 * n76;
|
|
n67 += n69 * n76;
|
|
n70 += n72 * n76;
|
|
int n62 = this.vb;
|
|
if (!bl) {
|
|
if (n62 != 0) {
|
|
int n80 = this.nb & 1;
|
|
n80 = 1;
|
|
if (!bl) {
|
|
if (n63 == n80) {
|
|
++this.nb;
|
|
n64 += n66;
|
|
n67 += n69;
|
|
n70 += n72;
|
|
n78 += n77;
|
|
}
|
|
n66 <<= 1;
|
|
n69 <<= 1;
|
|
n72 <<= 1;
|
|
int n80 = n77;
|
|
n80 = 1;
|
|
}
|
|
n77 = n63 << n80;
|
|
n79 = 2;
|
|
}
|
|
n62 = this.eb[n5];
|
|
}
|
|
if (!bl) {
|
|
if (n62 == 0) {
|
|
for (n2 = this.nb; n2 < this.ob; n2 += n79) {
|
|
int n83;
|
|
p p4 = this.mb[n2];
|
|
n3 = p4.a >> 8;
|
|
int n84 = p4.b >> 8;
|
|
int n81 = n83 = n84 - n3;
|
|
if (!bl) {
|
|
if (n81 <= 0) {
|
|
n64 += n66;
|
|
n67 += n69;
|
|
n70 += n72;
|
|
n78 += n77;
|
|
if (!bl) continue;
|
|
}
|
|
n81 = p4.c;
|
|
}
|
|
int n86 = n81;
|
|
int n87 = (p4.d - n86) / n83;
|
|
int n85 = n3;
|
|
n85 = -this.x;
|
|
if (!bl) {
|
|
if (n82 < n85) {
|
|
n86 += (-this.x - n3) * n87;
|
|
n3 = -this.x;
|
|
n83 = n84 - n3;
|
|
}
|
|
int n85 = n84;
|
|
n85 = this.x;
|
|
}
|
|
if (!bl) {
|
|
if (n82 > n85) {
|
|
int n90 = this.x;
|
|
n83 = n90 - n3;
|
|
}
|
|
f.c(this.lb, this.db[n5], 0, 0, n64 + n73 * n3, n67 + n74 * n3, n70 + n75 * n3, n65, n68, n71, n83, n78 + n3, n86, n87);
|
|
n64 += n66;
|
|
n67 += n69;
|
|
n70 += n72;
|
|
int n85 = n78;
|
|
n85 = n77;
|
|
}
|
|
n78 = n82 + n85;
|
|
if (!bl) continue;
|
|
}
|
|
return;
|
|
}
|
|
n62 = this.nb;
|
|
}
|
|
for (n2 = (int)(v74636); n2 < this.ob; n2 += n79) {
|
|
int n91;
|
|
p p5 = this.mb[n2];
|
|
n3 = p5.a >> 8;
|
|
int n92 = p5.b >> 8;
|
|
int n86 = n91 = n92 - n3;
|
|
if (!bl) {
|
|
if (n86 <= 0) {
|
|
n64 += n66;
|
|
n67 += n69;
|
|
n70 += n72;
|
|
n78 += n77;
|
|
if (!bl) continue;
|
|
}
|
|
n86 = p5.c;
|
|
}
|
|
int n94 = n86;
|
|
int n95 = (p5.d - n94) / n91;
|
|
int n88 = n3;
|
|
n88 = -this.x;
|
|
if (!bl) {
|
|
if (n87 < n88) {
|
|
n94 += (-this.x - n3) * n95;
|
|
n3 = -this.x;
|
|
n91 = n92 - n3;
|
|
}
|
|
int n88 = n92;
|
|
n88 = this.x;
|
|
}
|
|
if (!bl) {
|
|
if (n87 > n88) {
|
|
int n98 = this.x;
|
|
n91 = n98 - n3;
|
|
}
|
|
f.b(this.lb, 0, 0, 0, this.db[n5], n64 + n73 * n3, n67 + n74 * n3, n70 + n75 * n3, n65, n68, n71, n91, n78 + n3, n94, n95);
|
|
n64 += n66;
|
|
n67 += n69;
|
|
n70 += n72;
|
|
int n88 = n78;
|
|
n88 = n77;
|
|
}
|
|
n78 = n87 + n88;
|
|
if (!bl) continue;
|
|
}
|
|
return;
|
|
}
|
|
n16 = n15 = 0;
|
|
}
|
|
while (n15 < this.a) {
|
|
block74: {
|
|
block77: {
|
|
int n89;
|
|
block76: {
|
|
int n90;
|
|
block75: {
|
|
int n13 = this.b[n15];
|
|
n13 = n5;
|
|
if (bl) break block73;
|
|
if (bl) break block75;
|
|
if (n14 == n13) {
|
|
this.d = this.c[n15];
|
|
if (!bl) break;
|
|
}
|
|
n89 = n15;
|
|
if (bl) break block76;
|
|
n90 = this.a - 1;
|
|
}
|
|
if (n89 != n90) break block77;
|
|
n89 = (int)(Math.random() * (double)this.a);
|
|
}
|
|
n12 = n89;
|
|
this.b[n12] = n5;
|
|
n5 = -1 - n5;
|
|
n11 = (n5 >> 10 & 0x1F) * 8;
|
|
int n101 = (n5 >> 5 & 0x1F) * 8;
|
|
n10 = (n5 & 0x1F) * 8;
|
|
for (n9 = 0; n9 < 256; ++n9) {
|
|
n8 = n9 * n9;
|
|
n7 = n11 * n8 / 65536;
|
|
n6 = n101 * n8 / 65536;
|
|
int n102 = n10 * n8 / 65536;
|
|
this.c[n12][255 - n9] = (n7 << 16) + (n6 << 8) + n102;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block74;
|
|
}
|
|
this.d = this.c[n12];
|
|
}
|
|
++n15;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
n15 = this.w;
|
|
int n13 = this.z;
|
|
n13 = this.nb * n15;
|
|
}
|
|
n12 = n14 + n13;
|
|
n11 = 1;
|
|
int n91 = this.vb;
|
|
if (!bl) {
|
|
if (n91 != 0) {
|
|
int n93 = this.nb & 1;
|
|
n93 = 1;
|
|
if (!bl) {
|
|
if (n92 == n93) {
|
|
++this.nb;
|
|
n12 += n15;
|
|
}
|
|
int n93 = n15;
|
|
n93 = 1;
|
|
}
|
|
n15 = n92 << n93;
|
|
n11 = 2;
|
|
}
|
|
n91 = l2.E;
|
|
}
|
|
if (!bl) {
|
|
if (n91 != 0) {
|
|
for (n2 = this.nb; n2 < this.ob; n2 += n11) {
|
|
p p6 = this.mb[n2];
|
|
n3 = p6.a >> 8;
|
|
n10 = p6.b >> 8;
|
|
int n94 = n9 = n10 - n3;
|
|
if (!bl) {
|
|
if (n94 <= 0) {
|
|
n12 += n15;
|
|
if (!bl) continue;
|
|
}
|
|
n94 = p6.c;
|
|
}
|
|
n8 = n94;
|
|
n7 = (p6.d - n8) / n9;
|
|
int n96 = n3;
|
|
n96 = -this.x;
|
|
if (!bl) {
|
|
if (n95 < n96) {
|
|
n8 += (-this.x - n3) * n7;
|
|
n3 = -this.x;
|
|
n9 = n10 - n3;
|
|
}
|
|
int n96 = n10;
|
|
n96 = this.x;
|
|
}
|
|
if (!bl) {
|
|
if (n95 > n96) {
|
|
n6 = this.x;
|
|
n9 = n6 - n3;
|
|
}
|
|
f.b(this.lb, -n9, n12 + n3, 0, this.d, n8, n7);
|
|
int n96 = n12;
|
|
n96 = n15;
|
|
}
|
|
n12 = n95 + n96;
|
|
if (!bl) continue;
|
|
}
|
|
return;
|
|
}
|
|
n91 = this.nb;
|
|
}
|
|
for (n2 = (int)(v74994); n2 < this.ob; n2 += n11) {
|
|
p p7 = this.mb[n2];
|
|
n3 = p7.a >> 8;
|
|
n10 = p7.b >> 8;
|
|
int n97 = n9 = n10 - n3;
|
|
if (!bl) {
|
|
if (n97 <= 0) {
|
|
n12 += n15;
|
|
if (!bl) continue;
|
|
}
|
|
n97 = p7.c;
|
|
}
|
|
n8 = n97;
|
|
n7 = (p7.d - n8) / n9;
|
|
int n99 = n3;
|
|
n99 = -this.x;
|
|
if (!bl) {
|
|
if (n98 < n99) {
|
|
n8 += (-this.x - n3) * n7;
|
|
n3 = -this.x;
|
|
n9 = n10 - n3;
|
|
}
|
|
int n99 = n10;
|
|
n99 = this.x;
|
|
}
|
|
if (!bl) {
|
|
if (n98 > n99) {
|
|
n6 = this.x;
|
|
n9 = n6 - n3;
|
|
}
|
|
f.c(this.lb, -n9, n12 + n3, 0, this.d, n8, n7);
|
|
int n99 = n12;
|
|
n99 = n15;
|
|
}
|
|
n12 = n98 + n99;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
private static void a(int[] nArray, int[] nArray2, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9, int n10, int n11, int n12, int n13) {
|
|
int n14;
|
|
int n15;
|
|
int n16;
|
|
int n17;
|
|
boolean bl;
|
|
block24: {
|
|
int n18;
|
|
int n19;
|
|
int n20;
|
|
int n21;
|
|
int n22;
|
|
block32: {
|
|
block31: {
|
|
block29: {
|
|
block30: {
|
|
int n23;
|
|
int n24;
|
|
block28: {
|
|
block27: {
|
|
block25: {
|
|
block26: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
int n25 = n10;
|
|
if (!bl) {
|
|
if (n25 <= 0) {
|
|
return;
|
|
}
|
|
n25 = 0;
|
|
}
|
|
n22 = n25;
|
|
n21 = 0;
|
|
n17 = 0;
|
|
n24 = n6;
|
|
if (!bl) {
|
|
if (n24 != 0) {
|
|
n2 = n4 / n6 << 7;
|
|
n3 = n5 / n6 << 7;
|
|
}
|
|
n24 = n2;
|
|
}
|
|
if (bl) break block25;
|
|
if (n24 >= 0) break block26;
|
|
n2 = 0;
|
|
if (!bl) break block27;
|
|
}
|
|
n24 = n2;
|
|
}
|
|
n23 = 16256;
|
|
if (bl) break block28;
|
|
if (n24 > n23) {
|
|
n2 = 16256;
|
|
}
|
|
}
|
|
n4 += n7;
|
|
n5 += n8;
|
|
n24 = n6;
|
|
n23 = n9;
|
|
}
|
|
n20 = n6 = n24 + n23;
|
|
if (!bl) {
|
|
if (n20 != 0) {
|
|
n22 = n4 / n6 << 7;
|
|
n21 = n5 / n6 << 7;
|
|
}
|
|
n20 = n22;
|
|
}
|
|
if (bl) break block29;
|
|
if (n20 >= 0) break block30;
|
|
n22 = 0;
|
|
if (!bl) break block31;
|
|
}
|
|
n20 = n22;
|
|
}
|
|
n19 = 16256;
|
|
if (bl) break block32;
|
|
if (n20 > n19) {
|
|
n22 = 16256;
|
|
}
|
|
}
|
|
n20 = n22 - n2;
|
|
n19 = 4;
|
|
}
|
|
n16 = n20 >> n19;
|
|
n15 = n21 - n3 >> 4;
|
|
for (n14 = n10 >> 4; n14 > 0; --n14) {
|
|
int n26;
|
|
int n27;
|
|
block36: {
|
|
block35: {
|
|
block33: {
|
|
block34: {
|
|
n2 += n12 & 0x600000;
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = nArray2[(n3 & 0x3F80) + (n2 >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
n2 += n16;
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + (n2 >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
n2 += n16;
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + (n2 >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
n2 += n16;
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + (n2 >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
nArray[n11++] = nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17;
|
|
n2 = n22;
|
|
n3 = n21;
|
|
n4 += n7;
|
|
n5 += n8;
|
|
n18 = n6 += n9;
|
|
if (bl) break block24;
|
|
if (!bl) {
|
|
if (n18 != 0) {
|
|
n22 = n4 / n6 << 7;
|
|
n21 = n5 / n6 << 7;
|
|
}
|
|
n27 = n22;
|
|
}
|
|
if (bl) break block33;
|
|
if (n27 >= 0) break block34;
|
|
n22 = 0;
|
|
if (!bl) break block35;
|
|
}
|
|
n27 = n22;
|
|
}
|
|
n26 = 16256;
|
|
if (bl) break block36;
|
|
if (n27 > n26) {
|
|
n22 = 16256;
|
|
}
|
|
}
|
|
n16 = n22 - n2 >> 4;
|
|
n27 = n21 - n3;
|
|
n26 = 4;
|
|
}
|
|
n15 = n27 >> n26;
|
|
if (!bl) continue;
|
|
}
|
|
n18 = n14 = 0;
|
|
}
|
|
while (n14 < (n10 & 0xF)) {
|
|
int n28 = n14 & 3;
|
|
if (!bl) {
|
|
if (n28 == 0) {
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
}
|
|
nArray[n11++] = nArray2[(n3 & 0x3F80) + (n2 >> 7)] >>> n17;
|
|
n2 += n16;
|
|
n28 = n3 + n15;
|
|
}
|
|
n3 = n28;
|
|
++n14;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
private static void b(int[] nArray, int[] nArray2, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9, int n10, int n11, int n12, int n13) {
|
|
int n14;
|
|
int n15;
|
|
int n16;
|
|
int n17;
|
|
boolean bl;
|
|
block24: {
|
|
int n18;
|
|
int n19;
|
|
int n20;
|
|
int n21;
|
|
int n22;
|
|
int n23;
|
|
block32: {
|
|
block31: {
|
|
block29: {
|
|
block30: {
|
|
int n24;
|
|
int n25;
|
|
block28: {
|
|
block27: {
|
|
block25: {
|
|
block26: {
|
|
bl = q.d;
|
|
n23 = h.P;
|
|
int n26 = n10;
|
|
if (!bl) {
|
|
if (n26 <= 0) {
|
|
return;
|
|
}
|
|
n26 = 0;
|
|
}
|
|
n22 = n26;
|
|
n21 = 0;
|
|
n17 = 0;
|
|
n25 = n6;
|
|
if (!bl) {
|
|
if (n25 != 0) {
|
|
n2 = n4 / n6 << 7;
|
|
n3 = n5 / n6 << 7;
|
|
}
|
|
n25 = n2;
|
|
}
|
|
if (bl) break block25;
|
|
if (n25 >= 0) break block26;
|
|
n2 = 0;
|
|
n25 = n23;
|
|
if (bl) break block25;
|
|
if (n25 == 0 && !bl) break block27;
|
|
}
|
|
n25 = n2;
|
|
}
|
|
n24 = 16256;
|
|
if (bl) break block28;
|
|
if (n25 > n24) {
|
|
n2 = 16256;
|
|
}
|
|
}
|
|
n4 += n7;
|
|
n5 += n8;
|
|
n25 = n6;
|
|
n24 = n9;
|
|
}
|
|
n20 = n6 = n25 + n24;
|
|
if (!bl) {
|
|
if (n20 != 0) {
|
|
n22 = n4 / n6 << 7;
|
|
n21 = n5 / n6 << 7;
|
|
}
|
|
n20 = n22;
|
|
}
|
|
if (bl) break block29;
|
|
if (n20 >= 0) break block30;
|
|
n22 = 0;
|
|
n20 = n23;
|
|
if (bl) break block29;
|
|
if (n20 == 0 && !bl) break block31;
|
|
}
|
|
n20 = n22;
|
|
}
|
|
n19 = 16256;
|
|
if (bl) break block32;
|
|
if (n20 > n19) {
|
|
n22 = 16256;
|
|
}
|
|
}
|
|
n20 = n22 - n2;
|
|
n19 = 4;
|
|
}
|
|
n16 = n20 >> n19;
|
|
n15 = n21 - n3 >> 4;
|
|
for (n14 = n10 >> 4; n14 > 0; --n14) {
|
|
int n27;
|
|
int n28;
|
|
block36: {
|
|
block35: {
|
|
block33: {
|
|
block34: {
|
|
n2 += n12 & 0x600000;
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = (nArray2[(n3 & 0x3F80) + (n2 >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n16;
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + (n2 >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n16;
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + (n2 >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n16;
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + (n2 >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n15) & 0x3F80) + ((n2 += n16) >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 = n22;
|
|
n3 = n21;
|
|
n4 += n7;
|
|
n5 += n8;
|
|
n18 = n6 += n9;
|
|
if (bl) break block24;
|
|
if (!bl) {
|
|
if (n18 != 0) {
|
|
n22 = n4 / n6 << 7;
|
|
n21 = n5 / n6 << 7;
|
|
}
|
|
n28 = n22;
|
|
}
|
|
if (bl) break block33;
|
|
if (n28 >= 0) break block34;
|
|
n22 = 0;
|
|
n28 = n23;
|
|
if (bl) break block33;
|
|
if (n28 == 0 && !bl) break block35;
|
|
}
|
|
n28 = n22;
|
|
}
|
|
n27 = 16256;
|
|
if (bl) break block36;
|
|
if (n28 > n27) {
|
|
n22 = 16256;
|
|
}
|
|
}
|
|
n16 = n22 - n2 >> 4;
|
|
n28 = n21 - n3;
|
|
n27 = 4;
|
|
}
|
|
n15 = n28 >> n27;
|
|
if (!bl) continue;
|
|
}
|
|
n18 = n14 = 0;
|
|
}
|
|
while (n14 < (n10 & 0xF)) {
|
|
int n29 = n14 & 3;
|
|
if (!bl) {
|
|
if (n29 == 0) {
|
|
n2 = (n2 & 0x3FFF) + (n12 & 0x600000);
|
|
n17 = n12 >> 23;
|
|
n12 += n13;
|
|
}
|
|
nArray[n11++] = (nArray2[(n3 & 0x3F80) + (n2 >> 7)] >>> n17) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n16;
|
|
n29 = n3 + n15;
|
|
}
|
|
n3 = n29;
|
|
++n14;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
private static void a(int[] var0, int var1_1, int var2_2, int var3_3, int[] var4_4, int var5_5, int var6_6, int var7_7, int var8_8, int var9_9, int var10_10, int var11_11, int var12_12, int var13_13, int var14_14) {
|
|
block57: {
|
|
block56: {
|
|
block54: {
|
|
block55: {
|
|
var23_15 = q.d;
|
|
var15_16 = false;
|
|
v0 = var11_11;
|
|
if (!var23_15) {
|
|
if (v0 <= 0) {
|
|
return;
|
|
}
|
|
v0 = 0;
|
|
}
|
|
var16_17 = v0;
|
|
var17_18 = 0;
|
|
var14_14 <<= 2;
|
|
v1 = var7_7;
|
|
if (!var23_15) {
|
|
if (v1 != 0) {
|
|
var16_17 = var5_5 / var7_7 << 7;
|
|
var17_18 = var6_6 / var7_7 << 7;
|
|
}
|
|
v1 = var16_17;
|
|
}
|
|
if (var23_15) break block54;
|
|
if (v1 >= 0) break block55;
|
|
var16_17 = 0;
|
|
if (!var23_15) break block56;
|
|
}
|
|
v1 = var16_17;
|
|
}
|
|
if (var23_15) break block57;
|
|
if (v1 > 16256) {
|
|
var16_17 = 16256;
|
|
}
|
|
}
|
|
v1 = var11_11;
|
|
}
|
|
var18_19 = v1;
|
|
block0: while (true) {
|
|
v2 = var18_19;
|
|
block1: while (v2 > 0) {
|
|
block61: {
|
|
block60: {
|
|
block58: {
|
|
block59: {
|
|
var5_5 += var8_8;
|
|
var6_6 += var9_9;
|
|
var2_2 = var16_17;
|
|
var3_3 = var17_18;
|
|
v3 = var7_7 += var10_10;
|
|
if (!var23_15) {
|
|
if (v3 != 0) {
|
|
var16_17 = var5_5 / var7_7 << 7;
|
|
var17_18 = var6_6 / var7_7 << 7;
|
|
}
|
|
v3 = var16_17;
|
|
}
|
|
if (var23_15) break block58;
|
|
if (v3 >= 0) break block59;
|
|
var16_17 = 0;
|
|
if (!var23_15) break block60;
|
|
}
|
|
v3 = var16_17;
|
|
}
|
|
v4 = 16256;
|
|
if (var23_15) break block61;
|
|
if (v3 > v4) {
|
|
var16_17 = 16256;
|
|
}
|
|
}
|
|
v3 = var16_17 - var2_2;
|
|
v4 = 4;
|
|
}
|
|
var19_20 = v3 >> v4;
|
|
var20_21 = var17_18 - var3_3 >> 4;
|
|
var21_22 = var13_13 >> 23;
|
|
var2_2 += var13_13 & 0x600000;
|
|
var13_13 += var14_14;
|
|
v5 = var18_19;
|
|
v6 = 16;
|
|
if (var23_15) ** GOTO lbl91
|
|
if (v5 >= v6) ** GOTO lbl88
|
|
var22_23 = 0;
|
|
while (var22_23 < var18_19) {
|
|
block66: {
|
|
block65: {
|
|
block64: {
|
|
block63: {
|
|
block62: {
|
|
v2 = var4_4[(var3_3 & 16256) + (var2_2 >> 7)] >>> var21_22;
|
|
if (var23_15) continue block1;
|
|
if (var23_15) break block62;
|
|
if (v2 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var3_3 += var20_21;
|
|
if (var23_15) break block63;
|
|
v7 = var22_23 & 3;
|
|
}
|
|
if (v7 == 3) {
|
|
var2_2 = (var2_2 & 16383) + (var13_13 & 0x600000);
|
|
var21_22 = var13_13 >> 23;
|
|
var13_13 += var14_14;
|
|
}
|
|
++var22_23;
|
|
}
|
|
if (!var23_15) continue;
|
|
lbl88:
|
|
// 2 sources
|
|
|
|
v8 = var4_4[(var3_3 & 16256) + (var2_2 >> 7)] >>> var21_22;
|
|
v6 = v8;
|
|
v5 = v8;
|
|
lbl91:
|
|
// 2 sources
|
|
|
|
var1_1 = v6;
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var2_2 = (var2_2 & 16383) + (var13_13 & 0x600000);
|
|
var21_22 = var13_13 >> 23;
|
|
var13_13 += var14_14;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + (var2_2 >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var2_2 = (var2_2 & 16383) + (var13_13 & 0x600000);
|
|
var21_22 = var13_13 >> 23;
|
|
var13_13 += var14_14;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + (var2_2 >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var2_2 = (var2_2 & 16383) + (var13_13 & 0x600000);
|
|
var21_22 = var13_13 >> 23;
|
|
var13_13 += var14_14;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + (var2_2 >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7)] >>> var21_22;
|
|
}
|
|
if (var23_15) break block64;
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v9 = var4_4;
|
|
v10 = ((var3_3 += var20_21) & 16256) + ((var2_2 += var19_20) >> 7);
|
|
if (var23_15) break block65;
|
|
v5 = var1_1 = v9[v10] >>> var21_22;
|
|
}
|
|
if (v5 == 0) break block66;
|
|
v9 = var0;
|
|
v10 = var12_12;
|
|
}
|
|
v9[v10] = var1_1;
|
|
}
|
|
++var12_12;
|
|
break;
|
|
}
|
|
var18_19 -= 16;
|
|
if (!var23_15) continue block0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Exception decompiling
|
|
*/
|
|
private static void c(int[] var0, int[] var1_1, int var2_2, int var3_3, int var4_4, int var5_5, int var6_6, int var7_7, int var8_8, int var9_9, int var10_10, int var11_11, int var12_12, int var13_13) {
|
|
/*
|
|
* 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: Tried to end blocks [1[DOLOOP]], but top level block is 2[WHILELOOP]
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.Op04StructuredStatement.processEndingBlocks(Op04StructuredStatement.java:435)
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.Op04StructuredStatement.buildNestedBlocks(Op04StructuredStatement.java:484)
|
|
* at org.benf.cfr.reader.bytecode.analysis.opgraph.Op03SimpleStatement.createInitialStructuredBlock(Op03SimpleStatement.java:736)
|
|
* at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisInner(CodeAnalyser.java:850)
|
|
* 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");
|
|
}
|
|
|
|
private static void d(int[] nArray, int[] nArray2, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9, int n10, int n11, int n12, int n13) {
|
|
int n14;
|
|
int n15;
|
|
int n16;
|
|
int n17;
|
|
boolean bl;
|
|
block29: {
|
|
int n18;
|
|
block28: {
|
|
block26: {
|
|
block27: {
|
|
bl = q.d;
|
|
n17 = h.P;
|
|
int n19 = n10;
|
|
if (!bl) {
|
|
if (n19 <= 0) {
|
|
return;
|
|
}
|
|
n19 = 0;
|
|
}
|
|
n16 = n19;
|
|
n15 = 0;
|
|
n13 <<= 2;
|
|
n18 = n6;
|
|
if (!bl) {
|
|
if (n18 != 0) {
|
|
n16 = n4 / n6 << 6;
|
|
n15 = n5 / n6 << 6;
|
|
}
|
|
n18 = n16;
|
|
}
|
|
if (bl) break block26;
|
|
if (n18 >= 0) break block27;
|
|
n16 = 0;
|
|
n18 = n17;
|
|
if (bl) break block26;
|
|
if (n18 == 0 && !bl) break block28;
|
|
}
|
|
n18 = n16;
|
|
}
|
|
if (bl) break block29;
|
|
if (n18 > 4032) {
|
|
n16 = 4032;
|
|
}
|
|
}
|
|
n18 = n14 = n10;
|
|
}
|
|
while (n14 > 0) {
|
|
block36: {
|
|
int n20;
|
|
int n21;
|
|
block35: {
|
|
int n22;
|
|
int n23;
|
|
block25: {
|
|
int n24;
|
|
int n25;
|
|
block34: {
|
|
int n26;
|
|
int n27;
|
|
block33: {
|
|
block32: {
|
|
block30: {
|
|
block31: {
|
|
n4 += n7;
|
|
n5 += n8;
|
|
n2 = n16;
|
|
n3 = n15;
|
|
n27 = n6 += n9;
|
|
if (!bl) {
|
|
if (n27 != 0) {
|
|
n16 = n4 / n6 << 6;
|
|
n15 = n5 / n6 << 6;
|
|
}
|
|
n27 = n16;
|
|
}
|
|
if (bl) break block30;
|
|
if (n27 >= 0) break block31;
|
|
n16 = 0;
|
|
n27 = n17;
|
|
if (bl) break block30;
|
|
if (n27 == 0 && !bl) break block32;
|
|
}
|
|
n27 = n16;
|
|
}
|
|
n26 = 4032;
|
|
if (bl) break block33;
|
|
if (n27 > n26) {
|
|
n16 = 4032;
|
|
}
|
|
}
|
|
n27 = n16 - n2;
|
|
n26 = 4;
|
|
}
|
|
n25 = n27 >> n26;
|
|
n24 = n15 - n3 >> 4;
|
|
n21 = n12 >> 20;
|
|
n2 += n12 & 0xC0000;
|
|
n12 += n13;
|
|
n23 = n14;
|
|
n22 = 16;
|
|
if (bl) break block25;
|
|
if (n23 >= n22) break block34;
|
|
int n28 = 0;
|
|
while (n28 < n14) {
|
|
nArray[n11++] = (nArray2[(n3 & 0xFC0) + (n2 >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n25;
|
|
n3 += n24;
|
|
if (!bl) {
|
|
n23 = n28 & 3;
|
|
n22 = 3;
|
|
if (bl) break block25;
|
|
if (n23 == n22) {
|
|
n2 = (n2 & 0xFFF) + (n12 & 0xC0000);
|
|
n21 = n12 >> 20;
|
|
n12 += n13;
|
|
}
|
|
++n28;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
n20 = n17;
|
|
if (bl) break block35;
|
|
if (n20 == 0 && !bl) break block36;
|
|
}
|
|
nArray[n11++] = (nArray2[(n3 & 0xFC0) + (n2 >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n25;
|
|
n2 = (n2 & 0xFFF) + (n12 & 0xC0000);
|
|
n21 = n12 >> 20;
|
|
n12 += n13;
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + (n2 >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n25;
|
|
n2 = (n2 & 0xFFF) + (n12 & 0xC0000);
|
|
n21 = n12 >> 20;
|
|
n12 += n13;
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + (n2 >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n25;
|
|
n2 = (n2 & 0xFFF) + (n12 & 0xC0000);
|
|
n21 = n12 >> 20;
|
|
n12 += n13;
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + (n2 >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
nArray[n11++] = (nArray2[((n3 += n24) & 0xFC0) + ((n2 += n25) >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
n2 += n25;
|
|
n23 = n3;
|
|
n22 = n24;
|
|
}
|
|
n20 = n23 + n22;
|
|
}
|
|
n3 = n20;
|
|
nArray[n11++] = (nArray2[(n3 & 0xFC0) + (n2 >> 6)] >>> n21) + (nArray[n11] >> 1 & 0x7F7F7F);
|
|
}
|
|
n14 -= 16;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
private static void b(int[] var0, int var1_1, int var2_2, int var3_3, int[] var4_4, int var5_5, int var6_6, int var7_7, int var8_8, int var9_9, int var10_10, int var11_11, int var12_12, int var13_13, int var14_14) {
|
|
block57: {
|
|
block56: {
|
|
block54: {
|
|
block55: {
|
|
var23_15 = q.d;
|
|
var15_16 = false;
|
|
v0 = var11_11;
|
|
if (!var23_15) {
|
|
if (v0 <= 0) {
|
|
return;
|
|
}
|
|
v0 = 0;
|
|
}
|
|
var16_17 = v0;
|
|
var17_18 = 0;
|
|
var14_14 <<= 2;
|
|
v1 = var7_7;
|
|
if (!var23_15) {
|
|
if (v1 != 0) {
|
|
var16_17 = var5_5 / var7_7 << 6;
|
|
var17_18 = var6_6 / var7_7 << 6;
|
|
}
|
|
v1 = var16_17;
|
|
}
|
|
if (var23_15) break block54;
|
|
if (v1 >= 0) break block55;
|
|
var16_17 = 0;
|
|
if (!var23_15) break block56;
|
|
}
|
|
v1 = var16_17;
|
|
}
|
|
if (var23_15) break block57;
|
|
if (v1 > 4032) {
|
|
var16_17 = 4032;
|
|
}
|
|
}
|
|
v1 = var11_11;
|
|
}
|
|
var18_19 = v1;
|
|
block0: while (true) {
|
|
v2 = var18_19;
|
|
block1: while (v2 > 0) {
|
|
block61: {
|
|
block60: {
|
|
block58: {
|
|
block59: {
|
|
var5_5 += var8_8;
|
|
var6_6 += var9_9;
|
|
var2_2 = var16_17;
|
|
var3_3 = var17_18;
|
|
v3 = var7_7 += var10_10;
|
|
if (!var23_15) {
|
|
if (v3 != 0) {
|
|
var16_17 = var5_5 / var7_7 << 6;
|
|
var17_18 = var6_6 / var7_7 << 6;
|
|
}
|
|
v3 = var16_17;
|
|
}
|
|
if (var23_15) break block58;
|
|
if (v3 >= 0) break block59;
|
|
var16_17 = 0;
|
|
if (!var23_15) break block60;
|
|
}
|
|
v3 = var16_17;
|
|
}
|
|
v4 = 4032;
|
|
if (var23_15) break block61;
|
|
if (v3 > v4) {
|
|
var16_17 = 4032;
|
|
}
|
|
}
|
|
v3 = var16_17 - var2_2;
|
|
v4 = 4;
|
|
}
|
|
var19_20 = v3 >> v4;
|
|
var20_21 = var17_18 - var3_3 >> 4;
|
|
var21_22 = var13_13 >> 20;
|
|
var2_2 += var13_13 & 786432;
|
|
var13_13 += var14_14;
|
|
v5 = var18_19;
|
|
v6 = 16;
|
|
if (var23_15) ** GOTO lbl91
|
|
if (v5 >= v6) ** GOTO lbl88
|
|
var22_23 = 0;
|
|
while (var22_23 < var18_19) {
|
|
block66: {
|
|
block65: {
|
|
block64: {
|
|
block63: {
|
|
block62: {
|
|
v2 = var4_4[(var3_3 & 4032) + (var2_2 >> 6)] >>> var21_22;
|
|
if (var23_15) continue block1;
|
|
if (var23_15) break block62;
|
|
if (v2 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var3_3 += var20_21;
|
|
if (var23_15) break block63;
|
|
v7 = var22_23 & 3;
|
|
}
|
|
if (v7 == 3) {
|
|
var2_2 = (var2_2 & 4095) + (var13_13 & 786432);
|
|
var21_22 = var13_13 >> 20;
|
|
var13_13 += var14_14;
|
|
}
|
|
++var22_23;
|
|
}
|
|
if (!var23_15) continue;
|
|
lbl88:
|
|
// 2 sources
|
|
|
|
v8 = var4_4[(var3_3 & 4032) + (var2_2 >> 6)] >>> var21_22;
|
|
v6 = v8;
|
|
v5 = v8;
|
|
lbl91:
|
|
// 2 sources
|
|
|
|
var1_1 = v6;
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var2_2 = (var2_2 & 4095) + (var13_13 & 786432);
|
|
var21_22 = var13_13 >> 20;
|
|
var13_13 += var14_14;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + (var2_2 >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var2_2 = (var2_2 & 4095) + (var13_13 & 786432);
|
|
var21_22 = var13_13 >> 20;
|
|
var13_13 += var14_14;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + (var2_2 >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
var2_2 += var19_20;
|
|
var2_2 = (var2_2 & 4095) + (var13_13 & 786432);
|
|
var21_22 = var13_13 >> 20;
|
|
var13_13 += var14_14;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + (var2_2 >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (!var23_15) {
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v5 = var1_1 = var4_4[((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6)] >>> var21_22;
|
|
}
|
|
if (var23_15) break block64;
|
|
if (v5 != 0) {
|
|
var0[var12_12] = var1_1;
|
|
}
|
|
++var12_12;
|
|
v9 = var4_4;
|
|
v10 = ((var3_3 += var20_21) & 4032) + ((var2_2 += var19_20) >> 6);
|
|
if (var23_15) break block65;
|
|
v5 = var1_1 = v9[v10] >>> var21_22;
|
|
}
|
|
if (v5 == 0) break block66;
|
|
v9 = var0;
|
|
v10 = var12_12;
|
|
}
|
|
v9[v10] = var1_1;
|
|
}
|
|
++var12_12;
|
|
break;
|
|
}
|
|
var18_19 -= 16;
|
|
if (!var23_15) continue block0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void a(int[] nArray, int n2, int n3, int n4, int[] nArray2, int n5, int n6) {
|
|
int n7;
|
|
int n8;
|
|
boolean bl;
|
|
block7: {
|
|
bl = q.d;
|
|
int n9 = h.P;
|
|
int n10 = n2;
|
|
if (!bl) {
|
|
if (n10 >= 0) {
|
|
return;
|
|
}
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
n5 += (n6 <<= 1);
|
|
n10 = n2 / 8;
|
|
}
|
|
for (n8 = n7 = (v93142); n8 < 0; ++n8) {
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
n5 += n6;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
n7 = -(n2 % 8);
|
|
}
|
|
n8 = 0;
|
|
while (n8 < n7) {
|
|
nArray[n3++] = n4;
|
|
if (!bl) {
|
|
if ((n8 & 1) == 1) {
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
n5 += n6;
|
|
}
|
|
++n8;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
private static void b(int[] nArray, int n2, int n3, int n4, int[] nArray2, int n5, int n6) {
|
|
int n7;
|
|
int n8;
|
|
boolean bl;
|
|
block7: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
int n9 = n2;
|
|
if (!bl) {
|
|
if (n9 >= 0) {
|
|
return;
|
|
}
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
n5 += (n6 <<= 2);
|
|
n9 = n2 / 16;
|
|
}
|
|
for (n8 = n7 = (v93261); n8 < 0; ++n8) {
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
n5 += n6;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
n7 = -(n2 % 16);
|
|
}
|
|
n8 = 0;
|
|
while (n8 < n7) {
|
|
nArray[n3++] = n4 + (nArray[n3] >> 1 & 0x7F7F7F);
|
|
if (!bl) {
|
|
if ((n8 & 3) == 3) {
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
n5 += n6;
|
|
n5 += n6;
|
|
}
|
|
++n8;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
private static void c(int[] nArray, int n2, int n3, int n4, int[] nArray2, int n5, int n6) {
|
|
int n7;
|
|
int n8;
|
|
boolean bl;
|
|
block7: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
int n9 = n2;
|
|
if (!bl) {
|
|
if (n9 >= 0) {
|
|
return;
|
|
}
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
n5 += (n6 <<= 2);
|
|
n9 = n2 / 16;
|
|
}
|
|
for (n8 = n7 = (v93543); n8 < 0; ++n8) {
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
nArray[n3++] = n4;
|
|
n4 = nArray2[(n5 += n6) >> 8 & 0xFF];
|
|
n5 += n6;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
n7 = -(n2 % 16);
|
|
}
|
|
n8 = 0;
|
|
while (n8 < n7) {
|
|
nArray[n3++] = n4;
|
|
if (!bl) {
|
|
if ((n8 & 3) == 3) {
|
|
n4 = nArray2[n5 >> 8 & 0xFF];
|
|
n5 += n6;
|
|
}
|
|
++n8;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public void b(int n2, int n3, int n4, int n5, int n6, int n7, int n8) {
|
|
int n9;
|
|
int n10;
|
|
int n11;
|
|
block8: {
|
|
int n12;
|
|
int n13;
|
|
int n14;
|
|
int n15;
|
|
block7: {
|
|
boolean bl = q.d;
|
|
this.G = 1024 - (n5 &= 0x3FF) & 0x3FF;
|
|
this.H = 1024 - (n6 &= 0x3FF) & 0x3FF;
|
|
this.I = 1024 - (n7 &= 0x3FF) & 0x3FF;
|
|
n11 = 0;
|
|
n10 = 0;
|
|
n9 = n8;
|
|
n15 = n5;
|
|
if (!bl) {
|
|
if (n15 != 0) {
|
|
n14 = k[n5];
|
|
n13 = k[n5 + 1024];
|
|
n12 = 0 * n13 - n9 * n14 >> 15;
|
|
n9 = 0 * n14 + n9 * n13 >> 15;
|
|
n10 = n12;
|
|
}
|
|
n15 = n6;
|
|
}
|
|
if (!bl) {
|
|
if (n15 != 0) {
|
|
n14 = k[n6];
|
|
n13 = k[n6 + 1024];
|
|
n12 = n9 * n14 + 0 * n13 >> 15;
|
|
n9 = n9 * n13 - 0 * n14 >> 15;
|
|
n11 = n12;
|
|
}
|
|
n15 = n7;
|
|
}
|
|
if (bl) break block7;
|
|
if (n15 == 0) break block8;
|
|
n15 = k[n7];
|
|
}
|
|
n14 = n15;
|
|
n13 = k[n7 + 1024];
|
|
n12 = n10 * n14 + n11 * n13 >> 15;
|
|
n10 = n10 * n13 - n11 * n14 >> 15;
|
|
n11 = n12;
|
|
}
|
|
this.D = n2 - n11;
|
|
this.E = n3 - n10;
|
|
this.F = n4 - n9;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
private void c(int var1_1) {
|
|
block50: {
|
|
block55: {
|
|
block51: {
|
|
block52: {
|
|
var29_2 = q.d;
|
|
var2_3 = false;
|
|
var3_4 = this.O[var1_1];
|
|
var4_5 = var3_4.g;
|
|
var5_6 = var3_4.h;
|
|
var6_7 = var4_5.k[var5_6];
|
|
var7_8 = var4_5.j[var5_6];
|
|
var8_9 = var4_5.o[var5_6];
|
|
var9_10 = var4_5.b[var6_7[0]];
|
|
var10_11 = var4_5.c[var6_7[0]];
|
|
var11_12 = var4_5.d[var6_7[0]];
|
|
var12_13 = var4_5.b[var6_7[1]] - var9_10;
|
|
var13_14 = var4_5.c[var6_7[1]] - var10_11;
|
|
var14_15 = var4_5.d[var6_7[1]] - var11_12;
|
|
var15_16 = var4_5.b[var6_7[2]] - var9_10;
|
|
var16_17 = var4_5.c[var6_7[2]] - var10_11;
|
|
var17_18 = var4_5.d[var6_7[2]] - var11_12;
|
|
var18_19 = var13_14 * var17_18 - var16_17 * var14_15;
|
|
var19_20 = var14_15 * var15_16 - var17_18 * var12_13;
|
|
var20_21 = var12_13 * var16_17 - var15_16 * var13_14;
|
|
v0 = var8_9;
|
|
v1 = -1;
|
|
if (var29_2) break block51;
|
|
if (v0 != v1) break block52;
|
|
var8_9 = 0;
|
|
do {
|
|
block54: {
|
|
block53: {
|
|
if (var18_19 > 25000) break block53;
|
|
v2 = var19_20;
|
|
v3 = 25000;
|
|
if (var29_2 || var29_2) break block54;
|
|
if (v2 > v3) break block53;
|
|
v2 = var20_21;
|
|
v3 = 25000;
|
|
if (var29_2) break block54;
|
|
if (v2 > v3) break block53;
|
|
v2 = var18_19;
|
|
v3 = -25000;
|
|
if (!var29_2) {
|
|
if (v2 >= v3) {
|
|
v2 = var19_20;
|
|
v3 = -25000;
|
|
if (!var29_2) {
|
|
if (v2 >= v3) {
|
|
v2 = var20_21;
|
|
v3 = -25000;
|
|
if (!var29_2) {
|
|
if (v2 >= v3) break;
|
|
} else {
|
|
** GOTO lbl52
|
|
}
|
|
} else {
|
|
** GOTO lbl51
|
|
}
|
|
} else {
|
|
** GOTO lbl50
|
|
}
|
|
} else {
|
|
** GOTO lbl49
|
|
}
|
|
}
|
|
break block54;
|
|
lbl49:
|
|
// 2 sources
|
|
|
|
break block53;
|
|
lbl50:
|
|
// 2 sources
|
|
|
|
break block54;
|
|
lbl51:
|
|
// 2 sources
|
|
|
|
break block53;
|
|
lbl52:
|
|
// 2 sources
|
|
|
|
break block54;
|
|
}
|
|
++var8_9;
|
|
var18_19 >>= 1;
|
|
var19_20 >>= 1;
|
|
v2 = var20_21;
|
|
v3 = 1;
|
|
}
|
|
var20_21 = v2 >> v3;
|
|
} while (!var29_2);
|
|
var4_5.o[var5_6] = var8_9;
|
|
var4_5.n[var5_6] = (int)((double)this.C * Math.sqrt(var18_19 * var18_19 + var19_20 * var19_20 + var20_21 * var20_21));
|
|
if (!var29_2) break block55;
|
|
}
|
|
var18_19 >>= var8_9;
|
|
var19_20 >>= var8_9;
|
|
v0 = var20_21;
|
|
v1 = var8_9;
|
|
}
|
|
var20_21 = v0 >> v1;
|
|
}
|
|
var3_4.m = var9_10 * var18_19 + var10_11 * var19_20 + var11_12 * var20_21;
|
|
var3_4.j = var18_19;
|
|
var3_4.k = var19_20;
|
|
var3_4.l = var20_21;
|
|
var22_23 = var21_22 = var4_5.d[var6_7[0]];
|
|
var24_25 = var23_24 = var4_5.e[var6_7[0]];
|
|
var26_27 = var25_26 = var4_5.f[var6_7[0]];
|
|
for (var27_28 = 1; var27_28 < var7_8; ++var27_28) {
|
|
block65: {
|
|
block64: {
|
|
block63: {
|
|
block62: {
|
|
block60: {
|
|
block61: {
|
|
block59: {
|
|
block58: {
|
|
block56: {
|
|
block57: {
|
|
var28_29 = var4_5.d[var6_7[var27_28]];
|
|
if (var29_2) break block50;
|
|
v4 = var28_29;
|
|
v5 = var22_23;
|
|
if (var29_2) break block56;
|
|
if (v4 <= v5) break block57;
|
|
var22_23 = var28_29;
|
|
if (!var29_2) break block58;
|
|
}
|
|
v4 = var28_29;
|
|
v5 = var21_22;
|
|
}
|
|
if (var29_2) break block59;
|
|
if (v4 < v5) {
|
|
var21_22 = var28_29;
|
|
}
|
|
}
|
|
v4 = var28_29 = var4_5.e[var6_7[var27_28]];
|
|
v5 = var24_25;
|
|
}
|
|
if (var29_2) break block60;
|
|
if (v4 <= v5) break block61;
|
|
var24_25 = var28_29;
|
|
if (!var29_2) break block62;
|
|
}
|
|
v4 = var28_29;
|
|
v5 = var23_24;
|
|
}
|
|
if (var29_2) break block63;
|
|
if (v4 < v5) {
|
|
var23_24 = var28_29;
|
|
}
|
|
}
|
|
v4 = var28_29 = var4_5.f[var6_7[var27_28]];
|
|
v5 = var26_27;
|
|
}
|
|
if (var29_2) break block64;
|
|
if (v4 > v5) {
|
|
var26_27 = var28_29;
|
|
if (!var29_2) continue;
|
|
}
|
|
v4 = var28_29;
|
|
if (var29_2) break block65;
|
|
v5 = var25_26;
|
|
}
|
|
if (v4 >= v5) continue;
|
|
v4 = var28_29;
|
|
}
|
|
var25_26 = v4;
|
|
if (!var29_2) continue;
|
|
}
|
|
var3_4.e = var21_22;
|
|
var3_4.f = var22_23;
|
|
var3_4.a = var23_24;
|
|
var3_4.c = var24_25;
|
|
var3_4.b = var25_26;
|
|
var3_4.d = var26_27;
|
|
}
|
|
}
|
|
|
|
private void d(int n2) {
|
|
int n3;
|
|
int n4;
|
|
int n5;
|
|
int n6;
|
|
int n7;
|
|
int n8;
|
|
block27: {
|
|
int n9;
|
|
block28: {
|
|
int n10;
|
|
int n11;
|
|
block25: {
|
|
boolean bl;
|
|
block26: {
|
|
block24: {
|
|
int[] nArray;
|
|
l l2;
|
|
block23: {
|
|
block21: {
|
|
block22: {
|
|
block20: {
|
|
block19: {
|
|
block17: {
|
|
block18: {
|
|
block16: {
|
|
int n12;
|
|
block14: {
|
|
block15: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
g g2 = this.O[n2];
|
|
l2 = g2.g;
|
|
int n13 = g2.h;
|
|
nArray = l2.k[n13];
|
|
boolean bl3 = false;
|
|
boolean bl4 = false;
|
|
boolean bl5 = true;
|
|
int n14 = l2.b[nArray[0]];
|
|
int n15 = l2.c[nArray[0]];
|
|
int n16 = l2.d[nArray[0]];
|
|
l2.n[n13] = 1;
|
|
l2.o[n13] = 0;
|
|
g2.m = n14 * 0 + n15 * 0 + n16 * 1;
|
|
g2.j = 0;
|
|
g2.k = 0;
|
|
g2.l = 1;
|
|
n7 = n8 = l2.d[nArray[0]];
|
|
n5 = n6 = l2.e[nArray[0]];
|
|
n12 = l2.e[nArray[1]];
|
|
if (bl) break block14;
|
|
if (n12 >= n6) break block15;
|
|
n6 = l2.e[nArray[1]];
|
|
if (!bl) break block16;
|
|
}
|
|
n12 = l2.e[nArray[1]];
|
|
}
|
|
n5 = n12;
|
|
}
|
|
n4 = l2.f[nArray[1]];
|
|
n3 = l2.f[nArray[0]];
|
|
n9 = n11 = l2.d[nArray[1]];
|
|
n10 = n7;
|
|
if (bl) break block17;
|
|
if (n9 <= n10) break block18;
|
|
n7 = n11;
|
|
if (!bl) break block19;
|
|
}
|
|
n9 = n11;
|
|
n10 = n8;
|
|
}
|
|
if (bl) break block20;
|
|
if (n9 < n10) {
|
|
n8 = n11;
|
|
}
|
|
}
|
|
n9 = n11 = l2.e[nArray[1]];
|
|
n10 = n5;
|
|
}
|
|
if (bl) break block21;
|
|
if (n9 <= n10) break block22;
|
|
n5 = n11;
|
|
if (!bl) break block23;
|
|
}
|
|
n9 = n11;
|
|
n10 = n6;
|
|
}
|
|
if (bl) break block24;
|
|
if (n9 < n10) {
|
|
n6 = n11;
|
|
}
|
|
}
|
|
n9 = n11 = l2.f[nArray[1]];
|
|
n10 = n3;
|
|
}
|
|
if (bl) break block25;
|
|
if (n9 <= n10) break block26;
|
|
n3 = n11;
|
|
if (!bl) break block27;
|
|
}
|
|
n9 = n11;
|
|
if (bl) break block28;
|
|
n10 = n4;
|
|
}
|
|
if (n9 >= n10) break block27;
|
|
n9 = n11;
|
|
}
|
|
n4 = n9;
|
|
}
|
|
g2.e = n8;
|
|
g2.f = n7;
|
|
g2.a = n6 - 20;
|
|
g2.c = n5 + 20;
|
|
g2.b = n4;
|
|
g2.d = n3;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
private boolean a(g var1_1, g var2_2) {
|
|
block58: {
|
|
block57: {
|
|
block56: {
|
|
block42: {
|
|
block41: {
|
|
block44: {
|
|
block43: {
|
|
var27_3 = q.d;
|
|
var3_4 = false;
|
|
v0 = var1_1.a;
|
|
v1 = var2_2.c;
|
|
if (!var27_3) {
|
|
if (v0 >= v1) {
|
|
return true;
|
|
}
|
|
v0 = var2_2.a;
|
|
v1 = var1_1.c;
|
|
}
|
|
if (!var27_3) {
|
|
if (v0 >= v1) {
|
|
return true;
|
|
}
|
|
v0 = var1_1.b;
|
|
v1 = var2_2.d;
|
|
}
|
|
if (!var27_3) {
|
|
if (v0 >= v1) {
|
|
return true;
|
|
}
|
|
v0 = var2_2.b;
|
|
v1 = var1_1.d;
|
|
}
|
|
if (!var27_3) {
|
|
if (v0 >= v1) {
|
|
return true;
|
|
}
|
|
v0 = var1_1.e;
|
|
v1 = var2_2.f;
|
|
}
|
|
if (var27_3) break block43;
|
|
if (v0 >= v1) {
|
|
return true;
|
|
}
|
|
v2 = var2_2;
|
|
if (var27_3) break block44;
|
|
v0 = v2.e;
|
|
v1 = var1_1.f;
|
|
}
|
|
if (v0 > v1) {
|
|
return false;
|
|
}
|
|
v2 = var1_1;
|
|
}
|
|
var4_5 = v2.g;
|
|
var5_6 = var2_2.g;
|
|
var6_7 = var1_1.h;
|
|
var7_8 = var2_2.h;
|
|
var8_9 = var4_5.k[var6_7];
|
|
var9_10 = var5_6.k[var7_8];
|
|
var10_11 = var4_5.j[var6_7];
|
|
var11_12 = var5_6.j[var7_8];
|
|
var12_13 = var5_6.b[var9_10[0]];
|
|
var13_14 = var5_6.c[var9_10[0]];
|
|
var14_15 = var5_6.d[var9_10[0]];
|
|
var15_16 = var2_2.j;
|
|
var16_17 = var2_2.k;
|
|
var17_18 = var2_2.l;
|
|
var18_19 = var5_6.n[var7_8];
|
|
var19_20 = var2_2.m;
|
|
var20_21 = 0;
|
|
for (var21_22 = 0; var21_22 < var10_11; ++var21_22) {
|
|
block47: {
|
|
block48: {
|
|
block49: {
|
|
block45: {
|
|
block46: {
|
|
var22_24 = var8_9[var21_22];
|
|
v3 = var23_26 = (var12_13 - var4_5.b[var22_24]) * var15_16 + (var13_14 - var4_5.c[var22_24]) * var16_17 + (var14_15 - var4_5.d[var22_24]) * var17_18;
|
|
v4 = -var18_19;
|
|
if (var27_3) ** GOTO lbl98
|
|
if (var27_3) break block45;
|
|
if (v3 >= v4) break block46;
|
|
v5 = var19_20;
|
|
if (var27_3) break block47;
|
|
if (v5 < 0) break block48;
|
|
}
|
|
v5 = var23_26;
|
|
if (var27_3) break block49;
|
|
v6 = var18_19;
|
|
}
|
|
if (v5 <= v6) continue;
|
|
v5 = var19_20;
|
|
}
|
|
if (!var27_3) {
|
|
if (v5 <= 0 && !var27_3) continue;
|
|
}
|
|
break block47;
|
|
}
|
|
v5 = var20_21 = 1;
|
|
}
|
|
if (!var27_3) break;
|
|
if (!var27_3) continue;
|
|
}
|
|
v7 = var20_21;
|
|
if (!var27_3) {
|
|
if (v7 == 0) {
|
|
return true;
|
|
}
|
|
var12_13 = var4_5.b[var8_9[0]];
|
|
var13_14 = var4_5.c[var8_9[0]];
|
|
var14_15 = var4_5.d[var8_9[0]];
|
|
var15_16 = var1_1.j;
|
|
var16_17 = var1_1.k;
|
|
var17_18 = var1_1.l;
|
|
var18_19 = var4_5.n[var6_7];
|
|
var19_20 = var1_1.m;
|
|
var20_21 = 0;
|
|
v7 = 0;
|
|
}
|
|
var21_22 = v7;
|
|
do {
|
|
block55: {
|
|
block52: {
|
|
block53: {
|
|
block54: {
|
|
block50: {
|
|
block51: {
|
|
v3 = var21_22;
|
|
v4 = var11_12;
|
|
lbl98:
|
|
// 2 sources
|
|
|
|
if (v3 >= v4) break;
|
|
var22_24 = var9_10[var21_22];
|
|
v8 = var23_26 = (var12_13 - var5_6.b[var22_24]) * var15_16 + (var13_14 - var5_6.c[var22_24]) * var16_17 + (var14_15 - var5_6.d[var22_24]) * var17_18;
|
|
v9 = -var18_19;
|
|
if (var27_3) break block41;
|
|
if (var27_3) break block50;
|
|
if (v8 >= v9) break block51;
|
|
v10 = var19_20;
|
|
if (var27_3) break block52;
|
|
if (v10 > 0) break block53;
|
|
}
|
|
v10 = var23_26;
|
|
if (var27_3) break block54;
|
|
v11 = var18_19;
|
|
}
|
|
if (v10 <= v11) break block55;
|
|
v10 = var19_20;
|
|
}
|
|
if (var27_3) break block52;
|
|
if (v10 >= 0 && !var27_3) break block55;
|
|
}
|
|
v10 = var20_21 = 1;
|
|
}
|
|
if (!var27_3) break;
|
|
}
|
|
++var21_22;
|
|
} while (!var27_3);
|
|
v8 = var20_21;
|
|
if (!var27_3) {
|
|
if (v8 == 0) {
|
|
return true;
|
|
}
|
|
v8 = var10_11;
|
|
}
|
|
if (var27_3) ** GOTO lbl146
|
|
v9 = 2;
|
|
}
|
|
if (v8 == v9) {
|
|
var21_23 = new int[4];
|
|
var22_25 = new int[4];
|
|
var23_26 = var8_9[0];
|
|
var24_28 = var8_9[1];
|
|
var21_23[0] = var4_5.e[var23_26] - 20;
|
|
var21_23[1] = var4_5.e[var24_28] - 20;
|
|
var21_23[2] = var4_5.e[var24_28] + 20;
|
|
var21_23[3] = var4_5.e[var23_26] + 20;
|
|
var22_25[0] = var22_25[3] = var4_5.f[var23_26];
|
|
var22_25[1] = var22_25[2] = var4_5.f[var24_28];
|
|
} else {
|
|
v8 = var10_11;
|
|
lbl146:
|
|
// 2 sources
|
|
|
|
var21_23 = new int[v8];
|
|
var22_25 = new int[var10_11];
|
|
for (var23_26 = 0; var23_26 < var10_11; ++var23_26) {
|
|
var24_28 = var8_9[var23_26];
|
|
var21_23[var23_26] = var4_5.e[var24_28];
|
|
var22_25[var23_26] = var4_5.f[var24_28];
|
|
if (!var27_3) {
|
|
if (!var27_3) continue;
|
|
}
|
|
break block42;
|
|
}
|
|
}
|
|
v12 = var11_12;
|
|
if (var27_3) break block56;
|
|
if (v12 != 2) break block42;
|
|
var23_27 = new int[4];
|
|
var24_29 = new int[4];
|
|
var25_30 = var9_10[0];
|
|
var26_32 = var9_10[1];
|
|
var23_27[0] = var5_6.e[var25_30] - 20;
|
|
var23_27[1] = var5_6.e[var26_32] - 20;
|
|
var23_27[2] = var5_6.e[var26_32] + 20;
|
|
var23_27[3] = var5_6.e[var25_30] + 20;
|
|
var24_29[0] = var24_29[3] = var5_6.f[var25_30];
|
|
var24_29[1] = var24_29[2] = var5_6.f[var26_32];
|
|
break block57;
|
|
}
|
|
v12 = var11_12;
|
|
}
|
|
var23_27 = new int[v12];
|
|
var24_29 = new int[var11_12];
|
|
for (var25_31 = 0; var25_31 < var11_12; ++var25_31) {
|
|
var26_33 = var9_10[var25_31];
|
|
var23_27[var25_31] = var5_6.e[var26_33];
|
|
var24_29[var25_31] = var5_6.f[var26_33];
|
|
if (!var27_3) {
|
|
if (!var27_3) continue;
|
|
}
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
v13 = this.a(var21_23, var22_25, var23_27, var24_29);
|
|
if (!var27_3) {
|
|
** if (v13) goto lbl-1000
|
|
lbl-1000:
|
|
// 1 sources
|
|
|
|
{
|
|
v13 = true;
|
|
** GOTO lbl189
|
|
}
|
|
}
|
|
break block58;
|
|
lbl-1000:
|
|
// 2 sources
|
|
|
|
{
|
|
v13 = false;
|
|
}
|
|
}
|
|
return v13;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
private boolean b(g var1_1, g var2_2) {
|
|
block14: {
|
|
var24_3 = q.d;
|
|
var3_4 = false;
|
|
var4_5 = var1_1.g;
|
|
var5_6 = var2_2.g;
|
|
var6_7 = var1_1.h;
|
|
var7_8 = var2_2.h;
|
|
var8_9 = var4_5.k[var6_7];
|
|
var9_10 = var5_6.k[var7_8];
|
|
var10_11 = var4_5.j[var6_7];
|
|
var11_12 = var5_6.j[var7_8];
|
|
var12_13 = var5_6.b[var9_10[0]];
|
|
var13_14 = var5_6.c[var9_10[0]];
|
|
var14_15 = var5_6.d[var9_10[0]];
|
|
var15_16 = var2_2.j;
|
|
var16_17 = var2_2.k;
|
|
var17_18 = var2_2.l;
|
|
var18_19 = var5_6.n[var7_8];
|
|
var19_20 = var2_2.m;
|
|
var20_21 = 0;
|
|
for (var21_22 = 0; var21_22 < var10_11; ++var21_22) {
|
|
block17: {
|
|
block18: {
|
|
block19: {
|
|
block15: {
|
|
block16: {
|
|
var22_23 = var8_9[var21_22];
|
|
v0 = var23_24 = (var12_13 - var4_5.b[var22_23]) * var15_16 + (var13_14 - var4_5.c[var22_23]) * var16_17 + (var14_15 - var4_5.d[var22_23]) * var17_18;
|
|
v1 = -var18_19;
|
|
if (var24_3) ** GOTO lbl64
|
|
if (var24_3) break block15;
|
|
if (v0 >= v1) break block16;
|
|
v2 = var19_20;
|
|
if (var24_3) break block17;
|
|
if (v2 < 0) break block18;
|
|
}
|
|
v2 = var23_24;
|
|
if (var24_3) break block19;
|
|
v3 = var18_19;
|
|
}
|
|
if (v2 <= v3) continue;
|
|
v2 = var19_20;
|
|
}
|
|
if (!var24_3) {
|
|
if (v2 <= 0 && !var24_3) continue;
|
|
}
|
|
break block17;
|
|
}
|
|
v2 = var20_21 = 1;
|
|
}
|
|
if (!var24_3) break;
|
|
if (!var24_3) continue;
|
|
}
|
|
v4 = var20_21;
|
|
if (!var24_3) {
|
|
if (v4 == 0) {
|
|
return true;
|
|
}
|
|
var12_13 = var4_5.b[var8_9[0]];
|
|
var13_14 = var4_5.c[var8_9[0]];
|
|
var14_15 = var4_5.d[var8_9[0]];
|
|
var15_16 = var1_1.j;
|
|
var16_17 = var1_1.k;
|
|
var17_18 = var1_1.l;
|
|
var18_19 = var4_5.n[var6_7];
|
|
var19_20 = var1_1.m;
|
|
var20_21 = 0;
|
|
v4 = 0;
|
|
}
|
|
var21_22 = v4;
|
|
do {
|
|
block25: {
|
|
block22: {
|
|
block23: {
|
|
block24: {
|
|
block20: {
|
|
block21: {
|
|
v0 = var21_22;
|
|
v1 = var11_12;
|
|
lbl64:
|
|
// 2 sources
|
|
|
|
if (v0 >= v1) break;
|
|
var22_23 = var9_10[var21_22];
|
|
v5 = var23_24 = (var12_13 - var5_6.b[var22_23]) * var15_16 + (var13_14 - var5_6.c[var22_23]) * var16_17 + (var14_15 - var5_6.d[var22_23]) * var17_18;
|
|
if (var24_3) break block14;
|
|
v6 = -var18_19;
|
|
if (var24_3) break block20;
|
|
if (v5 >= v6) break block21;
|
|
v7 = var19_20;
|
|
if (var24_3) break block22;
|
|
if (v7 > 0) break block23;
|
|
}
|
|
v7 = var23_24;
|
|
if (var24_3) break block24;
|
|
v6 = var18_19;
|
|
}
|
|
if (v7 <= v6) break block25;
|
|
v7 = var19_20;
|
|
}
|
|
if (var24_3) break block22;
|
|
if (v7 >= 0 && !var24_3) break block25;
|
|
}
|
|
v7 = var20_21 = 1;
|
|
}
|
|
if (!var24_3) break;
|
|
}
|
|
++var21_22;
|
|
} while (!var24_3);
|
|
v5 = var20_21;
|
|
}
|
|
if (!var24_3) {
|
|
v5 = v5 == 0 ? 1 : 0;
|
|
}
|
|
return (boolean)v5;
|
|
}
|
|
|
|
public void b(int n2, int n3, int n4) {
|
|
this.Y = n2;
|
|
this.Z = new byte[n2][];
|
|
this.ab = new int[n2][];
|
|
this.bb = new int[n2];
|
|
this.cb = new long[n2];
|
|
this.eb = new boolean[n2];
|
|
this.db = new int[n2][];
|
|
fb = 0L;
|
|
this.gb = new int[n3][];
|
|
this.hb = new int[n4][];
|
|
}
|
|
|
|
public void a(int n2, byte[] byArray, int[] nArray, int n3) {
|
|
this.Z[n2] = byArray;
|
|
this.ab[n2] = nArray;
|
|
this.bb[n2] = n3;
|
|
this.cb[n2] = 0L;
|
|
this.eb[n2] = false;
|
|
this.db[n2] = null;
|
|
this.e(n2);
|
|
}
|
|
|
|
public void e(int n2) {
|
|
block23: {
|
|
int n3;
|
|
boolean bl;
|
|
block24: {
|
|
int n4;
|
|
block25: {
|
|
block22: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
if (!bl) {
|
|
if (n2 < 0) {
|
|
return;
|
|
}
|
|
++fb;
|
|
}
|
|
int[] nArray = this.db[n2];
|
|
if (!bl) {
|
|
if (nArray != null) {
|
|
return;
|
|
}
|
|
nArray = this.bb;
|
|
}
|
|
n4 = nArray[n2];
|
|
if (bl) break block24;
|
|
if (n4 != 0) break block25;
|
|
int n5 = 0;
|
|
while (n5 < this.gb.length) {
|
|
block27: {
|
|
block26: {
|
|
int[][] nArray2 = this.gb;
|
|
int n6 = n5++;
|
|
if (bl) break block26;
|
|
if (nArray2[n6] != null) break block27;
|
|
this.gb[n5] = new int[16384];
|
|
nArray2 = this.db;
|
|
n6 = n2;
|
|
}
|
|
nArray2[n6] = this.gb[n5];
|
|
this.f(n2);
|
|
return;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
long l2 = 0x40000000L;
|
|
int n7 = 0;
|
|
for (int i2 = 0; i2 < this.Y; ++i2) {
|
|
long l3;
|
|
f f2;
|
|
block30: {
|
|
int[] nArray3;
|
|
block29: {
|
|
int n8;
|
|
block28: {
|
|
if (bl) break block22;
|
|
n8 = i2;
|
|
if (bl) break block28;
|
|
if (n8 == n2) continue;
|
|
nArray3 = this.bb;
|
|
if (bl) break block29;
|
|
n8 = nArray3[i2];
|
|
}
|
|
if (n8 != 0) continue;
|
|
f2 = this;
|
|
if (bl) break block30;
|
|
nArray3 = f2.db[i2];
|
|
}
|
|
if (nArray3 == null) continue;
|
|
f2 = this;
|
|
}
|
|
long l4 = (l3 = f2.cb[i2] - l2) == 0L ? 0 : (l3 < 0L ? -1 : 1);
|
|
if (!bl) {
|
|
if (l4 >= 0) continue;
|
|
l2 = this.cb[i2];
|
|
l4 = i2;
|
|
}
|
|
n7 = (int)l4;
|
|
if (!bl) continue;
|
|
}
|
|
this.db[n2] = this.db[n7];
|
|
this.db[n7] = null;
|
|
this.f(n2);
|
|
}
|
|
return;
|
|
}
|
|
n4 = n3 = 0;
|
|
}
|
|
while (n3 < this.hb.length) {
|
|
block32: {
|
|
block31: {
|
|
int[][] nArray = this.hb;
|
|
int n9 = n3++;
|
|
if (bl) break block31;
|
|
if (nArray[n9] != null) break block32;
|
|
this.hb[n3] = new int[65536];
|
|
nArray = this.db;
|
|
n9 = n2;
|
|
}
|
|
nArray[n9] = this.hb[n3];
|
|
this.f(n2);
|
|
return;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
long l5 = 0x40000000L;
|
|
int n10 = 0;
|
|
for (int i3 = 0; i3 < this.Y; ++i3) {
|
|
long l6;
|
|
f f3;
|
|
block35: {
|
|
int[] nArray;
|
|
block34: {
|
|
int n11;
|
|
int n12;
|
|
block33: {
|
|
if (bl) break block23;
|
|
n12 = i3;
|
|
n11 = n2;
|
|
if (bl) break block33;
|
|
if (n12 == n11) continue;
|
|
nArray = this.bb;
|
|
if (bl) break block34;
|
|
n12 = nArray[i3];
|
|
n11 = 1;
|
|
}
|
|
if (n12 != n11) continue;
|
|
f3 = this;
|
|
if (bl) break block35;
|
|
nArray = f3.db[i3];
|
|
}
|
|
if (nArray == null) continue;
|
|
f3 = this;
|
|
}
|
|
long l7 = (l6 = f3.cb[i3] - l5) == 0L ? 0 : (l6 < 0L ? -1 : 1);
|
|
if (!bl) {
|
|
if (l7 >= 0) continue;
|
|
l5 = this.cb[i3];
|
|
l7 = i3;
|
|
}
|
|
n10 = (int)l7;
|
|
if (!bl) continue;
|
|
}
|
|
this.db[n2] = this.db[n10];
|
|
this.db[n10] = null;
|
|
this.f(n2);
|
|
}
|
|
}
|
|
|
|
private void f(int n2) {
|
|
int n3;
|
|
int n4;
|
|
int n5;
|
|
int[] nArray;
|
|
boolean bl;
|
|
block8: {
|
|
int n6;
|
|
int n7;
|
|
block11: {
|
|
int n8;
|
|
block9: {
|
|
block10: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
n8 = this.bb[n2];
|
|
if (bl) break block9;
|
|
if (n8 != 0) break block10;
|
|
n7 = 64;
|
|
if (!bl) break block11;
|
|
}
|
|
n8 = 128;
|
|
}
|
|
n7 = n8;
|
|
}
|
|
nArray = this.db[n2];
|
|
n5 = 0;
|
|
n4 = 0;
|
|
block0: while (true) {
|
|
int n9 = n4;
|
|
block1: while (n9 < n7) {
|
|
n6 = 0;
|
|
if (bl) break block8;
|
|
for (n3 = v103858; n3 < n7; ++n3) {
|
|
int n10;
|
|
block14: {
|
|
int n11;
|
|
block15: {
|
|
block12: {
|
|
block13: {
|
|
n10 = this.ab[n2][this.Z[n2][n3 + n4 * n7] & 0xFF];
|
|
n9 = n10 &= 0xF8F8FF;
|
|
if (bl) continue block1;
|
|
if (bl) break block12;
|
|
if (n9 != 0) break block13;
|
|
n10 = 1;
|
|
if (!bl) break block14;
|
|
}
|
|
n11 = n10;
|
|
}
|
|
if (bl) break block15;
|
|
if (n11 != 0xF800FF) break block14;
|
|
n11 = 0;
|
|
}
|
|
n10 = n11;
|
|
this.eb[n2] = true;
|
|
}
|
|
nArray[n5++] = n10;
|
|
if (!bl) continue;
|
|
}
|
|
++n4;
|
|
if (!bl) continue block0;
|
|
}
|
|
break;
|
|
}
|
|
n6 = n4 = 0;
|
|
}
|
|
while (n4 < n5) {
|
|
n3 = nArray[n4];
|
|
nArray[n5 + n4] = n3 - (n3 >>> 3) & 0xF8F8FF;
|
|
nArray[n5 * 2 + n4] = n3 - (n3 >>> 2) & 0xF8F8FF;
|
|
nArray[n5 * 3 + n4] = n3 - (n3 >>> 2) - (n3 >>> 3) & 0xF8F8FF;
|
|
++n4;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public void g(int n2) {
|
|
int n3;
|
|
int n4;
|
|
int[] nArray;
|
|
boolean bl;
|
|
block6: {
|
|
int n5;
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
int[] nArray2 = this.db[n2];
|
|
if (!bl) {
|
|
if (nArray2 == null) {
|
|
return;
|
|
}
|
|
nArray2 = this.db[n2];
|
|
}
|
|
nArray = nArray2;
|
|
int n6 = 0;
|
|
while (n6 < 64) {
|
|
block7: {
|
|
n4 = n6 + 4032;
|
|
n3 = nArray[n4];
|
|
n5 = 0;
|
|
if (bl) break block6;
|
|
for (int i2 = v103958; i2 < 63; ++i2) {
|
|
nArray[n4] = nArray[n4 - 64];
|
|
n4 -= 64;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
this.db[n2][n4] = n3;
|
|
++n6;
|
|
}
|
|
if (!bl) continue;
|
|
}
|
|
n6 = 4096;
|
|
n5 = n4 = 0;
|
|
}
|
|
while (n4 < 4096) {
|
|
n3 = nArray[n4];
|
|
nArray[4096 + n4] = n3 - (n3 >>> 3) & 0xF8F8FF;
|
|
nArray[8192 + n4] = n3 - (n3 >>> 2) & 0xF8F8FF;
|
|
nArray[12288 + n4] = n3 - (n3 >>> 2) - (n3 >>> 3) & 0xF8F8FF;
|
|
++n4;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public int h(int n2) {
|
|
boolean bl = q.d;
|
|
int n3 = n2;
|
|
if (!bl) {
|
|
if (n3 == 12345678) {
|
|
return 0;
|
|
}
|
|
this.e(n2);
|
|
n3 = n2;
|
|
}
|
|
if (!bl) {
|
|
if (n3 >= 0) {
|
|
return this.db[n2][0];
|
|
}
|
|
n3 = n2;
|
|
}
|
|
if (!bl) {
|
|
if (n3 < 0) {
|
|
n2 = -(n2 + 1);
|
|
int n4 = n2 >> 10 & 0x1F;
|
|
int n5 = n2 >> 5 & 0x1F;
|
|
int n6 = n2 & 0x1F;
|
|
return (n4 << 19) + (n5 << 11) + (n6 << 3);
|
|
}
|
|
n3 = 0;
|
|
}
|
|
return n3;
|
|
}
|
|
|
|
public void c(int n2, int n3, int n4) {
|
|
int n5;
|
|
boolean bl;
|
|
block5: {
|
|
int n6;
|
|
block6: {
|
|
bl = q.d;
|
|
n6 = n2;
|
|
if (bl) break block5;
|
|
if (n6 != 0) break block6;
|
|
n6 = n3;
|
|
if (bl) break block5;
|
|
if (n6 != 0) break block6;
|
|
n6 = n4;
|
|
if (bl) break block5;
|
|
if (n6 == 0) {
|
|
n2 = 32;
|
|
}
|
|
}
|
|
n6 = n5 = 0;
|
|
}
|
|
while (n5 < this.J) {
|
|
this.L[n5].c(n2, n3, n4);
|
|
++n5;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public void a(int n2, int n3, int n4, int n5, int n6) {
|
|
int n7;
|
|
boolean bl;
|
|
block5: {
|
|
int n8;
|
|
block6: {
|
|
bl = q.d;
|
|
n8 = n4;
|
|
if (bl) break block5;
|
|
if (n8 != 0) break block6;
|
|
n8 = n5;
|
|
if (bl) break block5;
|
|
if (n8 != 0) break block6;
|
|
n8 = n6;
|
|
if (bl) break block5;
|
|
if (n8 == 0) {
|
|
n4 = 32;
|
|
}
|
|
}
|
|
n8 = n7 = 0;
|
|
}
|
|
while (n7 < this.J) {
|
|
this.L[n7].a(n2, n3, n4, n5, n6);
|
|
++n7;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public static int d(int n2, int n3, int n4) {
|
|
return -1 - n2 / 8 * 1024 - n3 / 8 * 32 - n4 / 8;
|
|
}
|
|
|
|
public int b(int n2, int n3, int n4, int n5, int n6) {
|
|
int n7 = n5;
|
|
int n8 = n3;
|
|
if (!q.d) {
|
|
if (n7 == n8) {
|
|
return n2;
|
|
}
|
|
n7 = n2;
|
|
n8 = (n4 - n2) * (n6 - n3) / (n5 - n3);
|
|
}
|
|
return n7 + n8;
|
|
}
|
|
|
|
public boolean a(int n2, int n3, int n4, int n5, boolean n6) {
|
|
int n7;
|
|
block24: {
|
|
int n8;
|
|
block23: {
|
|
boolean bl;
|
|
block19: {
|
|
block20: {
|
|
int n9;
|
|
block22: {
|
|
int n10;
|
|
block21: {
|
|
block17: {
|
|
block18: {
|
|
block15: {
|
|
block16: {
|
|
bl = q.d;
|
|
n7 = n6;
|
|
if (bl) break block15;
|
|
if (!n7) break block16;
|
|
int n10 = n2;
|
|
n10 = n4;
|
|
if (bl) break block17;
|
|
if (n9 <= n10) break block18;
|
|
}
|
|
n7 = n2;
|
|
}
|
|
n8 = n4;
|
|
if (bl) break block19;
|
|
if (n7 >= n8) break block20;
|
|
}
|
|
int n10 = n2;
|
|
n10 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n9 > n10) {
|
|
return true;
|
|
}
|
|
int n10 = n3;
|
|
n10 = n4;
|
|
}
|
|
if (bl) break block21;
|
|
if (n9 > n10) {
|
|
return true;
|
|
}
|
|
n9 = n3;
|
|
if (bl) break block22;
|
|
n10 = n5;
|
|
}
|
|
if (n9 > n10) {
|
|
return true;
|
|
}
|
|
n9 = n6;
|
|
}
|
|
if (!bl) {
|
|
n9 = n9 == 0;
|
|
}
|
|
return n9;
|
|
}
|
|
int n8 = n2;
|
|
n8 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n7 < n8) {
|
|
return true;
|
|
}
|
|
int n8 = n3;
|
|
n8 = n4;
|
|
}
|
|
if (bl) break block23;
|
|
if (n7 < n8) {
|
|
return true;
|
|
}
|
|
n7 = n3;
|
|
if (bl) break block24;
|
|
n8 = n5;
|
|
}
|
|
if (n7 < n8) {
|
|
return true;
|
|
}
|
|
n7 = n6;
|
|
}
|
|
return n7;
|
|
}
|
|
|
|
public boolean a(int n2, int n3, int n4, boolean n5) {
|
|
int n6;
|
|
block16: {
|
|
int n7;
|
|
block13: {
|
|
boolean bl;
|
|
block14: {
|
|
int n8;
|
|
block15: {
|
|
int n9;
|
|
block11: {
|
|
block12: {
|
|
block9: {
|
|
block10: {
|
|
bl = q.d;
|
|
n6 = n5;
|
|
if (bl) break block9;
|
|
if (!n6) break block10;
|
|
int n9 = n2;
|
|
n9 = n4;
|
|
if (bl) break block11;
|
|
if (n8 <= n9) break block12;
|
|
}
|
|
n6 = n2;
|
|
}
|
|
n7 = n4;
|
|
if (bl) break block13;
|
|
if (n6 >= n7) break block14;
|
|
}
|
|
n8 = n3;
|
|
if (bl) break block15;
|
|
n9 = n4;
|
|
}
|
|
if (n8 > n9) {
|
|
return true;
|
|
}
|
|
n8 = n5;
|
|
}
|
|
if (!bl) {
|
|
n8 = n8 == 0;
|
|
}
|
|
return n8;
|
|
}
|
|
n6 = n3;
|
|
if (bl) break block16;
|
|
n7 = n4;
|
|
}
|
|
if (n6 < n7) {
|
|
return true;
|
|
}
|
|
n6 = n5;
|
|
}
|
|
return n6;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
* Could not resolve type clashes
|
|
*/
|
|
public boolean a(int[] var1_1, int[] var2_2, int[] var3_3, int[] var4_4) {
|
|
block144: {
|
|
block123: {
|
|
block122: {
|
|
block121: {
|
|
block133: {
|
|
block120: {
|
|
block119: {
|
|
block131: {
|
|
block132: {
|
|
block118: {
|
|
block117: {
|
|
block130: {
|
|
block116: {
|
|
var22_5 = q.d;
|
|
var5_6 = false;
|
|
var6_7 = var1_1.length;
|
|
var7_8 = var3_3.length;
|
|
var8_9 = 0;
|
|
var10_11 = var9_10 = var2_2[0];
|
|
var11_12 = 0;
|
|
var13_14 = var12_13 = var4_4[0];
|
|
var14_15 = 0;
|
|
for (var15_16 = 1; var15_16 < var6_7; ++var15_16) {
|
|
block125: {
|
|
block124: {
|
|
v0 = var2_2[var15_16];
|
|
v1 = var9_10;
|
|
if (var22_5) ** GOTO lbl32
|
|
if (var22_5) break block124;
|
|
if (v0 < v1) {
|
|
var9_10 = var2_2[var15_16];
|
|
var11_12 = var15_16;
|
|
if (!var22_5) continue;
|
|
}
|
|
v2 = var2_2[var15_16];
|
|
if (var22_5) break block125;
|
|
v3 = var10_11;
|
|
}
|
|
if (v2 <= v3) continue;
|
|
v2 = var2_2[var15_16];
|
|
}
|
|
var10_11 = v2;
|
|
if (!var22_5) continue;
|
|
}
|
|
var15_16 = 1;
|
|
do {
|
|
block128: {
|
|
block129: {
|
|
block126: {
|
|
block127: {
|
|
v0 = var15_16;
|
|
v1 = var7_8;
|
|
lbl32:
|
|
// 2 sources
|
|
|
|
if (v0 >= v1) break;
|
|
v4 = var4_4[var15_16];
|
|
v5 = var12_13;
|
|
if (var22_5) break block116;
|
|
if (var22_5) break block126;
|
|
if (v4 >= v5) break block127;
|
|
var12_13 = var4_4[var15_16];
|
|
var14_15 = var15_16;
|
|
if (!var22_5) break block128;
|
|
}
|
|
v6 = var4_4[var15_16];
|
|
if (var22_5) break block129;
|
|
v7 = var13_14;
|
|
}
|
|
if (v6 <= v7) break block128;
|
|
v6 = var4_4[var15_16];
|
|
}
|
|
var13_14 = v6;
|
|
}
|
|
++var15_16;
|
|
} while (!var22_5);
|
|
v4 = var12_13;
|
|
v5 = var10_11;
|
|
}
|
|
if (!var22_5) {
|
|
if (v4 >= v5) {
|
|
return false;
|
|
}
|
|
v4 = var9_10;
|
|
v5 = var13_14;
|
|
}
|
|
if (var22_5) break block130;
|
|
if (v4 >= v5) {
|
|
return false;
|
|
}
|
|
v4 = var2_2[var11_12];
|
|
if (var22_5) break block131;
|
|
v5 = var4_4[var14_15];
|
|
}
|
|
if (v4 >= v5) break block132;
|
|
var15_16 = var11_12;
|
|
while (var2_2[var15_16] < var4_4[var14_15]) {
|
|
var15_16 = (var15_16 + 1) % var6_7;
|
|
if (!var22_5) {
|
|
if (!var22_5) continue;
|
|
}
|
|
break block117;
|
|
}
|
|
while (var2_2[var11_12] < var4_4[var14_15]) {
|
|
v8 = (var11_12 - 1 + var6_7) % var6_7;
|
|
if (!var22_5) {
|
|
var11_12 = v8;
|
|
if (!var22_5) continue;
|
|
}
|
|
break block118;
|
|
}
|
|
}
|
|
v8 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var14_15]);
|
|
}
|
|
var18_17 = v8;
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var14_15]);
|
|
var20_19 = var3_3[var14_15];
|
|
v9 = var18_17;
|
|
if (!var22_5) {
|
|
v9 = v9 < var20_19 ? 1 : 0;
|
|
}
|
|
v10 = var19_18;
|
|
if (!var22_5) {
|
|
v10 = v10 < var20_19 ? 1 : 0;
|
|
}
|
|
var17_20 = v9 | v10;
|
|
v11 = this.a(var18_17, var19_18, var20_19, var17_20);
|
|
if (!var22_5) {
|
|
if (v11 != 0) {
|
|
return true;
|
|
}
|
|
v11 = (var14_15 + 1) % var7_8;
|
|
}
|
|
var16_21 = v11;
|
|
var14_15 = (var14_15 - 1 + var7_8) % var7_8;
|
|
v12 = var11_12;
|
|
if (var22_5) ** GOTO lbl148
|
|
if (v12 != var15_16) break block133;
|
|
var8_9 = 1;
|
|
if (!var22_5) break block133;
|
|
}
|
|
v4 = var16_21 = var14_15;
|
|
}
|
|
while (var4_4[var16_21] < var2_2[var11_12]) {
|
|
var16_21 = (var16_21 + 1) % var7_8;
|
|
if (!var22_5) {
|
|
if (!var22_5) continue;
|
|
}
|
|
break block119;
|
|
}
|
|
while (var4_4[var14_15] < var2_2[var11_12]) {
|
|
v13 = (var14_15 - 1 + var7_8) % var7_8;
|
|
if (!var22_5) {
|
|
var14_15 = v13;
|
|
if (!var22_5) continue;
|
|
}
|
|
break block120;
|
|
}
|
|
}
|
|
v13 = var1_1[var11_12];
|
|
}
|
|
var18_17 = v13;
|
|
var19_18 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var11_12]);
|
|
var20_19 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var11_12]);
|
|
v14 = var18_17;
|
|
if (!var22_5) {
|
|
v14 = v14 < var19_18 ? 1 : 0;
|
|
}
|
|
v15 = var18_17;
|
|
if (!var22_5) {
|
|
v15 = v15 < var20_19 ? 1 : 0;
|
|
}
|
|
v16 = var17_20 = v14 | v15;
|
|
if (!var22_5) {
|
|
v16 = v16 == false;
|
|
}
|
|
v12 = (int)this.a(var19_18, var20_19, var18_17, v16);
|
|
if (!var22_5) {
|
|
if (v12 != 0) {
|
|
return true;
|
|
}
|
|
var15_16 = (var11_12 + 1) % var6_7;
|
|
var11_12 = (var11_12 - 1 + var6_7) % var6_7;
|
|
v12 = var14_15;
|
|
}
|
|
if (var22_5) ** GOTO lbl148
|
|
if (v12 == var16_21) {
|
|
var8_9 = 2;
|
|
}
|
|
}
|
|
while (true) {
|
|
block139: {
|
|
block138: {
|
|
block134: {
|
|
block135: {
|
|
block137: {
|
|
block136: {
|
|
v12 = var8_9;
|
|
lbl148:
|
|
// 3 sources
|
|
|
|
if (v12 != 0) break;
|
|
v17 = var2_2[var11_12];
|
|
v18 = var2_2[var15_16];
|
|
if (var22_5) break block134;
|
|
if (v17 >= v18) break block135;
|
|
v19 = var2_2[var11_12];
|
|
v20 = var4_4[var14_15];
|
|
if (var22_5) break block136;
|
|
if (v19 < v20) {
|
|
v21 = var2_2[var11_12];
|
|
if (!var22_5) {
|
|
if (v21 < var4_4[var16_21]) {
|
|
var18_17 = var1_1[var11_12];
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var2_2[var11_12]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var11_12]);
|
|
var21_22 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var11_12]);
|
|
v22 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v22 != 0) {
|
|
return true;
|
|
}
|
|
v22 = var11_12 = (var11_12 - 1 + var6_7) % var6_7;
|
|
}
|
|
if (!var22_5) {
|
|
if (v22 != var15_16) continue;
|
|
v22 = 1;
|
|
}
|
|
var8_9 = v22;
|
|
if (!var22_5) continue;
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var16_21]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var16_21]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var4_4[var16_21]);
|
|
v21 = var3_3[var16_21];
|
|
}
|
|
var21_22 = v21;
|
|
v23 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v23 != 0) {
|
|
return true;
|
|
}
|
|
var16_21 = (var16_21 + 1) % var7_8;
|
|
v23 = var14_15;
|
|
}
|
|
if (!var22_5) {
|
|
if (v23 != var16_21) continue;
|
|
v23 = 2;
|
|
}
|
|
var8_9 = v23;
|
|
if (!var22_5) continue;
|
|
}
|
|
v19 = var4_4[var14_15];
|
|
if (var22_5) break block137;
|
|
v20 = var4_4[var16_21];
|
|
}
|
|
if (v19 < v20) {
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var14_15]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var14_15]);
|
|
var20_19 = var3_3[var14_15];
|
|
var21_22 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var4_4[var14_15]);
|
|
v24 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v24 != 0) {
|
|
return true;
|
|
}
|
|
v24 = var14_15 = (var14_15 - 1 + var7_8) % var7_8;
|
|
}
|
|
if (!var22_5) {
|
|
if (v24 != var16_21) continue;
|
|
v24 = 2;
|
|
}
|
|
var8_9 = v24;
|
|
if (!var22_5) continue;
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var16_21]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var16_21]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var4_4[var16_21]);
|
|
v19 = var3_3[var16_21];
|
|
}
|
|
var21_22 = v19;
|
|
v25 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v25 != 0) {
|
|
return true;
|
|
}
|
|
var16_21 = (var16_21 + 1) % var7_8;
|
|
v25 = var14_15;
|
|
}
|
|
if (!var22_5) {
|
|
if (v25 != var16_21) continue;
|
|
v25 = 2;
|
|
}
|
|
var8_9 = v25;
|
|
if (!var22_5) continue;
|
|
}
|
|
v17 = var2_2[var15_16];
|
|
v18 = var4_4[var14_15];
|
|
}
|
|
if (var22_5) break block138;
|
|
if (v17 < v18) {
|
|
v26 = var2_2[var15_16];
|
|
if (!var22_5) {
|
|
if (v26 < var4_4[var16_21]) {
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var2_2[var15_16]);
|
|
var19_18 = var1_1[var15_16];
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var15_16]);
|
|
var21_22 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var15_16]);
|
|
v27 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v27 != 0) {
|
|
return true;
|
|
}
|
|
var15_16 = (var15_16 + 1) % var6_7;
|
|
v27 = var11_12;
|
|
}
|
|
if (!var22_5) {
|
|
if (v27 != var15_16) continue;
|
|
v27 = 1;
|
|
}
|
|
var8_9 = v27;
|
|
if (!var22_5) continue;
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var16_21]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var16_21]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var4_4[var16_21]);
|
|
v26 = var3_3[var16_21];
|
|
}
|
|
var21_22 = v26;
|
|
v28 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v28 != 0) {
|
|
return true;
|
|
}
|
|
var16_21 = (var16_21 + 1) % var7_8;
|
|
v28 = var14_15;
|
|
}
|
|
if (!var22_5) {
|
|
if (v28 != var16_21) continue;
|
|
v28 = 2;
|
|
}
|
|
var8_9 = v28;
|
|
if (!var22_5) continue;
|
|
}
|
|
v17 = var4_4[var14_15];
|
|
if (var22_5) break block139;
|
|
v18 = var4_4[var16_21];
|
|
}
|
|
if (v17 < v18) {
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var14_15]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var14_15]);
|
|
var20_19 = var3_3[var14_15];
|
|
var21_22 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var4_4[var14_15]);
|
|
v29 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v29 != 0) {
|
|
return true;
|
|
}
|
|
v29 = var14_15 = (var14_15 - 1 + var7_8) % var7_8;
|
|
}
|
|
if (!var22_5) {
|
|
if (v29 != var16_21) continue;
|
|
v29 = 2;
|
|
}
|
|
var8_9 = v29;
|
|
if (!var22_5) continue;
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var16_21]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var16_21]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var4_4[var16_21]);
|
|
v17 = var3_3[var16_21];
|
|
}
|
|
var21_22 = v17;
|
|
v30 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v30 != 0) {
|
|
return true;
|
|
}
|
|
var16_21 = (var16_21 + 1) % var7_8;
|
|
v30 = var14_15;
|
|
}
|
|
if (v30 != var16_21) continue;
|
|
var8_9 = 2;
|
|
if (!var22_5) {
|
|
if (var22_5) break;
|
|
continue;
|
|
}
|
|
break block121;
|
|
break;
|
|
}
|
|
while (var8_9 == 1) {
|
|
block141: {
|
|
block140: {
|
|
v31 = var2_2[var11_12];
|
|
v32 = var4_4[var14_15];
|
|
if (var22_5) break block140;
|
|
if (v31 < v32) {
|
|
v33 = var2_2[var11_12];
|
|
if (!var22_5) {
|
|
if (v33 < var4_4[var16_21]) {
|
|
var18_17 = var1_1[var11_12];
|
|
var19_18 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var11_12]);
|
|
var20_19 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var11_12]);
|
|
v34 = var17_20;
|
|
if (!var22_5) {
|
|
v34 = v34 == false;
|
|
}
|
|
return this.a(var19_18, var20_19, var18_17, v34);
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var16_21]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var16_21]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var4_4[var16_21]);
|
|
v33 = var3_3[var16_21];
|
|
}
|
|
var21_22 = v33;
|
|
v35 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v35 != 0) {
|
|
return true;
|
|
}
|
|
var16_21 = (var16_21 + 1) % var7_8;
|
|
v35 = var14_15;
|
|
}
|
|
if (!var22_5) {
|
|
if (v35 != var16_21) continue;
|
|
v35 = 0;
|
|
}
|
|
var8_9 = v35;
|
|
if (!var22_5) continue;
|
|
}
|
|
v31 = var4_4[var14_15];
|
|
if (var22_5) break block141;
|
|
v32 = var4_4[var16_21];
|
|
}
|
|
if (v31 < v32) {
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var14_15]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var14_15]);
|
|
var20_19 = var3_3[var14_15];
|
|
var21_22 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var4_4[var14_15]);
|
|
v36 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v36 != 0) {
|
|
return true;
|
|
}
|
|
v36 = var14_15 = (var14_15 - 1 + var7_8) % var7_8;
|
|
}
|
|
if (!var22_5) {
|
|
if (v36 != var16_21) continue;
|
|
v36 = 0;
|
|
}
|
|
var8_9 = v36;
|
|
if (!var22_5) continue;
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var16_21]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var16_21]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var4_4[var16_21]);
|
|
v31 = var3_3[var16_21];
|
|
}
|
|
var21_22 = v31;
|
|
v37 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v37 != 0) {
|
|
return true;
|
|
}
|
|
var16_21 = (var16_21 + 1) % var7_8;
|
|
v37 = var14_15;
|
|
}
|
|
if (v37 != var16_21) continue;
|
|
var8_9 = 0;
|
|
if (!var22_5) {
|
|
if (!var22_5) continue;
|
|
}
|
|
break block122;
|
|
}
|
|
}
|
|
while (var8_9 == 2) {
|
|
block143: {
|
|
block142: {
|
|
v38 = var4_4[var14_15];
|
|
v39 = var2_2[var11_12];
|
|
if (var22_5) break block142;
|
|
if (v38 < v39) {
|
|
v40 = var4_4[var14_15];
|
|
if (!var22_5) {
|
|
if (v40 < var2_2[var15_16]) {
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var14_15]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var14_15]);
|
|
var20_19 = var3_3[var14_15];
|
|
return this.a(var18_17, var19_18, var20_19, var17_20);
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var2_2[var15_16]);
|
|
var19_18 = var1_1[var15_16];
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var15_16]);
|
|
v40 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var15_16]);
|
|
}
|
|
var21_22 = v40;
|
|
v41 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v41 != 0) {
|
|
return true;
|
|
}
|
|
var15_16 = (var15_16 + 1) % var6_7;
|
|
v41 = var11_12;
|
|
}
|
|
if (!var22_5) {
|
|
if (v41 != var15_16) continue;
|
|
v41 = 0;
|
|
}
|
|
var8_9 = v41;
|
|
if (!var22_5) continue;
|
|
}
|
|
v38 = var2_2[var11_12];
|
|
if (var22_5) break block143;
|
|
v39 = var2_2[var15_16];
|
|
}
|
|
if (v38 < v39) {
|
|
var18_17 = var1_1[var11_12];
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var2_2[var11_12]);
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var11_12]);
|
|
var21_22 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var11_12]);
|
|
v42 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v42 != 0) {
|
|
return true;
|
|
}
|
|
v42 = var11_12 = (var11_12 - 1 + var6_7) % var6_7;
|
|
}
|
|
if (!var22_5) {
|
|
if (v42 != var15_16) continue;
|
|
v42 = 0;
|
|
}
|
|
var8_9 = v42;
|
|
if (!var22_5) continue;
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var2_2[var15_16]);
|
|
var19_18 = var1_1[var15_16];
|
|
var20_19 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var15_16]);
|
|
v38 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var15_16]);
|
|
}
|
|
var21_22 = v38;
|
|
v43 = this.a(var18_17, var19_18, var20_19, var21_22, var17_20);
|
|
if (!var22_5) {
|
|
if (v43 != 0) {
|
|
return true;
|
|
}
|
|
var15_16 = (var15_16 + 1) % var6_7;
|
|
v43 = var11_12;
|
|
}
|
|
if (v43 != var15_16) continue;
|
|
var8_9 = 0;
|
|
if (!var22_5) {
|
|
if (!var22_5) continue;
|
|
}
|
|
break block123;
|
|
}
|
|
}
|
|
v44 = var2_2[var11_12];
|
|
if (var22_5) break block144;
|
|
if (v44 < var4_4[var14_15]) {
|
|
var18_17 = var1_1[var11_12];
|
|
var19_18 = this.b(var3_3[(var14_15 + 1) % var7_8], var4_4[(var14_15 + 1) % var7_8], var3_3[var14_15], var4_4[var14_15], var2_2[var11_12]);
|
|
var20_19 = this.b(var3_3[(var16_21 - 1 + var7_8) % var7_8], var4_4[(var16_21 - 1 + var7_8) % var7_8], var3_3[var16_21], var4_4[var16_21], var2_2[var11_12]);
|
|
v45 = var17_20;
|
|
if (!var22_5) {
|
|
v45 = v45 == false;
|
|
}
|
|
return this.a(var19_18, var20_19, var18_17, v45);
|
|
}
|
|
var18_17 = this.b(var1_1[(var11_12 + 1) % var6_7], var2_2[(var11_12 + 1) % var6_7], var1_1[var11_12], var2_2[var11_12], var4_4[var14_15]);
|
|
var19_18 = this.b(var1_1[(var15_16 - 1 + var6_7) % var6_7], var2_2[(var15_16 - 1 + var6_7) % var6_7], var1_1[var15_16], var2_2[var15_16], var4_4[var14_15]);
|
|
var20_19 = var3_3[var14_15];
|
|
}
|
|
v44 = (int)this.a(var18_17, var19_18, var20_19, var17_20);
|
|
}
|
|
return (boolean)v44;
|
|
}
|
|
|
|
/*
|
|
* 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 = "-\u0002\u0002*M\u0014\u0004P0V\u0013\u0006\u0014dP\u0015C\u0011 @Z\r\u0005(HZ\f\u0012.A\u0019\u0017Q".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 = 122;
|
|
break;
|
|
}
|
|
case 1: {
|
|
n7 = 99;
|
|
break;
|
|
}
|
|
case 2: {
|
|
n7 = 112;
|
|
break;
|
|
}
|
|
case 3: {
|
|
n7 = 68;
|
|
break;
|
|
}
|
|
default: {
|
|
n7 = 36;
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
Eb = new String(cArray).intern();
|
|
k = new int[2048];
|
|
l = new int[512];
|
|
jb = new int[256];
|
|
}
|
|
}
|
|
|