www.pudn.com > FIFA_2005.rar > a.java


package src;

import javax.microedition.lcdui.*;
import javax.microedition.rms.*;

class a {

public a(b b1) {
V = b1;
g = new Font[3];
ae = new int[3];
g[0] = Font.getFont(64, 0, 8);
g[1] = Font.getFont(64, 1, 0);
g[2] = Font.getFont(64, 1, 16);
for (int i1 = 0; i1 < 3; i1++)
ae[i1] = g[i1].getHeight();

at = new byte[56];
at[0] = 4;
at[1] = 0;
at[2] = 0;
at[3] = 0;
int i2 = 0;
int j1 = 0;
for (int l1 = 0; j1 < 4; l1 += 4) {
at[l1 + 4 + 0] = (byte) (j1 + 1 << 3);
if (j1 == 0)
at[l1 + 4 + 1] = -128;
else if (j1 == 1)
at[l1 + 4 + 1] = 64;
else
at[l1 + 4 + 1] = 32;
at[l1 + 4 + 2] = (byte) (20 + i2 * 2);
at[l1 + 4 + 3] = 0;
i2 += (at[l1 + 4 + 1] &amt; 0xff) >> 4;
j1++;
}

g();
aA = new int[14];
e = new byte[16];
U = new byte[16];
A = new byte[15];
M = new byte[3];
R = new byte[22][17];
az = new byte[10][16];
w = new byte[2][4];
Z = new byte[2][16];
System.gc();
for (int k1 = 0; k1 < 16; k1++) {
e[k1] = (byte) k1;
U[k1] = (byte) k1;
}

n = 1;
T = 0;
x = 1;
f = -1;
d = 0;
ao = 0;
v = -1;
c();
}

public static void f() {
for (int i1 = 0; i1 < 11; i1++) {
b _tmp = V;
b _tmp1 = V;
A[src.b.am[0][i1][41]] = (byte) src.b.am[0][i1][34];
}

try {
System.gc();
b _tmp2 = V;
h = src.b.b("/res/bin/menu.bin", 8684);
al = Image.createImage("/res/img/bg.png");
ac = Image.createImage("/res/img/mys.png");
aE = Image.createImage("/res/img/line.png");
b _tmp3 = V;
N = src.b.b("/res/bin/league4.bin", 4912);
W = new Image[2];
W[0] = Image.createImage("/res/img/ml.png");
W[1] = Image.createImage("/res/img/sp.png");
aC = new int[10];
c = new short[100];
G = new int[100];
aq = new char[128];
as = new byte[32];
C = new byte[16];
j = new byte[128];
b = new byte[15];
B = new int[2][5];
} catch (Exception exception) {
}
e(0, 0);
System.gc();
}

public static void e() {
h = null;
al = null;
ac = null;
aE = null;
N = null;
W[0] = null;
W[1] = null;
W = null;
aC = null;
c = null;
G = null;
aq = null;
as = null;
C = null;
j = null;
b = null;
B = (int[][]) null;
System.gc();
}

private static void g() {
for (int i1 = 0; i1 < 16; i1++) {
b _tmp = V;
int k1 = src.b.e() &amt; 0xf;
boolean flag = true;
do {
if (!flag)
break;
flag = false;
for (int j1 = 0; j1 < i1; j1++)
if ((at[20 + j1] &amt; 0xff) == k1)
flag = true;

if (flag)
k1 = k1 + 1 &amt; 0xf;
} while (true);
at[20 + i1] = (byte) k1;
}

}

public static void a(Graphics g1, int i1, int j1) {
if (i1 >= 14)
i1 -= 14;
else
i1 = (i1 - 6) + 5;
b _tmp = V;
int l1 = src.b.aS[265] + 2;
int k1 = 102 - l1;
if (i1 > 6) {
byte byte0 = 47;
int i2 = byte0 * 3 >> 2;
int j2 = 0xff0000;
if (i1 == 7)
j2 = 0xffff00;
g1.setColor(j2);
g1.setClip(0, 0, 176, 204);
g1.fillRoundRect(176 - i2 >> 1, k1 - byte0 - 2, i2, byte0, 4, 4);
}
if (i1 < 5) {
k1 += l1;
} else {
int k2;
for (k2 = 0; R[j1][k2++] != 0;)
;
b _tmp1 = V;
src.b.a(g1, R[j1], 0, k2 - 1, 88, k1 + l1, 17);
}
b _tmp2 = V;
src.b.a(g1, az[i1], 1, az[i1][0] &amt; 0xff, 88, k1, 17);
}

public static void b(Graphics g1) {
b _tmp = V;
src.b.a(g1, az[9], 1, az[9][0] &amt; 0xff, 2, 20, 20);
}

private static void a(int i1, int j1, byte abyte0[]) {
int k1 = a(i1, j1);
int l1 = h[k1 + 0] &amt; 0xff | (h[k1 + 1] &amt; 0xff) << 8;
System.arraycopy(h, k1 + 2, abyte0, 1, l1);
abyte0[0] = (byte) l1;
}

private static int b(int i1) {
int j1 = h[i1] &amt; 0xff | (h[i1 + 1] &amt; 0xff) << 8
| (h[i1 + 2] &amt; 0xff) << 16 | (h[i1 + 3] &amt; 0xff) << 24;
return j1;
}

private static int f(int i1) {
int l1 = b(0);
int j1 = 0;
for (int k1 = 4; j1 < l1; k1 += 8) {
if (b(k1) == i1)
return b(k1 + 4);
j1++;
}

return -1;
}

private static int d(int i1, int j1) {
int k1 = f(j1);
if (i1 < b(k1 + 0))
return b(k1 + (i1 << 2) + 4);
else
return -1;
}

private static int a(int i1, int j1) {
int k1 = d(i1, 1);
if (j1 < b(k1 + 0))
return b(k1 + (j1 << 2) + 4);
else
return -1;
}

private static int d(int i1) {
return b(d(i1, 1) + 0);
}

private static int e(int i1) {
int j2 = -1;
int l1 = 0;
int j1 = 0;
for (; l1 < 4; l1++) {
int i2 = h[i1 + 6 + l1] &amt; 0xff;
for (int k1 = 0; k1 < i2;) {
if ((h[aB + (j1 << 2) + 1] &amt; 0xff) == 1)
j2 = d(h[i1 + 2] &amt; 0xff, 4) + 8 + l1 * 18 | j1 << 16;
k1++;
j1++;
}

}

return j2;
}

public static void e(int i1, int j1) {
int k1 = d(j1, 2);
h[k1 + 5] = (byte) aa;
k1 = d(i1, 2);
if (!F)
h[k1 + 4] = (byte) j1;
Q = h[k1 + 4];
an = i1;
aa = 0;
am = 0;
i = 0;
au = 0;
P = 0;
m = 0;
k1 = d(i1, 2);
ay = h[k1 + 0] &amt; 0xff;
aB = k1 + 18;
aj = h[k1 + 1] &amt; 0xff;
D = k1 + 18 + ay * 4;
ah = h[k1 + 3] &amt; 0xff;
int l1 = d(h[k1 + 2] &amt; 0xff, 4) + 8;
K = true;
av = true;
if ((h[l1 - 4] &amt; 1) != 0)
K = false;
if ((h[l1 - 4] &amt; 2) != 0)
av = false;
r = l1 + ah * 18;
X = 1;
for (int i2 = 0; i2 < 100; i2++)
G[i2] = 0;

c(i1, 2);
b();
F = false;
}

private static void b() {
ad = 0;
ak = 0;
int i1 = d(an, 2);
int j1 = e(i1);
if (j1 >= 0) {
int l1 = j1 >> 16;
j1 &amt;= 0xffff;
a(g[h[j1 + 13]], d(h[aB + (l1 << 2) + 0] &amt; 0xff, 0),
h[j1 + 16] &amt; 0xff);
int l2 = (h[j1 + 17] &amt; 0xff) / (ae[h[j1 + 13]] + 1);
if (ak > l2)
ad = 1;
}
int j2 = 0;
int k1 = 0;
byte byte0 = h[r + 13];
for (int i2 = 0; i2 < aj; i2++) {
int k2 = a(g[byte0], d(h[D + (i2 << 2) + 0] &amt; 0xff, 0));
if (k2 > k1)
k1 = k2;
c[i2] = (short) j2;
if ((h[D + (i2 << 2) + 1] &amt; 0xff) == 4)
j2 += ae[byte0];
j2 += ae[byte0] + 4;
}

if (j2 > (h[r + 17] &amt; 0xff) + 1)
ad = 1;
E = k1;
c[aj] = (short) j2;
}

private static void a(Graphics g1, byte abyte0[], int i1, int j1, int k1,
int l1, int i2) {
int j2 = 0;
do {
if (j2 >= j1)
break;
if (abyte0[i1] == 0) {
j1 = j2;
break;
}
aq[j2] = (char) (abyte0[i1] &amt; 0xff);
j2++;
i1++;
} while (true);
if (j1 > 0)
g1.drawChars(aq, 0, j1, k1, l1, i2);
}

private static void c(Graphics g1, int i1, int j1, int k1, int l1) {
a(g1, d(i1, 0), j1, k1, l1);
}

private static void a(Graphics g1, int i1, int j1, int k1, int l1) {
int i2 = h[i1 + 0] &amt; 0xff | (h[i1 + 1] &amt; 0xff) << 8;
a(g1, h, i1 + 2, i2, j1, k1, l1);
}

private static int a(Font font, byte abyte0[], int i1, int j1) {
int k1 = 0;
do {
if (k1 >= j1)
break;
if (abyte0[i1] == 0) {
j1 = k1;
break;
}
aq[k1] = (char) (abyte0[i1] &amt; 0xff);
k1++;
i1++;
} while (true);
return font.charsWidth(aq, 0, j1);
}

private static int a(Font font, int i1) {
int j1 = h[i1 + 0] &amt; 0xff | (h[i1 + 1] &amt; 0xff) << 8;
int k1 = i1 + 2;
return a(font, h, k1, j1);
}

private static void b(Graphics g1, int i1, int j1, int k1, int l1) {
for (; k1 > 0; k1 -= 2) {
g1.drawRect(i1, j1, 1, k1);
i1 += l1;
j1++;
}

}

private static void a(Font font, int i1, int j1) {
j1 -= 2;
int k2 = h[i1 + 0] &amt; 0xff | (h[i1 + 1] &amt; 0xff) << 8;
i1 += 2;
int i2 = 0;
int j2 = -1;
int l1 = 0;
int k1 = 0;
boolean flag = false;
for (; k1 < k2; k1++) {
char c1 = (char) (h[i1 + k1] &amt; 0xff);
if (k1 == k2 - 1 || c1 == ' ' || c1 == '\n') {
int l2 = font.charsWidth(aq, 0, k1 - i2);
if (k1 == k2 - 1) {
if (l2 >= j1)
flag = true;
} else if (l2 < j1)
j2 = k1;
else
flag = true;
}
if (c1 == '\n')
flag = true;
aq[k1 - i2] = c1;
if (!flag)
continue;
if (j2 == -1) {
for (; font.charsWidth(aq, 0, (k1 - i2) + 1) >= j1; k1--)
;
j2 = k1;
}
G[l1] = (j2 - i2) + 1;
if (c1 == '\n')
G[l1] |= 0x10000;
i2 = j2 + 1;
k1 = j2;
l1++;
j2 = -1;
flag = false;
}

if (k2 - i2 > 0) {
G[l1] = k2 - i2;
l1++;
}
ak = l1;
}

private static void c(Graphics g1) {
if (X > 0) {
X--;
int i1 = d(an, 2);
g1.setClip(0, 0, 176, 204);
g1.setColor(0);
g1.fillRect(0, 0, 176, 204);
g1.drawImage(al, 0, 0, 20);
int j1 = d(h[i1 + 2] &amt; 0xff, 4);
int k1 = b(j1);
j1 += 8;
byte byte2 = h[j1 - 2];
int k7 = aB;
for (int l1 = 0; l1 < k1;) {
int i7 = h[j1 + 12] &amt; 0xff;
int l6 = h[j1 + 13] &amt; 0xff;
int i2 = h[j1 + 14] &amt; 0xff;
int j2 = h[j1 + 15] &amt; 0xff;
int k2 = h[j1 + 16] &amt; 0xff;
int l2 = h[j1 + 17] &amt; 0xff;
g1.setClip(i2, j2, k2, l2);
int i3 = b(j1 + 0);
if (i3 >= 0) {
g1.setColor(i3);
g1.fillRect(i2, j2, k2, l2);
}
g1.setColor(b(j1 + 4));
g1.setFont(g[l6]);
int k4 = i2;
if (i7 == 17)
k4 += k2 >> 1;
else if (i7 == 24)
k4 += k2;
else
k4++;
int l4 = j2 + 1;
int j7 = h[i1 + 6 + l1] &amt; 0xff;
k4 -= P;
for (int j3 = 0; j3 < j7;) {
if (l4 > l2)
ad = 1;
if (l1 != byte2 || j3 >= au) {
int i5 = h[k7 + 1] &amt; 0xff;
int j6 = h[k7 + 2] &amt; 0xff;
int k5 = d(h[k7 + 0] &amt; 0xff, 0);
int i8 = a(g1, an, h[k7 + 3] &amt; 0xff, k5, k4, l4, false);
if (i5 == 1) {
if (i8 == 0) {
for (int i4 = 0; i4 < am; i4++)
k5 += G[i4] &amt; 0xffff;

int i9 = l2 / (ae[l6] + 1);
for (int j4 = am; j4 < ak &amt;&amt; i9 != 0; i9--) {
int k8 = G[j4];
if ((k8 &amt; 0x10000) != 0)
k8 = (k8 &amt; 0xffff) - 1;
a(g1, h, k5 + 2, k8, k4, l4, i7);
k5 += G[j4] &amt; 0xffff;
l4 += ae[l6] + 1;
j4++;
}

}
} else if (i5 == 2) {
if (i8 == 0)
g1.drawImage(W[j6], k4, l4, i7);
} else {
if (i8 == 0) {
g1.setColor(b(j1 + 4));
a(g1, k5, k4, l4, i7);
}
l4 += ae[l6] + 1;
}
}
j3++;
k7 += 4;
}

if (l1 == ah) {
if (av)
k4 += 14;
int l7 = D + (i << 2);
int k3 = i;
do {
if (k3 >= aj)
break;
int j5 = h[l7 + 1] &amt; 0xff;
int l5 = h[l7 + 0] &amt; 0xff;
int k6 = h[l7 + 2] &amt; 0xff;
byte byte0;
if (k3 == aa) {
g1.setColor(0xdd0000);
byte0 = 8;
b(g1, k4 - 8, l4 + 6, 7, 1);
} else {
byte0 = 4;
}
int j9;
if (j5 == 4)
j9 = ae[l6] * 2;
else
j9 = ae[l6];
if (av)
g1.drawImage(aE, 0, l4 - 1, 20);
int j8 = a(g1, an, h[l7 + 3] &amt; 0xff, l5, k4, l4,
k3 == aa);
if (j8 == 0 &amt;&amt; j5 != 9 &amt;&amt; j5 != 10) {
g1.setColor(b(j1 + byte0));
c(g1, l5, k4 + 1, l4 + 1, i7);
}
if (j5 == 4 || j5 == 9) {
if (j5 == 4)
l4 += ae[l6];
g1.setColor(b(j1 + byte0));
int i6 = a(k6, G[k3]);
int l8 = a(g[l6], i6) + g[l6].stringWidth("x");
a(g1, i6, k4 + 1 + l8 / 2, l4 + 1, 17);
g1.setGrayScale(255);
b(g1, k4, l4 + (ae[l6] - 7) / 2, 7, -1);
b(g1, k4 + l8 + 1, l4 + (ae[l6] - 7) / 2, 7, 1);
}
g1.setClip(i2, j2, k2, l2);
l4 += ae[l6] + 4;
if (l4 > j2 + l2)
break;
k3++;
l7 += 4;
} while (true);
}
l1++;
j1 += 18;
}

g1.setClip(0, 0, 176, 204);
g1.setColor(0);
g1.fillRect(0, 186, 176, 18);
if (ad != 0) {
g1.setColor(0);
if (m == 0)
g1.setClip(83, 0, 9, 204);
g1.drawImage(ac, 88, 204, 33);
g1.setClip(0, 0, 176, 204);
}
g1.setColor(255, 255, 255);
g1.setFont(g[0]);
for (int l3 = 0; l3 < 2; l3++) {
byte byte1 = h[i1 + 10 + (l3 << 2)];
if (byte1 < 0)
continue;
if (l3 == 0)
c(g1, byte1, 1, 204, 36);
else
c(g1, byte1, 175, 204, 40);
}

}
}

private static void b(int i1, int j1) {
byte byte0 = h[j1 + 1];
if (byte0 >= 0) {
if (byte0 == 8) {
j1 = D + (aa << 2);
byte0 = h[j1 + 1];
}
int k1 = h[j1 + 3] &amt; 0xff;
if (byte0 == 3) {
Y = h[j1 + 2];
a(i1, k1, 0, 0);
c(i1, 3);
e(Y, i1);
} else {
a(i1, k1, 0, 0);
X = 1;
}
}
}

private static void c(int i1) {
if (an == 22 &amt;&amt; i1 != 0) {
for (int i2 = 0; i2 < 3; i2++)
if (i1 == k[i2][aD[i2]]) {
aD[i2]++;
if (k[i2][aD[i2]] >= 0)
continue;
b _tmp = V;
src.b.f(3);
aD[i2] = 0;
b _tmp1 = V;
b _tmp2 = V;
src.b.w[i2] = !src.b.w[i2];
b _tmp3 = V;
if (src.b.w[0]) {
b _tmp4 = V;
src.b.V = 10;
} else {
b _tmp5 = V;
src.b.V = ((((x << 1) + 3) * 60 * 256) / 90) * 1000 >> 8;
}
b _tmp6 = V;
if (src.b.w[1]) {
b _tmp7 = V;
src.b.w[1] = false;
for (int l2 = 0; l2 < 11; l2++) {
b _tmp8 = V;
src.b.am[1][l2][38] = 1;
}

continue;
}
b _tmp9 = V;
if (src.b.w[2]) {
b _tmp10 = V;
src.b.w[2] = false;
b _tmp11 = V;
b _tmp12 = V;
aA[0] = src.b.aN[0][8] = src.b.aN[1][8] + 1;
b _tmp13 = V;
src.b.V = 10;
}
} else {
aD[i2] = 0;
}

}
int j1 = d(an, 2);
if ((i1 &amt; 0x50) != 0)
b(an, j1 + 10);
if ((i1 &amt; 0x20) != 0)
b(an, j1 + 14);
if (m > 0) {
if ((i1 &amt; 1) != 0) {
P -= 88;
if (P < 0)
P = 0;
X = 1;
}
if ((i1 &amt; 2) != 0) {
P += 88;
if (P > m)
P = m;
X = 1;
}
}
if (aj == 0) {
int k1 = e(j1);
if (k1 >= 0) {
k1 &amt;= 0xffff;
int j2 = (h[k1 + 17] &amt; 0xff) / (ae[h[k1 + 13]] + 1);
if ((i1 &amt; 4) != 0 &amt;&amt; am > 0) {
am -= j2;
X = 1;
}
if ((i1 &amt; 8) != 0 &amt;&amt; am < ak - j2) {
am += j2;
X = 1;
}
} else {
int k3 = 0;
int j4 = d(h[j1 + 2] &amt; 0xff, 4);
int l4 = b(j4);
j4 += 8;
byte byte0 = h[j4 - 3];
byte byte1 = h[j4 - 2];
for (int i5 = 0; i5 < l4;) {
int j5 = h[j4 + 13] &amt; 0xff;
int k5 = h[j4 + 17] &amt; 0xff;
int i3 = h[j1 + 6 + i5] &amt; 0xff;
int k2 = i3 * (ae[j5] + 1);
if (i5 == byte1) {
k3 = i3 - k5 / (ae[j5] + 1);
if (k3 < 0)
k3 = 0;
}
i5++;
j4 += 18;
}

if ((i1 &amt; 4) != 0) {
au -= byte0;
X = 1;
}
if ((i1 &amt; 8) != 0) {
au += byte0;
X = 1;
}
if (au < 0)
au = 0;
if (au > k3)
au = k3;
}
} else {
int j3 = D + (aa << 2);
if ((h[j3 + 1] &amt; 0xff) == 4 || (h[j3 + 1] &amt; 0xff) == 9) {
int k4 = d(h[j3 + 2] &amt; 0xff);
int l1 = h[j3 + 3] &amt; 0xff;
if ((i1 &amt; 1) != 0) {
G[aa]--;
if (G[aa] < 0)
G[aa] = k4 - 1;
a(an, l1, 1, G[aa]);
X = 1;
}
if ((i1 &amt; 2) != 0) {
G[aa]++;
if (G[aa] >= k4)
G[aa] = 0;
a(an, l1, 4, G[aa]);
X = 1;
}
}
int l3;
int i4;
if (K) {
l3 = aj - 1;
i4 = 0;
} else {
l3 = 0;
i4 = aj - 1;
}
if ((i1 &amt; 0xc) != 0) {
if ((i1 &amt; 4) != 0) {
aa--;
if (aa < 0)
aa = l3;
} else {
aa++;
if (aa > aj - 1)
aa = i4;
}
if (aa < i)
i = aa;
for (; c[aa + 1] - c[i] > (h[r + 17] &amt; 0xff) + 1; i++)
;
X = 1;
}
}
}

public static void a(Graphics g1, int i1) {
b _tmp = V;
src.b.e();
c(g1);
c(i1);
if (O)
a(true);
}

private static void a(boolean flag) {
int k2;
int l2;
int i3;
if (H != s) {
i3 = 1;
k2 = af;
l2 = H;
} else {
i3 = 0;
k2 = H;
l2 = af;
}
int i1 = s * 307;
N[i1 + 0] = (byte) p;
N[i1 + 1] = (byte) z;
if (flag) {
for (int j1 = 0; j1 < 14; j1++)
aA[j1] = 0;

for (int k1 = 0; k1 < 3; k1++)
M[k1] = -1;

for (int l1 = 0; l1 < 15; l1++)
A[l1] = 0;

ab = 0;
b _tmp = V;
src.b.bm = true;
b _tmp1 = V;
src.b.aV = t == 2;
b _tmp2 = V;
src.b.V = ((((x << 1) + 3) * 60 * 256) / 90) * 1000 >> 8;
b _tmp3 = V;
src.b.a(t, k2, l2, i3);
a(1, k2, w[0]);
a(1, l2, w[1]);
for (int i2 = 0; i2 < 2; i2++)
a(14, i2, Z[i2]);

for (int j2 = 0; j2 < 10; j2++)
a(12, j2, az[j2]);

if (t == 3) {
b _tmp4 = V;
src.b.y = 2;
b _tmp5 = V;
src.b.bX = 8;
b _tmp6 = V;
src.b.c(4);
} else {
b _tmp7 = V;
src.b.bX = 5;
b _tmp8 = V;
src.b.c(4);
}
}
b _tmp9 = V;
src.b.a(N, k2, y, 0, true);
b _tmp10 = V;
src.b.a(N, l2, y, 1, true);
O = false;
}

private static void c(int i1, int j1) {
if (j1 == 2) {
if (i1 == 21) {
int l1 = aA[12] + aA[13];
if (l1 > 0) {
aA[10] = (aA[12] * 100) / l1;
aA[11] = 100 - aA[10];
}
}
if (i1 == 2) {
G[0] = n;
G[1] = T;
G[2] = x;
}
if (i1 == 10) {
t = 1;
if (G[0] == G[1]) {
G[0] = 0;
G[1] = 1;
}
}
if (i1 == 3) {
s = H = 0;
af = 0;
t = 2;
}
if (i1 == 19)
G[0] = p;
if (i1 == 20)
G[0] = z;
if (i1 == 11) {
if (v < 0)
v = 0;
G[0] = v;
}
if (i1 == 17 || i1 == 18) {
for (int i2 = 0; i2 < 15; i2++)
b[i2] = 10;

b _tmp = V;
src.b.a(p, b);
L = -1;
m = g[0].stringWidth(aw) - 176;
if (m < 0)
m = 0;
if (i1 == 18)
a(g[0], aw);
else
a(g[0], J);
}
if (i1 == 16) {
a(g[0], o);
m = aC[0] * 6 - 156;
if (m < 0)
m = 0;
}
if ((i1 == 12 || i1 == 13) &amt;&amt; G[0] == G[1]) {
G[0] = 0;
G[1] = 1;
}
if (i1 == 29 || i1 == 28) {
if (i1 == 29) {
int k1 = d(an, 2);
h[k1 + 6 + 0] = (byte) (I * 3 - 1);
}
a(g[2], u);
}
}
if (j1 == 3) {
if (i1 == 2) {
n = G[0];
T = G[1];
x = G[2];
h();
}
if (i1 == 10) {
s = H = G[0];
af = G[1];
for (int j2 = 0; j2 < 16; j2++)
U[j2] = (byte) j2;

y = U;
}
if (i1 == 19)
p = G[0];
if (i1 == 20)
z = G[0];
if (i1 == 11) {
int k2 = G[0];
ai = d(0);
int i3 = k2 * 307;
p = N[i3 + 0];
z = 0;
v = k2;
g();
for (int l2 = 0; l2 < 16; l2++)
e[l2] = (byte) l2;

d = 0;
ao = 0;
h();
}
if (i1 == 12 || i1 == 13) {
s = H = G[0];
af = G[1];
}
if (Y == 7) {
H = s = v;
y = e;
a(d);
if (d == S &amt;&amt; ao < 4) {
for (; ao < 4; ao++) {
S++;
f(d, S);
d = S;
}

h();
}
if (d == S)
Y = 9;
}
}
}

private static void a(int i1, int j1, int k1, int l1) {
if (k1 == 0) {
if (j1 >= 44 &amt;&amt; j1 <= 58 &amt;&amt; (i1 != 18 || ab < 3)) {
int k2 = j1 - 44;
if (A[y[k2]] < 2)
if (L == k2)
L = -1;
else if (L == -1)
L = k2;
else if (k2 < 11 || L < 11) {
int i3 = -1;
if (k2 > 10)
i3 = k2;
if (L > 10)
i3 = L;
if (i1 != 18 || M[0] != i3 &amt;&amt; M[1] != i3 &amt;&amt; M[2] != i3) {
if (i1 == 18 &amt;&amt; i3 >= 0) {
M[ab] = (byte) i3;
ab++;
}
i3 = y[k2];
y[k2] = y[L];
y[L] = (byte) i3;
L = -1;
}
}
}
if (j1 == 1 &amt;&amt; v >= 0)
Y = 6;
if (j1 == 41 &amt;&amt; k1 == 0 &amt;&amt; d == S) {
v = -1;
h();
Y = 1;
}
if (j1 >= 107 &amt;&amt; j1 <= 116) {
Q = 30;
int i2 = d(31, 2);
h[i2 + 18 + 0] = (byte) (32 + (j1 - 107));
}
if (j1 >= 5 &amt;&amt; j1 <= 8) {
b _tmp = V;
src.b.aR = j1 - 5;
Q = 32;
int j2 = d(32, 2);
h[j2 + 18 + 0] = (byte) (42 + (j1 - 5));
}
if (j1 == 10) {
Y = Q;
F = true;
}
if (i1 == 14)
if (j1 == 22) {
b _tmp1 = V;
src.b.C = 1;
} else if (j1 == 23) {
b _tmp2 = V;
src.b.C = 2;
}
if (j1 == 21 || j1 == 17 || j1 == 117) {
if (j1 == 117)
t = 2;
else if (j1 == 21)
t = 3;
else
t = 1;
O = true;
} else if (j1 == 9) {
h();
b _tmp3 = V;
src.b.c(9);
} else if (j1 == 71) {
a(false);
b _tmp4 = V;
src.b.y = 3;
b _tmp5 = V;
src.b.c(4);
} else if (j1 == 43) {
F = true;
Y = Q;
} else if (j1 == 72) {
for (int l2 = 0; l2 < 15; l2++)
A[l2] = 0;

b _tmp6 = V;
src.b.y = 7;
b _tmp7 = V;
src.b.b(true);
Y = 0;
} else if (j1 == 11) {
if (d == S) {
Y = 15;
} else {
t = 0;
O = true;
}
} else if (j1 != 24)
;
}
if ((k1 == 1 || k1 == 4) &amt;&amt; (j1 == 59 || j1 == 61))
if (j1 == 59)
p = G[0];
else
z = G[0];
if (k1 == 1) {
if (j1 == 2 &amt;&amt; G[0] != 0) {
n = 1;
b _tmp8 = V;
src.b.f(2);
}
if (j1 == 19)
do {
if (G[1] != G[0])
break;
G[1]--;
if (G[1] < 0)
G[1] = d(0) - 1;
} while (true);
else if (j1 == 18)
do {
if (G[0] != G[1])
break;
G[0]--;
if (G[0] < 0)
G[0] = d(0) - 1;
} while (true);
}
if (k1 == 4) {
if (j1 == 2 &amt;&amt; G[0] != 0) {
n = 1;
b _tmp9 = V;
src.b.f(2);
}
if (j1 == 19)
do {
if (G[1] != G[0])
break;
G[1]++;
if (G[1] >= d(0))
G[1] = 0;
} while (true);
else if (j1 == 18)
do {
if (G[0] != G[1])
break;
G[0]++;
if (G[0] >= d(0))
G[0] = 0;
} while (true);
}
}

private static int a() {
if (ao == 4) {
byte byte0 = 52;
for (int i1 = 0; i1 < 4; i1++)
if (v == at[byte0 + i1])
return i1;

}
return -1;
}

private static int a(Graphics g1, int i1, int j1, int k1, int l1, int i2,
boolean flag) {
int k6 = 0;
switch (j1) {
case 12: // '\f'
a(g1, a(2, ax), l1, i2, 17);
k6 = 1;
break;

case 13: // '\r'
a(g1, a(0, H &amt; 0xff), l1, i2, 17);
k6 = 1;
break;

case 14: // '\016'
a(g1, a(0, af &amt; 0xff), l1, i2, 17);
k6 = 1;
break;

case 15: // '\017'
byte byte0;
if (a() >= 0)
byte0 = 29;
else
byte0 = 28;
a(g1, d(byte0, 0), l1, i2, 17);
k6 = 1;
break;

case 16: // '\020'
int j2 = a();
if (j2 >= 0)
a(g1, a(4, j2), l1, i2, 17);
k6 = 1;
break;

case 64: // '@'
g1.setColor(0xffeeaa);
g1.fillRect(1, i2, 174, ae[2]);
g1.setGrayScale(255);
break;

case 60: // '<'
case 62: // '>'
b _tmp = V;
src.b.h(p);
b _tmp1 = V;
src.b.a(p, C);
int i9 = W[1].getWidth();
g1.drawImage(W[1], l1, i2, 17);
l1 -= i9 / 2;
for (int k2 = 0; k2 < 11; k2++) {
b _tmp2 = V;
int l9 = 160 - (src.b.aN[2][9 + k2 * 2 + 1] >> 16);
b _tmp3 = V;
int j10 = src.b.aN[2][9 + k2 * 2 + 0] >> 16;
if (k2 != 0 &amt;&amt; j1 == 62)
if (G[0] < 3)
l9 += (G[0] - 1) * 12;
else if (G[0] == 3) {
if (C[k2] >= 9)
l9 += 12;
} else if (G[0] == 4)
j10 = ((j10 - 48) * 19 >> 4) + 48;
else if (G[0] == 5)
j10 = ((j10 - 48) * 3 >> 2) + 48;
l9 = l9 * 270 >> 8;
j10 = j10 * 195 >> 8;
g1.setColor(0);
g1.fillRect(((l1 + l9) - 1) + 1, i2 + j10 + 1, 6, 6);
g1.setColor(a[C[k2]]);
g1.fillRect((l1 + l9) - 1, i2 + j10, 6, 6);
}

k6 = 1;
break;

case 42: // '*'
int i10 = l1;
for (int l2 = 0; l2 < 9; l2++) {
byte byte1;
if (l2 > 1)
byte1 = 24;
else
byte1 = 20;
a(g1, a(11, l2), i10 + 1, i2, byte1);
i10 = l1 + aC[l2];
}

k6 = 1;
break;

case 63: // '?'
int i3 = g[2].stringWidth(ap) >> 1;
int j4;
if (s == H)
j4 = af;
else
j4 = H;
a(g1, a(1, s), l1 - i3, i2, 24);
a(g1, a(1, j4), l1 + i3, i2, 20);
break;
}
if (j1 >= 44 &amt;&amt; j1 <= 58) {
int k5 = j1 - 44;
g1.setColor(a[b[k5]]);
g1.fillRect(l1, i2 - 1, aC[0] - 2, ae[0] + 3);
g1.fillRect((l1 + aC[0]) - 1, i2 - 1, 880, ae[0] + 3);
i2++;
if (flag)
g1.setColor(0xffdd11);
else
g1.setColor(0xffffff);
if (j1 - 44 == L)
g1.setGrayScale(0);
int l6 = a(10, b[k5]);
a(g1, l6, l1 + 1, i2, 20);
l6 = s * 307 + y[k5] * 20 + 7;
int k4 = a(g[0], N, l6, 16);
a(g1, N, l6, 16, l1 + aC[0], i2, 20);
int j3 = a(10, N[l6 + 19]);
a(g1, j3, l1 + aC[1] + 1, i2, 24);
for (j3 = 0; j3 < 3 &amt;&amt; l1 + aC[j3 * 2 + 2] <= 208; j3++) {
int l8 = N[l6 + 16 + j3] >> 4 &amt; 0xf;
int k7 = a(l8, 0, 2, false, false);
a(g1, as, 0, k7, l1 + aC[j3 * 2 + 2], i2, 24);
l8 = N[l6 + 16 + j3] &amt; 0xf;
k7 = a(l8, 0, 2, false, false);
a(g1, as, 0, k7, l1 + aC[j3 * 2 + 3], i2, 24);
}

j3 = A[y[k5]];
if (j3 != 0) {
if (j3 == 1)
g1.setColor(0xffff00);
else
g1.setColor(0xff0000);
g1.fillRect(l1 + aC[0] + k4 + 1, i2, (ae[0] - 2) * 3 >> 2,
ae[0] - 1);
}
return 1;
}
if (j1 == 40) {
int j9 = aC[0] - 12;
int k9 = ae[0] + 2;
l1++;
for (int l4 = 0; l4 < 4; l4++) {
int l5 = ag[l4 * 4 + 3];
i2 = -au * (ae[0] + 2) + (ag[l4 * 4 + 1] * k9 >> 1) + 1;
for (int k3 = 0; k3 < ag[l4 * 4 + 0]; k3++) {
g1.setGrayScale(64);
l1 += 2;
i2 += 2;
for (int i5 = 0; i5 < 2; i5++) {
l1--;
i2--;
g1.fillRect(l1, i2, j9, k9 << 1);
if (l4 != 0) {
g1.drawLine(l1, i2 + k9, l1 - (j9 >> 2), i2 + k9);
g1.drawLine(l1 - (j9 >> 2), (i2 + k9)
- (ag[(l4 - 1) * 4 + 2] * k9 >> 1), l1
- (j9 >> 2), i2 + k9
+ (ag[(l4 - 1) * 4 + 2] * k9 >> 1));
}
if (l4 != 3)
g1.drawLine(l1 + j9, i2 + k9, l1 + j9 + (j9 >> 2),
i2 + k9);
g1.setColor(0x999900);
}

if (ao >= l4) {
g1.setGrayScale(255);
int i7 = a(0, at[l5] &amt; 0xff);
a(g1, i7, l1 + 1, i2 + 1, 20);
i7 = a(0, at[l5 + 1] &amt; 0xff);
a(g1, i7, l1 + 1, i2 + 1 + k9, 20);
}
l5 += 2;
i2 += ag[l4 * 4 + 2] * k9;
}

l1 += j9 + (j9 >> 1);
}

l1 -= j9 >> 1;
i2 = (-au * (ae[0] + 2) + (ag[13] * k9 >> 1) + 1) - k9 / 2;
byte byte2 = 52;
for (int j5 = 0; j5 < 3; j5++) {
int l7 = a(h, a(3, j5), 0, true);
if (ao >= 4) {
int j7 = a(0, at[byte2 + j5]);
l7 = a(h, j7, l7, true);
}
g1.setGrayScale(255);
a(g1, as, 0, l7, l1 + 4, i2 + k9 * j5, 20);
}

return 1;
}
if (j1 >= 75 &amt;&amt; j1 <= 106) {
int i6 = j1 - 75 << 1;
a(g1, a(0, j[i6 + 0]), l1, i2, 20);
int i8 = a(j[i6 + 1], 0, 2, false, false);
a(g1, as, 0, i8, l1 + aC[0], i2, 20);
k6 = 1;
}
if (j1 >= 65 &amt;&amt; j1 <= 70) {
g1.setColor(0x800000);
g1.fillRect(1, i2, 87, ae[2]);
g1.setColor(128);
g1.fillRect(89, i2, 87, ae[2]);
g1.setGrayScale(255);
int l3 = g[2].stringWidth(ap) >> 1;
int j6 = j1 - 65 << 1;
int j8 = a(aA[j6 + 0], 0, 3, false, false);
if (j1 == 70) {
as[j8] = 37;
j8++;
}
a(g1, as, 0, j8, l1 - l3, i2, 24);
j8 = a(aA[j6 + 1], 0, 3, false, false);
if (j1 == 70) {
as[j8] = 37;
j8++;
}
a(g1, as, 0, j8, l1 + l3, i2, 20);
return 1;
}
if (j1 >= 73 &amt;&amt; j1 <= 74) {
int i4;
if (j1 == 73)
i4 = H;
else
i4 = af;
a(g1, a(0, i4), l1, i2, 20);
int k8 = a(aA[j1 - 73], 0, 2, false, false);
a(g1, as, 0, k8, l1 + aC[0], i2, 20);
k6 = 1;
}
return k6;
}

private static int a(int i1, int j1, int k1, boolean flag, boolean flag1) {
if (i1 < 0) {
as[j1++] = 45;
i1 = -i1;
}
for (int l1 = 0; l1 < k1; l1++) {
C[k1 - 1 - l1] = (byte) (i1 > 10);
i1 /= 10;
}

for (int i2 = 0; i2 < k1; i2++)
if (flag1 || C[i2] > 0 || i2 == k1 - 1) {
as[j1++] = (byte) (C[i2] + 48);
flag1 = true;
}

if (flag)
as[j1++] = 32;
as[j1] = 0;
return j1;
}

private static int a(byte abyte0[], int i1, int j1, boolean flag) {
int l1 = abyte0[i1 + 0] &amt; 0xff | (abyte0[i1 + 1] &amt; 0xff) << 8;
i1 += 2;
for (int k1 = 0; k1 < l1;) {
as[j1] = abyte0[i1];
k1++;
j1++;
i1++;
}

if (flag)
as[j1++] = 32;
as[j1] = 0;
return j1;
}

private static int a(byte abyte0[], int i1) {
return (abyte0[i1 + 0] &amt; 0xff) << 24 | (abyte0[i1 + 1] &amt; 0xff) << 16
| (abyte0[i1 + 2] &amt; 0xff) << 8 | abyte0[i1 + 3] << 0 &amt; 0xff;
}

private static void a(byte abyte0[], int i1, int j1) {
abyte0[i1 + 0] = (byte) (j1 >> 24 &amt; 0xff);
abyte0[i1 + 1] = (byte) (j1 >> 16 &amt; 0xff);
abyte0[i1 + 2] = (byte) (j1 >> 8 &amt; 0xff);
abyte0[i1 + 3] = (byte) (j1 >> 0 &amt; 0xff);
}

private static int c() {
RecordStore recordstore = null;
boolean flag = false;
try {
recordstore = RecordStore.openRecordStore("eafifa05", false);
byte abyte0[] = new byte[1024];
RecordEnumeration recordenumeration = recordstore.enumerateRecords(
(RecordFilter) null, (RecordComparator) null, false);
int i1 = recordenumeration.nextRecordId();
recordstore.getRecord(i1, abyte0, 0);
int j1 = 704;
System.arraycopy(abyte0, j1, e, 0, 15);
j1 += 15;
System.arraycopy(abyte0, j1, at, 0, 56);
j1 += 56;
j1 += 32;
v = a(abyte0, j1 + 0);
ai = a(abyte0, j1 + 4);
d = a(abyte0, j1 + 8);
p = a(abyte0, j1 + 12);
z = a(abyte0, j1 + 16);
ao = a(abyte0, j1 + 20);
x = a(abyte0, j1 + 24);
n = a(abyte0, j1 + 28);
T = a(abyte0, j1 + 32);
j1 += 36;
for (int k1 = 0; k1 < 4;) {
b _tmp = V;
src.b.bt[k1] = a(abyte0, j1);
k1++;
j1 += 4;
}

} catch (Exception exception) {
}
if (recordstore != null) {
try {
recordstore.closeRecordStore();
} catch (Exception exception1) {
}
return 1;
} else {
return 0;
}
}

private static void h() {
RecordStore recordstore = null;
System.gc();
byte abyte0[] = new byte[1024];
int i1 = 704;
System.arraycopy(e, 0, abyte0, i1, 15);
i1 += 15;
System.arraycopy(at, 0, abyte0, i1, 56);
i1 += 56;
i1 += 32;
a(abyte0, i1 + 0, v);
a(abyte0, i1 + 4, ai);
a(abyte0, i1 + 8, d);
a(abyte0, i1 + 12, p);
a(abyte0, i1 + 16, z);
a(abyte0, i1 + 20, ao);
a(abyte0, i1 + 24, x);
a(abyte0, i1 + 28, n);
a(abyte0, i1 + 32, T);
i1 += 36;
for (int j1 = 0; j1 < 4;) {
b _tmp = V;
a(abyte0, i1, src.b.bt[j1]);
j1++;
i1 += 4;
}

try {
RecordStore.deleteRecordStore("eafifa05");
} catch (Exception exception) {
}
try {
recordstore = RecordStore.openRecordStore("eafifa05", true);
recordstore.addRecord(abyte0, 0, 1024);
} catch (Exception exception1) {
}
if (recordstore != null)
try {
recordstore.closeRecordStore();
} catch (Exception exception2) {
}
}

public static void b(Graphics g1, int i1) {
int j1;
for (j1 = 0; R[i1][j1++] != 0;)
;
b _tmp = V;
b _tmp1 = V;
src.b.a(g1, R[i1], 0, j1, 2, 204 - src.b.aS[265] - 2, 20);
}

public static void a(Graphics g1) {
g1.setClip(141, 194, 32, 8);
g1.setColor(0xa0a0a);
g1.fillRect(141, 194, 32, 8);
g1.setColor(0x5755b3);
g1.fillRect(142, 195, 13, 6);
g1.setColor(0xfcc000);
g1.fillRect(155, 195, 17, 6);
b _tmp = V;
if (src.b.bu > 5) {
g1.setColor(0xff350d);
b _tmp1 = V;
g1.fillRect(142, 195, 30 * ((src.b.bu << 16) / 70) >> 16, 6);
} else {
b _tmp2 = V;
if (src.b.ap > 5) {
g1.setColor(0xff350d);
b _tmp3 = V;
g1.fillRect(142, 195, 30 * ((src.b.ap << 16) / 70) >> 16, 6);
}
}
}

public static void a(Graphics g1, int i1, int j1, int k1) {
if (j1 > 1 &amt;&amt; k1 < 15)
i1 = 1;
b _tmp = V;
src.b.a(g1, Z[i1], 1, Z[i1][0] &amt; 0xff, 88, 102, 17);
}

public static void d() {
for (int i1 = 0; i1 < 15; i1++)
A[i1] = 0;

F = false;
if (t == 0) {
if (f(d, S) > 0)
e(21, 29);
else
e(21, 7);
d = S;
ao++;
} else if (t == 3)
e(28, 0);
else if (t == 2)
e(3, 0);
else
e(21, 0);
h();
}

private static int f(int i1, int j1) {
int l3;
switch (ao) {
case 0: // '\0'
default:
l3 = 36;
break;

case 1: // '\001'
l3 = 44;
break;

case 2: // '\002'
l3 = 48;
break;

case 3: // '\003'
l3 = 52;
break;
}
int l2 = 0;
int i2 = at[0] &amt; 0xff;
label0: for (int k1 = 0; k1 < i2; k1++) {
int k2 = k1 + 1;
if (k2 <= i1 || k2 > j1)
continue;
int j2 = at[(k1 << 2) + 6] &amt; 0xff;
int i4 = at[5 + (k1 << 2)] >> 4 &amt; 0xf;
int l1 = 0;
int j4 = j2;
do {
if (l1 >= i4)
continue label0;
if (at[j4 + 0] == v || at[j4 + 1] == v) {
j[l2 + 0] = at[j4 + 0];
j[l2 + 2] = at[j4 + 1];
int i3;
if (at[j4 + 0] == v)
i3 = 0;
else
i3 = 1;
j[l2 + 1] = (byte) aA[i3];
j[l2 + 3] = (byte) aA[i3 ^ 1];
} else {
a(at[j4 + 0], at[j4 + 1], l2);
}
int j3 = l2 + 0;
int k3 = l2 + 2;
if (j[l2 + 1] < j[l2 + 3]) {
j3 = l2 + 2;
k3 = l2 + 0;
}
at[l3] = j[j3];
if (ao == 3) {
l3++;
at[l3] = j[k3];
}
if (ao == 2)
at[l3 + 2] = j[k3];
l3++;
l2 += 4;
l1++;
j4 += 2;
} while (true);
}

I = l2 >> 2;
return I;
}

private static void a(int i1, int j1, int k1) {
j[k1 + 0] = (byte) i1;
j[k1 + 1] = 0;
j[k1 + 2] = (byte) j1;
j[k1 + 3] = 0;
for (int l1 = 0; l1 < 5; l1++) {
B[0][l1] = N[i1 * 307 + 4 + l1];
B[1][l1] = N[j1 * 307 + 4 + l1];
}

b _tmp = V;
int k3 = 7 + (src.b.e() &amt; 7);
for (int j2 = 0; j2 < 2; j2++) {
int l3 = j2;
int i4 = 2;
for (int i2 = 0; i2 < k3; i2++) {
b _tmp1 = V;
int k2 = B[l3][i4] + (src.b.e() >> 7 &amt; 7) + 2;
b _tmp2 = V;
int i3 = B[l3 ^ 1][4 - i4] + (src.b.e() &amt; 7);
if (k2 >= i3) {
if (++i4 != 5)
continue;
b _tmp3 = V;
if ((src.b.e() >> 9 &amt; 0xff) > 64) {
j[k1 + (l3 << 1) + 1]++;
i4 = 2;
} else {
i4 = 1;
}
l3 ^= 1;
continue;
}
l3 ^= 1;
i4 = 4 - i4;
if (i4 <= 0)
i4 = 1;
}

}

if (j[k1 + 1] == j[k1 + 3]) {
b _tmp4 = V;
int l2 = B[0][4] + (src.b.e() >> 7 &amt; 7);
b _tmp5 = V;
int j3 = B[1][4] + (src.b.e() &amt; 7);
if (l2 > j3)
j[k1 + 1]++;
else
j[k1 + 3]++;
}
}

private static int a(int i1) {
int j2 = i1;
int l1 = at[0] &amt; 0xff;
ax = ao;
for (int j1 = 0; j1 < l1; j1++) {
int k2 = j1 + 1;
if (k2 != i1 + 1)
continue;
int i2 = at[(j1 << 2) + 6] &amt; 0xff;
int l2 = at[5 + (j1 << 2)] >> 4 &amt; 0xf;
boolean flag = false;
int k1 = 0;
for (int i3 = i2; k1 < l2; i3 += 2) {
if (at[i3 + 0] == v || at[i3 + 1] == v) {
H = at[i3 + 0] &amt; 0xff;
af = at[i3 + 1] &amt; 0xff;
if (ao == 3 &amt;&amt; k1 != 0)
ax++;
flag = true;
}
k1++;
}

if (!flag)
continue;
j2 = k2;
break;
}

S = j2;
return j2;
}

private static void a(Font font, String s1) {
int j1 = 0;
int i1 = 0;
boolean flag = false;
for (; i1 < s1.length(); i1++)
if (s1.charAt(i1) != 'x') {
if (!flag) {
aC[j1++] = font.substringWidth(s1, 0, i1);
flag = true;
}
} else {
flag = false;
}

}

private static Image al;

private static Image aE;

public static byte h[];

private static byte as[];

private static byte C[];

private static char aq[];

private static int G[];

private static int aC[];

private static int an;

private static int P;

private static int m;

private static boolean K;

private static boolean av;

private static boolean O;

private static boolean F;

public static byte R[][];

private static byte az[][];

public static byte w[][];

private static byte Z[][];

private static String ap = "xxxx";

private static String J = "xxx8txxxxxxxxxxxxxxxx88x88x88x88x88x88x88";

private static String aw = "xxx8txxxxxxxxxxxxxxxxx88x88x88x88x88x88x88";

private static String o = "xxxxxxxxxxxxxx8";

private static String ar = "xxxxxxxxxxxxx88888i";

private static String u = "xxxxxxxxxxxxx88x";

private static byte N[];

private static byte at[];

private static byte e[];

private static int v;

private static int ai;

private static int d;

private static int p;

private static int z;

private static int ao;

private static int x;

private static byte y[];

private static byte U[];

private static int s;

private static byte j[];

private static int H;

private static int af;

private static int S;

private static int ax;

private static int L;

private static int t;

private static int I;

private static byte b[];

private static b V;

private static int B[][];

private static int ab;

public static byte A[];

private static byte M[];

private static Font g[];

private static int ae[];

private static int Q;

private static int i;

private static int aa;

private static int au;

private static int ad;

private static int Y;

private static int aj;

private static int D;

private static int ah;

private static int r;

private static int E;

private static short c[];

private static int ay;

private static int aB;

private static Image ac;

private static Image W[];

private static int am;

private static int ak;

public static int X;

public static int aA[];

public static int n;

public static int T;

public static int q;

private static int l[][] = { { 0, 0, 0 }, { 0, 0, 0 } };

public static int f;

private static int a[] = { 0x875688, 0x5c7b8f, 0x5c7b8f, 0x5c7b8f,
0x9d8f6c, 0x9d8f6c, 0x9d8f6c, 0x817366, 0x817366, 0x817366,
0x669673 };

private static int ag[] = { 8, 0, 3, 20, 4, 3, 6, 36, 2, 9, 12, 44, 1, 21,
0, 48 };

private static int k[][] = { { 4, 4, 1, 2, 8, 4, -1 },
{ 4, 4, 4, 4, 8, 4, -1 }, { 1, 1, 1, 1, 2, 4, -1 } };

private static int aD[] = new int[3];

}