wes
c30e839b64
Full source recovered from SBoT.jar (July 2004) plus the three bundled example scripts (BoneBury, GuildFish, GuildFisher). Class names are the original RSC-era single-letter obfuscation (a.java-z.java); mudclient.java and Script.java kept their real names since those weren't obfuscated.
2043 lines
72 KiB
Java
2043 lines
72 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
import java.io.DataInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
|
|
public class l {
|
|
public int a;
|
|
public int[] b;
|
|
public int[] c;
|
|
public int[] d;
|
|
public int[] e;
|
|
public int[] f;
|
|
public int[] g;
|
|
public byte[] h;
|
|
public int i;
|
|
public int[] j;
|
|
public int[][] k;
|
|
public int[] l;
|
|
public int[] m;
|
|
public int[] n;
|
|
public int[] o;
|
|
public int[] p;
|
|
public int[] q;
|
|
public int[] r;
|
|
public int[] s;
|
|
public int t;
|
|
public int u;
|
|
public boolean v;
|
|
public int w;
|
|
public int x;
|
|
public int y;
|
|
public int z;
|
|
public int A;
|
|
public int B;
|
|
public boolean C;
|
|
public boolean D;
|
|
public boolean E;
|
|
public int F;
|
|
public int[] G;
|
|
public byte[] H;
|
|
private boolean I;
|
|
public boolean J;
|
|
public boolean K;
|
|
public boolean L;
|
|
public boolean M;
|
|
private static int[] N;
|
|
private static int[] O;
|
|
private static byte[] P;
|
|
private static int[] Q;
|
|
private int R;
|
|
private int S;
|
|
public int T;
|
|
public int[] U;
|
|
public int[] V;
|
|
public int[] W;
|
|
public int[] X;
|
|
public int[] Y;
|
|
public int[] Z;
|
|
private int ab;
|
|
private int[][] bb;
|
|
private int[] cb;
|
|
private int[] db;
|
|
private int[] eb;
|
|
private int[] fb;
|
|
private int[] gb;
|
|
private int[] hb;
|
|
private int ib;
|
|
private int jb;
|
|
private int kb;
|
|
private int lb;
|
|
private int mb;
|
|
private int nb;
|
|
private int ob;
|
|
private int pb;
|
|
private int qb;
|
|
private int rb;
|
|
private int sb;
|
|
private int tb;
|
|
private int ub;
|
|
private int vb;
|
|
private int wb;
|
|
private int xb;
|
|
private int yb;
|
|
private int zb;
|
|
private int Ab;
|
|
private int Bb;
|
|
private int Cb;
|
|
protected int Db;
|
|
protected int Eb;
|
|
private int Fb;
|
|
private int Gb;
|
|
|
|
public l(int n2, int n3) {
|
|
this.u = 1;
|
|
this.v = true;
|
|
this.C = true;
|
|
this.D = false;
|
|
this.E = false;
|
|
this.F = -1;
|
|
this.I = false;
|
|
this.J = false;
|
|
this.K = false;
|
|
this.L = false;
|
|
this.M = false;
|
|
this.R = 4;
|
|
this.S = 12345678;
|
|
this.yb = 12345678;
|
|
this.zb = 180;
|
|
this.Ab = 155;
|
|
this.Bb = 95;
|
|
this.Cb = 256;
|
|
this.Db = 512;
|
|
this.Eb = 32;
|
|
this.a(n2, n3);
|
|
this.bb = new int[n3][1];
|
|
for (int i2 = 0; i2 < n3; ++i2) {
|
|
this.bb[i2][0] = i2;
|
|
if (!q.d) continue;
|
|
}
|
|
}
|
|
|
|
public l(int n2, int n3, boolean bl, boolean bl2, boolean bl3, boolean bl4, boolean bl5) {
|
|
this.u = 1;
|
|
this.v = true;
|
|
this.C = true;
|
|
this.D = false;
|
|
this.E = false;
|
|
this.F = -1;
|
|
this.I = false;
|
|
this.J = false;
|
|
this.K = false;
|
|
this.L = false;
|
|
this.M = false;
|
|
this.R = 4;
|
|
this.S = 12345678;
|
|
this.yb = 12345678;
|
|
this.zb = 180;
|
|
this.Ab = 155;
|
|
this.Bb = 95;
|
|
this.Cb = 256;
|
|
this.Db = 512;
|
|
this.Eb = 32;
|
|
this.I = bl;
|
|
this.J = bl2;
|
|
this.K = bl3;
|
|
this.L = bl4;
|
|
this.M = bl5;
|
|
this.a(n2, n3);
|
|
}
|
|
|
|
private void a(int n2, int n3) {
|
|
block21: {
|
|
l l2;
|
|
boolean bl;
|
|
block19: {
|
|
boolean bl2;
|
|
block20: {
|
|
block17: {
|
|
l l3;
|
|
block18: {
|
|
block16: {
|
|
block14: {
|
|
l l4;
|
|
block15: {
|
|
boolean bl3;
|
|
block13: {
|
|
bl2 = q.d;
|
|
this.U = new int[n2];
|
|
this.V = new int[n2];
|
|
this.W = new int[n2];
|
|
this.g = new int[n2];
|
|
this.h = new byte[n2];
|
|
this.j = new int[n3];
|
|
this.k = new int[n3][];
|
|
this.l = new int[n3];
|
|
this.m = new int[n3];
|
|
this.p = new int[n3];
|
|
this.o = new int[n3];
|
|
this.n = new int[n3];
|
|
bl3 = this.M;
|
|
if (!bl2) {
|
|
if (!bl3) {
|
|
this.b = new int[n2];
|
|
this.c = new int[n2];
|
|
this.d = new int[n2];
|
|
this.e = new int[n2];
|
|
this.f = new int[n2];
|
|
}
|
|
bl3 = this.L;
|
|
}
|
|
if (bl2) break block13;
|
|
if (!bl3) {
|
|
this.H = new byte[n3];
|
|
this.G = new int[n3];
|
|
}
|
|
l4 = this;
|
|
if (bl2) break block14;
|
|
bl3 = l4.I;
|
|
}
|
|
if (!bl3) break block15;
|
|
this.X = this.U;
|
|
this.Y = this.V;
|
|
this.Z = this.W;
|
|
if (!bl2) break block16;
|
|
}
|
|
this.X = new int[n2];
|
|
this.Y = new int[n2];
|
|
l4 = this;
|
|
}
|
|
l4.Z = new int[n2];
|
|
}
|
|
l3 = this;
|
|
if (bl2) break block17;
|
|
if (!l3.K) break block18;
|
|
bl = this.J;
|
|
if (bl2) break block19;
|
|
if (bl) break block20;
|
|
}
|
|
this.q = new int[n3];
|
|
this.r = new int[n3];
|
|
l3 = this;
|
|
}
|
|
l3.s = new int[n3];
|
|
}
|
|
l2 = this;
|
|
if (bl2) break block21;
|
|
bl = l2.J;
|
|
}
|
|
if (!bl) {
|
|
this.cb = new int[n3];
|
|
this.db = new int[n3];
|
|
this.eb = new int[n3];
|
|
this.fb = new int[n3];
|
|
this.gb = new int[n3];
|
|
this.hb = new int[n3];
|
|
}
|
|
this.i = 0;
|
|
this.a = 0;
|
|
this.T = n2;
|
|
this.ab = n3;
|
|
this.kb = 0;
|
|
this.jb = 0;
|
|
this.ib = 0;
|
|
this.nb = 0;
|
|
this.mb = 0;
|
|
this.lb = 0;
|
|
this.qb = 256;
|
|
this.pb = 256;
|
|
this.ob = 256;
|
|
this.wb = 256;
|
|
this.vb = 256;
|
|
this.ub = 256;
|
|
this.tb = 256;
|
|
this.sb = 256;
|
|
this.rb = 256;
|
|
l2 = this;
|
|
}
|
|
l2.xb = 0;
|
|
}
|
|
|
|
public void a() {
|
|
this.b = new int[this.a];
|
|
this.c = new int[this.a];
|
|
this.d = new int[this.a];
|
|
this.e = new int[this.a];
|
|
this.f = new int[this.a];
|
|
}
|
|
|
|
public void b() {
|
|
this.i = 0;
|
|
this.a = 0;
|
|
}
|
|
|
|
public void b(int n2, int n3) {
|
|
block6: {
|
|
block5: {
|
|
l l2;
|
|
int n4;
|
|
block4: {
|
|
boolean bl = q.d;
|
|
this.i -= n2;
|
|
n4 = this.i;
|
|
if (bl) break block4;
|
|
if (n4 < 0) {
|
|
this.i = 0;
|
|
}
|
|
this.a -= n3;
|
|
l2 = this;
|
|
if (bl) break block5;
|
|
n4 = l2.a;
|
|
}
|
|
if (n4 >= 0) break block6;
|
|
l2 = this;
|
|
}
|
|
l2.a = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public l(byte[] var1_1, int var2_2, boolean var3_3) {
|
|
block30: {
|
|
block29: {
|
|
block28: {
|
|
block27: {
|
|
block26: {
|
|
block25: {
|
|
var9_4 = q.d;
|
|
super();
|
|
var4_5 = false;
|
|
this.u = 1;
|
|
this.v = true;
|
|
this.C = true;
|
|
this.D = false;
|
|
this.E = false;
|
|
this.F = -1;
|
|
this.I = false;
|
|
this.J = false;
|
|
this.K = false;
|
|
this.L = false;
|
|
this.M = false;
|
|
this.R = 4;
|
|
this.S = 12345678;
|
|
this.yb = 12345678;
|
|
this.zb = 180;
|
|
this.Ab = 155;
|
|
this.Bb = 95;
|
|
this.Cb = 256;
|
|
this.Db = 512;
|
|
this.Eb = 32;
|
|
var5_6 = q.a(var1_1, var2_2);
|
|
var6_7 = q.a(var1_1, var2_2 += 2);
|
|
var2_2 += 2;
|
|
this.a(var5_6, var6_7);
|
|
this.bb = new int[var6_7][1];
|
|
for (var7_8 = 0; var7_8 < var5_6; ++var7_8) {
|
|
this.U[var7_8] = q.d(var1_1, var2_2);
|
|
var2_2 += 2;
|
|
if (!var9_4) {
|
|
if (!var9_4) continue;
|
|
}
|
|
break block25;
|
|
}
|
|
var7_8 = 0;
|
|
}
|
|
while (var7_8 < var5_6) {
|
|
this.V[var7_8] = q.d(var1_1, var2_2);
|
|
var2_2 += 2;
|
|
++var7_8;
|
|
if (!var9_4) {
|
|
if (!var9_4) continue;
|
|
}
|
|
break block26;
|
|
}
|
|
var7_8 = 0;
|
|
}
|
|
while (var7_8 < var5_6) {
|
|
this.W[var7_8] = q.d(var1_1, var2_2);
|
|
var2_2 += 2;
|
|
++var7_8;
|
|
if (!var9_4) {
|
|
if (!var9_4) continue;
|
|
}
|
|
break block27;
|
|
}
|
|
this.a = var5_6;
|
|
}
|
|
for (var7_8 = 0; var7_8 < var6_7; ++var7_8) {
|
|
this.j[var7_8] = var1_1[var2_2++] & 255;
|
|
if (!var9_4) {
|
|
if (!var9_4) continue;
|
|
}
|
|
break block28;
|
|
}
|
|
var7_8 = 0;
|
|
}
|
|
while (var7_8 < var6_7) {
|
|
block31: {
|
|
this.l[var7_8] = q.d(var1_1, var2_2);
|
|
var2_2 += 2;
|
|
if (var9_4) break block31;
|
|
v0 = this.l[var7_8];
|
|
v1 = 32767;
|
|
if (var9_4) ** GOTO lbl79
|
|
if (v0 == v1) {
|
|
this.l[var7_8] = this.S;
|
|
}
|
|
++var7_8;
|
|
}
|
|
if (!var9_4) continue;
|
|
}
|
|
var7_8 = 0;
|
|
do {
|
|
v0 = var7_8;
|
|
v1 = var6_7;
|
|
lbl79:
|
|
// 2 sources
|
|
|
|
if (v0 >= v1) break;
|
|
this.m[var7_8] = q.d(var1_1, var2_2);
|
|
var2_2 += 2;
|
|
if (var9_4) continue;
|
|
v2 = this.m[var7_8];
|
|
v3 = 32767;
|
|
if (var9_4) ** GOTO lbl94
|
|
if (v2 == v3) {
|
|
this.m[var7_8] = this.S;
|
|
}
|
|
++var7_8;
|
|
} while (!var9_4);
|
|
var7_8 = 0;
|
|
do {
|
|
block34: {
|
|
block33: {
|
|
block32: {
|
|
v2 = var7_8;
|
|
v3 = var6_7;
|
|
lbl94:
|
|
// 2 sources
|
|
|
|
if (v2 >= v3) break;
|
|
var8_9 = var1_1[var2_2++] & 255;
|
|
if (var9_4) break block32;
|
|
v4 = var8_9;
|
|
if (var9_4) break block29;
|
|
if (v4 != 0) break block33;
|
|
this.p[var7_8] = 0;
|
|
}
|
|
if (!var9_4) break block34;
|
|
}
|
|
this.p[var7_8] = this.S;
|
|
}
|
|
++var7_8;
|
|
} while (!var9_4);
|
|
v4 = 0;
|
|
}
|
|
var7_8 = v4;
|
|
block7: while (true) {
|
|
v5 = var7_8;
|
|
v6 = var6_7;
|
|
block8: while (v5 < v6) {
|
|
this.k[var7_8] = new int[this.j[var7_8]];
|
|
if (var9_4) break block30;
|
|
for (var8_9 = 0; var8_9 < this.j[var7_8]; ++var8_9) {
|
|
v5 = var5_6;
|
|
v6 = 256;
|
|
if (var9_4) continue block8;
|
|
if (v5 < v6) {
|
|
this.k[var7_8][var8_9] = var1_1[var2_2++] & 255;
|
|
if (!var9_4) continue;
|
|
}
|
|
this.k[var7_8][var8_9] = q.a(var1_1, var2_2);
|
|
var2_2 += 2;
|
|
if (!var9_4) continue;
|
|
}
|
|
++var7_8;
|
|
if (!var9_4) continue block7;
|
|
}
|
|
break;
|
|
}
|
|
this.i = var6_7;
|
|
this.u = 1;
|
|
}
|
|
}
|
|
|
|
public l(String string) {
|
|
block19: {
|
|
int n2;
|
|
int n3;
|
|
int n4;
|
|
int n5;
|
|
int n6;
|
|
byte[] byArray;
|
|
boolean bl;
|
|
block18: {
|
|
int n7;
|
|
block17: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
this.u = 1;
|
|
this.v = true;
|
|
this.C = true;
|
|
this.D = false;
|
|
this.E = false;
|
|
this.F = -1;
|
|
this.I = false;
|
|
this.J = false;
|
|
this.K = false;
|
|
this.L = false;
|
|
this.M = false;
|
|
this.R = 4;
|
|
this.S = 12345678;
|
|
this.yb = 12345678;
|
|
this.zb = 180;
|
|
this.Ab = 155;
|
|
this.Bb = 95;
|
|
this.Cb = 256;
|
|
this.Db = 512;
|
|
this.Eb = 32;
|
|
boolean bl3 = false;
|
|
boolean bl4 = false;
|
|
byArray = null;
|
|
try {
|
|
DataInputStream dataInputStream;
|
|
block16: {
|
|
InputStream inputStream = q.a(string);
|
|
dataInputStream = new DataInputStream(inputStream);
|
|
byArray = new byte[3];
|
|
this.Fb = 0;
|
|
this.Gb = 0;
|
|
for (n7 = 0; n7 < 3; n7 += dataInputStream.read(byArray, n7, 3 - n7)) {
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block16;
|
|
}
|
|
n7 = this.a(byArray);
|
|
byArray = new byte[n7];
|
|
this.Fb = 0;
|
|
this.Gb = 0;
|
|
}
|
|
for (n6 = 0; n6 < n7; n6 += dataInputStream.read(byArray, n6, n7 - n6)) {
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block17;
|
|
}
|
|
dataInputStream.close();
|
|
}
|
|
catch (IOException iOException) {
|
|
this.a = 0;
|
|
this.i = 0;
|
|
return;
|
|
}
|
|
}
|
|
int n8 = this.a(byArray);
|
|
n5 = this.a(byArray);
|
|
n7 = 0;
|
|
this.a(n8, n5);
|
|
this.bb = new int[n5][];
|
|
for (n6 = 0; n6 < n8; ++n6) {
|
|
n4 = this.a(byArray);
|
|
n3 = this.a(byArray);
|
|
n2 = this.a(byArray);
|
|
this.a(n4, n3, n2);
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block18;
|
|
}
|
|
n6 = 0;
|
|
}
|
|
block5: while (n6 < n5) {
|
|
block23: {
|
|
block21: {
|
|
l l2;
|
|
block22: {
|
|
int n9;
|
|
block20: {
|
|
int n10;
|
|
n4 = this.a(byArray);
|
|
n3 = this.a(byArray);
|
|
n2 = this.a(byArray);
|
|
int n11 = this.a(byArray);
|
|
this.Db = this.a(byArray);
|
|
this.Eb = this.a(byArray);
|
|
n9 = this.a(byArray);
|
|
int[] nArray = new int[n4];
|
|
if (bl) break block19;
|
|
for (int i2 = 0; i2 < n4; ++i2) {
|
|
nArray[i2] = this.a(byArray);
|
|
if (bl) continue block5;
|
|
if (!bl) continue;
|
|
}
|
|
int[] nArray2 = new int[n11];
|
|
for (n10 = 0; n10 < n11; ++n10) {
|
|
nArray2[n10] = this.a(byArray);
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block20;
|
|
}
|
|
n10 = this.a(n4, nArray, n3, n2);
|
|
l2 = this;
|
|
if (bl) break block21;
|
|
l2.bb[n6] = nArray2;
|
|
}
|
|
if (n9 != 0) break block22;
|
|
this.p[n10] = 0;
|
|
if (!bl) break block23;
|
|
}
|
|
l2 = this;
|
|
}
|
|
l2.p[n10] = this.S;
|
|
}
|
|
++n6;
|
|
if (!bl) continue;
|
|
}
|
|
this.u = 1;
|
|
}
|
|
}
|
|
|
|
public l(l[] lArray, int n2, boolean bl, boolean bl2, boolean bl3, boolean bl4) {
|
|
this.u = 1;
|
|
this.v = true;
|
|
this.C = true;
|
|
this.D = false;
|
|
this.E = false;
|
|
this.F = -1;
|
|
this.I = false;
|
|
this.J = false;
|
|
this.K = false;
|
|
this.L = false;
|
|
this.M = false;
|
|
this.R = 4;
|
|
this.S = 12345678;
|
|
this.yb = 12345678;
|
|
this.zb = 180;
|
|
this.Ab = 155;
|
|
this.Bb = 95;
|
|
this.Cb = 256;
|
|
this.Db = 512;
|
|
this.Eb = 32;
|
|
this.I = bl;
|
|
this.J = bl2;
|
|
this.K = bl3;
|
|
this.L = bl4;
|
|
this.a(lArray, n2, false);
|
|
}
|
|
|
|
public l(l[] lArray, int n2) {
|
|
this.u = 1;
|
|
this.v = true;
|
|
this.C = true;
|
|
this.D = false;
|
|
this.E = false;
|
|
this.F = -1;
|
|
this.I = false;
|
|
this.J = false;
|
|
this.K = false;
|
|
this.L = false;
|
|
this.M = false;
|
|
this.R = 4;
|
|
this.S = 12345678;
|
|
this.yb = 12345678;
|
|
this.zb = 180;
|
|
this.Ab = 155;
|
|
this.Bb = 95;
|
|
this.Cb = 256;
|
|
this.Db = 512;
|
|
this.Eb = 32;
|
|
this.a(lArray, n2, true);
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public void a(l[] var1_1, int var2_2, boolean var3_3) {
|
|
block14: {
|
|
block13: {
|
|
var14_4 = q.d;
|
|
var4_5 = false;
|
|
var5_6 = 0;
|
|
var6_7 = 0;
|
|
for (var7_8 = 0; var7_8 < var2_2; ++var7_8) {
|
|
var5_6 += var1_1[var7_8].i;
|
|
var6_7 += var1_1[var7_8].a;
|
|
if (!var14_4) {
|
|
if (!var14_4) continue;
|
|
}
|
|
break block13;
|
|
}
|
|
this.a(var6_7, var5_6);
|
|
}
|
|
v0 = var3_3;
|
|
if (!var14_4) {
|
|
if (v0) {
|
|
this.bb = new int[var5_6][];
|
|
}
|
|
v0 = false;
|
|
}
|
|
var7_8 = (int)v0;
|
|
block1: while (true) {
|
|
v1 = var7_8;
|
|
block2: while (v1 < var2_2) {
|
|
var8_9 = var1_1[var7_8];
|
|
var8_9.h();
|
|
this.Eb = var8_9.Eb;
|
|
this.Db = var8_9.Db;
|
|
this.zb = var8_9.zb;
|
|
this.Ab = var8_9.Ab;
|
|
this.Bb = var8_9.Bb;
|
|
this.Cb = var8_9.Cb;
|
|
if (var14_4) break block14;
|
|
var9_10 = 0;
|
|
while (var9_10 < var8_9.i) {
|
|
block16: {
|
|
block17: {
|
|
block15: {
|
|
var10_11 = new int[var8_9.j[var9_10]];
|
|
var11_12 = var8_9.k[var9_10];
|
|
v1 = 0;
|
|
if (var14_4) continue block2;
|
|
for (var12_13 = v175808; var12_13 < var8_9.j[var9_10]; ++var12_13) {
|
|
var10_11[var12_13] = this.a(var8_9.U[var11_12[var12_13]], var8_9.V[var11_12[var12_13]], var8_9.W[var11_12[var12_13]]);
|
|
if (!var14_4) {
|
|
if (!var14_4) continue;
|
|
}
|
|
break block15;
|
|
}
|
|
var12_13 = this.a(var8_9.j[var9_10], var10_11, var8_9.l[var9_10], var8_9.m[var9_10]);
|
|
this.p[var12_13] = var8_9.p[var9_10];
|
|
this.o[var12_13] = var8_9.o[var9_10];
|
|
this.n[var12_13] = var8_9.n[var9_10];
|
|
}
|
|
if (var14_4) break block16;
|
|
if (!var3_3) break block17;
|
|
v2 = var2_2;
|
|
if (var14_4) ** GOTO lbl61
|
|
if (v2 <= 1) ** GOTO lbl59
|
|
this.bb[var12_13] = new int[var8_9.bb[var9_10].length + 1];
|
|
this.bb[var12_13][0] = var7_8;
|
|
for (var13_14 = 0; var13_14 < var8_9.bb[var9_10].length; ++var13_14) {
|
|
this.bb[var12_13][var13_14 + 1] = var8_9.bb[var9_10][var13_14];
|
|
if (!var14_4) {
|
|
if (!var14_4) continue;
|
|
}
|
|
break block16;
|
|
lbl59:
|
|
// 2 sources
|
|
|
|
this.bb[var12_13] = new int[var8_9.bb[var9_10].length];
|
|
v2 = var13_14 = 0;
|
|
while (var13_14 < var8_9.bb[var9_10].length) {
|
|
this.bb[var12_13][var13_14] = var8_9.bb[var9_10][var13_14];
|
|
++var13_14;
|
|
if (!var14_4) {
|
|
if (!var14_4) continue;
|
|
}
|
|
break block16;
|
|
}
|
|
break block5;
|
|
}
|
|
}
|
|
++var9_10;
|
|
}
|
|
if (!var14_4) continue;
|
|
}
|
|
++var7_8;
|
|
if (!var14_4) continue block1;
|
|
}
|
|
break;
|
|
}
|
|
this.u = 1;
|
|
}
|
|
}
|
|
|
|
public int a(int n2, int n3, int n4) {
|
|
int n5;
|
|
block12: {
|
|
int n6;
|
|
block9: {
|
|
boolean bl = q.d;
|
|
for (int i2 = 0; i2 < this.a; ++i2) {
|
|
int n7;
|
|
block11: {
|
|
int n8;
|
|
block10: {
|
|
n5 = this.U[i2];
|
|
n6 = n2;
|
|
if (bl) break block9;
|
|
if (!bl) {
|
|
if (n5 != n6) continue;
|
|
n7 = this.V[i2];
|
|
n8 = n3;
|
|
}
|
|
if (bl) break block10;
|
|
if (n7 != n8) continue;
|
|
n7 = this.W[i2];
|
|
if (bl) break block11;
|
|
n8 = n4;
|
|
}
|
|
if (n7 != n8) continue;
|
|
n7 = i2;
|
|
}
|
|
return n7;
|
|
}
|
|
n5 = this.a;
|
|
if (bl) break block12;
|
|
n6 = this.T;
|
|
}
|
|
if (n5 >= n6) {
|
|
return -1;
|
|
}
|
|
this.U[this.a] = n2;
|
|
this.V[this.a] = n3;
|
|
this.W[this.a] = n4;
|
|
int n9 = this.a;
|
|
n5 = n9;
|
|
this.a = n9 + 1;
|
|
}
|
|
return n5;
|
|
}
|
|
|
|
public int b(int n2, int n3, int n4) {
|
|
int n5 = this.a;
|
|
if (!q.d) {
|
|
if (n5 >= this.T) {
|
|
return -1;
|
|
}
|
|
this.U[this.a] = n2;
|
|
this.V[this.a] = n3;
|
|
this.W[this.a] = n4;
|
|
int n6 = this.a;
|
|
n5 = n6;
|
|
this.a = n6 + 1;
|
|
}
|
|
return n5;
|
|
}
|
|
|
|
public int a(int n2, int[] nArray, int n3, int n4) {
|
|
int n5 = this.i;
|
|
if (!q.d) {
|
|
if (n5 >= this.ab) {
|
|
return -1;
|
|
}
|
|
this.j[this.i] = n2;
|
|
this.k[this.i] = nArray;
|
|
this.l[this.i] = n3;
|
|
this.m[this.i] = n4;
|
|
this.u = 1;
|
|
int n6 = this.i;
|
|
n5 = n6;
|
|
this.i = n6 + 1;
|
|
}
|
|
return n5;
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public l[] a(int var1_1, int var2_2, int var3_3, int var4_4, int var5_5, int var6_6, int var7_7, boolean var8_8) {
|
|
block18: {
|
|
block17: {
|
|
block15: {
|
|
block14: {
|
|
var19_9 = q.d;
|
|
var9_10 = false;
|
|
this.h();
|
|
var10_11 = new int[var6_6];
|
|
var11_12 = new int[var6_6];
|
|
for (var12_13 = 0; var12_13 < var6_6; ++var12_13) {
|
|
var10_11[var12_13] = 0;
|
|
var11_12[var12_13] = 0;
|
|
if (!var19_9) {
|
|
if (!var19_9) continue;
|
|
}
|
|
break block14;
|
|
}
|
|
var12_13 = 0;
|
|
}
|
|
while (var12_13 < this.i) {
|
|
block16: {
|
|
var13_15 = 0;
|
|
var14_16 = 0;
|
|
var15_17 = this.j[var12_13];
|
|
var16_18 = this.k[var12_13];
|
|
v0 = 0;
|
|
if (var19_9) break block15;
|
|
for (var17_20 = v178280; var17_20 < var15_17; ++var17_20) {
|
|
var13_15 += this.U[var16_18[var17_20]];
|
|
var14_16 += this.W[var16_18[var17_20]];
|
|
if (!var19_9) {
|
|
if (!var19_9) continue;
|
|
}
|
|
break block16;
|
|
}
|
|
v1 = var17_20 = var13_15 / (var15_17 * var3_3) + var14_16 / (var15_17 * var4_4) * var5_5;
|
|
var10_11[v1] = var10_11[v1] + var15_17;
|
|
v2 = var17_20;
|
|
var11_12[v2] = var11_12[v2] + 1;
|
|
++var12_13;
|
|
}
|
|
if (!var19_9) continue;
|
|
}
|
|
v0 = var6_6;
|
|
}
|
|
var12_14 = new l[v0];
|
|
for (var13_15 = 0; var13_15 < var6_6; ++var13_15) {
|
|
block20: {
|
|
block19: {
|
|
v3 = var10_11;
|
|
v4 = var13_15;
|
|
if (var19_9) break block19;
|
|
v5 = v3[v4];
|
|
v6 = var7_7;
|
|
if (var19_9) ** GOTO lbl58
|
|
if (v5 <= v6) break block20;
|
|
v3 = var10_11;
|
|
v4 = var13_15;
|
|
}
|
|
v3[v4] = var7_7;
|
|
}
|
|
var12_14[var13_15] = new l(var10_11[var13_15], var11_12[var13_15], true, true, true, var8_8, true);
|
|
var12_14[var13_15].Db = this.Db;
|
|
var12_14[var13_15].Eb = this.Eb;
|
|
if (!var19_9) continue;
|
|
}
|
|
var13_15 = 0;
|
|
block4: do {
|
|
v5 = var13_15;
|
|
v6 = this.i;
|
|
lbl58:
|
|
// 2 sources
|
|
|
|
if (v5 >= v6) break;
|
|
var14_16 = 0;
|
|
var15_17 = 0;
|
|
var16_19 = this.j[var13_15];
|
|
var17_22 = this.k[var13_15];
|
|
v7 = 0;
|
|
if (var19_9) break block17;
|
|
for (var18_23 = v178378; var18_23 < var16_19; ++var18_23) {
|
|
var14_16 += this.U[var17_22[var18_23]];
|
|
var15_17 += this.W[var17_22[var18_23]];
|
|
if (var19_9) continue block4;
|
|
if (!var19_9) continue;
|
|
}
|
|
var18_23 = var14_16 / (var16_19 * var3_3) + var15_17 / (var16_19 * var4_4) * var5_5;
|
|
this.a(var12_14[var18_23], var17_22, var16_19, var13_15);
|
|
++var13_15;
|
|
} while (!var19_9);
|
|
v7 = var13_15 = 0;
|
|
}
|
|
while (var13_15 < var6_6) {
|
|
v8 = var12_14;
|
|
if (!var19_9) {
|
|
v8[var13_15].a();
|
|
++var13_15;
|
|
if (!var19_9) continue;
|
|
}
|
|
break block18;
|
|
}
|
|
v8 = var12_14;
|
|
}
|
|
return v8;
|
|
}
|
|
|
|
public void a(l l2, int[] nArray, int n2, int n3) {
|
|
block8: {
|
|
l l3;
|
|
block9: {
|
|
boolean bl;
|
|
block7: {
|
|
int n4;
|
|
bl = q.d;
|
|
int[] nArray2 = new int[n2];
|
|
for (n4 = 0; n4 < n2; ++n4) {
|
|
int n5 = nArray2[n4] = l2.a(this.U[nArray[n4]], this.V[nArray[n4]], this.W[nArray[n4]]);
|
|
l2.g[n5] = this.g[nArray[n4]];
|
|
l2.h[n5] = this.h[nArray[n4]];
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block7;
|
|
}
|
|
n4 = l2.a(n2, nArray2, this.l[n3], this.m[n3]);
|
|
}
|
|
l3 = l2;
|
|
if (bl) break block8;
|
|
if (l3.L) break block9;
|
|
l3 = this;
|
|
if (bl) break block8;
|
|
if (!l3.L) {
|
|
l2.G[n4] = this.G[n3];
|
|
}
|
|
}
|
|
l2.p[n4] = this.p[n3];
|
|
l2.o[n4] = this.o[n3];
|
|
l3 = l2;
|
|
}
|
|
l3.n[n4] = this.n[n3];
|
|
}
|
|
|
|
public void a(boolean bl, int n2, int n3, int n4, int n5, int n6) {
|
|
block6: {
|
|
int n7;
|
|
boolean bl2 = q.d;
|
|
boolean bl3 = false;
|
|
this.Eb = 256 - n2 * 4;
|
|
this.Db = (64 - n3) * 16 + 128;
|
|
int n8 = this.K;
|
|
if (!bl2) {
|
|
if (n8 != 0) {
|
|
return;
|
|
}
|
|
n8 = n7 = 0;
|
|
}
|
|
while (n7 < this.i) {
|
|
block8: {
|
|
block7: {
|
|
if (bl2) break block6;
|
|
if (!bl) break block7;
|
|
this.p[n7] = this.S;
|
|
if (!bl2) break block8;
|
|
}
|
|
this.p[n7] = 0;
|
|
}
|
|
++n7;
|
|
if (!bl2) continue;
|
|
}
|
|
this.zb = n4;
|
|
this.Ab = n5;
|
|
this.Bb = n6;
|
|
this.Cb = (int)Math.sqrt(n4 * n4 + n5 * n5 + n6 * n6);
|
|
this.e();
|
|
}
|
|
}
|
|
|
|
public void a(int n2, int n3, int n4, int n5, int n6) {
|
|
this.Eb = 256 - n2 * 4;
|
|
this.Db = (64 - n3) * 16 + 128;
|
|
l l2 = this;
|
|
if (!q.d) {
|
|
if (l2.K) {
|
|
return;
|
|
}
|
|
this.zb = n4;
|
|
this.Ab = n5;
|
|
this.Bb = n6;
|
|
this.Cb = (int)Math.sqrt(n4 * n4 + n5 * n5 + n6 * n6);
|
|
l2 = this;
|
|
}
|
|
l2.e();
|
|
}
|
|
|
|
public void c(int n2, int n3, int n4) {
|
|
l l2 = this;
|
|
if (!q.d) {
|
|
if (l2.K) {
|
|
return;
|
|
}
|
|
this.zb = n2;
|
|
this.Ab = n3;
|
|
this.Bb = n4;
|
|
this.Cb = (int)Math.sqrt(n2 * n2 + n3 * n3 + n4 * n4);
|
|
l2 = this;
|
|
}
|
|
l2.e();
|
|
}
|
|
|
|
public void c(int n2, int n3) {
|
|
this.h[n2] = (byte)n3;
|
|
}
|
|
|
|
public void d(int n2, int n3, int n4) {
|
|
this.lb = this.lb + n2 & 0xFF;
|
|
this.mb = this.mb + n3 & 0xFF;
|
|
this.nb = this.nb + n4 & 0xFF;
|
|
this.c();
|
|
this.u = 1;
|
|
}
|
|
|
|
public void e(int n2, int n3, int n4) {
|
|
this.lb = n2 & 0xFF;
|
|
this.mb = n3 & 0xFF;
|
|
this.nb = n4 & 0xFF;
|
|
this.c();
|
|
this.u = 1;
|
|
}
|
|
|
|
public void f(int n2, int n3, int n4) {
|
|
this.ib += n2;
|
|
this.jb += n3;
|
|
this.kb += n4;
|
|
this.c();
|
|
this.u = 1;
|
|
}
|
|
|
|
public void g(int n2, int n3, int n4) {
|
|
this.ib = n2;
|
|
this.jb = n3;
|
|
this.kb = n4;
|
|
this.c();
|
|
this.u = 1;
|
|
}
|
|
|
|
private void c() {
|
|
block22: {
|
|
l l2;
|
|
block23: {
|
|
block20: {
|
|
l l3;
|
|
block21: {
|
|
int n2;
|
|
boolean bl;
|
|
block18: {
|
|
block19: {
|
|
block16: {
|
|
l l4;
|
|
block17: {
|
|
int n3;
|
|
block14: {
|
|
block15: {
|
|
block12: {
|
|
l l5;
|
|
block13: {
|
|
int n4;
|
|
int n5;
|
|
block10: {
|
|
block11: {
|
|
block8: {
|
|
l l6;
|
|
block9: {
|
|
bl = q.d;
|
|
l6 = this;
|
|
if (bl) break block8;
|
|
if (l6.rb != 256) break block9;
|
|
l6 = this;
|
|
if (bl) break block8;
|
|
if (l6.sb != 256) break block9;
|
|
l6 = this;
|
|
if (bl) break block8;
|
|
if (l6.tb != 256) break block9;
|
|
l6 = this;
|
|
if (bl) break block8;
|
|
if (l6.ub != 256) break block9;
|
|
l6 = this;
|
|
if (bl) break block8;
|
|
if (l6.vb != 256) break block9;
|
|
n5 = this.wb;
|
|
n4 = 256;
|
|
if (bl) break block10;
|
|
if (n5 == n4) break block11;
|
|
}
|
|
l6 = this;
|
|
}
|
|
l6.xb = 4;
|
|
return;
|
|
}
|
|
l5 = this;
|
|
if (bl) break block12;
|
|
n5 = l5.ob;
|
|
n4 = 256;
|
|
}
|
|
if (n5 != n4) break block13;
|
|
l5 = this;
|
|
if (bl) break block12;
|
|
if (l5.pb != 256) break block13;
|
|
n3 = this.qb;
|
|
if (bl) break block14;
|
|
if (n3 == 256) break block15;
|
|
}
|
|
l5 = this;
|
|
}
|
|
l5.xb = 3;
|
|
return;
|
|
}
|
|
l4 = this;
|
|
if (bl) break block16;
|
|
n3 = l4.lb;
|
|
}
|
|
if (n3 != 0) break block17;
|
|
l4 = this;
|
|
if (bl) break block16;
|
|
if (l4.mb != 0) break block17;
|
|
n2 = this.nb;
|
|
if (bl) break block18;
|
|
if (n2 == 0) break block19;
|
|
}
|
|
l4 = this;
|
|
}
|
|
l4.xb = 2;
|
|
return;
|
|
}
|
|
l3 = this;
|
|
if (bl) break block20;
|
|
n2 = l3.ib;
|
|
}
|
|
if (n2 != 0) break block21;
|
|
l3 = this;
|
|
if (bl) break block20;
|
|
if (l3.jb != 0) break block21;
|
|
l2 = this;
|
|
if (bl) break block22;
|
|
if (l2.kb == 0) break block23;
|
|
}
|
|
l3 = this;
|
|
}
|
|
l3.xb = 1;
|
|
return;
|
|
}
|
|
l2 = this;
|
|
}
|
|
l2.xb = 0;
|
|
}
|
|
|
|
private void h(int n2, int n3, int n4) {
|
|
int n5 = 0;
|
|
while (n5 < this.a) {
|
|
int n6 = n5;
|
|
this.X[n6] = this.X[n6] + n2;
|
|
int n7 = n5;
|
|
this.Y[n7] = this.Y[n7] + n3;
|
|
int n8 = n5++;
|
|
this.Z[n8] = this.Z[n8] + n4;
|
|
if (!q.d) continue;
|
|
}
|
|
}
|
|
|
|
private void i(int n2, int n3, int n4) {
|
|
boolean bl = q.d;
|
|
for (int i2 = 0; i2 < this.a; ++i2) {
|
|
int n5;
|
|
int n6;
|
|
int n7;
|
|
int n8 = n4;
|
|
if (!bl) {
|
|
if (n8 != 0) {
|
|
n7 = N[n4];
|
|
n6 = N[n4 + 256];
|
|
n5 = this.Y[i2] * n7 + this.X[i2] * n6 >> 15;
|
|
this.Y[i2] = this.Y[i2] * n6 - this.X[i2] * n7 >> 15;
|
|
this.X[i2] = n5;
|
|
}
|
|
n8 = n2;
|
|
}
|
|
if (!bl) {
|
|
if (n8 != 0) {
|
|
n7 = N[n2];
|
|
n6 = N[n2 + 256];
|
|
n5 = this.Y[i2] * n6 - this.Z[i2] * n7 >> 15;
|
|
this.Z[i2] = this.Y[i2] * n7 + this.Z[i2] * n6 >> 15;
|
|
this.Y[i2] = n5;
|
|
}
|
|
n8 = n3;
|
|
}
|
|
if (!bl) {
|
|
if (n8 == 0) continue;
|
|
n8 = N[n3];
|
|
}
|
|
n7 = n8;
|
|
n6 = N[n3 + 256];
|
|
n5 = this.Z[i2] * n7 + this.X[i2] * n6 >> 15;
|
|
this.Z[i2] = this.Z[i2] * n6 - this.X[i2] * n7 >> 15;
|
|
this.X[i2] = n5;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
private void a(int n2, int n3, int n4, int n5, int n6, int n7) {
|
|
boolean bl = q.d;
|
|
for (int i2 = 0; i2 < this.a; ++i2) {
|
|
int n8 = n2;
|
|
if (!bl) {
|
|
if (n8 != 0) {
|
|
int n9 = i2;
|
|
this.X[n9] = this.X[n9] + (this.Y[i2] * n2 >> 8);
|
|
}
|
|
n8 = n3;
|
|
}
|
|
if (!bl) {
|
|
if (n8 != 0) {
|
|
int n10 = i2;
|
|
this.Z[n10] = this.Z[n10] + (this.Y[i2] * n3 >> 8);
|
|
}
|
|
n8 = n4;
|
|
}
|
|
if (!bl) {
|
|
if (n8 != 0) {
|
|
int n11 = i2;
|
|
this.X[n11] = this.X[n11] + (this.Z[i2] * n4 >> 8);
|
|
}
|
|
n8 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n8 != 0) {
|
|
int n12 = i2;
|
|
this.Y[n12] = this.Y[n12] + (this.Z[i2] * n5 >> 8);
|
|
}
|
|
n8 = n6;
|
|
}
|
|
if (!bl) {
|
|
if (n8 != 0) {
|
|
int n13 = i2;
|
|
this.Z[n13] = this.Z[n13] + (this.X[i2] * n6 >> 8);
|
|
}
|
|
n8 = n7;
|
|
}
|
|
if (n8 == 0) continue;
|
|
int n14 = i2;
|
|
this.Y[n14] = this.Y[n14] + (this.X[i2] * n7 >> 8);
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
private void j(int n2, int n3, int n4) {
|
|
for (int i2 = 0; i2 < this.a; ++i2) {
|
|
this.X[i2] = this.X[i2] * n2 >> 8;
|
|
this.Y[i2] = this.Y[i2] * n3 >> 8;
|
|
this.Z[i2] = this.Z[i2] * n4 >> 8;
|
|
if (!q.d) continue;
|
|
}
|
|
}
|
|
|
|
private void d() {
|
|
boolean bl = q.d;
|
|
boolean bl2 = false;
|
|
this.A = 999999;
|
|
this.y = 999999;
|
|
this.w = 999999;
|
|
this.B = -999999;
|
|
this.z = -999999;
|
|
this.x = -999999;
|
|
this.yb = -999999;
|
|
for (int i2 = 0; i2 < this.i; ++i2) {
|
|
int n2;
|
|
int n3;
|
|
int n4;
|
|
int n5;
|
|
int n6;
|
|
int n7;
|
|
int n8;
|
|
int n9;
|
|
block32: {
|
|
int[] nArray = this.k[i2];
|
|
int n10 = nArray[0];
|
|
int n11 = this.j[i2];
|
|
n8 = n9 = this.X[n10];
|
|
n6 = n7 = this.Y[n10];
|
|
n4 = n5 = this.Z[n10];
|
|
for (int i3 = 0; i3 < n11; ++i3) {
|
|
int n12;
|
|
block42: {
|
|
int n13;
|
|
int n14;
|
|
block41: {
|
|
block40: {
|
|
block39: {
|
|
block37: {
|
|
block38: {
|
|
block36: {
|
|
block35: {
|
|
block33: {
|
|
block34: {
|
|
n14 = nArray[i3];
|
|
n3 = this.X[n14];
|
|
n2 = n9;
|
|
if (bl) break block32;
|
|
if (bl) break block33;
|
|
if (n3 >= n2) break block34;
|
|
n9 = this.X[n14];
|
|
if (!bl) break block35;
|
|
}
|
|
n12 = this.X[n14];
|
|
n13 = n8;
|
|
}
|
|
if (bl) break block36;
|
|
if (n12 > n13) {
|
|
n8 = this.X[n14];
|
|
}
|
|
}
|
|
n12 = this.Y[n14];
|
|
n13 = n7;
|
|
}
|
|
if (bl) break block37;
|
|
if (n12 >= n13) break block38;
|
|
n7 = this.Y[n14];
|
|
if (!bl) break block39;
|
|
}
|
|
n12 = this.Y[n14];
|
|
n13 = n6;
|
|
}
|
|
if (bl) break block40;
|
|
if (n12 > n13) {
|
|
n6 = this.Y[n14];
|
|
}
|
|
}
|
|
n12 = this.Z[n14];
|
|
n13 = n5;
|
|
}
|
|
if (bl) break block41;
|
|
if (n12 < n13) {
|
|
n5 = this.Z[n14];
|
|
if (!bl) continue;
|
|
}
|
|
n12 = this.Z[n14];
|
|
if (bl) break block42;
|
|
n13 = n4;
|
|
}
|
|
if (n12 <= n13) continue;
|
|
n12 = this.Z[n14];
|
|
}
|
|
n4 = n12;
|
|
if (!bl) continue;
|
|
}
|
|
n3 = this.J;
|
|
if (!bl) {
|
|
if (n3 == 0) {
|
|
this.cb[i2] = n9;
|
|
this.db[i2] = n8;
|
|
this.eb[i2] = n7;
|
|
this.fb[i2] = n6;
|
|
this.gb[i2] = n5;
|
|
this.hb[i2] = n4;
|
|
}
|
|
n3 = n8 - n9;
|
|
}
|
|
n2 = this.yb;
|
|
}
|
|
if (!bl) {
|
|
if (n3 > n2) {
|
|
this.yb = n8 - n9;
|
|
}
|
|
n3 = n6 - n7;
|
|
n2 = this.yb;
|
|
}
|
|
if (!bl) {
|
|
if (n3 > n2) {
|
|
this.yb = n6 - n7;
|
|
}
|
|
n3 = n4 - n5;
|
|
n2 = this.yb;
|
|
}
|
|
if (!bl) {
|
|
if (n3 > n2) {
|
|
this.yb = n4 - n5;
|
|
}
|
|
n3 = n9;
|
|
n2 = this.w;
|
|
}
|
|
if (!bl) {
|
|
if (n3 < n2) {
|
|
this.w = n9;
|
|
}
|
|
n3 = n8;
|
|
n2 = this.x;
|
|
}
|
|
if (!bl) {
|
|
if (n3 > n2) {
|
|
this.x = n8;
|
|
}
|
|
n3 = n7;
|
|
n2 = this.y;
|
|
}
|
|
if (!bl) {
|
|
if (n3 < n2) {
|
|
this.y = n7;
|
|
}
|
|
n3 = n6;
|
|
n2 = this.z;
|
|
}
|
|
if (!bl) {
|
|
if (n3 > n2) {
|
|
this.z = n6;
|
|
}
|
|
n3 = n5;
|
|
n2 = this.A;
|
|
}
|
|
if (!bl) {
|
|
if (n3 < n2) {
|
|
this.A = n5;
|
|
}
|
|
n3 = n4;
|
|
n2 = this.B;
|
|
}
|
|
if (n3 <= n2) continue;
|
|
this.B = n4;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public void e() {
|
|
block22: {
|
|
block21: {
|
|
var10_1 = q.d;
|
|
var1_2 = false;
|
|
v0 = this.K;
|
|
if (!var10_1) {
|
|
if (v0 != 0) {
|
|
return;
|
|
}
|
|
v0 = this.Db * this.Cb >> 8;
|
|
}
|
|
var2_3 = v0;
|
|
for (var3_4 = 0; var3_4 < this.i; ++var3_4) {
|
|
v1 = this.p;
|
|
v2 = var3_4;
|
|
if (!var10_1) {
|
|
v3 = v1[v2];
|
|
if (var10_1) break block21;
|
|
if (v3 == this.S) continue;
|
|
v1 = this.p;
|
|
v2 = var3_4;
|
|
}
|
|
v1[v2] = (this.q[var3_4] * this.zb + this.r[var3_4] * this.Ab + this.s[var3_4] * this.Bb) / var2_3;
|
|
if (!var10_1) continue;
|
|
}
|
|
v3 = this.a;
|
|
}
|
|
var3_5 = new int[v3];
|
|
var4_6 = new int[this.a];
|
|
var5_7 = new int[this.a];
|
|
var6_8 = new int[this.a];
|
|
for (var7_9 = 0; var7_9 < this.a; ++var7_9) {
|
|
var3_5[var7_9] = 0;
|
|
var4_6[var7_9] = 0;
|
|
var5_7[var7_9] = 0;
|
|
var6_8[var7_9] = 0;
|
|
if (!var10_1) {
|
|
if (!var10_1) continue;
|
|
}
|
|
break block22;
|
|
}
|
|
var7_9 = 0;
|
|
}
|
|
while (var7_9 < this.i) {
|
|
v4 = this.p[var7_9];
|
|
if (var10_1) ** GOTO lbl43
|
|
v5 = this.S;
|
|
if (var10_1) ** GOTO lbl63
|
|
if (v4 == v5) {
|
|
v4 = var8_10 = 0;
|
|
lbl43:
|
|
// 3 sources
|
|
|
|
while (var8_10 < this.j[var7_9]) {
|
|
v6 = var9_11 = this.k[var7_9][var8_10];
|
|
var3_5[v6] = var3_5[v6] + this.q[var7_9];
|
|
v7 = var9_11;
|
|
var4_6[v7] = var4_6[v7] + this.r[var7_9];
|
|
v8 = var9_11;
|
|
var5_7[v8] = var5_7[v8] + this.s[var7_9];
|
|
v9 = var9_11;
|
|
var6_8[v9] = var6_8[v9] + 1;
|
|
++var8_10;
|
|
if (!var10_1) {
|
|
if (!var10_1) continue;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
++var7_9;
|
|
}
|
|
if (!var10_1) continue;
|
|
}
|
|
var7_9 = 0;
|
|
do {
|
|
block24: {
|
|
block23: {
|
|
v10 = var7_9;
|
|
v5 = this.a;
|
|
lbl63:
|
|
// 2 sources
|
|
|
|
if (v10 >= v5) break;
|
|
v11 = var6_8;
|
|
v12 = var7_9;
|
|
if (var10_1) break block23;
|
|
if (v11[v12] <= 0) break block24;
|
|
v11 = this.g;
|
|
v12 = var7_9;
|
|
}
|
|
v11[v12] = (var3_5[var7_9] * this.zb + var4_6[var7_9] * this.Ab + var5_7[var7_9] * this.Bb) / (var2_3 * var6_8[var7_9]);
|
|
}
|
|
++var7_9;
|
|
} while (!var10_1);
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
* Could not resolve type clashes
|
|
*/
|
|
public void f() {
|
|
block15: {
|
|
var17_1 = q.d;
|
|
var1_2 = false;
|
|
v0 = this.K;
|
|
if (!var17_1) {
|
|
if (v0 != 0) {
|
|
v0 = this.J;
|
|
if (!var17_1) {
|
|
if (v0 != 0) {
|
|
return;
|
|
} else {
|
|
** GOTO lbl-1000
|
|
}
|
|
}
|
|
} else lbl-1000:
|
|
// 3 sources
|
|
|
|
{
|
|
v0 = var2_3 = 0;
|
|
}
|
|
}
|
|
while (var2_3 < this.i) {
|
|
block16: {
|
|
var3_4 = this.k[var2_3];
|
|
var4_5 = this.X[var3_4[0]];
|
|
var5_6 = this.Y[var3_4[0]];
|
|
var6_7 = this.Z[var3_4[0]];
|
|
var7_8 = this.X[var3_4[1]] - var4_5;
|
|
var8_9 = this.Y[var3_4[1]] - var5_6;
|
|
var9_10 = this.Z[var3_4[1]] - var6_7;
|
|
var10_11 = this.X[var3_4[2]] - var4_5;
|
|
var11_12 = this.Y[var3_4[2]] - var5_6;
|
|
var12_13 = this.Z[var3_4[2]] - var6_7;
|
|
var13_14 = var8_9 * var12_13 - var11_12 * var9_10;
|
|
var14_15 = var9_10 * var10_11 - var12_13 * var7_8;
|
|
if (var17_1) break block15;
|
|
var15_16 = var7_8 * var11_12 - var10_11 * var8_9;
|
|
do {
|
|
block18: {
|
|
block17: {
|
|
if (var13_14 > 8192) break block17;
|
|
v1 = var14_15;
|
|
v2 = 8192;
|
|
if (var17_1 || var17_1) break block18;
|
|
if (v1 > v2) break block17;
|
|
v1 = var15_16;
|
|
v2 = 8192;
|
|
if (var17_1) break block18;
|
|
if (v1 <= v2) {
|
|
v1 = var13_14;
|
|
v2 = -8192;
|
|
if (!var17_1) {
|
|
if (v1 >= v2) {
|
|
v1 = var14_15;
|
|
v2 = -8192;
|
|
if (!var17_1) {
|
|
if (v1 >= v2) {
|
|
v3 = var15_16;
|
|
if (!var17_1) {
|
|
if (v3 >= -8192) break;
|
|
}
|
|
break block16;
|
|
} else {
|
|
** GOTO lbl53
|
|
}
|
|
} else {
|
|
** GOTO lbl52
|
|
}
|
|
} else {
|
|
** GOTO lbl51
|
|
}
|
|
} else {
|
|
** GOTO lbl50
|
|
}
|
|
}
|
|
break block17;
|
|
lbl50:
|
|
// 2 sources
|
|
|
|
break block18;
|
|
lbl51:
|
|
// 2 sources
|
|
|
|
break block17;
|
|
lbl52:
|
|
// 2 sources
|
|
|
|
break block18;
|
|
}
|
|
var13_14 >>= 1;
|
|
var14_15 >>= 1;
|
|
v1 = var15_16;
|
|
v2 = 1;
|
|
}
|
|
var15_16 = v1 >> v2;
|
|
} while (!var17_1);
|
|
v3 = var16_17 = (int)(256.0 * Math.sqrt(var13_14 * var13_14 + var14_15 * var14_15 + var15_16 * var15_16));
|
|
}
|
|
if (!var17_1) {
|
|
if (var16_17 <= 0) {
|
|
var16_17 = 1;
|
|
}
|
|
this.q[var2_3] = var13_14 * 65536 / var16_17;
|
|
this.r[var2_3] = var14_15 * 65536 / var16_17;
|
|
this.s[var2_3] = var15_16 * 65535 / var16_17;
|
|
this.o[var2_3] = -1;
|
|
++var2_3;
|
|
}
|
|
if (!var17_1) continue;
|
|
}
|
|
this.e();
|
|
}
|
|
}
|
|
|
|
public void g() {
|
|
block24: {
|
|
l l2;
|
|
block27: {
|
|
int n2;
|
|
int n3;
|
|
block26: {
|
|
boolean bl;
|
|
block25: {
|
|
block21: {
|
|
int n4;
|
|
block23: {
|
|
int n5;
|
|
int n6;
|
|
block22: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
n6 = this.u;
|
|
n5 = 2;
|
|
if (bl) break block22;
|
|
if (n6 == n5) {
|
|
block20: {
|
|
this.u = 0;
|
|
for (int i2 = 0; i2 < this.a; ++i2) {
|
|
this.X[i2] = this.U[i2];
|
|
this.Y[i2] = this.V[i2];
|
|
this.Z[i2] = this.W[i2];
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block20;
|
|
}
|
|
this.A = -9999999;
|
|
this.y = -9999999;
|
|
this.w = -9999999;
|
|
this.B = 9999999;
|
|
this.z = 9999999;
|
|
this.x = 9999999;
|
|
this.yb = 9999999;
|
|
}
|
|
return;
|
|
}
|
|
n6 = this.u;
|
|
if (bl) break block23;
|
|
n5 = 1;
|
|
}
|
|
if (n6 != n5) break block24;
|
|
this.u = 0;
|
|
n6 = n4 = 0;
|
|
}
|
|
while (n4 < this.a) {
|
|
this.X[n4] = this.U[n4];
|
|
this.Y[n4] = this.V[n4];
|
|
this.Z[n4] = this.W[n4];
|
|
++n4;
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block21;
|
|
}
|
|
n3 = this.xb;
|
|
n2 = 2;
|
|
if (bl) break block25;
|
|
if (n3 >= n2) {
|
|
this.i(this.lb, this.mb, this.nb);
|
|
}
|
|
}
|
|
n3 = this.xb;
|
|
n2 = 3;
|
|
}
|
|
if (!bl) {
|
|
if (n3 >= n2) {
|
|
this.j(this.ob, this.pb, this.qb);
|
|
}
|
|
n3 = this.xb;
|
|
n2 = 4;
|
|
}
|
|
if (bl) break block26;
|
|
if (n3 >= n2) {
|
|
this.a(this.rb, this.sb, this.tb, this.ub, this.vb, this.wb);
|
|
}
|
|
l2 = this;
|
|
if (bl) break block27;
|
|
n3 = l2.xb;
|
|
n2 = 1;
|
|
}
|
|
if (n3 >= n2) {
|
|
this.h(this.ib, this.jb, this.kb);
|
|
}
|
|
this.d();
|
|
l2 = this;
|
|
}
|
|
l2.f();
|
|
}
|
|
}
|
|
|
|
public void a(int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9) {
|
|
int n10;
|
|
int n11;
|
|
boolean bl;
|
|
block24: {
|
|
block25: {
|
|
block22: {
|
|
l l2;
|
|
block23: {
|
|
bl = q.d;
|
|
boolean bl2 = false;
|
|
this.g();
|
|
l2 = this;
|
|
if (bl) break block22;
|
|
if (l2.A > f.Bb) break block23;
|
|
l2 = this;
|
|
if (bl) break block22;
|
|
if (l2.B < f.Ab) break block23;
|
|
l2 = this;
|
|
if (bl) break block22;
|
|
if (l2.w > f.xb) break block23;
|
|
l2 = this;
|
|
if (bl) break block22;
|
|
if (l2.x < f.wb) break block23;
|
|
l2 = this;
|
|
if (bl) break block22;
|
|
if (l2.y > f.zb) break block23;
|
|
n11 = this.z;
|
|
if (bl) break block24;
|
|
if (n11 >= f.yb) break block25;
|
|
}
|
|
l2 = this;
|
|
}
|
|
l2.v = false;
|
|
return;
|
|
}
|
|
this.v = true;
|
|
n11 = 0;
|
|
}
|
|
int n12 = n11;
|
|
int n13 = 0;
|
|
int n14 = 0;
|
|
int n15 = 0;
|
|
int n16 = 0;
|
|
int n17 = 0;
|
|
int n18 = n7;
|
|
if (!bl) {
|
|
if (n18 != 0) {
|
|
n12 = O[n7];
|
|
n13 = O[n7 + 1024];
|
|
}
|
|
n18 = n6;
|
|
}
|
|
if (!bl) {
|
|
if (n18 != 0) {
|
|
n16 = O[n6];
|
|
n17 = O[n6 + 1024];
|
|
}
|
|
n18 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n18 != 0) {
|
|
n14 = O[n5];
|
|
n15 = O[n5 + 1024];
|
|
}
|
|
n18 = n10 = 0;
|
|
}
|
|
while (n10 < this.a) {
|
|
int n19;
|
|
int n20;
|
|
int n21;
|
|
block29: {
|
|
block28: {
|
|
block27: {
|
|
block26: {
|
|
int n22;
|
|
n21 = this.X[n10] - n2;
|
|
n20 = this.Y[n10] - n3;
|
|
n19 = this.Z[n10] - n4;
|
|
int n23 = n7;
|
|
if (!bl) {
|
|
if (n23 != 0) {
|
|
n22 = n20 * n12 + n21 * n13 >> 15;
|
|
n20 = n20 * n13 - n21 * n12 >> 15;
|
|
n21 = n22;
|
|
}
|
|
n23 = n6;
|
|
}
|
|
if (!bl) {
|
|
if (n23 != 0) {
|
|
n22 = n19 * n16 + n21 * n17 >> 15;
|
|
n19 = n19 * n17 - n21 * n16 >> 15;
|
|
n21 = n22;
|
|
}
|
|
n23 = n5;
|
|
}
|
|
if (!bl) {
|
|
if (n23 != 0) {
|
|
n22 = n20 * n15 - n19 * n14 >> 15;
|
|
n19 = n20 * n14 + n19 * n15 >> 15;
|
|
n20 = n22;
|
|
}
|
|
n23 = n19;
|
|
}
|
|
if (n23 < n9) break block26;
|
|
this.e[n10] = (n21 << n8) / n19;
|
|
if (!bl) break block27;
|
|
}
|
|
this.e[n10] = n21 << n8;
|
|
}
|
|
if (n19 < n9) break block28;
|
|
this.f[n10] = (n20 << n8) / n19;
|
|
if (!bl) break block29;
|
|
}
|
|
this.f[n10] = n20 << n8;
|
|
}
|
|
this.b[n10] = n21;
|
|
this.c[n10] = n20;
|
|
this.d[n10] = n19;
|
|
++n10;
|
|
if (!bl) continue;
|
|
}
|
|
}
|
|
|
|
public void h() {
|
|
block2: {
|
|
boolean bl = q.d;
|
|
this.g();
|
|
for (int i2 = 0; i2 < this.a; ++i2) {
|
|
this.U[i2] = this.X[i2];
|
|
this.V[i2] = this.Y[i2];
|
|
this.W[i2] = this.Z[i2];
|
|
if (!bl) {
|
|
if (!bl) continue;
|
|
}
|
|
break block2;
|
|
}
|
|
this.kb = 0;
|
|
this.jb = 0;
|
|
this.ib = 0;
|
|
this.nb = 0;
|
|
this.mb = 0;
|
|
this.lb = 0;
|
|
this.qb = 256;
|
|
this.pb = 256;
|
|
this.ob = 256;
|
|
this.wb = 256;
|
|
this.vb = 256;
|
|
this.ub = 256;
|
|
this.tb = 256;
|
|
this.sb = 256;
|
|
this.rb = 256;
|
|
this.xb = 0;
|
|
}
|
|
}
|
|
|
|
public l i() {
|
|
l[] lArray = new l[]{this};
|
|
l l2 = new l(lArray, 1);
|
|
l2.t = 0;
|
|
l2.E = this.E;
|
|
return l2;
|
|
}
|
|
|
|
public l a(boolean bl, boolean bl2, boolean bl3, boolean bl4) {
|
|
l[] lArray = new l[]{this};
|
|
l l2 = new l(lArray, 1, bl, bl2, bl3, bl4);
|
|
l2.t = 0;
|
|
return l2;
|
|
}
|
|
|
|
public void a(l l2) {
|
|
this.lb = l2.lb;
|
|
this.mb = l2.mb;
|
|
this.nb = l2.nb;
|
|
this.ib = l2.ib;
|
|
this.jb = l2.jb;
|
|
this.kb = l2.kb;
|
|
this.c();
|
|
this.u = 1;
|
|
}
|
|
|
|
public int a(byte[] byArray) {
|
|
int n2;
|
|
int n3;
|
|
boolean bl;
|
|
block5: {
|
|
bl = q.d;
|
|
do {
|
|
if (byArray[this.Fb] != 10) {
|
|
n3 = byArray[this.Fb];
|
|
if (!bl) {
|
|
if (n3 != 13) break;
|
|
}
|
|
break block5;
|
|
}
|
|
++this.Fb;
|
|
} while (!bl);
|
|
n3 = Q[byArray[this.Fb++] & 0xFF];
|
|
}
|
|
int n4 = n3;
|
|
int n5 = Q[byArray[this.Fb++] & 0xFF];
|
|
int n6 = Q[byArray[this.Fb++] & 0xFF];
|
|
int n7 = n2 = n4 * 4096 + n5 * 64 + n6 - 131072;
|
|
if (!bl) {
|
|
if (n7 == 123456) {
|
|
n2 = this.S;
|
|
}
|
|
n7 = n2;
|
|
}
|
|
return n7;
|
|
}
|
|
|
|
static {
|
|
int n2;
|
|
N = new int[512];
|
|
O = new int[2048];
|
|
P = new byte[64];
|
|
Q = new int[256];
|
|
for (n2 = 0; n2 < 256; ++n2) {
|
|
l.N[n2] = (int)(Math.sin((double)n2 * 0.02454369) * 32768.0);
|
|
l.N[n2 + 256] = (int)(Math.cos((double)n2 * 0.02454369) * 32768.0);
|
|
}
|
|
for (n2 = 0; n2 < 1024; ++n2) {
|
|
l.O[n2] = (int)(Math.sin((double)n2 * 0.00613592315) * 32768.0);
|
|
l.O[n2 + 1024] = (int)(Math.cos((double)n2 * 0.00613592315) * 32768.0);
|
|
}
|
|
for (n2 = 0; n2 < 10; ++n2) {
|
|
l.P[n2] = (byte)(48 + n2);
|
|
}
|
|
for (n2 = 0; n2 < 26; ++n2) {
|
|
l.P[n2 + 10] = (byte)(65 + n2);
|
|
}
|
|
for (n2 = 0; n2 < 26; ++n2) {
|
|
l.P[n2 + 36] = (byte)(97 + n2);
|
|
}
|
|
l.P[62] = -93;
|
|
l.P[63] = 36;
|
|
for (n2 = 0; n2 < 10; ++n2) {
|
|
l.Q[48 + n2] = n2;
|
|
}
|
|
for (n2 = 0; n2 < 26; ++n2) {
|
|
l.Q[65 + n2] = n2 + 10;
|
|
}
|
|
for (n2 = 0; n2 < 26; ++n2) {
|
|
l.Q[97 + n2] = n2 + 36;
|
|
}
|
|
l.Q[163] = 62;
|
|
l.Q[36] = 63;
|
|
}
|
|
}
|
|
|