A RuneTek3 client (377) that is deobfuscated, converted to Kotlin, and includes QoL improvements.
some chatsensor cleanup, should i just remove this part?
author
Henning Berge
date
(Jan 15, 2020, 10:24 PM +0100)
commit
89951ca2
89951ca247130cf7a70cd047148a89d002400dc9
parent
e29bdd06
e29bdd0614726a52e87fe84a1a66845f84433f8f
+131
-194
+131
-194
src/main/java/com/jagex/runescape/cache/cfg/ChatCensor.java
+131
-194
src/main/java/com/jagex/runescape/cache/cfg/ChatCensor.java
···
6
6
public class ChatCensor {
7
7
8
8
9
-
public static int anInt728 = 3;
10
-
public static int anInt729;
11
-
public static boolean aBoolean731;
12
-
public static boolean aBoolean732;
13
-
public static int anInt733 = -48545;
14
-
public static int anInt734;
15
-
public static byte aByte735 = -113;
16
-
public static int anInt736 = 3;
17
-
public static boolean aBoolean738;
18
-
public static int fragments[];
19
-
public static char badWords[][];
20
-
public static byte badBytes[][][];
21
-
public static char domains[][];
22
-
public static char topLevelDomains[][];
23
-
public static int topLevelDomainsType[];
24
-
public static final String toCharArray[] = { "cook", "cook's", "cooks", "seeks", "sheet", "woop", "woops",
25
-
"faq", "noob", "noobs" };
9
+
private static int[] fragments;
10
+
private static char[][] badWords;
11
+
private static byte[][][] badBytes;
12
+
private static char[][] domains;
13
+
private static char[][] topLevelDomains;
14
+
private static int[] topLevelDomainsType;
15
+
private static final String[] exceptions = {"cook", "cook's", "cooks", "seeks", "sheet", "woop", "woops",
16
+
"faq", "noob", "noobs"};
26
17
27
18
public static void load(Archive archive) {
28
19
Buffer fragmentsEnc = new Buffer(archive.getFile("fragmentsenc.txt"));
···
32
23
loadDictionaries(fragmentsEnc, badEnc, domainEnc, topLevelDomainsBuffer);
33
24
}
34
25
35
-
public static void loadDictionaries(Buffer fragmentsEnc, Buffer badEnc,
36
-
Buffer domainEnc, Buffer topLevelDomainsBuffer) {
26
+
private static void loadDictionaries(Buffer fragmentsEnc, Buffer badEnc,
27
+
Buffer domainEnc, Buffer topLevelDomainsBuffer) {
37
28
loadBadEnc(badEnc);
38
29
loadDomainEnc(domainEnc);
39
30
loadFragmentsEnc(fragmentsEnc);
40
31
loadTopLevelDomains(topLevelDomainsBuffer);
41
32
}
42
33
43
-
public static void loadTopLevelDomains(Buffer buffer) {
34
+
private static void loadTopLevelDomains(Buffer buffer) {
44
35
int length = buffer.getIntBE();
45
36
topLevelDomains = new char[length][];
46
37
topLevelDomainsType = new int[length];
···
55
46
56
47
}
57
48
58
-
public static void loadBadEnc(Buffer buffer) {
49
+
private static void loadBadEnc(Buffer buffer) {
59
50
int length = buffer.getIntBE();
60
51
badWords = new char[length][];
61
52
badBytes = new byte[length][][];
···
63
54
64
55
}
65
56
66
-
public static void loadDomainEnc(Buffer buffer) {
57
+
private static void loadDomainEnc(Buffer buffer) {
67
58
int length = buffer.getIntBE();
68
59
domains = new char[length][];
69
60
loadDomains(buffer, domains);
70
61
}
71
62
72
-
public static void loadFragmentsEnc(Buffer buffer) {
63
+
private static void loadFragmentsEnc(Buffer buffer) {
73
64
fragments = new int[buffer.getIntBE()];
74
65
for (int index = 0; index < fragments.length; index++)
75
66
fragments[index] = buffer.getUnsignedShortBE();
76
67
77
68
}
78
69
79
-
public static void loadBadWords(Buffer buffer, char[][] badWords, byte[][][] badBytes) {
70
+
private static void loadBadWords(Buffer buffer, char[][] badWords, byte[][][] badBytes) {
80
71
for (int index = 0; index < badWords.length; index++) {
81
72
char[] badWord = new char[buffer.getUnsignedByte()];
82
-
for (int k = 0; k < badWord.length; k++)
83
-
badWord[k] = (char) buffer.getUnsignedByte();
73
+
for (int character = 0; character < badWord.length; character++)
74
+
badWord[character] = (char) buffer.getUnsignedByte();
84
75
85
76
badWords[index] = badWord;
86
77
byte[][] badByte = new byte[buffer.getUnsignedByte()][2];
···
95
86
96
87
}
97
88
98
-
public static void loadDomains(Buffer buffer, char[][] cs) {
89
+
private static void loadDomains(Buffer buffer, char[][] cs) {
99
90
for (int index = 0; index < cs.length; index++) {
100
91
char[] domainEnc = new char[buffer.getUnsignedByte()];
101
92
for (int character = 0; character < domainEnc.length; character++)
···
106
97
107
98
}
108
99
109
-
public static void formatLegalCharacters(char[] characters) {
100
+
private static void formatLegalCharacters(char[] characters) {
110
101
int character = 0;
111
102
for (int index = 0; index < characters.length; index++) {
112
103
if (isLegalCharacter(characters[index]))
···
122
113
123
114
}
124
115
125
-
public static boolean isLegalCharacter(char character) {
116
+
private static boolean isLegalCharacter(char character) {
126
117
return character >= ' ' && character <= '\177' || character == ' ' || character == '\n' || character == '\t' || character == '\243' || character == '\u20AC';
127
118
}
128
119
···
132
123
String censoredStringTrimmed = (new String(censoredString)).trim();
133
124
censoredString = censoredStringTrimmed.toLowerCase().toCharArray();
134
125
String censoredStringLowercased = censoredStringTrimmed.toLowerCase();
135
-
method391(censoredString, 0);
136
-
method386(censoredString, anInt733);
137
-
method387(3, censoredString);
138
-
method400(3, censoredString);
139
-
for (int i = 0; i < toCharArray.length; i++) {
140
-
for (int j = -1; (j = censoredStringLowercased.indexOf(toCharArray[i], j + 1)) != -1;) {
141
-
char ac1[] = toCharArray[i].toCharArray();
142
-
for (int k = 0; k < ac1.length; k++)
143
-
censoredString[k + j] = ac1[k];
126
+
method391(censoredString);
127
+
method386(censoredString);
128
+
method387(censoredString);
129
+
method400(censoredString);
130
+
for (String exception : exceptions) {
131
+
for (int index = -1; (index = censoredStringLowercased.indexOf(exception, index + 1)) != -1; ) {
132
+
char[] ac1 = exception.toCharArray();
133
+
System.arraycopy(ac1, 0, censoredString, index, ac1.length);
144
134
145
135
}
146
136
147
137
}
148
138
149
-
method384(0, censoredString, censoredStringTrimmed.toCharArray());
150
-
method385(1, censoredString);
139
+
method384(censoredString, censoredStringTrimmed.toCharArray());
140
+
method385(censoredString);
151
141
return (new String(censoredString)).trim();
152
142
}
153
143
154
-
public static void method384(int i, char ac[], char ac1[]) {
144
+
private static void method384(char[] ac, char[] ac1) {
155
145
for (int j = 0; j < ac1.length; j++)
156
-
if (ac[j] != '*' && method408(-217, ac1[j]))
146
+
if (ac[j] != '*' && method408(ac1[j]))
157
147
ac[j] = ac1[j];
158
148
159
-
if (i != 0)
160
-
anInt728 = 271;
161
149
}
162
150
163
-
public static void method385(int i, char ac[]) {
151
+
private static void method385(char[] ac) {
164
152
boolean flag = true;
165
153
for (int j = 0; j < ac.length; j++) {
166
154
char c = ac[j];
167
-
if (method405(true, c)) {
155
+
if (method405(c)) {
168
156
if (flag) {
169
157
if (method407(c))
170
158
flag = false;
171
-
} else if (method408(-217, c))
159
+
} else if (method408(c))
172
160
ac[j] = (char) ((c + 97) - 65);
173
161
} else {
174
162
flag = true;
175
163
}
176
164
}
177
-
178
-
if (i == 1)
179
-
;
180
165
}
181
166
182
-
public static void method386(char ac[], int i) {
167
+
private static void method386(char[] ac) {
183
168
for (int j = 0; j < 2; j++) {
184
169
for (int k = badWords.length - 1; k >= 0; k--)
185
-
method395(badBytes[k], -939, badWords[k], ac);
170
+
method395(badBytes[k], badWords[k], ac);
186
171
187
172
}
188
173
189
-
if (i != -48545)
190
-
aBoolean731 = !aBoolean731;
191
174
}
192
175
193
-
public static void method387(int i, char ac[]) {
194
-
char ac1[] = ac.clone();
195
-
char ac2[] = { '(', 'a', ')' };
196
-
method395(null, -939, ac2, ac1);
197
-
if (i < 3 || i > 3)
198
-
anInt728 = 382;
199
-
char ac3[] = ac.clone();
200
-
char ac4[] = { 'd', 'o', 't' };
201
-
method395(null, -939, ac4, ac3);
176
+
private static void method387(char[] ac) {
177
+
char[] ac1 = ac.clone();
178
+
char[] ac2 = {'(', 'a', ')'};
179
+
method395(null, ac2, ac1);
180
+
char[] ac3 = ac.clone();
181
+
char[] ac4 = {'d', 'o', 't'};
182
+
method395(null, ac4, ac3);
202
183
for (int j = domains.length - 1; j >= 0; j--)
203
-
method388(ac, ac3, ac1, -65, domains[j]);
184
+
method388(ac, ac3, ac1, domains[j]);
204
185
205
186
}
206
187
207
-
public static void method388(char ac[], char ac1[], char ac2[], int i, char ac3[]) {
208
-
if (i >= 0)
209
-
return;
188
+
private static void method388(char[] ac, char[] ac1, char[] ac2, char[] ac3) {
210
189
if (ac3.length > ac.length)
211
190
return;
212
191
int j;
···
215
194
int i1 = 0;
216
195
j = 1;
217
196
while (l < ac.length) {
218
-
int j1 = 0;
197
+
int j1;
219
198
char c = ac[l];
220
199
char c1 = '\0';
221
200
if (l + 1 < ac.length)
222
201
c1 = ac[l + 1];
223
-
if (i1 < ac3.length && (j1 = method397(c, 0, ac3[i1], c1)) > 0) {
202
+
if (i1 < ac3.length && (j1 = method397(c, ac3[i1], c1)) > 0) {
224
203
l += j1;
225
204
i1++;
226
205
continue;
227
206
}
228
207
if (i1 == 0)
229
208
break;
230
-
if ((j1 = method397(c, 0, ac3[i1 - 1], c1)) > 0) {
209
+
if ((j1 = method397(c, ac3[i1 - 1], c1)) > 0) {
231
210
l += j1;
232
211
if (i1 == 1)
233
212
j++;
234
213
continue;
235
214
}
236
-
if (i1 >= ac3.length || !method403(c, false))
215
+
if (i1 >= ac3.length || !method403(c))
237
216
break;
238
217
l++;
239
218
}
240
219
if (i1 >= ac3.length) {
241
220
boolean flag1 = false;
242
-
int k1 = method389(ac, ac2, (byte) -72, k);
243
-
int l1 = method390(ac1, 0, l - 1, ac);
221
+
int k1 = method389(ac, ac2, k);
222
+
int l1 = method390(ac1, l - 1, ac);
244
223
if (k1 > 2 || l1 > 2)
245
224
flag1 = true;
246
225
if (flag1) {
···
253
232
254
233
}
255
234
256
-
public static int method389(char ac[], char ac1[], byte byte0, int i) {
235
+
private static int method389(char[] ac, char[] ac1, int i) {
257
236
if (i == 0)
258
237
return 2;
259
238
for (int j = i - 1; j >= 0; j--) {
260
-
if (!method403(ac[j], false))
239
+
if (!method403(ac[j]))
261
240
break;
262
241
if (ac[j] == '@')
263
242
return 3;
···
265
244
266
245
int k = 0;
267
246
for (int l = i - 1; l >= 0; l--) {
268
-
if (!method403(ac1[l], false))
247
+
if (!method403(ac1[l]))
269
248
break;
270
249
if (ac1[l] == '*')
271
250
k++;
272
251
}
273
252
274
-
if (byte0 != -72)
275
-
return 3;
276
253
if (k >= 3)
277
254
return 4;
278
-
return !method403(ac[i - 1], false) ? 0 : 1;
255
+
return !method403(ac[i - 1]) ? 0 : 1;
279
256
}
280
257
281
-
public static int method390(char ac[], int i, int j, char ac1[]) {
258
+
private static int method390(char[] ac, int j, char[] ac1) {
282
259
if (j + 1 == ac1.length)
283
260
return 2;
284
261
for (int k = j + 1; k < ac1.length; k++) {
285
-
if (!method403(ac1[k], false))
262
+
if (!method403(ac1[k]))
286
263
break;
287
264
if (ac1[k] == '.' || ac1[k] == ',')
288
265
return 3;
289
266
}
290
267
291
268
int l = 0;
292
-
if (i != 0)
293
-
return anInt733;
294
269
for (int i1 = j + 1; i1 < ac1.length; i1++) {
295
-
if (!method403(ac[i1], false))
270
+
if (!method403(ac[i1]))
296
271
break;
297
272
if (ac[i1] == '*')
298
273
l++;
···
300
275
301
276
if (l >= 3)
302
277
return 4;
303
-
return !method403(ac1[j + 1], false) ? 0 : 1;
278
+
return !method403(ac1[j + 1]) ? 0 : 1;
304
279
}
305
280
306
-
public static void method391(char ac[], int i) {
307
-
char ac1[] = ac.clone();
308
-
char ac2[] = { 'd', 'o', 't' };
309
-
method395(null, -939, ac2, ac1);
310
-
char ac3[] = ac.clone();
311
-
char ac4[] = { 's', 'l', 'a', 's', 'h' };
312
-
if (i != 0)
313
-
aBoolean732 = !aBoolean732;
314
-
method395(null, -939, ac4, ac3);
281
+
private static void method391(char[] ac) {
282
+
char[] ac1 = ac.clone();
283
+
char[] ac2 = {'d', 'o', 't'};
284
+
method395(null, ac2, ac1);
285
+
char[] ac3 = ac.clone();
286
+
char[] ac4 = {'s', 'l', 'a', 's', 'h'};
287
+
method395(null, ac4, ac3);
315
288
for (int j = 0; j < topLevelDomains.length; j++)
316
-
method392(ac, (byte) 7, ac1, topLevelDomainsType[j], topLevelDomains[j], ac3);
289
+
method392(ac, ac1, topLevelDomainsType[j], topLevelDomains[j], ac3);
317
290
318
291
}
319
292
320
-
public static void method392(char ac[], byte byte0, char ac1[], int i, char ac2[], char ac3[]) {
293
+
private static void method392(char[] ac, char[] ac1, int i, char[] ac2, char[] ac3) {
321
294
if (ac2.length > ac.length)
322
295
return;
323
296
int j;
···
326
299
int i1 = 0;
327
300
j = 1;
328
301
while (l < ac.length) {
329
-
int j1 = 0;
302
+
int j1;
330
303
char c = ac[l];
331
304
char c1 = '\0';
332
305
if (l + 1 < ac.length)
333
306
c1 = ac[l + 1];
334
-
if (i1 < ac2.length && (j1 = method397(c, 0, ac2[i1], c1)) > 0) {
307
+
if (i1 < ac2.length && (j1 = method397(c, ac2[i1], c1)) > 0) {
335
308
l += j1;
336
309
i1++;
337
310
continue;
338
311
}
339
312
if (i1 == 0)
340
313
break;
341
-
if ((j1 = method397(c, 0, ac2[i1 - 1], c1)) > 0) {
314
+
if ((j1 = method397(c, ac2[i1 - 1], c1)) > 0) {
342
315
l += j1;
343
316
if (i1 == 1)
344
317
j++;
345
318
continue;
346
319
}
347
-
if (i1 >= ac2.length || !method403(c, false))
320
+
if (i1 >= ac2.length || !method403(c))
348
321
break;
349
322
l++;
350
323
}
351
324
if (i1 >= ac2.length) {
352
325
boolean flag1 = false;
353
-
int k1 = method393(ac1, k, ac, (byte) -113);
354
-
int l1 = method394(ac3, l - 1, ac, 3);
326
+
int k1 = method393(ac1, k, ac);
327
+
int l1 = method394(ac3, l - 1, ac);
355
328
if (i == 1 && k1 > 0 && l1 > 0)
356
329
flag1 = true;
357
330
if (i == 2 && (k1 > 2 && l1 > 0 || k1 > 0 && l1 > 2))
···
379
352
boolean flag3 = false;
380
353
for (int i3 = i2 - 1; i3 >= 0; i3--)
381
354
if (flag3) {
382
-
if (method403(ac[i3], false))
355
+
if (method403(ac[i3]))
383
356
break;
384
357
i2 = i3;
385
-
} else if (!method403(ac[i3], false)) {
358
+
} else if (!method403(ac[i3])) {
386
359
flag3 = true;
387
360
i2 = i3;
388
361
}
···
405
378
boolean flag5 = false;
406
379
for (int k3 = j2 + 1; k3 < ac.length; k3++)
407
380
if (flag5) {
408
-
if (method403(ac[k3], false))
381
+
if (method403(ac[k3]))
409
382
break;
410
383
j2 = k3;
411
-
} else if (!method403(ac[k3], false)) {
384
+
} else if (!method403(ac[k3])) {
412
385
flag5 = true;
413
386
j2 = k3;
414
387
}
···
420
393
}
421
394
}
422
395
}
423
-
424
-
if (byte0 == 7)
425
-
byte0 = 0;
426
396
}
427
397
428
-
public static int method393(char ac[], int i, char ac1[], byte byte0) {
429
-
if (byte0 != aByte735) {
430
-
for (int j = 1; j > 0; j++);
431
-
}
398
+
private static int method393(char[] ac, int i, char[] ac1) {
432
399
if (i == 0)
433
400
return 2;
434
401
for (int k = i - 1; k >= 0; k--) {
435
-
if (!method403(ac1[k], false))
402
+
if (!method403(ac1[k]))
436
403
break;
437
404
if (ac1[k] == ',' || ac1[k] == '.')
438
405
return 3;
···
440
407
441
408
int l = 0;
442
409
for (int i1 = i - 1; i1 >= 0; i1--) {
443
-
if (!method403(ac[i1], false))
410
+
if (!method403(ac[i1]))
444
411
break;
445
412
if (ac[i1] == '*')
446
413
l++;
···
448
415
449
416
if (l >= 3)
450
417
return 4;
451
-
return !method403(ac1[i - 1], false) ? 0 : 1;
418
+
return !method403(ac1[i - 1]) ? 0 : 1;
452
419
}
453
420
454
-
public static int method394(char ac[], int i, char ac1[], int j) {
455
-
if (j < anInt736 || j > anInt736) {
456
-
for (int k = 1; k > 0; k++);
457
-
}
421
+
private static int method394(char[] ac, int i, char[] ac1) {
458
422
if (i + 1 == ac1.length)
459
423
return 2;
460
424
for (int l = i + 1; l < ac1.length; l++) {
461
-
if (!method403(ac1[l], false))
425
+
if (!method403(ac1[l]))
462
426
break;
463
427
if (ac1[l] == '\\' || ac1[l] == '/')
464
428
return 3;
···
466
430
467
431
int i1 = 0;
468
432
for (int j1 = i + 1; j1 < ac1.length; j1++) {
469
-
if (!method403(ac[j1], false))
433
+
if (!method403(ac[j1]))
470
434
break;
471
435
if (ac[j1] == '*')
472
436
i1++;
···
474
438
475
439
if (i1 >= 5)
476
440
return 4;
477
-
return !method403(ac1[i + 1], false) ? 0 : 1;
441
+
return !method403(ac1[i + 1]) ? 0 : 1;
478
442
}
479
443
480
-
public static void method395(byte abyte0[][], int i, char ac[], char ac1[]) {
481
-
while (i >= 0)
482
-
return;
444
+
private static void method395(byte[][] abyte0, char[] ac, char[] ac1) {
483
445
if (ac.length > ac1.length)
484
446
return;
485
447
int j;
···
492
454
boolean flag2 = false;
493
455
boolean flag3 = false;
494
456
while (l < ac1.length && (!flag2 || !flag3)) {
495
-
int k1 = 0;
457
+
int k1;
496
458
char c = ac1[l];
497
459
char c2 = '\0';
498
460
if (l + 1 < ac1.length)
499
461
c2 = ac1[l + 1];
500
-
if (i1 < ac.length && (k1 = method398(ac[i1], c, c2, 7)) > 0) {
501
-
if (k1 == 1 && method406(c, false))
462
+
if (i1 < ac.length && (k1 = method398(ac[i1], c, c2)) > 0) {
463
+
if (k1 == 1 && method406(c))
502
464
flag2 = true;
503
-
if (k1 == 2 && (method406(c, false) || method406(c2, false)))
465
+
if (k1 == 2 && (method406(c) || method406(c2)))
504
466
flag2 = true;
505
467
l += k1;
506
468
i1++;
···
508
470
}
509
471
if (i1 == 0)
510
472
break;
511
-
if ((k1 = method398(ac[i1 - 1], c, c2, 7)) > 0) {
473
+
if ((k1 = method398(ac[i1 - 1], c, c2)) > 0) {
512
474
l += k1;
513
475
if (i1 == 1)
514
476
j++;
515
477
continue;
516
478
}
517
-
if (i1 >= ac.length || !method404(2, c))
479
+
if (i1 >= ac.length || !method404(c))
518
480
break;
519
-
if (method403(c, false) && c != '\'')
481
+
if (method403(c) && c != '\'')
520
482
flag1 = true;
521
-
if (method406(c, false))
483
+
if (method406(c))
522
484
flag3 = true;
523
485
l++;
524
486
if ((++j1 * 100) / (l - k) > 90)
···
533
495
char c3 = ' ';
534
496
if (l < ac1.length)
535
497
c3 = ac1[l];
536
-
byte byte0 = method399(c1, (byte) 7);
537
-
byte byte1 = method399(c3, (byte) 7);
538
-
if (abyte0 != null && method396(byte1, abyte0, byte0, 4))
498
+
byte byte0 = method399(c1);
499
+
byte byte1 = method399(c3);
500
+
if (abyte0 != null && method396(byte1, abyte0, byte0))
539
501
flag4 = false;
540
502
} else {
541
503
boolean flag5 = false;
542
504
boolean flag6 = false;
543
-
if (k - 1 < 0 || method403(ac1[k - 1], false) && ac1[k - 1] != '\'')
505
+
if (k - 1 < 0 || method403(ac1[k - 1]) && ac1[k - 1] != '\'')
544
506
flag5 = true;
545
-
if (l >= ac1.length || method403(ac1[l], false) && ac1[l] != '\'')
507
+
if (l >= ac1.length || method403(ac1[l]) && ac1[l] != '\'')
546
508
flag6 = true;
547
509
if (!flag5 || !flag6) {
548
510
boolean flag7 = false;
···
550
512
if (flag5)
551
513
k2 = k;
552
514
for (; !flag7 && k2 < l; k2++)
553
-
if (k2 >= 0 && (!method403(ac1[k2], false) || ac1[k2] == '\'')) {
554
-
char ac2[] = new char[3];
515
+
if (k2 >= 0 && (!method403(ac1[k2]) || ac1[k2] == '\'')) {
516
+
char[] ac2 = new char[3];
555
517
int j3;
556
518
for (j3 = 0; j3 < 3; j3++) {
557
-
if (k2 + j3 >= ac1.length || method403(ac1[k2 + j3], false) && ac1[k2 + j3] != '\'')
519
+
if (k2 + j3 >= ac1.length || method403(ac1[k2 + j3]) && ac1[k2 + j3] != '\'')
558
520
break;
559
521
ac2[j3] = ac1[k2 + j3];
560
522
}
···
562
524
boolean flag8 = true;
563
525
if (j3 == 0)
564
526
flag8 = false;
565
-
if (j3 < 3 && k2 - 1 >= 0 && (!method403(ac1[k2 - 1], false) || ac1[k2 - 1] == '\''))
527
+
if (j3 < 3 && k2 - 1 >= 0 && (!method403(ac1[k2 - 1]) || ac1[k2 - 1] == '\''))
566
528
flag8 = false;
567
-
if (flag8 && !method409(ac2, 463))
529
+
if (flag8 && !method409(ac2))
568
530
flag7 = true;
569
531
}
570
532
···
577
539
int i2 = 0;
578
540
int j2 = -1;
579
541
for (int l2 = k; l2 < l; l2++)
580
-
if (method406(ac1[l2], false))
542
+
if (method406(ac1[l2]))
581
543
l1++;
582
-
else if (method405(true, ac1[l2])) {
544
+
else if (method405(ac1[l2])) {
583
545
i2++;
584
546
j2 = l2;
585
547
}
···
599
561
600
562
}
601
563
602
-
public static boolean method396(byte byte0, byte abyte0[][], byte byte1, int i) {
564
+
private static boolean method396(byte byte0, byte[][] abyte0, byte byte1) {
603
565
int j = 0;
604
-
if (i < 4 || i > 4)
605
-
throw new NullPointerException();
606
566
if (abyte0[j][0] == byte1 && abyte0[j][1] == byte0)
607
567
return true;
608
568
int k = abyte0.length - 1;
···
620
580
return false;
621
581
}
622
582
623
-
public static int method397(char c, int i, char c1, char c2) {
624
-
if (i != 0)
625
-
return anInt733;
583
+
private static int method397(char c, char c1, char c2) {
626
584
if (c1 == c)
627
585
return 1;
628
586
if (c1 == 'o' && c == '0')
···
638
596
return c1 != 'l' || c != 'i' ? 0 : 1;
639
597
}
640
598
641
-
public static int method398(char c, char c1, char c2, int i) {
642
-
if (i != 7)
643
-
return anInt728;
599
+
private static int method398(char c, char c1, char c2) {
644
600
if (c == c1)
645
601
return 1;
646
602
if (c >= 'a' && c <= 'm') {
···
738
694
return 0;
739
695
}
740
696
741
-
public static byte method399(char c, byte byte0) {
742
-
if (byte0 != 7)
743
-
throw new NullPointerException();
697
+
private static byte method399(char c) {
744
698
if (c >= 'a' && c <= 'z')
745
699
return (byte) ((c - 97) + 1);
746
700
if (c == '\'')
···
751
705
return 27;
752
706
}
753
707
754
-
public static void method400(int i, char ac[]) {
755
-
int j = 0;
708
+
private static void method400(char[] ac) {
709
+
int j;
756
710
int k = 0;
757
711
int l = 0;
758
-
if (i < 3 || i > 3)
759
-
return;
760
712
int i1 = 0;
761
-
while ((j = method401(307, k, ac)) != -1) {
713
+
while ((j = method401(k, ac)) != -1) {
762
714
boolean flag = false;
763
715
for (int j1 = k; j1 >= 0 && j1 < j && !flag; j1++)
764
-
if (!method403(ac[j1], false) && !method404(2, ac[j1]))
716
+
if (!method403(ac[j1]) && !method404(ac[j1]))
765
717
flag = true;
766
718
767
719
if (flag)
768
720
l = 0;
769
721
if (l == 0)
770
722
i1 = j;
771
-
k = method402(j, 618, ac);
723
+
k = method402(j, ac);
772
724
int k1 = 0;
773
725
for (int l1 = j; l1 < k; l1++)
774
726
k1 = (k1 * 10 + ac[l1]) - 48;
···
786
738
}
787
739
}
788
740
789
-
public static int method401(int i, int j, char ac[]) {
741
+
private static int method401(int j, char[] ac) {
790
742
for (int k = j; k < ac.length && k >= 0; k++)
791
743
if (ac[k] >= '0' && ac[k] <= '9')
792
744
return k;
793
745
794
-
if (i <= 0)
795
-
aBoolean731 = !aBoolean731;
796
746
return -1;
797
747
}
798
748
799
-
public static int method402(int i, int j, char ac[]) {
800
-
if (j <= 0) {
801
-
for (int k = 1; k > 0; k++);
802
-
}
749
+
private static int method402(int i, char[] ac) {
803
750
for (int l = i; l < ac.length && l >= 0; l++)
804
751
if (ac[l] < '0' || ac[l] > '9')
805
752
return l;
···
807
754
return ac.length;
808
755
}
809
756
810
-
public static boolean method403(char c, boolean flag) {
811
-
if (flag)
812
-
throw new NullPointerException();
813
-
return !method405(true, c) && !method406(c, false);
757
+
private static boolean method403(char c) {
758
+
return !method405(c) && !method406(c);
814
759
}
815
760
816
-
public static boolean method404(int i, char c) {
817
-
if (i != 2)
818
-
aBoolean732 = !aBoolean732;
761
+
private static boolean method404(char c) {
819
762
if (c < 'a' || c > 'z')
820
763
return true;
821
764
return c == 'v' || c == 'x' || c == 'j' || c == 'q' || c == 'z';
822
765
}
823
766
824
-
public static boolean method405(boolean flag, char c) {
767
+
private static boolean method405(char c) {
825
768
return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z';
826
769
}
827
770
828
-
public static boolean method406(char c, boolean flag) {
829
-
if (flag)
830
-
throw new NullPointerException();
771
+
private static boolean method406(char c) {
831
772
return c >= '0' && c <= '9';
832
773
}
833
774
834
-
public static boolean method407(char c) {
775
+
private static boolean method407(char c) {
835
776
return c >= 'a' && c <= 'z';
836
777
}
837
778
838
-
public static boolean method408(int i, char c) {
779
+
private static boolean method408(char c) {
839
780
return c >= 'A' && c <= 'Z';
840
781
}
841
782
842
-
public static boolean method409(char ac[], int i) {
783
+
private static boolean method409(char[] ac) {
843
784
boolean flag = true;
844
785
for (int j = 0; j < ac.length; j++)
845
-
if (!method406(ac[j], false) && ac[j] != 0)
786
+
if (!method406(ac[j]) && ac[j] != 0)
846
787
flag = false;
847
788
848
-
i = 78 / i;
849
789
if (flag)
850
790
return true;
851
-
int k = method410(ac, (byte) 5);
791
+
int k = method410(ac);
852
792
int l = 0;
853
793
int i1 = fragments.length - 1;
854
794
if (k == fragments[l] || k == fragments[i1])
···
865
805
return false;
866
806
}
867
807
868
-
public static int method410(char ac[], byte byte0) {
808
+
private static int method410(char[] ac) {
869
809
if (ac.length > 6)
870
810
return 0;
871
811
int i = 0;
872
-
if (byte0 == 5)
873
-
byte0 = 0;
874
-
else
875
-
return 3;
812
+
876
813
for (int j = 0; j < ac.length; j++) {
877
814
char c = ac[ac.length - j - 1];
878
815
if (c >= 'a' && c <= 'z')