A RuneTek3 client (377) that is deobfuscated, converted to Kotlin, and includes QoL improvements.
0

Configure Feed

Select the types of activity you want to include in your feed.

some chatsensor cleanup, should i just remove this part?

+131 -194
+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')