API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 20th, 2018
213
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 332.52 KB | None | 0 0
raw download clone embed print report
  1. /* Class387_Sub3 - Decompiled by JODE
  2. * Visit http://jode.sourceforge.net/
  3. */
  4. import java.nio.ByteBuffer;
  5.  
  6. import sun.misc.Unsafe;
  7.  
  8. public class Class387_Sub3 extends Class387 {
  9. Class166[] aClass166Array7892;
  10. boolean aBoolean7893;
  11. Class_ra_Sub3 aClass_ra_Sub3_7894;
  12. int[] vertices_y;
  13. int anInt7896;
  14. short aShort7897;
  15. short aShort7898;
  16. int anInt7899 = 0;
  17. int anInt7900 = 0;
  18. int[] vertices_x;
  19. static int origin_x;
  20. boolean aBoolean7903;
  21. Class68[] aClass68Array7904;
  22. static boolean aBoolean7905;
  23. int anInt7906 = 0;
  24. short[] aShortArray7907;
  25. short[] aShortArray7908;
  26. short[] aShortArray7909;
  27. short[] aShortArray7910;
  28. Class186 aClass186_7911;
  29. int anInt7912;
  30. int[] anIntArray7913;
  31. float[] aFloatArray7914;
  32. Class185 aClass185_7915;
  33. int anInt7916 = 0;
  34. int anInt7917 = 0;
  35. int[][] verticesByLabel;
  36. short[] aShortArray7919;
  37. short[] aShortArray7920;
  38. short[] aShortArray7921;
  39. short[] aShortArray7922;
  40. short[] aShortArray7923;
  41. int[][] anIntArrayArray7924;
  42. short[] aShortArray7925;
  43. Class167 aClass167_7926;
  44. Class186 aClass186_7927;
  45. int anInt7928;
  46. static int[] anIntArray7929;
  47. Class186 aClass186_7930;
  48. boolean aBoolean7931 = false;
  49. boolean aBoolean7932 = true;
  50. static int[] anIntArray7933;
  51. Class186 aClass186_7934;
  52. short[] aShortArray7935;
  53. int anInt7936;
  54. static int origin_y;
  55. int anInt7938;
  56. int anInt7939;
  57. int anInt7940;
  58. int anInt7941;
  59. int anInt7942;
  60. int anInt7943;
  61. int[] anIntArray7944;
  62. int[] anIntArray7945;
  63. int[][] anIntArrayArray7946;
  64. int[] anIntArray7947;
  65. short[] aShortArray7948;
  66. Class85[] aClass85Array7949;
  67. boolean aBoolean7950;
  68. int anInt7951;
  69. Class191[] aClass191Array7952;
  70. float[] aFloatArray7953;
  71. static int anInt7954 = 7;
  72. static long[] aLongArray7955;
  73. static int origin_z;
  74. static int anInt7957 = 4;
  75. byte[] aByteArray7958;
  76. static int[] anIntArray7959;
  77. static int[] anIntArray7960;
  78. static int[] anIntArray7961;
  79. static float[] aFloatArray7962 = new float[2];
  80. byte[] aByteArray7963;
  81. short[] aShortArray7964;
  82. int[] vertices_z;
  83. static Class156 aClass156_7966;
  84.  
  85. @Override
  86. public int ya() {
  87. if (!aBoolean7950) {
  88. method4832();
  89. }
  90. return anInt7941;
  91. }
  92.  
  93. @Override
  94. public int an() {
  95. return anInt7912;
  96. }
  97.  
  98. void method4832() {
  99. int i = 32767;
  100. int i_0_ = 32767;
  101. int i_1_ = 32767;
  102. int i_2_ = -32768;
  103. int i_3_ = -32768;
  104. int i_4_ = -32768;
  105. int i_5_ = 0;
  106. int i_6_ = 0;
  107. for (int i_7_ = 0; i_7_ < anInt7900; i_7_++) {
  108. int i_8_ = vertices_x[i_7_];
  109. int i_9_ = vertices_y[i_7_];
  110. int i_10_ = vertices_z[i_7_];
  111. if (i_8_ < i) {
  112. i = i_8_;
  113. }
  114. if (i_8_ > i_2_) {
  115. i_2_ = i_8_;
  116. }
  117. if (i_9_ < i_0_) {
  118. i_0_ = i_9_;
  119. }
  120. if (i_9_ > i_3_) {
  121. i_3_ = i_9_;
  122. }
  123. if (i_10_ < i_1_) {
  124. i_1_ = i_10_;
  125. }
  126. if (i_10_ > i_4_) {
  127. i_4_ = i_10_;
  128. }
  129. int i_11_ = i_8_ * i_8_ + i_10_ * i_10_;
  130. if (i_11_ > i_5_) {
  131. i_5_ = i_11_;
  132. }
  133. i_11_ = i_8_ * i_8_ + i_10_ * i_10_ + i_9_ * i_9_;
  134. if (i_11_ > i_6_) {
  135. i_6_ = i_11_;
  136. }
  137. }
  138. anInt7940 = i;
  139. anInt7941 = i_2_;
  140. anInt7938 = i_0_;
  141. anInt7939 = i_3_;
  142. anInt7942 = i_1_;
  143. anInt7943 = i_4_;
  144. anInt7936 = (int) (Math.sqrt(i_5_) + 0.99);
  145. anInt7928 = (int) (Math.sqrt(i_6_) + 0.99);
  146. aBoolean7950 = true;
  147. }
  148.  
  149. static byte[] method4833(byte[] is, int i) {
  150. byte[] is_12_ = new byte[i];
  151. System.arraycopy(is, 0, is_12_, 0, i);
  152. return is_12_;
  153. }
  154.  
  155. static short[] method4834(short[] is, int i) {
  156. short[] is_13_ = new short[i];
  157. System.arraycopy(is, 0, is_13_, 0, i);
  158. return is_13_;
  159. }
  160.  
  161. boolean method4835() {
  162. if (aClass167_7926.aBoolean1710) {
  163. return true;
  164. }
  165. if (aClass167_7926.anInterface7_Impl2_1709 == null) {
  166. aClass167_7926.anInterface7_Impl2_1709 = aClass_ra_Sub3_7894.method5381(false);
  167. }
  168. Interface7_Impl2 interface7_impl2 = aClass167_7926.anInterface7_Impl2_1709;
  169. interface7_impl2.method113(anInt7917 * 6);
  170. Unsafe unsafe = aClass_ra_Sub3_7894.anUnsafe8219;
  171. if (unsafe != null) {
  172. int i = anInt7917 * 6;
  173. long l = interface7_impl2.method62(0, i);
  174. if (l == 0L) {
  175. return false;
  176. }
  177. for (int i_14_ = 0; i_14_ < anInt7917; i_14_++) {
  178. unsafe.putShort(l, aShortArray7920[i_14_]);
  179. l += 2L;
  180. unsafe.putShort(l, aShortArray7921[i_14_]);
  181. l += 2L;
  182. unsafe.putShort(l, aShortArray7922[i_14_]);
  183. l += 2L;
  184. }
  185. interface7_impl2.method69();
  186. aClass167_7926.anInterface7_Impl2_1707 = interface7_impl2;
  187. aClass167_7926.aBoolean1710 = true;
  188. aBoolean7932 = true;
  189. return true;
  190. }
  191. ByteBuffer bytebuffer = aClass_ra_Sub3_7894.aByteBuffer8216;
  192. bytebuffer.clear();
  193. for (int i = 0; i < anInt7917; i++) {
  194. bytebuffer.putShort(aShortArray7920[i]);
  195. bytebuffer.putShort(aShortArray7921[i]);
  196. bytebuffer.putShort(aShortArray7922[i]);
  197. }
  198. if (interface7_impl2.method63(0, bytebuffer.position(), aClass_ra_Sub3_7894.aLong8217)) {
  199. aClass167_7926.anInterface7_Impl2_1707 = interface7_impl2;
  200. aClass167_7926.aBoolean1710 = true;
  201. aBoolean7932 = true;
  202. return true;
  203. }
  204. return false;
  205. }
  206.  
  207. @Override
  208. public int dp() {
  209. if (!aBoolean7950) {
  210. method4832();
  211. }
  212. return anInt7943;
  213. }
  214.  
  215. @Override
  216. public void animate_transform_osrs(int type, int[] labels, int x, int y, int z) {
  217. int numLabels = labels.length;
  218. if (type == 0) {
  219. x <<= 4;
  220. y <<= 4;
  221. z <<= 4;
  222. int i_7 = 0;
  223. origin_x = 0;
  224. origin_y = 0;
  225. origin_z = 0;
  226. for (int i_8 = 0; i_8 < numLabels; i_8++) {
  227. int i_9 = labels[i_8];
  228. if (i_9 < verticesByLabel.length) {
  229. int[] ints_10 = verticesByLabel[i_9];
  230. for (int i_12 : ints_10) {
  231. origin_x += vertices_x[i_12];
  232. origin_y += vertices_y[i_12];
  233. origin_z += vertices_z[i_12];
  234. i_7++;
  235. }
  236. }
  237. }
  238. if (i_7 > 0) {
  239. origin_x = x + origin_x / i_7;
  240. origin_y = y + origin_y / i_7;
  241. origin_z = z + origin_z / i_7;
  242. } else {
  243. origin_x = x;
  244. origin_y = y;
  245. origin_z = z;
  246. }
  247. } else {
  248. if (type == 1) {
  249. x <<= 4;
  250. y <<= 4;
  251. z <<= 4;
  252. for (int i_7 = 0; i_7 < numLabels; i_7++) {
  253. int i_8 = labels[i_7];
  254. if (i_8 < verticesByLabel.length) {
  255. int[] ints_13 = verticesByLabel[i_8];
  256. for (int element : ints_13) {
  257. int i_11 = element;
  258. vertices_x[i_11] += x;
  259. vertices_y[i_11] += y;
  260. vertices_z[i_11] += z;
  261. }
  262. }
  263. }
  264.  
  265. } else if (type == 2) {
  266. final int[] sinTable = Class220.anIntArray2483;
  267. final int[] cosTable = Class220.anIntArray2474;
  268. for (int i_7 = 0; i_7 < numLabels; i_7++) {
  269. int i_8 = labels[i_7];
  270. if (i_8 < verticesByLabel.length) {
  271. int[] ints_13 = verticesByLabel[i_8];
  272. for (int element : ints_13) {
  273. int i_11 = element;
  274. vertices_x[i_11] -= origin_x;
  275. vertices_y[i_11] -= origin_y;
  276. vertices_z[i_11] -= origin_z;
  277. int i_12 = (x & 0xff) * 64;
  278. int i_15 = (y & 0xff) * 64;
  279. int i_16 = (z & 0xff) * 64;
  280. int i_17;
  281. int i_18;
  282. int i_19;
  283. if (i_16 != 0) {
  284. i_17 = sinTable[i_16];
  285. i_18 = cosTable[i_16];
  286. i_19 = i_17 * vertices_y[i_11] + i_18 * vertices_x[i_11] + 16383 >> 14;
  287. vertices_y[i_11] = i_18 * vertices_y[i_11] - i_17 * vertices_x[i_11] + 16383 >> 14;
  288. vertices_x[i_11] = i_19;
  289. }
  290.  
  291. if (i_12 != 0) {
  292. i_17 = sinTable[i_12];
  293. i_18 = cosTable[i_12];
  294. i_19 = i_18 * vertices_y[i_11] - i_17 * vertices_z[i_11] + 16383 >> 14;
  295. vertices_z[i_11] = i_17 * vertices_y[i_11] + i_18 * vertices_z[i_11] + 16383 >> 14;
  296. vertices_y[i_11] = i_19;
  297. }
  298.  
  299. if (i_15 != 0) {
  300. i_17 = sinTable[i_15];
  301. i_18 = cosTable[i_15];
  302. i_19 = i_17 * vertices_z[i_11] + i_18 * vertices_x[i_11] + 16383 >> 14;
  303. vertices_z[i_11] = i_18 * vertices_z[i_11] - i_17 * vertices_x[i_11] + 16383 >> 14;
  304. vertices_x[i_11] = i_19;
  305. }
  306.  
  307. vertices_x[i_11] += origin_x;
  308. vertices_y[i_11] += origin_y;
  309. vertices_z[i_11] += origin_z;
  310. }
  311. }
  312. }
  313. } else if (type == 3) {
  314. for (int i_7 = 0; i_7 < numLabels; i_7++) {
  315. int i_8 = labels[i_7];
  316. if (i_8 < verticesByLabel.length) {
  317. int[] ints_13 = verticesByLabel[i_8];
  318. for (int element : ints_13) {
  319. int i_11 = element;
  320. vertices_x[i_11] -= origin_x;
  321. vertices_y[i_11] -= origin_y;
  322. vertices_z[i_11] -= origin_z;
  323. vertices_x[i_11] = x * vertices_x[i_11] / 128;
  324. vertices_y[i_11] = y * vertices_y[i_11] / 128;
  325. vertices_z[i_11] = z * vertices_z[i_11] / 128;
  326. vertices_x[i_11] += origin_x;
  327. vertices_y[i_11] += origin_y;
  328. vertices_z[i_11] += origin_z;
  329. }
  330. }
  331. }
  332.  
  333. } else if (type == 5) {
  334. if (anIntArrayArray7924 != null) {
  335. boolean bool_79_ = false;
  336. for (int i_80_ = 0; i_80_ < numLabels; i_80_++) {
  337. int i_81_ = labels[i_80_];
  338. if (i_81_ < anIntArrayArray7924.length) {
  339. int[] is_82_ = anIntArrayArray7924[i_81_];
  340. for (int element : is_82_) {
  341. int i_84_ = element;
  342. int i_85_ = (aByteArray7963[i_84_] & 0xff) + x * 8;
  343. if (i_85_ < 0) {
  344. i_85_ = 0;
  345. } else if (i_85_ > 255) {
  346. i_85_ = 255;
  347. }
  348. aByteArray7963[i_84_] = (byte) i_85_;
  349. }
  350. bool_79_ = bool_79_ | is_82_.length > 0;
  351. }
  352. }
  353. if (bool_79_) {
  354. if (aClass191Array7952 != null) {
  355. for (int i_86_ = 0; i_86_ < anInt7951; i_86_++) {
  356. Class191 class191 = aClass191Array7952[i_86_];
  357. Class166 class166 = aClass166Array7892[i_86_];
  358. class166.anInt1703 = class166.anInt1703 & 0xffffff
  359. | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  360. }
  361. }
  362. method4838();
  363. }
  364. }
  365. }
  366. }
  367. }
  368.  
  369. @Override
  370. void method4738(int i, int[] is, int i_15_, int i_16_, int i_17_, int i_18_, boolean bool) {
  371. int i_19_ = is.length;
  372. if (i == 0) {
  373. i_15_ <<= 4;
  374. i_16_ <<= 4;
  375. i_17_ <<= 4;
  376. int i_20_ = 0;
  377. origin_x = 0;
  378. origin_y = 0;
  379. origin_z = 0;
  380. for (int i_21_ = 0; i_21_ < i_19_; i_21_++) {
  381. int i_22_ = is[i_21_];
  382. if (i_22_ < verticesByLabel.length) {
  383. int[] is_23_ = verticesByLabel[i_22_];
  384. for (int i_25_ : is_23_) {
  385. origin_x += vertices_x[i_25_];
  386. origin_y += vertices_y[i_25_];
  387. origin_z += vertices_z[i_25_];
  388. i_20_++;
  389. }
  390. }
  391. }
  392. if (i_20_ > 0) {
  393. origin_x = origin_x / i_20_ + i_15_;
  394. origin_y = origin_y / i_20_ + i_16_;
  395. origin_z = origin_z / i_20_ + i_17_;
  396. } else {
  397. origin_x = i_15_;
  398. origin_y = i_16_;
  399. origin_z = i_17_;
  400. }
  401. } else if (i == 1) {
  402. i_15_ <<= 4;
  403. i_16_ <<= 4;
  404. i_17_ <<= 4;
  405. for (int i_26_ = 0; i_26_ < i_19_; i_26_++) {
  406. int i_27_ = is[i_26_];
  407. if (i_27_ < verticesByLabel.length) {
  408. int[] is_28_ = verticesByLabel[i_27_];
  409. for (int element : is_28_) {
  410. int i_30_ = element;
  411. vertices_x[i_30_] += i_15_;
  412. vertices_y[i_30_] += i_16_;
  413. vertices_z[i_30_] += i_17_;
  414. }
  415. }
  416. }
  417. } else if (i == 2) {
  418. for (int i_31_ = 0; i_31_ < i_19_; i_31_++) {
  419. int i_32_ = is[i_31_];
  420. if (i_32_ < verticesByLabel.length) {
  421. int[] is_33_ = verticesByLabel[i_32_];
  422. if ((i_18_ & 0x1) == 0) {
  423. for (int element : is_33_) {
  424. int i_35_ = element;
  425. vertices_x[i_35_] -= origin_x;
  426. vertices_y[i_35_] -= origin_y;
  427. vertices_z[i_35_] -= origin_z;
  428. if (i_17_ != 0) {
  429. int i_36_ = Class220.anIntArray2483[i_17_];
  430. int i_37_ = Class220.anIntArray2474[i_17_];
  431. int i_38_ = vertices_y[i_35_] * i_36_ + vertices_x[i_35_] * i_37_ + 16383 >> 14;
  432. vertices_y[i_35_] = vertices_y[i_35_] * i_37_ - vertices_x[i_35_] * i_36_ + 16383 >> 14;
  433. vertices_x[i_35_] = i_38_;
  434. }
  435. if (i_15_ != 0) {
  436. int i_39_ = Class220.anIntArray2483[i_15_];
  437. int i_40_ = Class220.anIntArray2474[i_15_];
  438. int i_41_ = vertices_y[i_35_] * i_40_ - vertices_z[i_35_] * i_39_ + 16383 >> 14;
  439. vertices_z[i_35_] = vertices_y[i_35_] * i_39_ + vertices_z[i_35_] * i_40_ + 16383 >> 14;
  440. vertices_y[i_35_] = i_41_;
  441. }
  442. if (i_16_ != 0) {
  443. int i_42_ = Class220.anIntArray2483[i_16_];
  444. int i_43_ = Class220.anIntArray2474[i_16_];
  445. int i_44_ = vertices_z[i_35_] * i_42_ + vertices_x[i_35_] * i_43_ + 16383 >> 14;
  446. vertices_z[i_35_] = vertices_z[i_35_] * i_43_ - vertices_x[i_35_] * i_42_ + 16383 >> 14;
  447. vertices_x[i_35_] = i_44_;
  448. }
  449. vertices_x[i_35_] += origin_x;
  450. vertices_y[i_35_] += origin_y;
  451. vertices_z[i_35_] += origin_z;
  452. }
  453. } else {
  454. for (int element : is_33_) {
  455. int i_46_ = element;
  456. vertices_x[i_46_] -= origin_x;
  457. vertices_y[i_46_] -= origin_y;
  458. vertices_z[i_46_] -= origin_z;
  459. if (i_15_ != 0) {
  460. int i_47_ = Class220.anIntArray2483[i_15_];
  461. int i_48_ = Class220.anIntArray2474[i_15_];
  462. int i_49_ = vertices_y[i_46_] * i_48_ - vertices_z[i_46_] * i_47_ + 16383 >> 14;
  463. vertices_z[i_46_] = vertices_y[i_46_] * i_47_ + vertices_z[i_46_] * i_48_ + 16383 >> 14;
  464. vertices_y[i_46_] = i_49_;
  465. }
  466. if (i_17_ != 0) {
  467. int i_50_ = Class220.anIntArray2483[i_17_];
  468. int i_51_ = Class220.anIntArray2474[i_17_];
  469. int i_52_ = vertices_y[i_46_] * i_50_ + vertices_x[i_46_] * i_51_ + 16383 >> 14;
  470. vertices_y[i_46_] = vertices_y[i_46_] * i_51_ - vertices_x[i_46_] * i_50_ + 16383 >> 14;
  471. vertices_x[i_46_] = i_52_;
  472. }
  473. if (i_16_ != 0) {
  474. int i_53_ = Class220.anIntArray2483[i_16_];
  475. int i_54_ = Class220.anIntArray2474[i_16_];
  476. int i_55_ = vertices_z[i_46_] * i_53_ + vertices_x[i_46_] * i_54_ + 16383 >> 14;
  477. vertices_z[i_46_] = vertices_z[i_46_] * i_54_ - vertices_x[i_46_] * i_53_ + 16383 >> 14;
  478. vertices_x[i_46_] = i_55_;
  479. }
  480. vertices_x[i_46_] += origin_x;
  481. vertices_y[i_46_] += origin_y;
  482. vertices_z[i_46_] += origin_z;
  483. }
  484. }
  485. }
  486. }
  487. if (bool) {
  488. for (int i_56_ = 0; i_56_ < i_19_; i_56_++) {
  489. int i_57_ = is[i_56_];
  490. if (i_57_ < verticesByLabel.length) {
  491. int[] is_58_ = verticesByLabel[i_57_];
  492. for (int i_60_ : is_58_) {
  493. int i_61_ = anIntArray7947[i_60_];
  494. int i_62_ = anIntArray7947[i_60_ + 1];
  495. for (int i_63_ = i_61_; i_63_ < i_62_; i_63_++) {
  496. int i_64_ = aShortArray7948[i_63_] - 1;
  497. if (i_64_ == -1) {
  498. break;
  499. }
  500. if (i_17_ != 0) {
  501. int i_65_ = Class220.anIntArray2483[i_17_];
  502. int i_66_ = Class220.anIntArray2474[i_17_];
  503. int i_67_ = aShortArray7910[i_64_] * i_65_ + aShortArray7909[i_64_] * i_66_ + 16383 >> 14;
  504. aShortArray7910[i_64_] = (short) (aShortArray7910[i_64_] * i_66_ - aShortArray7909[i_64_] * i_65_ + 16383 >> 14);
  505. aShortArray7909[i_64_] = (short) i_67_;
  506. }
  507. if (i_15_ != 0) {
  508. int i_68_ = Class220.anIntArray2483[i_15_];
  509. int i_69_ = Class220.anIntArray2474[i_15_];
  510. int i_70_ = aShortArray7910[i_64_] * i_69_ - aShortArray7919[i_64_] * i_68_ + 16383 >> 14;
  511. aShortArray7919[i_64_] = (short) (aShortArray7910[i_64_] * i_68_ + aShortArray7919[i_64_] * i_69_ + 16383 >> 14);
  512. aShortArray7910[i_64_] = (short) i_70_;
  513. }
  514. if (i_16_ != 0) {
  515. int i_71_ = Class220.anIntArray2483[i_16_];
  516. int i_72_ = Class220.anIntArray2474[i_16_];
  517. int i_73_ = aShortArray7919[i_64_] * i_71_ + aShortArray7909[i_64_] * i_72_ + 16383 >> 14;
  518. aShortArray7919[i_64_] = (short) (aShortArray7919[i_64_] * i_72_ - aShortArray7909[i_64_] * i_71_ + 16383 >> 14);
  519. aShortArray7909[i_64_] = (short) i_73_;
  520. }
  521. }
  522. }
  523. }
  524. }
  525. method4839();
  526. }
  527. } else if (i == 3) {
  528. for (int i_74_ = 0; i_74_ < i_19_; i_74_++) {
  529. int i_75_ = is[i_74_];
  530. if (i_75_ < verticesByLabel.length) {
  531. int[] is_76_ = verticesByLabel[i_75_];
  532. for (int element : is_76_) {
  533. int i_78_ = element;
  534. vertices_x[i_78_] -= origin_x;
  535. vertices_y[i_78_] -= origin_y;
  536. vertices_z[i_78_] -= origin_z;
  537. vertices_x[i_78_] = vertices_x[i_78_] * i_15_ >> 7;
  538. vertices_y[i_78_] = vertices_y[i_78_] * i_16_ >> 7;
  539. vertices_z[i_78_] = vertices_z[i_78_] * i_17_ >> 7;
  540. vertices_x[i_78_] += origin_x;
  541. vertices_y[i_78_] += origin_y;
  542. vertices_z[i_78_] += origin_z;
  543. }
  544. }
  545. }
  546. } else if (i == 5) {
  547. if (anIntArrayArray7924 != null) {
  548. boolean bool_79_ = false;
  549. for (int i_80_ = 0; i_80_ < i_19_; i_80_++) {
  550. int i_81_ = is[i_80_];
  551. if (i_81_ < anIntArrayArray7924.length) {
  552. int[] is_82_ = anIntArrayArray7924[i_81_];
  553. for (int element : is_82_) {
  554. int i_84_ = element;
  555. int i_85_ = (aByteArray7963[i_84_] & 0xff) + i_15_ * 8;
  556. if (i_85_ < 0) {
  557. i_85_ = 0;
  558. } else if (i_85_ > 255) {
  559. i_85_ = 255;
  560. }
  561. aByteArray7963[i_84_] = (byte) i_85_;
  562. }
  563. bool_79_ = bool_79_ | is_82_.length > 0;
  564. }
  565. }
  566. if (bool_79_) {
  567. if (aClass191Array7952 != null) {
  568. for (int i_86_ = 0; i_86_ < anInt7951; i_86_++) {
  569. Class191 class191 = aClass191Array7952[i_86_];
  570. Class166 class166 = aClass166Array7892[i_86_];
  571. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  572. }
  573. }
  574. method4838();
  575. }
  576. }
  577. } else if (i == 7) {
  578. if (anIntArrayArray7924 != null) {
  579. boolean bool_87_ = false;
  580. for (int i_88_ = 0; i_88_ < i_19_; i_88_++) {
  581. int i_89_ = is[i_88_];
  582. if (i_89_ < anIntArrayArray7924.length) {
  583. int[] is_90_ = anIntArrayArray7924[i_89_];
  584. for (int element : is_90_) {
  585. int i_92_ = element;
  586. int i_93_ = aShortArray7935[i_92_] & 0xffff;
  587. int i_94_ = i_93_ >> 10 & 0x3f;
  588. int i_95_ = i_93_ >> 7 & 0x7;
  589. int i_96_ = i_93_ & 0x7f;
  590. i_94_ = i_94_ + i_15_ & 0x3f;
  591. i_95_ += i_16_ / 4;
  592. if (i_95_ < 0) {
  593. i_95_ = 0;
  594. } else if (i_95_ > 7) {
  595. i_95_ = 7;
  596. }
  597. i_96_ += i_17_;
  598. if (i_96_ < 0) {
  599. i_96_ = 0;
  600. } else if (i_96_ > 127) {
  601. i_96_ = 127;
  602. }
  603. aShortArray7935[i_92_] = (short) (i_94_ << 10 | i_95_ << 7 | i_96_);
  604. }
  605. bool_87_ = bool_87_ | is_90_.length > 0;
  606. }
  607. }
  608. if (bool_87_) {
  609. if (aClass191Array7952 != null) {
  610. for (int i_97_ = 0; i_97_ < anInt7951; i_97_++) {
  611. Class191 class191 = aClass191Array7952[i_97_];
  612. Class166 class166 = aClass166Array7892[i_97_];
  613. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  614. }
  615. }
  616. method4838();
  617. }
  618. }
  619. } else if (i == 8) {
  620. if (anIntArrayArray7946 != null) {
  621. for (int i_98_ = 0; i_98_ < i_19_; i_98_++) {
  622. int i_99_ = is[i_98_];
  623. if (i_99_ < anIntArrayArray7946.length) {
  624. int[] is_100_ = anIntArrayArray7946[i_99_];
  625. for (int element : is_100_) {
  626. Class166 class166 = aClass166Array7892[element];
  627. class166.anInt1704 += i_15_;
  628. class166.anInt1705 += i_16_;
  629. }
  630. }
  631. }
  632. }
  633. } else if (i == 10) {
  634. if (anIntArrayArray7946 != null) {
  635. for (int i_102_ = 0; i_102_ < i_19_; i_102_++) {
  636. int i_103_ = is[i_102_];
  637. if (i_103_ < anIntArrayArray7946.length) {
  638. int[] is_104_ = anIntArrayArray7946[i_103_];
  639. for (int element : is_104_) {
  640. Class166 class166 = aClass166Array7892[element];
  641. class166.anInt1702 = class166.anInt1702 * i_15_ >> 7;
  642. class166.anInt1701 = class166.anInt1701 * i_16_ >> 7;
  643. }
  644. }
  645. }
  646. }
  647. } else if (i == 9) {
  648. if (anIntArrayArray7946 != null) {
  649. for (int i_106_ = 0; i_106_ < i_19_; i_106_++) {
  650. int i_107_ = is[i_106_];
  651. if (i_107_ < anIntArrayArray7946.length) {
  652. int[] is_108_ = anIntArrayArray7946[i_107_];
  653. for (int element : is_108_) {
  654. Class166 class166 = aClass166Array7892[element];
  655. class166.anInt1706 = class166.anInt1706 + i_15_ & 0x3fff;
  656. }
  657. }
  658. }
  659. }
  660. }
  661. }
  662.  
  663. @Override
  664. public void method4784() {
  665. if (anInt7906 > 0 && anInt7917 > 0) {
  666. method4844();
  667. method4835();
  668. method4837();
  669. }
  670. }
  671.  
  672. @Override
  673. public Class387 method4755(byte i, int i_110_, boolean bool) {
  674. boolean bool_111_ = false;
  675. Class387_Sub3 class387_sub3_112_;
  676. Class387_Sub3 class387_sub3_113_;
  677. if (i > 0 && i <= 7) {
  678. class387_sub3_113_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8267[i - 1];
  679. class387_sub3_112_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8288[i - 1];
  680. bool_111_ = true;
  681. } else {
  682. class387_sub3_112_ = class387_sub3_113_ = new Class387_Sub3(aClass_ra_Sub3_7894, 0, 0, true, false);
  683. }
  684. return method4836(class387_sub3_112_, class387_sub3_113_, i_110_, bool_111_, bool);
  685. }
  686.  
  687. Class387 method4836(Class387_Sub3 class387_sub3_114_, Class387_Sub3 class387_sub3_115_, int i, boolean bool, boolean bool_116_) {
  688. class387_sub3_114_.anInt7912 = i;
  689. class387_sub3_114_.anInt7896 = anInt7896;
  690. class387_sub3_114_.aShort7897 = aShort7897;
  691. class387_sub3_114_.aShort7898 = aShort7898;
  692. class387_sub3_114_.anInt7899 = anInt7899;
  693. class387_sub3_114_.anInt7900 = anInt7900;
  694. class387_sub3_114_.anInt7906 = anInt7906;
  695. class387_sub3_114_.anInt7916 = anInt7916;
  696. class387_sub3_114_.anInt7917 = anInt7917;
  697. class387_sub3_114_.anInt7951 = anInt7951;
  698. if ((i & 0x100) != 0) {
  699. class387_sub3_114_.aBoolean7893 = true;
  700. } else {
  701. class387_sub3_114_.aBoolean7893 = aBoolean7893;
  702. }
  703. class387_sub3_114_.aBoolean7903 = aBoolean7903;
  704. boolean bool_117_ = Class154.method1659(i, anInt7896);
  705. boolean bool_118_ = Class154.method1670(i, anInt7896);
  706. boolean bool_119_ = Class154.method1660(i, anInt7896);
  707. boolean bool_120_ = bool_117_ | bool_118_ | bool_119_;
  708. if (bool_120_) {
  709. if (bool_117_) {
  710. if (class387_sub3_115_.vertices_x == null || class387_sub3_115_.vertices_x.length < anInt7899) {
  711. class387_sub3_114_.vertices_x = class387_sub3_115_.vertices_x = new int[anInt7899];
  712. } else {
  713. class387_sub3_114_.vertices_x = class387_sub3_115_.vertices_x;
  714. }
  715. } else {
  716. class387_sub3_114_.vertices_x = vertices_x;
  717. }
  718. if (bool_118_) {
  719. if (class387_sub3_115_.vertices_y == null || class387_sub3_115_.vertices_y.length < anInt7899) {
  720. class387_sub3_114_.vertices_y = class387_sub3_115_.vertices_y = new int[anInt7899];
  721. } else {
  722. class387_sub3_114_.vertices_y = class387_sub3_115_.vertices_y;
  723. }
  724. } else {
  725. class387_sub3_114_.vertices_y = vertices_y;
  726. }
  727. if (bool_119_) {
  728. if (class387_sub3_115_.vertices_z == null || class387_sub3_115_.vertices_z.length < anInt7899) {
  729. class387_sub3_114_.vertices_z = class387_sub3_115_.vertices_z = new int[anInt7899];
  730. } else {
  731. class387_sub3_114_.vertices_z = class387_sub3_115_.vertices_z;
  732. }
  733. } else {
  734. class387_sub3_114_.vertices_z = vertices_z;
  735. }
  736. for (int i_121_ = 0; i_121_ < anInt7899; i_121_++) {
  737. if (bool_117_) {
  738. class387_sub3_114_.vertices_x[i_121_] = vertices_x[i_121_];
  739. }
  740. if (bool_118_) {
  741. class387_sub3_114_.vertices_y[i_121_] = vertices_y[i_121_];
  742. }
  743. if (bool_119_) {
  744. class387_sub3_114_.vertices_z[i_121_] = vertices_z[i_121_];
  745. }
  746. }
  747. } else {
  748. class387_sub3_114_.vertices_x = vertices_x;
  749. class387_sub3_114_.vertices_y = vertices_y;
  750. class387_sub3_114_.vertices_z = vertices_z;
  751. }
  752. if (Class154.method1685(i, anInt7896)) {
  753. class387_sub3_114_.aClass186_7927 = class387_sub3_115_.aClass186_7927;
  754. class387_sub3_114_.aClass186_7927.anInterface7_Impl1_1902 = aClass186_7927.anInterface7_Impl1_1902;
  755. class387_sub3_114_.aClass186_7927.aBoolean1900 = aClass186_7927.aBoolean1900;
  756. class387_sub3_114_.aClass186_7927.aBoolean1901 = true;
  757. } else if (Class154.method1671(i, anInt7896)) {
  758. class387_sub3_114_.aClass186_7927 = aClass186_7927;
  759. } else {
  760. class387_sub3_114_.aClass186_7927 = null;
  761. }
  762. if (Class154.method1662(i, anInt7896)) {
  763. if (class387_sub3_115_.aShortArray7935 == null || class387_sub3_115_.aShortArray7935.length < anInt7916) {
  764. class387_sub3_114_.aShortArray7935 = class387_sub3_115_.aShortArray7935 = new short[anInt7916];
  765. } else {
  766. class387_sub3_114_.aShortArray7935 = class387_sub3_115_.aShortArray7935;
  767. }
  768. for (int i_122_ = 0; i_122_ < anInt7916; i_122_++) {
  769. class387_sub3_114_.aShortArray7935[i_122_] = aShortArray7935[i_122_];
  770. }
  771. } else {
  772. class387_sub3_114_.aShortArray7935 = aShortArray7935;
  773. }
  774. if (Class154.method1663(i, anInt7896)) {
  775. if (class387_sub3_115_.aByteArray7963 == null || class387_sub3_115_.aByteArray7963.length < anInt7916) {
  776. class387_sub3_114_.aByteArray7963 = class387_sub3_115_.aByteArray7963 = new byte[anInt7916];
  777. } else {
  778. class387_sub3_114_.aByteArray7963 = class387_sub3_115_.aByteArray7963;
  779. }
  780. for (int i_123_ = 0; i_123_ < anInt7916; i_123_++) {
  781. class387_sub3_114_.aByteArray7963[i_123_] = aByteArray7963[i_123_];
  782. }
  783. } else {
  784. class387_sub3_114_.aByteArray7963 = aByteArray7963;
  785. }
  786. if (Class154.method1680(i, anInt7896)) {
  787. class387_sub3_114_.aClass186_7911 = class387_sub3_115_.aClass186_7911;
  788. class387_sub3_114_.aClass186_7911.anInterface7_Impl1_1902 = aClass186_7911.anInterface7_Impl1_1902;
  789. class387_sub3_114_.aClass186_7911.aBoolean1900 = aClass186_7911.aBoolean1900;
  790. class387_sub3_114_.aClass186_7911.aBoolean1901 = true;
  791. } else if (Class154.method1667(i, anInt7896)) {
  792. class387_sub3_114_.aClass186_7911 = aClass186_7911;
  793. } else {
  794. class387_sub3_114_.aClass186_7911 = null;
  795. }
  796. if (Class154.method1661(i, anInt7896)) {
  797. if (class387_sub3_115_.aShortArray7909 == null || class387_sub3_115_.aShortArray7909.length < anInt7906) {
  798. int i_124_ = anInt7906;
  799. class387_sub3_114_.aShortArray7909 = class387_sub3_115_.aShortArray7909 = new short[i_124_];
  800. class387_sub3_114_.aShortArray7910 = class387_sub3_115_.aShortArray7910 = new short[i_124_];
  801. class387_sub3_114_.aShortArray7919 = class387_sub3_115_.aShortArray7919 = new short[i_124_];
  802. } else {
  803. class387_sub3_114_.aShortArray7909 = class387_sub3_115_.aShortArray7909;
  804. class387_sub3_114_.aShortArray7910 = class387_sub3_115_.aShortArray7910;
  805. class387_sub3_114_.aShortArray7919 = class387_sub3_115_.aShortArray7919;
  806. }
  807. if (aClass185_7915 != null) {
  808. if (class387_sub3_115_.aClass185_7915 == null) {
  809. class387_sub3_115_.aClass185_7915 = new Class185();
  810. }
  811. Class185 class185 = class387_sub3_114_.aClass185_7915 = class387_sub3_115_.aClass185_7915;
  812. if (class185.aShortArray1899 == null || class185.aShortArray1899.length < anInt7906) {
  813. int i_125_ = anInt7906;
  814. class185.aShortArray1899 = new short[i_125_];
  815. class185.aShortArray1897 = new short[i_125_];
  816. class185.aShortArray1896 = new short[i_125_];
  817. class185.aByteArray1898 = new byte[i_125_];
  818. }
  819. for (int i_126_ = 0; i_126_ < anInt7906; i_126_++) {
  820. class387_sub3_114_.aShortArray7909[i_126_] = aShortArray7909[i_126_];
  821. class387_sub3_114_.aShortArray7910[i_126_] = aShortArray7910[i_126_];
  822. class387_sub3_114_.aShortArray7919[i_126_] = aShortArray7919[i_126_];
  823. class185.aShortArray1899[i_126_] = aClass185_7915.aShortArray1899[i_126_];
  824. class185.aShortArray1897[i_126_] = aClass185_7915.aShortArray1897[i_126_];
  825. class185.aShortArray1896[i_126_] = aClass185_7915.aShortArray1896[i_126_];
  826. class185.aByteArray1898[i_126_] = aClass185_7915.aByteArray1898[i_126_];
  827. }
  828. } else {
  829. class387_sub3_114_.aClass185_7915 = null;
  830. for (int i_127_ = 0; i_127_ < anInt7906; i_127_++) {
  831. class387_sub3_114_.aShortArray7909[i_127_] = aShortArray7909[i_127_];
  832. class387_sub3_114_.aShortArray7910[i_127_] = aShortArray7910[i_127_];
  833. class387_sub3_114_.aShortArray7919[i_127_] = aShortArray7919[i_127_];
  834. }
  835. }
  836. class387_sub3_114_.aByteArray7958 = aByteArray7958;
  837. } else {
  838. class387_sub3_114_.aClass185_7915 = aClass185_7915;
  839. class387_sub3_114_.aShortArray7909 = aShortArray7909;
  840. class387_sub3_114_.aShortArray7910 = aShortArray7910;
  841. class387_sub3_114_.aShortArray7919 = aShortArray7919;
  842. class387_sub3_114_.aByteArray7958 = aByteArray7958;
  843. }
  844. if (Class154.method1669(i, anInt7896)) {
  845. class387_sub3_114_.aClass186_7934 = class387_sub3_115_.aClass186_7934;
  846. class387_sub3_114_.aClass186_7934.anInterface7_Impl1_1902 = aClass186_7934.anInterface7_Impl1_1902;
  847. class387_sub3_114_.aClass186_7934.aBoolean1900 = aClass186_7934.aBoolean1900;
  848. class387_sub3_114_.aClass186_7934.aBoolean1901 = true;
  849. } else if (Class154.method1690(i, anInt7896)) {
  850. class387_sub3_114_.aClass186_7934 = aClass186_7934;
  851. } else {
  852. class387_sub3_114_.aClass186_7934 = null;
  853. }
  854. if (Class154.method1664(i, anInt7896)) {
  855. if (class387_sub3_115_.aFloatArray7953 == null || class387_sub3_115_.aFloatArray7953.length < anInt7916) {
  856. int i_128_ = anInt7906;
  857. class387_sub3_114_.aFloatArray7953 = class387_sub3_115_.aFloatArray7953 = new float[i_128_];
  858. class387_sub3_114_.aFloatArray7914 = class387_sub3_115_.aFloatArray7914 = new float[i_128_];
  859. } else {
  860. class387_sub3_114_.aFloatArray7953 = class387_sub3_115_.aFloatArray7953;
  861. class387_sub3_114_.aFloatArray7914 = class387_sub3_115_.aFloatArray7914;
  862. }
  863. for (int i_129_ = 0; i_129_ < anInt7906; i_129_++) {
  864. class387_sub3_114_.aFloatArray7953[i_129_] = aFloatArray7953[i_129_];
  865. class387_sub3_114_.aFloatArray7914[i_129_] = aFloatArray7914[i_129_];
  866. }
  867. } else {
  868. class387_sub3_114_.aFloatArray7953 = aFloatArray7953;
  869. class387_sub3_114_.aFloatArray7914 = aFloatArray7914;
  870. }
  871. if (Class154.method1692(i, anInt7896)) {
  872. class387_sub3_114_.aClass186_7930 = class387_sub3_115_.aClass186_7930;
  873. class387_sub3_114_.aClass186_7930.anInterface7_Impl1_1902 = aClass186_7930.anInterface7_Impl1_1902;
  874. class387_sub3_114_.aClass186_7930.aBoolean1900 = aClass186_7930.aBoolean1900;
  875. class387_sub3_114_.aClass186_7930.aBoolean1901 = true;
  876. } else if (Class154.method1683(i, anInt7896)) {
  877. class387_sub3_114_.aClass186_7930 = aClass186_7930;
  878. } else {
  879. class387_sub3_114_.aClass186_7930 = null;
  880. }
  881. if (Class154.method1682(i, anInt7896)) {
  882. if (class387_sub3_115_.aShortArray7920 == null || class387_sub3_115_.aShortArray7920.length < anInt7916) {
  883. int i_130_ = anInt7916;
  884. class387_sub3_114_.aShortArray7920 = class387_sub3_115_.aShortArray7920 = new short[i_130_];
  885. class387_sub3_114_.aShortArray7921 = class387_sub3_115_.aShortArray7921 = new short[i_130_];
  886. class387_sub3_114_.aShortArray7922 = class387_sub3_115_.aShortArray7922 = new short[i_130_];
  887. } else {
  888. class387_sub3_114_.aShortArray7920 = class387_sub3_115_.aShortArray7920;
  889. class387_sub3_114_.aShortArray7921 = class387_sub3_115_.aShortArray7921;
  890. class387_sub3_114_.aShortArray7922 = class387_sub3_115_.aShortArray7922;
  891. }
  892. for (int i_131_ = 0; i_131_ < anInt7916; i_131_++) {
  893. class387_sub3_114_.aShortArray7920[i_131_] = aShortArray7920[i_131_];
  894. class387_sub3_114_.aShortArray7921[i_131_] = aShortArray7921[i_131_];
  895. class387_sub3_114_.aShortArray7922[i_131_] = aShortArray7922[i_131_];
  896. }
  897. } else {
  898. class387_sub3_114_.aShortArray7920 = aShortArray7920;
  899. class387_sub3_114_.aShortArray7921 = aShortArray7921;
  900. class387_sub3_114_.aShortArray7922 = aShortArray7922;
  901. }
  902. if (Class154.method1686(i, anInt7896)) {
  903. class387_sub3_114_.aClass167_7926 = class387_sub3_115_.aClass167_7926;
  904. class387_sub3_114_.aClass167_7926.anInterface7_Impl2_1707 = aClass167_7926.anInterface7_Impl2_1707;
  905. class387_sub3_114_.aClass167_7926.aBoolean1710 = aClass167_7926.aBoolean1710;
  906. class387_sub3_114_.aClass167_7926.aBoolean1708 = true;
  907. } else if (Class154.method1668(i, anInt7896)) {
  908. class387_sub3_114_.aClass167_7926 = aClass167_7926;
  909. } else {
  910. class387_sub3_114_.aClass167_7926 = null;
  911. }
  912. if (Class154.method1665(i, anInt7896)) {
  913. if (class387_sub3_115_.aShortArray7923 == null || class387_sub3_115_.aShortArray7923.length < anInt7916) {
  914. int i_132_ = anInt7916;
  915. class387_sub3_114_.aShortArray7923 = class387_sub3_115_.aShortArray7923 = new short[i_132_];
  916. } else {
  917. class387_sub3_114_.aShortArray7923 = class387_sub3_115_.aShortArray7923;
  918. }
  919. for (int i_133_ = 0; i_133_ < anInt7916; i_133_++) {
  920. class387_sub3_114_.aShortArray7923[i_133_] = aShortArray7923[i_133_];
  921. }
  922. } else {
  923. class387_sub3_114_.aShortArray7923 = aShortArray7923;
  924. }
  925. if (Class154.method1666(i, anInt7896)) {
  926. if (class387_sub3_115_.aClass166Array7892 == null || class387_sub3_115_.aClass166Array7892.length < anInt7951) {
  927. int i_134_ = anInt7951;
  928. class387_sub3_114_.aClass166Array7892 = class387_sub3_115_.aClass166Array7892 = new Class166[i_134_];
  929. for (int i_135_ = 0; i_135_ < anInt7951; i_135_++) {
  930. class387_sub3_114_.aClass166Array7892[i_135_] = aClass166Array7892[i_135_].method1785();
  931. }
  932. } else {
  933. class387_sub3_114_.aClass166Array7892 = class387_sub3_115_.aClass166Array7892;
  934. for (int i_136_ = 0; i_136_ < anInt7951; i_136_++) {
  935. class387_sub3_114_.aClass166Array7892[i_136_].method1786(aClass166Array7892[i_136_]);
  936. }
  937. }
  938. } else {
  939. class387_sub3_114_.aClass166Array7892 = aClass166Array7892;
  940. }
  941. class387_sub3_114_.aClass191Array7952 = aClass191Array7952;
  942. if (aBoolean7950) {
  943. class387_sub3_114_.anInt7928 = anInt7928;
  944. class387_sub3_114_.anInt7936 = anInt7936;
  945. class387_sub3_114_.anInt7940 = anInt7940;
  946. class387_sub3_114_.anInt7941 = anInt7941;
  947. class387_sub3_114_.anInt7938 = anInt7938;
  948. class387_sub3_114_.anInt7939 = anInt7939;
  949. class387_sub3_114_.anInt7942 = anInt7942;
  950. class387_sub3_114_.anInt7943 = anInt7943;
  951. class387_sub3_114_.aBoolean7950 = true;
  952. } else {
  953. class387_sub3_114_.aBoolean7950 = false;
  954. }
  955. class387_sub3_114_.verticesByLabel = verticesByLabel;
  956. class387_sub3_114_.anIntArrayArray7924 = anIntArrayArray7924;
  957. class387_sub3_114_.anIntArrayArray7946 = anIntArrayArray7946;
  958. class387_sub3_114_.aShortArray7948 = aShortArray7948;
  959. class387_sub3_114_.anIntArray7947 = anIntArray7947;
  960. class387_sub3_114_.aShortArray7907 = aShortArray7907;
  961. class387_sub3_114_.aShortArray7908 = aShortArray7908;
  962. class387_sub3_114_.aShortArray7964 = aShortArray7964;
  963. class387_sub3_114_.aShortArray7925 = aShortArray7925;
  964. class387_sub3_114_.anIntArray7944 = anIntArray7944;
  965. class387_sub3_114_.anIntArray7913 = anIntArray7913;
  966. class387_sub3_114_.anIntArray7945 = anIntArray7945;
  967. class387_sub3_114_.aClass85Array7949 = aClass85Array7949;
  968. class387_sub3_114_.aClass68Array7904 = aClass68Array7904;
  969. return class387_sub3_114_;
  970. }
  971.  
  972. void method4837() {
  973. if (aBoolean7932) {
  974. aBoolean7932 = false;
  975. if (aClass85Array7949 == null && aClass68Array7904 == null && aClass191Array7952 == null && !Class154.method1689(anInt7912, anInt7896)) {
  976. boolean bool = false;
  977. boolean bool_137_ = false;
  978. boolean bool_138_ = false;
  979. if (vertices_x != null && !Class154.method1672(anInt7912, anInt7896)) {
  980. if (aClass186_7927 == null || aClass186_7927.method1848()) {
  981. if (!aBoolean7950) {
  982. method4832();
  983. }
  984. bool = true;
  985. } else {
  986. aBoolean7932 = true;
  987. }
  988. }
  989. if (vertices_y != null && !Class154.method1673(anInt7912, anInt7896)) {
  990. if (aClass186_7927 == null || aClass186_7927.method1848()) {
  991. if (!aBoolean7950) {
  992. method4832();
  993. }
  994. bool_137_ = true;
  995. } else {
  996. aBoolean7932 = true;
  997. }
  998. }
  999. if (vertices_z != null && !Class154.method1674(anInt7912, anInt7896)) {
  1000. if (aClass186_7927 == null || aClass186_7927.method1848()) {
  1001. if (!aBoolean7950) {
  1002. method4832();
  1003. }
  1004. bool_138_ = true;
  1005. } else {
  1006. aBoolean7932 = true;
  1007. }
  1008. }
  1009. if (bool) {
  1010. vertices_x = null;
  1011. }
  1012. if (bool_137_) {
  1013. vertices_y = null;
  1014. }
  1015. if (bool_138_) {
  1016. vertices_z = null;
  1017. }
  1018. }
  1019. if (aShortArray7948 != null && vertices_x == null && vertices_y == null && vertices_z == null) {
  1020. aShortArray7948 = null;
  1021. anIntArray7947 = null;
  1022. }
  1023. while_121_: do {
  1024. if (aByteArray7958 != null && !Class154.method1675(anInt7912, anInt7896)) {
  1025. do {
  1026. if ((anInt7896 & 0x37) != 0) {
  1027. if (aClass186_7934 != null && !aClass186_7934.method1848()) {
  1028. break;
  1029. }
  1030. } else if (aClass186_7911 != null && !aClass186_7911.method1848()) {
  1031. break;
  1032. }
  1033. aShortArray7919 = null;
  1034. aShortArray7910 = null;
  1035. aShortArray7909 = null;
  1036. aByteArray7958 = null;
  1037. break while_121_;
  1038. } while (false);
  1039. aBoolean7932 = true;
  1040. }
  1041. } while (false);
  1042. if (aShortArray7935 != null && !Class154.method1688(anInt7912, anInt7896)) {
  1043. if (aClass186_7911 == null || aClass186_7911.method1848()) {
  1044. aShortArray7935 = null;
  1045. } else {
  1046. aBoolean7932 = true;
  1047. }
  1048. }
  1049. if (aByteArray7963 != null && !Class154.method1687(anInt7912, anInt7896)) {
  1050. if (aClass186_7911 == null || aClass186_7911.method1848()) {
  1051. aByteArray7963 = null;
  1052. } else {
  1053. aBoolean7932 = true;
  1054. }
  1055. }
  1056. if (aFloatArray7953 != null && !Class154.method1676(anInt7912, anInt7896)) {
  1057. if (aClass186_7930 == null || aClass186_7930.method1848()) {
  1058. aFloatArray7914 = null;
  1059. aFloatArray7953 = null;
  1060. } else {
  1061. aBoolean7932 = true;
  1062. }
  1063. }
  1064. if (aShortArray7923 != null && !Class154.method1681(anInt7912, anInt7896)) {
  1065. if (aClass186_7911 == null || aClass186_7911.method1848()) {
  1066. aShortArray7923 = null;
  1067. } else {
  1068. aBoolean7932 = true;
  1069. }
  1070. }
  1071. if (aShortArray7920 != null && !Class154.method1691(anInt7912, anInt7896)) {
  1072. if ((aClass167_7926 == null || aClass167_7926.method1787()) && (aClass186_7911 == null || aClass186_7911.method1848())) {
  1073. aShortArray7922 = null;
  1074. aShortArray7921 = null;
  1075. aShortArray7920 = null;
  1076. } else {
  1077. aBoolean7932 = true;
  1078. }
  1079. }
  1080. if (aShortArray7907 != null) {
  1081. if (aClass186_7927 == null || aClass186_7927.method1848()) {
  1082. aShortArray7907 = null;
  1083. } else {
  1084. aBoolean7932 = true;
  1085. }
  1086. }
  1087. if (aShortArray7908 != null) {
  1088. if (aClass186_7911 == null || aClass186_7911.method1848()) {
  1089. aShortArray7908 = null;
  1090. } else {
  1091. aBoolean7932 = true;
  1092. }
  1093. }
  1094. if (anIntArrayArray7924 != null && !Class154.method1677(anInt7912, anInt7896)) {
  1095. anIntArrayArray7924 = null;
  1096. aShortArray7925 = null;
  1097. }
  1098. if (verticesByLabel != null && !Class154.method1678(anInt7912, anInt7896)) {
  1099. verticesByLabel = null;
  1100. aShortArray7964 = null;
  1101. }
  1102. if (anIntArrayArray7946 != null && !Class154.method1679(anInt7912, anInt7896)) {
  1103. anIntArrayArray7946 = null;
  1104. }
  1105. if (anIntArray7944 != null && (anInt7912 & 0x800) == 0 && (anInt7912 & 0x40000) == 0) {
  1106. anIntArray7944 = null;
  1107. anIntArray7913 = null;
  1108. anIntArray7945 = null;
  1109. }
  1110. }
  1111. }
  1112.  
  1113. @Override
  1114. public Class68[] method4775() {
  1115. return aClass68Array7904;
  1116. }
  1117.  
  1118. void method4838() {
  1119. if (aClass186_7911 != null) {
  1120. aClass186_7911.aBoolean1900 = false;
  1121. }
  1122. }
  1123.  
  1124. void method4839() {
  1125. if ((anInt7896 & 0x37) != 0) {
  1126. if (aClass186_7934 != null) {
  1127. aClass186_7934.aBoolean1900 = false;
  1128. }
  1129. } else if (aClass186_7911 != null) {
  1130. aClass186_7911.aBoolean1900 = false;
  1131. }
  1132. }
  1133.  
  1134. @Override
  1135. public Class_na ct(Class_na class_na) {
  1136. if (anInt7906 == 0) {
  1137. return null;
  1138. }
  1139. if (!aBoolean7950) {
  1140. method4832();
  1141. }
  1142. int i;
  1143. int i_139_;
  1144. if (aClass_ra_Sub3_7894.anInt8299 > 0) {
  1145. i = anInt7940 - (anInt7939 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1146. i_139_ = anInt7941 - (anInt7938 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1147. } else {
  1148. i = anInt7940 - (anInt7938 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1149. i_139_ = anInt7941 - (anInt7939 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1150. }
  1151. int i_140_;
  1152. int i_141_;
  1153. if (aClass_ra_Sub3_7894.anInt8317 > 0) {
  1154. i_140_ = anInt7942 - (anInt7939 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1155. i_141_ = anInt7943 - (anInt7938 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1156. } else {
  1157. i_140_ = anInt7942 - (anInt7938 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1158. i_141_ = anInt7943 - (anInt7939 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  1159. }
  1160. int i_142_ = i_139_ - i + 1;
  1161. int i_143_ = i_141_ - i_140_ + 1;
  1162. Class_na_Sub2 class_na_sub2 = (Class_na_Sub2) class_na;
  1163. Class_na_Sub2 class_na_sub2_144_;
  1164. if (class_na_sub2 != null && class_na_sub2.method3489(i_142_, i_143_)) {
  1165. class_na_sub2_144_ = class_na_sub2;
  1166. class_na_sub2_144_.method3487();
  1167. } else {
  1168. class_na_sub2_144_ = new Class_na_Sub2(aClass_ra_Sub3_7894, i_142_, i_143_);
  1169. }
  1170. class_na_sub2_144_.method3486(i, i_140_, i_139_, i_141_);
  1171. method4842(class_na_sub2_144_);
  1172. return class_na_sub2_144_;
  1173. }
  1174.  
  1175. @Override
  1176. public void f(int i) {
  1177. int i_145_ = Class220.anIntArray2483[i];
  1178. int i_146_ = Class220.anIntArray2474[i];
  1179. for (int i_147_ = 0; i_147_ < anInt7900; i_147_++) {
  1180. int i_148_ = vertices_z[i_147_] * i_145_ + vertices_x[i_147_] * i_146_ >> 14;
  1181. vertices_z[i_147_] = vertices_z[i_147_] * i_146_ - vertices_x[i_147_] * i_145_ >> 14;
  1182. vertices_x[i_147_] = i_148_;
  1183. }
  1184. method4851();
  1185. aBoolean7950 = false;
  1186. }
  1187.  
  1188. @Override
  1189. public void t(int i) {
  1190. int i_149_ = Class220.anIntArray2483[i];
  1191. int i_150_ = Class220.anIntArray2474[i];
  1192. for (int i_151_ = 0; i_151_ < anInt7900; i_151_++) {
  1193. int i_152_ = vertices_y[i_151_] * i_150_ - vertices_z[i_151_] * i_149_ >> 14;
  1194. vertices_z[i_151_] = vertices_y[i_151_] * i_149_ + vertices_z[i_151_] * i_150_ >> 14;
  1195. vertices_y[i_151_] = i_152_;
  1196. }
  1197. method4851();
  1198. aBoolean7950 = false;
  1199. }
  1200.  
  1201. @Override
  1202. public void EA(int i) {
  1203. int i_153_ = Class220.anIntArray2483[i];
  1204. int i_154_ = Class220.anIntArray2474[i];
  1205. for (int i_155_ = 0; i_155_ < anInt7900; i_155_++) {
  1206. int i_156_ = vertices_y[i_155_] * i_153_ + vertices_x[i_155_] * i_154_ >> 14;
  1207. vertices_y[i_155_] = vertices_y[i_155_] * i_154_ - vertices_x[i_155_] * i_153_ >> 14;
  1208. vertices_x[i_155_] = i_156_;
  1209. }
  1210. method4851();
  1211. aBoolean7950 = false;
  1212. }
  1213.  
  1214. @Override
  1215. public void ia(int i, int i_157_, int i_158_) {
  1216. for (int i_159_ = 0; i_159_ < anInt7900; i_159_++) {
  1217. if (i != 0) {
  1218. vertices_x[i_159_] += i;
  1219. }
  1220. if (i_157_ != 0) {
  1221. vertices_y[i_159_] += i_157_;
  1222. }
  1223. if (i_158_ != 0) {
  1224. vertices_z[i_159_] += i_158_;
  1225. }
  1226. }
  1227. method4851();
  1228. aBoolean7950 = false;
  1229. }
  1230.  
  1231. @Override
  1232. public byte[] ah() {
  1233. return aByteArray7963;
  1234. }
  1235.  
  1236. @Override
  1237. public void oa(int i, int i_160_, int i_161_) {
  1238. for (int i_162_ = 0; i_162_ < anInt7900; i_162_++) {
  1239. if (i != 128) {
  1240. vertices_x[i_162_] = vertices_x[i_162_] * i >> 7;
  1241. }
  1242. if (i_160_ != 128) {
  1243. vertices_y[i_162_] = vertices_y[i_162_] * i_160_ >> 7;
  1244. }
  1245. if (i_161_ != 128) {
  1246. vertices_z[i_162_] = vertices_z[i_162_] * i_161_ >> 7;
  1247. }
  1248. }
  1249. method4851();
  1250. aBoolean7950 = false;
  1251. }
  1252.  
  1253. @Override
  1254. public Class387 method4748(byte i, int i_163_, boolean bool) {
  1255. boolean bool_164_ = false;
  1256. Class387_Sub3 class387_sub3_165_;
  1257. Class387_Sub3 class387_sub3_166_;
  1258. if (i > 0 && i <= 7) {
  1259. class387_sub3_166_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8267[i - 1];
  1260. class387_sub3_165_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8288[i - 1];
  1261. bool_164_ = true;
  1262. } else {
  1263. class387_sub3_165_ = class387_sub3_166_ = new Class387_Sub3(aClass_ra_Sub3_7894, 0, 0, true, false);
  1264. }
  1265. return method4836(class387_sub3_165_, class387_sub3_166_, i_163_, bool_164_, bool);
  1266. }
  1267.  
  1268. @Override
  1269. public void pa(int i, int i_167_, Class_xa class_xa, Class_xa class_xa_168_, int i_169_, int i_170_, int i_171_) {
  1270. if (!aBoolean7950) {
  1271. method4832();
  1272. }
  1273. int i_172_ = i_169_ + anInt7940;
  1274. int i_173_ = i_169_ + anInt7941;
  1275. int i_174_ = i_171_ + anInt7942;
  1276. int i_175_ = i_171_ + anInt7943;
  1277. if (i != 1 && i != 2 && i != 3 && i != 5 || i_172_ >= 0 && i_173_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6287 * -506105871 && i_174_ >= 0 && i_175_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6286 * -1148794921) {
  1278. if (i == 4 || i == 5) {
  1279. if (class_xa_168_ == null || i_172_ < 0 || i_173_ + class_xa_168_.anInt6288 * -1212653763 >> class_xa_168_.anInt6289 * -2137349879 >= class_xa_168_.anInt6287 * -506105871 || i_174_ < 0 || i_175_ + class_xa_168_.anInt6288 * -1212653763 >> class_xa_168_.anInt6289 * -2137349879 >= class_xa_168_.anInt6286 * -1148794921) {
  1280. return;
  1281. }
  1282. } else {
  1283. i_172_ >>= class_xa.anInt6289 * -2137349879;
  1284. i_173_ = i_173_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  1285. i_174_ >>= class_xa.anInt6289 * -2137349879;
  1286. i_175_ = i_175_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  1287. if (class_xa.method6341(i_172_, i_174_, (byte) -124) == i_170_ && class_xa.method6341(i_173_, i_174_, (byte) -30) == i_170_ && class_xa.method6341(i_172_, i_175_, (byte) -100) == i_170_ && class_xa.method6341(i_173_, i_175_, (byte) -104) == i_170_) {
  1288. return;
  1289. }
  1290. }
  1291. if (i == 1) {
  1292. for (int i_176_ = 0; i_176_ < anInt7900; i_176_++) {
  1293. vertices_y[i_176_] = vertices_y[i_176_] + class_xa.method6340(vertices_x[i_176_] + i_169_, vertices_z[i_176_] + i_171_, -1680457516) - i_170_;
  1294. }
  1295. } else if (i == 2) {
  1296. int i_177_ = anInt7938;
  1297. if (i_177_ == 0) {
  1298. return;
  1299. }
  1300. for (int i_178_ = 0; i_178_ < anInt7900; i_178_++) {
  1301. int i_179_ = (vertices_y[i_178_] << 16) / i_177_;
  1302. if (i_179_ < i_167_) {
  1303. vertices_y[i_178_] = vertices_y[i_178_] + (class_xa.method6340(vertices_x[i_178_] + i_169_, vertices_z[i_178_] + i_171_, -1706111217) - i_170_) * (i_167_ - i_179_) / i_167_;
  1304. }
  1305. }
  1306. } else if (i == 3) {
  1307. int i_180_ = (i_167_ & 0xff) * 4;
  1308. int i_181_ = (i_167_ >> 8 & 0xff) * 4;
  1309. int i_182_ = (i_167_ >> 16 & 0xff) << 6;
  1310. int i_183_ = (i_167_ >> 24 & 0xff) << 6;
  1311. if (i_169_ - (i_180_ >> 1) < 0 || i_169_ + (i_180_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6287 * -506105871 << class_xa.anInt6289 * -2137349879 || i_171_ - (i_181_ >> 1) < 0 || i_171_ + (i_181_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6286 * -1148794921 << class_xa.anInt6289 * -2137349879) {
  1312. return;
  1313. }
  1314. method4732(class_xa, i_169_, i_170_, i_171_, i_180_, i_181_, i_182_, i_183_);
  1315. } else if (i == 4) {
  1316. int i_184_ = anInt7939 - anInt7938;
  1317. for (int i_185_ = 0; i_185_ < anInt7900; i_185_++) {
  1318. vertices_y[i_185_] = vertices_y[i_185_] + class_xa_168_.method6340(vertices_x[i_185_] + i_169_, vertices_z[i_185_] + i_171_, -1523371782) - i_170_ + i_184_;
  1319. }
  1320. } else if (i == 5) {
  1321. int i_186_ = anInt7939 - anInt7938;
  1322. for (int i_187_ = 0; i_187_ < anInt7900; i_187_++) {
  1323. int i_188_ = vertices_x[i_187_] + i_169_;
  1324. int i_189_ = vertices_z[i_187_] + i_171_;
  1325. int i_190_ = class_xa.method6340(i_188_, i_189_, -1428452858);
  1326. int i_191_ = class_xa_168_.method6340(i_188_, i_189_, -2144565564);
  1327. int i_192_ = i_190_ - i_191_ - i_167_;
  1328. vertices_y[i_187_] = ((vertices_y[i_187_] << 8) / i_186_ * i_192_ >> 8) - (i_170_ - i_190_);
  1329. }
  1330. }
  1331. method4851();
  1332. aBoolean7950 = false;
  1333. }
  1334. }
  1335.  
  1336. void method4840() {
  1337. if (aClass167_7926 != null) {
  1338. aClass167_7926.aBoolean1710 = false;
  1339. }
  1340. }
  1341.  
  1342. Class387_Sub3(Class_ra_Sub3 class_ra_sub3, int i, int i_193_, boolean bool, boolean bool_194_) {
  1343. aBoolean7893 = false;
  1344. aBoolean7903 = false;
  1345. aBoolean7950 = false;
  1346. aClass_ra_Sub3_7894 = class_ra_sub3;
  1347. anInt7912 = i;
  1348. anInt7896 = i_193_;
  1349. aBoolean7931 = bool_194_;
  1350. if (bool || Class154.method1671(anInt7912, anInt7896)) {
  1351. aClass186_7927 = new Class186(Class154.method1685(anInt7912, anInt7896));
  1352. }
  1353. if (bool || Class154.method1683(anInt7912, anInt7896)) {
  1354. aClass186_7930 = new Class186(Class154.method1692(anInt7912, anInt7896));
  1355. }
  1356. if (bool || Class154.method1667(anInt7912, anInt7896)) {
  1357. aClass186_7911 = new Class186(Class154.method1680(anInt7912, anInt7896));
  1358. }
  1359. if (bool || Class154.method1690(anInt7912, anInt7896)) {
  1360. aClass186_7934 = new Class186(Class154.method1669(anInt7912, anInt7896));
  1361. }
  1362. if (bool || Class154.method1668(anInt7912, anInt7896)) {
  1363. aClass167_7926 = new Class167(Class154.method1686(anInt7912, anInt7896));
  1364. }
  1365. if (bool && bool_194_) {
  1366. aClass186_7927.anInterface7_Impl1_1903 = aClass186_7927.anInterface7_Impl1_1902 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  1367. aClass186_7930.anInterface7_Impl1_1903 = aClass186_7930.anInterface7_Impl1_1902 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  1368. aClass186_7911.anInterface7_Impl1_1903 = aClass186_7911.anInterface7_Impl1_1902 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  1369. aClass186_7934.anInterface7_Impl1_1903 = aClass186_7934.anInterface7_Impl1_1902 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  1370. }
  1371. }
  1372.  
  1373. @Override
  1374. public int YA() {
  1375. if (!aBoolean7950) {
  1376. method4832();
  1377. }
  1378. return anInt7938;
  1379. }
  1380.  
  1381. @Override
  1382. public int dk() {
  1383. return aShort7897;
  1384. }
  1385.  
  1386. @Override
  1387. public int AA() {
  1388. if (!aBoolean7950) {
  1389. method4832();
  1390. }
  1391. return anInt7942;
  1392. }
  1393.  
  1394. @Override
  1395. public boolean method4763(int i, int i_195_, Class222 class222, boolean bool, int i_196_) {
  1396. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8236;
  1397. class233.method2145(class222);
  1398. class233.method2144(aClass_ra_Sub3_7894.aClass233_8205);
  1399. boolean bool_197_ = false;
  1400. float f = 3.4028235E38F;
  1401. float f_198_ = -3.4028235E38F;
  1402. float f_199_ = 3.4028235E38F;
  1403. float f_200_ = -3.4028235E38F;
  1404. if (!aBoolean7950) {
  1405. method4832();
  1406. }
  1407. int i_201_ = anInt7941 - anInt7940 >> 1;
  1408. int i_202_ = anInt7939 - anInt7938 >> 1;
  1409. int i_203_ = anInt7943 - anInt7942 >> 1;
  1410. int i_204_ = anInt7940 + i_201_;
  1411. int i_205_ = anInt7938 + i_202_;
  1412. int i_206_ = anInt7942 + i_203_;
  1413. int i_207_ = i_204_ - (i_201_ << i_196_);
  1414. int i_208_ = i_205_ - (i_202_ << i_196_);
  1415. int i_209_ = i_206_ - (i_203_ << i_196_);
  1416. int i_210_ = i_204_ + (i_201_ << i_196_);
  1417. int i_211_ = i_205_ + (i_202_ << i_196_);
  1418. int i_212_ = i_206_ + (i_203_ << i_196_);
  1419. anIntArray7959[0] = i_207_;
  1420. anIntArray7960[0] = i_208_;
  1421. anIntArray7961[0] = i_209_;
  1422. anIntArray7959[1] = i_210_;
  1423. anIntArray7960[1] = i_208_;
  1424. anIntArray7961[1] = i_209_;
  1425. anIntArray7959[2] = i_207_;
  1426. anIntArray7960[2] = i_211_;
  1427. anIntArray7961[2] = i_209_;
  1428. anIntArray7959[3] = i_210_;
  1429. anIntArray7960[3] = i_211_;
  1430. anIntArray7961[3] = i_209_;
  1431. anIntArray7959[4] = i_207_;
  1432. anIntArray7960[4] = i_208_;
  1433. anIntArray7961[4] = i_212_;
  1434. anIntArray7959[5] = i_210_;
  1435. anIntArray7960[5] = i_208_;
  1436. anIntArray7961[5] = i_212_;
  1437. anIntArray7959[6] = i_207_;
  1438. anIntArray7960[6] = i_211_;
  1439. anIntArray7961[6] = i_212_;
  1440. anIntArray7959[7] = i_210_;
  1441. anIntArray7960[7] = i_211_;
  1442. anIntArray7961[7] = i_212_;
  1443. for (int i_213_ = 0; i_213_ < 8; i_213_++) {
  1444. float f_214_ = anIntArray7959[i_213_];
  1445. float f_215_ = anIntArray7960[i_213_];
  1446. float f_216_ = anIntArray7961[i_213_];
  1447. float f_217_ = class233.aFloatArray2594[2] * f_214_ + class233.aFloatArray2594[6] * f_215_ + class233.aFloatArray2594[10] * f_216_ + class233.aFloatArray2594[14];
  1448. float f_218_ = class233.aFloatArray2594[3] * f_214_ + class233.aFloatArray2594[7] * f_215_ + class233.aFloatArray2594[11] * f_216_ + class233.aFloatArray2594[15];
  1449. if (f_217_ >= -f_218_) {
  1450. float f_219_ = class233.aFloatArray2594[0] * f_214_ + class233.aFloatArray2594[4] * f_215_ + class233.aFloatArray2594[8] * f_216_ + class233.aFloatArray2594[12];
  1451. float f_220_ = class233.aFloatArray2594[1] * f_214_ + class233.aFloatArray2594[5] * f_215_ + class233.aFloatArray2594[9] * f_216_ + class233.aFloatArray2594[13];
  1452. float f_221_ = aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_219_ / f_218_;
  1453. float f_222_ = aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_220_ / f_218_;
  1454. if (f_221_ < f) {
  1455. f = f_221_;
  1456. }
  1457. if (f_221_ > f_198_) {
  1458. f_198_ = f_221_;
  1459. }
  1460. if (f_222_ < f_199_) {
  1461. f_199_ = f_222_;
  1462. }
  1463. if (f_222_ > f_200_) {
  1464. f_200_ = f_222_;
  1465. }
  1466. bool_197_ = true;
  1467. }
  1468. }
  1469. if (bool_197_ && i > f && i < f_198_ && i_195_ > f_199_ && i_195_ < f_200_) {
  1470. if (bool) {
  1471. return true;
  1472. }
  1473. if (anIntArray7933.length < anInt7906) {
  1474. anIntArray7933 = new int[anInt7906];
  1475. anIntArray7929 = new int[anInt7906];
  1476. }
  1477. for (int i_223_ = 0; i_223_ < anInt7900; i_223_++) {
  1478. float f_224_ = vertices_x[i_223_];
  1479. float f_225_ = vertices_y[i_223_];
  1480. float f_226_ = vertices_z[i_223_];
  1481. float f_227_ = class233.aFloatArray2594[2] * f_224_ + class233.aFloatArray2594[6] * f_225_ + class233.aFloatArray2594[10] * f_226_ + class233.aFloatArray2594[14];
  1482. float f_228_ = class233.aFloatArray2594[3] * f_224_ + class233.aFloatArray2594[7] * f_225_ + class233.aFloatArray2594[11] * f_226_ + class233.aFloatArray2594[15];
  1483. if (f_227_ >= -f_228_) {
  1484. float f_229_ = class233.aFloatArray2594[0] * f_224_ + class233.aFloatArray2594[4] * f_225_ + class233.aFloatArray2594[8] * f_226_ + class233.aFloatArray2594[12];
  1485. float f_230_ = class233.aFloatArray2594[1] * f_224_ + class233.aFloatArray2594[5] * f_225_ + class233.aFloatArray2594[9] * f_226_ + class233.aFloatArray2594[13];
  1486. int i_231_ = anIntArray7947[i_223_];
  1487. int i_232_ = anIntArray7947[i_223_ + 1];
  1488. for (int i_233_ = i_231_; i_233_ < i_232_; i_233_++) {
  1489. int i_234_ = aShortArray7948[i_233_] - 1;
  1490. if (i_234_ == -1) {
  1491. break;
  1492. }
  1493. anIntArray7933[i_234_] = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_229_ / f_228_);
  1494. anIntArray7929[i_234_] = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_230_ / f_228_);
  1495. }
  1496. } else {
  1497. int i_235_ = anIntArray7947[i_223_];
  1498. int i_236_ = anIntArray7947[i_223_ + 1];
  1499. for (int i_237_ = i_235_; i_237_ < i_236_; i_237_++) {
  1500. int i_238_ = aShortArray7948[i_237_] - 1;
  1501. if (i_238_ == -1) {
  1502. break;
  1503. }
  1504. anIntArray7933[aShortArray7948[i_237_] - 1] = -999999;
  1505. }
  1506. }
  1507. }
  1508. for (int i_239_ = 0; i_239_ < anInt7916; i_239_++) {
  1509. if (anIntArray7933[aShortArray7920[i_239_]] != -999999 && anIntArray7933[aShortArray7921[i_239_]] != -999999 && anIntArray7933[aShortArray7922[i_239_]] != -999999 && method4841(i, i_195_, anIntArray7929[aShortArray7920[i_239_]], anIntArray7929[aShortArray7921[i_239_]], anIntArray7929[aShortArray7922[i_239_]], anIntArray7933[aShortArray7920[i_239_]], anIntArray7933[aShortArray7921[i_239_]], anIntArray7933[aShortArray7922[i_239_]])) {
  1510. return true;
  1511. }
  1512. }
  1513. }
  1514. return false;
  1515. }
  1516.  
  1517. @Override
  1518. public void method4745(Class387 class387, int i, int i_240_, int i_241_, boolean bool) {
  1519. Class387_Sub3 class387_sub3_242_ = (Class387_Sub3) class387;
  1520. if (anInt7916 != 0 && class387_sub3_242_.anInt7916 != 0) {
  1521. int i_243_ = class387_sub3_242_.anInt7900;
  1522. int[] is = class387_sub3_242_.vertices_x;
  1523. int[] is_244_ = class387_sub3_242_.vertices_y;
  1524. int[] is_245_ = class387_sub3_242_.vertices_z;
  1525. short[] is_246_ = class387_sub3_242_.aShortArray7909;
  1526. short[] is_247_ = class387_sub3_242_.aShortArray7910;
  1527. short[] is_248_ = class387_sub3_242_.aShortArray7919;
  1528. byte[] is_249_ = class387_sub3_242_.aByteArray7958;
  1529. short[] is_250_;
  1530. short[] is_251_;
  1531. short[] is_252_;
  1532. byte[] is_253_;
  1533. if (aClass185_7915 != null) {
  1534. is_250_ = aClass185_7915.aShortArray1899;
  1535. is_251_ = aClass185_7915.aShortArray1897;
  1536. is_252_ = aClass185_7915.aShortArray1896;
  1537. is_253_ = aClass185_7915.aByteArray1898;
  1538. } else {
  1539. is_250_ = null;
  1540. is_251_ = null;
  1541. is_252_ = null;
  1542. is_253_ = null;
  1543. }
  1544. short[] is_254_;
  1545. short[] is_255_;
  1546. short[] is_256_;
  1547. byte[] is_257_;
  1548. if (class387_sub3_242_.aClass185_7915 != null) {
  1549. is_254_ = class387_sub3_242_.aClass185_7915.aShortArray1899;
  1550. is_255_ = class387_sub3_242_.aClass185_7915.aShortArray1897;
  1551. is_256_ = class387_sub3_242_.aClass185_7915.aShortArray1896;
  1552. is_257_ = class387_sub3_242_.aClass185_7915.aByteArray1898;
  1553. } else {
  1554. is_254_ = null;
  1555. is_255_ = null;
  1556. is_256_ = null;
  1557. is_257_ = null;
  1558. }
  1559. int[] is_258_ = class387_sub3_242_.anIntArray7947;
  1560. short[] is_259_ = class387_sub3_242_.aShortArray7948;
  1561. if (!class387_sub3_242_.aBoolean7950) {
  1562. class387_sub3_242_.method4832();
  1563. }
  1564. int i_260_ = class387_sub3_242_.anInt7938;
  1565. int i_261_ = class387_sub3_242_.anInt7939;
  1566. int i_262_ = class387_sub3_242_.anInt7940;
  1567. int i_263_ = class387_sub3_242_.anInt7941;
  1568. int i_264_ = class387_sub3_242_.anInt7942;
  1569. int i_265_ = class387_sub3_242_.anInt7943;
  1570. for (int i_266_ = 0; i_266_ < anInt7900; i_266_++) {
  1571. int i_267_ = vertices_y[i_266_] - i_240_;
  1572. if (i_267_ >= i_260_ && i_267_ <= i_261_) {
  1573. int i_268_ = vertices_x[i_266_] - i;
  1574. if (i_268_ >= i_262_ && i_268_ <= i_263_) {
  1575. int i_269_ = vertices_z[i_266_] - i_241_;
  1576. if (i_269_ >= i_264_ && i_269_ <= i_265_) {
  1577. int i_270_ = -1;
  1578. int i_271_ = anIntArray7947[i_266_];
  1579. int i_272_ = anIntArray7947[i_266_ + 1];
  1580. for (int i_273_ = i_271_; i_273_ < i_272_; i_273_++) {
  1581. i_270_ = aShortArray7948[i_273_] - 1;
  1582. if (i_270_ == -1 || aByteArray7958[i_270_] != 0) {
  1583. break;
  1584. }
  1585. }
  1586. if (i_270_ != -1) {
  1587. for (int i_274_ = 0; i_274_ < i_243_; i_274_++) {
  1588. if (i_268_ == is[i_274_] && i_269_ == is_245_[i_274_] && i_267_ == is_244_[i_274_]) {
  1589. int i_275_ = -1;
  1590. i_271_ = is_258_[i_274_];
  1591. i_272_ = is_258_[i_274_ + 1];
  1592. for (int i_276_ = i_271_; i_276_ < i_272_; i_276_++) {
  1593. i_275_ = is_259_[i_276_] - 1;
  1594. if (i_275_ == -1 || is_249_[i_275_] != 0) {
  1595. break;
  1596. }
  1597. }
  1598. if (i_275_ != -1) {
  1599. if (is_250_ == null) {
  1600. aClass185_7915 = new Class185();
  1601. is_250_ = aClass185_7915.aShortArray1899 = Class378.method4670(aShortArray7909, (byte) -55);
  1602. is_251_ = aClass185_7915.aShortArray1897 = Class378.method4670(aShortArray7910, (byte) -99);
  1603. is_252_ = aClass185_7915.aShortArray1896 = Class378.method4670(aShortArray7919, (byte) -32);
  1604. is_253_ = aClass185_7915.aByteArray1898 = Class409.method4978(aByteArray7958, 1194497584);
  1605. }
  1606. if (is_254_ == null) {
  1607. Class185 class185 = class387_sub3_242_.aClass185_7915 = new Class185();
  1608. is_254_ = class185.aShortArray1899 = Class378.method4670(is_246_, (byte) -56);
  1609. is_255_ = class185.aShortArray1897 = Class378.method4670(is_247_, (byte) -81);
  1610. is_256_ = class185.aShortArray1896 = Class378.method4670(is_248_, (byte) -45);
  1611. is_257_ = class185.aByteArray1898 = Class409.method4978(is_249_, 1194497584);
  1612. }
  1613. short i_277_ = aShortArray7909[i_270_];
  1614. short i_278_ = aShortArray7910[i_270_];
  1615. short i_279_ = aShortArray7919[i_270_];
  1616. byte i_280_ = aByteArray7958[i_270_];
  1617. i_271_ = is_258_[i_274_];
  1618. i_272_ = is_258_[i_274_ + 1];
  1619. for (int i_281_ = i_271_; i_281_ < i_272_; i_281_++) {
  1620. int i_282_ = is_259_[i_281_] - 1;
  1621. if (i_282_ == -1) {
  1622. break;
  1623. }
  1624. if (is_257_[i_282_] != 0) {
  1625. is_254_[i_282_] += i_277_;
  1626. is_255_[i_282_] += i_278_;
  1627. is_256_[i_282_] += i_279_;
  1628. is_257_[i_282_] += i_280_;
  1629. }
  1630. }
  1631. i_277_ = is_246_[i_275_];
  1632. i_278_ = is_247_[i_275_];
  1633. i_279_ = is_248_[i_275_];
  1634. i_280_ = is_249_[i_275_];
  1635. i_271_ = anIntArray7947[i_266_];
  1636. i_272_ = anIntArray7947[i_266_ + 1];
  1637. for (int i_283_ = i_271_; i_283_ < i_272_; i_283_++) {
  1638. int i_284_ = aShortArray7948[i_283_] - 1;
  1639. if (i_284_ == -1) {
  1640. break;
  1641. }
  1642. if (is_253_[i_284_] != 0) {
  1643. is_250_[i_284_] += i_277_;
  1644. is_251_[i_284_] += i_278_;
  1645. is_252_[i_284_] += i_279_;
  1646. is_253_[i_284_] += i_280_;
  1647. }
  1648. }
  1649. class387_sub3_242_.method4839();
  1650. method4839();
  1651. }
  1652. }
  1653. }
  1654. }
  1655. }
  1656. }
  1657. }
  1658. }
  1659. }
  1660. }
  1661.  
  1662. @Override
  1663. void e(int i, int[] is, int i_285_, int i_286_, int i_287_, boolean bool, int i_288_, int[] is_289_) {
  1664. int i_290_ = is.length;
  1665. if (i == 0) {
  1666. i_285_ <<= 4;
  1667. i_286_ <<= 4;
  1668. i_287_ <<= 4;
  1669. int i_291_ = 0;
  1670. origin_x = 0;
  1671. origin_y = 0;
  1672. origin_z = 0;
  1673. for (int i_292_ = 0; i_292_ < i_290_; i_292_++) {
  1674. int i_293_ = is[i_292_];
  1675. if (i_293_ < verticesByLabel.length) {
  1676. int[] is_294_ = verticesByLabel[i_293_];
  1677. for (int i_296_ : is_294_) {
  1678. if (aShortArray7964 == null || (i_288_ & aShortArray7964[i_296_]) != 0) {
  1679. origin_x += vertices_x[i_296_];
  1680. origin_y += vertices_y[i_296_];
  1681. origin_z += vertices_z[i_296_];
  1682. i_291_++;
  1683. }
  1684. }
  1685. }
  1686. }
  1687. if (i_291_ > 0) {
  1688. origin_x = origin_x / i_291_ + i_285_;
  1689. origin_y = origin_y / i_291_ + i_286_;
  1690. origin_z = origin_z / i_291_ + i_287_;
  1691. aBoolean7905 = true;
  1692. } else {
  1693. origin_x = i_285_;
  1694. origin_y = i_286_;
  1695. origin_z = i_287_;
  1696. }
  1697. } else if (i == 1) {
  1698. if (is_289_ != null) {
  1699. int i_297_ = is_289_[0] * i_285_ + is_289_[1] * i_286_ + is_289_[2] * i_287_ + 8192 >> 14;
  1700. int i_298_ = is_289_[3] * i_285_ + is_289_[4] * i_286_ + is_289_[5] * i_287_ + 8192 >> 14;
  1701. int i_299_ = is_289_[6] * i_285_ + is_289_[7] * i_286_ + is_289_[8] * i_287_ + 8192 >> 14;
  1702. i_285_ = i_297_;
  1703. i_286_ = i_298_;
  1704. i_287_ = i_299_;
  1705. }
  1706. i_285_ <<= 4;
  1707. i_286_ <<= 4;
  1708. i_287_ <<= 4;
  1709. for (int i_300_ = 0; i_300_ < i_290_; i_300_++) {
  1710. int i_301_ = is[i_300_];
  1711. if (i_301_ < verticesByLabel.length) {
  1712. int[] is_302_ = verticesByLabel[i_301_];
  1713. for (int element : is_302_) {
  1714. int i_304_ = element;
  1715. if (aShortArray7964 == null || (i_288_ & aShortArray7964[i_304_]) != 0) {
  1716. vertices_x[i_304_] += i_285_;
  1717. vertices_y[i_304_] += i_286_;
  1718. vertices_z[i_304_] += i_287_;
  1719. }
  1720. }
  1721. }
  1722. }
  1723. } else if (i == 2) {
  1724. if (is_289_ != null) {
  1725. int i_305_ = is_289_[9] << 4;
  1726. int i_306_ = is_289_[10] << 4;
  1727. int i_307_ = is_289_[11] << 4;
  1728. int i_308_ = is_289_[12] << 4;
  1729. int i_309_ = is_289_[13] << 4;
  1730. int i_310_ = is_289_[14] << 4;
  1731. if (aBoolean7905) {
  1732. int i_311_ = is_289_[0] * origin_x + is_289_[3] * origin_y + is_289_[6] * origin_z + 8192 >> 14;
  1733. int i_312_ = is_289_[1] * origin_x + is_289_[4] * origin_y + is_289_[7] * origin_z + 8192 >> 14;
  1734. int i_313_ = is_289_[2] * origin_x + is_289_[5] * origin_y + is_289_[8] * origin_z + 8192 >> 14;
  1735. i_311_ += i_308_;
  1736. i_312_ += i_309_;
  1737. i_313_ += i_310_;
  1738. origin_x = i_311_;
  1739. origin_y = i_312_;
  1740. origin_z = i_313_;
  1741. aBoolean7905 = false;
  1742. }
  1743. int[] is_314_ = new int[9];
  1744. int i_315_ = Class220.anIntArray2474[i_285_];
  1745. int i_316_ = Class220.anIntArray2483[i_285_];
  1746. int i_317_ = Class220.anIntArray2474[i_286_];
  1747. int i_318_ = Class220.anIntArray2483[i_286_];
  1748. int i_319_ = Class220.anIntArray2474[i_287_];
  1749. int i_320_ = Class220.anIntArray2483[i_287_];
  1750. int i_321_ = i_316_ * i_319_ + 8192 >> 14;
  1751. int i_322_ = i_316_ * i_320_ + 8192 >> 14;
  1752. is_314_[0] = i_317_ * i_319_ + i_318_ * i_322_ + 8192 >> 14;
  1753. is_314_[1] = -i_317_ * i_320_ + i_318_ * i_321_ + 8192 >> 14;
  1754. is_314_[2] = i_318_ * i_315_ + 8192 >> 14;
  1755. is_314_[3] = i_315_ * i_320_ + 8192 >> 14;
  1756. is_314_[4] = i_315_ * i_319_ + 8192 >> 14;
  1757. is_314_[5] = -i_316_;
  1758. is_314_[6] = -i_318_ * i_319_ + i_317_ * i_322_ + 8192 >> 14;
  1759. is_314_[7] = i_318_ * i_320_ + i_317_ * i_321_ + 8192 >> 14;
  1760. is_314_[8] = i_317_ * i_315_ + 8192 >> 14;
  1761. int i_323_ = is_314_[0] * -origin_x + is_314_[1] * -origin_y + is_314_[2] * -origin_z + 8192 >> 14;
  1762. int i_324_ = is_314_[3] * -origin_x + is_314_[4] * -origin_y + is_314_[5] * -origin_z + 8192 >> 14;
  1763. int i_325_ = is_314_[6] * -origin_x + is_314_[7] * -origin_y + is_314_[8] * -origin_z + 8192 >> 14;
  1764. int i_326_ = i_323_ + origin_x;
  1765. int i_327_ = i_324_ + origin_y;
  1766. int i_328_ = i_325_ + origin_z;
  1767. int[] is_329_ = new int[9];
  1768. for (int i_330_ = 0; i_330_ < 3; i_330_++) {
  1769. for (int i_331_ = 0; i_331_ < 3; i_331_++) {
  1770. int i_332_ = 0;
  1771. for (int i_333_ = 0; i_333_ < 3; i_333_++) {
  1772. i_332_ += is_314_[i_330_ * 3 + i_333_] * is_289_[i_331_ * 3 + i_333_];
  1773. }
  1774. is_329_[i_330_ * 3 + i_331_] = i_332_ + 8192 >> 14;
  1775. }
  1776. }
  1777. int i_334_ = is_314_[0] * i_308_ + is_314_[1] * i_309_ + is_314_[2] * i_310_ + 8192 >> 14;
  1778. int i_335_ = is_314_[3] * i_308_ + is_314_[4] * i_309_ + is_314_[5] * i_310_ + 8192 >> 14;
  1779. int i_336_ = is_314_[6] * i_308_ + is_314_[7] * i_309_ + is_314_[8] * i_310_ + 8192 >> 14;
  1780. i_334_ += i_326_;
  1781. i_335_ += i_327_;
  1782. i_336_ += i_328_;
  1783. int[] is_337_ = new int[9];
  1784. for (int i_338_ = 0; i_338_ < 3; i_338_++) {
  1785. for (int i_339_ = 0; i_339_ < 3; i_339_++) {
  1786. int i_340_ = 0;
  1787. for (int i_341_ = 0; i_341_ < 3; i_341_++) {
  1788. i_340_ += is_289_[i_338_ * 3 + i_341_] * is_329_[i_339_ + i_341_ * 3];
  1789. }
  1790. is_337_[i_338_ * 3 + i_339_] = i_340_ + 8192 >> 14;
  1791. }
  1792. }
  1793. int i_342_ = is_289_[0] * i_334_ + is_289_[1] * i_335_ + is_289_[2] * i_336_ + 8192 >> 14;
  1794. int i_343_ = is_289_[3] * i_334_ + is_289_[4] * i_335_ + is_289_[5] * i_336_ + 8192 >> 14;
  1795. int i_344_ = is_289_[6] * i_334_ + is_289_[7] * i_335_ + is_289_[8] * i_336_ + 8192 >> 14;
  1796. i_342_ += i_305_;
  1797. i_343_ += i_306_;
  1798. i_344_ += i_307_;
  1799. for (int i_345_ = 0; i_345_ < i_290_; i_345_++) {
  1800. int i_346_ = is[i_345_];
  1801. if (i_346_ < verticesByLabel.length) {
  1802. int[] is_347_ = verticesByLabel[i_346_];
  1803. for (int element : is_347_) {
  1804. int i_349_ = element;
  1805. if (aShortArray7964 == null || (i_288_ & aShortArray7964[i_349_]) != 0) {
  1806. int i_350_ = is_337_[0] * vertices_x[i_349_] + is_337_[1] * vertices_y[i_349_] + is_337_[2] * vertices_z[i_349_] + 8192 >> 14;
  1807. int i_351_ = is_337_[3] * vertices_x[i_349_] + is_337_[4] * vertices_y[i_349_] + is_337_[5] * vertices_z[i_349_] + 8192 >> 14;
  1808. int i_352_ = is_337_[6] * vertices_x[i_349_] + is_337_[7] * vertices_y[i_349_] + is_337_[8] * vertices_z[i_349_] + 8192 >> 14;
  1809. i_350_ += i_342_;
  1810. i_351_ += i_343_;
  1811. i_352_ += i_344_;
  1812. vertices_x[i_349_] = i_350_;
  1813. vertices_y[i_349_] = i_351_;
  1814. vertices_z[i_349_] = i_352_;
  1815. }
  1816. }
  1817. }
  1818. }
  1819. } else {
  1820. for (int i_353_ = 0; i_353_ < i_290_; i_353_++) {
  1821. int i_354_ = is[i_353_];
  1822. if (i_354_ < verticesByLabel.length) {
  1823. int[] is_355_ = verticesByLabel[i_354_];
  1824. for (int element : is_355_) {
  1825. int i_357_ = element;
  1826. if (aShortArray7964 == null || (i_288_ & aShortArray7964[i_357_]) != 0) {
  1827. vertices_x[i_357_] -= origin_x;
  1828. vertices_y[i_357_] -= origin_y;
  1829. vertices_z[i_357_] -= origin_z;
  1830. if (i_287_ != 0) {
  1831. int i_358_ = Class220.anIntArray2483[i_287_];
  1832. int i_359_ = Class220.anIntArray2474[i_287_];
  1833. int i_360_ = vertices_y[i_357_] * i_358_ + vertices_x[i_357_] * i_359_ + 16383 >> 14;
  1834. vertices_y[i_357_] = vertices_y[i_357_] * i_359_ - vertices_x[i_357_] * i_358_ + 16383 >> 14;
  1835. vertices_x[i_357_] = i_360_;
  1836. }
  1837. if (i_285_ != 0) {
  1838. int i_361_ = Class220.anIntArray2483[i_285_];
  1839. int i_362_ = Class220.anIntArray2474[i_285_];
  1840. int i_363_ = vertices_y[i_357_] * i_362_ - vertices_z[i_357_] * i_361_ + 16383 >> 14;
  1841. vertices_z[i_357_] = vertices_y[i_357_] * i_361_ + vertices_z[i_357_] * i_362_ + 16383 >> 14;
  1842. vertices_y[i_357_] = i_363_;
  1843. }
  1844. if (i_286_ != 0) {
  1845. int i_364_ = Class220.anIntArray2483[i_286_];
  1846. int i_365_ = Class220.anIntArray2474[i_286_];
  1847. int i_366_ = vertices_z[i_357_] * i_364_ + vertices_x[i_357_] * i_365_ + 16383 >> 14;
  1848. vertices_z[i_357_] = vertices_z[i_357_] * i_365_ - vertices_x[i_357_] * i_364_ + 16383 >> 14;
  1849. vertices_x[i_357_] = i_366_;
  1850. }
  1851. vertices_x[i_357_] += origin_x;
  1852. vertices_y[i_357_] += origin_y;
  1853. vertices_z[i_357_] += origin_z;
  1854. }
  1855. }
  1856. }
  1857. }
  1858. if (bool) {
  1859. for (int i_367_ = 0; i_367_ < i_290_; i_367_++) {
  1860. int i_368_ = is[i_367_];
  1861. if (i_368_ < verticesByLabel.length) {
  1862. int[] is_369_ = verticesByLabel[i_368_];
  1863. for (int i_371_ : is_369_) {
  1864. if (aShortArray7964 == null || (i_288_ & aShortArray7964[i_371_]) != 0) {
  1865. int i_372_ = anIntArray7947[i_371_];
  1866. int i_373_ = anIntArray7947[i_371_ + 1];
  1867. for (int i_374_ = i_372_; i_374_ < i_373_; i_374_++) {
  1868. int i_375_ = aShortArray7948[i_374_] - 1;
  1869. if (i_375_ == -1) {
  1870. break;
  1871. }
  1872. if (i_287_ != 0) {
  1873. int i_376_ = Class220.anIntArray2483[i_287_];
  1874. int i_377_ = Class220.anIntArray2474[i_287_];
  1875. int i_378_ = aShortArray7910[i_375_] * i_376_ + aShortArray7909[i_375_] * i_377_ + 16383 >> 14;
  1876. aShortArray7910[i_375_] = (short) (aShortArray7910[i_375_] * i_377_ - aShortArray7909[i_375_] * i_376_ + 16383 >> 14);
  1877. aShortArray7909[i_375_] = (short) i_378_;
  1878. }
  1879. if (i_285_ != 0) {
  1880. int i_379_ = Class220.anIntArray2483[i_285_];
  1881. int i_380_ = Class220.anIntArray2474[i_285_];
  1882. int i_381_ = aShortArray7910[i_375_] * i_380_ - aShortArray7919[i_375_] * i_379_ + 16383 >> 14;
  1883. aShortArray7919[i_375_] = (short) (aShortArray7910[i_375_] * i_379_ + aShortArray7919[i_375_] * i_380_ + 16383 >> 14);
  1884. aShortArray7910[i_375_] = (short) i_381_;
  1885. }
  1886. if (i_286_ != 0) {
  1887. int i_382_ = Class220.anIntArray2483[i_286_];
  1888. int i_383_ = Class220.anIntArray2474[i_286_];
  1889. int i_384_ = aShortArray7919[i_375_] * i_382_ + aShortArray7909[i_375_] * i_383_ + 16383 >> 14;
  1890. aShortArray7919[i_375_] = (short) (aShortArray7919[i_375_] * i_383_ - aShortArray7909[i_375_] * i_382_ + 16383 >> 14);
  1891. aShortArray7909[i_375_] = (short) i_384_;
  1892. }
  1893. }
  1894. }
  1895. }
  1896. }
  1897. }
  1898. method4839();
  1899. }
  1900. }
  1901. } else if (i == 3) {
  1902. if (is_289_ != null) {
  1903. int i_385_ = is_289_[9] << 4;
  1904. int i_386_ = is_289_[10] << 4;
  1905. int i_387_ = is_289_[11] << 4;
  1906. int i_388_ = is_289_[12] << 4;
  1907. int i_389_ = is_289_[13] << 4;
  1908. int i_390_ = is_289_[14] << 4;
  1909. if (aBoolean7905) {
  1910. int i_391_ = is_289_[0] * origin_x + is_289_[3] * origin_y + is_289_[6] * origin_z + 8192 >> 14;
  1911. int i_392_ = is_289_[1] * origin_x + is_289_[4] * origin_y + is_289_[7] * origin_z + 8192 >> 14;
  1912. int i_393_ = is_289_[2] * origin_x + is_289_[5] * origin_y + is_289_[8] * origin_z + 8192 >> 14;
  1913. i_391_ += i_388_;
  1914. i_392_ += i_389_;
  1915. i_393_ += i_390_;
  1916. origin_x = i_391_;
  1917. origin_y = i_392_;
  1918. origin_z = i_393_;
  1919. aBoolean7905 = false;
  1920. }
  1921. int i_394_ = i_285_ << 15 >> 7;
  1922. int i_395_ = i_286_ << 15 >> 7;
  1923. int i_396_ = i_287_ << 15 >> 7;
  1924. int i_397_ = i_394_ * -origin_x + 8192 >> 14;
  1925. int i_398_ = i_395_ * -origin_y + 8192 >> 14;
  1926. int i_399_ = i_396_ * -origin_z + 8192 >> 14;
  1927. int i_400_ = i_397_ + origin_x;
  1928. int i_401_ = i_398_ + origin_y;
  1929. int i_402_ = i_399_ + origin_z;
  1930. int[] is_403_ = new int[9];
  1931. is_403_[0] = i_394_ * is_289_[0] + 8192 >> 14;
  1932. is_403_[1] = i_394_ * is_289_[3] + 8192 >> 14;
  1933. is_403_[2] = i_394_ * is_289_[6] + 8192 >> 14;
  1934. is_403_[3] = i_395_ * is_289_[1] + 8192 >> 14;
  1935. is_403_[4] = i_395_ * is_289_[4] + 8192 >> 14;
  1936. is_403_[5] = i_395_ * is_289_[7] + 8192 >> 14;
  1937. is_403_[6] = i_396_ * is_289_[2] + 8192 >> 14;
  1938. is_403_[7] = i_396_ * is_289_[5] + 8192 >> 14;
  1939. is_403_[8] = i_396_ * is_289_[8] + 8192 >> 14;
  1940. int i_404_ = i_394_ * i_388_ + 8192 >> 14;
  1941. int i_405_ = i_395_ * i_389_ + 8192 >> 14;
  1942. int i_406_ = i_396_ * i_390_ + 8192 >> 14;
  1943. i_404_ += i_400_;
  1944. i_405_ += i_401_;
  1945. i_406_ += i_402_;
  1946. int[] is_407_ = new int[9];
  1947. for (int i_408_ = 0; i_408_ < 3; i_408_++) {
  1948. for (int i_409_ = 0; i_409_ < 3; i_409_++) {
  1949. int i_410_ = 0;
  1950. for (int i_411_ = 0; i_411_ < 3; i_411_++) {
  1951. i_410_ += is_289_[i_408_ * 3 + i_411_] * is_403_[i_409_ + i_411_ * 3];
  1952. }
  1953. is_407_[i_408_ * 3 + i_409_] = i_410_ + 8192 >> 14;
  1954. }
  1955. }
  1956. int i_412_ = is_289_[0] * i_404_ + is_289_[1] * i_405_ + is_289_[2] * i_406_ + 8192 >> 14;
  1957. int i_413_ = is_289_[3] * i_404_ + is_289_[4] * i_405_ + is_289_[5] * i_406_ + 8192 >> 14;
  1958. int i_414_ = is_289_[6] * i_404_ + is_289_[7] * i_405_ + is_289_[8] * i_406_ + 8192 >> 14;
  1959. i_412_ += i_385_;
  1960. i_413_ += i_386_;
  1961. i_414_ += i_387_;
  1962. for (int i_415_ = 0; i_415_ < i_290_; i_415_++) {
  1963. int i_416_ = is[i_415_];
  1964. if (i_416_ < verticesByLabel.length) {
  1965. int[] is_417_ = verticesByLabel[i_416_];
  1966. for (int element : is_417_) {
  1967. int i_419_ = element;
  1968. if (aShortArray7964 == null || (i_288_ & aShortArray7964[i_419_]) != 0) {
  1969. int i_420_ = is_407_[0] * vertices_x[i_419_] + is_407_[1] * vertices_y[i_419_] + is_407_[2] * vertices_z[i_419_] + 8192 >> 14;
  1970. int i_421_ = is_407_[3] * vertices_x[i_419_] + is_407_[4] * vertices_y[i_419_] + is_407_[5] * vertices_z[i_419_] + 8192 >> 14;
  1971. int i_422_ = is_407_[6] * vertices_x[i_419_] + is_407_[7] * vertices_y[i_419_] + is_407_[8] * vertices_z[i_419_] + 8192 >> 14;
  1972. i_420_ += i_412_;
  1973. i_421_ += i_413_;
  1974. i_422_ += i_414_;
  1975. vertices_x[i_419_] = i_420_;
  1976. vertices_y[i_419_] = i_421_;
  1977. vertices_z[i_419_] = i_422_;
  1978. }
  1979. }
  1980. }
  1981. }
  1982. } else {
  1983. for (int i_423_ = 0; i_423_ < i_290_; i_423_++) {
  1984. int i_424_ = is[i_423_];
  1985. if (i_424_ < verticesByLabel.length) {
  1986. int[] is_425_ = verticesByLabel[i_424_];
  1987. for (int element : is_425_) {
  1988. int i_427_ = element;
  1989. if (aShortArray7964 == null || (i_288_ & aShortArray7964[i_427_]) != 0) {
  1990. vertices_x[i_427_] -= origin_x;
  1991. vertices_y[i_427_] -= origin_y;
  1992. vertices_z[i_427_] -= origin_z;
  1993. vertices_x[i_427_] = vertices_x[i_427_] * i_285_ >> 7;
  1994. vertices_y[i_427_] = vertices_y[i_427_] * i_286_ >> 7;
  1995. vertices_z[i_427_] = vertices_z[i_427_] * i_287_ >> 7;
  1996. vertices_x[i_427_] += origin_x;
  1997. vertices_y[i_427_] += origin_y;
  1998. vertices_z[i_427_] += origin_z;
  1999. }
  2000. }
  2001. }
  2002. }
  2003. }
  2004. } else if (i == 5) {
  2005. if (anIntArrayArray7924 != null) {
  2006. boolean bool_428_ = false;
  2007. for (int i_429_ = 0; i_429_ < i_290_; i_429_++) {
  2008. int i_430_ = is[i_429_];
  2009. if (i_430_ < anIntArrayArray7924.length) {
  2010. int[] is_431_ = anIntArrayArray7924[i_430_];
  2011. for (int element : is_431_) {
  2012. int i_433_ = element;
  2013. if (aShortArray7925 == null || (i_288_ & aShortArray7925[i_433_]) != 0) {
  2014. int i_434_ = (aByteArray7963[i_433_] & 0xff) + i_285_ * 8;
  2015. if (i_434_ < 0) {
  2016. i_434_ = 0;
  2017. } else if (i_434_ > 255) {
  2018. i_434_ = 255;
  2019. }
  2020. aByteArray7963[i_433_] = (byte) i_434_;
  2021. }
  2022. }
  2023. bool_428_ = bool_428_ | is_431_.length > 0;
  2024. }
  2025. }
  2026. if (bool_428_) {
  2027. if (aClass191Array7952 != null) {
  2028. for (int i_435_ = 0; i_435_ < anInt7951; i_435_++) {
  2029. Class191 class191 = aClass191Array7952[i_435_];
  2030. Class166 class166 = aClass166Array7892[i_435_];
  2031. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  2032. }
  2033. }
  2034. method4838();
  2035. }
  2036. }
  2037. } else if (i == 7) {
  2038. if (anIntArrayArray7924 != null) {
  2039. boolean bool_436_ = false;
  2040. for (int i_437_ = 0; i_437_ < i_290_; i_437_++) {
  2041. int i_438_ = is[i_437_];
  2042. if (i_438_ < anIntArrayArray7924.length) {
  2043. int[] is_439_ = anIntArrayArray7924[i_438_];
  2044. for (int element : is_439_) {
  2045. int i_441_ = element;
  2046. if (aShortArray7925 == null || (i_288_ & aShortArray7925[i_441_]) != 0) {
  2047. int i_442_ = aShortArray7935[i_441_] & 0xffff;
  2048. int i_443_ = i_442_ >> 10 & 0x3f;
  2049. int i_444_ = i_442_ >> 7 & 0x7;
  2050. int i_445_ = i_442_ & 0x7f;
  2051. i_443_ = i_443_ + i_285_ & 0x3f;
  2052. i_444_ += i_286_ / 4;
  2053. if (i_444_ < 0) {
  2054. i_444_ = 0;
  2055. } else if (i_444_ > 7) {
  2056. i_444_ = 7;
  2057. }
  2058. i_445_ += i_287_;
  2059. if (i_445_ < 0) {
  2060. i_445_ = 0;
  2061. } else if (i_445_ > 127) {
  2062. i_445_ = 127;
  2063. }
  2064. aShortArray7935[i_441_] = (short) (i_443_ << 10 | i_444_ << 7 | i_445_);
  2065. }
  2066. }
  2067. bool_436_ = bool_436_ | is_439_.length > 0;
  2068. }
  2069. }
  2070. if (bool_436_) {
  2071. if (aClass191Array7952 != null) {
  2072. for (int i_446_ = 0; i_446_ < anInt7951; i_446_++) {
  2073. Class191 class191 = aClass191Array7952[i_446_];
  2074. Class166 class166 = aClass166Array7892[i_446_];
  2075. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  2076. }
  2077. }
  2078. method4838();
  2079. }
  2080. }
  2081. } else if (i == 8) {
  2082. if (anIntArrayArray7946 != null) {
  2083. for (int i_447_ = 0; i_447_ < i_290_; i_447_++) {
  2084. int i_448_ = is[i_447_];
  2085. if (i_448_ < anIntArrayArray7946.length) {
  2086. int[] is_449_ = anIntArrayArray7946[i_448_];
  2087. for (int element : is_449_) {
  2088. Class166 class166 = aClass166Array7892[element];
  2089. class166.anInt1704 += i_285_;
  2090. class166.anInt1705 += i_286_;
  2091. }
  2092. }
  2093. }
  2094. }
  2095. } else if (i == 10) {
  2096. if (anIntArrayArray7946 != null) {
  2097. for (int i_451_ = 0; i_451_ < i_290_; i_451_++) {
  2098. int i_452_ = is[i_451_];
  2099. if (i_452_ < anIntArrayArray7946.length) {
  2100. int[] is_453_ = anIntArrayArray7946[i_452_];
  2101. for (int element : is_453_) {
  2102. Class166 class166 = aClass166Array7892[element];
  2103. class166.anInt1702 = class166.anInt1702 * i_285_ >> 7;
  2104. class166.anInt1701 = class166.anInt1701 * i_286_ >> 7;
  2105. }
  2106. }
  2107. }
  2108. }
  2109. } else if (i == 9) {
  2110. if (anIntArrayArray7946 != null) {
  2111. for (int i_455_ = 0; i_455_ < i_290_; i_455_++) {
  2112. int i_456_ = is[i_455_];
  2113. if (i_456_ < anIntArrayArray7946.length) {
  2114. int[] is_457_ = anIntArrayArray7946[i_456_];
  2115. for (int element : is_457_) {
  2116. Class166 class166 = aClass166Array7892[element];
  2117. class166.anInt1706 = class166.anInt1706 + i_285_ & 0x3fff;
  2118. }
  2119. }
  2120. }
  2121. }
  2122. }
  2123. }
  2124.  
  2125. @Override
  2126. public void Q(int i) {
  2127. aShort7898 = (short) i;
  2128. method4851();
  2129. method4839();
  2130. }
  2131.  
  2132. @Override
  2133. public int c() {
  2134. return aShort7897;
  2135. }
  2136.  
  2137. @Override
  2138. public int Z() {
  2139. return aShort7898;
  2140. }
  2141.  
  2142. @Override
  2143. public int dq() {
  2144. if (!aBoolean7950) {
  2145. method4832();
  2146. }
  2147. return anInt7943;
  2148. }
  2149.  
  2150. @Override
  2151. public void bc(int i) {
  2152. int i_459_ = Class220.anIntArray2483[i];
  2153. int i_460_ = Class220.anIntArray2474[i];
  2154. for (int i_461_ = 0; i_461_ < anInt7900; i_461_++) {
  2155. int i_462_ = vertices_z[i_461_] * i_459_ + vertices_x[i_461_] * i_460_ >> 14;
  2156. vertices_z[i_461_] = vertices_z[i_461_] * i_460_ - vertices_x[i_461_] * i_459_ >> 14;
  2157. vertices_x[i_461_] = i_462_;
  2158. }
  2159. for (int i_463_ = 0; i_463_ < anInt7906; i_463_++) {
  2160. int i_464_ = aShortArray7919[i_463_] * i_459_ + aShortArray7909[i_463_] * i_460_ >> 14;
  2161. aShortArray7919[i_463_] = (short) (aShortArray7919[i_463_] * i_460_ - aShortArray7909[i_463_] * i_459_ >> 14);
  2162. aShortArray7909[i_463_] = (short) i_464_;
  2163. }
  2164. method4851();
  2165. method4839();
  2166. aBoolean7950 = false;
  2167. }
  2168.  
  2169. @Override
  2170. public void W(short i, short i_465_) {
  2171. Interface_ma interface_ma = aClass_ra_Sub3_7894.anInterface_ma5299;
  2172. for (int i_466_ = 0; i_466_ < anInt7916; i_466_++) {
  2173. if (aShortArray7923[i_466_] == i) {
  2174. aShortArray7923[i_466_] = i_465_;
  2175. }
  2176. }
  2177. byte i_467_ = 0;
  2178. byte i_468_ = 0;
  2179. if (i != -1) {
  2180. Class53 class53 = interface_ma.method174(i & 0xffff, 1064866173);
  2181. i_467_ = class53.aByte533;
  2182. i_468_ = class53.aByte534;
  2183. }
  2184. byte i_469_ = 0;
  2185. byte i_470_ = 0;
  2186. if (i_465_ != -1) {
  2187. Class53 class53 = interface_ma.method174(i_465_ & 0xffff, 2063902774);
  2188. i_469_ = class53.aByte533;
  2189. i_470_ = class53.aByte534;
  2190. if (class53.aByte535 != 0 || class53.aByte509 != 0) {
  2191. aBoolean7903 = true;
  2192. }
  2193. }
  2194. if (i_467_ != i_469_ | i_468_ != i_470_) {
  2195. if (aClass191Array7952 != null) {
  2196. for (int i_471_ = 0; i_471_ < anInt7951; i_471_++) {
  2197. Class191 class191 = aClass191Array7952[i_471_];
  2198. Class166 class166 = aClass166Array7892[i_471_];
  2199. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  2200. }
  2201. }
  2202. method4838();
  2203. }
  2204. }
  2205.  
  2206. @Override
  2207. public void PA(int i, int i_472_, int i_473_, int i_474_) {
  2208. for (int i_475_ = 0; i_475_ < anInt7916; i_475_++) {
  2209. int i_476_ = aShortArray7935[i_475_] & 0xffff;
  2210. int i_477_ = i_476_ >> 10 & 0x3f;
  2211. int i_478_ = i_476_ >> 7 & 0x7;
  2212. int i_479_ = i_476_ & 0x7f;
  2213. if (i != -1) {
  2214. i_477_ += (i - i_477_) * i_474_ >> 7;
  2215. }
  2216. if (i_472_ != -1) {
  2217. i_478_ += (i_472_ - i_478_) * i_474_ >> 7;
  2218. }
  2219. if (i_473_ != -1) {
  2220. i_479_ += (i_473_ - i_479_) * i_474_ >> 7;
  2221. }
  2222. aShortArray7935[i_475_] = (short) (i_477_ << 10 | i_478_ << 7 | i_479_);
  2223. }
  2224. if (aClass191Array7952 != null) {
  2225. for (int i_480_ = 0; i_480_ < anInt7951; i_480_++) {
  2226. Class191 class191 = aClass191Array7952[i_480_];
  2227. Class166 class166 = aClass166Array7892[i_480_];
  2228. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  2229. }
  2230. }
  2231. method4838();
  2232. }
  2233.  
  2234. @Override
  2235. public boolean method4743() {
  2236. if (aShortArray7923 == null) {
  2237. return true;
  2238. }
  2239. for (short element : aShortArray7923) {
  2240. if (element != -1 && !aClass_ra_Sub3_7894.anInterface_ma5299.method170(element, (short) 10294)) {
  2241. return false;
  2242. }
  2243. }
  2244. return true;
  2245. }
  2246.  
  2247. @Override
  2248. public boolean i() {
  2249. return aBoolean7893;
  2250. }
  2251.  
  2252. @Override
  2253. public boolean u() {
  2254. return aBoolean7903;
  2255. }
  2256.  
  2257. static {
  2258. anIntArray7933 = new int[1];
  2259. anIntArray7929 = new int[1];
  2260. anIntArray7959 = new int[8];
  2261. anIntArray7960 = new int[8];
  2262. anIntArray7961 = new int[8];
  2263. }
  2264.  
  2265. @Override
  2266. void method4734() {
  2267. /* empty */
  2268. }
  2269.  
  2270. @Override
  2271. public Class387 method4770(byte i, int i_481_, boolean bool) {
  2272. boolean bool_482_ = false;
  2273. Class387_Sub3 class387_sub3_483_;
  2274. Class387_Sub3 class387_sub3_484_;
  2275. if (i > 0 && i <= 7) {
  2276. class387_sub3_484_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8267[i - 1];
  2277. class387_sub3_483_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8288[i - 1];
  2278. bool_482_ = true;
  2279. } else {
  2280. class387_sub3_483_ = class387_sub3_484_ = new Class387_Sub3(aClass_ra_Sub3_7894, 0, 0, true, false);
  2281. }
  2282. return method4836(class387_sub3_483_, class387_sub3_484_, i_481_, bool_482_, bool);
  2283. }
  2284.  
  2285. @Override
  2286. void w(int i, int i_485_, int i_486_, int i_487_) {
  2287. if (i == 0) {
  2288. int i_488_ = 0;
  2289. origin_x = 0;
  2290. origin_y = 0;
  2291. origin_z = 0;
  2292. for (int i_489_ = 0; i_489_ < anInt7900; i_489_++) {
  2293. origin_x += vertices_x[i_489_];
  2294. origin_y += vertices_y[i_489_];
  2295. origin_z += vertices_z[i_489_];
  2296. i_488_++;
  2297. }
  2298. if (i_488_ > 0) {
  2299. origin_x = origin_x / i_488_ + i_485_;
  2300. origin_y = origin_y / i_488_ + i_486_;
  2301. origin_z = origin_z / i_488_ + i_487_;
  2302. } else {
  2303. origin_x = i_485_;
  2304. origin_y = i_486_;
  2305. origin_z = i_487_;
  2306. }
  2307. } else if (i == 1) {
  2308. for (int i_490_ = 0; i_490_ < anInt7900; i_490_++) {
  2309. vertices_x[i_490_] += i_485_;
  2310. vertices_y[i_490_] += i_486_;
  2311. vertices_z[i_490_] += i_487_;
  2312. }
  2313. } else if (i == 2) {
  2314. for (int i_491_ = 0; i_491_ < anInt7900; i_491_++) {
  2315. vertices_x[i_491_] -= origin_x;
  2316. vertices_y[i_491_] -= origin_y;
  2317. vertices_z[i_491_] -= origin_z;
  2318. if (i_487_ != 0) {
  2319. int i_492_ = Class220.anIntArray2483[i_487_];
  2320. int i_493_ = Class220.anIntArray2474[i_487_];
  2321. int i_494_ = vertices_y[i_491_] * i_492_ + vertices_x[i_491_] * i_493_ + 16383 >> 14;
  2322. vertices_y[i_491_] = vertices_y[i_491_] * i_493_ - vertices_x[i_491_] * i_492_ + 16383 >> 14;
  2323. vertices_x[i_491_] = i_494_;
  2324. }
  2325. if (i_485_ != 0) {
  2326. int i_495_ = Class220.anIntArray2483[i_485_];
  2327. int i_496_ = Class220.anIntArray2474[i_485_];
  2328. int i_497_ = vertices_y[i_491_] * i_496_ - vertices_z[i_491_] * i_495_ + 16383 >> 14;
  2329. vertices_z[i_491_] = vertices_y[i_491_] * i_495_ + vertices_z[i_491_] * i_496_ + 16383 >> 14;
  2330. vertices_y[i_491_] = i_497_;
  2331. }
  2332. if (i_486_ != 0) {
  2333. int i_498_ = Class220.anIntArray2483[i_486_];
  2334. int i_499_ = Class220.anIntArray2474[i_486_];
  2335. int i_500_ = vertices_z[i_491_] * i_498_ + vertices_x[i_491_] * i_499_ + 16383 >> 14;
  2336. vertices_z[i_491_] = vertices_z[i_491_] * i_499_ - vertices_x[i_491_] * i_498_ + 16383 >> 14;
  2337. vertices_x[i_491_] = i_500_;
  2338. }
  2339. vertices_x[i_491_] += origin_x;
  2340. vertices_y[i_491_] += origin_y;
  2341. vertices_z[i_491_] += origin_z;
  2342. }
  2343. } else if (i == 3) {
  2344. for (int i_501_ = 0; i_501_ < anInt7900; i_501_++) {
  2345. vertices_x[i_501_] -= origin_x;
  2346. vertices_y[i_501_] -= origin_y;
  2347. vertices_z[i_501_] -= origin_z;
  2348. vertices_x[i_501_] = vertices_x[i_501_] * i_485_ / 128;
  2349. vertices_y[i_501_] = vertices_y[i_501_] * i_486_ / 128;
  2350. vertices_z[i_501_] = vertices_z[i_501_] * i_487_ / 128;
  2351. vertices_x[i_501_] += origin_x;
  2352. vertices_y[i_501_] += origin_y;
  2353. vertices_z[i_501_] += origin_z;
  2354. }
  2355. } else if (i == 5) {
  2356. for (int i_502_ = 0; i_502_ < anInt7916; i_502_++) {
  2357. int i_503_ = (aByteArray7963[i_502_] & 0xff) + i_485_ * 8;
  2358. if (i_503_ < 0) {
  2359. i_503_ = 0;
  2360. } else if (i_503_ > 255) {
  2361. i_503_ = 255;
  2362. }
  2363. aByteArray7963[i_502_] = (byte) i_503_;
  2364. }
  2365. if (aClass191Array7952 != null) {
  2366. for (int i_504_ = 0; i_504_ < anInt7951; i_504_++) {
  2367. Class191 class191 = aClass191Array7952[i_504_];
  2368. Class166 class166 = aClass166Array7892[i_504_];
  2369. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  2370. }
  2371. }
  2372. method4838();
  2373. } else if (i == 7) {
  2374. for (int i_505_ = 0; i_505_ < anInt7916; i_505_++) {
  2375. int i_506_ = aShortArray7935[i_505_] & 0xffff;
  2376. int i_507_ = i_506_ >> 10 & 0x3f;
  2377. int i_508_ = i_506_ >> 7 & 0x7;
  2378. int i_509_ = i_506_ & 0x7f;
  2379. i_507_ = i_507_ + i_485_ & 0x3f;
  2380. i_508_ += i_486_ / 4;
  2381. if (i_508_ < 0) {
  2382. i_508_ = 0;
  2383. } else if (i_508_ > 7) {
  2384. i_508_ = 7;
  2385. }
  2386. i_509_ += i_487_;
  2387. if (i_509_ < 0) {
  2388. i_509_ = 0;
  2389. } else if (i_509_ > 127) {
  2390. i_509_ = 127;
  2391. }
  2392. aShortArray7935[i_505_] = (short) (i_507_ << 10 | i_508_ << 7 | i_509_);
  2393. }
  2394. if (aClass191Array7952 != null) {
  2395. for (int i_510_ = 0; i_510_ < anInt7951; i_510_++) {
  2396. Class191 class191 = aClass191Array7952[i_510_];
  2397. Class166 class166 = aClass166Array7892[i_510_];
  2398. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  2399. }
  2400. }
  2401. method4838();
  2402. } else if (i == 8) {
  2403. for (int i_511_ = 0; i_511_ < anInt7951; i_511_++) {
  2404. Class166 class166 = aClass166Array7892[i_511_];
  2405. class166.anInt1704 += i_485_;
  2406. class166.anInt1705 += i_486_;
  2407. }
  2408. } else if (i == 10) {
  2409. for (int i_512_ = 0; i_512_ < anInt7951; i_512_++) {
  2410. Class166 class166 = aClass166Array7892[i_512_];
  2411. class166.anInt1702 = class166.anInt1702 * i_485_ >> 7;
  2412. class166.anInt1701 = class166.anInt1701 * i_486_ >> 7;
  2413. }
  2414. } else if (i == 9) {
  2415. for (int i_513_ = 0; i_513_ < anInt7951; i_513_++) {
  2416. Class166 class166 = aClass166Array7892[i_513_];
  2417. class166.anInt1706 = class166.anInt1706 + i_485_ & 0x3fff;
  2418. }
  2419. }
  2420. }
  2421.  
  2422. @Override
  2423. void ka() {
  2424. for (int i = 0; i < anInt7899; i++) {
  2425. vertices_x[i] = vertices_x[i] + 7 >> 4;
  2426. vertices_y[i] = vertices_y[i] + 7 >> 4;
  2427. vertices_z[i] = vertices_z[i] + 7 >> 4;
  2428. }
  2429. method4851();
  2430. aBoolean7950 = false;
  2431. }
  2432.  
  2433. @Override
  2434. public void method4741(Class222 class222, int i, boolean bool) {
  2435. if (aShortArray7964 != null) {
  2436. Class222 class222_514_ = class222;
  2437. if (bool) {
  2438. class222_514_ = aClass_ra_Sub3_7894.aClass222_8235;
  2439. class222_514_.method2074(class222);
  2440. }
  2441. float[] fs = new float[3];
  2442. for (int i_515_ = 0; i_515_ < anInt7900; i_515_++) {
  2443. if ((i & aShortArray7964[i_515_]) != 0) {
  2444. class222_514_.method2077(vertices_x[i_515_], vertices_y[i_515_], vertices_z[i_515_], fs);
  2445. vertices_x[i_515_] = (int) fs[0];
  2446. vertices_y[i_515_] = (int) fs[1];
  2447. vertices_z[i_515_] = (int) fs[2];
  2448. }
  2449. }
  2450. }
  2451. }
  2452.  
  2453. @Override
  2454. public Class68[] method4728() {
  2455. return aClass68Array7904;
  2456. }
  2457.  
  2458. @Override
  2459. public Class85[] method4781() {
  2460. return aClass85Array7949;
  2461. }
  2462.  
  2463. @Override
  2464. public void method4786(Class222 class222) {
  2465. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8236;
  2466. class233.method2145(class222);
  2467. if (aClass85Array7949 != null) {
  2468. for (Class85 class85 : aClass85Array7949) {
  2469. Class85 class85_516_ = class85;
  2470. if (class85.aClass85_776 != null) {
  2471. class85_516_ = class85.aClass85_776;
  2472. }
  2473. class85_516_.anInt777 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[4] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[8] * vertices_z[class85.anInt773 * -710317103])) * -1879868075;
  2474. class85_516_.anInt783 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[5] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[9] * vertices_z[class85.anInt773 * -710317103])) * -2041556771;
  2475. class85_516_.anInt779 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[6] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[10] * vertices_z[class85.anInt773 * -710317103])) * -1434499227;
  2476. class85_516_.anInt772 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[4] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[8] * vertices_z[class85.anInt774 * 1705862021])) * 1070341177;
  2477. class85_516_.anInt781 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[5] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[9] * vertices_z[class85.anInt774 * 1705862021])) * 1802851857;
  2478. class85_516_.anInt782 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[6] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[10] * vertices_z[class85.anInt774 * 1705862021])) * 103846281;
  2479. class85_516_.anInt771 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[4] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[8] * vertices_z[class85.anInt775 * 1636170731])) * -2103324039;
  2480. class85_516_.anInt784 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[5] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[9] * vertices_z[class85.anInt775 * 1636170731])) * -526039059;
  2481. class85_516_.anInt785 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[6] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[10] * vertices_z[class85.anInt775 * 1636170731])) * 491030489;
  2482. }
  2483. }
  2484. if (aClass68Array7904 != null) {
  2485. for (Class68 element : aClass68Array7904) {
  2486. Class68 class68 = element;
  2487. Class68 class68_517_ = class68;
  2488. if (class68.aClass68_672 != null) {
  2489. class68_517_ = class68.aClass68_672;
  2490. }
  2491. if (class68.aClass233_677 != null) {
  2492. class68.aClass233_677.method2142(class233);
  2493. } else {
  2494. class68.aClass233_677 = new Class233(class233);
  2495. }
  2496. class68_517_.anInt671 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[4] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[8] * vertices_z[class68.anInt674 * -180596249])) * -1436341053;
  2497. class68_517_.anInt675 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[5] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[9] * vertices_z[class68.anInt674 * -180596249])) * 449866009;
  2498. class68_517_.anInt676 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[6] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[10] * vertices_z[class68.anInt674 * -180596249])) * 1336328763;
  2499. }
  2500. }
  2501. }
  2502.  
  2503. @Override
  2504. public boolean method4787(int i, int i_518_, Class222 class222, boolean bool, int i_519_) {
  2505. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8236;
  2506. class233.method2145(class222);
  2507. class233.method2144(aClass_ra_Sub3_7894.aClass233_8205);
  2508. boolean bool_520_ = false;
  2509. float f = 3.4028235E38F;
  2510. float f_521_ = -3.4028235E38F;
  2511. float f_522_ = 3.4028235E38F;
  2512. float f_523_ = -3.4028235E38F;
  2513. if (!aBoolean7950) {
  2514. method4832();
  2515. }
  2516. int i_524_ = anInt7941 - anInt7940 >> 1;
  2517. int i_525_ = anInt7939 - anInt7938 >> 1;
  2518. int i_526_ = anInt7943 - anInt7942 >> 1;
  2519. int i_527_ = anInt7940 + i_524_;
  2520. int i_528_ = anInt7938 + i_525_;
  2521. int i_529_ = anInt7942 + i_526_;
  2522. int i_530_ = i_527_ - (i_524_ << i_519_);
  2523. int i_531_ = i_528_ - (i_525_ << i_519_);
  2524. int i_532_ = i_529_ - (i_526_ << i_519_);
  2525. int i_533_ = i_527_ + (i_524_ << i_519_);
  2526. int i_534_ = i_528_ + (i_525_ << i_519_);
  2527. int i_535_ = i_529_ + (i_526_ << i_519_);
  2528. anIntArray7959[0] = i_530_;
  2529. anIntArray7960[0] = i_531_;
  2530. anIntArray7961[0] = i_532_;
  2531. anIntArray7959[1] = i_533_;
  2532. anIntArray7960[1] = i_531_;
  2533. anIntArray7961[1] = i_532_;
  2534. anIntArray7959[2] = i_530_;
  2535. anIntArray7960[2] = i_534_;
  2536. anIntArray7961[2] = i_532_;
  2537. anIntArray7959[3] = i_533_;
  2538. anIntArray7960[3] = i_534_;
  2539. anIntArray7961[3] = i_532_;
  2540. anIntArray7959[4] = i_530_;
  2541. anIntArray7960[4] = i_531_;
  2542. anIntArray7961[4] = i_535_;
  2543. anIntArray7959[5] = i_533_;
  2544. anIntArray7960[5] = i_531_;
  2545. anIntArray7961[5] = i_535_;
  2546. anIntArray7959[6] = i_530_;
  2547. anIntArray7960[6] = i_534_;
  2548. anIntArray7961[6] = i_535_;
  2549. anIntArray7959[7] = i_533_;
  2550. anIntArray7960[7] = i_534_;
  2551. anIntArray7961[7] = i_535_;
  2552. for (int i_536_ = 0; i_536_ < 8; i_536_++) {
  2553. float f_537_ = anIntArray7959[i_536_];
  2554. float f_538_ = anIntArray7960[i_536_];
  2555. float f_539_ = anIntArray7961[i_536_];
  2556. float f_540_ = class233.aFloatArray2594[2] * f_537_ + class233.aFloatArray2594[6] * f_538_ + class233.aFloatArray2594[10] * f_539_ + class233.aFloatArray2594[14];
  2557. float f_541_ = class233.aFloatArray2594[3] * f_537_ + class233.aFloatArray2594[7] * f_538_ + class233.aFloatArray2594[11] * f_539_ + class233.aFloatArray2594[15];
  2558. if (f_540_ >= -f_541_) {
  2559. float f_542_ = class233.aFloatArray2594[0] * f_537_ + class233.aFloatArray2594[4] * f_538_ + class233.aFloatArray2594[8] * f_539_ + class233.aFloatArray2594[12];
  2560. float f_543_ = class233.aFloatArray2594[1] * f_537_ + class233.aFloatArray2594[5] * f_538_ + class233.aFloatArray2594[9] * f_539_ + class233.aFloatArray2594[13];
  2561. float f_544_ = aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_542_ / f_541_;
  2562. float f_545_ = aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_543_ / f_541_;
  2563. if (f_544_ < f) {
  2564. f = f_544_;
  2565. }
  2566. if (f_544_ > f_521_) {
  2567. f_521_ = f_544_;
  2568. }
  2569. if (f_545_ < f_522_) {
  2570. f_522_ = f_545_;
  2571. }
  2572. if (f_545_ > f_523_) {
  2573. f_523_ = f_545_;
  2574. }
  2575. bool_520_ = true;
  2576. }
  2577. }
  2578. if (bool_520_ && i > f && i < f_521_ && i_518_ > f_522_ && i_518_ < f_523_) {
  2579. if (bool) {
  2580. return true;
  2581. }
  2582. if (anIntArray7933.length < anInt7906) {
  2583. anIntArray7933 = new int[anInt7906];
  2584. anIntArray7929 = new int[anInt7906];
  2585. }
  2586. for (int i_546_ = 0; i_546_ < anInt7900; i_546_++) {
  2587. float f_547_ = vertices_x[i_546_];
  2588. float f_548_ = vertices_y[i_546_];
  2589. float f_549_ = vertices_z[i_546_];
  2590. float f_550_ = class233.aFloatArray2594[2] * f_547_ + class233.aFloatArray2594[6] * f_548_ + class233.aFloatArray2594[10] * f_549_ + class233.aFloatArray2594[14];
  2591. float f_551_ = class233.aFloatArray2594[3] * f_547_ + class233.aFloatArray2594[7] * f_548_ + class233.aFloatArray2594[11] * f_549_ + class233.aFloatArray2594[15];
  2592. if (f_550_ >= -f_551_) {
  2593. float f_552_ = class233.aFloatArray2594[0] * f_547_ + class233.aFloatArray2594[4] * f_548_ + class233.aFloatArray2594[8] * f_549_ + class233.aFloatArray2594[12];
  2594. float f_553_ = class233.aFloatArray2594[1] * f_547_ + class233.aFloatArray2594[5] * f_548_ + class233.aFloatArray2594[9] * f_549_ + class233.aFloatArray2594[13];
  2595. int i_554_ = anIntArray7947[i_546_];
  2596. int i_555_ = anIntArray7947[i_546_ + 1];
  2597. for (int i_556_ = i_554_; i_556_ < i_555_; i_556_++) {
  2598. int i_557_ = aShortArray7948[i_556_] - 1;
  2599. if (i_557_ == -1) {
  2600. break;
  2601. }
  2602. anIntArray7933[i_557_] = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_552_ / f_551_);
  2603. anIntArray7929[i_557_] = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_553_ / f_551_);
  2604. }
  2605. } else {
  2606. int i_558_ = anIntArray7947[i_546_];
  2607. int i_559_ = anIntArray7947[i_546_ + 1];
  2608. for (int i_560_ = i_558_; i_560_ < i_559_; i_560_++) {
  2609. int i_561_ = aShortArray7948[i_560_] - 1;
  2610. if (i_561_ == -1) {
  2611. break;
  2612. }
  2613. anIntArray7933[aShortArray7948[i_560_] - 1] = -999999;
  2614. }
  2615. }
  2616. }
  2617. for (int i_562_ = 0; i_562_ < anInt7916; i_562_++) {
  2618. if (anIntArray7933[aShortArray7920[i_562_]] != -999999 && anIntArray7933[aShortArray7921[i_562_]] != -999999 && anIntArray7933[aShortArray7922[i_562_]] != -999999 && method4841(i, i_518_, anIntArray7929[aShortArray7920[i_562_]], anIntArray7929[aShortArray7921[i_562_]], anIntArray7929[aShortArray7922[i_562_]], anIntArray7933[aShortArray7920[i_562_]], anIntArray7933[aShortArray7921[i_562_]], anIntArray7933[aShortArray7922[i_562_]])) {
  2619. return true;
  2620. }
  2621. }
  2622. }
  2623. return false;
  2624. }
  2625.  
  2626. boolean method4841(int i, int i_563_, int i_564_, int i_565_, int i_566_, int i_567_, int i_568_, int i_569_) {
  2627. if (i_563_ < i_564_ && i_563_ < i_565_ && i_563_ < i_566_) {
  2628. return false;
  2629. }
  2630. if (i_563_ > i_564_ && i_563_ > i_565_ && i_563_ > i_566_) {
  2631. return false;
  2632. }
  2633. if (i < i_567_ && i < i_568_ && i < i_569_) {
  2634. return false;
  2635. }
  2636. if (i > i_567_ && i > i_568_ && i > i_569_) {
  2637. return false;
  2638. }
  2639. return true;
  2640. }
  2641.  
  2642. @Override
  2643. public void bk(int i, int i_570_, int i_571_) {
  2644. for (int i_572_ = 0; i_572_ < anInt7900; i_572_++) {
  2645. if (i != 0) {
  2646. vertices_x[i_572_] += i;
  2647. }
  2648. if (i_570_ != 0) {
  2649. vertices_y[i_572_] += i_570_;
  2650. }
  2651. if (i_571_ != 0) {
  2652. vertices_z[i_572_] += i_571_;
  2653. }
  2654. }
  2655. method4851();
  2656. aBoolean7950 = false;
  2657. }
  2658.  
  2659. void method4842(Class_na_Sub2 class_na_sub2) {
  2660. if (anIntArray7933.length < anInt7906) {
  2661. anIntArray7933 = new int[anInt7906];
  2662. anIntArray7929 = new int[anInt7906];
  2663. }
  2664. for (int i = 0; i < anInt7900; i++) {
  2665. int i_573_ = (vertices_x[i] - (vertices_y[i] * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313) - class_na_sub2.anInt10018;
  2666. int i_574_ = (vertices_z[i] - (vertices_y[i] * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313) - class_na_sub2.anInt10022;
  2667. int i_575_ = anIntArray7947[i];
  2668. int i_576_ = anIntArray7947[i + 1];
  2669. for (int i_577_ = i_575_; i_577_ < i_576_; i_577_++) {
  2670. int i_578_ = aShortArray7948[i_577_] - 1;
  2671. if (i_578_ == -1) {
  2672. break;
  2673. }
  2674. anIntArray7933[i_578_] = i_573_;
  2675. anIntArray7929[i_578_] = i_574_;
  2676. }
  2677. }
  2678. for (int i = 0; i < anInt7917; i++) {
  2679. if (aByteArray7963 == null || aByteArray7963[i] <= 128) {
  2680. short i_579_ = aShortArray7920[i];
  2681. short i_580_ = aShortArray7921[i];
  2682. short i_581_ = aShortArray7922[i];
  2683. int i_582_ = anIntArray7933[i_579_];
  2684. int i_583_ = anIntArray7933[i_580_];
  2685. int i_584_ = anIntArray7933[i_581_];
  2686. int i_585_ = anIntArray7929[i_579_];
  2687. int i_586_ = anIntArray7929[i_580_];
  2688. int i_587_ = anIntArray7929[i_581_];
  2689. if ((i_582_ - i_583_) * (i_586_ - i_587_) - (i_586_ - i_585_) * (i_584_ - i_583_) > 0) {
  2690. class_na_sub2.method3490(i_585_, i_586_, i_587_, i_582_, i_583_, i_584_);
  2691. }
  2692. }
  2693. }
  2694. }
  2695.  
  2696. @Override
  2697. public void method4739(Class222 class222, Class302_Sub1 class302_sub1, int i) {
  2698. if (aClass156_7966 != null) {
  2699. aClass156_7966.method1694();
  2700. }
  2701. if (anInt7906 != 0) {
  2702. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8246;
  2703. Class233 class233_588_ = aClass_ra_Sub3_7894.aClass233_8236;
  2704. Class233 class233_589_ = aClass_ra_Sub3_7894.aClass233_8204;
  2705. class233_588_.method2145(class222);
  2706. class233_589_.method2142(class233_588_);
  2707. class233_589_.method2144(aClass_ra_Sub3_7894.aClass233_8205);
  2708. if (!aBoolean7950) {
  2709. method4832();
  2710. }
  2711. float[] fs = aClass_ra_Sub3_7894.aFloatArray8312;
  2712. class233_588_.method2149(0.0F, anInt7938, 0.0F, fs);
  2713. float f = fs[0];
  2714. float f_590_ = fs[1];
  2715. float f_591_ = fs[2];
  2716. class233_588_.method2149(0.0F, anInt7939, 0.0F, fs);
  2717. float f_592_ = fs[0];
  2718. float f_593_ = fs[1];
  2719. float f_594_ = fs[2];
  2720. for (int i_595_ = 0; i_595_ < 6; i_595_++) {
  2721. float[] fs_596_ = aClass_ra_Sub3_7894.aFloatArrayArray8252[i_595_];
  2722. float f_597_ = fs_596_[0] * f + fs_596_[1] * f_590_ + fs_596_[2] * f_591_ + fs_596_[3] + anInt7936;
  2723. float f_598_ = fs_596_[0] * f_592_ + fs_596_[1] * f_593_ + fs_596_[2] * f_594_ + fs_596_[3] + anInt7936;
  2724. if (f_597_ < 0.0F && f_598_ < 0.0F) {
  2725. return;
  2726. }
  2727. }
  2728. if (class302_sub1 != null) {
  2729. boolean bool = false;
  2730. boolean bool_599_ = true;
  2731. int i_600_ = anInt7940 + anInt7941 >> 1;
  2732. int i_601_ = anInt7942 + anInt7943 >> 1;
  2733. int i_602_ = i_600_;
  2734. int i_603_ = anInt7938;
  2735. int i_604_ = i_601_;
  2736. float f_605_ = class233_589_.aFloatArray2594[0] * i_602_ + class233_589_.aFloatArray2594[4] * i_603_ + class233_589_.aFloatArray2594[8] * i_604_ + class233_589_.aFloatArray2594[12];
  2737. float f_606_ = class233_589_.aFloatArray2594[1] * i_602_ + class233_589_.aFloatArray2594[5] * i_603_ + class233_589_.aFloatArray2594[9] * i_604_ + class233_589_.aFloatArray2594[13];
  2738. float f_607_ = class233_589_.aFloatArray2594[2] * i_602_ + class233_589_.aFloatArray2594[6] * i_603_ + class233_589_.aFloatArray2594[10] * i_604_ + class233_589_.aFloatArray2594[14];
  2739. float f_608_ = class233_589_.aFloatArray2594[3] * i_602_ + class233_589_.aFloatArray2594[7] * i_603_ + class233_589_.aFloatArray2594[11] * i_604_ + class233_589_.aFloatArray2594[15];
  2740. if (f_607_ >= -f_608_) {
  2741. class302_sub1.anInt7641 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_605_ / f_608_);
  2742. class302_sub1.anInt7642 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_606_ / f_608_);
  2743. } else {
  2744. bool = true;
  2745. }
  2746. i_602_ = i_600_;
  2747. i_603_ = anInt7939;
  2748. i_604_ = i_601_;
  2749. float f_609_ = class233_589_.aFloatArray2594[0] * i_602_ + class233_589_.aFloatArray2594[4] * i_603_ + class233_589_.aFloatArray2594[8] * i_604_ + class233_589_.aFloatArray2594[12];
  2750. float f_610_ = class233_589_.aFloatArray2594[1] * i_602_ + class233_589_.aFloatArray2594[5] * i_603_ + class233_589_.aFloatArray2594[9] * i_604_ + class233_589_.aFloatArray2594[13];
  2751. float f_611_ = class233_589_.aFloatArray2594[2] * i_602_ + class233_589_.aFloatArray2594[6] * i_603_ + class233_589_.aFloatArray2594[10] * i_604_ + class233_589_.aFloatArray2594[14];
  2752. float f_612_ = class233_589_.aFloatArray2594[3] * i_602_ + class233_589_.aFloatArray2594[7] * i_603_ + class233_589_.aFloatArray2594[11] * i_604_ + class233_589_.aFloatArray2594[15];
  2753. if (f_611_ >= -f_612_) {
  2754. class302_sub1.anInt7643 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_609_ / f_612_);
  2755. class302_sub1.anInt7640 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_610_ / f_612_);
  2756. } else {
  2757. bool = true;
  2758. }
  2759. if (bool) {
  2760. if (f_607_ < -f_608_ && f_611_ < -f_612_) {
  2761. bool_599_ = false;
  2762. } else if (f_607_ < -f_608_) {
  2763. float f_613_ = (f_607_ + f_608_) / (f_611_ + f_612_) - 1.0F;
  2764. float f_614_ = f_605_ + f_613_ * (f_609_ - f_605_);
  2765. float f_615_ = f_606_ + f_613_ * (f_610_ - f_606_);
  2766. float f_616_ = f_608_ + f_613_ * (f_612_ - f_608_);
  2767. class302_sub1.anInt7641 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_614_ / f_616_);
  2768. class302_sub1.anInt7642 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_615_ / f_616_);
  2769. } else if (f_611_ < -f_612_) {
  2770. float f_617_ = (f_611_ + f_612_) / (f_607_ + f_608_) - 1.0F;
  2771. float f_618_ = f_609_ + f_617_ * (f_605_ - f_609_);
  2772. float f_619_ = f_610_ + f_617_ * (f_606_ - f_610_);
  2773. float f_620_ = f_612_ + f_617_ * (f_608_ - f_612_);
  2774. class302_sub1.anInt7643 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_618_ / f_620_);
  2775. class302_sub1.anInt7640 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_619_ / f_620_);
  2776. }
  2777. }
  2778. if (bool_599_) {
  2779. if (f_607_ / f_608_ > f_611_ / f_612_) {
  2780. float f_621_ = f_605_ + class233.aFloatArray2594[0] * anInt7936 + class233.aFloatArray2594[12];
  2781. float f_622_ = f_608_ + class233.aFloatArray2594[3] * anInt7936 + class233.aFloatArray2594[15];
  2782. class302_sub1.anInt7645 = (int) (aClass_ra_Sub3_7894.aFloat8253 - class302_sub1.anInt7641 + aClass_ra_Sub3_7894.aFloat8329 * f_621_ / f_622_);
  2783. } else {
  2784. float f_623_ = f_609_ + class233.aFloatArray2594[0] * anInt7936 + class233.aFloatArray2594[12];
  2785. float f_624_ = f_612_ + class233.aFloatArray2594[3] * anInt7936 + class233.aFloatArray2594[15];
  2786. class302_sub1.anInt7645 = (int) (aClass_ra_Sub3_7894.aFloat8253 - class302_sub1.anInt7643 + aClass_ra_Sub3_7894.aFloat8329 * f_623_ / f_624_);
  2787. }
  2788. class302_sub1.aBoolean7644 = true;
  2789. }
  2790. }
  2791. aClass_ra_Sub3_7894.method5394(i);
  2792. method4843(class222);
  2793. aClass_ra_Sub3_7894.method5394(0);
  2794. class233_588_.method2145(class222);
  2795. class233_588_.method2144(aClass_ra_Sub3_7894.aClass233_8230);
  2796. method4849(class233_588_);
  2797. }
  2798. }
  2799.  
  2800. void method4843(Class222 class222) {
  2801. if (anInt7917 != 0 && method4844() && method4835()) {
  2802. if (aClass156_7966 == null) {
  2803. /* empty */
  2804. }
  2805. aClass_ra_Sub3_7894.method5393();
  2806. Class137 class137 = aClass_ra_Sub3_7894.aClass137_8316;
  2807. aClass_ra_Sub3_7894.method5383(0, aClass186_7927.anInterface7_Impl1_1902);
  2808. aClass_ra_Sub3_7894.method5383(1, aClass186_7911.anInterface7_Impl1_1902);
  2809. aClass_ra_Sub3_7894.method5383(2, aClass186_7930.anInterface7_Impl1_1902);
  2810. aClass_ra_Sub3_7894.method5384(aClass167_7926.anInterface7_Impl2_1707);
  2811. aClass_ra_Sub3_7894.aClass233_8236.method2145(class222);
  2812. class137.method1506(aClass_ra_Sub3_7894.aClass233_8236);
  2813. class137.aClass233_1519.method2172();
  2814. if (aClass_ra_Sub3_7894.aBoolean8326) {
  2815. Class78 class78 = aClass_ra_Sub3_7894.method5373();
  2816. class137.aClass232_1523.method2135(0.0F, 1.0F, 0.0F, -aClass_ra_Sub3_7894.anInt8328);
  2817. class137.aClass232_1523.method2139(3.0F / (class78.anInt725 * 1996750669));
  2818. class137.aClass217_1524.method2007((class78.anInt726 * -1212608691 >> 16 & 0xff) / 255.0F, (class78.anInt726 * -1212608691 >> 8 & 0xff) / 255.0F, (class78.anInt726 * -1212608691 >> 0 & 0xff) / 255.0F);
  2819. } else {
  2820. class137.aClass232_1523.method2135(0.0F, 0.0F, 0.0F, 0.0F);
  2821. class137.aClass217_1524.method2007(0.0F, 0.0F, 0.0F);
  2822. }
  2823. if (aClass_ra_Sub3_7894.anInt8233 > 0) {
  2824. class137.aClass232_1525.method2135(0.0F, 0.0F, 1.0F, -aClass_ra_Sub3_7894.aFloat8292);
  2825. class137.aClass217_1522.method2007((aClass_ra_Sub3_7894.anInt8332 >> 16 & 0xff) / 255.0F, (aClass_ra_Sub3_7894.anInt8332 >> 8 & 0xff) / 255.0F, (aClass_ra_Sub3_7894.anInt8332 >> 0 & 0xff) / 255.0F);
  2826. aClass_ra_Sub3_7894.aClass233_8236.method2145(class222);
  2827. aClass_ra_Sub3_7894.aClass233_8236.method2159();
  2828. class137.aClass232_1523.method2138(aClass_ra_Sub3_7894.aClass233_8236);
  2829. aClass_ra_Sub3_7894.aClass233_8236.method2145(class222);
  2830. aClass_ra_Sub3_7894.aClass233_8236.method2144(aClass_ra_Sub3_7894.aClass233_8230);
  2831. aClass_ra_Sub3_7894.aClass233_8236.method2159();
  2832. class137.aClass232_1525.method2138(aClass_ra_Sub3_7894.aClass233_8236);
  2833. class137.aClass232_1525.method2139(1.0F / (aClass_ra_Sub3_7894.aFloat8336 - aClass_ra_Sub3_7894.aFloat8292));
  2834. } else {
  2835. class137.aClass232_1525.method2135(0.0F, 0.0F, 0.0F, 0.0F);
  2836. class137.aClass217_1522.method2007(0.0F, 0.0F, 0.0F);
  2837. }
  2838. if ((anInt7896 & 0x37) == 0) {
  2839. aClass_ra_Sub3_7894.method5455(aClass_ra_Sub3_7894.aClass153_8306);
  2840. if (aClass_ra_Sub3_7894.aBoolean8214) {
  2841. aClass_ra_Sub3_7894.method5417(false);
  2842. }
  2843. for (int i = 0; i < anIntArray7945.length; i++) {
  2844. int i_625_ = anIntArray7944[i];
  2845. int i_626_ = anIntArray7944[i + 1];
  2846. int i_627_ = aShortArray7923[i_625_] & 0xffff;
  2847. boolean bool = false;
  2848. if (i_627_ != 65535) {
  2849. class137.anInterface9_Impl2_1517 = aClass_ra_Sub3_7894.aClass157_8351.method1698(i_627_);
  2850. Class53 class53 = aClass_ra_Sub3_7894.anInterface_ma5299.method174(i_627_, 2089802504);
  2851. bool = !Class298_Sub32_Sub31.method3339(class53.aByte529, -1764580449);
  2852. class137.aClass233_1519.aFloatArray2594[12] = aClass_ra_Sub3_7894.anInt8342 % 128000 / 1000.0F * class53.aByte535 / 64.0F % 1.0F;
  2853. class137.aClass233_1519.aFloatArray2594[13] = aClass_ra_Sub3_7894.anInt8342 % 128000 / 1000.0F * class53.aByte509 / 64.0F % 1.0F;
  2854. } else {
  2855. class137.anInterface9_Impl2_1517 = aClass_ra_Sub3_7894.anInterface9_Impl2_8310;
  2856. float[] fs = class137.aClass233_1519.aFloatArray2594;
  2857. class137.aClass233_1519.aFloatArray2594[13] = 0.0F;
  2858. fs[12] = 0.0F;
  2859. }
  2860. class137.anInt1532 = anIntArray7945[i];
  2861. class137.anInt1533 = anIntArray7913[i];
  2862. class137.anInt1534 = i_625_ * 3;
  2863. class137.anInt1514 = i_626_ - i_625_;
  2864. class137.method1514(bool);
  2865. }
  2866. } else {
  2867. aClass_ra_Sub3_7894.method5383(3, aClass186_7934.anInterface7_Impl1_1902);
  2868. aClass_ra_Sub3_7894.method5455(aClass_ra_Sub3_7894.aClass153_8358);
  2869. Class222 class222_628_ = aClass_ra_Sub3_7894.aClass222_8235;
  2870. class222_628_.method2070(class222);
  2871. class222_628_.method2058();
  2872. int i = 0;
  2873. if (aClass_ra_Sub3_7894.aBoolean8214) {
  2874. aClass_ra_Sub3_7894.method5417(true);
  2875. } else {
  2876. class137.aClass217_1527.method2007(aClass_ra_Sub3_7894.aFloatArray8283[0], aClass_ra_Sub3_7894.aFloatArray8283[1], aClass_ra_Sub3_7894.aFloatArray8283[2]);
  2877. class137.aClass217_1527.method2018(class222_628_);
  2878. class137.aClass217_1528.method2007(aClass_ra_Sub3_7894.aFloat8364 * aClass_ra_Sub3_7894.aFloat8362, aClass_ra_Sub3_7894.aFloat8364 * aClass_ra_Sub3_7894.aFloat8289, aClass_ra_Sub3_7894.aFloat8364 * aClass_ra_Sub3_7894.aFloat8290);
  2879. class137.aClass217_1529.method2007(-aClass_ra_Sub3_7894.aFloat8293 * aClass_ra_Sub3_7894.aFloat8362, -aClass_ra_Sub3_7894.aFloat8293 * aClass_ra_Sub3_7894.aFloat8289, -aClass_ra_Sub3_7894.aFloat8293 * aClass_ra_Sub3_7894.aFloat8290);
  2880. class137.aClass217_1515.method2007(aClass_ra_Sub3_7894.aFloat8291 * aClass_ra_Sub3_7894.aFloat8362, aClass_ra_Sub3_7894.aFloat8291 * aClass_ra_Sub3_7894.aFloat8289, aClass_ra_Sub3_7894.aFloat8291 * aClass_ra_Sub3_7894.aFloat8290);
  2881. if (aClass_ra_Sub3_7894.anInt8295 > 0) {
  2882. i = aClass_ra_Sub3_7894.anInt8295;
  2883. Class217 class217 = aClass_ra_Sub3_7894.aClass217_8238;
  2884. for (int i_629_ = 0; i_629_ < i; i_629_++) {
  2885. Class298_Sub10 class298_sub10 = aClass_ra_Sub3_7894.aClass298_Sub10Array8286[i_629_];
  2886. int i_630_ = class298_sub10.method2898(-1700557017);
  2887. class217.method2013(class298_sub10.aClass217_7231);
  2888. class217.method2016(class222_628_);
  2889. class137.aFloatArray1516[i_629_ * 4 + 0] = class217.aFloat2451;
  2890. class137.aFloatArray1516[i_629_ * 4 + 1] = class217.aFloat2455;
  2891. class137.aFloatArray1516[i_629_ * 4 + 2] = class217.aFloat2454;
  2892. class137.aFloatArray1516[i_629_ * 4 + 3] = class298_sub10.method2900(-516677016) * class298_sub10.method2900(-969209529);
  2893. float f = class298_sub10.method2901(608404512) / 255.0F;
  2894. class137.aFloatArray1526[i_629_ * 4 + 0] = (i_630_ >> 16 & 0xff) * f;
  2895. class137.aFloatArray1526[i_629_ * 4 + 1] = (i_630_ >> 8 & 0xff) * f;
  2896. class137.aFloatArray1526[i_629_ * 4 + 2] = (i_630_ & 0xff) * f;
  2897. class137.aFloatArray1526[i_629_ * 4 + 3] = 1.0F;
  2898. }
  2899. }
  2900. }
  2901. for (int i_631_ = 0; i_631_ < anIntArray7945.length; i_631_++) {
  2902. int i_632_ = anIntArray7944[i_631_];
  2903. int i_633_ = anIntArray7944[i_631_ + 1];
  2904. int i_634_ = aShortArray7923[i_632_] & 0xffff;
  2905. byte i_635_ = 11;
  2906. if (i_634_ != 65535) {
  2907. class137.anInterface9_Impl2_1517 = aClass_ra_Sub3_7894.aClass157_8351.method1698(i_634_);
  2908. Class53 class53 = aClass_ra_Sub3_7894.anInterface_ma5299.method174(i_634_, 1828434127);
  2909. i_635_ = class53.aByte529;
  2910. class137.method1509(class53);
  2911. class137.aClass233_1519.aFloatArray2594[12] = aClass_ra_Sub3_7894.anInt8342 % 128000 / 1000.0F * class53.aByte535 / 64.0F % 1.0F;
  2912. class137.aClass233_1519.aFloatArray2594[13] = aClass_ra_Sub3_7894.anInt8342 % 128000 / 1000.0F * class53.aByte509 / 64.0F % 1.0F;
  2913. } else {
  2914. class137.anInterface9_Impl2_1517 = aClass_ra_Sub3_7894.anInterface9_Impl2_8310;
  2915. float[] fs = class137.aClass233_1519.aFloatArray2594;
  2916. class137.aClass233_1519.aFloatArray2594[13] = 0.0F;
  2917. fs[12] = 0.0F;
  2918. }
  2919. class137.anInt1532 = anIntArray7945[i_631_];
  2920. class137.anInt1533 = anIntArray7913[i_631_];
  2921. class137.anInt1534 = i_632_ * 3;
  2922. class137.anInt1514 = i_633_ - i_632_;
  2923. switch (i_635_) {
  2924. case 6:
  2925. class137.method1514(!Class298_Sub32_Sub31.method3339(i_635_, -2085193350));
  2926. break;
  2927. default:
  2928. class137.method1507(i);
  2929. break;
  2930. case 5:
  2931. if (!aClass_ra_Sub3_7894.aBoolean8214) {
  2932. Class161_Sub1_Sub1 class161_sub1_sub1 = aClass_ra_Sub3_7894.aClass161_Sub1_Sub1_8266;
  2933. Class53 class53 = aClass_ra_Sub3_7894.anInterface_ma5299.method174(i_634_, 1474848008);
  2934. class161_sub1_sub1.method1738(class53.aByte536, class53.anInt531 * 1616831825, (byte) 19);
  2935. class161_sub1_sub1.aClass233_9121.method2145(class222);
  2936. class161_sub1_sub1.aClass233_9124.method2145(class222);
  2937. class161_sub1_sub1.aClass233_9124.method2144(aClass_ra_Sub3_7894.aClass233_8251);
  2938. class161_sub1_sub1.anInt9132 = anIntArray7945[i_631_] * 1459484499;
  2939. class161_sub1_sub1.anInt9133 = anIntArray7913[i_631_] * -2143476445;
  2940. class161_sub1_sub1.anInt9134 = i_632_ * 1595616125;
  2941. class161_sub1_sub1.anInt9135 = (i_633_ - i_632_) * -1212285161;
  2942. class161_sub1_sub1.method1739(-1182747927);
  2943. } else {
  2944. class137.method1507(i);
  2945. }
  2946. break;
  2947. case 7:
  2948. class137.aClass217_1530.method2007(aClass_ra_Sub3_7894.aClass233_8231.aFloatArray2594[12], aClass_ra_Sub3_7894.aClass233_8231.aFloatArray2594[13], aClass_ra_Sub3_7894.aClass233_8231.aFloatArray2594[14]);
  2949. class137.aClass217_1530.method2016(class222_628_);
  2950. class137.aClass233_1535.method2145(class222);
  2951. class137.anInterface9_Impl1_1518 = aClass_ra_Sub3_7894.method5321();
  2952. class137.method1503(i);
  2953. break;
  2954. case 1:
  2955. class137.aClass217_1530.method2007(aClass_ra_Sub3_7894.aClass233_8231.aFloatArray2594[12], aClass_ra_Sub3_7894.aClass233_8231.aFloatArray2594[13], aClass_ra_Sub3_7894.aClass233_8231.aFloatArray2594[14]);
  2956. class137.aClass217_1530.method2016(class222_628_);
  2957. class137.method1508(i);
  2958. }
  2959. }
  2960. }
  2961. method4837();
  2962. }
  2963. }
  2964.  
  2965. @Override
  2966. public int cr() {
  2967. if (!aBoolean7950) {
  2968. method4832();
  2969. }
  2970. return anInt7940;
  2971. }
  2972.  
  2973. boolean method4844() {
  2974. boolean bool = !aClass186_7911.aBoolean1900;
  2975. boolean bool_636_ = (anInt7896 & 0x37) != 0 && !aClass186_7934.aBoolean1900;
  2976. boolean bool_637_ = !aClass186_7927.aBoolean1900;
  2977. boolean bool_638_ = !aClass186_7930.aBoolean1900;
  2978. if (!bool_637_ && !bool && !bool_636_ && !bool_638_) {
  2979. return true;
  2980. }
  2981. boolean bool_639_ = true;
  2982. if (bool_637_ && aShortArray7907 != null) {
  2983. if (aClass186_7927.anInterface7_Impl1_1903 == null) {
  2984. aClass186_7927.anInterface7_Impl1_1903 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  2985. }
  2986. Interface7_Impl1 interface7_impl1 = aClass186_7927.anInterface7_Impl1_1903;
  2987. interface7_impl1.method72(anInt7906 * 12, 12);
  2988. Unsafe unsafe = aClass_ra_Sub3_7894.anUnsafe8219;
  2989. if (unsafe != null) {
  2990. int i = anInt7906 * 12;
  2991. long l = interface7_impl1.method62(0, i);
  2992. for (int i_640_ = 0; i_640_ < anInt7906; i_640_++) {
  2993. short i_641_ = aShortArray7907[i_640_];
  2994. unsafe.putFloat(l, vertices_x[i_641_]);
  2995. l += 4L;
  2996. unsafe.putFloat(l, vertices_y[i_641_]);
  2997. l += 4L;
  2998. unsafe.putFloat(l, vertices_z[i_641_]);
  2999. l += 4L;
  3000. }
  3001. interface7_impl1.method69();
  3002. } else {
  3003. ByteBuffer bytebuffer = aClass_ra_Sub3_7894.aByteBuffer8216;
  3004. bytebuffer.clear();
  3005. for (int i = 0; i < anInt7906; i++) {
  3006. bytebuffer.putFloat(vertices_x[aShortArray7907[i]]);
  3007. bytebuffer.putFloat(vertices_y[aShortArray7907[i]]);
  3008. bytebuffer.putFloat(vertices_z[aShortArray7907[i]]);
  3009. }
  3010. interface7_impl1.method63(0, bytebuffer.position(), aClass_ra_Sub3_7894.aLong8217);
  3011. }
  3012. aClass186_7927.anInterface7_Impl1_1902 = interface7_impl1;
  3013. aClass186_7927.aBoolean1900 = true;
  3014. }
  3015. if (bool) {
  3016. if (aClass186_7911.anInterface7_Impl1_1903 == null) {
  3017. aClass186_7911.anInterface7_Impl1_1903 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  3018. }
  3019. Interface7_Impl1 interface7_impl1 = aClass186_7911.anInterface7_Impl1_1903;
  3020. interface7_impl1.method72(anInt7906 * 4, 4);
  3021. Unsafe unsafe = aClass_ra_Sub3_7894.anUnsafe8219;
  3022. if (unsafe != null) {
  3023. int i = anInt7906 * 4;
  3024. long l = interface7_impl1.method62(0, i);
  3025. if ((anInt7896 & 0x37) == 0) {
  3026. short[] is;
  3027. short[] is_642_;
  3028. short[] is_643_;
  3029. byte[] is_644_;
  3030. if (aClass185_7915 != null) {
  3031. is = aClass185_7915.aShortArray1899;
  3032. is_642_ = aClass185_7915.aShortArray1897;
  3033. is_643_ = aClass185_7915.aShortArray1896;
  3034. is_644_ = aClass185_7915.aByteArray1898;
  3035. } else {
  3036. is = aShortArray7909;
  3037. is_642_ = aShortArray7910;
  3038. is_643_ = aShortArray7919;
  3039. is_644_ = aByteArray7958;
  3040. }
  3041. float f = aClass_ra_Sub3_7894.aFloat8364 * 768.0F / aShort7898;
  3042. float f_645_ = aClass_ra_Sub3_7894.aFloat8293 * 768.0F / aShort7898;
  3043. for (int i_646_ = 0; i_646_ < anInt7906; i_646_++) {
  3044. short i_647_ = aShortArray7908[i_646_];
  3045. int i_648_ = method4846(aShortArray7935[i_647_] & 0xffff, aShortArray7923[i_647_], aShort7897);
  3046. float f_649_ = (i_648_ >> 16 & 0xff) * aClass_ra_Sub3_7894.aFloat8362;
  3047. float f_650_ = (i_648_ >> 8 & 0xff) * aClass_ra_Sub3_7894.aFloat8289;
  3048. float f_651_ = (i_648_ & 0xff) * aClass_ra_Sub3_7894.aFloat8290;
  3049. byte i_652_ = is_644_[i_646_];
  3050. float f_653_;
  3051. if (i_652_ == 0) {
  3052. f_653_ = (aClass_ra_Sub3_7894.aFloatArray8283[0] * is[i_646_] + aClass_ra_Sub3_7894.aFloatArray8283[1] * is_642_[i_646_] + aClass_ra_Sub3_7894.aFloatArray8283[2] * is_643_[i_646_]) * 0.0026041667F;
  3053. } else {
  3054. f_653_ = (aClass_ra_Sub3_7894.aFloatArray8283[0] * is[i_646_] + aClass_ra_Sub3_7894.aFloatArray8283[1] * is_642_[i_646_] + aClass_ra_Sub3_7894.aFloatArray8283[2] * is_643_[i_646_]) / (i_652_ * 256.0F);
  3055. }
  3056. float f_654_ = aClass_ra_Sub3_7894.aFloat8291 + f_653_ * (f_653_ < 0.0F ? f_645_ : f);
  3057. int i_655_ = (int) (f_649_ * f_654_);
  3058. if (i_655_ < 0) {
  3059. i_655_ = 0;
  3060. } else if (i_655_ > 255) {
  3061. i_655_ = 255;
  3062. }
  3063. int i_656_ = (int) (f_650_ * f_654_);
  3064. if (i_656_ < 0) {
  3065. i_656_ = 0;
  3066. } else if (i_656_ > 255) {
  3067. i_656_ = 255;
  3068. }
  3069. int i_657_ = (int) (f_651_ * f_654_);
  3070. if (i_657_ < 0) {
  3071. i_657_ = 0;
  3072. } else if (i_657_ > 255) {
  3073. i_657_ = 255;
  3074. }
  3075. unsafe.putInt(l, 255 - aByteArray7963[i_647_] << 24 | i_655_ << 16 | i_656_ << 8 | i_657_);
  3076. l += 4L;
  3077. }
  3078. } else {
  3079. for (int i_658_ = 0; i_658_ < anInt7906; i_658_++) {
  3080. short i_659_ = aShortArray7908[i_658_];
  3081. int i_660_ = 255 - aByteArray7963[i_659_] << 24 | method4846(aShortArray7935[i_659_] & 0xffff, aShortArray7923[i_659_], aShort7897);
  3082. unsafe.putInt(l, i_660_);
  3083. l += 4L;
  3084. }
  3085. }
  3086. interface7_impl1.method69();
  3087. } else {
  3088. ByteBuffer bytebuffer = aClass_ra_Sub3_7894.aByteBuffer8216;
  3089. bytebuffer.clear();
  3090. if ((anInt7896 & 0x37) == 0) {
  3091. short[] is;
  3092. short[] is_661_;
  3093. short[] is_662_;
  3094. byte[] is_663_;
  3095. if (aClass185_7915 != null) {
  3096. is = aClass185_7915.aShortArray1899;
  3097. is_661_ = aClass185_7915.aShortArray1897;
  3098. is_662_ = aClass185_7915.aShortArray1896;
  3099. is_663_ = aClass185_7915.aByteArray1898;
  3100. } else {
  3101. is = aShortArray7909;
  3102. is_661_ = aShortArray7910;
  3103. is_662_ = aShortArray7919;
  3104. is_663_ = aByteArray7958;
  3105. }
  3106. float f = aClass_ra_Sub3_7894.aFloat8364 * 768.0F / aShort7898;
  3107. float f_664_ = aClass_ra_Sub3_7894.aFloat8293 * 768.0F / aShort7898;
  3108. for (int i = 0; i < anInt7906; i++) {
  3109. short i_665_ = aShortArray7908[i];
  3110. int i_666_ = method4846(aShortArray7935[i_665_] & 0xffff, aShortArray7923[i_665_], aShort7897);
  3111. float f_667_ = (i_666_ >> 16 & 0xff) * aClass_ra_Sub3_7894.aFloat8362;
  3112. float f_668_ = (i_666_ >> 8 & 0xff) * aClass_ra_Sub3_7894.aFloat8289;
  3113. float f_669_ = (i_666_ & 0xff) * aClass_ra_Sub3_7894.aFloat8290;
  3114. byte i_670_ = is_663_[i];
  3115. float f_671_;
  3116. if (i_670_ == 0) {
  3117. f_671_ = (aClass_ra_Sub3_7894.aFloatArray8283[0] * is[i] + aClass_ra_Sub3_7894.aFloatArray8283[1] * is_661_[i] + aClass_ra_Sub3_7894.aFloatArray8283[2] * is_662_[i]) * 0.0026041667F;
  3118. } else {
  3119. f_671_ = (aClass_ra_Sub3_7894.aFloatArray8283[0] * is[i] + aClass_ra_Sub3_7894.aFloatArray8283[1] * is_661_[i] + aClass_ra_Sub3_7894.aFloatArray8283[2] * is_662_[i]) / (i_670_ * 256.0F);
  3120. }
  3121. float f_672_ = aClass_ra_Sub3_7894.aFloat8291 + f_671_ * (f_671_ < 0.0F ? f_664_ : f);
  3122. int i_673_ = (int) (f_667_ * f_672_);
  3123. if (i_673_ < 0) {
  3124. i_673_ = 0;
  3125. } else if (i_673_ > 255) {
  3126. i_673_ = 255;
  3127. }
  3128. int i_674_ = (int) (f_668_ * f_672_);
  3129. if (i_674_ < 0) {
  3130. i_674_ = 0;
  3131. } else if (i_674_ > 255) {
  3132. i_674_ = 255;
  3133. }
  3134. int i_675_ = (int) (f_669_ * f_672_);
  3135. if (i_675_ < 0) {
  3136. i_675_ = 0;
  3137. } else if (i_675_ > 255) {
  3138. i_675_ = 255;
  3139. }
  3140. bytebuffer.putInt(255 - aByteArray7963[i_665_] << 24 | i_673_ << 16 | i_674_ << 8 | i_675_);
  3141. }
  3142. } else {
  3143. for (int i = 0; i < anInt7906; i++) {
  3144. short i_676_ = aShortArray7908[i];
  3145. int i_677_ = 255 - aByteArray7963[i_676_] << 24 | method4846(aShortArray7935[i_676_] & 0xffff, aShortArray7923[i_676_], aShort7897);
  3146. bytebuffer.putInt(i_677_);
  3147. }
  3148. }
  3149. interface7_impl1.method63(0, bytebuffer.position(), aClass_ra_Sub3_7894.aLong8217);
  3150. }
  3151. aClass186_7911.anInterface7_Impl1_1902 = interface7_impl1;
  3152. aClass186_7911.aBoolean1900 = true;
  3153. }
  3154. if (bool_636_) {
  3155. if (aClass186_7934.anInterface7_Impl1_1903 == null) {
  3156. aClass186_7934.anInterface7_Impl1_1903 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  3157. }
  3158. Interface7_Impl1 interface7_impl1 = aClass186_7934.anInterface7_Impl1_1903;
  3159. interface7_impl1.method72(anInt7906 * 12, 12);
  3160. short[] is;
  3161. short[] is_678_;
  3162. short[] is_679_;
  3163. byte[] is_680_;
  3164. if (aClass185_7915 != null) {
  3165. is = aClass185_7915.aShortArray1899;
  3166. is_678_ = aClass185_7915.aShortArray1897;
  3167. is_679_ = aClass185_7915.aShortArray1896;
  3168. is_680_ = aClass185_7915.aByteArray1898;
  3169. } else {
  3170. is = aShortArray7909;
  3171. is_678_ = aShortArray7910;
  3172. is_679_ = aShortArray7919;
  3173. is_680_ = aByteArray7958;
  3174. }
  3175. float f = 3.0F / aShort7898;
  3176. float f_681_ = 3.0F / (aShort7898 + aShort7898 / 2);
  3177. Unsafe unsafe = aClass_ra_Sub3_7894.anUnsafe8219;
  3178. if (unsafe != null) {
  3179. int i = anInt7906 * 12;
  3180. long l = interface7_impl1.method62(0, i);
  3181. for (int i_682_ = 0; i_682_ < anInt7906; i_682_++) {
  3182. float f_683_ = is_680_[i_682_] == 0 ? f_681_ : f / is_680_[i_682_];
  3183. float f_684_ = is[i_682_] * f_683_;
  3184. float f_685_ = is_678_[i_682_] * f_683_;
  3185. float f_686_ = is_679_[i_682_] * f_683_;
  3186. unsafe.putFloat(l, f_684_);
  3187. l += 4L;
  3188. unsafe.putFloat(l, f_685_);
  3189. l += 4L;
  3190. unsafe.putFloat(l, f_686_);
  3191. l += 4L;
  3192. }
  3193. interface7_impl1.method69();
  3194. } else {
  3195. ByteBuffer bytebuffer = aClass_ra_Sub3_7894.aByteBuffer8216;
  3196. bytebuffer.clear();
  3197. for (int i = 0; i < anInt7906; i++) {
  3198. float f_687_ = is_680_[i] == 0 ? f_681_ : f / is_680_[i];
  3199. float f_688_ = is[i] * f_687_;
  3200. float f_689_ = is_678_[i] * f_687_;
  3201. float f_690_ = is_679_[i] * f_687_;
  3202. bytebuffer.putFloat(f_688_);
  3203. bytebuffer.putFloat(f_689_);
  3204. bytebuffer.putFloat(f_690_);
  3205. }
  3206. interface7_impl1.method63(0, bytebuffer.position(), aClass_ra_Sub3_7894.aLong8217);
  3207. }
  3208. aClass186_7934.anInterface7_Impl1_1902 = interface7_impl1;
  3209. aClass186_7934.aBoolean1900 = true;
  3210. }
  3211. if (bool_638_) {
  3212. if (aClass186_7930.anInterface7_Impl1_1903 == null) {
  3213. aClass186_7930.anInterface7_Impl1_1903 = aClass_ra_Sub3_7894.method5382(aBoolean7931);
  3214. }
  3215. Interface7_Impl1 interface7_impl1 = aClass186_7930.anInterface7_Impl1_1903;
  3216. interface7_impl1.method72(anInt7906 * 8, 8);
  3217. Unsafe unsafe = aClass_ra_Sub3_7894.anUnsafe8219;
  3218. if (unsafe != null) {
  3219. int i = anInt7906 * 8;
  3220. long l = interface7_impl1.method62(0, i);
  3221. for (int i_691_ = 0; i_691_ < anInt7906; i_691_++) {
  3222. unsafe.putFloat(l, aFloatArray7953[i_691_]);
  3223. l += 4L;
  3224. unsafe.putFloat(l, aFloatArray7914[i_691_]);
  3225. l += 4L;
  3226. }
  3227. interface7_impl1.method69();
  3228. } else {
  3229. ByteBuffer bytebuffer = aClass_ra_Sub3_7894.aByteBuffer8216;
  3230. bytebuffer.clear();
  3231. for (int i = 0; i < anInt7906; i++) {
  3232. bytebuffer.putFloat(aFloatArray7953[i]);
  3233. bytebuffer.putFloat(aFloatArray7914[i]);
  3234. }
  3235. interface7_impl1.method63(0, bytebuffer.position(), aClass_ra_Sub3_7894.aLong8217);
  3236. }
  3237. aClass186_7930.anInterface7_Impl1_1902 = interface7_impl1;
  3238. aClass186_7930.aBoolean1900 = true;
  3239. }
  3240. return bool_639_;
  3241. }
  3242.  
  3243. @Override
  3244. public int m() {
  3245. return anInt7912;
  3246. }
  3247.  
  3248. int method4845(int i, int i_692_) {
  3249. i_692_ = i_692_ * (i & 0x7f) >> 7;
  3250. if (i_692_ < 2) {
  3251. i_692_ = 2;
  3252. } else if (i_692_ > 126) {
  3253. i_692_ = 126;
  3254. }
  3255. return (i & 0xff80) + i_692_;
  3256. }
  3257.  
  3258. int method4846(int i, short i_693_, int i_694_) {
  3259. int i_695_ = aClass_ra_Sub3_7894.anIntArray8215[method4845(i, i_694_)];
  3260. if (i_693_ != -1) {
  3261. Class53 class53 = aClass_ra_Sub3_7894.anInterface_ma5299.method174(i_693_ & 0xffff, 655487432);
  3262. int i_696_ = class53.aByte533 & 0xff;
  3263. if (i_696_ != 0) {
  3264. int i_697_ = 131586 * i_694_;
  3265. if (i_696_ == 256) {
  3266. i_695_ = i_697_;
  3267. } else {
  3268. int i_698_ = i_696_;
  3269. int i_699_ = 256 - i_696_;
  3270. i_695_ = ((i_697_ & 0xff00ff) * i_698_ + (i_695_ & 0xff00ff) * i_699_ & ~0xff00ff) + ((i_697_ & 0xff00) * i_698_ + (i_695_ & 0xff00) * i_699_ & 0xff0000) >> 8;
  3271. }
  3272. }
  3273. int i_700_ = class53.aByte534 & 0xff;
  3274. if (i_700_ != 0) {
  3275. i_700_ += 256;
  3276. int i_701_ = ((i_695_ & 0xff0000) >> 16) * i_700_;
  3277. if (i_701_ > 65535) {
  3278. i_701_ = 65535;
  3279. }
  3280. int i_702_ = ((i_695_ & 0xff00) >> 8) * i_700_;
  3281. if (i_702_ > 65535) {
  3282. i_702_ = 65535;
  3283. }
  3284. int i_703_ = (i_695_ & 0xff) * i_700_;
  3285. if (i_703_ > 65535) {
  3286. i_703_ = 65535;
  3287. }
  3288. i_695_ = (i_701_ << 8 & 0xff0000) + (i_702_ & 0xff00) + (i_703_ >> 8);
  3289. }
  3290. }
  3291. return i_695_ & 0xffffff;
  3292. }
  3293.  
  3294. @Override
  3295. public int cp() {
  3296. if (!aBoolean7950) {
  3297. method4832();
  3298. }
  3299. return anInt7941;
  3300. }
  3301.  
  3302. @Override
  3303. public void method4742(byte i, byte[] is) {
  3304. if (is == null) {
  3305. for (int i_704_ = 0; i_704_ < anInt7916; i_704_++) {
  3306. aByteArray7963[i_704_] = i;
  3307. }
  3308. } else {
  3309. for (int i_705_ = 0; i_705_ < anInt7916; i_705_++) {
  3310. int i_706_ = 255 - (255 - (is[i_705_] & 0xff)) * (255 - (i & 0xff)) / 255;
  3311. aByteArray7963[i_705_] = (byte) i_706_;
  3312. }
  3313. }
  3314. method4838();
  3315. }
  3316.  
  3317. @Override
  3318. public void dj(int i, int i_707_, int i_708_, int i_709_) {
  3319. for (int i_710_ = 0; i_710_ < anInt7916; i_710_++) {
  3320. int i_711_ = aShortArray7935[i_710_] & 0xffff;
  3321. int i_712_ = i_711_ >> 10 & 0x3f;
  3322. int i_713_ = i_711_ >> 7 & 0x7;
  3323. int i_714_ = i_711_ & 0x7f;
  3324. if (i != -1) {
  3325. i_712_ += (i - i_712_) * i_709_ >> 7;
  3326. }
  3327. if (i_707_ != -1) {
  3328. i_713_ += (i_707_ - i_713_) * i_709_ >> 7;
  3329. }
  3330. if (i_708_ != -1) {
  3331. i_714_ += (i_708_ - i_714_) * i_709_ >> 7;
  3332. }
  3333. aShortArray7935[i_710_] = (short) (i_712_ << 10 | i_713_ << 7 | i_714_);
  3334. }
  3335. if (aClass191Array7952 != null) {
  3336. for (int i_715_ = 0; i_715_ < anInt7951; i_715_++) {
  3337. Class191 class191 = aClass191Array7952[i_715_];
  3338. Class166 class166 = aClass166Array7892[i_715_];
  3339. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  3340. }
  3341. }
  3342. method4838();
  3343. }
  3344.  
  3345. @Override
  3346. public int cq() {
  3347. if (!aBoolean7950) {
  3348. method4832();
  3349. }
  3350. return anInt7941;
  3351. }
  3352.  
  3353. @Override
  3354. public int n() {
  3355. if (!aBoolean7950) {
  3356. method4832();
  3357. }
  3358. return anInt7928;
  3359. }
  3360.  
  3361. @Override
  3362. public Class387 method4750(byte i, int i_716_, boolean bool) {
  3363. boolean bool_717_ = false;
  3364. Class387_Sub3 class387_sub3_718_;
  3365. Class387_Sub3 class387_sub3_719_;
  3366. if (i > 0 && i <= 7) {
  3367. class387_sub3_719_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8267[i - 1];
  3368. class387_sub3_718_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8288[i - 1];
  3369. bool_717_ = true;
  3370. } else {
  3371. class387_sub3_718_ = class387_sub3_719_ = new Class387_Sub3(aClass_ra_Sub3_7894, 0, 0, true, false);
  3372. }
  3373. return method4836(class387_sub3_718_, class387_sub3_719_, i_716_, bool_717_, bool);
  3374. }
  3375.  
  3376. static float[] method4847(float[] fs, int i) {
  3377. float[] fs_720_ = new float[i];
  3378. System.arraycopy(fs, 0, fs_720_, 0, i);
  3379. return fs_720_;
  3380. }
  3381.  
  3382. @Override
  3383. public void au(int i) {
  3384. if (aClass186_7927 != null) {
  3385. aClass186_7927.aBoolean1901 = Class154.method1685(i, anInt7896);
  3386. }
  3387. if (aClass186_7930 != null) {
  3388. aClass186_7930.aBoolean1901 = Class154.method1692(i, anInt7896);
  3389. }
  3390. if (aClass186_7911 != null) {
  3391. aClass186_7911.aBoolean1901 = Class154.method1680(i, anInt7896);
  3392. }
  3393. if (aClass186_7934 != null) {
  3394. aClass186_7934.aBoolean1901 = Class154.method1669(i, anInt7896);
  3395. }
  3396. anInt7912 = i;
  3397. if (aClass185_7915 != null && (anInt7912 & 0x10000) == 0) {
  3398. aShortArray7909 = aClass185_7915.aShortArray1899;
  3399. aShortArray7910 = aClass185_7915.aShortArray1897;
  3400. aShortArray7919 = aClass185_7915.aShortArray1896;
  3401. aByteArray7958 = aClass185_7915.aByteArray1898;
  3402. aClass185_7915 = null;
  3403. }
  3404. aBoolean7932 = true;
  3405. method4837();
  3406. }
  3407.  
  3408. @Override
  3409. public void ar(int i) {
  3410. if (aClass186_7927 != null) {
  3411. aClass186_7927.aBoolean1901 = Class154.method1685(i, anInt7896);
  3412. }
  3413. if (aClass186_7930 != null) {
  3414. aClass186_7930.aBoolean1901 = Class154.method1692(i, anInt7896);
  3415. }
  3416. if (aClass186_7911 != null) {
  3417. aClass186_7911.aBoolean1901 = Class154.method1680(i, anInt7896);
  3418. }
  3419. if (aClass186_7934 != null) {
  3420. aClass186_7934.aBoolean1901 = Class154.method1669(i, anInt7896);
  3421. }
  3422. anInt7912 = i;
  3423. if (aClass185_7915 != null && (anInt7912 & 0x10000) == 0) {
  3424. aShortArray7909 = aClass185_7915.aShortArray1899;
  3425. aShortArray7910 = aClass185_7915.aShortArray1897;
  3426. aShortArray7919 = aClass185_7915.aShortArray1896;
  3427. aByteArray7958 = aClass185_7915.aByteArray1898;
  3428. aClass185_7915 = null;
  3429. }
  3430. aBoolean7932 = true;
  3431. method4837();
  3432. }
  3433.  
  3434. @Override
  3435. public void ac(int i) {
  3436. if (aClass186_7927 != null) {
  3437. aClass186_7927.aBoolean1901 = Class154.method1685(i, anInt7896);
  3438. }
  3439. if (aClass186_7930 != null) {
  3440. aClass186_7930.aBoolean1901 = Class154.method1692(i, anInt7896);
  3441. }
  3442. if (aClass186_7911 != null) {
  3443. aClass186_7911.aBoolean1901 = Class154.method1680(i, anInt7896);
  3444. }
  3445. if (aClass186_7934 != null) {
  3446. aClass186_7934.aBoolean1901 = Class154.method1669(i, anInt7896);
  3447. }
  3448. anInt7912 = i;
  3449. if (aClass185_7915 != null && (anInt7912 & 0x10000) == 0) {
  3450. aShortArray7909 = aClass185_7915.aShortArray1899;
  3451. aShortArray7910 = aClass185_7915.aShortArray1897;
  3452. aShortArray7919 = aClass185_7915.aShortArray1896;
  3453. aByteArray7958 = aClass185_7915.aByteArray1898;
  3454. aClass185_7915 = null;
  3455. }
  3456. aBoolean7932 = true;
  3457. method4837();
  3458. }
  3459.  
  3460. @Override
  3461. public void method4752() {
  3462. if (anInt7906 > 0 && anInt7917 > 0) {
  3463. method4844();
  3464. method4835();
  3465. method4837();
  3466. }
  3467. }
  3468.  
  3469. @Override
  3470. public void method4764() {
  3471. if (anInt7906 > 0 && anInt7917 > 0) {
  3472. method4844();
  3473. method4835();
  3474. method4837();
  3475. }
  3476. }
  3477.  
  3478. @Override
  3479. public void bf(int i) {
  3480. int i_721_ = Class220.anIntArray2483[i];
  3481. int i_722_ = Class220.anIntArray2474[i];
  3482. for (int i_723_ = 0; i_723_ < anInt7900; i_723_++) {
  3483. int i_724_ = vertices_z[i_723_] * i_721_ + vertices_x[i_723_] * i_722_ >> 14;
  3484. vertices_z[i_723_] = vertices_z[i_723_] * i_722_ - vertices_x[i_723_] * i_721_ >> 14;
  3485. vertices_x[i_723_] = i_724_;
  3486. }
  3487. method4851();
  3488. aBoolean7950 = false;
  3489. }
  3490.  
  3491. @Override
  3492. public void be(int i) {
  3493. int i_725_ = Class220.anIntArray2483[i];
  3494. int i_726_ = Class220.anIntArray2474[i];
  3495. for (int i_727_ = 0; i_727_ < anInt7900; i_727_++) {
  3496. int i_728_ = vertices_z[i_727_] * i_725_ + vertices_x[i_727_] * i_726_ >> 14;
  3497. vertices_z[i_727_] = vertices_z[i_727_] * i_726_ - vertices_x[i_727_] * i_725_ >> 14;
  3498. vertices_x[i_727_] = i_728_;
  3499. }
  3500. method4851();
  3501. aBoolean7950 = false;
  3502. }
  3503.  
  3504. @Override
  3505. public void by(int i) {
  3506. int i_729_ = Class220.anIntArray2483[i];
  3507. int i_730_ = Class220.anIntArray2474[i];
  3508. for (int i_731_ = 0; i_731_ < anInt7900; i_731_++) {
  3509. int i_732_ = vertices_z[i_731_] * i_729_ + vertices_x[i_731_] * i_730_ >> 14;
  3510. vertices_z[i_731_] = vertices_z[i_731_] * i_730_ - vertices_x[i_731_] * i_729_ >> 14;
  3511. vertices_x[i_731_] = i_732_;
  3512. }
  3513. for (int i_733_ = 0; i_733_ < anInt7906; i_733_++) {
  3514. int i_734_ = aShortArray7919[i_733_] * i_729_ + aShortArray7909[i_733_] * i_730_ >> 14;
  3515. aShortArray7919[i_733_] = (short) (aShortArray7919[i_733_] * i_730_ - aShortArray7909[i_733_] * i_729_ >> 14);
  3516. aShortArray7909[i_733_] = (short) i_734_;
  3517. }
  3518. method4851();
  3519. method4839();
  3520. aBoolean7950 = false;
  3521. }
  3522.  
  3523. short method4848(Model class64, int i, int i_735_, long l, int i_736_, int i_737_, int i_738_, int i_739_, float f, float f_740_) {
  3524. int i_741_ = anIntArray7947[i];
  3525. int i_742_ = anIntArray7947[i + 1];
  3526. int i_743_ = 0;
  3527. for (int i_744_ = i_741_; i_744_ < i_742_; i_744_++) {
  3528. short i_745_ = aShortArray7948[i_744_];
  3529. if (i_745_ == 0) {
  3530. i_743_ = i_744_;
  3531. break;
  3532. }
  3533. if (aLongArray7955[i_744_] == l) {
  3534. return (short) (i_745_ - 1);
  3535. }
  3536. }
  3537. aShortArray7948[i_743_] = (short) (anInt7906 + 1);
  3538. aLongArray7955[i_743_] = l;
  3539. aShortArray7908[anInt7906] = (short) i_735_;
  3540. aShortArray7907[anInt7906] = (short) i;
  3541. aShortArray7909[anInt7906] = (short) i_736_;
  3542. aShortArray7910[anInt7906] = (short) i_737_;
  3543. aShortArray7919[anInt7906] = (short) i_738_;
  3544. aByteArray7958[anInt7906] = (byte) i_739_;
  3545. aFloatArray7953[anInt7906] = f;
  3546. aFloatArray7914[anInt7906] = f_740_;
  3547. return (short) anInt7906++;
  3548. }
  3549.  
  3550. void method4849(Class233 class233) {
  3551. if (aClass191Array7952 != null) {
  3552. aClass_ra_Sub3_7894.RA(!aBoolean7893);
  3553. Class222 class222 = aClass_ra_Sub3_7894.aClass222_8235;
  3554. Class130 class130 = aClass_ra_Sub3_7894.aClass130_8249;
  3555. for (int i = 0; i < anInt7951; i++) {
  3556. Class191 class191 = aClass191Array7952[i];
  3557. Class166 class166 = aClass166Array7892[i];
  3558. if (!class191.aBoolean1945 || !aClass_ra_Sub3_7894.method5054()) {
  3559. float f = (vertices_x[class191.anInt1951] + vertices_x[class191.anInt1946] + vertices_x[class191.anInt1944]) * 0.3333333F;
  3560. float f_746_ = (vertices_y[class191.anInt1951] + vertices_y[class191.anInt1946] + vertices_y[class191.anInt1944]) * 0.3333333F;
  3561. float f_747_ = (vertices_z[class191.anInt1951] + vertices_z[class191.anInt1946] + vertices_z[class191.anInt1944]) * 0.3333333F;
  3562. float f_748_ = class233.aFloatArray2594[0] * f + class233.aFloatArray2594[4] * f_746_ + class233.aFloatArray2594[8] * f_747_ + class233.aFloatArray2594[12];
  3563. float f_749_ = class233.aFloatArray2594[1] * f + class233.aFloatArray2594[5] * f_746_ + class233.aFloatArray2594[9] * f_747_ + class233.aFloatArray2594[13];
  3564. float f_750_ = class233.aFloatArray2594[2] * f + class233.aFloatArray2594[6] * f_746_ + class233.aFloatArray2594[10] * f_747_ + class233.aFloatArray2594[14];
  3565. float f_751_ = (float) (1.0 / Math.sqrt(f_748_ * f_748_ + f_749_ * f_749_ + f_750_ * f_750_)) * class191.anInt1952;
  3566. class222.method2056(class166.anInt1706, class166.anInt1702 * class191.aShort1948 >> 7, class166.anInt1701 * class191.aShort1949 >> 7, f_748_ + class166.anInt1704 - f_748_ * f_751_, f_749_ + class166.anInt1705 - f_749_ * f_751_, f_750_ - f_750_ * f_751_);
  3567. class222.method2073(aClass_ra_Sub3_7894.aClass222_8229);
  3568. aClass_ra_Sub3_7894.aClass233_8204.method2145(class222);
  3569. class130.method1452(aClass_ra_Sub3_7894.aClass233_8204);
  3570. class130.aClass233_1494.method2172();
  3571. class130.anInt1493 = class166.anInt1703;
  3572. class130.anInterface9_Impl2_1492 = aClass_ra_Sub3_7894.aClass157_8351.method1698(class191.aShort1950);
  3573. class130.method1451();
  3574. }
  3575. }
  3576. aClass_ra_Sub3_7894.RA(true);
  3577. }
  3578. }
  3579.  
  3580. @Override
  3581. public void bo(int i) {
  3582. int i_752_ = Class220.anIntArray2483[i];
  3583. int i_753_ = Class220.anIntArray2474[i];
  3584. for (int i_754_ = 0; i_754_ < anInt7900; i_754_++) {
  3585. int i_755_ = vertices_y[i_754_] * i_753_ - vertices_z[i_754_] * i_752_ >> 14;
  3586. vertices_z[i_754_] = vertices_y[i_754_] * i_752_ + vertices_z[i_754_] * i_753_ >> 14;
  3587. vertices_y[i_754_] = i_755_;
  3588. }
  3589. method4851();
  3590. aBoolean7950 = false;
  3591. }
  3592.  
  3593. @Override
  3594. public void bb(int i) {
  3595. int i_756_ = Class220.anIntArray2483[i];
  3596. int i_757_ = Class220.anIntArray2474[i];
  3597. for (int i_758_ = 0; i_758_ < anInt7900; i_758_++) {
  3598. int i_759_ = vertices_y[i_758_] * i_756_ + vertices_x[i_758_] * i_757_ >> 14;
  3599. vertices_y[i_758_] = vertices_y[i_758_] * i_757_ - vertices_x[i_758_] * i_756_ >> 14;
  3600. vertices_x[i_758_] = i_759_;
  3601. }
  3602. method4851();
  3603. aBoolean7950 = false;
  3604. }
  3605.  
  3606. @Override
  3607. public void bl(int i, int i_760_, int i_761_) {
  3608. for (int i_762_ = 0; i_762_ < anInt7900; i_762_++) {
  3609. if (i != 0) {
  3610. vertices_x[i_762_] += i;
  3611. }
  3612. if (i_760_ != 0) {
  3613. vertices_y[i_762_] += i_760_;
  3614. }
  3615. if (i_761_ != 0) {
  3616. vertices_z[i_762_] += i_761_;
  3617. }
  3618. }
  3619. method4851();
  3620. aBoolean7950 = false;
  3621. }
  3622.  
  3623. @Override
  3624. public void bu(int i, int i_763_, int i_764_) {
  3625. for (int i_765_ = 0; i_765_ < anInt7900; i_765_++) {
  3626. if (i != 0) {
  3627. vertices_x[i_765_] += i;
  3628. }
  3629. if (i_763_ != 0) {
  3630. vertices_y[i_765_] += i_763_;
  3631. }
  3632. if (i_764_ != 0) {
  3633. vertices_z[i_765_] += i_764_;
  3634. }
  3635. }
  3636. method4851();
  3637. aBoolean7950 = false;
  3638. }
  3639.  
  3640. @Override
  3641. public void bw(int i, int i_766_, int i_767_) {
  3642. for (int i_768_ = 0; i_768_ < anInt7900; i_768_++) {
  3643. if (i != 0) {
  3644. vertices_x[i_768_] += i;
  3645. }
  3646. if (i_766_ != 0) {
  3647. vertices_y[i_768_] += i_766_;
  3648. }
  3649. if (i_767_ != 0) {
  3650. vertices_z[i_768_] += i_767_;
  3651. }
  3652. }
  3653. method4851();
  3654. aBoolean7950 = false;
  3655. }
  3656.  
  3657. @Override
  3658. public Class85[] method4771() {
  3659. return aClass85Array7949;
  3660. }
  3661.  
  3662. @Override
  3663. public void bq(int i, int i_769_, int i_770_) {
  3664. for (int i_771_ = 0; i_771_ < anInt7900; i_771_++) {
  3665. if (i != 128) {
  3666. vertices_x[i_771_] = vertices_x[i_771_] * i >> 7;
  3667. }
  3668. if (i_769_ != 128) {
  3669. vertices_y[i_771_] = vertices_y[i_771_] * i_769_ >> 7;
  3670. }
  3671. if (i_770_ != 128) {
  3672. vertices_z[i_771_] = vertices_z[i_771_] * i_770_ >> 7;
  3673. }
  3674. }
  3675. method4851();
  3676. aBoolean7950 = false;
  3677. }
  3678.  
  3679. @Override
  3680. public void bg(int i, int i_772_, Class_xa class_xa, Class_xa class_xa_773_, int i_774_, int i_775_, int i_776_) {
  3681. if (!aBoolean7950) {
  3682. method4832();
  3683. }
  3684. int i_777_ = i_774_ + anInt7940;
  3685. int i_778_ = i_774_ + anInt7941;
  3686. int i_779_ = i_776_ + anInt7942;
  3687. int i_780_ = i_776_ + anInt7943;
  3688. if (i != 1 && i != 2 && i != 3 && i != 5 || i_777_ >= 0 && i_778_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6287 * -506105871 && i_779_ >= 0 && i_780_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6286 * -1148794921) {
  3689. if (i == 4 || i == 5) {
  3690. if (class_xa_773_ == null || i_777_ < 0 || i_778_ + class_xa_773_.anInt6288 * -1212653763 >> class_xa_773_.anInt6289 * -2137349879 >= class_xa_773_.anInt6287 * -506105871 || i_779_ < 0 || i_780_ + class_xa_773_.anInt6288 * -1212653763 >> class_xa_773_.anInt6289 * -2137349879 >= class_xa_773_.anInt6286 * -1148794921) {
  3691. return;
  3692. }
  3693. } else {
  3694. i_777_ >>= class_xa.anInt6289 * -2137349879;
  3695. i_778_ = i_778_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  3696. i_779_ >>= class_xa.anInt6289 * -2137349879;
  3697. i_780_ = i_780_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  3698. if (class_xa.method6341(i_777_, i_779_, (byte) -8) == i_775_ && class_xa.method6341(i_778_, i_779_, (byte) -69) == i_775_ && class_xa.method6341(i_777_, i_780_, (byte) -76) == i_775_ && class_xa.method6341(i_778_, i_780_, (byte) -23) == i_775_) {
  3699. return;
  3700. }
  3701. }
  3702. if (i == 1) {
  3703. for (int i_781_ = 0; i_781_ < anInt7900; i_781_++) {
  3704. vertices_y[i_781_] = vertices_y[i_781_] + class_xa.method6340(vertices_x[i_781_] + i_774_, vertices_z[i_781_] + i_776_, -2097067003) - i_775_;
  3705. }
  3706. } else if (i == 2) {
  3707. int i_782_ = anInt7938;
  3708. if (i_782_ == 0) {
  3709. return;
  3710. }
  3711. for (int i_783_ = 0; i_783_ < anInt7900; i_783_++) {
  3712. int i_784_ = (vertices_y[i_783_] << 16) / i_782_;
  3713. if (i_784_ < i_772_) {
  3714. vertices_y[i_783_] = vertices_y[i_783_] + (class_xa.method6340(vertices_x[i_783_] + i_774_, vertices_z[i_783_] + i_776_, -1363823811) - i_775_) * (i_772_ - i_784_) / i_772_;
  3715. }
  3716. }
  3717. } else if (i == 3) {
  3718. int i_785_ = (i_772_ & 0xff) * 4;
  3719. int i_786_ = (i_772_ >> 8 & 0xff) * 4;
  3720. int i_787_ = (i_772_ >> 16 & 0xff) << 6;
  3721. int i_788_ = (i_772_ >> 24 & 0xff) << 6;
  3722. if (i_774_ - (i_785_ >> 1) < 0 || i_774_ + (i_785_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6287 * -506105871 << class_xa.anInt6289 * -2137349879 || i_776_ - (i_786_ >> 1) < 0 || i_776_ + (i_786_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6286 * -1148794921 << class_xa.anInt6289 * -2137349879) {
  3723. return;
  3724. }
  3725. method4732(class_xa, i_774_, i_775_, i_776_, i_785_, i_786_, i_787_, i_788_);
  3726. } else if (i == 4) {
  3727. int i_789_ = anInt7939 - anInt7938;
  3728. for (int i_790_ = 0; i_790_ < anInt7900; i_790_++) {
  3729. vertices_y[i_790_] = vertices_y[i_790_] + class_xa_773_.method6340(vertices_x[i_790_] + i_774_, vertices_z[i_790_] + i_776_, -1820526862) - i_775_ + i_789_;
  3730. }
  3731. } else if (i == 5) {
  3732. int i_791_ = anInt7939 - anInt7938;
  3733. for (int i_792_ = 0; i_792_ < anInt7900; i_792_++) {
  3734. int i_793_ = vertices_x[i_792_] + i_774_;
  3735. int i_794_ = vertices_z[i_792_] + i_776_;
  3736. int i_795_ = class_xa.method6340(i_793_, i_794_, -1985664825);
  3737. int i_796_ = class_xa_773_.method6340(i_793_, i_794_, -1789819114);
  3738. int i_797_ = i_795_ - i_796_ - i_772_;
  3739. vertices_y[i_792_] = ((vertices_y[i_792_] << 8) / i_791_ * i_797_ >> 8) - (i_775_ - i_795_);
  3740. }
  3741. }
  3742. method4851();
  3743. aBoolean7950 = false;
  3744. }
  3745. }
  3746.  
  3747. @Override
  3748. public void bs(int i, int i_798_, Class_xa class_xa, Class_xa class_xa_799_, int i_800_, int i_801_, int i_802_) {
  3749. if (!aBoolean7950) {
  3750. method4832();
  3751. }
  3752. int i_803_ = i_800_ + anInt7940;
  3753. int i_804_ = i_800_ + anInt7941;
  3754. int i_805_ = i_802_ + anInt7942;
  3755. int i_806_ = i_802_ + anInt7943;
  3756. if (i != 1 && i != 2 && i != 3 && i != 5 || i_803_ >= 0 && i_804_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6287 * -506105871 && i_805_ >= 0 && i_806_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6286 * -1148794921) {
  3757. if (i == 4 || i == 5) {
  3758. if (class_xa_799_ == null || i_803_ < 0 || i_804_ + class_xa_799_.anInt6288 * -1212653763 >> class_xa_799_.anInt6289 * -2137349879 >= class_xa_799_.anInt6287 * -506105871 || i_805_ < 0 || i_806_ + class_xa_799_.anInt6288 * -1212653763 >> class_xa_799_.anInt6289 * -2137349879 >= class_xa_799_.anInt6286 * -1148794921) {
  3759. return;
  3760. }
  3761. } else {
  3762. i_803_ >>= class_xa.anInt6289 * -2137349879;
  3763. i_804_ = i_804_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  3764. i_805_ >>= class_xa.anInt6289 * -2137349879;
  3765. i_806_ = i_806_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  3766. if (class_xa.method6341(i_803_, i_805_, (byte) -36) == i_801_ && class_xa.method6341(i_804_, i_805_, (byte) -5) == i_801_ && class_xa.method6341(i_803_, i_806_, (byte) -59) == i_801_ && class_xa.method6341(i_804_, i_806_, (byte) -77) == i_801_) {
  3767. return;
  3768. }
  3769. }
  3770. if (i == 1) {
  3771. for (int i_807_ = 0; i_807_ < anInt7900; i_807_++) {
  3772. vertices_y[i_807_] = vertices_y[i_807_] + class_xa.method6340(vertices_x[i_807_] + i_800_, vertices_z[i_807_] + i_802_, -1988396086) - i_801_;
  3773. }
  3774. } else if (i == 2) {
  3775. int i_808_ = anInt7938;
  3776. if (i_808_ == 0) {
  3777. return;
  3778. }
  3779. for (int i_809_ = 0; i_809_ < anInt7900; i_809_++) {
  3780. int i_810_ = (vertices_y[i_809_] << 16) / i_808_;
  3781. if (i_810_ < i_798_) {
  3782. vertices_y[i_809_] = vertices_y[i_809_] + (class_xa.method6340(vertices_x[i_809_] + i_800_, vertices_z[i_809_] + i_802_, -1806752452) - i_801_) * (i_798_ - i_810_) / i_798_;
  3783. }
  3784. }
  3785. } else if (i == 3) {
  3786. int i_811_ = (i_798_ & 0xff) * 4;
  3787. int i_812_ = (i_798_ >> 8 & 0xff) * 4;
  3788. int i_813_ = (i_798_ >> 16 & 0xff) << 6;
  3789. int i_814_ = (i_798_ >> 24 & 0xff) << 6;
  3790. if (i_800_ - (i_811_ >> 1) < 0 || i_800_ + (i_811_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6287 * -506105871 << class_xa.anInt6289 * -2137349879 || i_802_ - (i_812_ >> 1) < 0 || i_802_ + (i_812_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6286 * -1148794921 << class_xa.anInt6289 * -2137349879) {
  3791. return;
  3792. }
  3793. method4732(class_xa, i_800_, i_801_, i_802_, i_811_, i_812_, i_813_, i_814_);
  3794. } else if (i == 4) {
  3795. int i_815_ = anInt7939 - anInt7938;
  3796. for (int i_816_ = 0; i_816_ < anInt7900; i_816_++) {
  3797. vertices_y[i_816_] = vertices_y[i_816_] + class_xa_799_.method6340(vertices_x[i_816_] + i_800_, vertices_z[i_816_] + i_802_, -1399719361) - i_801_ + i_815_;
  3798. }
  3799. } else if (i == 5) {
  3800. int i_817_ = anInt7939 - anInt7938;
  3801. for (int i_818_ = 0; i_818_ < anInt7900; i_818_++) {
  3802. int i_819_ = vertices_x[i_818_] + i_800_;
  3803. int i_820_ = vertices_z[i_818_] + i_802_;
  3804. int i_821_ = class_xa.method6340(i_819_, i_820_, -1686264500);
  3805. int i_822_ = class_xa_799_.method6340(i_819_, i_820_, -1996725293);
  3806. int i_823_ = i_821_ - i_822_ - i_798_;
  3807. vertices_y[i_818_] = ((vertices_y[i_818_] << 8) / i_817_ * i_823_ >> 8) - (i_801_ - i_821_);
  3808. }
  3809. }
  3810. method4851();
  3811. aBoolean7950 = false;
  3812. }
  3813. }
  3814.  
  3815. @Override
  3816. public void bp(int i, int i_824_, Class_xa class_xa, Class_xa class_xa_825_, int i_826_, int i_827_, int i_828_) {
  3817. if (!aBoolean7950) {
  3818. method4832();
  3819. }
  3820. int i_829_ = i_826_ + anInt7940;
  3821. int i_830_ = i_826_ + anInt7941;
  3822. int i_831_ = i_828_ + anInt7942;
  3823. int i_832_ = i_828_ + anInt7943;
  3824. if (i != 1 && i != 2 && i != 3 && i != 5 || i_829_ >= 0 && i_830_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6287 * -506105871 && i_831_ >= 0 && i_832_ + class_xa.anInt6288 * -1212653763 >> class_xa.anInt6289 * -2137349879 < class_xa.anInt6286 * -1148794921) {
  3825. if (i == 4 || i == 5) {
  3826. if (class_xa_825_ == null || i_829_ < 0 || i_830_ + class_xa_825_.anInt6288 * -1212653763 >> class_xa_825_.anInt6289 * -2137349879 >= class_xa_825_.anInt6287 * -506105871 || i_831_ < 0 || i_832_ + class_xa_825_.anInt6288 * -1212653763 >> class_xa_825_.anInt6289 * -2137349879 >= class_xa_825_.anInt6286 * -1148794921) {
  3827. return;
  3828. }
  3829. } else {
  3830. i_829_ >>= class_xa.anInt6289 * -2137349879;
  3831. i_830_ = i_830_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  3832. i_831_ >>= class_xa.anInt6289 * -2137349879;
  3833. i_832_ = i_832_ + class_xa.anInt6288 * -1212653763 - 1 >> class_xa.anInt6289 * -2137349879;
  3834. if (class_xa.method6341(i_829_, i_831_, (byte) -79) == i_827_ && class_xa.method6341(i_830_, i_831_, (byte) -15) == i_827_ && class_xa.method6341(i_829_, i_832_, (byte) -63) == i_827_ && class_xa.method6341(i_830_, i_832_, (byte) -127) == i_827_) {
  3835. return;
  3836. }
  3837. }
  3838. if (i == 1) {
  3839. for (int i_833_ = 0; i_833_ < anInt7900; i_833_++) {
  3840. vertices_y[i_833_] = vertices_y[i_833_] + class_xa.method6340(vertices_x[i_833_] + i_826_, vertices_z[i_833_] + i_828_, -1754503253) - i_827_;
  3841. }
  3842. } else if (i == 2) {
  3843. int i_834_ = anInt7938;
  3844. if (i_834_ == 0) {
  3845. return;
  3846. }
  3847. for (int i_835_ = 0; i_835_ < anInt7900; i_835_++) {
  3848. int i_836_ = (vertices_y[i_835_] << 16) / i_834_;
  3849. if (i_836_ < i_824_) {
  3850. vertices_y[i_835_] = vertices_y[i_835_] + (class_xa.method6340(vertices_x[i_835_] + i_826_, vertices_z[i_835_] + i_828_, -2096719300) - i_827_) * (i_824_ - i_836_) / i_824_;
  3851. }
  3852. }
  3853. } else if (i == 3) {
  3854. int i_837_ = (i_824_ & 0xff) * 4;
  3855. int i_838_ = (i_824_ >> 8 & 0xff) * 4;
  3856. int i_839_ = (i_824_ >> 16 & 0xff) << 6;
  3857. int i_840_ = (i_824_ >> 24 & 0xff) << 6;
  3858. if (i_826_ - (i_837_ >> 1) < 0 || i_826_ + (i_837_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6287 * -506105871 << class_xa.anInt6289 * -2137349879 || i_828_ - (i_838_ >> 1) < 0 || i_828_ + (i_838_ >> 1) + class_xa.anInt6288 * -1212653763 >= class_xa.anInt6286 * -1148794921 << class_xa.anInt6289 * -2137349879) {
  3859. return;
  3860. }
  3861. method4732(class_xa, i_826_, i_827_, i_828_, i_837_, i_838_, i_839_, i_840_);
  3862. } else if (i == 4) {
  3863. int i_841_ = anInt7939 - anInt7938;
  3864. for (int i_842_ = 0; i_842_ < anInt7900; i_842_++) {
  3865. vertices_y[i_842_] = vertices_y[i_842_] + class_xa_825_.method6340(vertices_x[i_842_] + i_826_, vertices_z[i_842_] + i_828_, -1750305937) - i_827_ + i_841_;
  3866. }
  3867. } else if (i == 5) {
  3868. int i_843_ = anInt7939 - anInt7938;
  3869. for (int i_844_ = 0; i_844_ < anInt7900; i_844_++) {
  3870. int i_845_ = vertices_x[i_844_] + i_826_;
  3871. int i_846_ = vertices_z[i_844_] + i_828_;
  3872. int i_847_ = class_xa.method6340(i_845_, i_846_, -1782278244);
  3873. int i_848_ = class_xa_825_.method6340(i_845_, i_846_, -1287457378);
  3874. int i_849_ = i_847_ - i_848_ - i_824_;
  3875. vertices_y[i_844_] = ((vertices_y[i_844_] << 8) / i_843_ * i_849_ >> 8) - (i_827_ - i_847_);
  3876. }
  3877. }
  3878. method4851();
  3879. aBoolean7950 = false;
  3880. }
  3881. }
  3882.  
  3883. @Override
  3884. void method4754() {
  3885. /* empty */
  3886. }
  3887.  
  3888. @Override
  3889. void method4757() {
  3890. /* empty */
  3891. }
  3892.  
  3893. @Override
  3894. void method4756() {
  3895. /* empty */
  3896. }
  3897.  
  3898. @Override
  3899. void method4758() {
  3900. /* empty */
  3901. }
  3902.  
  3903. @Override
  3904. boolean bt() {
  3905. if (verticesByLabel == null) {
  3906. return false;
  3907. }
  3908. for (int i = 0; i < anInt7899; i++) {
  3909. vertices_x[i] <<= 4;
  3910. vertices_y[i] <<= 4;
  3911. vertices_z[i] <<= 4;
  3912. }
  3913. origin_x = 0;
  3914. origin_y = 0;
  3915. origin_z = 0;
  3916. return true;
  3917. }
  3918.  
  3919. @Override
  3920. void br() {
  3921. for (int i = 0; i < anInt7899; i++) {
  3922. vertices_x[i] = vertices_x[i] + 7 >> 4;
  3923. vertices_y[i] = vertices_y[i] + 7 >> 4;
  3924. vertices_z[i] = vertices_z[i] + 7 >> 4;
  3925. }
  3926. method4851();
  3927. aBoolean7950 = false;
  3928. }
  3929.  
  3930. @Override
  3931. void bz() {
  3932. for (int i = 0; i < anInt7899; i++) {
  3933. vertices_x[i] = vertices_x[i] + 7 >> 4;
  3934. vertices_y[i] = vertices_y[i] + 7 >> 4;
  3935. vertices_z[i] = vertices_z[i] + 7 >> 4;
  3936. }
  3937. method4851();
  3938. aBoolean7950 = false;
  3939. }
  3940.  
  3941. @Override
  3942. void cm() {
  3943. for (int i = 0; i < anInt7899; i++) {
  3944. vertices_x[i] = vertices_x[i] + 7 >> 4;
  3945. vertices_y[i] = vertices_y[i] + 7 >> 4;
  3946. vertices_z[i] = vertices_z[i] + 7 >> 4;
  3947. }
  3948. method4851();
  3949. aBoolean7950 = false;
  3950. }
  3951.  
  3952. @Override
  3953. void cd() {
  3954. for (int i = 0; i < anInt7899; i++) {
  3955. vertices_x[i] = vertices_x[i] + 7 >> 4;
  3956. vertices_y[i] = vertices_y[i] + 7 >> 4;
  3957. vertices_z[i] = vertices_z[i] + 7 >> 4;
  3958. }
  3959. method4851();
  3960. aBoolean7950 = false;
  3961. }
  3962.  
  3963. @Override
  3964. void method4760(int i, int[] is, int i_850_, int i_851_, int i_852_, int i_853_, boolean bool) {
  3965. int i_854_ = is.length;
  3966. if (i == 0) {
  3967. i_850_ <<= 4;
  3968. i_851_ <<= 4;
  3969. i_852_ <<= 4;
  3970. int i_855_ = 0;
  3971. origin_x = 0;
  3972. origin_y = 0;
  3973. origin_z = 0;
  3974. for (int i_856_ = 0; i_856_ < i_854_; i_856_++) {
  3975. int i_857_ = is[i_856_];
  3976. if (i_857_ < verticesByLabel.length) {
  3977. int[] is_858_ = verticesByLabel[i_857_];
  3978. for (int i_860_ : is_858_) {
  3979. origin_x += vertices_x[i_860_];
  3980. origin_y += vertices_y[i_860_];
  3981. origin_z += vertices_z[i_860_];
  3982. i_855_++;
  3983. }
  3984. }
  3985. }
  3986. if (i_855_ > 0) {
  3987. origin_x = origin_x / i_855_ + i_850_;
  3988. origin_y = origin_y / i_855_ + i_851_;
  3989. origin_z = origin_z / i_855_ + i_852_;
  3990. } else {
  3991. origin_x = i_850_;
  3992. origin_y = i_851_;
  3993. origin_z = i_852_;
  3994. }
  3995. } else if (i == 1) {
  3996. i_850_ <<= 4;
  3997. i_851_ <<= 4;
  3998. i_852_ <<= 4;
  3999. for (int i_861_ = 0; i_861_ < i_854_; i_861_++) {
  4000. int i_862_ = is[i_861_];
  4001. if (i_862_ < verticesByLabel.length) {
  4002. int[] is_863_ = verticesByLabel[i_862_];
  4003. for (int element : is_863_) {
  4004. int i_865_ = element;
  4005. vertices_x[i_865_] += i_850_;
  4006. vertices_y[i_865_] += i_851_;
  4007. vertices_z[i_865_] += i_852_;
  4008. }
  4009. }
  4010. }
  4011. } else if (i == 2) {
  4012. for (int i_866_ = 0; i_866_ < i_854_; i_866_++) {
  4013. int i_867_ = is[i_866_];
  4014. if (i_867_ < verticesByLabel.length) {
  4015. int[] is_868_ = verticesByLabel[i_867_];
  4016. if ((i_853_ & 0x1) == 0) {
  4017. for (int element : is_868_) {
  4018. int i_870_ = element;
  4019. vertices_x[i_870_] -= origin_x;
  4020. vertices_y[i_870_] -= origin_y;
  4021. vertices_z[i_870_] -= origin_z;
  4022. if (i_852_ != 0) {
  4023. int i_871_ = Class220.anIntArray2483[i_852_];
  4024. int i_872_ = Class220.anIntArray2474[i_852_];
  4025. int i_873_ = vertices_y[i_870_] * i_871_ + vertices_x[i_870_] * i_872_ + 16383 >> 14;
  4026. vertices_y[i_870_] = vertices_y[i_870_] * i_872_ - vertices_x[i_870_] * i_871_ + 16383 >> 14;
  4027. vertices_x[i_870_] = i_873_;
  4028. }
  4029. if (i_850_ != 0) {
  4030. int i_874_ = Class220.anIntArray2483[i_850_];
  4031. int i_875_ = Class220.anIntArray2474[i_850_];
  4032. int i_876_ = vertices_y[i_870_] * i_875_ - vertices_z[i_870_] * i_874_ + 16383 >> 14;
  4033. vertices_z[i_870_] = vertices_y[i_870_] * i_874_ + vertices_z[i_870_] * i_875_ + 16383 >> 14;
  4034. vertices_y[i_870_] = i_876_;
  4035. }
  4036. if (i_851_ != 0) {
  4037. int i_877_ = Class220.anIntArray2483[i_851_];
  4038. int i_878_ = Class220.anIntArray2474[i_851_];
  4039. int i_879_ = vertices_z[i_870_] * i_877_ + vertices_x[i_870_] * i_878_ + 16383 >> 14;
  4040. vertices_z[i_870_] = vertices_z[i_870_] * i_878_ - vertices_x[i_870_] * i_877_ + 16383 >> 14;
  4041. vertices_x[i_870_] = i_879_;
  4042. }
  4043. vertices_x[i_870_] += origin_x;
  4044. vertices_y[i_870_] += origin_y;
  4045. vertices_z[i_870_] += origin_z;
  4046. }
  4047. } else {
  4048. for (int element : is_868_) {
  4049. int i_881_ = element;
  4050. vertices_x[i_881_] -= origin_x;
  4051. vertices_y[i_881_] -= origin_y;
  4052. vertices_z[i_881_] -= origin_z;
  4053. if (i_850_ != 0) {
  4054. int i_882_ = Class220.anIntArray2483[i_850_];
  4055. int i_883_ = Class220.anIntArray2474[i_850_];
  4056. int i_884_ = vertices_y[i_881_] * i_883_ - vertices_z[i_881_] * i_882_ + 16383 >> 14;
  4057. vertices_z[i_881_] = vertices_y[i_881_] * i_882_ + vertices_z[i_881_] * i_883_ + 16383 >> 14;
  4058. vertices_y[i_881_] = i_884_;
  4059. }
  4060. if (i_852_ != 0) {
  4061. int i_885_ = Class220.anIntArray2483[i_852_];
  4062. int i_886_ = Class220.anIntArray2474[i_852_];
  4063. int i_887_ = vertices_y[i_881_] * i_885_ + vertices_x[i_881_] * i_886_ + 16383 >> 14;
  4064. vertices_y[i_881_] = vertices_y[i_881_] * i_886_ - vertices_x[i_881_] * i_885_ + 16383 >> 14;
  4065. vertices_x[i_881_] = i_887_;
  4066. }
  4067. if (i_851_ != 0) {
  4068. int i_888_ = Class220.anIntArray2483[i_851_];
  4069. int i_889_ = Class220.anIntArray2474[i_851_];
  4070. int i_890_ = vertices_z[i_881_] * i_888_ + vertices_x[i_881_] * i_889_ + 16383 >> 14;
  4071. vertices_z[i_881_] = vertices_z[i_881_] * i_889_ - vertices_x[i_881_] * i_888_ + 16383 >> 14;
  4072. vertices_x[i_881_] = i_890_;
  4073. }
  4074. vertices_x[i_881_] += origin_x;
  4075. vertices_y[i_881_] += origin_y;
  4076. vertices_z[i_881_] += origin_z;
  4077. }
  4078. }
  4079. }
  4080. }
  4081. if (bool) {
  4082. for (int i_891_ = 0; i_891_ < i_854_; i_891_++) {
  4083. int i_892_ = is[i_891_];
  4084. if (i_892_ < verticesByLabel.length) {
  4085. int[] is_893_ = verticesByLabel[i_892_];
  4086. for (int i_895_ : is_893_) {
  4087. int i_896_ = anIntArray7947[i_895_];
  4088. int i_897_ = anIntArray7947[i_895_ + 1];
  4089. for (int i_898_ = i_896_; i_898_ < i_897_; i_898_++) {
  4090. int i_899_ = aShortArray7948[i_898_] - 1;
  4091. if (i_899_ == -1) {
  4092. break;
  4093. }
  4094. if (i_852_ != 0) {
  4095. int i_900_ = Class220.anIntArray2483[i_852_];
  4096. int i_901_ = Class220.anIntArray2474[i_852_];
  4097. int i_902_ = aShortArray7910[i_899_] * i_900_ + aShortArray7909[i_899_] * i_901_ + 16383 >> 14;
  4098. aShortArray7910[i_899_] = (short) (aShortArray7910[i_899_] * i_901_ - aShortArray7909[i_899_] * i_900_ + 16383 >> 14);
  4099. aShortArray7909[i_899_] = (short) i_902_;
  4100. }
  4101. if (i_850_ != 0) {
  4102. int i_903_ = Class220.anIntArray2483[i_850_];
  4103. int i_904_ = Class220.anIntArray2474[i_850_];
  4104. int i_905_ = aShortArray7910[i_899_] * i_904_ - aShortArray7919[i_899_] * i_903_ + 16383 >> 14;
  4105. aShortArray7919[i_899_] = (short) (aShortArray7910[i_899_] * i_903_ + aShortArray7919[i_899_] * i_904_ + 16383 >> 14);
  4106. aShortArray7910[i_899_] = (short) i_905_;
  4107. }
  4108. if (i_851_ != 0) {
  4109. int i_906_ = Class220.anIntArray2483[i_851_];
  4110. int i_907_ = Class220.anIntArray2474[i_851_];
  4111. int i_908_ = aShortArray7919[i_899_] * i_906_ + aShortArray7909[i_899_] * i_907_ + 16383 >> 14;
  4112. aShortArray7919[i_899_] = (short) (aShortArray7919[i_899_] * i_907_ - aShortArray7909[i_899_] * i_906_ + 16383 >> 14);
  4113. aShortArray7909[i_899_] = (short) i_908_;
  4114. }
  4115. }
  4116. }
  4117. }
  4118. }
  4119. method4839();
  4120. }
  4121. } else if (i == 3) {
  4122. for (int i_909_ = 0; i_909_ < i_854_; i_909_++) {
  4123. int i_910_ = is[i_909_];
  4124. if (i_910_ < verticesByLabel.length) {
  4125. int[] is_911_ = verticesByLabel[i_910_];
  4126. for (int element : is_911_) {
  4127. int i_913_ = element;
  4128. vertices_x[i_913_] -= origin_x;
  4129. vertices_y[i_913_] -= origin_y;
  4130. vertices_z[i_913_] -= origin_z;
  4131. vertices_x[i_913_] = vertices_x[i_913_] * i_850_ >> 7;
  4132. vertices_y[i_913_] = vertices_y[i_913_] * i_851_ >> 7;
  4133. vertices_z[i_913_] = vertices_z[i_913_] * i_852_ >> 7;
  4134. vertices_x[i_913_] += origin_x;
  4135. vertices_y[i_913_] += origin_y;
  4136. vertices_z[i_913_] += origin_z;
  4137. }
  4138. }
  4139. }
  4140. } else if (i == 5) {
  4141. if (anIntArrayArray7924 != null) {
  4142. boolean bool_914_ = false;
  4143. for (int i_915_ = 0; i_915_ < i_854_; i_915_++) {
  4144. int i_916_ = is[i_915_];
  4145. if (i_916_ < anIntArrayArray7924.length) {
  4146. int[] is_917_ = anIntArrayArray7924[i_916_];
  4147. for (int element : is_917_) {
  4148. int i_919_ = element;
  4149. int i_920_ = (aByteArray7963[i_919_] & 0xff) + i_850_ * 8;
  4150. if (i_920_ < 0) {
  4151. i_920_ = 0;
  4152. } else if (i_920_ > 255) {
  4153. i_920_ = 255;
  4154. }
  4155. aByteArray7963[i_919_] = (byte) i_920_;
  4156. }
  4157. bool_914_ = bool_914_ | is_917_.length > 0;
  4158. }
  4159. }
  4160. if (bool_914_) {
  4161. if (aClass191Array7952 != null) {
  4162. for (int i_921_ = 0; i_921_ < anInt7951; i_921_++) {
  4163. Class191 class191 = aClass191Array7952[i_921_];
  4164. Class166 class166 = aClass166Array7892[i_921_];
  4165. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  4166. }
  4167. }
  4168. method4838();
  4169. }
  4170. }
  4171. } else if (i == 7) {
  4172. if (anIntArrayArray7924 != null) {
  4173. boolean bool_922_ = false;
  4174. for (int i_923_ = 0; i_923_ < i_854_; i_923_++) {
  4175. int i_924_ = is[i_923_];
  4176. if (i_924_ < anIntArrayArray7924.length) {
  4177. int[] is_925_ = anIntArrayArray7924[i_924_];
  4178. for (int element : is_925_) {
  4179. int i_927_ = element;
  4180. int i_928_ = aShortArray7935[i_927_] & 0xffff;
  4181. int i_929_ = i_928_ >> 10 & 0x3f;
  4182. int i_930_ = i_928_ >> 7 & 0x7;
  4183. int i_931_ = i_928_ & 0x7f;
  4184. i_929_ = i_929_ + i_850_ & 0x3f;
  4185. i_930_ += i_851_ / 4;
  4186. if (i_930_ < 0) {
  4187. i_930_ = 0;
  4188. } else if (i_930_ > 7) {
  4189. i_930_ = 7;
  4190. }
  4191. i_931_ += i_852_;
  4192. if (i_931_ < 0) {
  4193. i_931_ = 0;
  4194. } else if (i_931_ > 127) {
  4195. i_931_ = 127;
  4196. }
  4197. aShortArray7935[i_927_] = (short) (i_929_ << 10 | i_930_ << 7 | i_931_);
  4198. }
  4199. bool_922_ = bool_922_ | is_925_.length > 0;
  4200. }
  4201. }
  4202. if (bool_922_) {
  4203. if (aClass191Array7952 != null) {
  4204. for (int i_932_ = 0; i_932_ < anInt7951; i_932_++) {
  4205. Class191 class191 = aClass191Array7952[i_932_];
  4206. Class166 class166 = aClass166Array7892[i_932_];
  4207. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  4208. }
  4209. }
  4210. method4838();
  4211. }
  4212. }
  4213. } else if (i == 8) {
  4214. if (anIntArrayArray7946 != null) {
  4215. for (int i_933_ = 0; i_933_ < i_854_; i_933_++) {
  4216. int i_934_ = is[i_933_];
  4217. if (i_934_ < anIntArrayArray7946.length) {
  4218. int[] is_935_ = anIntArrayArray7946[i_934_];
  4219. for (int element : is_935_) {
  4220. Class166 class166 = aClass166Array7892[element];
  4221. class166.anInt1704 += i_850_;
  4222. class166.anInt1705 += i_851_;
  4223. }
  4224. }
  4225. }
  4226. }
  4227. } else if (i == 10) {
  4228. if (anIntArrayArray7946 != null) {
  4229. for (int i_937_ = 0; i_937_ < i_854_; i_937_++) {
  4230. int i_938_ = is[i_937_];
  4231. if (i_938_ < anIntArrayArray7946.length) {
  4232. int[] is_939_ = anIntArrayArray7946[i_938_];
  4233. for (int element : is_939_) {
  4234. Class166 class166 = aClass166Array7892[element];
  4235. class166.anInt1702 = class166.anInt1702 * i_850_ >> 7;
  4236. class166.anInt1701 = class166.anInt1701 * i_851_ >> 7;
  4237. }
  4238. }
  4239. }
  4240. }
  4241. } else if (i == 9) {
  4242. if (anIntArrayArray7946 != null) {
  4243. for (int i_941_ = 0; i_941_ < i_854_; i_941_++) {
  4244. int i_942_ = is[i_941_];
  4245. if (i_942_ < anIntArrayArray7946.length) {
  4246. int[] is_943_ = anIntArrayArray7946[i_942_];
  4247. for (int element : is_943_) {
  4248. Class166 class166 = aClass166Array7892[element];
  4249. class166.anInt1706 = class166.anInt1706 + i_850_ & 0x3fff;
  4250. }
  4251. }
  4252. }
  4253. }
  4254. }
  4255. }
  4256.  
  4257. @Override
  4258. void method4761(int i, int[] is, int i_945_, int i_946_, int i_947_, int i_948_, boolean bool) {
  4259. int i_949_ = is.length;
  4260. if (i == 0) {
  4261. i_945_ <<= 4;
  4262. i_946_ <<= 4;
  4263. i_947_ <<= 4;
  4264. int i_950_ = 0;
  4265. origin_x = 0;
  4266. origin_y = 0;
  4267. origin_z = 0;
  4268. for (int i_951_ = 0; i_951_ < i_949_; i_951_++) {
  4269. int i_952_ = is[i_951_];
  4270. if (i_952_ < verticesByLabel.length) {
  4271. int[] is_953_ = verticesByLabel[i_952_];
  4272. for (int i_955_ : is_953_) {
  4273. origin_x += vertices_x[i_955_];
  4274. origin_y += vertices_y[i_955_];
  4275. origin_z += vertices_z[i_955_];
  4276. i_950_++;
  4277. }
  4278. }
  4279. }
  4280. if (i_950_ > 0) {
  4281. origin_x = origin_x / i_950_ + i_945_;
  4282. origin_y = origin_y / i_950_ + i_946_;
  4283. origin_z = origin_z / i_950_ + i_947_;
  4284. } else {
  4285. origin_x = i_945_;
  4286. origin_y = i_946_;
  4287. origin_z = i_947_;
  4288. }
  4289. } else if (i == 1) {
  4290. i_945_ <<= 4;
  4291. i_946_ <<= 4;
  4292. i_947_ <<= 4;
  4293. for (int i_956_ = 0; i_956_ < i_949_; i_956_++) {
  4294. int i_957_ = is[i_956_];
  4295. if (i_957_ < verticesByLabel.length) {
  4296. int[] is_958_ = verticesByLabel[i_957_];
  4297. for (int element : is_958_) {
  4298. int i_960_ = element;
  4299. vertices_x[i_960_] += i_945_;
  4300. vertices_y[i_960_] += i_946_;
  4301. vertices_z[i_960_] += i_947_;
  4302. }
  4303. }
  4304. }
  4305. } else if (i == 2) {
  4306. for (int i_961_ = 0; i_961_ < i_949_; i_961_++) {
  4307. int i_962_ = is[i_961_];
  4308. if (i_962_ < verticesByLabel.length) {
  4309. int[] is_963_ = verticesByLabel[i_962_];
  4310. if ((i_948_ & 0x1) == 0) {
  4311. for (int element : is_963_) {
  4312. int i_965_ = element;
  4313. vertices_x[i_965_] -= origin_x;
  4314. vertices_y[i_965_] -= origin_y;
  4315. vertices_z[i_965_] -= origin_z;
  4316. if (i_947_ != 0) {
  4317. int i_966_ = Class220.anIntArray2483[i_947_];
  4318. int i_967_ = Class220.anIntArray2474[i_947_];
  4319. int i_968_ = vertices_y[i_965_] * i_966_ + vertices_x[i_965_] * i_967_ + 16383 >> 14;
  4320. vertices_y[i_965_] = vertices_y[i_965_] * i_967_ - vertices_x[i_965_] * i_966_ + 16383 >> 14;
  4321. vertices_x[i_965_] = i_968_;
  4322. }
  4323. if (i_945_ != 0) {
  4324. int i_969_ = Class220.anIntArray2483[i_945_];
  4325. int i_970_ = Class220.anIntArray2474[i_945_];
  4326. int i_971_ = vertices_y[i_965_] * i_970_ - vertices_z[i_965_] * i_969_ + 16383 >> 14;
  4327. vertices_z[i_965_] = vertices_y[i_965_] * i_969_ + vertices_z[i_965_] * i_970_ + 16383 >> 14;
  4328. vertices_y[i_965_] = i_971_;
  4329. }
  4330. if (i_946_ != 0) {
  4331. int i_972_ = Class220.anIntArray2483[i_946_];
  4332. int i_973_ = Class220.anIntArray2474[i_946_];
  4333. int i_974_ = vertices_z[i_965_] * i_972_ + vertices_x[i_965_] * i_973_ + 16383 >> 14;
  4334. vertices_z[i_965_] = vertices_z[i_965_] * i_973_ - vertices_x[i_965_] * i_972_ + 16383 >> 14;
  4335. vertices_x[i_965_] = i_974_;
  4336. }
  4337. vertices_x[i_965_] += origin_x;
  4338. vertices_y[i_965_] += origin_y;
  4339. vertices_z[i_965_] += origin_z;
  4340. }
  4341. } else {
  4342. for (int element : is_963_) {
  4343. int i_976_ = element;
  4344. vertices_x[i_976_] -= origin_x;
  4345. vertices_y[i_976_] -= origin_y;
  4346. vertices_z[i_976_] -= origin_z;
  4347. if (i_945_ != 0) {
  4348. int i_977_ = Class220.anIntArray2483[i_945_];
  4349. int i_978_ = Class220.anIntArray2474[i_945_];
  4350. int i_979_ = vertices_y[i_976_] * i_978_ - vertices_z[i_976_] * i_977_ + 16383 >> 14;
  4351. vertices_z[i_976_] = vertices_y[i_976_] * i_977_ + vertices_z[i_976_] * i_978_ + 16383 >> 14;
  4352. vertices_y[i_976_] = i_979_;
  4353. }
  4354. if (i_947_ != 0) {
  4355. int i_980_ = Class220.anIntArray2483[i_947_];
  4356. int i_981_ = Class220.anIntArray2474[i_947_];
  4357. int i_982_ = vertices_y[i_976_] * i_980_ + vertices_x[i_976_] * i_981_ + 16383 >> 14;
  4358. vertices_y[i_976_] = vertices_y[i_976_] * i_981_ - vertices_x[i_976_] * i_980_ + 16383 >> 14;
  4359. vertices_x[i_976_] = i_982_;
  4360. }
  4361. if (i_946_ != 0) {
  4362. int i_983_ = Class220.anIntArray2483[i_946_];
  4363. int i_984_ = Class220.anIntArray2474[i_946_];
  4364. int i_985_ = vertices_z[i_976_] * i_983_ + vertices_x[i_976_] * i_984_ + 16383 >> 14;
  4365. vertices_z[i_976_] = vertices_z[i_976_] * i_984_ - vertices_x[i_976_] * i_983_ + 16383 >> 14;
  4366. vertices_x[i_976_] = i_985_;
  4367. }
  4368. vertices_x[i_976_] += origin_x;
  4369. vertices_y[i_976_] += origin_y;
  4370. vertices_z[i_976_] += origin_z;
  4371. }
  4372. }
  4373. }
  4374. }
  4375. if (bool) {
  4376. for (int i_986_ = 0; i_986_ < i_949_; i_986_++) {
  4377. int i_987_ = is[i_986_];
  4378. if (i_987_ < verticesByLabel.length) {
  4379. int[] is_988_ = verticesByLabel[i_987_];
  4380. for (int i_990_ : is_988_) {
  4381. int i_991_ = anIntArray7947[i_990_];
  4382. int i_992_ = anIntArray7947[i_990_ + 1];
  4383. for (int i_993_ = i_991_; i_993_ < i_992_; i_993_++) {
  4384. int i_994_ = aShortArray7948[i_993_] - 1;
  4385. if (i_994_ == -1) {
  4386. break;
  4387. }
  4388. if (i_947_ != 0) {
  4389. int i_995_ = Class220.anIntArray2483[i_947_];
  4390. int i_996_ = Class220.anIntArray2474[i_947_];
  4391. int i_997_ = aShortArray7910[i_994_] * i_995_ + aShortArray7909[i_994_] * i_996_ + 16383 >> 14;
  4392. aShortArray7910[i_994_] = (short) (aShortArray7910[i_994_] * i_996_ - aShortArray7909[i_994_] * i_995_ + 16383 >> 14);
  4393. aShortArray7909[i_994_] = (short) i_997_;
  4394. }
  4395. if (i_945_ != 0) {
  4396. int i_998_ = Class220.anIntArray2483[i_945_];
  4397. int i_999_ = Class220.anIntArray2474[i_945_];
  4398. int i_1000_ = aShortArray7910[i_994_] * i_999_ - aShortArray7919[i_994_] * i_998_ + 16383 >> 14;
  4399. aShortArray7919[i_994_] = (short) (aShortArray7910[i_994_] * i_998_ + aShortArray7919[i_994_] * i_999_ + 16383 >> 14);
  4400. aShortArray7910[i_994_] = (short) i_1000_;
  4401. }
  4402. if (i_946_ != 0) {
  4403. int i_1001_ = Class220.anIntArray2483[i_946_];
  4404. int i_1002_ = Class220.anIntArray2474[i_946_];
  4405. int i_1003_ = aShortArray7919[i_994_] * i_1001_ + aShortArray7909[i_994_] * i_1002_ + 16383 >> 14;
  4406. aShortArray7919[i_994_] = (short) (aShortArray7919[i_994_] * i_1002_ - aShortArray7909[i_994_] * i_1001_ + 16383 >> 14);
  4407. aShortArray7909[i_994_] = (short) i_1003_;
  4408. }
  4409. }
  4410. }
  4411. }
  4412. }
  4413. method4839();
  4414. }
  4415. } else if (i == 3) {
  4416. for (int i_1004_ = 0; i_1004_ < i_949_; i_1004_++) {
  4417. int i_1005_ = is[i_1004_];
  4418. if (i_1005_ < verticesByLabel.length) {
  4419. int[] is_1006_ = verticesByLabel[i_1005_];
  4420. for (int element : is_1006_) {
  4421. int i_1008_ = element;
  4422. vertices_x[i_1008_] -= origin_x;
  4423. vertices_y[i_1008_] -= origin_y;
  4424. vertices_z[i_1008_] -= origin_z;
  4425. vertices_x[i_1008_] = vertices_x[i_1008_] * i_945_ >> 7;
  4426. vertices_y[i_1008_] = vertices_y[i_1008_] * i_946_ >> 7;
  4427. vertices_z[i_1008_] = vertices_z[i_1008_] * i_947_ >> 7;
  4428. vertices_x[i_1008_] += origin_x;
  4429. vertices_y[i_1008_] += origin_y;
  4430. vertices_z[i_1008_] += origin_z;
  4431. }
  4432. }
  4433. }
  4434. } else if (i == 5) {
  4435. if (anIntArrayArray7924 != null) {
  4436. boolean bool_1009_ = false;
  4437. for (int i_1010_ = 0; i_1010_ < i_949_; i_1010_++) {
  4438. int i_1011_ = is[i_1010_];
  4439. if (i_1011_ < anIntArrayArray7924.length) {
  4440. int[] is_1012_ = anIntArrayArray7924[i_1011_];
  4441. for (int element : is_1012_) {
  4442. int i_1014_ = element;
  4443. int i_1015_ = (aByteArray7963[i_1014_] & 0xff) + i_945_ * 8;
  4444. if (i_1015_ < 0) {
  4445. i_1015_ = 0;
  4446. } else if (i_1015_ > 255) {
  4447. i_1015_ = 255;
  4448. }
  4449. aByteArray7963[i_1014_] = (byte) i_1015_;
  4450. }
  4451. bool_1009_ = bool_1009_ | is_1012_.length > 0;
  4452. }
  4453. }
  4454. if (bool_1009_) {
  4455. if (aClass191Array7952 != null) {
  4456. for (int i_1016_ = 0; i_1016_ < anInt7951; i_1016_++) {
  4457. Class191 class191 = aClass191Array7952[i_1016_];
  4458. Class166 class166 = aClass166Array7892[i_1016_];
  4459. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  4460. }
  4461. }
  4462. method4838();
  4463. }
  4464. }
  4465. } else if (i == 7) {
  4466. if (anIntArrayArray7924 != null) {
  4467. boolean bool_1017_ = false;
  4468. for (int i_1018_ = 0; i_1018_ < i_949_; i_1018_++) {
  4469. int i_1019_ = is[i_1018_];
  4470. if (i_1019_ < anIntArrayArray7924.length) {
  4471. int[] is_1020_ = anIntArrayArray7924[i_1019_];
  4472. for (int element : is_1020_) {
  4473. int i_1022_ = element;
  4474. int i_1023_ = aShortArray7935[i_1022_] & 0xffff;
  4475. int i_1024_ = i_1023_ >> 10 & 0x3f;
  4476. int i_1025_ = i_1023_ >> 7 & 0x7;
  4477. int i_1026_ = i_1023_ & 0x7f;
  4478. i_1024_ = i_1024_ + i_945_ & 0x3f;
  4479. i_1025_ += i_946_ / 4;
  4480. if (i_1025_ < 0) {
  4481. i_1025_ = 0;
  4482. } else if (i_1025_ > 7) {
  4483. i_1025_ = 7;
  4484. }
  4485. i_1026_ += i_947_;
  4486. if (i_1026_ < 0) {
  4487. i_1026_ = 0;
  4488. } else if (i_1026_ > 127) {
  4489. i_1026_ = 127;
  4490. }
  4491. aShortArray7935[i_1022_] = (short) (i_1024_ << 10 | i_1025_ << 7 | i_1026_);
  4492. }
  4493. bool_1017_ = bool_1017_ | is_1020_.length > 0;
  4494. }
  4495. }
  4496. if (bool_1017_) {
  4497. if (aClass191Array7952 != null) {
  4498. for (int i_1027_ = 0; i_1027_ < anInt7951; i_1027_++) {
  4499. Class191 class191 = aClass191Array7952[i_1027_];
  4500. Class166 class166 = aClass166Array7892[i_1027_];
  4501. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  4502. }
  4503. }
  4504. method4838();
  4505. }
  4506. }
  4507. } else if (i == 8) {
  4508. if (anIntArrayArray7946 != null) {
  4509. for (int i_1028_ = 0; i_1028_ < i_949_; i_1028_++) {
  4510. int i_1029_ = is[i_1028_];
  4511. if (i_1029_ < anIntArrayArray7946.length) {
  4512. int[] is_1030_ = anIntArrayArray7946[i_1029_];
  4513. for (int element : is_1030_) {
  4514. Class166 class166 = aClass166Array7892[element];
  4515. class166.anInt1704 += i_945_;
  4516. class166.anInt1705 += i_946_;
  4517. }
  4518. }
  4519. }
  4520. }
  4521. } else if (i == 10) {
  4522. if (anIntArrayArray7946 != null) {
  4523. for (int i_1032_ = 0; i_1032_ < i_949_; i_1032_++) {
  4524. int i_1033_ = is[i_1032_];
  4525. if (i_1033_ < anIntArrayArray7946.length) {
  4526. int[] is_1034_ = anIntArrayArray7946[i_1033_];
  4527. for (int element : is_1034_) {
  4528. Class166 class166 = aClass166Array7892[element];
  4529. class166.anInt1702 = class166.anInt1702 * i_945_ >> 7;
  4530. class166.anInt1701 = class166.anInt1701 * i_946_ >> 7;
  4531. }
  4532. }
  4533. }
  4534. }
  4535. } else if (i == 9) {
  4536. if (anIntArrayArray7946 != null) {
  4537. for (int i_1036_ = 0; i_1036_ < i_949_; i_1036_++) {
  4538. int i_1037_ = is[i_1036_];
  4539. if (i_1037_ < anIntArrayArray7946.length) {
  4540. int[] is_1038_ = anIntArrayArray7946[i_1037_];
  4541. for (int element : is_1038_) {
  4542. Class166 class166 = aClass166Array7892[element];
  4543. class166.anInt1706 = class166.anInt1706 + i_945_ & 0x3fff;
  4544. }
  4545. }
  4546. }
  4547. }
  4548. }
  4549. }
  4550.  
  4551. @Override
  4552. public void method4751(Class222 class222) {
  4553. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8236;
  4554. class233.method2145(class222);
  4555. if (aClass85Array7949 != null) {
  4556. for (Class85 class85 : aClass85Array7949) {
  4557. Class85 class85_1040_ = class85;
  4558. if (class85.aClass85_776 != null) {
  4559. class85_1040_ = class85.aClass85_776;
  4560. }
  4561. class85_1040_.anInt777 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[4] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[8] * vertices_z[class85.anInt773 * -710317103])) * -1879868075;
  4562. class85_1040_.anInt783 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[5] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[9] * vertices_z[class85.anInt773 * -710317103])) * -2041556771;
  4563. class85_1040_.anInt779 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[6] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[10] * vertices_z[class85.anInt773 * -710317103])) * -1434499227;
  4564. class85_1040_.anInt772 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[4] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[8] * vertices_z[class85.anInt774 * 1705862021])) * 1070341177;
  4565. class85_1040_.anInt781 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[5] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[9] * vertices_z[class85.anInt774 * 1705862021])) * 1802851857;
  4566. class85_1040_.anInt782 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[6] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[10] * vertices_z[class85.anInt774 * 1705862021])) * 103846281;
  4567. class85_1040_.anInt771 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[4] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[8] * vertices_z[class85.anInt775 * 1636170731])) * -2103324039;
  4568. class85_1040_.anInt784 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[5] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[9] * vertices_z[class85.anInt775 * 1636170731])) * -526039059;
  4569. class85_1040_.anInt785 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[6] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[10] * vertices_z[class85.anInt775 * 1636170731])) * 491030489;
  4570. }
  4571. }
  4572. if (aClass68Array7904 != null) {
  4573. for (Class68 element : aClass68Array7904) {
  4574. Class68 class68 = element;
  4575. Class68 class68_1041_ = class68;
  4576. if (class68.aClass68_672 != null) {
  4577. class68_1041_ = class68.aClass68_672;
  4578. }
  4579. if (class68.aClass233_677 != null) {
  4580. class68.aClass233_677.method2142(class233);
  4581. } else {
  4582. class68.aClass233_677 = new Class233(class233);
  4583. }
  4584. class68_1041_.anInt671 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[4] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[8] * vertices_z[class68.anInt674 * -180596249])) * -1436341053;
  4585. class68_1041_.anInt675 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[5] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[9] * vertices_z[class68.anInt674 * -180596249])) * 449866009;
  4586. class68_1041_.anInt676 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[6] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[10] * vertices_z[class68.anInt674 * -180596249])) * 1336328763;
  4587. }
  4588. }
  4589. }
  4590.  
  4591. @Override
  4592. void cj(int i, int[] is, int i_1042_, int i_1043_, int i_1044_, boolean bool, int i_1045_, int[] is_1046_) {
  4593. int i_1047_ = is.length;
  4594. if (i == 0) {
  4595. i_1042_ <<= 4;
  4596. i_1043_ <<= 4;
  4597. i_1044_ <<= 4;
  4598. int i_1048_ = 0;
  4599. origin_x = 0;
  4600. origin_y = 0;
  4601. origin_z = 0;
  4602. for (int i_1049_ = 0; i_1049_ < i_1047_; i_1049_++) {
  4603. int i_1050_ = is[i_1049_];
  4604. if (i_1050_ < verticesByLabel.length) {
  4605. int[] is_1051_ = verticesByLabel[i_1050_];
  4606. for (int i_1053_ : is_1051_) {
  4607. if (aShortArray7964 == null || (i_1045_ & aShortArray7964[i_1053_]) != 0) {
  4608. origin_x += vertices_x[i_1053_];
  4609. origin_y += vertices_y[i_1053_];
  4610. origin_z += vertices_z[i_1053_];
  4611. i_1048_++;
  4612. }
  4613. }
  4614. }
  4615. }
  4616. if (i_1048_ > 0) {
  4617. origin_x = origin_x / i_1048_ + i_1042_;
  4618. origin_y = origin_y / i_1048_ + i_1043_;
  4619. origin_z = origin_z / i_1048_ + i_1044_;
  4620. aBoolean7905 = true;
  4621. } else {
  4622. origin_x = i_1042_;
  4623. origin_y = i_1043_;
  4624. origin_z = i_1044_;
  4625. }
  4626. } else if (i == 1) {
  4627. if (is_1046_ != null) {
  4628. int i_1054_ = is_1046_[0] * i_1042_ + is_1046_[1] * i_1043_ + is_1046_[2] * i_1044_ + 8192 >> 14;
  4629. int i_1055_ = is_1046_[3] * i_1042_ + is_1046_[4] * i_1043_ + is_1046_[5] * i_1044_ + 8192 >> 14;
  4630. int i_1056_ = is_1046_[6] * i_1042_ + is_1046_[7] * i_1043_ + is_1046_[8] * i_1044_ + 8192 >> 14;
  4631. i_1042_ = i_1054_;
  4632. i_1043_ = i_1055_;
  4633. i_1044_ = i_1056_;
  4634. }
  4635. i_1042_ <<= 4;
  4636. i_1043_ <<= 4;
  4637. i_1044_ <<= 4;
  4638. for (int i_1057_ = 0; i_1057_ < i_1047_; i_1057_++) {
  4639. int i_1058_ = is[i_1057_];
  4640. if (i_1058_ < verticesByLabel.length) {
  4641. int[] is_1059_ = verticesByLabel[i_1058_];
  4642. for (int element : is_1059_) {
  4643. int i_1061_ = element;
  4644. if (aShortArray7964 == null || (i_1045_ & aShortArray7964[i_1061_]) != 0) {
  4645. vertices_x[i_1061_] += i_1042_;
  4646. vertices_y[i_1061_] += i_1043_;
  4647. vertices_z[i_1061_] += i_1044_;
  4648. }
  4649. }
  4650. }
  4651. }
  4652. } else if (i == 2) {
  4653. if (is_1046_ != null) {
  4654. int i_1062_ = is_1046_[9] << 4;
  4655. int i_1063_ = is_1046_[10] << 4;
  4656. int i_1064_ = is_1046_[11] << 4;
  4657. int i_1065_ = is_1046_[12] << 4;
  4658. int i_1066_ = is_1046_[13] << 4;
  4659. int i_1067_ = is_1046_[14] << 4;
  4660. if (aBoolean7905) {
  4661. int i_1068_ = is_1046_[0] * origin_x + is_1046_[3] * origin_y + is_1046_[6] * origin_z + 8192 >> 14;
  4662. int i_1069_ = is_1046_[1] * origin_x + is_1046_[4] * origin_y + is_1046_[7] * origin_z + 8192 >> 14;
  4663. int i_1070_ = is_1046_[2] * origin_x + is_1046_[5] * origin_y + is_1046_[8] * origin_z + 8192 >> 14;
  4664. i_1068_ += i_1065_;
  4665. i_1069_ += i_1066_;
  4666. i_1070_ += i_1067_;
  4667. origin_x = i_1068_;
  4668. origin_y = i_1069_;
  4669. origin_z = i_1070_;
  4670. aBoolean7905 = false;
  4671. }
  4672. int[] is_1071_ = new int[9];
  4673. int i_1072_ = Class220.anIntArray2474[i_1042_];
  4674. int i_1073_ = Class220.anIntArray2483[i_1042_];
  4675. int i_1074_ = Class220.anIntArray2474[i_1043_];
  4676. int i_1075_ = Class220.anIntArray2483[i_1043_];
  4677. int i_1076_ = Class220.anIntArray2474[i_1044_];
  4678. int i_1077_ = Class220.anIntArray2483[i_1044_];
  4679. int i_1078_ = i_1073_ * i_1076_ + 8192 >> 14;
  4680. int i_1079_ = i_1073_ * i_1077_ + 8192 >> 14;
  4681. is_1071_[0] = i_1074_ * i_1076_ + i_1075_ * i_1079_ + 8192 >> 14;
  4682. is_1071_[1] = -i_1074_ * i_1077_ + i_1075_ * i_1078_ + 8192 >> 14;
  4683. is_1071_[2] = i_1075_ * i_1072_ + 8192 >> 14;
  4684. is_1071_[3] = i_1072_ * i_1077_ + 8192 >> 14;
  4685. is_1071_[4] = i_1072_ * i_1076_ + 8192 >> 14;
  4686. is_1071_[5] = -i_1073_;
  4687. is_1071_[6] = -i_1075_ * i_1076_ + i_1074_ * i_1079_ + 8192 >> 14;
  4688. is_1071_[7] = i_1075_ * i_1077_ + i_1074_ * i_1078_ + 8192 >> 14;
  4689. is_1071_[8] = i_1074_ * i_1072_ + 8192 >> 14;
  4690. int i_1080_ = is_1071_[0] * -origin_x + is_1071_[1] * -origin_y + is_1071_[2] * -origin_z + 8192 >> 14;
  4691. int i_1081_ = is_1071_[3] * -origin_x + is_1071_[4] * -origin_y + is_1071_[5] * -origin_z + 8192 >> 14;
  4692. int i_1082_ = is_1071_[6] * -origin_x + is_1071_[7] * -origin_y + is_1071_[8] * -origin_z + 8192 >> 14;
  4693. int i_1083_ = i_1080_ + origin_x;
  4694. int i_1084_ = i_1081_ + origin_y;
  4695. int i_1085_ = i_1082_ + origin_z;
  4696. int[] is_1086_ = new int[9];
  4697. for (int i_1087_ = 0; i_1087_ < 3; i_1087_++) {
  4698. for (int i_1088_ = 0; i_1088_ < 3; i_1088_++) {
  4699. int i_1089_ = 0;
  4700. for (int i_1090_ = 0; i_1090_ < 3; i_1090_++) {
  4701. i_1089_ += is_1071_[i_1087_ * 3 + i_1090_] * is_1046_[i_1088_ * 3 + i_1090_];
  4702. }
  4703. is_1086_[i_1087_ * 3 + i_1088_] = i_1089_ + 8192 >> 14;
  4704. }
  4705. }
  4706. int i_1091_ = is_1071_[0] * i_1065_ + is_1071_[1] * i_1066_ + is_1071_[2] * i_1067_ + 8192 >> 14;
  4707. int i_1092_ = is_1071_[3] * i_1065_ + is_1071_[4] * i_1066_ + is_1071_[5] * i_1067_ + 8192 >> 14;
  4708. int i_1093_ = is_1071_[6] * i_1065_ + is_1071_[7] * i_1066_ + is_1071_[8] * i_1067_ + 8192 >> 14;
  4709. i_1091_ += i_1083_;
  4710. i_1092_ += i_1084_;
  4711. i_1093_ += i_1085_;
  4712. int[] is_1094_ = new int[9];
  4713. for (int i_1095_ = 0; i_1095_ < 3; i_1095_++) {
  4714. for (int i_1096_ = 0; i_1096_ < 3; i_1096_++) {
  4715. int i_1097_ = 0;
  4716. for (int i_1098_ = 0; i_1098_ < 3; i_1098_++) {
  4717. i_1097_ += is_1046_[i_1095_ * 3 + i_1098_] * is_1086_[i_1096_ + i_1098_ * 3];
  4718. }
  4719. is_1094_[i_1095_ * 3 + i_1096_] = i_1097_ + 8192 >> 14;
  4720. }
  4721. }
  4722. int i_1099_ = is_1046_[0] * i_1091_ + is_1046_[1] * i_1092_ + is_1046_[2] * i_1093_ + 8192 >> 14;
  4723. int i_1100_ = is_1046_[3] * i_1091_ + is_1046_[4] * i_1092_ + is_1046_[5] * i_1093_ + 8192 >> 14;
  4724. int i_1101_ = is_1046_[6] * i_1091_ + is_1046_[7] * i_1092_ + is_1046_[8] * i_1093_ + 8192 >> 14;
  4725. i_1099_ += i_1062_;
  4726. i_1100_ += i_1063_;
  4727. i_1101_ += i_1064_;
  4728. for (int i_1102_ = 0; i_1102_ < i_1047_; i_1102_++) {
  4729. int i_1103_ = is[i_1102_];
  4730. if (i_1103_ < verticesByLabel.length) {
  4731. int[] is_1104_ = verticesByLabel[i_1103_];
  4732. for (int element : is_1104_) {
  4733. int i_1106_ = element;
  4734. if (aShortArray7964 == null || (i_1045_ & aShortArray7964[i_1106_]) != 0) {
  4735. int i_1107_ = is_1094_[0] * vertices_x[i_1106_] + is_1094_[1] * vertices_y[i_1106_] + is_1094_[2] * vertices_z[i_1106_] + 8192 >> 14;
  4736. int i_1108_ = is_1094_[3] * vertices_x[i_1106_] + is_1094_[4] * vertices_y[i_1106_] + is_1094_[5] * vertices_z[i_1106_] + 8192 >> 14;
  4737. int i_1109_ = is_1094_[6] * vertices_x[i_1106_] + is_1094_[7] * vertices_y[i_1106_] + is_1094_[8] * vertices_z[i_1106_] + 8192 >> 14;
  4738. i_1107_ += i_1099_;
  4739. i_1108_ += i_1100_;
  4740. i_1109_ += i_1101_;
  4741. vertices_x[i_1106_] = i_1107_;
  4742. vertices_y[i_1106_] = i_1108_;
  4743. vertices_z[i_1106_] = i_1109_;
  4744. }
  4745. }
  4746. }
  4747. }
  4748. } else {
  4749. for (int i_1110_ = 0; i_1110_ < i_1047_; i_1110_++) {
  4750. int i_1111_ = is[i_1110_];
  4751. if (i_1111_ < verticesByLabel.length) {
  4752. int[] is_1112_ = verticesByLabel[i_1111_];
  4753. for (int element : is_1112_) {
  4754. int i_1114_ = element;
  4755. if (aShortArray7964 == null || (i_1045_ & aShortArray7964[i_1114_]) != 0) {
  4756. vertices_x[i_1114_] -= origin_x;
  4757. vertices_y[i_1114_] -= origin_y;
  4758. vertices_z[i_1114_] -= origin_z;
  4759. if (i_1044_ != 0) {
  4760. int i_1115_ = Class220.anIntArray2483[i_1044_];
  4761. int i_1116_ = Class220.anIntArray2474[i_1044_];
  4762. int i_1117_ = vertices_y[i_1114_] * i_1115_ + vertices_x[i_1114_] * i_1116_ + 16383 >> 14;
  4763. vertices_y[i_1114_] = vertices_y[i_1114_] * i_1116_ - vertices_x[i_1114_] * i_1115_ + 16383 >> 14;
  4764. vertices_x[i_1114_] = i_1117_;
  4765. }
  4766. if (i_1042_ != 0) {
  4767. int i_1118_ = Class220.anIntArray2483[i_1042_];
  4768. int i_1119_ = Class220.anIntArray2474[i_1042_];
  4769. int i_1120_ = vertices_y[i_1114_] * i_1119_ - vertices_z[i_1114_] * i_1118_ + 16383 >> 14;
  4770. vertices_z[i_1114_] = vertices_y[i_1114_] * i_1118_ + vertices_z[i_1114_] * i_1119_ + 16383 >> 14;
  4771. vertices_y[i_1114_] = i_1120_;
  4772. }
  4773. if (i_1043_ != 0) {
  4774. int i_1121_ = Class220.anIntArray2483[i_1043_];
  4775. int i_1122_ = Class220.anIntArray2474[i_1043_];
  4776. int i_1123_ = vertices_z[i_1114_] * i_1121_ + vertices_x[i_1114_] * i_1122_ + 16383 >> 14;
  4777. vertices_z[i_1114_] = vertices_z[i_1114_] * i_1122_ - vertices_x[i_1114_] * i_1121_ + 16383 >> 14;
  4778. vertices_x[i_1114_] = i_1123_;
  4779. }
  4780. vertices_x[i_1114_] += origin_x;
  4781. vertices_y[i_1114_] += origin_y;
  4782. vertices_z[i_1114_] += origin_z;
  4783. }
  4784. }
  4785. }
  4786. }
  4787. if (bool) {
  4788. for (int i_1124_ = 0; i_1124_ < i_1047_; i_1124_++) {
  4789. int i_1125_ = is[i_1124_];
  4790. if (i_1125_ < verticesByLabel.length) {
  4791. int[] is_1126_ = verticesByLabel[i_1125_];
  4792. for (int i_1128_ : is_1126_) {
  4793. if (aShortArray7964 == null || (i_1045_ & aShortArray7964[i_1128_]) != 0) {
  4794. int i_1129_ = anIntArray7947[i_1128_];
  4795. int i_1130_ = anIntArray7947[i_1128_ + 1];
  4796. for (int i_1131_ = i_1129_; i_1131_ < i_1130_; i_1131_++) {
  4797. int i_1132_ = aShortArray7948[i_1131_] - 1;
  4798. if (i_1132_ == -1) {
  4799. break;
  4800. }
  4801. if (i_1044_ != 0) {
  4802. int i_1133_ = Class220.anIntArray2483[i_1044_];
  4803. int i_1134_ = Class220.anIntArray2474[i_1044_];
  4804. int i_1135_ = aShortArray7910[i_1132_] * i_1133_ + aShortArray7909[i_1132_] * i_1134_ + 16383 >> 14;
  4805. aShortArray7910[i_1132_] = (short) (aShortArray7910[i_1132_] * i_1134_ - aShortArray7909[i_1132_] * i_1133_ + 16383 >> 14);
  4806. aShortArray7909[i_1132_] = (short) i_1135_;
  4807. }
  4808. if (i_1042_ != 0) {
  4809. int i_1136_ = Class220.anIntArray2483[i_1042_];
  4810. int i_1137_ = Class220.anIntArray2474[i_1042_];
  4811. int i_1138_ = aShortArray7910[i_1132_] * i_1137_ - aShortArray7919[i_1132_] * i_1136_ + 16383 >> 14;
  4812. aShortArray7919[i_1132_] = (short) (aShortArray7910[i_1132_] * i_1136_ + aShortArray7919[i_1132_] * i_1137_ + 16383 >> 14);
  4813. aShortArray7910[i_1132_] = (short) i_1138_;
  4814. }
  4815. if (i_1043_ != 0) {
  4816. int i_1139_ = Class220.anIntArray2483[i_1043_];
  4817. int i_1140_ = Class220.anIntArray2474[i_1043_];
  4818. int i_1141_ = aShortArray7919[i_1132_] * i_1139_ + aShortArray7909[i_1132_] * i_1140_ + 16383 >> 14;
  4819. aShortArray7919[i_1132_] = (short) (aShortArray7919[i_1132_] * i_1140_ - aShortArray7909[i_1132_] * i_1139_ + 16383 >> 14);
  4820. aShortArray7909[i_1132_] = (short) i_1141_;
  4821. }
  4822. }
  4823. }
  4824. }
  4825. }
  4826. }
  4827. method4839();
  4828. }
  4829. }
  4830. } else if (i == 3) {
  4831. if (is_1046_ != null) {
  4832. int i_1142_ = is_1046_[9] << 4;
  4833. int i_1143_ = is_1046_[10] << 4;
  4834. int i_1144_ = is_1046_[11] << 4;
  4835. int i_1145_ = is_1046_[12] << 4;
  4836. int i_1146_ = is_1046_[13] << 4;
  4837. int i_1147_ = is_1046_[14] << 4;
  4838. if (aBoolean7905) {
  4839. int i_1148_ = is_1046_[0] * origin_x + is_1046_[3] * origin_y + is_1046_[6] * origin_z + 8192 >> 14;
  4840. int i_1149_ = is_1046_[1] * origin_x + is_1046_[4] * origin_y + is_1046_[7] * origin_z + 8192 >> 14;
  4841. int i_1150_ = is_1046_[2] * origin_x + is_1046_[5] * origin_y + is_1046_[8] * origin_z + 8192 >> 14;
  4842. i_1148_ += i_1145_;
  4843. i_1149_ += i_1146_;
  4844. i_1150_ += i_1147_;
  4845. origin_x = i_1148_;
  4846. origin_y = i_1149_;
  4847. origin_z = i_1150_;
  4848. aBoolean7905 = false;
  4849. }
  4850. int i_1151_ = i_1042_ << 15 >> 7;
  4851. int i_1152_ = i_1043_ << 15 >> 7;
  4852. int i_1153_ = i_1044_ << 15 >> 7;
  4853. int i_1154_ = i_1151_ * -origin_x + 8192 >> 14;
  4854. int i_1155_ = i_1152_ * -origin_y + 8192 >> 14;
  4855. int i_1156_ = i_1153_ * -origin_z + 8192 >> 14;
  4856. int i_1157_ = i_1154_ + origin_x;
  4857. int i_1158_ = i_1155_ + origin_y;
  4858. int i_1159_ = i_1156_ + origin_z;
  4859. int[] is_1160_ = new int[9];
  4860. is_1160_[0] = i_1151_ * is_1046_[0] + 8192 >> 14;
  4861. is_1160_[1] = i_1151_ * is_1046_[3] + 8192 >> 14;
  4862. is_1160_[2] = i_1151_ * is_1046_[6] + 8192 >> 14;
  4863. is_1160_[3] = i_1152_ * is_1046_[1] + 8192 >> 14;
  4864. is_1160_[4] = i_1152_ * is_1046_[4] + 8192 >> 14;
  4865. is_1160_[5] = i_1152_ * is_1046_[7] + 8192 >> 14;
  4866. is_1160_[6] = i_1153_ * is_1046_[2] + 8192 >> 14;
  4867. is_1160_[7] = i_1153_ * is_1046_[5] + 8192 >> 14;
  4868. is_1160_[8] = i_1153_ * is_1046_[8] + 8192 >> 14;
  4869. int i_1161_ = i_1151_ * i_1145_ + 8192 >> 14;
  4870. int i_1162_ = i_1152_ * i_1146_ + 8192 >> 14;
  4871. int i_1163_ = i_1153_ * i_1147_ + 8192 >> 14;
  4872. i_1161_ += i_1157_;
  4873. i_1162_ += i_1158_;
  4874. i_1163_ += i_1159_;
  4875. int[] is_1164_ = new int[9];
  4876. for (int i_1165_ = 0; i_1165_ < 3; i_1165_++) {
  4877. for (int i_1166_ = 0; i_1166_ < 3; i_1166_++) {
  4878. int i_1167_ = 0;
  4879. for (int i_1168_ = 0; i_1168_ < 3; i_1168_++) {
  4880. i_1167_ += is_1046_[i_1165_ * 3 + i_1168_] * is_1160_[i_1166_ + i_1168_ * 3];
  4881. }
  4882. is_1164_[i_1165_ * 3 + i_1166_] = i_1167_ + 8192 >> 14;
  4883. }
  4884. }
  4885. int i_1169_ = is_1046_[0] * i_1161_ + is_1046_[1] * i_1162_ + is_1046_[2] * i_1163_ + 8192 >> 14;
  4886. int i_1170_ = is_1046_[3] * i_1161_ + is_1046_[4] * i_1162_ + is_1046_[5] * i_1163_ + 8192 >> 14;
  4887. int i_1171_ = is_1046_[6] * i_1161_ + is_1046_[7] * i_1162_ + is_1046_[8] * i_1163_ + 8192 >> 14;
  4888. i_1169_ += i_1142_;
  4889. i_1170_ += i_1143_;
  4890. i_1171_ += i_1144_;
  4891. for (int i_1172_ = 0; i_1172_ < i_1047_; i_1172_++) {
  4892. int i_1173_ = is[i_1172_];
  4893. if (i_1173_ < verticesByLabel.length) {
  4894. int[] is_1174_ = verticesByLabel[i_1173_];
  4895. for (int element : is_1174_) {
  4896. int i_1176_ = element;
  4897. if (aShortArray7964 == null || (i_1045_ & aShortArray7964[i_1176_]) != 0) {
  4898. int i_1177_ = is_1164_[0] * vertices_x[i_1176_] + is_1164_[1] * vertices_y[i_1176_] + is_1164_[2] * vertices_z[i_1176_] + 8192 >> 14;
  4899. int i_1178_ = is_1164_[3] * vertices_x[i_1176_] + is_1164_[4] * vertices_y[i_1176_] + is_1164_[5] * vertices_z[i_1176_] + 8192 >> 14;
  4900. int i_1179_ = is_1164_[6] * vertices_x[i_1176_] + is_1164_[7] * vertices_y[i_1176_] + is_1164_[8] * vertices_z[i_1176_] + 8192 >> 14;
  4901. i_1177_ += i_1169_;
  4902. i_1178_ += i_1170_;
  4903. i_1179_ += i_1171_;
  4904. vertices_x[i_1176_] = i_1177_;
  4905. vertices_y[i_1176_] = i_1178_;
  4906. vertices_z[i_1176_] = i_1179_;
  4907. }
  4908. }
  4909. }
  4910. }
  4911. } else {
  4912. for (int i_1180_ = 0; i_1180_ < i_1047_; i_1180_++) {
  4913. int i_1181_ = is[i_1180_];
  4914. if (i_1181_ < verticesByLabel.length) {
  4915. int[] is_1182_ = verticesByLabel[i_1181_];
  4916. for (int element : is_1182_) {
  4917. int i_1184_ = element;
  4918. if (aShortArray7964 == null || (i_1045_ & aShortArray7964[i_1184_]) != 0) {
  4919. vertices_x[i_1184_] -= origin_x;
  4920. vertices_y[i_1184_] -= origin_y;
  4921. vertices_z[i_1184_] -= origin_z;
  4922. vertices_x[i_1184_] = vertices_x[i_1184_] * i_1042_ >> 7;
  4923. vertices_y[i_1184_] = vertices_y[i_1184_] * i_1043_ >> 7;
  4924. vertices_z[i_1184_] = vertices_z[i_1184_] * i_1044_ >> 7;
  4925. vertices_x[i_1184_] += origin_x;
  4926. vertices_y[i_1184_] += origin_y;
  4927. vertices_z[i_1184_] += origin_z;
  4928. }
  4929. }
  4930. }
  4931. }
  4932. }
  4933. } else if (i == 5) {
  4934. if (anIntArrayArray7924 != null) {
  4935. boolean bool_1185_ = false;
  4936. for (int i_1186_ = 0; i_1186_ < i_1047_; i_1186_++) {
  4937. int i_1187_ = is[i_1186_];
  4938. if (i_1187_ < anIntArrayArray7924.length) {
  4939. int[] is_1188_ = anIntArrayArray7924[i_1187_];
  4940. for (int element : is_1188_) {
  4941. int i_1190_ = element;
  4942. if (aShortArray7925 == null || (i_1045_ & aShortArray7925[i_1190_]) != 0) {
  4943. int i_1191_ = (aByteArray7963[i_1190_] & 0xff) + i_1042_ * 8;
  4944. if (i_1191_ < 0) {
  4945. i_1191_ = 0;
  4946. } else if (i_1191_ > 255) {
  4947. i_1191_ = 255;
  4948. }
  4949. aByteArray7963[i_1190_] = (byte) i_1191_;
  4950. }
  4951. }
  4952. bool_1185_ = bool_1185_ | is_1188_.length > 0;
  4953. }
  4954. }
  4955. if (bool_1185_) {
  4956. if (aClass191Array7952 != null) {
  4957. for (int i_1192_ = 0; i_1192_ < anInt7951; i_1192_++) {
  4958. Class191 class191 = aClass191Array7952[i_1192_];
  4959. Class166 class166 = aClass166Array7892[i_1192_];
  4960. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  4961. }
  4962. }
  4963. method4838();
  4964. }
  4965. }
  4966. } else if (i == 7) {
  4967. if (anIntArrayArray7924 != null) {
  4968. boolean bool_1193_ = false;
  4969. for (int i_1194_ = 0; i_1194_ < i_1047_; i_1194_++) {
  4970. int i_1195_ = is[i_1194_];
  4971. if (i_1195_ < anIntArrayArray7924.length) {
  4972. int[] is_1196_ = anIntArrayArray7924[i_1195_];
  4973. for (int element : is_1196_) {
  4974. int i_1198_ = element;
  4975. if (aShortArray7925 == null || (i_1045_ & aShortArray7925[i_1198_]) != 0) {
  4976. int i_1199_ = aShortArray7935[i_1198_] & 0xffff;
  4977. int i_1200_ = i_1199_ >> 10 & 0x3f;
  4978. int i_1201_ = i_1199_ >> 7 & 0x7;
  4979. int i_1202_ = i_1199_ & 0x7f;
  4980. i_1200_ = i_1200_ + i_1042_ & 0x3f;
  4981. i_1201_ += i_1043_ / 4;
  4982. if (i_1201_ < 0) {
  4983. i_1201_ = 0;
  4984. } else if (i_1201_ > 7) {
  4985. i_1201_ = 7;
  4986. }
  4987. i_1202_ += i_1044_;
  4988. if (i_1202_ < 0) {
  4989. i_1202_ = 0;
  4990. } else if (i_1202_ > 127) {
  4991. i_1202_ = 127;
  4992. }
  4993. aShortArray7935[i_1198_] = (short) (i_1200_ << 10 | i_1201_ << 7 | i_1202_);
  4994. }
  4995. }
  4996. bool_1193_ = bool_1193_ | is_1196_.length > 0;
  4997. }
  4998. }
  4999. if (bool_1193_) {
  5000. if (aClass191Array7952 != null) {
  5001. for (int i_1203_ = 0; i_1203_ < anInt7951; i_1203_++) {
  5002. Class191 class191 = aClass191Array7952[i_1203_];
  5003. Class166 class166 = aClass166Array7892[i_1203_];
  5004. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  5005. }
  5006. }
  5007. method4838();
  5008. }
  5009. }
  5010. } else if (i == 8) {
  5011. if (anIntArrayArray7946 != null) {
  5012. for (int i_1204_ = 0; i_1204_ < i_1047_; i_1204_++) {
  5013. int i_1205_ = is[i_1204_];
  5014. if (i_1205_ < anIntArrayArray7946.length) {
  5015. int[] is_1206_ = anIntArrayArray7946[i_1205_];
  5016. for (int element : is_1206_) {
  5017. Class166 class166 = aClass166Array7892[element];
  5018. class166.anInt1704 += i_1042_;
  5019. class166.anInt1705 += i_1043_;
  5020. }
  5021. }
  5022. }
  5023. }
  5024. } else if (i == 10) {
  5025. if (anIntArrayArray7946 != null) {
  5026. for (int i_1208_ = 0; i_1208_ < i_1047_; i_1208_++) {
  5027. int i_1209_ = is[i_1208_];
  5028. if (i_1209_ < anIntArrayArray7946.length) {
  5029. int[] is_1210_ = anIntArrayArray7946[i_1209_];
  5030. for (int element : is_1210_) {
  5031. Class166 class166 = aClass166Array7892[element];
  5032. class166.anInt1702 = class166.anInt1702 * i_1042_ >> 7;
  5033. class166.anInt1701 = class166.anInt1701 * i_1043_ >> 7;
  5034. }
  5035. }
  5036. }
  5037. }
  5038. } else if (i == 9) {
  5039. if (anIntArrayArray7946 != null) {
  5040. for (int i_1212_ = 0; i_1212_ < i_1047_; i_1212_++) {
  5041. int i_1213_ = is[i_1212_];
  5042. if (i_1213_ < anIntArrayArray7946.length) {
  5043. int[] is_1214_ = anIntArrayArray7946[i_1213_];
  5044. for (int element : is_1214_) {
  5045. Class166 class166 = aClass166Array7892[element];
  5046. class166.anInt1706 = class166.anInt1706 + i_1042_ & 0x3fff;
  5047. }
  5048. }
  5049. }
  5050. }
  5051. }
  5052. }
  5053.  
  5054. @Override
  5055. void co(int i, int[] is, int i_1216_, int i_1217_, int i_1218_, boolean bool, int i_1219_, int[] is_1220_) {
  5056. int i_1221_ = is.length;
  5057. if (i == 0) {
  5058. i_1216_ <<= 4;
  5059. i_1217_ <<= 4;
  5060. i_1218_ <<= 4;
  5061. int i_1222_ = 0;
  5062. origin_x = 0;
  5063. origin_y = 0;
  5064. origin_z = 0;
  5065. for (int i_1223_ = 0; i_1223_ < i_1221_; i_1223_++) {
  5066. int i_1224_ = is[i_1223_];
  5067. if (i_1224_ < verticesByLabel.length) {
  5068. int[] is_1225_ = verticesByLabel[i_1224_];
  5069. for (int i_1227_ : is_1225_) {
  5070. if (aShortArray7964 == null || (i_1219_ & aShortArray7964[i_1227_]) != 0) {
  5071. origin_x += vertices_x[i_1227_];
  5072. origin_y += vertices_y[i_1227_];
  5073. origin_z += vertices_z[i_1227_];
  5074. i_1222_++;
  5075. }
  5076. }
  5077. }
  5078. }
  5079. if (i_1222_ > 0) {
  5080. origin_x = origin_x / i_1222_ + i_1216_;
  5081. origin_y = origin_y / i_1222_ + i_1217_;
  5082. origin_z = origin_z / i_1222_ + i_1218_;
  5083. aBoolean7905 = true;
  5084. } else {
  5085. origin_x = i_1216_;
  5086. origin_y = i_1217_;
  5087. origin_z = i_1218_;
  5088. }
  5089. } else if (i == 1) {
  5090. if (is_1220_ != null) {
  5091. int i_1228_ = is_1220_[0] * i_1216_ + is_1220_[1] * i_1217_ + is_1220_[2] * i_1218_ + 8192 >> 14;
  5092. int i_1229_ = is_1220_[3] * i_1216_ + is_1220_[4] * i_1217_ + is_1220_[5] * i_1218_ + 8192 >> 14;
  5093. int i_1230_ = is_1220_[6] * i_1216_ + is_1220_[7] * i_1217_ + is_1220_[8] * i_1218_ + 8192 >> 14;
  5094. i_1216_ = i_1228_;
  5095. i_1217_ = i_1229_;
  5096. i_1218_ = i_1230_;
  5097. }
  5098. i_1216_ <<= 4;
  5099. i_1217_ <<= 4;
  5100. i_1218_ <<= 4;
  5101. for (int i_1231_ = 0; i_1231_ < i_1221_; i_1231_++) {
  5102. int i_1232_ = is[i_1231_];
  5103. if (i_1232_ < verticesByLabel.length) {
  5104. int[] is_1233_ = verticesByLabel[i_1232_];
  5105. for (int element : is_1233_) {
  5106. int i_1235_ = element;
  5107. if (aShortArray7964 == null || (i_1219_ & aShortArray7964[i_1235_]) != 0) {
  5108. vertices_x[i_1235_] += i_1216_;
  5109. vertices_y[i_1235_] += i_1217_;
  5110. vertices_z[i_1235_] += i_1218_;
  5111. }
  5112. }
  5113. }
  5114. }
  5115. } else if (i == 2) {
  5116. if (is_1220_ != null) {
  5117. int i_1236_ = is_1220_[9] << 4;
  5118. int i_1237_ = is_1220_[10] << 4;
  5119. int i_1238_ = is_1220_[11] << 4;
  5120. int i_1239_ = is_1220_[12] << 4;
  5121. int i_1240_ = is_1220_[13] << 4;
  5122. int i_1241_ = is_1220_[14] << 4;
  5123. if (aBoolean7905) {
  5124. int i_1242_ = is_1220_[0] * origin_x + is_1220_[3] * origin_y + is_1220_[6] * origin_z + 8192 >> 14;
  5125. int i_1243_ = is_1220_[1] * origin_x + is_1220_[4] * origin_y + is_1220_[7] * origin_z + 8192 >> 14;
  5126. int i_1244_ = is_1220_[2] * origin_x + is_1220_[5] * origin_y + is_1220_[8] * origin_z + 8192 >> 14;
  5127. i_1242_ += i_1239_;
  5128. i_1243_ += i_1240_;
  5129. i_1244_ += i_1241_;
  5130. origin_x = i_1242_;
  5131. origin_y = i_1243_;
  5132. origin_z = i_1244_;
  5133. aBoolean7905 = false;
  5134. }
  5135. int[] is_1245_ = new int[9];
  5136. int i_1246_ = Class220.anIntArray2474[i_1216_];
  5137. int i_1247_ = Class220.anIntArray2483[i_1216_];
  5138. int i_1248_ = Class220.anIntArray2474[i_1217_];
  5139. int i_1249_ = Class220.anIntArray2483[i_1217_];
  5140. int i_1250_ = Class220.anIntArray2474[i_1218_];
  5141. int i_1251_ = Class220.anIntArray2483[i_1218_];
  5142. int i_1252_ = i_1247_ * i_1250_ + 8192 >> 14;
  5143. int i_1253_ = i_1247_ * i_1251_ + 8192 >> 14;
  5144. is_1245_[0] = i_1248_ * i_1250_ + i_1249_ * i_1253_ + 8192 >> 14;
  5145. is_1245_[1] = -i_1248_ * i_1251_ + i_1249_ * i_1252_ + 8192 >> 14;
  5146. is_1245_[2] = i_1249_ * i_1246_ + 8192 >> 14;
  5147. is_1245_[3] = i_1246_ * i_1251_ + 8192 >> 14;
  5148. is_1245_[4] = i_1246_ * i_1250_ + 8192 >> 14;
  5149. is_1245_[5] = -i_1247_;
  5150. is_1245_[6] = -i_1249_ * i_1250_ + i_1248_ * i_1253_ + 8192 >> 14;
  5151. is_1245_[7] = i_1249_ * i_1251_ + i_1248_ * i_1252_ + 8192 >> 14;
  5152. is_1245_[8] = i_1248_ * i_1246_ + 8192 >> 14;
  5153. int i_1254_ = is_1245_[0] * -origin_x + is_1245_[1] * -origin_y + is_1245_[2] * -origin_z + 8192 >> 14;
  5154. int i_1255_ = is_1245_[3] * -origin_x + is_1245_[4] * -origin_y + is_1245_[5] * -origin_z + 8192 >> 14;
  5155. int i_1256_ = is_1245_[6] * -origin_x + is_1245_[7] * -origin_y + is_1245_[8] * -origin_z + 8192 >> 14;
  5156. int i_1257_ = i_1254_ + origin_x;
  5157. int i_1258_ = i_1255_ + origin_y;
  5158. int i_1259_ = i_1256_ + origin_z;
  5159. int[] is_1260_ = new int[9];
  5160. for (int i_1261_ = 0; i_1261_ < 3; i_1261_++) {
  5161. for (int i_1262_ = 0; i_1262_ < 3; i_1262_++) {
  5162. int i_1263_ = 0;
  5163. for (int i_1264_ = 0; i_1264_ < 3; i_1264_++) {
  5164. i_1263_ += is_1245_[i_1261_ * 3 + i_1264_] * is_1220_[i_1262_ * 3 + i_1264_];
  5165. }
  5166. is_1260_[i_1261_ * 3 + i_1262_] = i_1263_ + 8192 >> 14;
  5167. }
  5168. }
  5169. int i_1265_ = is_1245_[0] * i_1239_ + is_1245_[1] * i_1240_ + is_1245_[2] * i_1241_ + 8192 >> 14;
  5170. int i_1266_ = is_1245_[3] * i_1239_ + is_1245_[4] * i_1240_ + is_1245_[5] * i_1241_ + 8192 >> 14;
  5171. int i_1267_ = is_1245_[6] * i_1239_ + is_1245_[7] * i_1240_ + is_1245_[8] * i_1241_ + 8192 >> 14;
  5172. i_1265_ += i_1257_;
  5173. i_1266_ += i_1258_;
  5174. i_1267_ += i_1259_;
  5175. int[] is_1268_ = new int[9];
  5176. for (int i_1269_ = 0; i_1269_ < 3; i_1269_++) {
  5177. for (int i_1270_ = 0; i_1270_ < 3; i_1270_++) {
  5178. int i_1271_ = 0;
  5179. for (int i_1272_ = 0; i_1272_ < 3; i_1272_++) {
  5180. i_1271_ += is_1220_[i_1269_ * 3 + i_1272_] * is_1260_[i_1270_ + i_1272_ * 3];
  5181. }
  5182. is_1268_[i_1269_ * 3 + i_1270_] = i_1271_ + 8192 >> 14;
  5183. }
  5184. }
  5185. int i_1273_ = is_1220_[0] * i_1265_ + is_1220_[1] * i_1266_ + is_1220_[2] * i_1267_ + 8192 >> 14;
  5186. int i_1274_ = is_1220_[3] * i_1265_ + is_1220_[4] * i_1266_ + is_1220_[5] * i_1267_ + 8192 >> 14;
  5187. int i_1275_ = is_1220_[6] * i_1265_ + is_1220_[7] * i_1266_ + is_1220_[8] * i_1267_ + 8192 >> 14;
  5188. i_1273_ += i_1236_;
  5189. i_1274_ += i_1237_;
  5190. i_1275_ += i_1238_;
  5191. for (int i_1276_ = 0; i_1276_ < i_1221_; i_1276_++) {
  5192. int i_1277_ = is[i_1276_];
  5193. if (i_1277_ < verticesByLabel.length) {
  5194. int[] is_1278_ = verticesByLabel[i_1277_];
  5195. for (int element : is_1278_) {
  5196. int i_1280_ = element;
  5197. if (aShortArray7964 == null || (i_1219_ & aShortArray7964[i_1280_]) != 0) {
  5198. int i_1281_ = is_1268_[0] * vertices_x[i_1280_] + is_1268_[1] * vertices_y[i_1280_] + is_1268_[2] * vertices_z[i_1280_] + 8192 >> 14;
  5199. int i_1282_ = is_1268_[3] * vertices_x[i_1280_] + is_1268_[4] * vertices_y[i_1280_] + is_1268_[5] * vertices_z[i_1280_] + 8192 >> 14;
  5200. int i_1283_ = is_1268_[6] * vertices_x[i_1280_] + is_1268_[7] * vertices_y[i_1280_] + is_1268_[8] * vertices_z[i_1280_] + 8192 >> 14;
  5201. i_1281_ += i_1273_;
  5202. i_1282_ += i_1274_;
  5203. i_1283_ += i_1275_;
  5204. vertices_x[i_1280_] = i_1281_;
  5205. vertices_y[i_1280_] = i_1282_;
  5206. vertices_z[i_1280_] = i_1283_;
  5207. }
  5208. }
  5209. }
  5210. }
  5211. } else {
  5212. for (int i_1284_ = 0; i_1284_ < i_1221_; i_1284_++) {
  5213. int i_1285_ = is[i_1284_];
  5214. if (i_1285_ < verticesByLabel.length) {
  5215. int[] is_1286_ = verticesByLabel[i_1285_];
  5216. for (int element : is_1286_) {
  5217. int i_1288_ = element;
  5218. if (aShortArray7964 == null || (i_1219_ & aShortArray7964[i_1288_]) != 0) {
  5219. vertices_x[i_1288_] -= origin_x;
  5220. vertices_y[i_1288_] -= origin_y;
  5221. vertices_z[i_1288_] -= origin_z;
  5222. if (i_1218_ != 0) {
  5223. int i_1289_ = Class220.anIntArray2483[i_1218_];
  5224. int i_1290_ = Class220.anIntArray2474[i_1218_];
  5225. int i_1291_ = vertices_y[i_1288_] * i_1289_ + vertices_x[i_1288_] * i_1290_ + 16383 >> 14;
  5226. vertices_y[i_1288_] = vertices_y[i_1288_] * i_1290_ - vertices_x[i_1288_] * i_1289_ + 16383 >> 14;
  5227. vertices_x[i_1288_] = i_1291_;
  5228. }
  5229. if (i_1216_ != 0) {
  5230. int i_1292_ = Class220.anIntArray2483[i_1216_];
  5231. int i_1293_ = Class220.anIntArray2474[i_1216_];
  5232. int i_1294_ = vertices_y[i_1288_] * i_1293_ - vertices_z[i_1288_] * i_1292_ + 16383 >> 14;
  5233. vertices_z[i_1288_] = vertices_y[i_1288_] * i_1292_ + vertices_z[i_1288_] * i_1293_ + 16383 >> 14;
  5234. vertices_y[i_1288_] = i_1294_;
  5235. }
  5236. if (i_1217_ != 0) {
  5237. int i_1295_ = Class220.anIntArray2483[i_1217_];
  5238. int i_1296_ = Class220.anIntArray2474[i_1217_];
  5239. int i_1297_ = vertices_z[i_1288_] * i_1295_ + vertices_x[i_1288_] * i_1296_ + 16383 >> 14;
  5240. vertices_z[i_1288_] = vertices_z[i_1288_] * i_1296_ - vertices_x[i_1288_] * i_1295_ + 16383 >> 14;
  5241. vertices_x[i_1288_] = i_1297_;
  5242. }
  5243. vertices_x[i_1288_] += origin_x;
  5244. vertices_y[i_1288_] += origin_y;
  5245. vertices_z[i_1288_] += origin_z;
  5246. }
  5247. }
  5248. }
  5249. }
  5250. if (bool) {
  5251. for (int i_1298_ = 0; i_1298_ < i_1221_; i_1298_++) {
  5252. int i_1299_ = is[i_1298_];
  5253. if (i_1299_ < verticesByLabel.length) {
  5254. int[] is_1300_ = verticesByLabel[i_1299_];
  5255. for (int i_1302_ : is_1300_) {
  5256. if (aShortArray7964 == null || (i_1219_ & aShortArray7964[i_1302_]) != 0) {
  5257. int i_1303_ = anIntArray7947[i_1302_];
  5258. int i_1304_ = anIntArray7947[i_1302_ + 1];
  5259. for (int i_1305_ = i_1303_; i_1305_ < i_1304_; i_1305_++) {
  5260. int i_1306_ = aShortArray7948[i_1305_] - 1;
  5261. if (i_1306_ == -1) {
  5262. break;
  5263. }
  5264. if (i_1218_ != 0) {
  5265. int i_1307_ = Class220.anIntArray2483[i_1218_];
  5266. int i_1308_ = Class220.anIntArray2474[i_1218_];
  5267. int i_1309_ = aShortArray7910[i_1306_] * i_1307_ + aShortArray7909[i_1306_] * i_1308_ + 16383 >> 14;
  5268. aShortArray7910[i_1306_] = (short) (aShortArray7910[i_1306_] * i_1308_ - aShortArray7909[i_1306_] * i_1307_ + 16383 >> 14);
  5269. aShortArray7909[i_1306_] = (short) i_1309_;
  5270. }
  5271. if (i_1216_ != 0) {
  5272. int i_1310_ = Class220.anIntArray2483[i_1216_];
  5273. int i_1311_ = Class220.anIntArray2474[i_1216_];
  5274. int i_1312_ = aShortArray7910[i_1306_] * i_1311_ - aShortArray7919[i_1306_] * i_1310_ + 16383 >> 14;
  5275. aShortArray7919[i_1306_] = (short) (aShortArray7910[i_1306_] * i_1310_ + aShortArray7919[i_1306_] * i_1311_ + 16383 >> 14);
  5276. aShortArray7910[i_1306_] = (short) i_1312_;
  5277. }
  5278. if (i_1217_ != 0) {
  5279. int i_1313_ = Class220.anIntArray2483[i_1217_];
  5280. int i_1314_ = Class220.anIntArray2474[i_1217_];
  5281. int i_1315_ = aShortArray7919[i_1306_] * i_1313_ + aShortArray7909[i_1306_] * i_1314_ + 16383 >> 14;
  5282. aShortArray7919[i_1306_] = (short) (aShortArray7919[i_1306_] * i_1314_ - aShortArray7909[i_1306_] * i_1313_ + 16383 >> 14);
  5283. aShortArray7909[i_1306_] = (short) i_1315_;
  5284. }
  5285. }
  5286. }
  5287. }
  5288. }
  5289. }
  5290. method4839();
  5291. }
  5292. }
  5293. } else if (i == 3) {
  5294. if (is_1220_ != null) {
  5295. int i_1316_ = is_1220_[9] << 4;
  5296. int i_1317_ = is_1220_[10] << 4;
  5297. int i_1318_ = is_1220_[11] << 4;
  5298. int i_1319_ = is_1220_[12] << 4;
  5299. int i_1320_ = is_1220_[13] << 4;
  5300. int i_1321_ = is_1220_[14] << 4;
  5301. if (aBoolean7905) {
  5302. int i_1322_ = is_1220_[0] * origin_x + is_1220_[3] * origin_y + is_1220_[6] * origin_z + 8192 >> 14;
  5303. int i_1323_ = is_1220_[1] * origin_x + is_1220_[4] * origin_y + is_1220_[7] * origin_z + 8192 >> 14;
  5304. int i_1324_ = is_1220_[2] * origin_x + is_1220_[5] * origin_y + is_1220_[8] * origin_z + 8192 >> 14;
  5305. i_1322_ += i_1319_;
  5306. i_1323_ += i_1320_;
  5307. i_1324_ += i_1321_;
  5308. origin_x = i_1322_;
  5309. origin_y = i_1323_;
  5310. origin_z = i_1324_;
  5311. aBoolean7905 = false;
  5312. }
  5313. int i_1325_ = i_1216_ << 15 >> 7;
  5314. int i_1326_ = i_1217_ << 15 >> 7;
  5315. int i_1327_ = i_1218_ << 15 >> 7;
  5316. int i_1328_ = i_1325_ * -origin_x + 8192 >> 14;
  5317. int i_1329_ = i_1326_ * -origin_y + 8192 >> 14;
  5318. int i_1330_ = i_1327_ * -origin_z + 8192 >> 14;
  5319. int i_1331_ = i_1328_ + origin_x;
  5320. int i_1332_ = i_1329_ + origin_y;
  5321. int i_1333_ = i_1330_ + origin_z;
  5322. int[] is_1334_ = new int[9];
  5323. is_1334_[0] = i_1325_ * is_1220_[0] + 8192 >> 14;
  5324. is_1334_[1] = i_1325_ * is_1220_[3] + 8192 >> 14;
  5325. is_1334_[2] = i_1325_ * is_1220_[6] + 8192 >> 14;
  5326. is_1334_[3] = i_1326_ * is_1220_[1] + 8192 >> 14;
  5327. is_1334_[4] = i_1326_ * is_1220_[4] + 8192 >> 14;
  5328. is_1334_[5] = i_1326_ * is_1220_[7] + 8192 >> 14;
  5329. is_1334_[6] = i_1327_ * is_1220_[2] + 8192 >> 14;
  5330. is_1334_[7] = i_1327_ * is_1220_[5] + 8192 >> 14;
  5331. is_1334_[8] = i_1327_ * is_1220_[8] + 8192 >> 14;
  5332. int i_1335_ = i_1325_ * i_1319_ + 8192 >> 14;
  5333. int i_1336_ = i_1326_ * i_1320_ + 8192 >> 14;
  5334. int i_1337_ = i_1327_ * i_1321_ + 8192 >> 14;
  5335. i_1335_ += i_1331_;
  5336. i_1336_ += i_1332_;
  5337. i_1337_ += i_1333_;
  5338. int[] is_1338_ = new int[9];
  5339. for (int i_1339_ = 0; i_1339_ < 3; i_1339_++) {
  5340. for (int i_1340_ = 0; i_1340_ < 3; i_1340_++) {
  5341. int i_1341_ = 0;
  5342. for (int i_1342_ = 0; i_1342_ < 3; i_1342_++) {
  5343. i_1341_ += is_1220_[i_1339_ * 3 + i_1342_] * is_1334_[i_1340_ + i_1342_ * 3];
  5344. }
  5345. is_1338_[i_1339_ * 3 + i_1340_] = i_1341_ + 8192 >> 14;
  5346. }
  5347. }
  5348. int i_1343_ = is_1220_[0] * i_1335_ + is_1220_[1] * i_1336_ + is_1220_[2] * i_1337_ + 8192 >> 14;
  5349. int i_1344_ = is_1220_[3] * i_1335_ + is_1220_[4] * i_1336_ + is_1220_[5] * i_1337_ + 8192 >> 14;
  5350. int i_1345_ = is_1220_[6] * i_1335_ + is_1220_[7] * i_1336_ + is_1220_[8] * i_1337_ + 8192 >> 14;
  5351. i_1343_ += i_1316_;
  5352. i_1344_ += i_1317_;
  5353. i_1345_ += i_1318_;
  5354. for (int i_1346_ = 0; i_1346_ < i_1221_; i_1346_++) {
  5355. int i_1347_ = is[i_1346_];
  5356. if (i_1347_ < verticesByLabel.length) {
  5357. int[] is_1348_ = verticesByLabel[i_1347_];
  5358. for (int element : is_1348_) {
  5359. int i_1350_ = element;
  5360. if (aShortArray7964 == null || (i_1219_ & aShortArray7964[i_1350_]) != 0) {
  5361. int i_1351_ = is_1338_[0] * vertices_x[i_1350_] + is_1338_[1] * vertices_y[i_1350_] + is_1338_[2] * vertices_z[i_1350_] + 8192 >> 14;
  5362. int i_1352_ = is_1338_[3] * vertices_x[i_1350_] + is_1338_[4] * vertices_y[i_1350_] + is_1338_[5] * vertices_z[i_1350_] + 8192 >> 14;
  5363. int i_1353_ = is_1338_[6] * vertices_x[i_1350_] + is_1338_[7] * vertices_y[i_1350_] + is_1338_[8] * vertices_z[i_1350_] + 8192 >> 14;
  5364. i_1351_ += i_1343_;
  5365. i_1352_ += i_1344_;
  5366. i_1353_ += i_1345_;
  5367. vertices_x[i_1350_] = i_1351_;
  5368. vertices_y[i_1350_] = i_1352_;
  5369. vertices_z[i_1350_] = i_1353_;
  5370. }
  5371. }
  5372. }
  5373. }
  5374. } else {
  5375. for (int i_1354_ = 0; i_1354_ < i_1221_; i_1354_++) {
  5376. int i_1355_ = is[i_1354_];
  5377. if (i_1355_ < verticesByLabel.length) {
  5378. int[] is_1356_ = verticesByLabel[i_1355_];
  5379. for (int element : is_1356_) {
  5380. int i_1358_ = element;
  5381. if (aShortArray7964 == null || (i_1219_ & aShortArray7964[i_1358_]) != 0) {
  5382. vertices_x[i_1358_] -= origin_x;
  5383. vertices_y[i_1358_] -= origin_y;
  5384. vertices_z[i_1358_] -= origin_z;
  5385. vertices_x[i_1358_] = vertices_x[i_1358_] * i_1216_ >> 7;
  5386. vertices_y[i_1358_] = vertices_y[i_1358_] * i_1217_ >> 7;
  5387. vertices_z[i_1358_] = vertices_z[i_1358_] * i_1218_ >> 7;
  5388. vertices_x[i_1358_] += origin_x;
  5389. vertices_y[i_1358_] += origin_y;
  5390. vertices_z[i_1358_] += origin_z;
  5391. }
  5392. }
  5393. }
  5394. }
  5395. }
  5396. } else if (i == 5) {
  5397. if (anIntArrayArray7924 != null) {
  5398. boolean bool_1359_ = false;
  5399. for (int i_1360_ = 0; i_1360_ < i_1221_; i_1360_++) {
  5400. int i_1361_ = is[i_1360_];
  5401. if (i_1361_ < anIntArrayArray7924.length) {
  5402. int[] is_1362_ = anIntArrayArray7924[i_1361_];
  5403. for (int element : is_1362_) {
  5404. int i_1364_ = element;
  5405. if (aShortArray7925 == null || (i_1219_ & aShortArray7925[i_1364_]) != 0) {
  5406. int i_1365_ = (aByteArray7963[i_1364_] & 0xff) + i_1216_ * 8;
  5407. if (i_1365_ < 0) {
  5408. i_1365_ = 0;
  5409. } else if (i_1365_ > 255) {
  5410. i_1365_ = 255;
  5411. }
  5412. aByteArray7963[i_1364_] = (byte) i_1365_;
  5413. }
  5414. }
  5415. bool_1359_ = bool_1359_ | is_1362_.length > 0;
  5416. }
  5417. }
  5418. if (bool_1359_) {
  5419. if (aClass191Array7952 != null) {
  5420. for (int i_1366_ = 0; i_1366_ < anInt7951; i_1366_++) {
  5421. Class191 class191 = aClass191Array7952[i_1366_];
  5422. Class166 class166 = aClass166Array7892[i_1366_];
  5423. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  5424. }
  5425. }
  5426. method4838();
  5427. }
  5428. }
  5429. } else if (i == 7) {
  5430. if (anIntArrayArray7924 != null) {
  5431. boolean bool_1367_ = false;
  5432. for (int i_1368_ = 0; i_1368_ < i_1221_; i_1368_++) {
  5433. int i_1369_ = is[i_1368_];
  5434. if (i_1369_ < anIntArrayArray7924.length) {
  5435. int[] is_1370_ = anIntArrayArray7924[i_1369_];
  5436. for (int element : is_1370_) {
  5437. int i_1372_ = element;
  5438. if (aShortArray7925 == null || (i_1219_ & aShortArray7925[i_1372_]) != 0) {
  5439. int i_1373_ = aShortArray7935[i_1372_] & 0xffff;
  5440. int i_1374_ = i_1373_ >> 10 & 0x3f;
  5441. int i_1375_ = i_1373_ >> 7 & 0x7;
  5442. int i_1376_ = i_1373_ & 0x7f;
  5443. i_1374_ = i_1374_ + i_1216_ & 0x3f;
  5444. i_1375_ += i_1217_ / 4;
  5445. if (i_1375_ < 0) {
  5446. i_1375_ = 0;
  5447. } else if (i_1375_ > 7) {
  5448. i_1375_ = 7;
  5449. }
  5450. i_1376_ += i_1218_;
  5451. if (i_1376_ < 0) {
  5452. i_1376_ = 0;
  5453. } else if (i_1376_ > 127) {
  5454. i_1376_ = 127;
  5455. }
  5456. aShortArray7935[i_1372_] = (short) (i_1374_ << 10 | i_1375_ << 7 | i_1376_);
  5457. }
  5458. }
  5459. bool_1367_ = bool_1367_ | is_1370_.length > 0;
  5460. }
  5461. }
  5462. if (bool_1367_) {
  5463. if (aClass191Array7952 != null) {
  5464. for (int i_1377_ = 0; i_1377_ < anInt7951; i_1377_++) {
  5465. Class191 class191 = aClass191Array7952[i_1377_];
  5466. Class166 class166 = aClass166Array7892[i_1377_];
  5467. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  5468. }
  5469. }
  5470. method4838();
  5471. }
  5472. }
  5473. } else if (i == 8) {
  5474. if (anIntArrayArray7946 != null) {
  5475. for (int i_1378_ = 0; i_1378_ < i_1221_; i_1378_++) {
  5476. int i_1379_ = is[i_1378_];
  5477. if (i_1379_ < anIntArrayArray7946.length) {
  5478. int[] is_1380_ = anIntArrayArray7946[i_1379_];
  5479. for (int element : is_1380_) {
  5480. Class166 class166 = aClass166Array7892[element];
  5481. class166.anInt1704 += i_1216_;
  5482. class166.anInt1705 += i_1217_;
  5483. }
  5484. }
  5485. }
  5486. }
  5487. } else if (i == 10) {
  5488. if (anIntArrayArray7946 != null) {
  5489. for (int i_1382_ = 0; i_1382_ < i_1221_; i_1382_++) {
  5490. int i_1383_ = is[i_1382_];
  5491. if (i_1383_ < anIntArrayArray7946.length) {
  5492. int[] is_1384_ = anIntArrayArray7946[i_1383_];
  5493. for (int element : is_1384_) {
  5494. Class166 class166 = aClass166Array7892[element];
  5495. class166.anInt1702 = class166.anInt1702 * i_1216_ >> 7;
  5496. class166.anInt1701 = class166.anInt1701 * i_1217_ >> 7;
  5497. }
  5498. }
  5499. }
  5500. }
  5501. } else if (i == 9) {
  5502. if (anIntArrayArray7946 != null) {
  5503. for (int i_1386_ = 0; i_1386_ < i_1221_; i_1386_++) {
  5504. int i_1387_ = is[i_1386_];
  5505. if (i_1387_ < anIntArrayArray7946.length) {
  5506. int[] is_1388_ = anIntArrayArray7946[i_1387_];
  5507. for (int element : is_1388_) {
  5508. Class166 class166 = aClass166Array7892[element];
  5509. class166.anInt1706 = class166.anInt1706 + i_1216_ & 0x3fff;
  5510. }
  5511. }
  5512. }
  5513. }
  5514. }
  5515. }
  5516.  
  5517. @Override
  5518. void cw(int i, int i_1390_, int i_1391_, int i_1392_) {
  5519. if (i == 0) {
  5520. int i_1393_ = 0;
  5521. origin_x = 0;
  5522. origin_y = 0;
  5523. origin_z = 0;
  5524. for (int i_1394_ = 0; i_1394_ < anInt7900; i_1394_++) {
  5525. origin_x += vertices_x[i_1394_];
  5526. origin_y += vertices_y[i_1394_];
  5527. origin_z += vertices_z[i_1394_];
  5528. i_1393_++;
  5529. }
  5530. if (i_1393_ > 0) {
  5531. origin_x = origin_x / i_1393_ + i_1390_;
  5532. origin_y = origin_y / i_1393_ + i_1391_;
  5533. origin_z = origin_z / i_1393_ + i_1392_;
  5534. } else {
  5535. origin_x = i_1390_;
  5536. origin_y = i_1391_;
  5537. origin_z = i_1392_;
  5538. }
  5539. } else if (i == 1) {
  5540. for (int i_1395_ = 0; i_1395_ < anInt7900; i_1395_++) {
  5541. vertices_x[i_1395_] += i_1390_;
  5542. vertices_y[i_1395_] += i_1391_;
  5543. vertices_z[i_1395_] += i_1392_;
  5544. }
  5545. } else if (i == 2) {
  5546. for (int i_1396_ = 0; i_1396_ < anInt7900; i_1396_++) {
  5547. vertices_x[i_1396_] -= origin_x;
  5548. vertices_y[i_1396_] -= origin_y;
  5549. vertices_z[i_1396_] -= origin_z;
  5550. if (i_1392_ != 0) {
  5551. int i_1397_ = Class220.anIntArray2483[i_1392_];
  5552. int i_1398_ = Class220.anIntArray2474[i_1392_];
  5553. int i_1399_ = vertices_y[i_1396_] * i_1397_ + vertices_x[i_1396_] * i_1398_ + 16383 >> 14;
  5554. vertices_y[i_1396_] = vertices_y[i_1396_] * i_1398_ - vertices_x[i_1396_] * i_1397_ + 16383 >> 14;
  5555. vertices_x[i_1396_] = i_1399_;
  5556. }
  5557. if (i_1390_ != 0) {
  5558. int i_1400_ = Class220.anIntArray2483[i_1390_];
  5559. int i_1401_ = Class220.anIntArray2474[i_1390_];
  5560. int i_1402_ = vertices_y[i_1396_] * i_1401_ - vertices_z[i_1396_] * i_1400_ + 16383 >> 14;
  5561. vertices_z[i_1396_] = vertices_y[i_1396_] * i_1400_ + vertices_z[i_1396_] * i_1401_ + 16383 >> 14;
  5562. vertices_y[i_1396_] = i_1402_;
  5563. }
  5564. if (i_1391_ != 0) {
  5565. int i_1403_ = Class220.anIntArray2483[i_1391_];
  5566. int i_1404_ = Class220.anIntArray2474[i_1391_];
  5567. int i_1405_ = vertices_z[i_1396_] * i_1403_ + vertices_x[i_1396_] * i_1404_ + 16383 >> 14;
  5568. vertices_z[i_1396_] = vertices_z[i_1396_] * i_1404_ - vertices_x[i_1396_] * i_1403_ + 16383 >> 14;
  5569. vertices_x[i_1396_] = i_1405_;
  5570. }
  5571. vertices_x[i_1396_] += origin_x;
  5572. vertices_y[i_1396_] += origin_y;
  5573. vertices_z[i_1396_] += origin_z;
  5574. }
  5575. } else if (i == 3) {
  5576. for (int i_1406_ = 0; i_1406_ < anInt7900; i_1406_++) {
  5577. vertices_x[i_1406_] -= origin_x;
  5578. vertices_y[i_1406_] -= origin_y;
  5579. vertices_z[i_1406_] -= origin_z;
  5580. vertices_x[i_1406_] = vertices_x[i_1406_] * i_1390_ / 128;
  5581. vertices_y[i_1406_] = vertices_y[i_1406_] * i_1391_ / 128;
  5582. vertices_z[i_1406_] = vertices_z[i_1406_] * i_1392_ / 128;
  5583. vertices_x[i_1406_] += origin_x;
  5584. vertices_y[i_1406_] += origin_y;
  5585. vertices_z[i_1406_] += origin_z;
  5586. }
  5587. } else if (i == 5) {
  5588. for (int i_1407_ = 0; i_1407_ < anInt7916; i_1407_++) {
  5589. int i_1408_ = (aByteArray7963[i_1407_] & 0xff) + i_1390_ * 8;
  5590. if (i_1408_ < 0) {
  5591. i_1408_ = 0;
  5592. } else if (i_1408_ > 255) {
  5593. i_1408_ = 255;
  5594. }
  5595. aByteArray7963[i_1407_] = (byte) i_1408_;
  5596. }
  5597. if (aClass191Array7952 != null) {
  5598. for (int i_1409_ = 0; i_1409_ < anInt7951; i_1409_++) {
  5599. Class191 class191 = aClass191Array7952[i_1409_];
  5600. Class166 class166 = aClass166Array7892[i_1409_];
  5601. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  5602. }
  5603. }
  5604. method4838();
  5605. } else if (i == 7) {
  5606. for (int i_1410_ = 0; i_1410_ < anInt7916; i_1410_++) {
  5607. int i_1411_ = aShortArray7935[i_1410_] & 0xffff;
  5608. int i_1412_ = i_1411_ >> 10 & 0x3f;
  5609. int i_1413_ = i_1411_ >> 7 & 0x7;
  5610. int i_1414_ = i_1411_ & 0x7f;
  5611. i_1412_ = i_1412_ + i_1390_ & 0x3f;
  5612. i_1413_ += i_1391_ / 4;
  5613. if (i_1413_ < 0) {
  5614. i_1413_ = 0;
  5615. } else if (i_1413_ > 7) {
  5616. i_1413_ = 7;
  5617. }
  5618. i_1414_ += i_1392_;
  5619. if (i_1414_ < 0) {
  5620. i_1414_ = 0;
  5621. } else if (i_1414_ > 127) {
  5622. i_1414_ = 127;
  5623. }
  5624. aShortArray7935[i_1410_] = (short) (i_1412_ << 10 | i_1413_ << 7 | i_1414_);
  5625. }
  5626. if (aClass191Array7952 != null) {
  5627. for (int i_1415_ = 0; i_1415_ < anInt7951; i_1415_++) {
  5628. Class191 class191 = aClass191Array7952[i_1415_];
  5629. Class166 class166 = aClass166Array7892[i_1415_];
  5630. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  5631. }
  5632. }
  5633. method4838();
  5634. } else if (i == 8) {
  5635. for (int i_1416_ = 0; i_1416_ < anInt7951; i_1416_++) {
  5636. Class166 class166 = aClass166Array7892[i_1416_];
  5637. class166.anInt1704 += i_1390_;
  5638. class166.anInt1705 += i_1391_;
  5639. }
  5640. } else if (i == 10) {
  5641. for (int i_1417_ = 0; i_1417_ < anInt7951; i_1417_++) {
  5642. Class166 class166 = aClass166Array7892[i_1417_];
  5643. class166.anInt1702 = class166.anInt1702 * i_1390_ >> 7;
  5644. class166.anInt1701 = class166.anInt1701 * i_1391_ >> 7;
  5645. }
  5646. } else if (i == 9) {
  5647. for (int i_1418_ = 0; i_1418_ < anInt7951; i_1418_++) {
  5648. Class166 class166 = aClass166Array7892[i_1418_];
  5649. class166.anInt1706 = class166.anInt1706 + i_1390_ & 0x3fff;
  5650. }
  5651. }
  5652. }
  5653.  
  5654. @Override
  5655. public void method4776(Class222 class222, int i, boolean bool) {
  5656. if (aShortArray7964 != null) {
  5657. Class222 class222_1419_ = class222;
  5658. if (bool) {
  5659. class222_1419_ = aClass_ra_Sub3_7894.aClass222_8235;
  5660. class222_1419_.method2074(class222);
  5661. }
  5662. float[] fs = new float[3];
  5663. for (int i_1420_ = 0; i_1420_ < anInt7900; i_1420_++) {
  5664. if ((i & aShortArray7964[i_1420_]) != 0) {
  5665. class222_1419_.method2077(vertices_x[i_1420_], vertices_y[i_1420_], vertices_z[i_1420_], fs);
  5666. vertices_x[i_1420_] = (int) fs[0];
  5667. vertices_y[i_1420_] = (int) fs[1];
  5668. vertices_z[i_1420_] = (int) fs[2];
  5669. }
  5670. }
  5671. }
  5672. }
  5673.  
  5674. @Override
  5675. public void method4762(Class222 class222, int i, boolean bool) {
  5676. if (aShortArray7964 != null) {
  5677. Class222 class222_1421_ = class222;
  5678. if (bool) {
  5679. class222_1421_ = aClass_ra_Sub3_7894.aClass222_8235;
  5680. class222_1421_.method2074(class222);
  5681. }
  5682. float[] fs = new float[3];
  5683. for (int i_1422_ = 0; i_1422_ < anInt7900; i_1422_++) {
  5684. if ((i & aShortArray7964[i_1422_]) != 0) {
  5685. class222_1421_.method2077(vertices_x[i_1422_], vertices_y[i_1422_], vertices_z[i_1422_], fs);
  5686. vertices_x[i_1422_] = (int) fs[0];
  5687. vertices_y[i_1422_] = (int) fs[1];
  5688. vertices_z[i_1422_] = (int) fs[2];
  5689. }
  5690. }
  5691. }
  5692. }
  5693.  
  5694. @Override
  5695. public void method4759(Class222 class222, Class302_Sub1 class302_sub1, int i) {
  5696. if (aClass156_7966 != null) {
  5697. aClass156_7966.method1694();
  5698. }
  5699. if (anInt7906 != 0) {
  5700. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8246;
  5701. Class233 class233_1423_ = aClass_ra_Sub3_7894.aClass233_8236;
  5702. Class233 class233_1424_ = aClass_ra_Sub3_7894.aClass233_8204;
  5703. class233_1423_.method2145(class222);
  5704. class233_1424_.method2142(class233_1423_);
  5705. class233_1424_.method2144(aClass_ra_Sub3_7894.aClass233_8205);
  5706. if (!aBoolean7950) {
  5707. method4832();
  5708. }
  5709. float[] fs = aClass_ra_Sub3_7894.aFloatArray8312;
  5710. class233_1423_.method2149(0.0F, anInt7938, 0.0F, fs);
  5711. float f = fs[0];
  5712. float f_1425_ = fs[1];
  5713. float f_1426_ = fs[2];
  5714. class233_1423_.method2149(0.0F, anInt7939, 0.0F, fs);
  5715. float f_1427_ = fs[0];
  5716. float f_1428_ = fs[1];
  5717. float f_1429_ = fs[2];
  5718. for (int i_1430_ = 0; i_1430_ < 6; i_1430_++) {
  5719. float[] fs_1431_ = aClass_ra_Sub3_7894.aFloatArrayArray8252[i_1430_];
  5720. float f_1432_ = fs_1431_[0] * f + fs_1431_[1] * f_1425_ + fs_1431_[2] * f_1426_ + fs_1431_[3] + anInt7936;
  5721. float f_1433_ = fs_1431_[0] * f_1427_ + fs_1431_[1] * f_1428_ + fs_1431_[2] * f_1429_ + fs_1431_[3] + anInt7936;
  5722. if (f_1432_ < 0.0F && f_1433_ < 0.0F) {
  5723. return;
  5724. }
  5725. }
  5726. if (class302_sub1 != null) {
  5727. boolean bool = false;
  5728. boolean bool_1434_ = true;
  5729. int i_1435_ = anInt7940 + anInt7941 >> 1;
  5730. int i_1436_ = anInt7942 + anInt7943 >> 1;
  5731. int i_1437_ = i_1435_;
  5732. int i_1438_ = anInt7938;
  5733. int i_1439_ = i_1436_;
  5734. float f_1440_ = class233_1424_.aFloatArray2594[0] * i_1437_ + class233_1424_.aFloatArray2594[4] * i_1438_ + class233_1424_.aFloatArray2594[8] * i_1439_ + class233_1424_.aFloatArray2594[12];
  5735. float f_1441_ = class233_1424_.aFloatArray2594[1] * i_1437_ + class233_1424_.aFloatArray2594[5] * i_1438_ + class233_1424_.aFloatArray2594[9] * i_1439_ + class233_1424_.aFloatArray2594[13];
  5736. float f_1442_ = class233_1424_.aFloatArray2594[2] * i_1437_ + class233_1424_.aFloatArray2594[6] * i_1438_ + class233_1424_.aFloatArray2594[10] * i_1439_ + class233_1424_.aFloatArray2594[14];
  5737. float f_1443_ = class233_1424_.aFloatArray2594[3] * i_1437_ + class233_1424_.aFloatArray2594[7] * i_1438_ + class233_1424_.aFloatArray2594[11] * i_1439_ + class233_1424_.aFloatArray2594[15];
  5738. if (f_1442_ >= -f_1443_) {
  5739. class302_sub1.anInt7641 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1440_ / f_1443_);
  5740. class302_sub1.anInt7642 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1441_ / f_1443_);
  5741. } else {
  5742. bool = true;
  5743. }
  5744. i_1437_ = i_1435_;
  5745. i_1438_ = anInt7939;
  5746. i_1439_ = i_1436_;
  5747. float f_1444_ = class233_1424_.aFloatArray2594[0] * i_1437_ + class233_1424_.aFloatArray2594[4] * i_1438_ + class233_1424_.aFloatArray2594[8] * i_1439_ + class233_1424_.aFloatArray2594[12];
  5748. float f_1445_ = class233_1424_.aFloatArray2594[1] * i_1437_ + class233_1424_.aFloatArray2594[5] * i_1438_ + class233_1424_.aFloatArray2594[9] * i_1439_ + class233_1424_.aFloatArray2594[13];
  5749. float f_1446_ = class233_1424_.aFloatArray2594[2] * i_1437_ + class233_1424_.aFloatArray2594[6] * i_1438_ + class233_1424_.aFloatArray2594[10] * i_1439_ + class233_1424_.aFloatArray2594[14];
  5750. float f_1447_ = class233_1424_.aFloatArray2594[3] * i_1437_ + class233_1424_.aFloatArray2594[7] * i_1438_ + class233_1424_.aFloatArray2594[11] * i_1439_ + class233_1424_.aFloatArray2594[15];
  5751. if (f_1446_ >= -f_1447_) {
  5752. class302_sub1.anInt7643 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1444_ / f_1447_);
  5753. class302_sub1.anInt7640 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1445_ / f_1447_);
  5754. } else {
  5755. bool = true;
  5756. }
  5757. if (bool) {
  5758. if (f_1442_ < -f_1443_ && f_1446_ < -f_1447_) {
  5759. bool_1434_ = false;
  5760. } else if (f_1442_ < -f_1443_) {
  5761. float f_1448_ = (f_1442_ + f_1443_) / (f_1446_ + f_1447_) - 1.0F;
  5762. float f_1449_ = f_1440_ + f_1448_ * (f_1444_ - f_1440_);
  5763. float f_1450_ = f_1441_ + f_1448_ * (f_1445_ - f_1441_);
  5764. float f_1451_ = f_1443_ + f_1448_ * (f_1447_ - f_1443_);
  5765. class302_sub1.anInt7641 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1449_ / f_1451_);
  5766. class302_sub1.anInt7642 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1450_ / f_1451_);
  5767. } else if (f_1446_ < -f_1447_) {
  5768. float f_1452_ = (f_1446_ + f_1447_) / (f_1442_ + f_1443_) - 1.0F;
  5769. float f_1453_ = f_1444_ + f_1452_ * (f_1440_ - f_1444_);
  5770. float f_1454_ = f_1445_ + f_1452_ * (f_1441_ - f_1445_);
  5771. float f_1455_ = f_1447_ + f_1452_ * (f_1443_ - f_1447_);
  5772. class302_sub1.anInt7643 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1453_ / f_1455_);
  5773. class302_sub1.anInt7640 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1454_ / f_1455_);
  5774. }
  5775. }
  5776. if (bool_1434_) {
  5777. if (f_1442_ / f_1443_ > f_1446_ / f_1447_) {
  5778. float f_1456_ = f_1440_ + class233.aFloatArray2594[0] * anInt7936 + class233.aFloatArray2594[12];
  5779. float f_1457_ = f_1443_ + class233.aFloatArray2594[3] * anInt7936 + class233.aFloatArray2594[15];
  5780. class302_sub1.anInt7645 = (int) (aClass_ra_Sub3_7894.aFloat8253 - class302_sub1.anInt7641 + aClass_ra_Sub3_7894.aFloat8329 * f_1456_ / f_1457_);
  5781. } else {
  5782. float f_1458_ = f_1444_ + class233.aFloatArray2594[0] * anInt7936 + class233.aFloatArray2594[12];
  5783. float f_1459_ = f_1447_ + class233.aFloatArray2594[3] * anInt7936 + class233.aFloatArray2594[15];
  5784. class302_sub1.anInt7645 = (int) (aClass_ra_Sub3_7894.aFloat8253 - class302_sub1.anInt7643 + aClass_ra_Sub3_7894.aFloat8329 * f_1458_ / f_1459_);
  5785. }
  5786. class302_sub1.aBoolean7644 = true;
  5787. }
  5788. }
  5789. aClass_ra_Sub3_7894.method5394(i);
  5790. method4843(class222);
  5791. aClass_ra_Sub3_7894.method5394(0);
  5792. class233_1423_.method2145(class222);
  5793. class233_1423_.method2144(aClass_ra_Sub3_7894.aClass233_8230);
  5794. method4849(class233_1423_);
  5795. }
  5796. }
  5797.  
  5798. @Override
  5799. public void method4740(Class222 class222, Class302_Sub1 class302_sub1, int i) {
  5800. if (aClass156_7966 != null) {
  5801. aClass156_7966.method1694();
  5802. }
  5803. if (anInt7906 != 0) {
  5804. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8246;
  5805. Class233 class233_1460_ = aClass_ra_Sub3_7894.aClass233_8236;
  5806. Class233 class233_1461_ = aClass_ra_Sub3_7894.aClass233_8204;
  5807. class233_1460_.method2145(class222);
  5808. class233_1461_.method2142(class233_1460_);
  5809. class233_1461_.method2144(aClass_ra_Sub3_7894.aClass233_8205);
  5810. if (!aBoolean7950) {
  5811. method4832();
  5812. }
  5813. float[] fs = aClass_ra_Sub3_7894.aFloatArray8312;
  5814. class233_1460_.method2149(0.0F, anInt7938, 0.0F, fs);
  5815. float f = fs[0];
  5816. float f_1462_ = fs[1];
  5817. float f_1463_ = fs[2];
  5818. class233_1460_.method2149(0.0F, anInt7939, 0.0F, fs);
  5819. float f_1464_ = fs[0];
  5820. float f_1465_ = fs[1];
  5821. float f_1466_ = fs[2];
  5822. for (int i_1467_ = 0; i_1467_ < 6; i_1467_++) {
  5823. float[] fs_1468_ = aClass_ra_Sub3_7894.aFloatArrayArray8252[i_1467_];
  5824. float f_1469_ = fs_1468_[0] * f + fs_1468_[1] * f_1462_ + fs_1468_[2] * f_1463_ + fs_1468_[3] + anInt7936;
  5825. float f_1470_ = fs_1468_[0] * f_1464_ + fs_1468_[1] * f_1465_ + fs_1468_[2] * f_1466_ + fs_1468_[3] + anInt7936;
  5826. if (f_1469_ < 0.0F && f_1470_ < 0.0F) {
  5827. return;
  5828. }
  5829. }
  5830. if (class302_sub1 != null) {
  5831. boolean bool = false;
  5832. boolean bool_1471_ = true;
  5833. int i_1472_ = anInt7940 + anInt7941 >> 1;
  5834. int i_1473_ = anInt7942 + anInt7943 >> 1;
  5835. int i_1474_ = i_1472_;
  5836. int i_1475_ = anInt7938;
  5837. int i_1476_ = i_1473_;
  5838. float f_1477_ = class233_1461_.aFloatArray2594[0] * i_1474_ + class233_1461_.aFloatArray2594[4] * i_1475_ + class233_1461_.aFloatArray2594[8] * i_1476_ + class233_1461_.aFloatArray2594[12];
  5839. float f_1478_ = class233_1461_.aFloatArray2594[1] * i_1474_ + class233_1461_.aFloatArray2594[5] * i_1475_ + class233_1461_.aFloatArray2594[9] * i_1476_ + class233_1461_.aFloatArray2594[13];
  5840. float f_1479_ = class233_1461_.aFloatArray2594[2] * i_1474_ + class233_1461_.aFloatArray2594[6] * i_1475_ + class233_1461_.aFloatArray2594[10] * i_1476_ + class233_1461_.aFloatArray2594[14];
  5841. float f_1480_ = class233_1461_.aFloatArray2594[3] * i_1474_ + class233_1461_.aFloatArray2594[7] * i_1475_ + class233_1461_.aFloatArray2594[11] * i_1476_ + class233_1461_.aFloatArray2594[15];
  5842. if (f_1479_ >= -f_1480_) {
  5843. class302_sub1.anInt7641 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1477_ / f_1480_);
  5844. class302_sub1.anInt7642 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1478_ / f_1480_);
  5845. } else {
  5846. bool = true;
  5847. }
  5848. i_1474_ = i_1472_;
  5849. i_1475_ = anInt7939;
  5850. i_1476_ = i_1473_;
  5851. float f_1481_ = class233_1461_.aFloatArray2594[0] * i_1474_ + class233_1461_.aFloatArray2594[4] * i_1475_ + class233_1461_.aFloatArray2594[8] * i_1476_ + class233_1461_.aFloatArray2594[12];
  5852. float f_1482_ = class233_1461_.aFloatArray2594[1] * i_1474_ + class233_1461_.aFloatArray2594[5] * i_1475_ + class233_1461_.aFloatArray2594[9] * i_1476_ + class233_1461_.aFloatArray2594[13];
  5853. float f_1483_ = class233_1461_.aFloatArray2594[2] * i_1474_ + class233_1461_.aFloatArray2594[6] * i_1475_ + class233_1461_.aFloatArray2594[10] * i_1476_ + class233_1461_.aFloatArray2594[14];
  5854. float f_1484_ = class233_1461_.aFloatArray2594[3] * i_1474_ + class233_1461_.aFloatArray2594[7] * i_1475_ + class233_1461_.aFloatArray2594[11] * i_1476_ + class233_1461_.aFloatArray2594[15];
  5855. if (f_1483_ >= -f_1484_) {
  5856. class302_sub1.anInt7643 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1481_ / f_1484_);
  5857. class302_sub1.anInt7640 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1482_ / f_1484_);
  5858. } else {
  5859. bool = true;
  5860. }
  5861. if (bool) {
  5862. if (f_1479_ < -f_1480_ && f_1483_ < -f_1484_) {
  5863. bool_1471_ = false;
  5864. } else if (f_1479_ < -f_1480_) {
  5865. float f_1485_ = (f_1479_ + f_1480_) / (f_1483_ + f_1484_) - 1.0F;
  5866. float f_1486_ = f_1477_ + f_1485_ * (f_1481_ - f_1477_);
  5867. float f_1487_ = f_1478_ + f_1485_ * (f_1482_ - f_1478_);
  5868. float f_1488_ = f_1480_ + f_1485_ * (f_1484_ - f_1480_);
  5869. class302_sub1.anInt7641 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1486_ / f_1488_);
  5870. class302_sub1.anInt7642 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1487_ / f_1488_);
  5871. } else if (f_1483_ < -f_1484_) {
  5872. float f_1489_ = (f_1483_ + f_1484_) / (f_1479_ + f_1480_) - 1.0F;
  5873. float f_1490_ = f_1481_ + f_1489_ * (f_1477_ - f_1481_);
  5874. float f_1491_ = f_1482_ + f_1489_ * (f_1478_ - f_1482_);
  5875. float f_1492_ = f_1484_ + f_1489_ * (f_1480_ - f_1484_);
  5876. class302_sub1.anInt7643 = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1490_ / f_1492_);
  5877. class302_sub1.anInt7640 = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1491_ / f_1492_);
  5878. }
  5879. }
  5880. if (bool_1471_) {
  5881. if (f_1479_ / f_1480_ > f_1483_ / f_1484_) {
  5882. float f_1493_ = f_1477_ + class233.aFloatArray2594[0] * anInt7936 + class233.aFloatArray2594[12];
  5883. float f_1494_ = f_1480_ + class233.aFloatArray2594[3] * anInt7936 + class233.aFloatArray2594[15];
  5884. class302_sub1.anInt7645 = (int) (aClass_ra_Sub3_7894.aFloat8253 - class302_sub1.anInt7641 + aClass_ra_Sub3_7894.aFloat8329 * f_1493_ / f_1494_);
  5885. } else {
  5886. float f_1495_ = f_1481_ + class233.aFloatArray2594[0] * anInt7936 + class233.aFloatArray2594[12];
  5887. float f_1496_ = f_1484_ + class233.aFloatArray2594[3] * anInt7936 + class233.aFloatArray2594[15];
  5888. class302_sub1.anInt7645 = (int) (aClass_ra_Sub3_7894.aFloat8253 - class302_sub1.anInt7643 + aClass_ra_Sub3_7894.aFloat8329 * f_1495_ / f_1496_);
  5889. }
  5890. class302_sub1.aBoolean7644 = true;
  5891. }
  5892. }
  5893. aClass_ra_Sub3_7894.method5394(i);
  5894. method4843(class222);
  5895. aClass_ra_Sub3_7894.method5394(0);
  5896. class233_1460_.method2145(class222);
  5897. class233_1460_.method2144(aClass_ra_Sub3_7894.aClass233_8230);
  5898. method4849(class233_1460_);
  5899. }
  5900. }
  5901.  
  5902. @Override
  5903. boolean ea() {
  5904. if (verticesByLabel == null) {
  5905. return false;
  5906. }
  5907. for (int i = 0; i < anInt7899; i++) {
  5908. vertices_x[i] <<= 4;
  5909. vertices_y[i] <<= 4;
  5910. vertices_z[i] <<= 4;
  5911. }
  5912. origin_x = 0;
  5913. origin_y = 0;
  5914. origin_z = 0;
  5915. return true;
  5916. }
  5917.  
  5918. @Override
  5919. public boolean method4746(int i, int i_1497_, Class222 class222, boolean bool, int i_1498_) {
  5920. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8236;
  5921. class233.method2145(class222);
  5922. class233.method2144(aClass_ra_Sub3_7894.aClass233_8205);
  5923. boolean bool_1499_ = false;
  5924. float f = 3.4028235E38F;
  5925. float f_1500_ = -3.4028235E38F;
  5926. float f_1501_ = 3.4028235E38F;
  5927. float f_1502_ = -3.4028235E38F;
  5928. if (!aBoolean7950) {
  5929. method4832();
  5930. }
  5931. int i_1503_ = anInt7941 - anInt7940 >> 1;
  5932. int i_1504_ = anInt7939 - anInt7938 >> 1;
  5933. int i_1505_ = anInt7943 - anInt7942 >> 1;
  5934. int i_1506_ = anInt7940 + i_1503_;
  5935. int i_1507_ = anInt7938 + i_1504_;
  5936. int i_1508_ = anInt7942 + i_1505_;
  5937. int i_1509_ = i_1506_ - (i_1503_ << i_1498_);
  5938. int i_1510_ = i_1507_ - (i_1504_ << i_1498_);
  5939. int i_1511_ = i_1508_ - (i_1505_ << i_1498_);
  5940. int i_1512_ = i_1506_ + (i_1503_ << i_1498_);
  5941. int i_1513_ = i_1507_ + (i_1504_ << i_1498_);
  5942. int i_1514_ = i_1508_ + (i_1505_ << i_1498_);
  5943. anIntArray7959[0] = i_1509_;
  5944. anIntArray7960[0] = i_1510_;
  5945. anIntArray7961[0] = i_1511_;
  5946. anIntArray7959[1] = i_1512_;
  5947. anIntArray7960[1] = i_1510_;
  5948. anIntArray7961[1] = i_1511_;
  5949. anIntArray7959[2] = i_1509_;
  5950. anIntArray7960[2] = i_1513_;
  5951. anIntArray7961[2] = i_1511_;
  5952. anIntArray7959[3] = i_1512_;
  5953. anIntArray7960[3] = i_1513_;
  5954. anIntArray7961[3] = i_1511_;
  5955. anIntArray7959[4] = i_1509_;
  5956. anIntArray7960[4] = i_1510_;
  5957. anIntArray7961[4] = i_1514_;
  5958. anIntArray7959[5] = i_1512_;
  5959. anIntArray7960[5] = i_1510_;
  5960. anIntArray7961[5] = i_1514_;
  5961. anIntArray7959[6] = i_1509_;
  5962. anIntArray7960[6] = i_1513_;
  5963. anIntArray7961[6] = i_1514_;
  5964. anIntArray7959[7] = i_1512_;
  5965. anIntArray7960[7] = i_1513_;
  5966. anIntArray7961[7] = i_1514_;
  5967. for (int i_1515_ = 0; i_1515_ < 8; i_1515_++) {
  5968. float f_1516_ = anIntArray7959[i_1515_];
  5969. float f_1517_ = anIntArray7960[i_1515_];
  5970. float f_1518_ = anIntArray7961[i_1515_];
  5971. float f_1519_ = class233.aFloatArray2594[2] * f_1516_ + class233.aFloatArray2594[6] * f_1517_ + class233.aFloatArray2594[10] * f_1518_ + class233.aFloatArray2594[14];
  5972. float f_1520_ = class233.aFloatArray2594[3] * f_1516_ + class233.aFloatArray2594[7] * f_1517_ + class233.aFloatArray2594[11] * f_1518_ + class233.aFloatArray2594[15];
  5973. if (f_1519_ >= -f_1520_) {
  5974. float f_1521_ = class233.aFloatArray2594[0] * f_1516_ + class233.aFloatArray2594[4] * f_1517_ + class233.aFloatArray2594[8] * f_1518_ + class233.aFloatArray2594[12];
  5975. float f_1522_ = class233.aFloatArray2594[1] * f_1516_ + class233.aFloatArray2594[5] * f_1517_ + class233.aFloatArray2594[9] * f_1518_ + class233.aFloatArray2594[13];
  5976. float f_1523_ = aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1521_ / f_1520_;
  5977. float f_1524_ = aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1522_ / f_1520_;
  5978. if (f_1523_ < f) {
  5979. f = f_1523_;
  5980. }
  5981. if (f_1523_ > f_1500_) {
  5982. f_1500_ = f_1523_;
  5983. }
  5984. if (f_1524_ < f_1501_) {
  5985. f_1501_ = f_1524_;
  5986. }
  5987. if (f_1524_ > f_1502_) {
  5988. f_1502_ = f_1524_;
  5989. }
  5990. bool_1499_ = true;
  5991. }
  5992. }
  5993. if (bool_1499_ && i > f && i < f_1500_ && i_1497_ > f_1501_ && i_1497_ < f_1502_) {
  5994. if (bool) {
  5995. return true;
  5996. }
  5997. if (anIntArray7933.length < anInt7906) {
  5998. anIntArray7933 = new int[anInt7906];
  5999. anIntArray7929 = new int[anInt7906];
  6000. }
  6001. for (int i_1525_ = 0; i_1525_ < anInt7900; i_1525_++) {
  6002. float f_1526_ = vertices_x[i_1525_];
  6003. float f_1527_ = vertices_y[i_1525_];
  6004. float f_1528_ = vertices_z[i_1525_];
  6005. float f_1529_ = class233.aFloatArray2594[2] * f_1526_ + class233.aFloatArray2594[6] * f_1527_ + class233.aFloatArray2594[10] * f_1528_ + class233.aFloatArray2594[14];
  6006. float f_1530_ = class233.aFloatArray2594[3] * f_1526_ + class233.aFloatArray2594[7] * f_1527_ + class233.aFloatArray2594[11] * f_1528_ + class233.aFloatArray2594[15];
  6007. if (f_1529_ >= -f_1530_) {
  6008. float f_1531_ = class233.aFloatArray2594[0] * f_1526_ + class233.aFloatArray2594[4] * f_1527_ + class233.aFloatArray2594[8] * f_1528_ + class233.aFloatArray2594[12];
  6009. float f_1532_ = class233.aFloatArray2594[1] * f_1526_ + class233.aFloatArray2594[5] * f_1527_ + class233.aFloatArray2594[9] * f_1528_ + class233.aFloatArray2594[13];
  6010. int i_1533_ = anIntArray7947[i_1525_];
  6011. int i_1534_ = anIntArray7947[i_1525_ + 1];
  6012. for (int i_1535_ = i_1533_; i_1535_ < i_1534_; i_1535_++) {
  6013. int i_1536_ = aShortArray7948[i_1535_] - 1;
  6014. if (i_1536_ == -1) {
  6015. break;
  6016. }
  6017. anIntArray7933[i_1536_] = (int) (aClass_ra_Sub3_7894.aFloat8253 + aClass_ra_Sub3_7894.aFloat8329 * f_1531_ / f_1530_);
  6018. anIntArray7929[i_1536_] = (int) (aClass_ra_Sub3_7894.aFloat8255 + aClass_ra_Sub3_7894.aFloat8256 * f_1532_ / f_1530_);
  6019. }
  6020. } else {
  6021. int i_1537_ = anIntArray7947[i_1525_];
  6022. int i_1538_ = anIntArray7947[i_1525_ + 1];
  6023. for (int i_1539_ = i_1537_; i_1539_ < i_1538_; i_1539_++) {
  6024. int i_1540_ = aShortArray7948[i_1539_] - 1;
  6025. if (i_1540_ == -1) {
  6026. break;
  6027. }
  6028. anIntArray7933[aShortArray7948[i_1539_] - 1] = -999999;
  6029. }
  6030. }
  6031. }
  6032. for (int i_1541_ = 0; i_1541_ < anInt7916; i_1541_++) {
  6033. if (anIntArray7933[aShortArray7920[i_1541_]] != -999999 && anIntArray7933[aShortArray7921[i_1541_]] != -999999 && anIntArray7933[aShortArray7922[i_1541_]] != -999999 && method4841(i, i_1497_, anIntArray7929[aShortArray7920[i_1541_]], anIntArray7929[aShortArray7921[i_1541_]], anIntArray7929[aShortArray7922[i_1541_]], anIntArray7933[aShortArray7920[i_1541_]], anIntArray7933[aShortArray7921[i_1541_]], anIntArray7933[aShortArray7922[i_1541_]])) {
  6034. return true;
  6035. }
  6036. }
  6037. }
  6038. return false;
  6039. }
  6040.  
  6041. @Override
  6042. public int ha() {
  6043. if (!aBoolean7950) {
  6044. method4832();
  6045. }
  6046. return anInt7943;
  6047. }
  6048.  
  6049. @Override
  6050. public Class85[] method4772() {
  6051. return aClass85Array7949;
  6052. }
  6053.  
  6054. @Override
  6055. public int RA() {
  6056. if (!aBoolean7950) {
  6057. method4832();
  6058. }
  6059. return anInt7940;
  6060. }
  6061.  
  6062. @Override
  6063. public int cu() {
  6064. if (!aBoolean7950) {
  6065. method4832();
  6066. }
  6067. return anInt7940;
  6068. }
  6069.  
  6070. @Override
  6071. public int ce() {
  6072. if (!aBoolean7950) {
  6073. method4832();
  6074. }
  6075. return anInt7928;
  6076. }
  6077.  
  6078. @Override
  6079. public int cb() {
  6080. if (!aBoolean7950) {
  6081. method4832();
  6082. }
  6083. return anInt7928;
  6084. }
  6085.  
  6086. @Override
  6087. void cl(int i, int[] is, int i_1542_, int i_1543_, int i_1544_, boolean bool, int i_1545_, int[] is_1546_) {
  6088. int i_1547_ = is.length;
  6089. if (i == 0) {
  6090. i_1542_ <<= 4;
  6091. i_1543_ <<= 4;
  6092. i_1544_ <<= 4;
  6093. int i_1548_ = 0;
  6094. origin_x = 0;
  6095. origin_y = 0;
  6096. origin_z = 0;
  6097. for (int i_1549_ = 0; i_1549_ < i_1547_; i_1549_++) {
  6098. int i_1550_ = is[i_1549_];
  6099. if (i_1550_ < verticesByLabel.length) {
  6100. int[] is_1551_ = verticesByLabel[i_1550_];
  6101. for (int i_1553_ : is_1551_) {
  6102. if (aShortArray7964 == null || (i_1545_ & aShortArray7964[i_1553_]) != 0) {
  6103. origin_x += vertices_x[i_1553_];
  6104. origin_y += vertices_y[i_1553_];
  6105. origin_z += vertices_z[i_1553_];
  6106. i_1548_++;
  6107. }
  6108. }
  6109. }
  6110. }
  6111. if (i_1548_ > 0) {
  6112. origin_x = origin_x / i_1548_ + i_1542_;
  6113. origin_y = origin_y / i_1548_ + i_1543_;
  6114. origin_z = origin_z / i_1548_ + i_1544_;
  6115. aBoolean7905 = true;
  6116. } else {
  6117. origin_x = i_1542_;
  6118. origin_y = i_1543_;
  6119. origin_z = i_1544_;
  6120. }
  6121. } else if (i == 1) {
  6122. if (is_1546_ != null) {
  6123. int i_1554_ = is_1546_[0] * i_1542_ + is_1546_[1] * i_1543_ + is_1546_[2] * i_1544_ + 8192 >> 14;
  6124. int i_1555_ = is_1546_[3] * i_1542_ + is_1546_[4] * i_1543_ + is_1546_[5] * i_1544_ + 8192 >> 14;
  6125. int i_1556_ = is_1546_[6] * i_1542_ + is_1546_[7] * i_1543_ + is_1546_[8] * i_1544_ + 8192 >> 14;
  6126. i_1542_ = i_1554_;
  6127. i_1543_ = i_1555_;
  6128. i_1544_ = i_1556_;
  6129. }
  6130. i_1542_ <<= 4;
  6131. i_1543_ <<= 4;
  6132. i_1544_ <<= 4;
  6133. for (int i_1557_ = 0; i_1557_ < i_1547_; i_1557_++) {
  6134. int i_1558_ = is[i_1557_];
  6135. if (i_1558_ < verticesByLabel.length) {
  6136. int[] is_1559_ = verticesByLabel[i_1558_];
  6137. for (int element : is_1559_) {
  6138. int i_1561_ = element;
  6139. if (aShortArray7964 == null || (i_1545_ & aShortArray7964[i_1561_]) != 0) {
  6140. vertices_x[i_1561_] += i_1542_;
  6141. vertices_y[i_1561_] += i_1543_;
  6142. vertices_z[i_1561_] += i_1544_;
  6143. }
  6144. }
  6145. }
  6146. }
  6147. } else if (i == 2) {
  6148. if (is_1546_ != null) {
  6149. int i_1562_ = is_1546_[9] << 4;
  6150. int i_1563_ = is_1546_[10] << 4;
  6151. int i_1564_ = is_1546_[11] << 4;
  6152. int i_1565_ = is_1546_[12] << 4;
  6153. int i_1566_ = is_1546_[13] << 4;
  6154. int i_1567_ = is_1546_[14] << 4;
  6155. if (aBoolean7905) {
  6156. int i_1568_ = is_1546_[0] * origin_x + is_1546_[3] * origin_y + is_1546_[6] * origin_z + 8192 >> 14;
  6157. int i_1569_ = is_1546_[1] * origin_x + is_1546_[4] * origin_y + is_1546_[7] * origin_z + 8192 >> 14;
  6158. int i_1570_ = is_1546_[2] * origin_x + is_1546_[5] * origin_y + is_1546_[8] * origin_z + 8192 >> 14;
  6159. i_1568_ += i_1565_;
  6160. i_1569_ += i_1566_;
  6161. i_1570_ += i_1567_;
  6162. origin_x = i_1568_;
  6163. origin_y = i_1569_;
  6164. origin_z = i_1570_;
  6165. aBoolean7905 = false;
  6166. }
  6167. int[] is_1571_ = new int[9];
  6168. int i_1572_ = Class220.anIntArray2474[i_1542_];
  6169. int i_1573_ = Class220.anIntArray2483[i_1542_];
  6170. int i_1574_ = Class220.anIntArray2474[i_1543_];
  6171. int i_1575_ = Class220.anIntArray2483[i_1543_];
  6172. int i_1576_ = Class220.anIntArray2474[i_1544_];
  6173. int i_1577_ = Class220.anIntArray2483[i_1544_];
  6174. int i_1578_ = i_1573_ * i_1576_ + 8192 >> 14;
  6175. int i_1579_ = i_1573_ * i_1577_ + 8192 >> 14;
  6176. is_1571_[0] = i_1574_ * i_1576_ + i_1575_ * i_1579_ + 8192 >> 14;
  6177. is_1571_[1] = -i_1574_ * i_1577_ + i_1575_ * i_1578_ + 8192 >> 14;
  6178. is_1571_[2] = i_1575_ * i_1572_ + 8192 >> 14;
  6179. is_1571_[3] = i_1572_ * i_1577_ + 8192 >> 14;
  6180. is_1571_[4] = i_1572_ * i_1576_ + 8192 >> 14;
  6181. is_1571_[5] = -i_1573_;
  6182. is_1571_[6] = -i_1575_ * i_1576_ + i_1574_ * i_1579_ + 8192 >> 14;
  6183. is_1571_[7] = i_1575_ * i_1577_ + i_1574_ * i_1578_ + 8192 >> 14;
  6184. is_1571_[8] = i_1574_ * i_1572_ + 8192 >> 14;
  6185. int i_1580_ = is_1571_[0] * -origin_x + is_1571_[1] * -origin_y + is_1571_[2] * -origin_z + 8192 >> 14;
  6186. int i_1581_ = is_1571_[3] * -origin_x + is_1571_[4] * -origin_y + is_1571_[5] * -origin_z + 8192 >> 14;
  6187. int i_1582_ = is_1571_[6] * -origin_x + is_1571_[7] * -origin_y + is_1571_[8] * -origin_z + 8192 >> 14;
  6188. int i_1583_ = i_1580_ + origin_x;
  6189. int i_1584_ = i_1581_ + origin_y;
  6190. int i_1585_ = i_1582_ + origin_z;
  6191. int[] is_1586_ = new int[9];
  6192. for (int i_1587_ = 0; i_1587_ < 3; i_1587_++) {
  6193. for (int i_1588_ = 0; i_1588_ < 3; i_1588_++) {
  6194. int i_1589_ = 0;
  6195. for (int i_1590_ = 0; i_1590_ < 3; i_1590_++) {
  6196. i_1589_ += is_1571_[i_1587_ * 3 + i_1590_] * is_1546_[i_1588_ * 3 + i_1590_];
  6197. }
  6198. is_1586_[i_1587_ * 3 + i_1588_] = i_1589_ + 8192 >> 14;
  6199. }
  6200. }
  6201. int i_1591_ = is_1571_[0] * i_1565_ + is_1571_[1] * i_1566_ + is_1571_[2] * i_1567_ + 8192 >> 14;
  6202. int i_1592_ = is_1571_[3] * i_1565_ + is_1571_[4] * i_1566_ + is_1571_[5] * i_1567_ + 8192 >> 14;
  6203. int i_1593_ = is_1571_[6] * i_1565_ + is_1571_[7] * i_1566_ + is_1571_[8] * i_1567_ + 8192 >> 14;
  6204. i_1591_ += i_1583_;
  6205. i_1592_ += i_1584_;
  6206. i_1593_ += i_1585_;
  6207. int[] is_1594_ = new int[9];
  6208. for (int i_1595_ = 0; i_1595_ < 3; i_1595_++) {
  6209. for (int i_1596_ = 0; i_1596_ < 3; i_1596_++) {
  6210. int i_1597_ = 0;
  6211. for (int i_1598_ = 0; i_1598_ < 3; i_1598_++) {
  6212. i_1597_ += is_1546_[i_1595_ * 3 + i_1598_] * is_1586_[i_1596_ + i_1598_ * 3];
  6213. }
  6214. is_1594_[i_1595_ * 3 + i_1596_] = i_1597_ + 8192 >> 14;
  6215. }
  6216. }
  6217. int i_1599_ = is_1546_[0] * i_1591_ + is_1546_[1] * i_1592_ + is_1546_[2] * i_1593_ + 8192 >> 14;
  6218. int i_1600_ = is_1546_[3] * i_1591_ + is_1546_[4] * i_1592_ + is_1546_[5] * i_1593_ + 8192 >> 14;
  6219. int i_1601_ = is_1546_[6] * i_1591_ + is_1546_[7] * i_1592_ + is_1546_[8] * i_1593_ + 8192 >> 14;
  6220. i_1599_ += i_1562_;
  6221. i_1600_ += i_1563_;
  6222. i_1601_ += i_1564_;
  6223. for (int i_1602_ = 0; i_1602_ < i_1547_; i_1602_++) {
  6224. int i_1603_ = is[i_1602_];
  6225. if (i_1603_ < verticesByLabel.length) {
  6226. int[] is_1604_ = verticesByLabel[i_1603_];
  6227. for (int element : is_1604_) {
  6228. int i_1606_ = element;
  6229. if (aShortArray7964 == null || (i_1545_ & aShortArray7964[i_1606_]) != 0) {
  6230. int i_1607_ = is_1594_[0] * vertices_x[i_1606_] + is_1594_[1] * vertices_y[i_1606_] + is_1594_[2] * vertices_z[i_1606_] + 8192 >> 14;
  6231. int i_1608_ = is_1594_[3] * vertices_x[i_1606_] + is_1594_[4] * vertices_y[i_1606_] + is_1594_[5] * vertices_z[i_1606_] + 8192 >> 14;
  6232. int i_1609_ = is_1594_[6] * vertices_x[i_1606_] + is_1594_[7] * vertices_y[i_1606_] + is_1594_[8] * vertices_z[i_1606_] + 8192 >> 14;
  6233. i_1607_ += i_1599_;
  6234. i_1608_ += i_1600_;
  6235. i_1609_ += i_1601_;
  6236. vertices_x[i_1606_] = i_1607_;
  6237. vertices_y[i_1606_] = i_1608_;
  6238. vertices_z[i_1606_] = i_1609_;
  6239. }
  6240. }
  6241. }
  6242. }
  6243. } else {
  6244. for (int i_1610_ = 0; i_1610_ < i_1547_; i_1610_++) {
  6245. int i_1611_ = is[i_1610_];
  6246. if (i_1611_ < verticesByLabel.length) {
  6247. int[] is_1612_ = verticesByLabel[i_1611_];
  6248. for (int element : is_1612_) {
  6249. int i_1614_ = element;
  6250. if (aShortArray7964 == null || (i_1545_ & aShortArray7964[i_1614_]) != 0) {
  6251. vertices_x[i_1614_] -= origin_x;
  6252. vertices_y[i_1614_] -= origin_y;
  6253. vertices_z[i_1614_] -= origin_z;
  6254. if (i_1544_ != 0) {
  6255. int i_1615_ = Class220.anIntArray2483[i_1544_];
  6256. int i_1616_ = Class220.anIntArray2474[i_1544_];
  6257. int i_1617_ = vertices_y[i_1614_] * i_1615_ + vertices_x[i_1614_] * i_1616_ + 16383 >> 14;
  6258. vertices_y[i_1614_] = vertices_y[i_1614_] * i_1616_ - vertices_x[i_1614_] * i_1615_ + 16383 >> 14;
  6259. vertices_x[i_1614_] = i_1617_;
  6260. }
  6261. if (i_1542_ != 0) {
  6262. int i_1618_ = Class220.anIntArray2483[i_1542_];
  6263. int i_1619_ = Class220.anIntArray2474[i_1542_];
  6264. int i_1620_ = vertices_y[i_1614_] * i_1619_ - vertices_z[i_1614_] * i_1618_ + 16383 >> 14;
  6265. vertices_z[i_1614_] = vertices_y[i_1614_] * i_1618_ + vertices_z[i_1614_] * i_1619_ + 16383 >> 14;
  6266. vertices_y[i_1614_] = i_1620_;
  6267. }
  6268. if (i_1543_ != 0) {
  6269. int i_1621_ = Class220.anIntArray2483[i_1543_];
  6270. int i_1622_ = Class220.anIntArray2474[i_1543_];
  6271. int i_1623_ = vertices_z[i_1614_] * i_1621_ + vertices_x[i_1614_] * i_1622_ + 16383 >> 14;
  6272. vertices_z[i_1614_] = vertices_z[i_1614_] * i_1622_ - vertices_x[i_1614_] * i_1621_ + 16383 >> 14;
  6273. vertices_x[i_1614_] = i_1623_;
  6274. }
  6275. vertices_x[i_1614_] += origin_x;
  6276. vertices_y[i_1614_] += origin_y;
  6277. vertices_z[i_1614_] += origin_z;
  6278. }
  6279. }
  6280. }
  6281. }
  6282. if (bool) {
  6283. for (int i_1624_ = 0; i_1624_ < i_1547_; i_1624_++) {
  6284. int i_1625_ = is[i_1624_];
  6285. if (i_1625_ < verticesByLabel.length) {
  6286. int[] is_1626_ = verticesByLabel[i_1625_];
  6287. for (int i_1628_ : is_1626_) {
  6288. if (aShortArray7964 == null || (i_1545_ & aShortArray7964[i_1628_]) != 0) {
  6289. int i_1629_ = anIntArray7947[i_1628_];
  6290. int i_1630_ = anIntArray7947[i_1628_ + 1];
  6291. for (int i_1631_ = i_1629_; i_1631_ < i_1630_; i_1631_++) {
  6292. int i_1632_ = aShortArray7948[i_1631_] - 1;
  6293. if (i_1632_ == -1) {
  6294. break;
  6295. }
  6296. if (i_1544_ != 0) {
  6297. int i_1633_ = Class220.anIntArray2483[i_1544_];
  6298. int i_1634_ = Class220.anIntArray2474[i_1544_];
  6299. int i_1635_ = aShortArray7910[i_1632_] * i_1633_ + aShortArray7909[i_1632_] * i_1634_ + 16383 >> 14;
  6300. aShortArray7910[i_1632_] = (short) (aShortArray7910[i_1632_] * i_1634_ - aShortArray7909[i_1632_] * i_1633_ + 16383 >> 14);
  6301. aShortArray7909[i_1632_] = (short) i_1635_;
  6302. }
  6303. if (i_1542_ != 0) {
  6304. int i_1636_ = Class220.anIntArray2483[i_1542_];
  6305. int i_1637_ = Class220.anIntArray2474[i_1542_];
  6306. int i_1638_ = aShortArray7910[i_1632_] * i_1637_ - aShortArray7919[i_1632_] * i_1636_ + 16383 >> 14;
  6307. aShortArray7919[i_1632_] = (short) (aShortArray7910[i_1632_] * i_1636_ + aShortArray7919[i_1632_] * i_1637_ + 16383 >> 14);
  6308. aShortArray7910[i_1632_] = (short) i_1638_;
  6309. }
  6310. if (i_1543_ != 0) {
  6311. int i_1639_ = Class220.anIntArray2483[i_1543_];
  6312. int i_1640_ = Class220.anIntArray2474[i_1543_];
  6313. int i_1641_ = aShortArray7919[i_1632_] * i_1639_ + aShortArray7909[i_1632_] * i_1640_ + 16383 >> 14;
  6314. aShortArray7919[i_1632_] = (short) (aShortArray7919[i_1632_] * i_1640_ - aShortArray7909[i_1632_] * i_1639_ + 16383 >> 14);
  6315. aShortArray7909[i_1632_] = (short) i_1641_;
  6316. }
  6317. }
  6318. }
  6319. }
  6320. }
  6321. }
  6322. method4839();
  6323. }
  6324. }
  6325. } else if (i == 3) {
  6326. if (is_1546_ != null) {
  6327. int i_1642_ = is_1546_[9] << 4;
  6328. int i_1643_ = is_1546_[10] << 4;
  6329. int i_1644_ = is_1546_[11] << 4;
  6330. int i_1645_ = is_1546_[12] << 4;
  6331. int i_1646_ = is_1546_[13] << 4;
  6332. int i_1647_ = is_1546_[14] << 4;
  6333. if (aBoolean7905) {
  6334. int i_1648_ = is_1546_[0] * origin_x + is_1546_[3] * origin_y + is_1546_[6] * origin_z + 8192 >> 14;
  6335. int i_1649_ = is_1546_[1] * origin_x + is_1546_[4] * origin_y + is_1546_[7] * origin_z + 8192 >> 14;
  6336. int i_1650_ = is_1546_[2] * origin_x + is_1546_[5] * origin_y + is_1546_[8] * origin_z + 8192 >> 14;
  6337. i_1648_ += i_1645_;
  6338. i_1649_ += i_1646_;
  6339. i_1650_ += i_1647_;
  6340. origin_x = i_1648_;
  6341. origin_y = i_1649_;
  6342. origin_z = i_1650_;
  6343. aBoolean7905 = false;
  6344. }
  6345. int i_1651_ = i_1542_ << 15 >> 7;
  6346. int i_1652_ = i_1543_ << 15 >> 7;
  6347. int i_1653_ = i_1544_ << 15 >> 7;
  6348. int i_1654_ = i_1651_ * -origin_x + 8192 >> 14;
  6349. int i_1655_ = i_1652_ * -origin_y + 8192 >> 14;
  6350. int i_1656_ = i_1653_ * -origin_z + 8192 >> 14;
  6351. int i_1657_ = i_1654_ + origin_x;
  6352. int i_1658_ = i_1655_ + origin_y;
  6353. int i_1659_ = i_1656_ + origin_z;
  6354. int[] is_1660_ = new int[9];
  6355. is_1660_[0] = i_1651_ * is_1546_[0] + 8192 >> 14;
  6356. is_1660_[1] = i_1651_ * is_1546_[3] + 8192 >> 14;
  6357. is_1660_[2] = i_1651_ * is_1546_[6] + 8192 >> 14;
  6358. is_1660_[3] = i_1652_ * is_1546_[1] + 8192 >> 14;
  6359. is_1660_[4] = i_1652_ * is_1546_[4] + 8192 >> 14;
  6360. is_1660_[5] = i_1652_ * is_1546_[7] + 8192 >> 14;
  6361. is_1660_[6] = i_1653_ * is_1546_[2] + 8192 >> 14;
  6362. is_1660_[7] = i_1653_ * is_1546_[5] + 8192 >> 14;
  6363. is_1660_[8] = i_1653_ * is_1546_[8] + 8192 >> 14;
  6364. int i_1661_ = i_1651_ * i_1645_ + 8192 >> 14;
  6365. int i_1662_ = i_1652_ * i_1646_ + 8192 >> 14;
  6366. int i_1663_ = i_1653_ * i_1647_ + 8192 >> 14;
  6367. i_1661_ += i_1657_;
  6368. i_1662_ += i_1658_;
  6369. i_1663_ += i_1659_;
  6370. int[] is_1664_ = new int[9];
  6371. for (int i_1665_ = 0; i_1665_ < 3; i_1665_++) {
  6372. for (int i_1666_ = 0; i_1666_ < 3; i_1666_++) {
  6373. int i_1667_ = 0;
  6374. for (int i_1668_ = 0; i_1668_ < 3; i_1668_++) {
  6375. i_1667_ += is_1546_[i_1665_ * 3 + i_1668_] * is_1660_[i_1666_ + i_1668_ * 3];
  6376. }
  6377. is_1664_[i_1665_ * 3 + i_1666_] = i_1667_ + 8192 >> 14;
  6378. }
  6379. }
  6380. int i_1669_ = is_1546_[0] * i_1661_ + is_1546_[1] * i_1662_ + is_1546_[2] * i_1663_ + 8192 >> 14;
  6381. int i_1670_ = is_1546_[3] * i_1661_ + is_1546_[4] * i_1662_ + is_1546_[5] * i_1663_ + 8192 >> 14;
  6382. int i_1671_ = is_1546_[6] * i_1661_ + is_1546_[7] * i_1662_ + is_1546_[8] * i_1663_ + 8192 >> 14;
  6383. i_1669_ += i_1642_;
  6384. i_1670_ += i_1643_;
  6385. i_1671_ += i_1644_;
  6386. for (int i_1672_ = 0; i_1672_ < i_1547_; i_1672_++) {
  6387. int i_1673_ = is[i_1672_];
  6388. if (i_1673_ < verticesByLabel.length) {
  6389. int[] is_1674_ = verticesByLabel[i_1673_];
  6390. for (int element : is_1674_) {
  6391. int i_1676_ = element;
  6392. if (aShortArray7964 == null || (i_1545_ & aShortArray7964[i_1676_]) != 0) {
  6393. int i_1677_ = is_1664_[0] * vertices_x[i_1676_] + is_1664_[1] * vertices_y[i_1676_] + is_1664_[2] * vertices_z[i_1676_] + 8192 >> 14;
  6394. int i_1678_ = is_1664_[3] * vertices_x[i_1676_] + is_1664_[4] * vertices_y[i_1676_] + is_1664_[5] * vertices_z[i_1676_] + 8192 >> 14;
  6395. int i_1679_ = is_1664_[6] * vertices_x[i_1676_] + is_1664_[7] * vertices_y[i_1676_] + is_1664_[8] * vertices_z[i_1676_] + 8192 >> 14;
  6396. i_1677_ += i_1669_;
  6397. i_1678_ += i_1670_;
  6398. i_1679_ += i_1671_;
  6399. vertices_x[i_1676_] = i_1677_;
  6400. vertices_y[i_1676_] = i_1678_;
  6401. vertices_z[i_1676_] = i_1679_;
  6402. }
  6403. }
  6404. }
  6405. }
  6406. } else {
  6407. for (int i_1680_ = 0; i_1680_ < i_1547_; i_1680_++) {
  6408. int i_1681_ = is[i_1680_];
  6409. if (i_1681_ < verticesByLabel.length) {
  6410. int[] is_1682_ = verticesByLabel[i_1681_];
  6411. for (int element : is_1682_) {
  6412. int i_1684_ = element;
  6413. if (aShortArray7964 == null || (i_1545_ & aShortArray7964[i_1684_]) != 0) {
  6414. vertices_x[i_1684_] -= origin_x;
  6415. vertices_y[i_1684_] -= origin_y;
  6416. vertices_z[i_1684_] -= origin_z;
  6417. vertices_x[i_1684_] = vertices_x[i_1684_] * i_1542_ >> 7;
  6418. vertices_y[i_1684_] = vertices_y[i_1684_] * i_1543_ >> 7;
  6419. vertices_z[i_1684_] = vertices_z[i_1684_] * i_1544_ >> 7;
  6420. vertices_x[i_1684_] += origin_x;
  6421. vertices_y[i_1684_] += origin_y;
  6422. vertices_z[i_1684_] += origin_z;
  6423. }
  6424. }
  6425. }
  6426. }
  6427. }
  6428. } else if (i == 5) {
  6429. if (anIntArrayArray7924 != null) {
  6430. boolean bool_1685_ = false;
  6431. for (int i_1686_ = 0; i_1686_ < i_1547_; i_1686_++) {
  6432. int i_1687_ = is[i_1686_];
  6433. if (i_1687_ < anIntArrayArray7924.length) {
  6434. int[] is_1688_ = anIntArrayArray7924[i_1687_];
  6435. for (int element : is_1688_) {
  6436. int i_1690_ = element;
  6437. if (aShortArray7925 == null || (i_1545_ & aShortArray7925[i_1690_]) != 0) {
  6438. int i_1691_ = (aByteArray7963[i_1690_] & 0xff) + i_1542_ * 8;
  6439. if (i_1691_ < 0) {
  6440. i_1691_ = 0;
  6441. } else if (i_1691_ > 255) {
  6442. i_1691_ = 255;
  6443. }
  6444. aByteArray7963[i_1690_] = (byte) i_1691_;
  6445. }
  6446. }
  6447. bool_1685_ = bool_1685_ | is_1688_.length > 0;
  6448. }
  6449. }
  6450. if (bool_1685_) {
  6451. if (aClass191Array7952 != null) {
  6452. for (int i_1692_ = 0; i_1692_ < anInt7951; i_1692_++) {
  6453. Class191 class191 = aClass191Array7952[i_1692_];
  6454. Class166 class166 = aClass166Array7892[i_1692_];
  6455. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  6456. }
  6457. }
  6458. method4838();
  6459. }
  6460. }
  6461. } else if (i == 7) {
  6462. if (anIntArrayArray7924 != null) {
  6463. boolean bool_1693_ = false;
  6464. for (int i_1694_ = 0; i_1694_ < i_1547_; i_1694_++) {
  6465. int i_1695_ = is[i_1694_];
  6466. if (i_1695_ < anIntArrayArray7924.length) {
  6467. int[] is_1696_ = anIntArrayArray7924[i_1695_];
  6468. for (int element : is_1696_) {
  6469. int i_1698_ = element;
  6470. if (aShortArray7925 == null || (i_1545_ & aShortArray7925[i_1698_]) != 0) {
  6471. int i_1699_ = aShortArray7935[i_1698_] & 0xffff;
  6472. int i_1700_ = i_1699_ >> 10 & 0x3f;
  6473. int i_1701_ = i_1699_ >> 7 & 0x7;
  6474. int i_1702_ = i_1699_ & 0x7f;
  6475. i_1700_ = i_1700_ + i_1542_ & 0x3f;
  6476. i_1701_ += i_1543_ / 4;
  6477. if (i_1701_ < 0) {
  6478. i_1701_ = 0;
  6479. } else if (i_1701_ > 7) {
  6480. i_1701_ = 7;
  6481. }
  6482. i_1702_ += i_1544_;
  6483. if (i_1702_ < 0) {
  6484. i_1702_ = 0;
  6485. } else if (i_1702_ > 127) {
  6486. i_1702_ = 127;
  6487. }
  6488. aShortArray7935[i_1698_] = (short) (i_1700_ << 10 | i_1701_ << 7 | i_1702_);
  6489. }
  6490. }
  6491. bool_1693_ = bool_1693_ | is_1696_.length > 0;
  6492. }
  6493. }
  6494. if (bool_1693_) {
  6495. if (aClass191Array7952 != null) {
  6496. for (int i_1703_ = 0; i_1703_ < anInt7951; i_1703_++) {
  6497. Class191 class191 = aClass191Array7952[i_1703_];
  6498. Class166 class166 = aClass166Array7892[i_1703_];
  6499. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  6500. }
  6501. }
  6502. method4838();
  6503. }
  6504. }
  6505. } else if (i == 8) {
  6506. if (anIntArrayArray7946 != null) {
  6507. for (int i_1704_ = 0; i_1704_ < i_1547_; i_1704_++) {
  6508. int i_1705_ = is[i_1704_];
  6509. if (i_1705_ < anIntArrayArray7946.length) {
  6510. int[] is_1706_ = anIntArrayArray7946[i_1705_];
  6511. for (int element : is_1706_) {
  6512. Class166 class166 = aClass166Array7892[element];
  6513. class166.anInt1704 += i_1542_;
  6514. class166.anInt1705 += i_1543_;
  6515. }
  6516. }
  6517. }
  6518. }
  6519. } else if (i == 10) {
  6520. if (anIntArrayArray7946 != null) {
  6521. for (int i_1708_ = 0; i_1708_ < i_1547_; i_1708_++) {
  6522. int i_1709_ = is[i_1708_];
  6523. if (i_1709_ < anIntArrayArray7946.length) {
  6524. int[] is_1710_ = anIntArrayArray7946[i_1709_];
  6525. for (int element : is_1710_) {
  6526. Class166 class166 = aClass166Array7892[element];
  6527. class166.anInt1702 = class166.anInt1702 * i_1542_ >> 7;
  6528. class166.anInt1701 = class166.anInt1701 * i_1543_ >> 7;
  6529. }
  6530. }
  6531. }
  6532. }
  6533. } else if (i == 9) {
  6534. if (anIntArrayArray7946 != null) {
  6535. for (int i_1712_ = 0; i_1712_ < i_1547_; i_1712_++) {
  6536. int i_1713_ = is[i_1712_];
  6537. if (i_1713_ < anIntArrayArray7946.length) {
  6538. int[] is_1714_ = anIntArrayArray7946[i_1713_];
  6539. for (int element : is_1714_) {
  6540. Class166 class166 = aClass166Array7892[element];
  6541. class166.anInt1706 = class166.anInt1706 + i_1542_ & 0x3fff;
  6542. }
  6543. }
  6544. }
  6545. }
  6546. }
  6547. }
  6548.  
  6549. @Override
  6550. public void method4783(Class222 class222) {
  6551. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8236;
  6552. class233.method2145(class222);
  6553. if (aClass85Array7949 != null) {
  6554. for (Class85 class85 : aClass85Array7949) {
  6555. Class85 class85_1716_ = class85;
  6556. if (class85.aClass85_776 != null) {
  6557. class85_1716_ = class85.aClass85_776;
  6558. }
  6559. class85_1716_.anInt777 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[4] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[8] * vertices_z[class85.anInt773 * -710317103])) * -1879868075;
  6560. class85_1716_.anInt783 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[5] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[9] * vertices_z[class85.anInt773 * -710317103])) * -2041556771;
  6561. class85_1716_.anInt779 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[6] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[10] * vertices_z[class85.anInt773 * -710317103])) * -1434499227;
  6562. class85_1716_.anInt772 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[4] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[8] * vertices_z[class85.anInt774 * 1705862021])) * 1070341177;
  6563. class85_1716_.anInt781 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[5] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[9] * vertices_z[class85.anInt774 * 1705862021])) * 1802851857;
  6564. class85_1716_.anInt782 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[6] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[10] * vertices_z[class85.anInt774 * 1705862021])) * 103846281;
  6565. class85_1716_.anInt771 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[4] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[8] * vertices_z[class85.anInt775 * 1636170731])) * -2103324039;
  6566. class85_1716_.anInt784 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[5] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[9] * vertices_z[class85.anInt775 * 1636170731])) * -526039059;
  6567. class85_1716_.anInt785 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[6] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[10] * vertices_z[class85.anInt775 * 1636170731])) * 491030489;
  6568. }
  6569. }
  6570. if (aClass68Array7904 != null) {
  6571. for (Class68 element : aClass68Array7904) {
  6572. Class68 class68 = element;
  6573. Class68 class68_1717_ = class68;
  6574. if (class68.aClass68_672 != null) {
  6575. class68_1717_ = class68.aClass68_672;
  6576. }
  6577. if (class68.aClass233_677 != null) {
  6578. class68.aClass233_677.method2142(class233);
  6579. } else {
  6580. class68.aClass233_677 = new Class233(class233);
  6581. }
  6582. class68_1717_.anInt671 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[4] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[8] * vertices_z[class68.anInt674 * -180596249])) * -1436341053;
  6583. class68_1717_.anInt675 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[5] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[9] * vertices_z[class68.anInt674 * -180596249])) * 449866009;
  6584. class68_1717_.anInt676 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[6] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[10] * vertices_z[class68.anInt674 * -180596249])) * 1336328763;
  6585. }
  6586. }
  6587. }
  6588.  
  6589. @Override
  6590. public void S(int i) {
  6591. int i_1718_ = Class220.anIntArray2483[i];
  6592. int i_1719_ = Class220.anIntArray2474[i];
  6593. for (int i_1720_ = 0; i_1720_ < anInt7900; i_1720_++) {
  6594. int i_1721_ = vertices_z[i_1720_] * i_1718_ + vertices_x[i_1720_] * i_1719_ >> 14;
  6595. vertices_z[i_1720_] = vertices_z[i_1720_] * i_1719_ - vertices_x[i_1720_] * i_1718_ >> 14;
  6596. vertices_x[i_1720_] = i_1721_;
  6597. }
  6598. for (int i_1722_ = 0; i_1722_ < anInt7906; i_1722_++) {
  6599. int i_1723_ = aShortArray7919[i_1722_] * i_1718_ + aShortArray7909[i_1722_] * i_1719_ >> 14;
  6600. aShortArray7919[i_1722_] = (short) (aShortArray7919[i_1722_] * i_1719_ - aShortArray7909[i_1722_] * i_1718_ >> 14);
  6601. aShortArray7909[i_1722_] = (short) i_1723_;
  6602. }
  6603. method4851();
  6604. method4839();
  6605. aBoolean7950 = false;
  6606. }
  6607.  
  6608. @Override
  6609. public Class387 method4749(byte i, int i_1724_, boolean bool) {
  6610. boolean bool_1725_ = false;
  6611. Class387_Sub3 class387_sub3_1726_;
  6612. Class387_Sub3 class387_sub3_1727_;
  6613. if (i > 0 && i <= 7) {
  6614. class387_sub3_1727_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8267[i - 1];
  6615. class387_sub3_1726_ = aClass_ra_Sub3_7894.aClass387_Sub3Array8288[i - 1];
  6616. bool_1725_ = true;
  6617. } else {
  6618. class387_sub3_1726_ = class387_sub3_1727_ = new Class387_Sub3(aClass_ra_Sub3_7894, 0, 0, true, false);
  6619. }
  6620. return method4836(class387_sub3_1726_, class387_sub3_1727_, i_1724_, bool_1725_, bool);
  6621. }
  6622.  
  6623. @Override
  6624. public int cf() {
  6625. if (!aBoolean7950) {
  6626. method4832();
  6627. }
  6628. return anInt7941;
  6629. }
  6630.  
  6631. @Override
  6632. public void KA(int i) {
  6633. if (aClass186_7927 != null) {
  6634. aClass186_7927.aBoolean1901 = Class154.method1685(i, anInt7896);
  6635. }
  6636. if (aClass186_7930 != null) {
  6637. aClass186_7930.aBoolean1901 = Class154.method1692(i, anInt7896);
  6638. }
  6639. if (aClass186_7911 != null) {
  6640. aClass186_7911.aBoolean1901 = Class154.method1680(i, anInt7896);
  6641. }
  6642. if (aClass186_7934 != null) {
  6643. aClass186_7934.aBoolean1901 = Class154.method1669(i, anInt7896);
  6644. }
  6645. anInt7912 = i;
  6646. if (aClass185_7915 != null && (anInt7912 & 0x10000) == 0) {
  6647. aShortArray7909 = aClass185_7915.aShortArray1899;
  6648. aShortArray7910 = aClass185_7915.aShortArray1897;
  6649. aShortArray7919 = aClass185_7915.aShortArray1896;
  6650. aByteArray7958 = aClass185_7915.aByteArray1898;
  6651. aClass185_7915 = null;
  6652. }
  6653. aBoolean7932 = true;
  6654. method4837();
  6655. }
  6656.  
  6657. @Override
  6658. public int dg() {
  6659. if (!aBoolean7950) {
  6660. method4832();
  6661. }
  6662. return anInt7942;
  6663. }
  6664.  
  6665. @Override
  6666. public int dl() {
  6667. if (!aBoolean7950) {
  6668. method4832();
  6669. }
  6670. return anInt7942;
  6671. }
  6672.  
  6673. @Override
  6674. public int ci() {
  6675. if (!aBoolean7950) {
  6676. method4832();
  6677. }
  6678. return anInt7928;
  6679. }
  6680.  
  6681. @Override
  6682. public int ds() {
  6683. if (!aBoolean7950) {
  6684. method4832();
  6685. }
  6686. return anInt7943;
  6687. }
  6688.  
  6689. @Override
  6690. public void bx(int i) {
  6691. int i_1728_ = Class220.anIntArray2483[i];
  6692. int i_1729_ = Class220.anIntArray2474[i];
  6693. for (int i_1730_ = 0; i_1730_ < anInt7900; i_1730_++) {
  6694. int i_1731_ = vertices_z[i_1730_] * i_1728_ + vertices_x[i_1730_] * i_1729_ >> 14;
  6695. vertices_z[i_1730_] = vertices_z[i_1730_] * i_1729_ - vertices_x[i_1730_] * i_1728_ >> 14;
  6696. vertices_x[i_1730_] = i_1731_;
  6697. }
  6698. for (int i_1732_ = 0; i_1732_ < anInt7906; i_1732_++) {
  6699. int i_1733_ = aShortArray7919[i_1732_] * i_1728_ + aShortArray7909[i_1732_] * i_1729_ >> 14;
  6700. aShortArray7919[i_1732_] = (short) (aShortArray7919[i_1732_] * i_1729_ - aShortArray7909[i_1732_] * i_1728_ >> 14);
  6701. aShortArray7909[i_1732_] = (short) i_1733_;
  6702. }
  6703. method4851();
  6704. method4839();
  6705. aBoolean7950 = false;
  6706. }
  6707.  
  6708. @Override
  6709. public void dd(int i) {
  6710. aShort7897 = (short) i;
  6711. method4838();
  6712. }
  6713.  
  6714. @Override
  6715. public void method4747(Class387 class387, int i, int i_1734_, int i_1735_, boolean bool) {
  6716. Class387_Sub3 class387_sub3_1736_ = (Class387_Sub3) class387;
  6717. if (anInt7916 != 0 && class387_sub3_1736_.anInt7916 != 0) {
  6718. int i_1737_ = class387_sub3_1736_.anInt7900;
  6719. int[] is = class387_sub3_1736_.vertices_x;
  6720. int[] is_1738_ = class387_sub3_1736_.vertices_y;
  6721. int[] is_1739_ = class387_sub3_1736_.vertices_z;
  6722. short[] is_1740_ = class387_sub3_1736_.aShortArray7909;
  6723. short[] is_1741_ = class387_sub3_1736_.aShortArray7910;
  6724. short[] is_1742_ = class387_sub3_1736_.aShortArray7919;
  6725. byte[] is_1743_ = class387_sub3_1736_.aByteArray7958;
  6726. short[] is_1744_;
  6727. short[] is_1745_;
  6728. short[] is_1746_;
  6729. byte[] is_1747_;
  6730. if (aClass185_7915 != null) {
  6731. is_1744_ = aClass185_7915.aShortArray1899;
  6732. is_1745_ = aClass185_7915.aShortArray1897;
  6733. is_1746_ = aClass185_7915.aShortArray1896;
  6734. is_1747_ = aClass185_7915.aByteArray1898;
  6735. } else {
  6736. is_1744_ = null;
  6737. is_1745_ = null;
  6738. is_1746_ = null;
  6739. is_1747_ = null;
  6740. }
  6741. short[] is_1748_;
  6742. short[] is_1749_;
  6743. short[] is_1750_;
  6744. byte[] is_1751_;
  6745. if (class387_sub3_1736_.aClass185_7915 != null) {
  6746. is_1748_ = class387_sub3_1736_.aClass185_7915.aShortArray1899;
  6747. is_1749_ = class387_sub3_1736_.aClass185_7915.aShortArray1897;
  6748. is_1750_ = class387_sub3_1736_.aClass185_7915.aShortArray1896;
  6749. is_1751_ = class387_sub3_1736_.aClass185_7915.aByteArray1898;
  6750. } else {
  6751. is_1748_ = null;
  6752. is_1749_ = null;
  6753. is_1750_ = null;
  6754. is_1751_ = null;
  6755. }
  6756. int[] is_1752_ = class387_sub3_1736_.anIntArray7947;
  6757. short[] is_1753_ = class387_sub3_1736_.aShortArray7948;
  6758. if (!class387_sub3_1736_.aBoolean7950) {
  6759. class387_sub3_1736_.method4832();
  6760. }
  6761. int i_1754_ = class387_sub3_1736_.anInt7938;
  6762. int i_1755_ = class387_sub3_1736_.anInt7939;
  6763. int i_1756_ = class387_sub3_1736_.anInt7940;
  6764. int i_1757_ = class387_sub3_1736_.anInt7941;
  6765. int i_1758_ = class387_sub3_1736_.anInt7942;
  6766. int i_1759_ = class387_sub3_1736_.anInt7943;
  6767. for (int i_1760_ = 0; i_1760_ < anInt7900; i_1760_++) {
  6768. int i_1761_ = vertices_y[i_1760_] - i_1734_;
  6769. if (i_1761_ >= i_1754_ && i_1761_ <= i_1755_) {
  6770. int i_1762_ = vertices_x[i_1760_] - i;
  6771. if (i_1762_ >= i_1756_ && i_1762_ <= i_1757_) {
  6772. int i_1763_ = vertices_z[i_1760_] - i_1735_;
  6773. if (i_1763_ >= i_1758_ && i_1763_ <= i_1759_) {
  6774. int i_1764_ = -1;
  6775. int i_1765_ = anIntArray7947[i_1760_];
  6776. int i_1766_ = anIntArray7947[i_1760_ + 1];
  6777. for (int i_1767_ = i_1765_; i_1767_ < i_1766_; i_1767_++) {
  6778. i_1764_ = aShortArray7948[i_1767_] - 1;
  6779. if (i_1764_ == -1 || aByteArray7958[i_1764_] != 0) {
  6780. break;
  6781. }
  6782. }
  6783. if (i_1764_ != -1) {
  6784. for (int i_1768_ = 0; i_1768_ < i_1737_; i_1768_++) {
  6785. if (i_1762_ == is[i_1768_] && i_1763_ == is_1739_[i_1768_] && i_1761_ == is_1738_[i_1768_]) {
  6786. int i_1769_ = -1;
  6787. i_1765_ = is_1752_[i_1768_];
  6788. i_1766_ = is_1752_[i_1768_ + 1];
  6789. for (int i_1770_ = i_1765_; i_1770_ < i_1766_; i_1770_++) {
  6790. i_1769_ = is_1753_[i_1770_] - 1;
  6791. if (i_1769_ == -1 || is_1743_[i_1769_] != 0) {
  6792. break;
  6793. }
  6794. }
  6795. if (i_1769_ != -1) {
  6796. if (is_1744_ == null) {
  6797. aClass185_7915 = new Class185();
  6798. is_1744_ = aClass185_7915.aShortArray1899 = Class378.method4670(aShortArray7909, (byte) -109);
  6799. is_1745_ = aClass185_7915.aShortArray1897 = Class378.method4670(aShortArray7910, (byte) -95);
  6800. is_1746_ = aClass185_7915.aShortArray1896 = Class378.method4670(aShortArray7919, (byte) -95);
  6801. is_1747_ = aClass185_7915.aByteArray1898 = Class409.method4978(aByteArray7958, 1194497584);
  6802. }
  6803. if (is_1748_ == null) {
  6804. Class185 class185 = class387_sub3_1736_.aClass185_7915 = new Class185();
  6805. is_1748_ = class185.aShortArray1899 = Class378.method4670(is_1740_, (byte) -48);
  6806. is_1749_ = class185.aShortArray1897 = Class378.method4670(is_1741_, (byte) -67);
  6807. is_1750_ = class185.aShortArray1896 = Class378.method4670(is_1742_, (byte) -93);
  6808. is_1751_ = class185.aByteArray1898 = Class409.method4978(is_1743_, 1194497584);
  6809. }
  6810. short i_1771_ = aShortArray7909[i_1764_];
  6811. short i_1772_ = aShortArray7910[i_1764_];
  6812. short i_1773_ = aShortArray7919[i_1764_];
  6813. byte i_1774_ = aByteArray7958[i_1764_];
  6814. i_1765_ = is_1752_[i_1768_];
  6815. i_1766_ = is_1752_[i_1768_ + 1];
  6816. for (int i_1775_ = i_1765_; i_1775_ < i_1766_; i_1775_++) {
  6817. int i_1776_ = is_1753_[i_1775_] - 1;
  6818. if (i_1776_ == -1) {
  6819. break;
  6820. }
  6821. if (is_1751_[i_1776_] != 0) {
  6822. is_1748_[i_1776_] += i_1771_;
  6823. is_1749_[i_1776_] += i_1772_;
  6824. is_1750_[i_1776_] += i_1773_;
  6825. is_1751_[i_1776_] += i_1774_;
  6826. }
  6827. }
  6828. i_1771_ = is_1740_[i_1769_];
  6829. i_1772_ = is_1741_[i_1769_];
  6830. i_1773_ = is_1742_[i_1769_];
  6831. i_1774_ = is_1743_[i_1769_];
  6832. i_1765_ = anIntArray7947[i_1760_];
  6833. i_1766_ = anIntArray7947[i_1760_ + 1];
  6834. for (int i_1777_ = i_1765_; i_1777_ < i_1766_; i_1777_++) {
  6835. int i_1778_ = aShortArray7948[i_1777_] - 1;
  6836. if (i_1778_ == -1) {
  6837. break;
  6838. }
  6839. if (is_1747_[i_1778_] != 0) {
  6840. is_1744_[i_1778_] += i_1771_;
  6841. is_1745_[i_1778_] += i_1772_;
  6842. is_1746_[i_1778_] += i_1773_;
  6843. is_1747_[i_1778_] += i_1774_;
  6844. }
  6845. }
  6846. class387_sub3_1736_.method4839();
  6847. method4839();
  6848. }
  6849. }
  6850. }
  6851. }
  6852. }
  6853. }
  6854. }
  6855. }
  6856. }
  6857. }
  6858.  
  6859. @Override
  6860. public void dc(int i) {
  6861. aShort7898 = (short) i;
  6862. method4851();
  6863. method4839();
  6864. }
  6865.  
  6866. @Override
  6867. public int dh() {
  6868. if (!aBoolean7950) {
  6869. method4832();
  6870. }
  6871. return anInt7938;
  6872. }
  6873.  
  6874. @Override
  6875. public int dn() {
  6876. return aShort7898;
  6877. }
  6878.  
  6879. @Override
  6880. public byte[] method_do() {
  6881. return aByteArray7963;
  6882. }
  6883.  
  6884. @Override
  6885. public void method4768(byte i, byte[] is) {
  6886. if (is == null) {
  6887. for (int i_1779_ = 0; i_1779_ < anInt7916; i_1779_++) {
  6888. aByteArray7963[i_1779_] = i;
  6889. }
  6890. } else {
  6891. for (int i_1780_ = 0; i_1780_ < anInt7916; i_1780_++) {
  6892. int i_1781_ = 255 - (255 - (is[i_1780_] & 0xff)) * (255 - (i & 0xff)) / 255;
  6893. aByteArray7963[i_1780_] = (byte) i_1781_;
  6894. }
  6895. }
  6896. method4838();
  6897. }
  6898.  
  6899. @Override
  6900. public void method4769(byte i, byte[] is) {
  6901. if (is == null) {
  6902. for (int i_1782_ = 0; i_1782_ < anInt7916; i_1782_++) {
  6903. aByteArray7963[i_1782_] = i;
  6904. }
  6905. } else {
  6906. for (int i_1783_ = 0; i_1783_ < anInt7916; i_1783_++) {
  6907. int i_1784_ = 255 - (255 - (is[i_1783_] & 0xff)) * (255 - (i & 0xff)) / 255;
  6908. aByteArray7963[i_1783_] = (byte) i_1784_;
  6909. }
  6910. }
  6911. method4838();
  6912. }
  6913.  
  6914. @Override
  6915. public void du(short i, short i_1785_) {
  6916. Interface_ma interface_ma = aClass_ra_Sub3_7894.anInterface_ma5299;
  6917. for (int i_1786_ = 0; i_1786_ < anInt7916; i_1786_++) {
  6918. if (aShortArray7923[i_1786_] == i) {
  6919. aShortArray7923[i_1786_] = i_1785_;
  6920. }
  6921. }
  6922. byte i_1787_ = 0;
  6923. byte i_1788_ = 0;
  6924. if (i != -1) {
  6925. Class53 class53 = interface_ma.method174(i & 0xffff, 536301787);
  6926. i_1787_ = class53.aByte533;
  6927. i_1788_ = class53.aByte534;
  6928. }
  6929. byte i_1789_ = 0;
  6930. byte i_1790_ = 0;
  6931. if (i_1785_ != -1) {
  6932. Class53 class53 = interface_ma.method174(i_1785_ & 0xffff, 696074580);
  6933. i_1789_ = class53.aByte533;
  6934. i_1790_ = class53.aByte534;
  6935. if (class53.aByte535 != 0 || class53.aByte509 != 0) {
  6936. aBoolean7903 = true;
  6937. }
  6938. }
  6939. if (i_1787_ != i_1789_ | i_1788_ != i_1790_) {
  6940. if (aClass191Array7952 != null) {
  6941. for (int i_1791_ = 0; i_1791_ < anInt7951; i_1791_++) {
  6942. Class191 class191 = aClass191Array7952[i_1791_];
  6943. Class166 class166 = aClass166Array7892[i_1791_];
  6944. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  6945. }
  6946. }
  6947. method4838();
  6948. }
  6949. }
  6950.  
  6951. @Override
  6952. public void dv(short i, short i_1792_) {
  6953. Interface_ma interface_ma = aClass_ra_Sub3_7894.anInterface_ma5299;
  6954. for (int i_1793_ = 0; i_1793_ < anInt7916; i_1793_++) {
  6955. if (aShortArray7923[i_1793_] == i) {
  6956. aShortArray7923[i_1793_] = i_1792_;
  6957. }
  6958. }
  6959. byte i_1794_ = 0;
  6960. byte i_1795_ = 0;
  6961. if (i != -1) {
  6962. Class53 class53 = interface_ma.method174(i & 0xffff, 1294573076);
  6963. i_1794_ = class53.aByte533;
  6964. i_1795_ = class53.aByte534;
  6965. }
  6966. byte i_1796_ = 0;
  6967. byte i_1797_ = 0;
  6968. if (i_1792_ != -1) {
  6969. Class53 class53 = interface_ma.method174(i_1792_ & 0xffff, 277630297);
  6970. i_1796_ = class53.aByte533;
  6971. i_1797_ = class53.aByte534;
  6972. if (class53.aByte535 != 0 || class53.aByte509 != 0) {
  6973. aBoolean7903 = true;
  6974. }
  6975. }
  6976. if (i_1794_ != i_1796_ | i_1795_ != i_1797_) {
  6977. if (aClass191Array7952 != null) {
  6978. for (int i_1798_ = 0; i_1798_ < anInt7951; i_1798_++) {
  6979. Class191 class191 = aClass191Array7952[i_1798_];
  6980. Class166 class166 = aClass166Array7892[i_1798_];
  6981. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  6982. }
  6983. }
  6984. method4838();
  6985. }
  6986. }
  6987.  
  6988. @Override
  6989. public void di(short i, short i_1799_) {
  6990. Interface_ma interface_ma = aClass_ra_Sub3_7894.anInterface_ma5299;
  6991. for (int i_1800_ = 0; i_1800_ < anInt7916; i_1800_++) {
  6992. if (aShortArray7923[i_1800_] == i) {
  6993. aShortArray7923[i_1800_] = i_1799_;
  6994. }
  6995. }
  6996. byte i_1801_ = 0;
  6997. byte i_1802_ = 0;
  6998. if (i != -1) {
  6999. Class53 class53 = interface_ma.method174(i & 0xffff, 1548685895);
  7000. i_1801_ = class53.aByte533;
  7001. i_1802_ = class53.aByte534;
  7002. }
  7003. byte i_1803_ = 0;
  7004. byte i_1804_ = 0;
  7005. if (i_1799_ != -1) {
  7006. Class53 class53 = interface_ma.method174(i_1799_ & 0xffff, 1149419492);
  7007. i_1803_ = class53.aByte533;
  7008. i_1804_ = class53.aByte534;
  7009. if (class53.aByte535 != 0 || class53.aByte509 != 0) {
  7010. aBoolean7903 = true;
  7011. }
  7012. }
  7013. if (i_1801_ != i_1803_ | i_1802_ != i_1804_) {
  7014. if (aClass191Array7952 != null) {
  7015. for (int i_1805_ = 0; i_1805_ < anInt7951; i_1805_++) {
  7016. Class191 class191 = aClass191Array7952[i_1805_];
  7017. Class166 class166 = aClass166Array7892[i_1805_];
  7018. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7019. }
  7020. }
  7021. method4838();
  7022. }
  7023. }
  7024.  
  7025. @Override
  7026. public void df(short i, short i_1806_) {
  7027. Interface_ma interface_ma = aClass_ra_Sub3_7894.anInterface_ma5299;
  7028. for (int i_1807_ = 0; i_1807_ < anInt7916; i_1807_++) {
  7029. if (aShortArray7923[i_1807_] == i) {
  7030. aShortArray7923[i_1807_] = i_1806_;
  7031. }
  7032. }
  7033. byte i_1808_ = 0;
  7034. byte i_1809_ = 0;
  7035. if (i != -1) {
  7036. Class53 class53 = interface_ma.method174(i & 0xffff, 1866757821);
  7037. i_1808_ = class53.aByte533;
  7038. i_1809_ = class53.aByte534;
  7039. }
  7040. byte i_1810_ = 0;
  7041. byte i_1811_ = 0;
  7042. if (i_1806_ != -1) {
  7043. Class53 class53 = interface_ma.method174(i_1806_ & 0xffff, 1664949994);
  7044. i_1810_ = class53.aByte533;
  7045. i_1811_ = class53.aByte534;
  7046. if (class53.aByte535 != 0 || class53.aByte509 != 0) {
  7047. aBoolean7903 = true;
  7048. }
  7049. }
  7050. if (i_1808_ != i_1810_ | i_1809_ != i_1811_) {
  7051. if (aClass191Array7952 != null) {
  7052. for (int i_1812_ = 0; i_1812_ < anInt7951; i_1812_++) {
  7053. Class191 class191 = aClass191Array7952[i_1812_];
  7054. Class166 class166 = aClass166Array7892[i_1812_];
  7055. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7056. }
  7057. }
  7058. method4838();
  7059. }
  7060. }
  7061.  
  7062. @Override
  7063. public int ec() {
  7064. if (!aBoolean7950) {
  7065. method4832();
  7066. }
  7067. return anInt7939;
  7068. }
  7069.  
  7070. @Override
  7071. public void dt(int i, int i_1813_, int i_1814_, int i_1815_) {
  7072. for (int i_1816_ = 0; i_1816_ < anInt7916; i_1816_++) {
  7073. int i_1817_ = aShortArray7935[i_1816_] & 0xffff;
  7074. int i_1818_ = i_1817_ >> 10 & 0x3f;
  7075. int i_1819_ = i_1817_ >> 7 & 0x7;
  7076. int i_1820_ = i_1817_ & 0x7f;
  7077. if (i != -1) {
  7078. i_1818_ += (i - i_1818_) * i_1815_ >> 7;
  7079. }
  7080. if (i_1813_ != -1) {
  7081. i_1819_ += (i_1813_ - i_1819_) * i_1815_ >> 7;
  7082. }
  7083. if (i_1814_ != -1) {
  7084. i_1820_ += (i_1814_ - i_1820_) * i_1815_ >> 7;
  7085. }
  7086. aShortArray7935[i_1816_] = (short) (i_1818_ << 10 | i_1819_ << 7 | i_1820_);
  7087. }
  7088. if (aClass191Array7952 != null) {
  7089. for (int i_1821_ = 0; i_1821_ < anInt7951; i_1821_++) {
  7090. Class191 class191 = aClass191Array7952[i_1821_];
  7091. Class166 class166 = aClass166Array7892[i_1821_];
  7092. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7093. }
  7094. }
  7095. method4838();
  7096. }
  7097.  
  7098. @Override
  7099. public boolean ev() {
  7100. return aBoolean7893;
  7101. }
  7102.  
  7103. @Override
  7104. public void dr(int i, int i_1822_, int i_1823_, int i_1824_) {
  7105. for (int i_1825_ = 0; i_1825_ < anInt7916; i_1825_++) {
  7106. int i_1826_ = aShortArray7935[i_1825_] & 0xffff;
  7107. int i_1827_ = i_1826_ >> 10 & 0x3f;
  7108. int i_1828_ = i_1826_ >> 7 & 0x7;
  7109. int i_1829_ = i_1826_ & 0x7f;
  7110. if (i != -1) {
  7111. i_1827_ += (i - i_1827_) * i_1824_ >> 7;
  7112. }
  7113. if (i_1822_ != -1) {
  7114. i_1828_ += (i_1822_ - i_1828_) * i_1824_ >> 7;
  7115. }
  7116. if (i_1823_ != -1) {
  7117. i_1829_ += (i_1823_ - i_1829_) * i_1824_ >> 7;
  7118. }
  7119. aShortArray7935[i_1825_] = (short) (i_1827_ << 10 | i_1828_ << 7 | i_1829_);
  7120. }
  7121. if (aClass191Array7952 != null) {
  7122. for (int i_1830_ = 0; i_1830_ < anInt7951; i_1830_++) {
  7123. Class191 class191 = aClass191Array7952[i_1830_];
  7124. Class166 class166 = aClass166Array7892[i_1830_];
  7125. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7126. }
  7127. }
  7128. method4838();
  7129. }
  7130.  
  7131. Class387_Sub3(Class_ra_Sub3 class_ra_sub3, Model class64, int i, int i_1831_, int i_1832_, int i_1833_) {
  7132. this(class_ra_sub3, i, i_1833_, true, false);
  7133. Interface_ma interface_ma = class_ra_sub3.anInterface_ma5299;
  7134. int[] is = new int[class64.numFaces];
  7135. anIntArray7947 = new int[class64.highestFaceIndex + 1];
  7136. for (int i_1834_ = 0; i_1834_ < class64.numFaces; i_1834_++) {
  7137. if (class64.facesType == null || class64.facesType[i_1834_] != 2) {
  7138. if (class64.facesMaterial != null && class64.facesMaterial[i_1834_] != -1) {
  7139. Class53 class53 = interface_ma.method174(class64.facesMaterial[i_1834_] & 0xffff, 854670928);
  7140. if (((anInt7896 & 0x40) == 0 || !class53.aBoolean524) && class53.aBoolean538) {
  7141. continue;
  7142. }
  7143. }
  7144. is[anInt7916++] = i_1834_;
  7145. anIntArray7947[class64.facesA[i_1834_]]++;
  7146. anIntArray7947[class64.facesB[i_1834_]]++;
  7147. anIntArray7947[class64.facesC[i_1834_]]++;
  7148. }
  7149. }
  7150. anInt7917 = anInt7916;
  7151. long[] ls = new long[anInt7916];
  7152. boolean bool = (anInt7912 & 0x100) != 0;
  7153. for (int i_1835_ = 0; i_1835_ < anInt7916; i_1835_++) {
  7154. int i_1836_ = is[i_1835_];
  7155. Class53 class53 = null;
  7156. int i_1837_ = 0;
  7157. int i_1838_ = 0;
  7158. int i_1839_ = 0;
  7159. int i_1840_ = 0;
  7160. if (class64.aClass84Array649 != null) {
  7161. boolean bool_1841_ = false;
  7162. for (Class84 class84 : class64.aClass84Array649) {
  7163. if (i_1836_ == class84.anInt767 * 1512514121) {
  7164. Class173 class173 = Class298.method2844(class84.anInt768 * 1834782277, 1266955447);
  7165. if (class173.aBoolean1757) {
  7166. bool_1841_ = true;
  7167. }
  7168. if (class173.anInt1751 * 39181267 != -1) {
  7169. Class53 class53_1843_ = interface_ma.method174(class173.anInt1751 * 39181267, 991625180);
  7170. if (class53_1843_.anInt528 * -2138060883 == 2) {
  7171. aBoolean7893 = true;
  7172. }
  7173. }
  7174. }
  7175. }
  7176. if (bool_1841_) {
  7177. ls[i_1835_] = 9223372036854775807L;
  7178. anInt7917--;
  7179. continue;
  7180. }
  7181. }
  7182. int i_1844_ = -1;
  7183. if (class64.facesMaterial != null) {
  7184. i_1844_ = class64.facesMaterial[i_1836_];
  7185. if (i_1844_ != -1) {
  7186. class53 = interface_ma.method174(i_1844_ & 0xffff, 1849620785);
  7187. if ((anInt7896 & 0x40) == 0 || !class53.aBoolean524) {
  7188. i_1839_ = class53.aByte529;
  7189. i_1840_ = class53.aByte536;
  7190. } else {
  7191. i_1844_ = -1;
  7192. class53 = null;
  7193. }
  7194. }
  7195. }
  7196. boolean bool_1845_ = class64.facesAlpha != null && class64.facesAlpha[i_1836_] != 0 || class53 != null && class53.anInt528 * -2138060883 != 0;
  7197. if ((bool || bool_1845_) && class64.facesPriority != null) {
  7198. i_1837_ += class64.facesPriority[i_1836_] << 17;
  7199. }
  7200. if (bool_1845_) {
  7201. i_1837_ += 65536;
  7202. }
  7203. i_1837_ += (i_1839_ & 0xff) << 8;
  7204. i_1837_ += i_1840_ & 0xff;
  7205. i_1838_ += (i_1844_ & 0xffff) << 16;
  7206. i_1838_ += i_1835_ & 0xffff;
  7207. ls[i_1835_] = ((long) i_1837_ << 32) + i_1838_;
  7208. aBoolean7893 |= bool_1845_;
  7209. Class387_Sub3 class387_sub3_1846_ = this;
  7210. class387_sub3_1846_.aBoolean7903 = class387_sub3_1846_.aBoolean7903 | (class53 != null && (class53.aByte535 != 0 || class53.aByte509 != 0));
  7211. }
  7212. Class277.method2598(ls, is, (byte) 8);
  7213. anInt7899 = class64.numVertices;
  7214. anInt7900 = class64.highestFaceIndex;
  7215. vertices_x = class64.verticesX;
  7216. vertices_y = class64.verticesY;
  7217. vertices_z = class64.verticesZ;
  7218. aShortArray7964 = class64.vertexDuplicates;
  7219. Class184[] class184s = new Class184[anInt7900];
  7220. aClass85Array7949 = class64.aClass85Array647;
  7221. aClass68Array7904 = class64.aClass68Array613;
  7222. if (class64.aClass84Array649 != null) {
  7223. anInt7951 = class64.aClass84Array649.length;
  7224. aClass191Array7952 = new Class191[anInt7951];
  7225. aClass166Array7892 = new Class166[anInt7951];
  7226. for (int i_1847_ = 0; i_1847_ < anInt7951; i_1847_++) {
  7227. Class84 class84 = class64.aClass84Array649[i_1847_];
  7228. Class173 class173 = Class298.method2844(class84.anInt768 * 1834782277, 1209275845);
  7229. int i_1848_ = -1;
  7230. for (int i_1849_ = 0; i_1849_ < anInt7916; i_1849_++) {
  7231. if (is[i_1849_] == class84.anInt767 * 1512514121) {
  7232. i_1848_ = i_1849_;
  7233. break;
  7234. }
  7235. }
  7236. int i_1850_ = Class294.anIntArray3165[class64.facesColour[class84.anInt767 * 1512514121] & 0xffff] & 0xffffff;
  7237. i_1850_ = i_1850_ | 255 - (class64.facesAlpha != null ? class64.facesAlpha[class84.anInt767 * 1512514121] : 0) << 24;
  7238. aClass191Array7952[i_1847_] = new Class191(i_1848_, class64.facesA[class84.anInt767 * 1512514121], class64.facesB[class84.anInt767 * 1512514121], class64.facesC[class84.anInt767 * 1512514121], class173.anInt1755 * 1951943953, class173.anInt1753 * 893949695, class173.anInt1751 * 39181267, class173.anInt1752 * -310074719, class173.anInt1754 * 1092922159, class173.aBoolean1757, class173.aBoolean1748, class84.anInt769 * 2010148771);
  7239. aClass166Array7892[i_1847_] = new Class166(i_1850_);
  7240. }
  7241. }
  7242. int i_1851_ = anInt7916 * 3;
  7243. aShortArray7907 = new short[i_1851_];
  7244. aShortArray7908 = new short[i_1851_];
  7245. aShortArray7909 = new short[i_1851_];
  7246. aShortArray7910 = new short[i_1851_];
  7247. aShortArray7919 = new short[i_1851_];
  7248. aByteArray7958 = new byte[i_1851_];
  7249. aFloatArray7953 = new float[i_1851_];
  7250. aFloatArray7914 = new float[i_1851_];
  7251. aShortArray7935 = new short[anInt7916];
  7252. aByteArray7963 = new byte[anInt7916];
  7253. aShortArray7920 = new short[anInt7916];
  7254. aShortArray7921 = new short[anInt7916];
  7255. aShortArray7922 = new short[anInt7916];
  7256. aShortArray7923 = new short[anInt7916];
  7257. if (class64.submeshes_lookup != null) {
  7258. aShortArray7925 = new short[anInt7916];
  7259. }
  7260. aShort7897 = (short) i_1831_;
  7261. aShort7898 = (short) i_1832_;
  7262. aShortArray7948 = new short[i_1851_];
  7263. aLongArray7955 = new long[i_1851_];
  7264. int i_1852_ = 0;
  7265. for (int i_1853_ = 0; i_1853_ < class64.highestFaceIndex; i_1853_++) {
  7266. int i_1854_ = anIntArray7947[i_1853_];
  7267. anIntArray7947[i_1853_] = i_1852_;
  7268. i_1852_ += i_1854_;
  7269. class184s[i_1853_] = new Class184();
  7270. }
  7271. anIntArray7947[class64.highestFaceIndex] = i_1852_;
  7272. Class76 class76 = method4785(class64, is, anInt7916);
  7273. Class189[] class189s = new Class189[class64.numFaces];
  7274. for (int i_1855_ = 0; i_1855_ < class64.numFaces; i_1855_++) {
  7275. short i_1856_ = class64.facesA[i_1855_];
  7276. short i_1857_ = class64.facesB[i_1855_];
  7277. short i_1858_ = class64.facesC[i_1855_];
  7278. int i_1859_ = vertices_x[i_1857_] - vertices_x[i_1856_];
  7279. int i_1860_ = vertices_y[i_1857_] - vertices_y[i_1856_];
  7280. int i_1861_ = vertices_z[i_1857_] - vertices_z[i_1856_];
  7281. int i_1862_ = vertices_x[i_1858_] - vertices_x[i_1856_];
  7282. int i_1863_ = vertices_y[i_1858_] - vertices_y[i_1856_];
  7283. int i_1864_ = vertices_z[i_1858_] - vertices_z[i_1856_];
  7284. int i_1865_ = i_1860_ * i_1864_ - i_1863_ * i_1861_;
  7285. int i_1866_ = i_1861_ * i_1862_ - i_1864_ * i_1859_;
  7286. int i_1867_;
  7287. for (i_1867_ = i_1859_ * i_1863_ - i_1862_ * i_1860_; i_1865_ > 8192 || i_1866_ > 8192 || i_1867_ > 8192 || i_1865_ < -8192 || i_1866_ < -8192 || i_1867_ < -8192; i_1867_ >>= 1) {
  7288. i_1865_ >>= 1;
  7289. i_1866_ >>= 1;
  7290. }
  7291. int i_1868_ = (int) Math.sqrt(i_1865_ * i_1865_ + i_1866_ * i_1866_ + i_1867_ * i_1867_);
  7292. if (i_1868_ <= 0) {
  7293. i_1868_ = 1;
  7294. }
  7295. i_1865_ = i_1865_ * 256 / i_1868_;
  7296. i_1866_ = i_1866_ * 256 / i_1868_;
  7297. i_1867_ = i_1867_ * 256 / i_1868_;
  7298. byte i_1869_ = class64.facesType == null ? (byte) 0 : class64.facesType[i_1855_];
  7299. if (i_1869_ == 0) {
  7300. Class184 class184 = class184s[i_1856_];
  7301. class184.anInt1894 += i_1865_;
  7302. class184.anInt1893 += i_1866_;
  7303. class184.anInt1892 += i_1867_;
  7304. class184.anInt1895++;
  7305. class184 = class184s[i_1857_];
  7306. class184.anInt1894 += i_1865_;
  7307. class184.anInt1893 += i_1866_;
  7308. class184.anInt1892 += i_1867_;
  7309. class184.anInt1895++;
  7310. class184 = class184s[i_1858_];
  7311. class184.anInt1894 += i_1865_;
  7312. class184.anInt1893 += i_1866_;
  7313. class184.anInt1892 += i_1867_;
  7314. class184.anInt1895++;
  7315. } else if (i_1869_ == 1) {
  7316. Class189 class189 = class189s[i_1855_] = new Class189();
  7317. class189.anInt1915 = i_1865_;
  7318. class189.anInt1916 = i_1866_;
  7319. class189.anInt1914 = i_1867_;
  7320. }
  7321. }
  7322. for (int i_1870_ = 0; i_1870_ < anInt7916; i_1870_++) {
  7323. int i_1871_ = is[i_1870_];
  7324. int i_1872_ = class64.facesColour[i_1871_] & 0xffff;
  7325. int i_1873_;
  7326. if (class64.facesTexture == null) {
  7327. i_1873_ = -1;
  7328. } else {
  7329. i_1873_ = class64.facesTexture[i_1871_];
  7330. }
  7331. int i_1874_;
  7332. if (class64.facesAlpha == null) {
  7333. i_1874_ = 0;
  7334. } else {
  7335. i_1874_ = class64.facesAlpha[i_1871_] & 0xff;
  7336. }
  7337. short i_1875_ = class64.facesMaterial == null ? (short) -1 : class64.facesMaterial[i_1871_];
  7338. if (i_1875_ != -1 && (anInt7896 & 0x40) != 0) {
  7339. Class53 class53 = interface_ma.method174(i_1875_ & 0xffff, 1230249869);
  7340. if (class53.aBoolean524) {
  7341. i_1875_ = (short) -1;
  7342. }
  7343. }
  7344. float f = 0.0F;
  7345. float f_1876_ = 0.0F;
  7346. float f_1877_ = 0.0F;
  7347. float f_1878_ = 0.0F;
  7348. float f_1879_ = 0.0F;
  7349. float f_1880_ = 0.0F;
  7350. int i_1881_ = 0;
  7351. int i_1882_ = 0;
  7352. int i_1883_ = 0;
  7353. if (i_1875_ != -1) {
  7354. if (i_1873_ == -1) {
  7355. f = 0.0F;
  7356. f_1876_ = 1.0F;
  7357. f_1877_ = 1.0F;
  7358. f_1878_ = 1.0F;
  7359. i_1881_ = 1;
  7360. f_1879_ = 0.0F;
  7361. f_1880_ = 0.0F;
  7362. i_1882_ = 2;
  7363. } else {
  7364. i_1873_ &= 0xff;
  7365. byte i_1884_ = class64.texturesMappingType[i_1873_];
  7366. if (i_1884_ == 0) {
  7367. short i_1885_ = class64.facesA[i_1871_];
  7368. short i_1886_ = class64.facesB[i_1871_];
  7369. short i_1887_ = class64.facesC[i_1871_];
  7370. short i_1888_ = class64.texturesMappingP[i_1873_];
  7371. short i_1889_ = class64.texturesMappingM[i_1873_];
  7372. short i_1890_ = class64.texturesMappingN[i_1873_];
  7373. float f_1891_ = class64.verticesX[i_1888_];
  7374. float f_1892_ = class64.verticesY[i_1888_];
  7375. float f_1893_ = class64.verticesZ[i_1888_];
  7376. float f_1894_ = class64.verticesX[i_1889_] - f_1891_;
  7377. float f_1895_ = class64.verticesY[i_1889_] - f_1892_;
  7378. float f_1896_ = class64.verticesZ[i_1889_] - f_1893_;
  7379. float f_1897_ = class64.verticesX[i_1890_] - f_1891_;
  7380. float f_1898_ = class64.verticesY[i_1890_] - f_1892_;
  7381. float f_1899_ = class64.verticesZ[i_1890_] - f_1893_;
  7382. float f_1900_ = class64.verticesX[i_1885_] - f_1891_;
  7383. float f_1901_ = class64.verticesY[i_1885_] - f_1892_;
  7384. float f_1902_ = class64.verticesZ[i_1885_] - f_1893_;
  7385. float f_1903_ = class64.verticesX[i_1886_] - f_1891_;
  7386. float f_1904_ = class64.verticesY[i_1886_] - f_1892_;
  7387. float f_1905_ = class64.verticesZ[i_1886_] - f_1893_;
  7388. float f_1906_ = class64.verticesX[i_1887_] - f_1891_;
  7389. float f_1907_ = class64.verticesY[i_1887_] - f_1892_;
  7390. float f_1908_ = class64.verticesZ[i_1887_] - f_1893_;
  7391. float f_1909_ = f_1895_ * f_1899_ - f_1896_ * f_1898_;
  7392. float f_1910_ = f_1896_ * f_1897_ - f_1894_ * f_1899_;
  7393. float f_1911_ = f_1894_ * f_1898_ - f_1895_ * f_1897_;
  7394. float f_1912_ = f_1898_ * f_1911_ - f_1899_ * f_1910_;
  7395. float f_1913_ = f_1899_ * f_1909_ - f_1897_ * f_1911_;
  7396. float f_1914_ = f_1897_ * f_1910_ - f_1898_ * f_1909_;
  7397. float f_1915_ = 1.0F / (f_1912_ * f_1894_ + f_1913_ * f_1895_ + f_1914_ * f_1896_);
  7398. f = (f_1912_ * f_1900_ + f_1913_ * f_1901_ + f_1914_ * f_1902_) * f_1915_;
  7399. f_1877_ = (f_1912_ * f_1903_ + f_1913_ * f_1904_ + f_1914_ * f_1905_) * f_1915_;
  7400. f_1879_ = (f_1912_ * f_1906_ + f_1913_ * f_1907_ + f_1914_ * f_1908_) * f_1915_;
  7401. f_1912_ = f_1895_ * f_1911_ - f_1896_ * f_1910_;
  7402. f_1913_ = f_1896_ * f_1909_ - f_1894_ * f_1911_;
  7403. f_1914_ = f_1894_ * f_1910_ - f_1895_ * f_1909_;
  7404. f_1915_ = 1.0F / (f_1912_ * f_1897_ + f_1913_ * f_1898_ + f_1914_ * f_1899_);
  7405. f_1876_ = (f_1912_ * f_1900_ + f_1913_ * f_1901_ + f_1914_ * f_1902_) * f_1915_;
  7406. f_1878_ = (f_1912_ * f_1903_ + f_1913_ * f_1904_ + f_1914_ * f_1905_) * f_1915_;
  7407. f_1880_ = (f_1912_ * f_1906_ + f_1913_ * f_1907_ + f_1914_ * f_1908_) * f_1915_;
  7408. } else {
  7409. short i_1916_ = class64.facesA[i_1871_];
  7410. short i_1917_ = class64.facesB[i_1871_];
  7411. short i_1918_ = class64.facesC[i_1871_];
  7412. int i_1919_ = class76.anIntArray713[i_1873_];
  7413. int i_1920_ = class76.anIntArray710[i_1873_];
  7414. int i_1921_ = class76.anIntArray709[i_1873_];
  7415. float[] fs = class76.aFloatArrayArray711[i_1873_];
  7416. byte i_1922_ = class64.textureDirection[i_1873_];
  7417. float f_1923_ = class64.textureSpeed[i_1873_] / 256.0F;
  7418. if (i_1884_ == 1) {
  7419. float f_1924_ = class64.textureScaleZ[i_1873_] / 1024.0F;
  7420. method4744(class64.verticesX[i_1916_], class64.verticesY[i_1916_], class64.verticesZ[i_1916_], i_1919_, i_1920_, i_1921_, fs, f_1924_, i_1922_, f_1923_, aFloatArray7962);
  7421. f = aFloatArray7962[0];
  7422. f_1876_ = aFloatArray7962[1];
  7423. method4744(class64.verticesX[i_1917_], class64.verticesY[i_1917_], class64.verticesZ[i_1917_], i_1919_, i_1920_, i_1921_, fs, f_1924_, i_1922_, f_1923_, aFloatArray7962);
  7424. f_1877_ = aFloatArray7962[0];
  7425. f_1878_ = aFloatArray7962[1];
  7426. method4744(class64.verticesX[i_1918_], class64.verticesY[i_1918_], class64.verticesZ[i_1918_], i_1919_, i_1920_, i_1921_, fs, f_1924_, i_1922_, f_1923_, aFloatArray7962);
  7427. f_1879_ = aFloatArray7962[0];
  7428. f_1880_ = aFloatArray7962[1];
  7429. float f_1925_ = f_1924_ / 2.0F;
  7430. if ((i_1922_ & 0x1) == 0) {
  7431. if (f_1877_ - f > f_1925_) {
  7432. f_1877_ -= f_1924_;
  7433. i_1881_ = 1;
  7434. } else if (f - f_1877_ > f_1925_) {
  7435. f_1877_ += f_1924_;
  7436. i_1881_ = 2;
  7437. }
  7438. if (f_1879_ - f > f_1925_) {
  7439. f_1879_ -= f_1924_;
  7440. i_1882_ = 1;
  7441. } else if (f - f_1879_ > f_1925_) {
  7442. f_1879_ += f_1924_;
  7443. i_1882_ = 2;
  7444. }
  7445. } else {
  7446. if (f_1878_ - f_1876_ > f_1925_) {
  7447. f_1878_ -= f_1924_;
  7448. i_1881_ = 1;
  7449. } else if (f_1876_ - f_1878_ > f_1925_) {
  7450. f_1878_ += f_1924_;
  7451. i_1881_ = 2;
  7452. }
  7453. if (f_1880_ - f_1876_ > f_1925_) {
  7454. f_1880_ -= f_1924_;
  7455. i_1882_ = 1;
  7456. } else if (f_1876_ - f_1880_ > f_1925_) {
  7457. f_1880_ += f_1924_;
  7458. i_1882_ = 2;
  7459. }
  7460. }
  7461. } else if (i_1884_ == 2) {
  7462. float f_1926_ = class64.textureTransU[i_1873_] / 256.0F;
  7463. float f_1927_ = class64.textureTransV[i_1873_] / 256.0F;
  7464. int i_1928_ = class64.verticesX[i_1917_] - class64.verticesX[i_1916_];
  7465. int i_1929_ = class64.verticesY[i_1917_] - class64.verticesY[i_1916_];
  7466. int i_1930_ = class64.verticesZ[i_1917_] - class64.verticesZ[i_1916_];
  7467. int i_1931_ = class64.verticesX[i_1918_] - class64.verticesX[i_1916_];
  7468. int i_1932_ = class64.verticesY[i_1918_] - class64.verticesY[i_1916_];
  7469. int i_1933_ = class64.verticesZ[i_1918_] - class64.verticesZ[i_1916_];
  7470. int i_1934_ = i_1929_ * i_1933_ - i_1932_ * i_1930_;
  7471. int i_1935_ = i_1930_ * i_1931_ - i_1933_ * i_1928_;
  7472. int i_1936_ = i_1928_ * i_1932_ - i_1931_ * i_1929_;
  7473. float f_1937_ = 64.0F / class64.textureScaleX[i_1873_];
  7474. float f_1938_ = 64.0F / class64.textureScaleY[i_1873_];
  7475. float f_1939_ = 64.0F / class64.textureScaleZ[i_1873_];
  7476. float f_1940_ = (i_1934_ * fs[0] + i_1935_ * fs[1] + i_1936_ * fs[2]) / f_1937_;
  7477. float f_1941_ = (i_1934_ * fs[3] + i_1935_ * fs[4] + i_1936_ * fs[5]) / f_1938_;
  7478. float f_1942_ = (i_1934_ * fs[6] + i_1935_ * fs[7] + i_1936_ * fs[8]) / f_1939_;
  7479. i_1883_ = method4729(f_1940_, f_1941_, f_1942_);
  7480. method4730(class64.verticesX[i_1916_], class64.verticesY[i_1916_], class64.verticesZ[i_1916_], i_1919_, i_1920_, i_1921_, i_1883_, fs, i_1922_, f_1923_, f_1926_, f_1927_, aFloatArray7962);
  7481. f = aFloatArray7962[0];
  7482. f_1876_ = aFloatArray7962[1];
  7483. method4730(class64.verticesX[i_1917_], class64.verticesY[i_1917_], class64.verticesZ[i_1917_], i_1919_, i_1920_, i_1921_, i_1883_, fs, i_1922_, f_1923_, f_1926_, f_1927_, aFloatArray7962);
  7484. f_1877_ = aFloatArray7962[0];
  7485. f_1878_ = aFloatArray7962[1];
  7486. method4730(class64.verticesX[i_1918_], class64.verticesY[i_1918_], class64.verticesZ[i_1918_], i_1919_, i_1920_, i_1921_, i_1883_, fs, i_1922_, f_1923_, f_1926_, f_1927_, aFloatArray7962);
  7487. f_1879_ = aFloatArray7962[0];
  7488. f_1880_ = aFloatArray7962[1];
  7489. } else if (i_1884_ == 3) {
  7490. method4780(class64.verticesX[i_1916_], class64.verticesY[i_1916_], class64.verticesZ[i_1916_], i_1919_, i_1920_, i_1921_, fs, i_1922_, f_1923_, aFloatArray7962);
  7491. f = aFloatArray7962[0];
  7492. f_1876_ = aFloatArray7962[1];
  7493. method4780(class64.verticesX[i_1917_], class64.verticesY[i_1917_], class64.verticesZ[i_1917_], i_1919_, i_1920_, i_1921_, fs, i_1922_, f_1923_, aFloatArray7962);
  7494. f_1877_ = aFloatArray7962[0];
  7495. f_1878_ = aFloatArray7962[1];
  7496. method4780(class64.verticesX[i_1918_], class64.verticesY[i_1918_], class64.verticesZ[i_1918_], i_1919_, i_1920_, i_1921_, fs, i_1922_, f_1923_, aFloatArray7962);
  7497. f_1879_ = aFloatArray7962[0];
  7498. f_1880_ = aFloatArray7962[1];
  7499. if ((i_1922_ & 0x1) == 0) {
  7500. if (f_1877_ - f > 0.5F) {
  7501. f_1877_--;
  7502. i_1881_ = 1;
  7503. } else if (f - f_1877_ > 0.5F) {
  7504. f_1877_++;
  7505. i_1881_ = 2;
  7506. }
  7507. if (f_1879_ - f > 0.5F) {
  7508. f_1879_--;
  7509. i_1882_ = 1;
  7510. } else if (f - f_1879_ > 0.5F) {
  7511. f_1879_++;
  7512. i_1882_ = 2;
  7513. }
  7514. } else {
  7515. if (f_1878_ - f_1876_ > 0.5F) {
  7516. f_1878_--;
  7517. i_1881_ = 1;
  7518. } else if (f_1876_ - f_1878_ > 0.5F) {
  7519. f_1878_++;
  7520. i_1881_ = 2;
  7521. }
  7522. if (f_1880_ - f_1876_ > 0.5F) {
  7523. f_1880_--;
  7524. i_1882_ = 1;
  7525. } else if (f_1876_ - f_1880_ > 0.5F) {
  7526. f_1880_++;
  7527. i_1882_ = 2;
  7528. }
  7529. }
  7530. }
  7531. }
  7532. }
  7533. }
  7534. byte i_1943_;
  7535. if (class64.facesType == null) {
  7536. i_1943_ = (byte) 0;
  7537. } else {
  7538. i_1943_ = class64.facesType[i_1871_];
  7539. }
  7540. if (i_1943_ == 0) {
  7541. long l = (i_1873_ << 2) + ((long) (i_1883_ << 24) + (long) (i_1872_ << 8) + i_1874_ << 32);
  7542. short i_1944_ = class64.facesA[i_1871_];
  7543. short i_1945_ = class64.facesB[i_1871_];
  7544. short i_1946_ = class64.facesC[i_1871_];
  7545. Class184 class184 = class184s[i_1944_];
  7546. aShortArray7920[i_1870_] = method4848(class64, i_1944_, i_1870_, l, class184.anInt1894, class184.anInt1893, class184.anInt1892, class184.anInt1895, f, f_1876_);
  7547. class184 = class184s[i_1945_];
  7548. aShortArray7921[i_1870_] = method4848(class64, i_1945_, i_1870_, l + i_1881_, class184.anInt1894, class184.anInt1893, class184.anInt1892, class184.anInt1895, f_1877_, f_1878_);
  7549. class184 = class184s[i_1946_];
  7550. aShortArray7922[i_1870_] = method4848(class64, i_1946_, i_1870_, l + i_1882_, class184.anInt1894, class184.anInt1893, class184.anInt1892, class184.anInt1895, f_1879_, f_1880_);
  7551. } else if (i_1943_ == 1) {
  7552. Class189 class189 = class189s[i_1871_];
  7553. long l = (i_1873_ << 2) + (class189.anInt1915 > 0 ? 1024 : 2048) + (class189.anInt1916 + 256 << 12) + (class189.anInt1914 + 256 << 22) + ((long) (i_1883_ << 24) + (long) (i_1872_ << 8) + i_1874_ << 32);
  7554. aShortArray7920[i_1870_] = method4848(class64, class64.facesA[i_1871_], i_1870_, l, class189.anInt1915, class189.anInt1916, class189.anInt1914, 0, f, f_1876_);
  7555. aShortArray7921[i_1870_] = method4848(class64, class64.facesB[i_1871_], i_1870_, l + i_1881_, class189.anInt1915, class189.anInt1916, class189.anInt1914, 0, f_1877_, f_1878_);
  7556. aShortArray7922[i_1870_] = method4848(class64, class64.facesC[i_1871_], i_1870_, l + i_1882_, class189.anInt1915, class189.anInt1916, class189.anInt1914, 0, f_1879_, f_1880_);
  7557. }
  7558. if (class64.facesAlpha != null) {
  7559. aByteArray7963[i_1870_] = class64.facesAlpha[i_1871_];
  7560. }
  7561. if (class64.submeshes_lookup != null) {
  7562. aShortArray7925[i_1870_] = class64.submeshes_lookup[i_1871_];
  7563. }
  7564. aShortArray7935[i_1870_] = class64.facesColour[i_1871_];
  7565. aShortArray7923[i_1870_] = i_1875_;
  7566. }
  7567. if (anInt7917 > 0) {
  7568. int i_1947_ = 1;
  7569. short i_1948_ = aShortArray7923[0];
  7570. for (int i_1949_ = 0; i_1949_ < anInt7917; i_1949_++) {
  7571. short i_1950_ = aShortArray7923[i_1949_];
  7572. if (i_1950_ != i_1948_) {
  7573. i_1947_++;
  7574. i_1948_ = i_1950_;
  7575. }
  7576. }
  7577. anIntArray7945 = new int[i_1947_];
  7578. anIntArray7913 = new int[i_1947_];
  7579. anIntArray7944 = new int[i_1947_ + 1];
  7580. anIntArray7944[0] = 0;
  7581. int i_1951_ = anInt7906;
  7582. int i_1952_ = 0;
  7583. i_1947_ = 0;
  7584. i_1948_ = aShortArray7923[0];
  7585. for (int i_1953_ = 0; i_1953_ < anInt7917; i_1953_++) {
  7586. short i_1954_ = aShortArray7923[i_1953_];
  7587. if (i_1954_ != i_1948_) {
  7588. anIntArray7945[i_1947_] = i_1951_;
  7589. anIntArray7913[i_1947_] = i_1952_ - i_1951_ + 1;
  7590. anIntArray7944[++i_1947_] = i_1953_;
  7591. i_1951_ = anInt7906;
  7592. i_1952_ = 0;
  7593. i_1948_ = i_1954_;
  7594. }
  7595. int i_1955_ = aShortArray7920[i_1953_];
  7596. if (i_1955_ < i_1951_) {
  7597. i_1951_ = i_1955_;
  7598. }
  7599. if (i_1955_ > i_1952_) {
  7600. i_1952_ = i_1955_;
  7601. }
  7602. i_1955_ = aShortArray7921[i_1953_];
  7603. if (i_1955_ < i_1951_) {
  7604. i_1951_ = i_1955_;
  7605. }
  7606. if (i_1955_ > i_1952_) {
  7607. i_1952_ = i_1955_;
  7608. }
  7609. i_1955_ = aShortArray7922[i_1953_];
  7610. if (i_1955_ < i_1951_) {
  7611. i_1951_ = i_1955_;
  7612. }
  7613. if (i_1955_ > i_1952_) {
  7614. i_1952_ = i_1955_;
  7615. }
  7616. }
  7617. anIntArray7945[i_1947_] = i_1951_;
  7618. anIntArray7913[i_1947_] = i_1952_ - i_1951_ + 1;
  7619. anIntArray7944[++i_1947_] = anInt7917;
  7620. }
  7621. aLongArray7955 = null;
  7622. aShortArray7907 = method4834(aShortArray7907, anInt7906);
  7623. aShortArray7908 = method4834(aShortArray7908, anInt7906);
  7624. aShortArray7909 = method4834(aShortArray7909, anInt7906);
  7625. aShortArray7910 = method4834(aShortArray7910, anInt7906);
  7626. aShortArray7919 = method4834(aShortArray7919, anInt7906);
  7627. aByteArray7958 = method4833(aByteArray7958, anInt7906);
  7628. aFloatArray7953 = method4847(aFloatArray7953, anInt7906);
  7629. aFloatArray7914 = method4847(aFloatArray7914, anInt7906);
  7630. if (class64.verticesSkin != null && Class154.method1678(i, anInt7896)) {
  7631. verticesByLabel = class64.method749(false);
  7632. }
  7633. if (class64.aClass84Array649 != null && Class154.method1679(i, anInt7896)) {
  7634. anIntArrayArray7946 = class64.method759();
  7635. }
  7636. if (class64.facesSkin != null && Class154.method1677(i, anInt7896)) {
  7637. int i_1956_ = 0;
  7638. int[] is_1957_ = new int[256];
  7639. for (int i_1958_ = 0; i_1958_ < anInt7916; i_1958_++) {
  7640. int i_1959_ = class64.facesSkin[is[i_1958_]];
  7641. if (i_1959_ >= 0) {
  7642. is_1957_[i_1959_]++;
  7643. if (i_1959_ > i_1956_) {
  7644. i_1956_ = i_1959_;
  7645. }
  7646. }
  7647. }
  7648. anIntArrayArray7924 = new int[i_1956_ + 1][];
  7649. for (int i_1960_ = 0; i_1960_ <= i_1956_; i_1960_++) {
  7650. anIntArrayArray7924[i_1960_] = new int[is_1957_[i_1960_]];
  7651. is_1957_[i_1960_] = 0;
  7652. }
  7653. for (int i_1961_ = 0; i_1961_ < anInt7916; i_1961_++) {
  7654. int i_1962_ = class64.facesSkin[is[i_1961_]];
  7655. if (i_1962_ >= 0) {
  7656. anIntArrayArray7924[i_1962_][is_1957_[i_1962_]++] = i_1961_;
  7657. }
  7658. }
  7659. }
  7660. }
  7661.  
  7662. @Override
  7663. public Class68[] method4773() {
  7664. return aClass68Array7904;
  7665. }
  7666.  
  7667. @Override
  7668. public Class68[] method4774() {
  7669. return aClass68Array7904;
  7670. }
  7671.  
  7672. @Override
  7673. boolean bj() {
  7674. if (verticesByLabel == null) {
  7675. return false;
  7676. }
  7677. for (int i = 0; i < anInt7899; i++) {
  7678. vertices_x[i] <<= 4;
  7679. vertices_y[i] <<= 4;
  7680. vertices_z[i] <<= 4;
  7681. }
  7682. origin_x = 0;
  7683. origin_y = 0;
  7684. origin_z = 0;
  7685. return true;
  7686. }
  7687.  
  7688. @Override
  7689. public boolean ex() {
  7690. return aBoolean7903;
  7691. }
  7692.  
  7693. @Override
  7694. public Class_na ga(Class_na class_na) {
  7695. if (anInt7906 == 0) {
  7696. return null;
  7697. }
  7698. if (!aBoolean7950) {
  7699. method4832();
  7700. }
  7701. int i;
  7702. int i_1963_;
  7703. if (aClass_ra_Sub3_7894.anInt8299 > 0) {
  7704. i = anInt7940 - (anInt7939 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7705. i_1963_ = anInt7941 - (anInt7938 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7706. } else {
  7707. i = anInt7940 - (anInt7938 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7708. i_1963_ = anInt7941 - (anInt7939 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7709. }
  7710. int i_1964_;
  7711. int i_1965_;
  7712. if (aClass_ra_Sub3_7894.anInt8317 > 0) {
  7713. i_1964_ = anInt7942 - (anInt7939 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7714. i_1965_ = anInt7943 - (anInt7938 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7715. } else {
  7716. i_1964_ = anInt7942 - (anInt7938 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7717. i_1965_ = anInt7943 - (anInt7939 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  7718. }
  7719. int i_1966_ = i_1963_ - i + 1;
  7720. int i_1967_ = i_1965_ - i_1964_ + 1;
  7721. Class_na_Sub2 class_na_sub2 = (Class_na_Sub2) class_na;
  7722. Class_na_Sub2 class_na_sub2_1968_;
  7723. if (class_na_sub2 != null && class_na_sub2.method3489(i_1966_, i_1967_)) {
  7724. class_na_sub2_1968_ = class_na_sub2;
  7725. class_na_sub2_1968_.method3487();
  7726. } else {
  7727. class_na_sub2_1968_ = new Class_na_Sub2(aClass_ra_Sub3_7894, i_1966_, i_1967_);
  7728. }
  7729. class_na_sub2_1968_.method3486(i, i_1964_, i_1963_, i_1965_);
  7730. method4842(class_na_sub2_1968_);
  7731. return class_na_sub2_1968_;
  7732. }
  7733.  
  7734. @Override
  7735. public boolean method4777() {
  7736. if (aShortArray7923 == null) {
  7737. return true;
  7738. }
  7739. for (short element : aShortArray7923) {
  7740. if (element != -1 && !aClass_ra_Sub3_7894.anInterface_ma5299.method170(element, (short) 24767)) {
  7741. return false;
  7742. }
  7743. }
  7744. return true;
  7745. }
  7746.  
  7747. @Override
  7748. public boolean method4778() {
  7749. if (aShortArray7923 == null) {
  7750. return true;
  7751. }
  7752. for (short element : aShortArray7923) {
  7753. if (element != -1 && !aClass_ra_Sub3_7894.anInterface_ma5299.method170(element, (short) 4712)) {
  7754. return false;
  7755. }
  7756. }
  7757. return true;
  7758. }
  7759.  
  7760. @Override
  7761. public boolean eg() {
  7762. return aBoolean7903;
  7763. }
  7764.  
  7765. @Override
  7766. public int N() {
  7767. if (!aBoolean7950) {
  7768. method4832();
  7769. }
  7770. return anInt7936;
  7771. }
  7772.  
  7773. @Override
  7774. public boolean ek() {
  7775. return aBoolean7903;
  7776. }
  7777.  
  7778. @Override
  7779. public void em() {
  7780. for (int i = 0; i < anInt7900; i++) {
  7781. vertices_z[i] = -vertices_z[i];
  7782. }
  7783. for (int i = 0; i < anInt7906; i++) {
  7784. aShortArray7919[i] = (short) -aShortArray7919[i];
  7785. }
  7786. for (int i = 0; i < anInt7916; i++) {
  7787. short i_1969_ = aShortArray7920[i];
  7788. aShortArray7920[i] = aShortArray7922[i];
  7789. aShortArray7922[i] = i_1969_;
  7790. }
  7791. method4851();
  7792. method4839();
  7793. method4840();
  7794. aBoolean7950 = false;
  7795. }
  7796.  
  7797. @Override
  7798. public void bm(int i) {
  7799. int i_1970_ = Class220.anIntArray2483[i];
  7800. int i_1971_ = Class220.anIntArray2474[i];
  7801. for (int i_1972_ = 0; i_1972_ < anInt7900; i_1972_++) {
  7802. int i_1973_ = vertices_z[i_1972_] * i_1970_ + vertices_x[i_1972_] * i_1971_ >> 14;
  7803. vertices_z[i_1972_] = vertices_z[i_1972_] * i_1971_ - vertices_x[i_1972_] * i_1970_ >> 14;
  7804. vertices_x[i_1972_] = i_1973_;
  7805. }
  7806. for (int i_1974_ = 0; i_1974_ < anInt7906; i_1974_++) {
  7807. int i_1975_ = aShortArray7919[i_1974_] * i_1970_ + aShortArray7909[i_1974_] * i_1971_ >> 14;
  7808. aShortArray7919[i_1974_] = (short) (aShortArray7919[i_1974_] * i_1971_ - aShortArray7909[i_1974_] * i_1970_ >> 14);
  7809. aShortArray7909[i_1974_] = (short) i_1975_;
  7810. }
  7811. method4851();
  7812. method4839();
  7813. aBoolean7950 = false;
  7814. }
  7815.  
  7816. @Override
  7817. public void eb(short i, short i_1976_) {
  7818. for (int i_1977_ = 0; i_1977_ < anInt7916; i_1977_++) {
  7819. if (aShortArray7935[i_1977_] == i) {
  7820. aShortArray7935[i_1977_] = i_1976_;
  7821. }
  7822. }
  7823. if (aClass191Array7952 != null) {
  7824. for (int i_1978_ = 0; i_1978_ < anInt7951; i_1978_++) {
  7825. Class191 class191 = aClass191Array7952[i_1978_];
  7826. Class166 class166 = aClass166Array7892[i_1978_];
  7827. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7828. }
  7829. }
  7830. method4838();
  7831. }
  7832.  
  7833. @Override
  7834. public void ey(short i, short i_1979_) {
  7835. for (int i_1980_ = 0; i_1980_ < anInt7916; i_1980_++) {
  7836. if (aShortArray7935[i_1980_] == i) {
  7837. aShortArray7935[i_1980_] = i_1979_;
  7838. }
  7839. }
  7840. if (aClass191Array7952 != null) {
  7841. for (int i_1981_ = 0; i_1981_ < anInt7951; i_1981_++) {
  7842. Class191 class191 = aClass191Array7952[i_1981_];
  7843. Class166 class166 = aClass166Array7892[i_1981_];
  7844. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7845. }
  7846. }
  7847. method4838();
  7848. }
  7849.  
  7850. @Override
  7851. public void method4782(Class222 class222) {
  7852. Class233 class233 = aClass_ra_Sub3_7894.aClass233_8236;
  7853. class233.method2145(class222);
  7854. if (aClass85Array7949 != null) {
  7855. for (Class85 class85 : aClass85Array7949) {
  7856. Class85 class85_1982_ = class85;
  7857. if (class85.aClass85_776 != null) {
  7858. class85_1982_ = class85.aClass85_776;
  7859. }
  7860. class85_1982_.anInt777 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[4] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[8] * vertices_z[class85.anInt773 * -710317103])) * -1879868075;
  7861. class85_1982_.anInt783 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[5] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[9] * vertices_z[class85.anInt773 * -710317103])) * -2041556771;
  7862. class85_1982_.anInt779 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt773 * -710317103] + class233.aFloatArray2594[6] * vertices_y[class85.anInt773 * -710317103] + class233.aFloatArray2594[10] * vertices_z[class85.anInt773 * -710317103])) * -1434499227;
  7863. class85_1982_.anInt772 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[4] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[8] * vertices_z[class85.anInt774 * 1705862021])) * 1070341177;
  7864. class85_1982_.anInt781 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[5] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[9] * vertices_z[class85.anInt774 * 1705862021])) * 1802851857;
  7865. class85_1982_.anInt782 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt774 * 1705862021] + class233.aFloatArray2594[6] * vertices_y[class85.anInt774 * 1705862021] + class233.aFloatArray2594[10] * vertices_z[class85.anInt774 * 1705862021])) * 103846281;
  7866. class85_1982_.anInt771 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[4] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[8] * vertices_z[class85.anInt775 * 1636170731])) * -2103324039;
  7867. class85_1982_.anInt784 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[5] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[9] * vertices_z[class85.anInt775 * 1636170731])) * -526039059;
  7868. class85_1982_.anInt785 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class85.anInt775 * 1636170731] + class233.aFloatArray2594[6] * vertices_y[class85.anInt775 * 1636170731] + class233.aFloatArray2594[10] * vertices_z[class85.anInt775 * 1636170731])) * 491030489;
  7869. }
  7870. }
  7871. if (aClass68Array7904 != null) {
  7872. for (Class68 element : aClass68Array7904) {
  7873. Class68 class68 = element;
  7874. Class68 class68_1983_ = class68;
  7875. if (class68.aClass68_672 != null) {
  7876. class68_1983_ = class68.aClass68_672;
  7877. }
  7878. if (class68.aClass233_677 != null) {
  7879. class68.aClass233_677.method2142(class233);
  7880. } else {
  7881. class68.aClass233_677 = new Class233(class233);
  7882. }
  7883. class68_1983_.anInt671 = (int) (class233.aFloatArray2594[12] + (class233.aFloatArray2594[0] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[4] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[8] * vertices_z[class68.anInt674 * -180596249])) * -1436341053;
  7884. class68_1983_.anInt675 = (int) (class233.aFloatArray2594[13] + (class233.aFloatArray2594[1] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[5] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[9] * vertices_z[class68.anInt674 * -180596249])) * 449866009;
  7885. class68_1983_.anInt676 = (int) (class233.aFloatArray2594[14] + (class233.aFloatArray2594[2] * vertices_x[class68.anInt674 * -180596249] + class233.aFloatArray2594[6] * vertices_y[class68.anInt674 * -180596249] + class233.aFloatArray2594[10] * vertices_z[class68.anInt674 * -180596249])) * 1336328763;
  7886. }
  7887. }
  7888. }
  7889.  
  7890. @Override
  7891. public void X(short i, short i_1984_) {
  7892. for (int i_1985_ = 0; i_1985_ < anInt7916; i_1985_++) {
  7893. if (aShortArray7935[i_1985_] == i) {
  7894. aShortArray7935[i_1985_] = i_1984_;
  7895. }
  7896. }
  7897. if (aClass191Array7952 != null) {
  7898. for (int i_1986_ = 0; i_1986_ < anInt7951; i_1986_++) {
  7899. Class191 class191 = aClass191Array7952[i_1986_];
  7900. Class166 class166 = aClass166Array7892[i_1986_];
  7901. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7902. }
  7903. }
  7904. method4838();
  7905. }
  7906.  
  7907. @Override
  7908. public void dx(int i) {
  7909. aShort7898 = (short) i;
  7910. method4851();
  7911. method4839();
  7912. }
  7913.  
  7914. @Override
  7915. void method4733() {
  7916. /* empty */
  7917. }
  7918.  
  7919. @Override
  7920. public void dz(short i, short i_1987_) {
  7921. Interface_ma interface_ma = aClass_ra_Sub3_7894.anInterface_ma5299;
  7922. for (int i_1988_ = 0; i_1988_ < anInt7916; i_1988_++) {
  7923. if (aShortArray7923[i_1988_] == i) {
  7924. aShortArray7923[i_1988_] = i_1987_;
  7925. }
  7926. }
  7927. byte i_1989_ = 0;
  7928. byte i_1990_ = 0;
  7929. if (i != -1) {
  7930. Class53 class53 = interface_ma.method174(i & 0xffff, 555074717);
  7931. i_1989_ = class53.aByte533;
  7932. i_1990_ = class53.aByte534;
  7933. }
  7934. byte i_1991_ = 0;
  7935. byte i_1992_ = 0;
  7936. if (i_1987_ != -1) {
  7937. Class53 class53 = interface_ma.method174(i_1987_ & 0xffff, 276140436);
  7938. i_1991_ = class53.aByte533;
  7939. i_1992_ = class53.aByte534;
  7940. if (class53.aByte535 != 0 || class53.aByte509 != 0) {
  7941. aBoolean7903 = true;
  7942. }
  7943. }
  7944. if (i_1989_ != i_1991_ | i_1990_ != i_1992_) {
  7945. if (aClass191Array7952 != null) {
  7946. for (int i_1993_ = 0; i_1993_ < anInt7951; i_1993_++) {
  7947. Class191 class191 = aClass191Array7952[i_1993_];
  7948. Class166 class166 = aClass166Array7892[i_1993_];
  7949. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  7950. }
  7951. }
  7952. method4838();
  7953. }
  7954. }
  7955.  
  7956. @Override
  7957. public int db() {
  7958. return aShort7897;
  7959. }
  7960.  
  7961. @Override
  7962. public Class68[] method4753() {
  7963. return aClass68Array7904;
  7964. }
  7965.  
  7966. @Override
  7967. public int ca() {
  7968. if (!aBoolean7950) {
  7969. method4832();
  7970. }
  7971. return anInt7936;
  7972. }
  7973.  
  7974. void method4850() {
  7975. if (aClass186_7927 != null) {
  7976. aClass186_7927.method1849();
  7977. }
  7978. if (aClass186_7930 != null) {
  7979. aClass186_7930.method1849();
  7980. }
  7981. if (aClass186_7911 != null) {
  7982. aClass186_7911.method1849();
  7983. }
  7984. if (aClass186_7934 != null) {
  7985. aClass186_7934.method1849();
  7986. }
  7987. if (aClass167_7926 != null) {
  7988. aClass167_7926.method1788();
  7989. }
  7990. }
  7991.  
  7992. @Override
  7993. public void p(int i) {
  7994. aShort7897 = (short) i;
  7995. method4838();
  7996. }
  7997.  
  7998. @Override
  7999. public int o() {
  8000. if (!aBoolean7950) {
  8001. method4832();
  8002. }
  8003. return anInt7939;
  8004. }
  8005.  
  8006. void method4851() {
  8007. if (aClass186_7927 != null) {
  8008. aClass186_7927.aBoolean1900 = false;
  8009. }
  8010. }
  8011.  
  8012. @Override
  8013. public Class_na cc(Class_na class_na) {
  8014. if (anInt7906 == 0) {
  8015. return null;
  8016. }
  8017. if (!aBoolean7950) {
  8018. method4832();
  8019. }
  8020. int i;
  8021. int i_1994_;
  8022. if (aClass_ra_Sub3_7894.anInt8299 > 0) {
  8023. i = anInt7940 - (anInt7939 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8024. i_1994_ = anInt7941 - (anInt7938 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8025. } else {
  8026. i = anInt7940 - (anInt7938 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8027. i_1994_ = anInt7941 - (anInt7939 * aClass_ra_Sub3_7894.anInt8299 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8028. }
  8029. int i_1995_;
  8030. int i_1996_;
  8031. if (aClass_ra_Sub3_7894.anInt8317 > 0) {
  8032. i_1995_ = anInt7942 - (anInt7939 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8033. i_1996_ = anInt7943 - (anInt7938 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8034. } else {
  8035. i_1995_ = anInt7942 - (anInt7938 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8036. i_1996_ = anInt7943 - (anInt7939 * aClass_ra_Sub3_7894.anInt8317 >> 8) >> aClass_ra_Sub3_7894.anInt8313;
  8037. }
  8038. int i_1997_ = i_1994_ - i + 1;
  8039. int i_1998_ = i_1996_ - i_1995_ + 1;
  8040. Class_na_Sub2 class_na_sub2 = (Class_na_Sub2) class_na;
  8041. Class_na_Sub2 class_na_sub2_1999_;
  8042. if (class_na_sub2 != null && class_na_sub2.method3489(i_1997_, i_1998_)) {
  8043. class_na_sub2_1999_ = class_na_sub2;
  8044. class_na_sub2_1999_.method3487();
  8045. } else {
  8046. class_na_sub2_1999_ = new Class_na_Sub2(aClass_ra_Sub3_7894, i_1997_, i_1998_);
  8047. }
  8048. class_na_sub2_1999_.method3486(i, i_1995_, i_1994_, i_1996_);
  8049. method4842(class_na_sub2_1999_);
  8050. return class_na_sub2_1999_;
  8051. }
  8052.  
  8053. @Override
  8054. public boolean method4788() {
  8055. if (aShortArray7923 == null) {
  8056. return true;
  8057. }
  8058. for (short element : aShortArray7923) {
  8059. if (element != -1 && !aClass_ra_Sub3_7894.anInterface_ma5299.method170(element, (short) 3108)) {
  8060. return false;
  8061. }
  8062. }
  8063. return true;
  8064. }
  8065.  
  8066. @Override
  8067. public void method4779(Class387 class387, int i, int i_2000_, int i_2001_, boolean bool) {
  8068. Class387_Sub3 class387_sub3_2002_ = (Class387_Sub3) class387;
  8069. if (anInt7916 != 0 && class387_sub3_2002_.anInt7916 != 0) {
  8070. int i_2003_ = class387_sub3_2002_.anInt7900;
  8071. int[] is = class387_sub3_2002_.vertices_x;
  8072. int[] is_2004_ = class387_sub3_2002_.vertices_y;
  8073. int[] is_2005_ = class387_sub3_2002_.vertices_z;
  8074. short[] is_2006_ = class387_sub3_2002_.aShortArray7909;
  8075. short[] is_2007_ = class387_sub3_2002_.aShortArray7910;
  8076. short[] is_2008_ = class387_sub3_2002_.aShortArray7919;
  8077. byte[] is_2009_ = class387_sub3_2002_.aByteArray7958;
  8078. short[] is_2010_;
  8079. short[] is_2011_;
  8080. short[] is_2012_;
  8081. byte[] is_2013_;
  8082. if (aClass185_7915 != null) {
  8083. is_2010_ = aClass185_7915.aShortArray1899;
  8084. is_2011_ = aClass185_7915.aShortArray1897;
  8085. is_2012_ = aClass185_7915.aShortArray1896;
  8086. is_2013_ = aClass185_7915.aByteArray1898;
  8087. } else {
  8088. is_2010_ = null;
  8089. is_2011_ = null;
  8090. is_2012_ = null;
  8091. is_2013_ = null;
  8092. }
  8093. short[] is_2014_;
  8094. short[] is_2015_;
  8095. short[] is_2016_;
  8096. byte[] is_2017_;
  8097. if (class387_sub3_2002_.aClass185_7915 != null) {
  8098. is_2014_ = class387_sub3_2002_.aClass185_7915.aShortArray1899;
  8099. is_2015_ = class387_sub3_2002_.aClass185_7915.aShortArray1897;
  8100. is_2016_ = class387_sub3_2002_.aClass185_7915.aShortArray1896;
  8101. is_2017_ = class387_sub3_2002_.aClass185_7915.aByteArray1898;
  8102. } else {
  8103. is_2014_ = null;
  8104. is_2015_ = null;
  8105. is_2016_ = null;
  8106. is_2017_ = null;
  8107. }
  8108. int[] is_2018_ = class387_sub3_2002_.anIntArray7947;
  8109. short[] is_2019_ = class387_sub3_2002_.aShortArray7948;
  8110. if (!class387_sub3_2002_.aBoolean7950) {
  8111. class387_sub3_2002_.method4832();
  8112. }
  8113. int i_2020_ = class387_sub3_2002_.anInt7938;
  8114. int i_2021_ = class387_sub3_2002_.anInt7939;
  8115. int i_2022_ = class387_sub3_2002_.anInt7940;
  8116. int i_2023_ = class387_sub3_2002_.anInt7941;
  8117. int i_2024_ = class387_sub3_2002_.anInt7942;
  8118. int i_2025_ = class387_sub3_2002_.anInt7943;
  8119. for (int i_2026_ = 0; i_2026_ < anInt7900; i_2026_++) {
  8120. int i_2027_ = vertices_y[i_2026_] - i_2000_;
  8121. if (i_2027_ >= i_2020_ && i_2027_ <= i_2021_) {
  8122. int i_2028_ = vertices_x[i_2026_] - i;
  8123. if (i_2028_ >= i_2022_ && i_2028_ <= i_2023_) {
  8124. int i_2029_ = vertices_z[i_2026_] - i_2001_;
  8125. if (i_2029_ >= i_2024_ && i_2029_ <= i_2025_) {
  8126. int i_2030_ = -1;
  8127. int i_2031_ = anIntArray7947[i_2026_];
  8128. int i_2032_ = anIntArray7947[i_2026_ + 1];
  8129. for (int i_2033_ = i_2031_; i_2033_ < i_2032_; i_2033_++) {
  8130. i_2030_ = aShortArray7948[i_2033_] - 1;
  8131. if (i_2030_ == -1 || aByteArray7958[i_2030_] != 0) {
  8132. break;
  8133. }
  8134. }
  8135. if (i_2030_ != -1) {
  8136. for (int i_2034_ = 0; i_2034_ < i_2003_; i_2034_++) {
  8137. if (i_2028_ == is[i_2034_] && i_2029_ == is_2005_[i_2034_] && i_2027_ == is_2004_[i_2034_]) {
  8138. int i_2035_ = -1;
  8139. i_2031_ = is_2018_[i_2034_];
  8140. i_2032_ = is_2018_[i_2034_ + 1];
  8141. for (int i_2036_ = i_2031_; i_2036_ < i_2032_; i_2036_++) {
  8142. i_2035_ = is_2019_[i_2036_] - 1;
  8143. if (i_2035_ == -1 || is_2009_[i_2035_] != 0) {
  8144. break;
  8145. }
  8146. }
  8147. if (i_2035_ != -1) {
  8148. if (is_2010_ == null) {
  8149. aClass185_7915 = new Class185();
  8150. is_2010_ = aClass185_7915.aShortArray1899 = Class378.method4670(aShortArray7909, (byte) -79);
  8151. is_2011_ = aClass185_7915.aShortArray1897 = Class378.method4670(aShortArray7910, (byte) -109);
  8152. is_2012_ = aClass185_7915.aShortArray1896 = Class378.method4670(aShortArray7919, (byte) -67);
  8153. is_2013_ = aClass185_7915.aByteArray1898 = Class409.method4978(aByteArray7958, 1194497584);
  8154. }
  8155. if (is_2014_ == null) {
  8156. Class185 class185 = class387_sub3_2002_.aClass185_7915 = new Class185();
  8157. is_2014_ = class185.aShortArray1899 = Class378.method4670(is_2006_, (byte) -33);
  8158. is_2015_ = class185.aShortArray1897 = Class378.method4670(is_2007_, (byte) -25);
  8159. is_2016_ = class185.aShortArray1896 = Class378.method4670(is_2008_, (byte) -24);
  8160. is_2017_ = class185.aByteArray1898 = Class409.method4978(is_2009_, 1194497584);
  8161. }
  8162. short i_2037_ = aShortArray7909[i_2030_];
  8163. short i_2038_ = aShortArray7910[i_2030_];
  8164. short i_2039_ = aShortArray7919[i_2030_];
  8165. byte i_2040_ = aByteArray7958[i_2030_];
  8166. i_2031_ = is_2018_[i_2034_];
  8167. i_2032_ = is_2018_[i_2034_ + 1];
  8168. for (int i_2041_ = i_2031_; i_2041_ < i_2032_; i_2041_++) {
  8169. int i_2042_ = is_2019_[i_2041_] - 1;
  8170. if (i_2042_ == -1) {
  8171. break;
  8172. }
  8173. if (is_2017_[i_2042_] != 0) {
  8174. is_2014_[i_2042_] += i_2037_;
  8175. is_2015_[i_2042_] += i_2038_;
  8176. is_2016_[i_2042_] += i_2039_;
  8177. is_2017_[i_2042_] += i_2040_;
  8178. }
  8179. }
  8180. i_2037_ = is_2006_[i_2035_];
  8181. i_2038_ = is_2007_[i_2035_];
  8182. i_2039_ = is_2008_[i_2035_];
  8183. i_2040_ = is_2009_[i_2035_];
  8184. i_2031_ = anIntArray7947[i_2026_];
  8185. i_2032_ = anIntArray7947[i_2026_ + 1];
  8186. for (int i_2043_ = i_2031_; i_2043_ < i_2032_; i_2043_++) {
  8187. int i_2044_ = aShortArray7948[i_2043_] - 1;
  8188. if (i_2044_ == -1) {
  8189. break;
  8190. }
  8191. if (is_2013_[i_2044_] != 0) {
  8192. is_2010_[i_2044_] += i_2037_;
  8193. is_2011_[i_2044_] += i_2038_;
  8194. is_2012_[i_2044_] += i_2039_;
  8195. is_2013_[i_2044_] += i_2040_;
  8196. }
  8197. }
  8198. class387_sub3_2002_.method4839();
  8199. method4839();
  8200. }
  8201. }
  8202. }
  8203. }
  8204. }
  8205. }
  8206. }
  8207. }
  8208. }
  8209. }
  8210.  
  8211. @Override
  8212. public void wa() {
  8213. for (int i = 0; i < anInt7900; i++) {
  8214. vertices_z[i] = -vertices_z[i];
  8215. }
  8216. for (int i = 0; i < anInt7906; i++) {
  8217. aShortArray7919[i] = (short) -aShortArray7919[i];
  8218. }
  8219. for (int i = 0; i < anInt7916; i++) {
  8220. short i_2045_ = aShortArray7920[i];
  8221. aShortArray7920[i] = aShortArray7922[i];
  8222. aShortArray7922[i] = i_2045_;
  8223. }
  8224. method4851();
  8225. method4839();
  8226. method4840();
  8227. aBoolean7950 = false;
  8228. }
  8229.  
  8230. @Override
  8231. void cv(int i, int i_2046_, int i_2047_, int i_2048_) {
  8232. if (i == 0) {
  8233. int i_2049_ = 0;
  8234. origin_x = 0;
  8235. origin_y = 0;
  8236. origin_z = 0;
  8237. for (int i_2050_ = 0; i_2050_ < anInt7900; i_2050_++) {
  8238. origin_x += vertices_x[i_2050_];
  8239. origin_y += vertices_y[i_2050_];
  8240. origin_z += vertices_z[i_2050_];
  8241. i_2049_++;
  8242. }
  8243. if (i_2049_ > 0) {
  8244. origin_x = origin_x / i_2049_ + i_2046_;
  8245. origin_y = origin_y / i_2049_ + i_2047_;
  8246. origin_z = origin_z / i_2049_ + i_2048_;
  8247. } else {
  8248. origin_x = i_2046_;
  8249. origin_y = i_2047_;
  8250. origin_z = i_2048_;
  8251. }
  8252. } else if (i == 1) {
  8253. for (int i_2051_ = 0; i_2051_ < anInt7900; i_2051_++) {
  8254. vertices_x[i_2051_] += i_2046_;
  8255. vertices_y[i_2051_] += i_2047_;
  8256. vertices_z[i_2051_] += i_2048_;
  8257. }
  8258. } else if (i == 2) {
  8259. for (int i_2052_ = 0; i_2052_ < anInt7900; i_2052_++) {
  8260. vertices_x[i_2052_] -= origin_x;
  8261. vertices_y[i_2052_] -= origin_y;
  8262. vertices_z[i_2052_] -= origin_z;
  8263. if (i_2048_ != 0) {
  8264. int i_2053_ = Class220.anIntArray2483[i_2048_];
  8265. int i_2054_ = Class220.anIntArray2474[i_2048_];
  8266. int i_2055_ = vertices_y[i_2052_] * i_2053_ + vertices_x[i_2052_] * i_2054_ + 16383 >> 14;
  8267. vertices_y[i_2052_] = vertices_y[i_2052_] * i_2054_ - vertices_x[i_2052_] * i_2053_ + 16383 >> 14;
  8268. vertices_x[i_2052_] = i_2055_;
  8269. }
  8270. if (i_2046_ != 0) {
  8271. int i_2056_ = Class220.anIntArray2483[i_2046_];
  8272. int i_2057_ = Class220.anIntArray2474[i_2046_];
  8273. int i_2058_ = vertices_y[i_2052_] * i_2057_ - vertices_z[i_2052_] * i_2056_ + 16383 >> 14;
  8274. vertices_z[i_2052_] = vertices_y[i_2052_] * i_2056_ + vertices_z[i_2052_] * i_2057_ + 16383 >> 14;
  8275. vertices_y[i_2052_] = i_2058_;
  8276. }
  8277. if (i_2047_ != 0) {
  8278. int i_2059_ = Class220.anIntArray2483[i_2047_];
  8279. int i_2060_ = Class220.anIntArray2474[i_2047_];
  8280. int i_2061_ = vertices_z[i_2052_] * i_2059_ + vertices_x[i_2052_] * i_2060_ + 16383 >> 14;
  8281. vertices_z[i_2052_] = vertices_z[i_2052_] * i_2060_ - vertices_x[i_2052_] * i_2059_ + 16383 >> 14;
  8282. vertices_x[i_2052_] = i_2061_;
  8283. }
  8284. vertices_x[i_2052_] += origin_x;
  8285. vertices_y[i_2052_] += origin_y;
  8286. vertices_z[i_2052_] += origin_z;
  8287. }
  8288. } else if (i == 3) {
  8289. for (int i_2062_ = 0; i_2062_ < anInt7900; i_2062_++) {
  8290. vertices_x[i_2062_] -= origin_x;
  8291. vertices_y[i_2062_] -= origin_y;
  8292. vertices_z[i_2062_] -= origin_z;
  8293. vertices_x[i_2062_] = vertices_x[i_2062_] * i_2046_ / 128;
  8294. vertices_y[i_2062_] = vertices_y[i_2062_] * i_2047_ / 128;
  8295. vertices_z[i_2062_] = vertices_z[i_2062_] * i_2048_ / 128;
  8296. vertices_x[i_2062_] += origin_x;
  8297. vertices_y[i_2062_] += origin_y;
  8298. vertices_z[i_2062_] += origin_z;
  8299. }
  8300. } else if (i == 5) {
  8301. for (int i_2063_ = 0; i_2063_ < anInt7916; i_2063_++) {
  8302. int i_2064_ = (aByteArray7963[i_2063_] & 0xff) + i_2046_ * 8;
  8303. if (i_2064_ < 0) {
  8304. i_2064_ = 0;
  8305. } else if (i_2064_ > 255) {
  8306. i_2064_ = 255;
  8307. }
  8308. aByteArray7963[i_2063_] = (byte) i_2064_;
  8309. }
  8310. if (aClass191Array7952 != null) {
  8311. for (int i_2065_ = 0; i_2065_ < anInt7951; i_2065_++) {
  8312. Class191 class191 = aClass191Array7952[i_2065_];
  8313. Class166 class166 = aClass166Array7892[i_2065_];
  8314. class166.anInt1703 = class166.anInt1703 & 0xffffff | 255 - (aByteArray7963[class191.anInt1947] & 0xff) << 24;
  8315. }
  8316. }
  8317. method4838();
  8318. } else if (i == 7) {
  8319. for (int i_2066_ = 0; i_2066_ < anInt7916; i_2066_++) {
  8320. int i_2067_ = aShortArray7935[i_2066_] & 0xffff;
  8321. int i_2068_ = i_2067_ >> 10 & 0x3f;
  8322. int i_2069_ = i_2067_ >> 7 & 0x7;
  8323. int i_2070_ = i_2067_ & 0x7f;
  8324. i_2068_ = i_2068_ + i_2046_ & 0x3f;
  8325. i_2069_ += i_2047_ / 4;
  8326. if (i_2069_ < 0) {
  8327. i_2069_ = 0;
  8328. } else if (i_2069_ > 7) {
  8329. i_2069_ = 7;
  8330. }
  8331. i_2070_ += i_2048_;
  8332. if (i_2070_ < 0) {
  8333. i_2070_ = 0;
  8334. } else if (i_2070_ > 127) {
  8335. i_2070_ = 127;
  8336. }
  8337. aShortArray7935[i_2066_] = (short) (i_2068_ << 10 | i_2069_ << 7 | i_2070_);
  8338. }
  8339. if (aClass191Array7952 != null) {
  8340. for (int i_2071_ = 0; i_2071_ < anInt7951; i_2071_++) {
  8341. Class191 class191 = aClass191Array7952[i_2071_];
  8342. Class166 class166 = aClass166Array7892[i_2071_];
  8343. class166.anInt1703 = class166.anInt1703 & ~0xffffff | Class294.anIntArray3165[aShortArray7935[class191.anInt1947] & 0xffff] & 0xffffff;
  8344. }
  8345. }
  8346. method4838();
  8347. } else if (i == 8) {
  8348. for (int i_2072_ = 0; i_2072_ < anInt7951; i_2072_++) {
  8349. Class166 class166 = aClass166Array7892[i_2072_];
  8350. class166.anInt1704 += i_2046_;
  8351. class166.anInt1705 += i_2047_;
  8352. }
  8353. } else if (i == 10) {
  8354. for (int i_2073_ = 0; i_2073_ < anInt7951; i_2073_++) {
  8355. Class166 class166 = aClass166Array7892[i_2073_];
  8356. class166.anInt1702 = class166.anInt1702 * i_2046_ >> 7;
  8357. class166.anInt1701 = class166.anInt1701 * i_2047_ >> 7;
  8358. }
  8359. } else if (i == 9) {
  8360. for (int i_2074_ = 0; i_2074_ < anInt7951; i_2074_++) {
  8361. Class166 class166 = aClass166Array7892[i_2074_];
  8362. class166.anInt1706 = class166.anInt1706 + i_2046_ & 0x3fff;
  8363. }
  8364. }
  8365. }
  8366. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!