API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 9th, 2021
920
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 46.24 KB | None | 0 0
raw download clone embed print report
  1.  
  2. namespace offsets
  3. {
  4. DWORD WEAPONCOMPLETEDEFS_OFFSET = 0x13268BA0;
  5. DWORD GameMode_PTR_OFFSET = 0x15fa8488;
  6. DWORD NO_RECOIL_OFFSET = 0x2A98;
  7.  
  8. namespace character
  9. {
  10. DWORD decrypt_client_PosInfo = 0x1130; //0x2B70;
  11. DWORD clientinfo_t_stance = 0x70;
  12. DWORD clientinfo_t_weapon = 0xFC8;
  13. DWORD clientinfo_t_entitynum = 0x3A0;
  14. DWORD clientinfo_t_idead = 0x3B4;
  15. DWORD clientinfo_t_team = 0x2B8;
  16. DWORD clientinfo_t_isvalid = 0x448;
  17. }
  18.  
  19. namespace bone
  20. {
  21. DWORD ENCRYPT_PTR_OFFSET = 0x1415C238;
  22. DWORD REVERSED_ADDRESS = 0x5b961f1;
  23. DWORD LastKey_XOR = 0xf;
  24. DWORD BONE_BASE_POS = 0x19D04;
  25. DWORD Bone_Size = 0x150;
  26. }
  27.  
  28. namespace Character_Info
  29. {
  30. DWORD ENCRYPT_PTR_OFFSET = 0x162CDF28;;
  31. DWORD REVERSED_ADDRESS = 0x5b960d9;
  32. DWORD LastKey_XOR = 0x7;
  33.  
  34. DWORD BASE_OFFSET = 0x98C78;
  35. DWORD BASE_REVERSED_ADDRESS = 0x5b96122;
  36. DWORD BASE_LastKey_XOR = 0x11;
  37.  
  38. DWORD LOCAL_INDEX_OFFSET = 0x14E50;
  39. DWORD clientinfo_t_size = 0x3A70;
  40. }
  41.  
  42. namespace visibility
  43. {
  44. DWORD FunctionDisTribute = 0x9493B70;
  45. DWORD AboutVisibleFunction = 0x4BB6C80;
  46. DWORD ListHead = 0x108;
  47. }
  48.  
  49. namespace camera
  50. {
  51. DWORD CAMERA_OFFSET = 0x1316A2C0;
  52. DWORD CAMER_POS = 0x1D8;
  53. DWORD REFDEF_OFFSET_2 = 0x162D0950;
  54. }
  55.  
  56. namespace name
  57. {
  58. DWORD NAME_ARRAY_OFFSET = 0x162DBBA8;
  59. DWORD NAME_LIST_OFFSET = 0x4C70; //
  60. }
  61.  
  62. namespace direcX
  63. {
  64. DWORD command_queue = 0x17CF9CA8;
  65. }
  66. }
  67.  
  68. QWORD DecryptClientInfo()
  69. {
  70. QWORD encrypted_address = *(QWORD*)(baseModuleAddr + offsets::Character_Info::ENCRYPT_PTR_OFFSET);
  71. QWORD peb = Peb;
  72.  
  73. QWORD rax, rcx, rdx, rbx = encrypted_address;
  74.  
  75. if (encrypted_address)
  76. {
  77. QWORD reversedAddr = *(QWORD*)(baseModuleAddr + offsets::Character_Info::REVERSED_ADDRESS);
  78.  
  79. QWORD LastKey = *(QWORD*)(_byteswap_uint64(reversedAddr)+offsets::Character_Info::LastKey_XOR);
  80. if (encrypted_address && LastKey)
  81. {
  82. QWORD rdx = Peb;
  83. rax = (baseModuleAddr + 0x399);
  84. rdx = (~rdx);
  85. rax = rbx + 0x9491;
  86. rax += rdx;
  87. rdx = LastKey;
  88. rdx *= rax;
  89. rax = 0xA9F1C87E4360EA6C;
  90. rdx ^= rax;
  91. rax = rdx;
  92. rax >>= 0x5;
  93. rdx ^= rax;
  94. rax = rdx;
  95. rax >>= 0xA;
  96. rdx ^= rax;
  97. rax = rdx;
  98. rax >>= 0x14;
  99. rdx ^= rax;
  100. rax = 0xAB19C29B58F02DE5;
  101. rbx = rdx;
  102. rbx >>= 0x28;
  103. rbx ^= rdx;
  104. rbx *= rax;
  105. return rbx;
  106. }
  107. }
  108. return 0;
  109. }
  110.  
  111. QWORD DecryptBaseIns()
  112. {
  113. QWORD encrypted_address;
  114. QWORD peb = Peb;
  115.  
  116. encrypted_address = *(QWORD*)(Settings::ClientInfoPointer + offsets::Character_Info::BASE_OFFSET);
  117.  
  118. if (encrypted_address)
  119. {
  120. QWORD reversedAddr = *(QWORD*)(baseModuleAddr + offsets::Character_Info::BASE_REVERSED_ADDRESS);
  121. QWORD last_key = *(QWORD*)(~(reversedAddr) + offsets::Character_Info::BASE_LastKey_XOR);
  122.  
  123. if (encrypted_address && last_key)
  124. {
  125. auto rax = encrypted_address;
  126.  
  127. Settings::ClientBaseCase = (_rotr64(~peb, 0xC) & 0xF);
  128.  
  129. switch (Settings::ClientBaseCase)
  130. {
  131. case 0:
  132. {
  133. auto var_11 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  134. auto var_21 = (encrypted_address) ^ (~peb);
  135. auto var_30 = (var_21)-(~peb);
  136. auto var_31 = (var_30) >> 0xf;
  137. auto var_32 = ((var_21)-(~peb)) ^ (var_31);
  138. auto var_38 = var_32;
  139. auto var_39 = (var_38) >> 0x1e;
  140. auto var_40 = (var_32) ^ (var_39);
  141. auto var_45 = var_40;
  142. auto var_46 = (var_45) >> 0x3c;
  143. auto var_47 = (var_40) ^ (var_46);
  144. auto var_52 = ~peb;
  145. auto var_53 = (var_47) ^ (((var_52)-(baseModuleAddr)) - (0xc9f3));
  146. auto var_54 = (var_53) ^ (0xdc69516c8ff82f73);
  147. auto var_65 = (var_54) * (0x523e2838a0e15a2b);
  148. auto var_72 = (var_65) ^ (0xa984d2eac8b916bb);
  149. auto var_79 = (var_72) * (*reinterpret_cast<uint64_t*>(~(var_11)+0x11));
  150. return var_79;
  151. }
  152. case 1:
  153. {
  154. auto var_10 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  155. auto var_23 = ~peb;
  156. auto var_24 = (var_23) ^ (baseModuleAddr + 0x48796cdd);
  157. auto var_30 = (((encrypted_address)-(0x81afb8cc672a75)) + (var_24)) ^ (0xec4770aeff1593bd);
  158. auto var_37 = *reinterpret_cast<uint64_t*>(~(var_10)+0x11);
  159. auto var_38 = (var_30) * (var_37);
  160. auto var_44 = ((var_38)-(baseModuleAddr)) * (0xcec4128e23d1950b);
  161. auto var_50 = var_44;
  162. auto var_51 = (var_50) >> 0x6;
  163. auto var_52 = (var_44) ^ (var_51);
  164. auto var_59 = var_52;
  165. auto var_60 = (var_59) >> 0xc;
  166. auto var_61 = (var_52) ^ (var_60);
  167. auto var_66 = var_61;
  168. auto var_67 = (var_66) >> 0x18;
  169. auto var_68 = (var_61) ^ (var_67);
  170. auto var_69 = var_68;
  171. auto var_70 = (var_69) >> 0x30;
  172. auto var_71 = (var_68) ^ (var_70);
  173. auto var_78 = var_71;
  174. auto var_79 = (var_78) >> 0x13;
  175. auto var_80 = (var_71) ^ (var_79);
  176. auto var_86 = var_80;
  177. auto var_87 = (var_86) >> 0x26;
  178. auto var_88 = (var_80) ^ (var_87);
  179. return var_88;
  180. }
  181. case 2:
  182. {
  183. auto var_2 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  184. auto var_12 = (encrypted_address) * (0xa26c40fc0b7bb2f3);
  185. auto var_18 = (var_12) ^ (~peb);
  186. auto var_20 = var_18;
  187. auto var_21 = (var_20) >> 0xb;
  188. auto var_22 = (var_18) ^ (var_21);
  189. auto var_30 = var_22;
  190. auto var_31 = (var_30) >> 0x16;
  191. auto var_32 = (var_22) ^ (var_31);
  192. auto var_34 = var_32;
  193. auto var_35 = (var_34) >> 0x2c;
  194. auto var_36 = (var_35) ^ (var_32);
  195. auto var_37 = *reinterpret_cast<uint64_t*>(~(var_2)+0x11);
  196. auto var_38 = (var_37) * (var_36);
  197. auto var_45 = (var_38) ^ (0x4358107a906624ab);
  198. auto var_55 = (var_45) * (0x71a09aac360c8d8f);
  199. auto var_56 = (var_55) ^ (baseModuleAddr);
  200. return (var_56)-(~peb);
  201. }
  202. case 3:
  203. {
  204. auto var_6 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  205. auto var_12 = (encrypted_address) * (0x6257be746de98169);
  206. auto var_23 = (((~(baseModuleAddr + 0x243b8019)) + 1) + (~peb)) ^ ((var_12)-(0x2390753244040631));
  207. auto var_25 = *reinterpret_cast<uint64_t*>(~(var_6)+0x11);
  208. auto var_26 = (var_25) * (var_23);
  209. auto var_27 = (var_26) ^ (baseModuleAddr);
  210. auto var_32 = var_27;
  211. auto var_33 = (var_32) >> 0x1d;
  212. auto var_34 = (var_27) ^ (var_33);
  213. auto var_37 = var_34;
  214. auto var_38 = (var_37) >> 0x3a;
  215. auto var_39 = (var_34) ^ (var_38);
  216. auto var_44 = ((var_39)-(baseModuleAddr)) * (0xf7812f5853abb391);
  217. return var_44;
  218. }
  219. case 4:
  220. {
  221. auto var_9 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  222. auto var_13 = ~peb;
  223. auto var_14 = (var_13) * (baseModuleAddr + 0x6b3e);
  224. auto var_15 = ((encrypted_address)+(var_14)) * (0xdb512a591ab1621d);
  225. auto var_21 = var_15;
  226. auto var_22 = (var_21) >> 0x3;
  227. auto var_23 = (var_15) ^ (var_22);
  228. auto var_31 = var_23;
  229. auto var_32 = (var_31) >> 0x6;
  230. auto var_33 = (var_23) ^ (var_32);
  231. auto var_37 = var_33;
  232. auto var_38 = (var_37) >> 0xc;
  233. auto var_39 = (var_33) ^ (var_38);
  234. auto var_51 = var_39;
  235. auto var_52 = (var_51) >> 0x18;
  236. auto var_53 = (var_39) ^ (var_52);
  237. auto var_56 = var_53;
  238. auto var_57 = (var_56) >> 0x30;
  239. auto var_58 = (var_53) ^ (var_57);
  240. auto var_59 = (var_58) * (0x2757db261e29a8ed);
  241. auto var_60 = (var_59) ^ (0x6281bfa33e9a3126);
  242. auto var_69 = ((var_60)+(~peb)) * (*reinterpret_cast<uint64_t*>(~(var_9)+0x11));
  243. return (var_69)-(~peb);
  244. }
  245.  
  246. case 5:
  247. {
  248. auto var_2 = 0x266688afce8c87b4;
  249. auto var_10 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  250. auto var_17 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(~(var_10)+0x11));
  251. auto var_22 = (var_17) * (0x6bffdb7107b8c2dd);
  252. auto var_29 = (((var_22)+(~peb)) + (baseModuleAddr + 0x158b)) ^ (0xffc0b447184a05a6);
  253. auto var_34 = (var_29) ^ (~peb);
  254. auto var_42 = var_34;
  255. auto var_43 = (var_42) >> 0x12;
  256. auto var_44 = (var_34) ^ (var_43);
  257. auto var_49 = var_44;
  258. auto var_50 = (var_49) >> 0x24;
  259. auto var_51 = (var_44) ^ (var_50);
  260. auto var_56 = (var_51) ^ (var_2);
  261. auto var_59 = ~peb;
  262. auto var_60 = (var_59) * (baseModuleAddr + 0x5430c2bd);
  263. return (var_56)-(var_60);
  264. }
  265. case 6:
  266. {
  267. auto var_9 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  268. auto var_13 = encrypted_address;
  269. auto var_14 = (var_13) >> 0x1b;
  270. auto var_15 = (encrypted_address) ^ (var_14);
  271. auto var_23 = var_15;
  272. auto var_24 = (var_23) >> 0x36;
  273. auto var_25 = (var_15) ^ (var_24);
  274. auto var_38 = ((var_25)+(baseModuleAddr)) * (*reinterpret_cast<uint64_t*>(~(var_9)+0x11));
  275. auto var_44 = var_38;
  276. auto var_45 = (var_44) >> 0xa;
  277. auto var_46 = (var_38) ^ (var_45);
  278. auto var_52 = var_46;
  279. auto var_53 = (var_52) >> 0x14;
  280. auto var_54 = (var_46) ^ (var_53);
  281. auto var_55 = var_54;
  282. auto var_56 = (var_55) >> 0x28;
  283. auto var_57 = (var_54) ^ (var_56);
  284. auto var_62 = var_57;
  285. auto var_63 = (var_62) >> 0xb;
  286. auto var_64 = (var_57) ^ (var_63);
  287. auto var_65 = var_64;
  288. auto var_66 = (var_65) >> 0x16;
  289. auto var_67 = (var_64) ^ (var_66);
  290. auto var_84 = var_67;
  291. auto var_85 = (var_84) >> 0x2c;
  292. auto var_86 = (var_67) ^ (var_85);
  293. auto var_87 = (var_86) * (0x6e4c3096e444edcf);
  294. auto var_95 = (var_87) ^ (0x66217bb891360b7d);
  295. return var_95;
  296. }
  297. case 7:
  298. {
  299. auto var_5 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  300. auto var_12 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(~(var_5)+0x11));
  301. auto var_18 = ~peb;
  302. auto var_19 = (var_18) * (baseModuleAddr + 0xd477);
  303. auto var_24 = (var_12)+(var_19);
  304. auto var_25 = (var_24) >> 0x10;
  305. auto var_26 = ((var_12)+(var_19)) ^ (var_25);
  306. auto var_28 = var_26;
  307. auto var_29 = (var_28) >> 0x20;
  308. auto var_30 = (var_26) ^ (var_29);
  309. auto var_52 = baseModuleAddr + 0x4357aca8;
  310. auto var_53 = (~(var_52)) ^ (~peb);
  311. auto var_54 = (var_30) ^ (var_53);
  312. auto var_62 = ((var_54)-(~peb)) * (0x8bc400c7254105e7);
  313. auto var_66 = (var_62) ^ (0xca763fb18d280560);
  314. auto var_78 = (var_66) * (0xa88827c6a7fbae25);
  315. return var_78;
  316. }
  317. case 8:
  318. {
  319. auto var_13 = 0x2c8dc48e719edd19;
  320. auto var_14 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  321. auto var_24 = (encrypted_address) ^ ((baseModuleAddr + 0xdd02) + (~peb));
  322. auto var_30 = (var_24)+(~peb);
  323. auto var_31 = (var_30) >> 0x1a;
  324. auto var_32 = ((var_24)+(~peb)) ^ (var_31);
  325. auto var_39 = var_32;
  326. auto var_40 = (var_39) >> 0x34;
  327. auto var_41 = (var_32) ^ (var_40);
  328. auto var_47 = *reinterpret_cast<uint64_t*>(~(var_14)+0x11);
  329. auto var_48 = (var_47) * (var_13);
  330. auto var_49 = (var_41) * (var_48);
  331. auto var_57 = (var_49) * (0x4512ca30acf44e19);
  332. auto var_58 = var_57;
  333. auto var_59 = (var_58) >> 0x3;
  334. auto var_60 = (var_57) ^ (var_59);
  335. auto var_66 = var_60;
  336. auto var_67 = (var_66) >> 0x6;
  337. auto var_68 = (var_60) ^ (var_67);
  338. auto var_74 = var_68;
  339. auto var_75 = (var_74) >> 0xc;
  340. auto var_76 = (var_68) ^ (var_75);
  341. auto var_80 = var_76;
  342. auto var_81 = (var_80) >> 0x18;
  343. auto var_82 = (var_76) ^ (var_81);
  344. auto var_88 = var_82;
  345. auto var_89 = (var_88) >> 0x30;
  346. auto var_90 = (var_82) ^ (var_89);
  347. auto var_98 = (var_90) * (0xe3c93f09fee963fb);
  348. return var_98;
  349. }
  350.  
  351. case 9:
  352. {
  353. auto var_2 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  354. auto var_14 = (encrypted_address)+((baseModuleAddr + 0x5783) - (~peb));
  355. auto var_15 = (var_14) >> 0x24;
  356. auto var_16 = ((encrypted_address)+((baseModuleAddr + 0x5783) - (~peb))) ^ (var_15);
  357. auto var_29 = (var_16) * (*reinterpret_cast<uint64_t*>(~(var_2)+0x11));
  358. auto var_31 = (var_29) * (0x57a614cbead94d0f);
  359. auto var_44 = ~peb;
  360. auto var_45 = ((((var_31)-(0x5eef0f8e63464328)) + (0xffffffffffff08a5)) + ((var_44)-(baseModuleAddr))) ^ (((var_44)-(baseModuleAddr)) + (0xffffffff8dacc40e));
  361. auto var_50 = (var_45) ^ (0x47f2e9267c14b85e);
  362. return var_50;
  363. }
  364. case 10:
  365. {
  366. auto var_2 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  367. auto var_16 = baseModuleAddr + 0xa995;
  368. auto var_17 = (~(var_16)) * (~peb);
  369. auto var_18 = (encrypted_address) ^ (var_17);
  370. auto var_23 = ~peb;
  371. auto var_24 = (var_23) ^ (baseModuleAddr + 0x2a56f5b5);
  372. auto var_30 = (((var_18)+(0x2628e820e6b63cc7)) - (var_24)) * (0x70114bb50cc89235);
  373. auto var_41 = var_30;
  374. auto var_42 = (var_41) >> 0x1e;
  375. auto var_43 = (var_30) ^ (var_42);
  376. auto var_55 = var_43;
  377. auto var_56 = (var_55) >> 0x3c;
  378. auto var_57 = (var_56) ^ (var_43);
  379. auto var_58 = *reinterpret_cast<uint64_t*>(~(var_2)+0x11);
  380. auto var_59 = (var_58) * (var_57);
  381. auto var_63 = (var_59) ^ (baseModuleAddr);
  382. return (var_63)-(baseModuleAddr);
  383. }
  384. case 11:
  385. {
  386. auto var_2 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  387. auto var_21 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(~(var_2)+0x11));
  388. auto var_25 = (var_21) ^ (baseModuleAddr);
  389. auto var_39 = var_25;
  390. auto var_40 = (var_39) >> 0x1b;
  391. auto var_41 = (var_25) ^ (var_40);
  392. auto var_52 = var_41;
  393. auto var_53 = (var_52) >> 0x36;
  394. auto var_54 = (var_41) ^ (var_53);
  395. auto var_63 = ~peb;
  396. auto var_64 = (~(var_63)) ^ (baseModuleAddr + 0x5d7f9617);
  397. auto var_69 = ((var_54)+(var_64)) * (0xea39d9b63e78b013);
  398. auto var_76 = (var_69) * (0x7c6cd9d6aadc4f6f);
  399. return ((var_76)+(0xfbdfc7fcc1dd651b)) + (baseModuleAddr);
  400. }
  401.  
  402. case 12:
  403. {
  404. auto var_2 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  405. auto var_16 = encrypted_address;
  406. auto var_17 = (var_16) >> 0xd;
  407. auto var_18 = (encrypted_address) ^ (var_17);
  408. auto var_22 = var_18;
  409. auto var_23 = (var_22) >> 0x1a;
  410. auto var_24 = (var_18) ^ (var_23);
  411. auto var_30 = var_24;
  412. auto var_31 = (var_30) >> 0x34;
  413. auto var_32 = (var_24) ^ (var_31);
  414. auto var_39 = baseModuleAddr + 0x5d6443d4;
  415. auto var_51 = (((var_32)+((~(var_39)) - (~peb))) + (~peb)) * (*reinterpret_cast<uint64_t*>(~(var_2)+0x11));
  416. auto var_65 = ((var_51)-(baseModuleAddr)) * (0x2dc1c48f58786c25);
  417. auto var_73 = (var_65) ^ (0x9aff32b7c2912dba);
  418. return (var_73)-(0x15c73d388aef7ed);
  419. }
  420. case 13:
  421. {
  422. auto var_2 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  423. auto var_26 = ~peb;
  424. auto var_27 = (var_26) ^ ((encrypted_address)-(0x5b05191929917021));
  425. auto var_28 = *reinterpret_cast<uint64_t*>(~(var_2)+0x11);
  426. auto var_29 = (var_28) * (var_27);
  427. auto var_33 = ~peb;
  428. auto var_34 = (var_29) * (0xa85e9b0a4e69386b);
  429. auto var_35 = (~(var_33)) * (baseModuleAddr + 0x7e28);
  430. auto var_36 = var_34;
  431. auto var_37 = (var_36) >> 0x23;
  432. auto var_38 = (var_35) ^ (var_37);
  433. auto var_40 = (var_34) ^ (var_38);
  434. return (var_40)-(baseModuleAddr);
  435. }
  436. case 14:
  437. {
  438. auto var_2 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  439. auto var_12 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(~(var_2)+0x11));
  440. auto var_18 = baseModuleAddr + 0x234c3076;
  441. auto var_19 = (~(var_18)) ^ (~peb);
  442. auto var_20 = (var_12)+(var_19);
  443. auto var_21 = (var_20) >> 0xc;
  444. auto var_22 = ((var_12)+(var_19)) ^ (var_21);
  445. auto var_29 = var_22;
  446. auto var_30 = (var_29) >> 0x18;
  447. auto var_31 = (var_22) ^ (var_30);
  448. auto var_32 = var_31;
  449. auto var_33 = (var_32) >> 0x30;
  450. auto var_34 = (var_31) ^ (var_33);
  451. auto var_38 = var_34;
  452. auto var_39 = (var_38) >> 0x9;
  453. auto var_40 = (var_34) ^ (var_39);
  454. auto var_47 = var_40;
  455. auto var_48 = (var_47) >> 0x12;
  456. auto var_49 = (var_40) ^ (var_48);
  457. auto var_57 = var_49;
  458. auto var_58 = (var_57) >> 0x24;
  459. auto var_59 = (var_49) ^ (var_58);
  460. auto var_65 = (((var_59)-(~peb)) + (baseModuleAddr + 0xafb9)) * (0x954aa677ffce2321);
  461. auto var_76 = ((var_65)-(baseModuleAddr)) ^ (0x8cc07550a5d822a8);
  462. return var_76;
  463. }
  464. case 15:
  465. {
  466. auto var_7 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b96122);
  467. auto var_13 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(~(var_7)+0x11));
  468. auto var_22 = (var_13) * (0x3eefbf2e9cced4fb);
  469. auto var_33 = (var_22)+(baseModuleAddr);
  470. auto var_34 = (var_33) >> 0x1e;
  471. auto var_35 = ((var_22)+(baseModuleAddr)) ^ (var_34);
  472. auto var_36 = var_35;
  473. auto var_37 = (var_36) >> 0x3c;
  474. auto var_38 = (var_35) ^ (var_37);
  475. auto var_50 = (var_38) ^ (0x1531cc8e73647589);
  476. auto var_57 = (var_50) ^ (baseModuleAddr);
  477. auto var_61 = var_57;
  478. auto var_62 = (var_61) >> 0xe;
  479. auto var_63 = (var_57) ^ (var_62);
  480. auto var_70 = var_63;
  481. auto var_71 = (var_70) >> 0x1c;
  482. auto var_72 = (var_63) ^ (var_71);
  483. auto var_73 = var_72;
  484. auto var_74 = (var_73) >> 0x38;
  485. auto var_75 = (var_72) ^ (var_74);
  486. return (var_75)-(0x5b00b756f06fc34b);
  487. }
  488. }
  489. }
  490. return 0;
  491. }
  492. return 0;
  493.  
  494. }
  495.  
  496. QWORD DecryptBone()
  497. {
  498. QWORD encrypted_address = *(QWORD*)(baseModuleAddr + offsets::bone::ENCRYPT_PTR_OFFSET);
  499.  
  500. if (encrypted_address)
  501. {
  502. QWORD reversedAddr = *(QWORD*)(baseModuleAddr + offsets::bone::REVERSED_ADDRESS);
  503. QWORD last_key = *(QWORD*)(_byteswap_uint64(reversedAddr)+offsets::bone::LastKey_XOR);
  504.  
  505. if (encrypted_address && last_key)
  506. {
  507. QWORD peb = Peb;
  508. auto r8 = encrypted_address;
  509. QWORD rdi, rcx = peb, rdx, rbx, rbp, rax, rsi, r9, r10, r11, r12, r13, r14, r15 = 0;
  510.  
  511. Settings::BonePointerCase = _rotl64(~peb, 0x2E) & 0xF;
  512.  
  513. switch (Settings::BonePointerCase)
  514. {
  515. case 0:
  516. {
  517. auto var_4 = baseModuleAddr + 0x32365032;
  518. auto var_11 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  519. auto var_15 = encrypted_address;
  520. auto var_16 = (var_15) >> 0x1e;
  521. auto var_17 = (encrypted_address) ^ (var_16);
  522. auto var_20 = var_17;
  523. auto var_21 = (var_20) >> 0x3c;
  524. auto var_22 = (var_17) ^ (var_21);
  525. auto var_41 = ~peb;
  526. auto var_42 = (var_41) ^ (var_4);
  527. auto var_43 = ((var_42)+((var_22)+(((0xffffffffffffeab3) - (~peb)) - (baseModuleAddr)))) ^ (~peb);
  528. auto var_44 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_11) + 0xf);
  529. auto var_45 = (var_44) * (var_43);
  530. auto var_51 = var_45;
  531. auto var_52 = (var_51) >> 0x2;
  532. auto var_53 = (var_45) ^ (var_52);
  533. auto var_58 = var_53;
  534. auto var_59 = (var_58) >> 0x4;
  535. auto var_60 = (var_53) ^ (var_59);
  536. auto var_65 = var_60;
  537. auto var_66 = (var_65) >> 0x8;
  538. auto var_67 = (var_60) ^ (var_66);
  539. auto var_70 = var_67;
  540. auto var_71 = (var_70) >> 0x10;
  541. auto var_72 = (var_67) ^ (var_71);
  542. auto var_79 = var_72;
  543. auto var_80 = (var_79) >> 0x20;
  544. auto var_81 = (var_72) ^ (var_80);
  545. auto var_82 = ((var_81)+(~peb)) * (0xbec529cc3b57d1d3);
  546. return var_82;
  547. }
  548. case 1:
  549. {
  550. auto var_13 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  551. auto var_18 = (encrypted_address) * (0xfda06f15dc4f8809);
  552. auto var_25 = baseModuleAddr + 0x3041;
  553. auto var_26 = (~(var_25)) ^ (~peb);
  554. auto var_37 = (var_18)+(var_26);
  555. auto var_38 = (var_37) >> 0x23;
  556. auto var_39 = ((var_18)+(var_26)) ^ (var_38);
  557. auto var_48 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_13) + 0xf);
  558. auto var_49 = (var_39) * (var_48);
  559. auto var_54 = ((var_49)-(~peb)) + (~(baseModuleAddr + 0x4fcc9679));
  560. auto var_55 = (var_54) >> 0x2;
  561. auto var_56 = (((var_49)-(~peb)) + (~(baseModuleAddr + 0x4fcc9679))) ^ (var_55);
  562. auto var_63 = var_56;
  563. auto var_64 = (var_63) >> 0x4;
  564. auto var_65 = (var_56) ^ (var_64);
  565. auto var_77 = var_65;
  566. auto var_78 = (var_77) >> 0x8;
  567. auto var_79 = (var_65) ^ (var_78);
  568. auto var_83 = var_79;
  569. auto var_84 = (var_83) >> 0x10;
  570. auto var_85 = (var_79) ^ (var_84);
  571. auto var_93 = var_85;
  572. auto var_94 = (var_93) >> 0x20;
  573. auto var_95 = (var_94) ^ (var_85);
  574. auto var_99 = (~(baseModuleAddr + 0x410a6e94)) + ((var_95)+(~peb));
  575. auto var_100 = (var_99) >> 0x14;
  576. auto var_101 = ((~(baseModuleAddr + 0x410a6e94)) + ((var_95)+(~peb))) ^ (var_100);
  577. auto var_103 = var_101;
  578. auto var_104 = (var_103) >> 0x28;
  579. auto var_105 = (var_101) ^ (var_104);
  580. return var_105;
  581. }
  582. case 2:
  583. {
  584. auto var_3 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  585. auto var_8 = (encrypted_address) ^ (~peb);
  586. auto var_10 = (var_8) ^ (baseModuleAddr + 0xe9f6);
  587. auto var_11 = var_10;
  588. auto var_12 = (var_11) >> 0x27;
  589. auto var_13 = (var_10) ^ (var_12);
  590. auto var_19 = var_13;
  591. auto var_20 = (var_19) >> 0x21;
  592. auto var_21 = (var_13) ^ (var_20);
  593. auto var_22 = (var_21) * (0x49171c9cee8a71ed);
  594. auto var_27 = ~peb;
  595. auto var_28 = baseModuleAddr + 0x2738d535;
  596. auto var_30 = (var_22) ^ ((~(var_27)) + (~(var_28)));
  597. auto var_35 = var_30;
  598. auto var_36 = (var_35) >> 0x1c;
  599. auto var_37 = (var_30) ^ (var_36);
  600. auto var_45 = var_37;
  601. auto var_46 = (var_45) >> 0x38;
  602. auto var_47 = (var_46) ^ (var_37);
  603. auto var_48 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_3) + 0xf);
  604. auto var_49 = (var_48) * (var_47);
  605. auto var_51 = (var_49) ^ (0x53a7cb1406485a75);
  606. return var_51;
  607. }
  608. case 3:
  609. {
  610. auto var_12 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  611. auto var_16 = (encrypted_address) * (0xc27ea91e53e37e3b);
  612. auto var_28 = (~(baseModuleAddr + 0x3908e86a)) * (~peb);
  613. auto var_34 = (var_16)+(var_28);
  614. auto var_35 = (var_34) >> 0x1d;
  615. auto var_36 = ((var_16)+(var_28)) ^ (var_35);
  616. auto var_44 = var_36;
  617. auto var_45 = (var_44) >> 0x3a;
  618. auto var_46 = (var_36) ^ (var_45);
  619. auto var_47 = var_46;
  620. auto var_48 = (var_47) >> 0x15;
  621. auto var_49 = (var_46) ^ (var_48);
  622. auto var_53 = var_49;
  623. auto var_56 = (var_53) >> 0x2a;
  624. auto var_57 = (var_56) ^ (var_49);
  625. auto var_58 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_12) + 0xf);
  626. auto var_59 = (var_58) * (var_57);
  627. auto var_61 = (var_59) ^ (0x39ec5b998643a846);
  628. auto var_73 = ~peb;
  629. auto var_74 = (var_73) ^ (baseModuleAddr + 0x7370);
  630. return ((var_61)-(0x32310e0aa749dc15)) - (var_74);
  631. }
  632. case 4:
  633. {
  634. auto var_9 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  635. auto var_13 = (encrypted_address) ^ (~peb);
  636. auto var_22 = var_13;
  637. auto var_23 = (var_22) >> 0x19;
  638. auto var_24 = (var_13) ^ (var_23);
  639. auto var_29 = var_24;
  640. auto var_30 = (var_29) >> 0x32;
  641. auto var_31 = (var_24) ^ (var_30);
  642. auto var_46 = (var_31) * (*reinterpret_cast<uint64_t*>(_byteswap_uint64(var_9) + 0xf));
  643. auto var_56 = ~peb;
  644. auto var_57 = (var_56) * (baseModuleAddr + 0xfad1);
  645. auto var_65 = ~peb;
  646. auto var_66 = (~(var_65)) ^ (baseModuleAddr + 0x16f1);
  647. auto var_67 = ((((var_46)+(0x232faa362b4f5caa)) + ((var_57)+(0x423bbfbab7f5ee22))) - (var_66)) * (0xea53aa0af4ebc2a1);
  648. return var_67;
  649. }
  650. case 5:
  651. {
  652. auto var_3 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  653. auto var_15 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(_byteswap_uint64(var_3) + 0xf));
  654. auto var_21 = ~peb;
  655. auto var_22 = (var_21) * (baseModuleAddr + 0x5e95);
  656. auto var_31 = (((var_15)-(var_22)) + (~peb)) * (0x4527ba802df3beb7);
  657. auto var_34 = var_31;
  658. auto var_35 = (var_34) >> 0x3;
  659. auto var_36 = (var_31) ^ (var_35);
  660. auto var_38 = var_36;
  661. auto var_39 = (var_38) >> 0x6;
  662. auto var_40 = (var_36) ^ (var_39);
  663. auto var_46 = var_40;
  664. auto var_47 = (var_46) >> 0xc;
  665. auto var_48 = (var_40) ^ (var_47);
  666. auto var_54 = var_48;
  667. auto var_55 = (var_54) >> 0x18;
  668. auto var_56 = (var_48) ^ (var_55);
  669. auto var_66 = var_56;
  670. auto var_67 = (var_66) >> 0x30;
  671. auto var_68 = (var_56) ^ (var_67);
  672. auto var_70 = (var_68)+(0x3ea9830e14a5504c);
  673. auto var_71 = (var_70) >> 0x16;
  674. auto var_72 = ((var_68)+(0x3ea9830e14a5504c)) ^ (var_71);
  675. auto var_77 = var_72;
  676. auto var_78 = (var_77) >> 0x2c;
  677. auto var_79 = (var_72) ^ (var_78);
  678. return (var_79)-(0x5d9d1d7f3eee5e8f);
  679. }
  680. case 6:
  681. {
  682. auto var_4 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  683. auto var_22 = ((encrypted_address)+(~peb)) ^ (baseModuleAddr);
  684. auto var_30 = (var_22) * (*reinterpret_cast<uint64_t*>(_byteswap_uint64(var_4) + 0xf));
  685. auto var_39 = (var_30) * (0xdb8efaff6cf98a0f);
  686. auto var_54 = (((var_39)-(0x2a20be5e1252ff0f)) - (baseModuleAddr)) ^ (0x97991596a6a37db);
  687. auto var_65 = var_54;
  688. auto var_66 = (var_65) >> 0x1a;
  689. auto var_67 = (var_54) ^ (var_66);
  690. auto var_69 = var_67;
  691. auto var_70 = (var_69) >> 0x34;
  692. auto var_71 = (var_67) ^ (var_70);
  693. return var_71;
  694. }
  695. case 7:
  696. {
  697. auto var_4 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  698. auto var_5 = 0xa1afcde07247cc98;
  699. auto var_16 = ~peb;
  700. auto var_17 = (encrypted_address) ^ (~(var_16));
  701. auto var_19 = (var_17) ^ (baseModuleAddr + 0x78273619);
  702. auto var_39 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_4) + 0xf);
  703. auto var_40 = (var_39) * ((0x33eee4c46acbef87) + ((var_19)-(~peb)));
  704. auto var_41 = var_40;
  705. auto var_42 = (var_41) >> 0x11;
  706. auto var_43 = (var_40) ^ (var_42);
  707. auto var_45 = var_43;
  708. auto var_46 = (var_45) >> 0x22;
  709. auto var_47 = (var_43) ^ (var_46);
  710. auto var_51 = (var_47) ^ (var_5);
  711. auto var_54 = ~peb;
  712. auto var_55 = (~(var_54)) ^ (baseModuleAddr + 0x3e24253b);
  713. auto var_56 = ((var_51)-(var_55)) * (0xf9d46cfab45e86d5);
  714. return var_56;
  715. }
  716.  
  717. case 8:
  718. {
  719. auto var_3 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  720. auto var_32 = encrypted_address;
  721. auto var_33 = (var_32) >> 0x15;
  722. auto var_34 = (encrypted_address) ^ (var_33);
  723. auto var_49 = var_34;
  724. auto var_50 = (var_49) >> 0x2a;
  725. auto var_51 = (var_50) ^ (var_34);
  726. auto var_52 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_3) + 0xf);
  727. auto var_53 = (var_52) * (var_51);
  728. auto var_59 = baseModuleAddr + 0x624687ce;
  729. auto var_60 = (var_59) * (~peb);
  730. auto var_66 = (((var_53)-(var_60)) + ((baseModuleAddr + 0x4a584b54) - (~peb))) ^ (baseModuleAddr);
  731. auto var_67 = (var_66) * (0x897dca7f0bb72f39);
  732. return (var_67)-(~peb);
  733. }
  734. case 9:
  735. {
  736. auto var_8 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  737. auto var_13 = encrypted_address;
  738. auto var_14 = (var_13) >> 0x1b;
  739. auto var_15 = (encrypted_address) ^ (var_14);
  740. auto var_23 = var_15;
  741. auto var_24 = (var_23) >> 0x36;
  742. auto var_25 = (var_15) ^ (var_24);
  743. auto var_32 = var_25;
  744. auto var_33 = (var_32) ^ (0x12173baf83bbce16);
  745. auto var_34 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_8) + 0xf);
  746. auto var_35 = (var_34) * (var_33);
  747. auto var_36 = var_35;
  748. auto var_37 = (var_36) >> 0x14;
  749. auto var_38 = (var_35) ^ (var_37);
  750. auto var_39 = var_38;
  751. auto var_40 = (var_39) >> 0x28;
  752. auto var_41 = (var_38) ^ (var_40);
  753. auto var_53 = ((var_41)+(~peb)) * (0xcb128b87db88c5d7);
  754. auto var_54 = baseModuleAddr + 0xd4b5;
  755. auto var_55 = (var_53) ^ (~(var_54));
  756. auto var_56 = (var_55) ^ (~peb);
  757. auto var_63 = (var_56) * (0x4826b6b54998f05d);
  758. return var_63;
  759. }
  760.  
  761. case 10:
  762. {
  763. auto var_4 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  764. auto var_18 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(_byteswap_uint64(var_4) + 0xf));
  765. auto var_26 = var_18;
  766. auto var_27 = (var_26) >> 0x8;
  767. auto var_28 = (var_18) ^ (var_27);
  768. auto var_29 = var_28;
  769. auto var_30 = (var_29) >> 0x10;
  770. auto var_31 = (var_28) ^ (var_30);
  771. auto var_36 = var_31;
  772. auto var_37 = (var_36) >> 0x20;
  773. auto var_38 = (var_31) ^ (var_37);
  774. auto var_51 = var_38;
  775. auto var_52 = (var_51) >> 0x28;
  776. auto var_53 = (var_38) ^ (var_52);
  777. auto var_58 = ((var_53)-(0x5ed4d8f5a2cee38a)) * (0x3bb9e7d86476d6c3);
  778. auto var_63 = (var_58) ^ (~peb);
  779. auto var_71 = baseModuleAddr + 0x7a6c;
  780. auto var_72 = var_63;
  781. auto var_73 = (var_72) >> 0x23;
  782. auto var_74 = ((var_71)-(~peb)) ^ (var_73);
  783. auto var_75 = (var_63) ^ (var_74);
  784. return var_75;
  785. }
  786.  
  787.  
  788. case 11:
  789. {
  790. auto var_4 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  791. auto var_8 = encrypted_address;
  792. auto var_9 = (var_8) >> 0x20;
  793. auto var_10 = (encrypted_address) ^ (var_9);
  794. auto var_20 = (((var_10)+(~peb)) + (baseModuleAddr)) * (0x75cdd6dacf5fc289);
  795. auto var_21 = ((var_20)-(0x2a4412ae79d0ae10)) ^ (0xe77bb1b70eafe7c8);
  796. auto var_29 = (var_21) * (*reinterpret_cast<uint64_t*>(_byteswap_uint64(var_4) + 0xf));
  797. auto var_36 = ((((var_29)-(baseModuleAddr)) + (0xffffffff8490c3da)) + (~peb)) ^ (baseModuleAddr);
  798. return var_36;
  799. }
  800.  
  801.  
  802. case 12:
  803. {
  804. auto var_3 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  805. auto var_9 = encrypted_address;
  806. auto var_10 = (var_9) >> 0x1d;
  807. auto var_11 = (encrypted_address) ^ (var_10);
  808. auto var_28 = var_11;
  809. auto var_29 = (var_28) >> 0x3a;
  810. auto var_30 = (var_11) ^ (var_29);
  811. auto var_34 = (var_30) ^ (~peb);
  812. auto var_36 = ~peb;
  813. auto var_38 = var_34;
  814. auto var_39 = (var_38) >> 0x14;
  815. auto var_40 = (var_34) ^ (var_39);
  816. auto var_45 = var_40;
  817. auto var_46 = (var_45) >> 0x28;
  818. auto var_47 = (((~(var_36)) - (baseModuleAddr)) - (0x4c2a)) ^ (var_46);
  819. auto var_48 = (var_47) ^ (var_40);
  820. auto var_49 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_3) + 0xf);
  821. auto var_50 = (var_49) * (var_48);
  822. auto var_51 = (var_50) * (0xc6a897a906a081f7);
  823. return (var_51)+(0x66b73083cce4738);
  824. }
  825.  
  826.  
  827. case 13:
  828. {
  829. auto var_13 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  830. auto var_17 = encrypted_address;
  831. auto var_18 = (var_17) >> 0x4;
  832. auto var_19 = (encrypted_address) ^ (var_18);
  833. auto var_22 = var_19;
  834. auto var_23 = (var_22) >> 0x8;
  835. auto var_24 = (var_19) ^ (var_23);
  836. auto var_28 = var_24;
  837. auto var_29 = (var_28) >> 0x10;
  838. auto var_30 = (var_24) ^ (var_29);
  839. auto var_37 = var_30;
  840. auto var_38 = (var_37) >> 0x20;
  841. auto var_39 = (var_30) ^ (var_38);
  842. auto var_48 = (var_39) * (0x7a6e858d82f5a169);
  843. auto var_49 = ((var_48)-(~peb)) + (baseModuleAddr + 0x1487642c);
  844. auto var_50 = (var_49) >> 0x1e;
  845. auto var_51 = (((var_48)-(~peb)) + (baseModuleAddr + 0x1487642c)) ^ (var_50);
  846. auto var_57 = var_51;
  847. auto var_58 = (var_57) >> 0x3c;
  848. auto var_59 = (var_51) ^ (var_58);
  849. auto var_68 = (var_59) * (*reinterpret_cast<uint64_t*>(_byteswap_uint64(var_13) + 0xf));
  850. auto var_79 = ~peb;
  851. return ((0x8768af88e9ae75fa) + ((~(var_79)) + ((var_68)-(baseModuleAddr)))) + (baseModuleAddr);
  852. }
  853.  
  854.  
  855. case 14:
  856. {
  857. auto var_11 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  858. auto var_22 = (encrypted_address) * (*reinterpret_cast<uint64_t*>(_byteswap_uint64(var_11) + 0xf));
  859. auto var_30 = var_22;
  860. auto var_31 = (var_30) >> 0xe;
  861. auto var_32 = (var_22) ^ (var_31);
  862. auto var_37 = var_32;
  863. auto var_38 = (var_37) >> 0x1c;
  864. auto var_39 = (var_32) ^ (var_38);
  865. auto var_46 = var_39;
  866. auto var_47 = (var_46) >> 0x38;
  867. auto var_48 = (var_39) ^ (var_47);
  868. auto var_49 = baseModuleAddr + 0x5253da5e;
  869. auto var_50 = ((var_48)+(0x77b214de20b62132)) ^ ((var_49)-(~peb));
  870. auto var_56 = (var_50) * (0x3a9a0158a4d04c2d);
  871. auto var_68 = (var_56) ^ (0x4bbaa0f6d504d6e8);
  872. auto var_75 = (var_68)-(~peb);
  873. auto var_76 = (var_75) >> 0x7;
  874. auto var_77 = ((var_68)-(~peb)) ^ (var_76);
  875. auto var_81 = var_77;
  876. auto var_82 = (var_81) >> 0xe;
  877. auto var_83 = (var_77) ^ (var_82);
  878. auto var_91 = var_83;
  879. auto var_92 = (var_91) >> 0x1c;
  880. auto var_93 = (var_83) ^ (var_92);
  881. auto var_94 = var_93;
  882. auto var_95 = (var_94) >> 0x38;
  883. auto var_96 = (var_93) ^ (var_95);
  884. return var_96;
  885. }
  886. case 15:
  887. {
  888. auto var_8 = *reinterpret_cast<uint64_t*>(baseModuleAddr + 0x5b961f1);
  889. auto var_14 = (encrypted_address) ^ (0xb4529d9c38d58369);
  890. auto var_15 = ~peb;
  891. auto var_21 = (((var_14)+(~(var_15))) + (baseModuleAddr + 0x8d34)) ^ ((baseModuleAddr + 0x1d7d730f) + (~peb));
  892. auto var_26 = (var_21) * (0x536d7b36970296db);
  893. auto var_34 = *reinterpret_cast<uint64_t*>(_byteswap_uint64(var_8) + 0xf);
  894. auto var_35 = (var_34) * ((var_26)+((baseModuleAddr) * 1));
  895. auto var_40 = var_35;
  896. auto var_41 = (var_40) >> 0x24;
  897. auto var_42 = (var_35) ^ (var_41);
  898. return (((var_42)-(baseModuleAddr)) + (0xffffffffffff69ff)) + (~peb);
  899. }
  900. }
  901. return r8;
  902. }
  903. return 0;
  904. }
  905. }
  906.  
  907. QWORD DecryptBoneIndexPtr(uint32_t i)
  908. {
  909. auto var_1 = (i) * (0x13c8);
  910. uint64_t var_3;
  911. uint64_t var_4 = _umul128(0xe16108ff1793eeb9, var_1, (DWORD64*)&var_3);
  912. auto var_5 = (var_3) >> 0xd;
  913. auto var_6 = (var_5) * (0x2459);
  914. auto var_7 = ((var_1)-(var_6)) * (0x2459);
  915. uint64_t var_8;
  916. uint64_t var_9 = _umul128(0xbb4776d52876e0dd, var_7, (DWORD64*)&var_8);
  917. auto var_10 = (var_8) >> 0xd;
  918. auto var_11 = (var_10) * (0x2bbe);
  919. uint64_t var_12;
  920. uint64_t var_13 = _umul128(0x889abf4cb4e4eb53, (var_7)-(var_11), (DWORD64*)&var_12);
  921. auto var_14 = (var_12) >> 0xa;
  922. auto var_15 = (var_14) * (0x77f);
  923. uint64_t var_16;
  924. uint64_t var_17 = _umul128(0xcccccccccccccccd, (var_7)-(var_11), (DWORD64*)&var_16);
  925. auto var_18 = (var_16) >> 0x3;
  926. auto var_19 = ((var_7)-(var_11)) * (0x16);
  927. auto var_20 = *reinterpret_cast<uint16_t*>(((var_19)-((((var_15)+(var_18)) + (((var_15)+(var_18)) * 4)) << (0x2))) + 0x5b98fb0 + ((baseModuleAddr) * 1));
  928. auto var_21 = (var_20) * (0x13c8);
  929. auto var_22 = 0x8a63ab88aa8dd5e7;
  930. uint64_t var_23;
  931. uint64_t var_24 = _umul128(var_22, var_21, (DWORD64*)&var_23);
  932. auto var_25 = 0x8a63ab88aa8dd5e7;
  933. auto var_26 = (var_23) >> 0xc;
  934. auto var_27 = (var_26) * (0x1d99);
  935. auto var_28 = ((var_21)-(var_27)) * (0x2b81);
  936. uint64_t var_29;
  937. uint64_t var_30 = _umul128(var_25, var_28, (DWORD64*)&var_29);
  938. auto var_31 = (var_29) >> 0xc;
  939. auto var_32 = (var_31) * (0x1d99);
  940. uint64_t var_33;
  941. uint64_t var_34 = _umul128(0xbfa02fe80bfa02ff, (var_28)-(var_32), (DWORD64*)&var_33);
  942. auto var_35 = (var_33) >> 0x7;
  943. auto var_36 = (var_35) * (0xab);
  944. uint64_t var_37;
  945. uint64_t var_38 = _umul128(0xfc0fc0fc0fc0fc1, (var_28)-(var_32), (DWORD64*)&var_37);
  946. auto var_39 = (var_37) >> 0x2;
  947. auto var_40 = ((var_36)+(var_39)) * (0x82);
  948. auto var_41 = ((var_28)-(var_32)) * (0x84);
  949. auto var_42 = *reinterpret_cast<uint16_t*>(((var_41)-(var_40)) + 0x5ba25a0 + ((baseModuleAddr) * 1));
  950. return var_42;
  951. }
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!