API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 30th, 2016
62
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 30.96 KB | None | 0 0
raw download clone embed print report
  1. char __thiscall sub_801B70(void *this, int a2, void *a3)
  2. {
  3. void *v3; // esi@1
  4. void **v4; // eax@5
  5. char (*v5)[4]; // eax@7
  6. void **v6; // eax@7
  7. char (*v7)[4]; // eax@9
  8. void **v8; // eax@9
  9. char (*v9)[4]; // eax@11
  10. void **v10; // eax@11
  11. char (*v11)[4]; // eax@13
  12. void **v12; // eax@13
  13. char (*v13)[4]; // eax@15
  14. void **v14; // eax@15
  15. char (*v15)[4]; // eax@17
  16. void **v16; // eax@17
  17. char (*v17)[4]; // eax@19
  18. void **v18; // eax@19
  19. char (*v19)[4]; // eax@21
  20. void **v20; // eax@21
  21. char (*v21)[4]; // eax@23
  22. void **v22; // eax@23
  23. char (*v23)[4]; // eax@25
  24. void **v24; // eax@25
  25. char (*v25)[4]; // eax@27
  26. void **v26; // eax@27
  27. char (*v27)[4]; // eax@29
  28. void **v28; // eax@29
  29. char (*v29)[4]; // eax@31
  30. void **v30; // eax@31
  31. void *v31; // edi@33
  32. size_t v32; // ST28_4@33
  33. char (*v33)[4]; // eax@33
  34. void **v34; // eax@33
  35. char (*v35)[4]; // eax@35
  36. void **v36; // eax@35
  37. char (*v37)[4]; // eax@37
  38. void **v38; // eax@37
  39. char (*v39)[4]; // eax@39
  40. void **v40; // eax@39
  41. char (*v41)[4]; // eax@41
  42. void *v42; // eax@41
  43. signed int v43; // edi@42
  44. void **v44; // eax@49
  45. char (*v45)[4]; // eax@51
  46. void *v46; // eax@51
  47. signed int v47; // edi@52
  48. void **v48; // eax@59
  49. char (*v49)[4]; // eax@61
  50. void *v50; // eax@61
  51. signed int v51; // edi@62
  52. void **v52; // eax@69
  53. char (*v53)[4]; // eax@71
  54. char *v54; // eax@71
  55. signed int v55; // edi@72
  56. signed int v56; // ebx@72
  57. int v57; // ecx@79
  58. signed int v58; // eax@79
  59. bool v59; // cf@79
  60. void **v60; // eax@83
  61. char (*v61)[4]; // eax@85
  62. int v62; // ebx@85
  63. void *v63; // eax@85
  64. signed int v64; // edi@86
  65. void **v65; // eax@93
  66. char (*v66)[4]; // eax@95
  67. void *v67; // edi@95
  68. void **v68; // eax@95
  69. char (*v69)[4]; // eax@97
  70. int v70; // ebx@97
  71. void *v71; // eax@97
  72. signed int v72; // edi@98
  73. void **v73; // eax@105
  74. char (*v74)[4]; // eax@107
  75. int v75; // ebx@107
  76. void *v76; // eax@107
  77. signed int v77; // edi@108
  78. void **v78; // eax@115
  79. char (*v79)[4]; // eax@117
  80. int v80; // ebx@117
  81. void *v81; // eax@117
  82. signed int v82; // edi@118
  83. void **v83; // eax@125
  84. char (*v84)[4]; // eax@127
  85. void **v85; // eax@127
  86. char (*v86)[4]; // eax@129
  87. void **v87; // eax@129
  88. char (*v88)[4]; // eax@131
  89. void **v89; // eax@131
  90. char (*v90)[4]; // eax@133
  91. void **v91; // eax@133
  92. char (*v92)[4]; // eax@135
  93. void **v93; // eax@135
  94. char (*v94)[4]; // eax@137
  95. void **v95; // eax@137
  96. char (*v96)[4]; // eax@139
  97. void *v97; // edi@139
  98. int v98; // ebx@139
  99. void **v99; // eax@139
  100. char (*v100)[4]; // eax@141
  101. char *v101; // eax@141
  102. bool v102; // zf@141
  103. int v103; // eax@142
  104. int v104; // edi@143
  105. int v105; // edi@147
  106. void **v106; // eax@147
  107. char (*v107)[4]; // eax@149
  108. void **v108; // eax@150
  109. char (*v109)[4]; // eax@152
  110. const char *v110; // eax@152
  111. const char *v111; // ebx@152
  112. int v112; // edi@154
  113. void **v113; // eax@156
  114. int v114; // ebx@156
  115. char (*v115)[4]; // eax@158
  116. void *v116; // eax@158
  117. signed int v117; // edi@159
  118. char *v118; // eax@166
  119. void **v119; // eax@172
  120. int v120; // ebx@172
  121. char (*v121)[4]; // eax@174
  122. void *v122; // eax@174
  123. signed int v123; // edi@175
  124. char *v124; // eax@182
  125. void **v125; // eax@187
  126. int v126; // ebx@187
  127. char (*v127)[4]; // eax@189
  128. void *v128; // eax@189
  129. signed int v129; // edi@190
  130. unsigned int v130; // ecx@197
  131. signed int v131; // eax@197
  132. void **v132; // eax@203
  133. char (*v133)[4]; // eax@205
  134. int v134; // edi@205
  135. int v135; // ebx@205
  136. void *v136; // eax@205
  137. signed int v137; // edi@206
  138. void **v138; // eax@213
  139. char (*v139)[4]; // eax@215
  140. void **v140; // eax@215
  141. char (*v141)[4]; // eax@217
  142. void **v142; // eax@217
  143. char (*v143)[4]; // eax@219
  144. void **v144; // eax@219
  145. char (*v145)[4]; // eax@221
  146. double v146; // st7@221
  147. double v147; // st6@221
  148. unsigned int v148; // ecx@221
  149. signed int v149; // eax@221
  150. double v150; // rt0@222
  151. double v151; // rt1@225
  152. double v152; // st6@225
  153. double v153; // st7@225
  154. char (*v154)[4]; // eax@236
  155. char (*v155)[4]; // eax@236
  156. char (*v156)[4]; // eax@236
  157. void **v157; // eax@236
  158. char (*v158)[4]; // eax@238
  159. void *v159; // ebx@238
  160. void *v160; // edi@238
  161. char v161; // al@239
  162. char (*v162)[4]; // eax@239
  163. char *v163; // eax@239
  164. bool v164; // sf@241
  165. unsigned __int8 v165; // of@241
  166. signed int v166; // eax@242
  167. int v167; // ebx@243
  168. int v168; // eax@243
  169. void **v169; // ecx@244
  170. void **v170; // eax@250
  171. char (*v171)[4]; // eax@252
  172. char *v172; // eax@252
  173. char result; // al@264
  174. unsigned int v174; // [sp+4h] [bp-328h]@1
  175. int v175; // [sp+14h] [bp-318h]@161
  176. int v176; // [sp+18h] [bp-314h]@165
  177. int v177; // [sp+1Ch] [bp-310h]@1
  178. int v178; // [sp+20h] [bp-30Ch]@1
  179. void *v179; // [sp+24h] [bp-308h]@42
  180. char *v180; // [sp+28h] [bp-304h]@41
  181. void *v181; // [sp+2Ch] [bp-300h]@1
  182. void *v182; // [sp+30h] [bp-2FCh]@1
  183. void *v183; // [sp+34h] [bp-2F8h]@5
  184. int v184[5]; // [sp+38h] [bp-2F4h]@217
  185. int v185[5]; // [sp+4Ch] [bp-2E0h]@221
  186. int v186[5]; // [sp+60h] [bp-2CCh]@219
  187. int v187[5]; // [sp+74h] [bp-2B8h]@215
  188. int v188; // [sp+88h] [bp-2A4h]@192
  189. int v189; // [sp+8Ch] [bp-2A0h]@196
  190. int v190; // [sp+90h] [bp-29Ch]@196
  191. int v191; // [sp+94h] [bp-298h]@196
  192. int v192; // [sp+98h] [bp-294h]@196
  193. char v193; // [sp+9Ch] [bp-290h]@156
  194. char v194; // [sp+19Ch] [bp-190h]@139
  195. char v195; // [sp+29Ch] [bp-90h]@44
  196. unsigned int v196; // [sp+31Ch] [bp-10h]@1
  197. int v197; // [sp+328h] [bp-4h]@1
  198. int savedregs; // [sp+32Ch] [bp+0h]@1
  199.  
  200. v196 = (unsigned int)&savedregs ^ dword_B68780;
  201. v174 = (unsigned int)&savedregs ^ dword_B68780;
  202. v3 = this;
  203. v177 = a2;
  204. v178 = EqGetTime();
  205. CXStr::CXStr(&v181, (char *)a3);
  206. v197 = 0;
  207. v182 = 0;
  208. LOBYTE(v197) = 1;
  209. if ( v181 && *((_DWORD *)v181 + 2) )
  210. sub_806EC0(`string');
  211. if ( (unsigned __int8)sub_7EBB70(a2, a3) )
  212. {
  213. v4 = (void **)operator+((int)&v183, &v181, "deity");
  214. LOBYTE(v197) = 2;
  215. sub_805D90(&v182, v4);
  216. LOBYTE(v197) = 1;
  217. if ( v183 )
  218. CXStr::FreeRep(v183);
  219. v5 = sub_8061C0(&v182);
  220. *((_DWORD *)v3 + 8761) = sub_80E1B0(v5, 0);
  221. v6 = (void **)operator+((int)&v183, &v181, "highest_level");
  222. LOBYTE(v197) = 3;
  223. sub_805D90(&v182, v6);
  224. LOBYTE(v197) = 1;
  225. if ( v183 )
  226. CXStr::FreeRep(v183);
  227. v7 = sub_8061C0(&v182);
  228. *((_BYTE *)v3 + 35049) = sub_80E1B0(v7, 0);
  229. v8 = (void **)operator+((int)&v183, &v181, "sobriety");
  230. LOBYTE(v197) = 4;
  231. sub_805D90(&v182, v8);
  232. LOBYTE(v197) = 1;
  233. if ( v183 )
  234. CXStr::FreeRep(v183);
  235. v9 = sub_8061C0(&v182);
  236. *((_DWORD *)v3 + 8763) = sub_80E1B0(v9, 0);
  237. v10 = (void **)operator+((int)&v183, &v181, "HairColor");
  238. LOBYTE(v197) = 5;
  239. sub_805D90(&v182, v10);
  240. LOBYTE(v197) = 1;
  241. if ( v183 )
  242. CXStr::FreeRep(v183);
  243. v11 = sub_8061C0(&v182);
  244. *((_BYTE *)v3 + 35056) = sub_80E1B0(v11, 0);
  245. v12 = (void **)operator+((int)&v183, &v181, "BeardColor");
  246. LOBYTE(v197) = 6;
  247. sub_805D90(&v182, v12);
  248. LOBYTE(v197) = 1;
  249. if ( v183 )
  250. CXStr::FreeRep(v183);
  251. v13 = sub_8061C0(&v182);
  252. *((_BYTE *)v3 + 35057) = sub_80E1B0(v13, 0);
  253. v14 = (void **)operator+((int)&v183, &v181, "NpcTintIndex");
  254. LOBYTE(v197) = 7;
  255. sub_805D90(&v182, v14);
  256. LOBYTE(v197) = 1;
  257. if ( v183 )
  258. CXStr::FreeRep(v183);
  259. v15 = sub_8061C0(&v182);
  260. *((_DWORD *)v3 + 8765) = sub_80E1B0(v15, 0);
  261. v16 = (void **)operator+((int)&v183, &v181, "LeftEye");
  262. LOBYTE(v197) = 8;
  263. sub_805D90(&v182, v16);
  264. LOBYTE(v197) = 1;
  265. if ( v183 )
  266. CXStr::FreeRep(v183);
  267. v17 = sub_8061C0(&v182);
  268. *((_BYTE *)v3 + 35064) = sub_80E1B0(v17, 0);
  269. v18 = (void **)operator+((int)&v183, &v181, "RightEye");
  270. LOBYTE(v197) = 9;
  271. sub_805D90(&v182, v18);
  272. LOBYTE(v197) = 1;
  273. if ( v183 )
  274. CXStr::FreeRep(v183);
  275. v19 = sub_8061C0(&v182);
  276. *((_BYTE *)v3 + 35065) = sub_80E1B0(v19, 0);
  277. v20 = (void **)operator+((int)&v183, &v181, "Hair");
  278. LOBYTE(v197) = 10;
  279. sub_805D90(&v182, v20);
  280. LOBYTE(v197) = 1;
  281. if ( v183 )
  282. CXStr::FreeRep(v183);
  283. v21 = sub_8061C0(&v182);
  284. *((_BYTE *)v3 + 35066) = sub_80E1B0(v21, 0);
  285. v22 = (void **)operator+((int)&v183, &v181, "Beard");
  286. LOBYTE(v197) = 11;
  287. sub_805D90(&v182, v22);
  288. LOBYTE(v197) = 1;
  289. if ( v183 )
  290. CXStr::FreeRep(v183);
  291. v23 = sub_8061C0(&v182);
  292. *((_BYTE *)v3 + 35067) = sub_80E1B0(v23, 0);
  293. v24 = (void **)operator+((int)&v183, &v181, "OldFace");
  294. LOBYTE(v197) = 12;
  295. sub_805D90(&v182, v24);
  296. LOBYTE(v197) = 1;
  297. if ( v183 )
  298. CXStr::FreeRep(v183);
  299. v25 = sub_8061C0(&v182);
  300. *((_BYTE *)v3 + 35068) = sub_80E1B0(v25, 0);
  301. v26 = (void **)operator+((int)&v183, &v181, "AbilityPts");
  302. LOBYTE(v197) = 13;
  303. sub_805D90(&v182, v26);
  304. LOBYTE(v197) = 1;
  305. if ( v183 )
  306. CXStr::FreeRep(v183);
  307. v27 = sub_8061C0(&v182);
  308. *((_DWORD *)v3 + 8768) = sub_80E1B0(v27, 0);
  309. v28 = (void **)operator+((int)&v183, &v181, "pkill");
  310. LOBYTE(v197) = 14;
  311. sub_805D90(&v182, v28);
  312. LOBYTE(v197) = 1;
  313. if ( v183 )
  314. CXStr::FreeRep(v183);
  315. v29 = sub_8061C0(&v182);
  316. *((_BYTE *)v3 + 35048) = (unsigned __int8)sub_80E1B0(v29, 0) != 0;
  317. v30 = (void **)operator+((int)&v183, &v181, "InventoryInstanceData");
  318. LOBYTE(v197) = 15;
  319. sub_805D90(&v182, v30);
  320. LOBYTE(v197) = 1;
  321. if ( v183 )
  322. CXStr::FreeRep(v183);
  323. v31 = (void *)sub_7E4DE0(v174);
  324. v32 = sub_7E4DF0();
  325. v33 = sub_8061C0(&v182);
  326. sub_7BE620(a2, (int)v33, v31, v32);
  327. sub_805DE0(v31);
  328. v34 = (void **)operator+((int)&v183, &v181, "PocketPetSaveString");
  329. LOBYTE(v197) = 16;
  330. sub_805D90(&v182, v34);
  331. LOBYTE(v197) = 1;
  332. if ( v183 )
  333. CXStr::FreeRep(v183);
  334. v35 = sub_8061C0(&v182);
  335. sub_80E2C0((int)v35, (char *)v3 + 35076, 4096, (int)`string');
  336. v36 = (void **)operator+((int)&v183, &v181, "primActor");
  337. LOBYTE(v197) = 17;
  338. sub_805D90(&v182, v36);
  339. LOBYTE(v197) = 1;
  340. if ( v183 )
  341. CXStr::FreeRep(v183);
  342. v37 = sub_8061C0(&v182);
  343. *((_DWORD *)v3 + 9803) = sub_80E1B0(v37, 0);
  344. v38 = (void **)operator+((int)&v183, &v181, "secdActor");
  345. LOBYTE(v197) = 18;
  346. sub_805D90(&v182, v38);
  347. LOBYTE(v197) = 1;
  348. if ( v183 )
  349. CXStr::FreeRep(v183);
  350. v39 = sub_8061C0(&v182);
  351. *((_DWORD *)v3 + 9804) = sub_80E1B0(v39, 0);
  352. v40 = (void **)operator+((int)&v183, &v181, "m_newBodyTint");
  353. LOBYTE(v197) = 19;
  354. sub_805D90(&v182, v40);
  355. LOBYTE(v197) = 1;
  356. if ( v183 )
  357. CXStr::FreeRep(v183);
  358. v41 = sub_8061C0(&v182);
  359. v180 = 0;
  360. v42 = (void *)sub_80E2B0((void *)a2, (int)v41);
  361. v183 = v42;
  362. if ( v42 )
  363. {
  364. v179 = (void *)strlen((const char *)v42);
  365. v43 = 0;
  366. do
  367. {
  368. if ( (signed int)v180 >= (signed int)v179 )
  369. {
  370. *((_DWORD *)v3 + v43 + 4397) = 0;
  371. }
  372. else
  373. {
  374. v180 += sub_8085A0((char *)v183 + (_DWORD)v180, &v195, 44);
  375. *((_DWORD *)v3 + v43 + 4397) = atol(&v195);
  376. }
  377. ++v43;
  378. }
  379. while ( v43 < 9 );
  380. }
  381. else
  382. {
  383. *((_DWORD *)v3 + 4397) = 0;
  384. *((_DWORD *)v3 + 4398) = 0;
  385. *((_DWORD *)v3 + 4399) = 0;
  386. *((_DWORD *)v3 + 4400) = 0;
  387. *((_DWORD *)v3 + 4401) = 0;
  388. *((_DWORD *)v3 + 4402) = 0;
  389. *((_DWORD *)v3 + 4403) = 0;
  390. *((_DWORD *)v3 + 4404) = 0;
  391. *((_DWORD *)v3 + 4405) = 0;
  392. }
  393. v44 = (void **)operator+((int)&v183, &v181, "factiontable");
  394. LOBYTE(v197) = 20;
  395. sub_805D90(&v182, v44);
  396. LOBYTE(v197) = 1;
  397. if ( v183 )
  398. CXStr::FreeRep(v183);
  399. v45 = sub_8061C0(&v182);
  400. v180 = 0;
  401. v46 = (void *)sub_80E2B0((void *)a2, (int)v45);
  402. v183 = v46;
  403. if ( v46 )
  404. {
  405. v179 = (void *)strlen((const char *)v46);
  406. v47 = 0;
  407. do
  408. {
  409. if ( (signed int)v180 >= (signed int)v179 )
  410. {
  411. *((_DWORD *)v3 + v47 + 4406) = 0;
  412. }
  413. else
  414. {
  415. v180 += sub_8085A0((char *)v183 + (_DWORD)v180, &v195, 44);
  416. *((_DWORD *)v3 + v47 + 4406) = atoi(&v195);
  417. }
  418. ++v47;
  419. }
  420. while ( v47 < 2048 );
  421. }
  422. else
  423. {
  424. memset((char *)v3 + 17624, 0, 0x2000u);
  425. }
  426. v48 = (void **)operator+((int)&v183, &v181, "KnownCombatAbilities");
  427. LOBYTE(v197) = 21;
  428. sub_805D90(&v182, v48);
  429. LOBYTE(v197) = 1;
  430. if ( v183 )
  431. CXStr::FreeRep(v183);
  432. v49 = sub_8061C0(&v182);
  433. v180 = 0;
  434. v50 = (void *)sub_80E2B0((void *)a2, (int)v49);
  435. v183 = v50;
  436. if ( v50 )
  437. {
  438. v179 = (void *)strlen((const char *)v50);
  439. v51 = 0;
  440. do
  441. {
  442. if ( (signed int)v180 >= (signed int)v179 )
  443. {
  444. *((_DWORD *)v3 + v51 + 6454) = 0;
  445. }
  446. else
  447. {
  448. v180 += sub_8085A0((char *)v183 + (_DWORD)v180, &v195, 44);
  449. *((_DWORD *)v3 + v51 + 6454) = atoi(&v195);
  450. }
  451. ++v51;
  452. }
  453. while ( v51 < 300 );
  454. }
  455. else
  456. {
  457. memset((char *)v3 + 25816, 0, 0x4B0u);
  458. }
  459. v52 = (void **)operator+((int)&v183, &v181, "spell_used");
  460. LOBYTE(v197) = 22;
  461. sub_805D90(&v182, v52);
  462. LOBYTE(v197) = 1;
  463. if ( v183 )
  464. CXStr::FreeRep(v183);
  465. v53 = sub_8061C0(&v182);
  466. v54 = (char *)sub_80E2B0((void *)a2, (int)v53);
  467. v180 = v54;
  468. if ( v54 )
  469. {
  470. v183 = (void *)strlen(v54);
  471. v55 = 0;
  472. v56 = 0;
  473. do
  474. {
  475. if ( v56 >= (signed int)v183 )
  476. {
  477. *((_DWORD *)v3 + v55 + 6754) = 0;
  478. }
  479. else
  480. {
  481. v56 += sub_8085A0(&v180[v56], &v195, 44);
  482. *((_DWORD *)v3 + v55 + 6754) = atoi(&v195);
  483. }
  484. ++v55;
  485. }
  486. while ( v55 < 13 );
  487. }
  488. else
  489. {
  490. *((_DWORD *)v3 + 6754) = 0;
  491. *((_DWORD *)v3 + 6755) = 0;
  492. *((_DWORD *)v3 + 6756) = 0;
  493. *((_DWORD *)v3 + 6757) = 0;
  494. *((_DWORD *)v3 + 6758) = 0;
  495. *((_DWORD *)v3 + 6759) = 0;
  496. *((_DWORD *)v3 + 6760) = 0;
  497. *((_DWORD *)v3 + 6761) = 0;
  498. *((_DWORD *)v3 + 6762) = 0;
  499. *((_DWORD *)v3 + 6763) = 0;
  500. *((_DWORD *)v3 + 6764) = 0;
  501. *((_DWORD *)v3 + 6765) = 0;
  502. *((_DWORD *)v3 + 6766) = 0;
  503. }
  504. v57 = v178;
  505. v58 = 0;
  506. v59 = 1;
  507. do
  508. {
  509. if ( !v59 )
  510. __debugbreak();
  511. *((_DWORD *)v3 + v58++ + 6754) += v57;
  512. v59 = (unsigned int)v58 < 0xD;
  513. }
  514. while ( v58 < 13 );
  515. v60 = (void **)operator+((int)&v183, &v181, "AATimers");
  516. LOBYTE(v197) = 23;
  517. sub_805D90(&v182, v60);
  518. LOBYTE(v197) = 1;
  519. if ( v183 )
  520. CXStr::FreeRep(v183);
  521. v61 = sub_8061C0(&v182);
  522. v62 = 0;
  523. v63 = (void *)sub_80E2B0((void *)v177, (int)v61);
  524. v179 = v63;
  525. if ( v63 )
  526. {
  527. v178 = strlen((const char *)v63);
  528. v64 = 0;
  529. do
  530. {
  531. if ( v62 >= v178 )
  532. {
  533. *((_DWORD *)v3 + v64 + 6907) = 0;
  534. }
  535. else
  536. {
  537. v62 += sub_8085A0((char *)v179 + v62, &v195, 44);
  538. *((_DWORD *)v3 + v64 + 6907) = atoi(&v195);
  539. }
  540. ++v64;
  541. }
  542. while ( v64 < 100 );
  543. }
  544. else
  545. {
  546. memset((char *)v3 + 27628, 0, 0x190u);
  547. }
  548. v65 = (void **)operator+((int)&v183, &v181, "m_tmLastShield");
  549. LOBYTE(v197) = 24;
  550. sub_805D90(&v182, v65);
  551. LOBYTE(v197) = 1;
  552. if ( v183 )
  553. CXStr::FreeRep(v183);
  554. v66 = sub_8061C0(&v182);
  555. v67 = (void *)v177;
  556. *((_DWORD *)v3 + 9794) = sub_80E1B0(v66, 0);
  557. v68 = (void **)operator+((int)&v183, &v181, "CombatAbilityTimers");
  558. LOBYTE(v197) = 25;
  559. sub_805D90(&v182, v68);
  560. LOBYTE(v197) = 1;
  561. if ( v183 )
  562. CXStr::FreeRep(v183);
  563. v69 = sub_8061C0(&v182);
  564. v70 = 0;
  565. v71 = (void *)sub_80E2B0(v67, (int)v69);
  566. v179 = v71;
  567. if ( v71 )
  568. {
  569. v178 = strlen((const char *)v71);
  570. v72 = 0;
  571. do
  572. {
  573. if ( v70 >= v178 )
  574. {
  575. *((_DWORD *)v3 + v72 + 6767) = 0;
  576. }
  577. else
  578. {
  579. v70 += sub_8085A0((char *)v179 + v70, &v195, 44);
  580. *((_DWORD *)v3 + v72 + 6767) = atoi(&v195);
  581. }
  582. ++v72;
  583. }
  584. while ( v72 < 20 );
  585. }
  586. else
  587. {
  588. *((_DWORD *)v3 + 6767) = 0;
  589. *((_DWORD *)v3 + 6768) = 0;
  590. *((_DWORD *)v3 + 6769) = 0;
  591. *((_DWORD *)v3 + 6770) = 0;
  592. *((_DWORD *)v3 + 6771) = 0;
  593. *((_DWORD *)v3 + 6772) = 0;
  594. *((_DWORD *)v3 + 6773) = 0;
  595. *((_DWORD *)v3 + 6774) = 0;
  596. *((_DWORD *)v3 + 6775) = 0;
  597. *((_DWORD *)v3 + 6776) = 0;
  598. *((_DWORD *)v3 + 6777) = 0;
  599. *((_DWORD *)v3 + 6778) = 0;
  600. *((_DWORD *)v3 + 6779) = 0;
  601. *((_DWORD *)v3 + 6780) = 0;
  602. *((_DWORD *)v3 + 6781) = 0;
  603. *((_DWORD *)v3 + 6782) = 0;
  604. *((_DWORD *)v3 + 6783) = 0;
  605. *((_DWORD *)v3 + 6784) = 0;
  606. *((_DWORD *)v3 + 6785) = 0;
  607. *((_DWORD *)v3 + 6786) = 0;
  608. }
  609. v73 = (void **)operator+((int)&v183, &v181, "LinkedSpellTimers");
  610. LOBYTE(v197) = 26;
  611. sub_805D90(&v182, v73);
  612. LOBYTE(v197) = 1;
  613. if ( v183 )
  614. CXStr::FreeRep(v183);
  615. v74 = sub_8061C0(&v182);
  616. v75 = 0;
  617. v76 = (void *)sub_80E2B0((void *)v177, (int)v74);
  618. v179 = v76;
  619. if ( v76 )
  620. {
  621. v178 = strlen((const char *)v76);
  622. v77 = 0;
  623. do
  624. {
  625. if ( v75 >= v178 )
  626. {
  627. *((_DWORD *)v3 + v77 + 6787) = 0;
  628. }
  629. else
  630. {
  631. v75 += sub_8085A0((char *)v179 + v75, &v195, 44);
  632. *((_DWORD *)v3 + v77 + 6787) = atoi(&v195);
  633. }
  634. ++v77;
  635. }
  636. while ( v77 < 20 );
  637. }
  638. else
  639. {
  640. *((_DWORD *)v3 + 6787) = 0;
  641. *((_DWORD *)v3 + 6788) = 0;
  642. *((_DWORD *)v3 + 6789) = 0;
  643. *((_DWORD *)v3 + 6790) = 0;
  644. *((_DWORD *)v3 + 6791) = 0;
  645. *((_DWORD *)v3 + 6792) = 0;
  646. *((_DWORD *)v3 + 6793) = 0;
  647. *((_DWORD *)v3 + 6794) = 0;
  648. *((_DWORD *)v3 + 6795) = 0;
  649. *((_DWORD *)v3 + 6796) = 0;
  650. *((_DWORD *)v3 + 6797) = 0;
  651. *((_DWORD *)v3 + 6798) = 0;
  652. *((_DWORD *)v3 + 6799) = 0;
  653. *((_DWORD *)v3 + 6800) = 0;
  654. *((_DWORD *)v3 + 6801) = 0;
  655. *((_DWORD *)v3 + 6802) = 0;
  656. *((_DWORD *)v3 + 6803) = 0;
  657. *((_DWORD *)v3 + 6804) = 0;
  658. *((_DWORD *)v3 + 6805) = 0;
  659. *((_DWORD *)v3 + 6806) = 0;
  660. }
  661. v78 = (void **)operator+((int)&v183, &v181, "ItemRecastTimers");
  662. LOBYTE(v197) = 27;
  663. sub_805D90(&v182, v78);
  664. LOBYTE(v197) = 1;
  665. if ( v183 )
  666. CXStr::FreeRep(v183);
  667. v79 = sub_8061C0(&v182);
  668. v80 = 0;
  669. v81 = (void *)sub_80E2B0((void *)v177, (int)v79);
  670. v179 = v81;
  671. if ( v81 )
  672. {
  673. v178 = strlen((const char *)v81);
  674. v82 = 0;
  675. do
  676. {
  677. if ( v80 >= v178 )
  678. {
  679. *((_DWORD *)v3 + v82 + 6807) = 0;
  680. }
  681. else
  682. {
  683. v80 += sub_8085A0((char *)v179 + v80, &v195, 44);
  684. *((_DWORD *)v3 + v82 + 6807) = atoi(&v195);
  685. }
  686. ++v82;
  687. }
  688. while ( v82 < 100 );
  689. }
  690. else
  691. {
  692. memset((char *)v3 + 27228, 0, 0x190u);
  693. }
  694. v83 = (void **)operator+((int)&v183, &v181, "TotalAAsSpent");
  695. LOBYTE(v197) = 28;
  696. sub_805D90(&v182, v83);
  697. LOBYTE(v197) = 1;
  698. if ( v183 )
  699. CXStr::FreeRep(v183);
  700. v84 = sub_8061C0(&v182);
  701. *((_DWORD *)v3 + 9796) = sub_80E1B0(v84, 0);
  702. v85 = (void **)operator+((int)&v183, &v181, "m_bSneak");
  703. LOBYTE(v197) = 29;
  704. sub_805D90(&v182, v85);
  705. LOBYTE(v197) = 1;
  706. if ( v183 )
  707. CXStr::FreeRep(v183);
  708. v86 = sub_8061C0(&v182);
  709. *((_BYTE *)v3 + 39180) = sub_80E1B0(v86, 0) != 0;
  710. v87 = (void **)operator+((int)&v183, &v181, "m_bHide");
  711. LOBYTE(v197) = 30;
  712. sub_805D90(&v182, v87);
  713. LOBYTE(v197) = 1;
  714. if ( v183 )
  715. CXStr::FreeRep(v183);
  716. v88 = sub_8061C0(&v182);
  717. *((_BYTE *)v3 + 39181) = sub_80E1B0(v88, 0) != 0;
  718. v89 = (void **)operator+((int)&v183, &v181, "titlePrefixID");
  719. LOBYTE(v197) = 31;
  720. sub_805D90(&v182, v89);
  721. LOBYTE(v197) = 1;
  722. if ( v183 )
  723. CXStr::FreeRep(v183);
  724. v90 = sub_8061C0(&v182);
  725. *((_DWORD *)v3 + 9806) = sub_80E1B0(v90, 0);
  726. v91 = (void **)operator+((int)&v183, &v181, "titleSuffixID");
  727. LOBYTE(v197) = 32;
  728. sub_805D90(&v182, v91);
  729. LOBYTE(v197) = 1;
  730. if ( v183 )
  731. CXStr::FreeRep(v183);
  732. v92 = sub_8061C0(&v182);
  733. *((_DWORD *)v3 + 9807) = sub_80E1B0(v92, 0);
  734. v93 = (void **)operator+((int)&v183, &v181, "m_soleEnabledZoneId");
  735. LOBYTE(v197) = 33;
  736. sub_805D90(&v182, v93);
  737. LOBYTE(v197) = 1;
  738. if ( v183 )
  739. CXStr::FreeRep(v183);
  740. v94 = sub_8061C0(&v182);
  741. *((_DWORD *)v3 + 9809) = sub_80E1B0(v94, -1);
  742. v95 = (void **)operator+((int)&v183, &v181, "m_profileFadeTime");
  743. LOBYTE(v197) = 34;
  744. sub_805D90(&v182, v95);
  745. LOBYTE(v197) = 1;
  746. if ( v183 )
  747. CXStr::FreeRep(v183);
  748. v96 = sub_8061C0(&v182);
  749. v97 = (void *)v177;
  750. v98 = 0;
  751. *((_DWORD *)v3 + 9810) = sub_80E220(v96, -1);
  752. sub_809C10(&v194, 0x100u, "PetSaveString%d", 0);
  753. v99 = (void **)operator+((int)&v183, &v181, &v194);
  754. LOBYTE(v197) = 35;
  755. sub_805D90(&v182, v99);
  756. LOBYTE(v197) = 1;
  757. if ( v183 )
  758. CXStr::FreeRep(v183);
  759. v100 = sub_8061C0(&v182);
  760. v101 = (char *)sub_80E2B0(v97, (int)v100);
  761. v102 = *((_DWORD *)v3 + 8760) == 0;
  762. v180 = v101;
  763. if ( !v102 )
  764. {
  765. do
  766. {
  767. v103 = *((_DWORD *)v3 + 8760);
  768. if ( v103 )
  769. {
  770. v104 = *(_DWORD *)(v103 + 4096);
  771. operator delete(*((void **)v3 + 8760));
  772. *((_DWORD *)v3 + 8760) = v104;
  773. }
  774. }
  775. while ( *((_DWORD *)v3 + 8760) );
  776. }
  777. for ( ; v180; v180 = (char *)sub_80E2B0((void *)v177, (int)v107) )
  778. {
  779. if ( !*v180 )
  780. break;
  781. v105 = operator new(0x1004u);
  782. sub_809B30((char *)v105, v180, 0x1000u);
  783. ++v98;
  784. *(_DWORD *)(v105 + 4096) = *((_DWORD *)v3 + 8760);
  785. *((_DWORD *)v3 + 8760) = v105;
  786. sub_809C10(&v194, 0x100u, "PetSaveString%d", v98);
  787. v106 = (void **)operator+((int)&v183, &v181, &v194);
  788. LOBYTE(v197) = 36;
  789. sub_805D90(&v182, v106);
  790. LOBYTE(v197) = 1;
  791. if ( v183 )
  792. CXStr::FreeRep(v183);
  793. v183 = 0;
  794. v107 = sub_8061C0(&v182);
  795. }
  796. v108 = (void **)operator+((int)&v183, &v181, "PetSaveString");
  797. LOBYTE(v197) = 37;
  798. sub_805D90(&v182, v108);
  799. LOBYTE(v197) = 1;
  800. if ( v183 )
  801. CXStr::FreeRep(v183);
  802. v109 = sub_8061C0(&v182);
  803. v110 = (const char *)sub_80E2B0((void *)v177, (int)v109);
  804. v111 = v110;
  805. if ( v110 && *v110 )
  806. {
  807. v112 = operator new(0x1004u);
  808. sub_809B30((char *)v112, v111, 0x1000u);
  809. *(_DWORD *)(v112 + 4096) = *((_DWORD *)v3 + 8760);
  810. *((_DWORD *)v3 + 8760) = v112;
  811. }
  812. v180 = 0;
  813. do
  814. {
  815. sprintf(&v193, "TributeBenefit%d", v180);
  816. v113 = (void **)operator+((int)&v183, &v181, &v193);
  817. LOBYTE(v197) = 38;
  818. sub_805D90(&v182, v113);
  819. v114 = 0;
  820. LOBYTE(v197) = 1;
  821. if ( v183 )
  822. CXStr::FreeRep(v183);
  823. v183 = 0;
  824. v115 = sub_8061C0(&v182);
  825. v116 = (void *)sub_80E2B0((void *)v177, (int)v115);
  826. v179 = v116;
  827. if ( v116 )
  828. {
  829. v178 = strlen((const char *)v116);
  830. v117 = 0;
  831. do
  832. {
  833. if ( v114 >= v178 )
  834. {
  835. *(&v175 + v117) = -1;
  836. }
  837. else
  838. {
  839. v114 += sub_8085A0((char *)v179 + v114, &v195, 44);
  840. *(&v175 + v117) = atoi(&v195);
  841. }
  842. ++v117;
  843. }
  844. while ( v117 < 2 );
  845. }
  846. else
  847. {
  848. v175 = -1;
  849. v176 = -1;
  850. }
  851. v118 = v180;
  852. if ( (unsigned int)v180 >= 5 )
  853. __debugbreak();
  854. *((_DWORD *)v3 + 2 * (_DWORD)v180 + 8697) = v175;
  855. if ( (unsigned int)v118 >= 5 )
  856. __debugbreak();
  857. *((_DWORD *)v3 + 2 * (_DWORD)v118 + 8698) = v176;
  858. v180 = v118 + 1;
  859. }
  860. while ( (signed int)(v118 + 1) < 5 );
  861. v180 = 0;
  862. do
  863. {
  864. sprintf(&v193, "TrophyTributeBenefit%d", v180);
  865. v119 = (void **)operator+((int)&v183, &v181, &v193);
  866. LOBYTE(v197) = 39;
  867. sub_805D90(&v182, v119);
  868. v120 = 0;
  869. LOBYTE(v197) = 1;
  870. if ( v183 )
  871. CXStr::FreeRep(v183);
  872. v183 = 0;
  873. v121 = sub_8061C0(&v182);
  874. v122 = (void *)sub_80E2B0((void *)v177, (int)v121);
  875. v179 = v122;
  876. if ( v122 )
  877. {
  878. v178 = strlen((const char *)v122);
  879. v123 = 0;
  880. do
  881. {
  882. if ( v120 >= v178 )
  883. {
  884. *(&v175 + v123) = -1;
  885. }
  886. else
  887. {
  888. v120 += sub_8085A0((char *)v179 + v120, &v195, 44);
  889. *(&v175 + v123) = atoi(&v195);
  890. }
  891. ++v123;
  892. }
  893. while ( v123 < 2 );
  894. }
  895. else
  896. {
  897. v175 = -1;
  898. v176 = -1;
  899. }
  900. v124 = v180;
  901. if ( (unsigned int)v180 >= 0xA )
  902. __debugbreak();
  903. *((_DWORD *)v3 + 2 * (_DWORD)v180 + 8707) = v175;
  904. if ( (unsigned int)v124 >= 0xA )
  905. __debugbreak();
  906. *((_DWORD *)v3 + 2 * (_DWORD)v124 + 8708) = v176;
  907. v180 = v124 + 1;
  908. }
  909. while ( (signed int)(v124 + 1) < 10 );
  910. v125 = (void **)operator+((int)&v183, &v181, "PotionBelt");
  911. LOBYTE(v197) = 40;
  912. sub_805D90(&v182, v125);
  913. v126 = 0;
  914. LOBYTE(v197) = 1;
  915. if ( v183 )
  916. CXStr::FreeRep(v183);
  917. v127 = sub_8061C0(&v182);
  918. v128 = (void *)sub_80E2B0((void *)v177, (int)v127);
  919. v179 = v128;
  920. if ( v128 )
  921. {
  922. v178 = strlen((const char *)v128);
  923. v129 = 0;
  924. do
  925. {
  926. if ( v126 >= v178 )
  927. {
  928. *(&v188 + v129) = 0;
  929. }
  930. else
  931. {
  932. v126 += sub_8085A0((char *)v179 + v126, &v195, 44);
  933. *(&v188 + v129) = atoi(&v195);
  934. }
  935. ++v129;
  936. }
  937. while ( v129 < 5 );
  938. }
  939. else
  940. {
  941. v188 = 0;
  942. v189 = 0;
  943. v190 = 0;
  944. v191 = 0;
  945. v192 = 0;
  946. }
  947. v130 = 0;
  948. v131 = 0;
  949. do
  950. {
  951. if ( v130 >= 5 )
  952. __debugbreak();
  953. *(_DWORD *)((char *)v3 + v131 + 34428) = 0;
  954. *(_DWORD *)((char *)v3 + v131 + 34432) = -1;
  955. *((_BYTE *)v3 + v131 + 34436) = 0;
  956. if ( v130 >= 5 )
  957. __debugbreak();
  958. *(_DWORD *)((char *)v3 + v131 + 34428) = *(&v188 + v130);
  959. v131 += 72;
  960. ++v130;
  961. }
  962. while ( v131 < 360 );
  963. v132 = (void **)operator+((int)&v183, &v181, "home_zone");
  964. LOBYTE(v197) = 41;
  965. sub_805D90(&v182, v132);
  966. LOBYTE(v197) = 1;
  967. if ( v183 )
  968. CXStr::FreeRep(v183);
  969. v133 = sub_8061C0(&v182);
  970. v134 = v177;
  971. v135 = 0;
  972. v136 = (void *)sub_80E2B0((void *)v177, (int)v133);
  973. v179 = v136;
  974. if ( v136 )
  975. {
  976. v178 = strlen((const char *)v136);
  977. v137 = 0;
  978. do
  979. {
  980. if ( v135 >= v178 )
  981. {
  982. *(&v188 + v137) = 0;
  983. }
  984. else
  985. {
  986. v135 += sub_8085A0((char *)v179 + v135, &v195, 44);
  987. *(&v188 + v137) = atoi(&v195);
  988. }
  989. ++v137;
  990. }
  991. while ( v137 < 5 );
  992. v134 = v177;
  993. }
  994. else
  995. {
  996. v188 = 0;
  997. v189 = 0;
  998. v190 = 0;
  999. v191 = 0;
  1000. v192 = 0;
  1001. }
  1002. v138 = (void **)operator+((int)&v183, &v181, "home_x");
  1003. LOBYTE(v197) = 42;
  1004. sub_805D90(&v182, v138);
  1005. LOBYTE(v197) = 1;
  1006. if ( v183 )
  1007. CXStr::FreeRep(v183);
  1008. v139 = sub_8061C0(&v182);
  1009. sub_7FF500(v134, (int)v139, (int)v187, 5, 0.0);
  1010. v140 = (void **)operator+((int)&v183, &v181, "home_y");
  1011. LOBYTE(v197) = 43;
  1012. sub_805D90(&v182, v140);
  1013. LOBYTE(v197) = 1;
  1014. if ( v183 )
  1015. CXStr::FreeRep(v183);
  1016. v141 = sub_8061C0(&v182);
  1017. sub_7FF500(v134, (int)v141, (int)v184, 5, 0.0);
  1018. v142 = (void **)operator+((int)&v183, &v181, "home_z");
  1019. LOBYTE(v197) = 44;
  1020. sub_805D90(&v182, v142);
  1021. LOBYTE(v197) = 1;
  1022. if ( v183 )
  1023. CXStr::FreeRep(v183);
  1024. v143 = sub_8061C0(&v182);
  1025. sub_7FF500(v134, (int)v143, (int)v186, 5, 0.0);
  1026. v144 = (void **)operator+((int)&v183, &v181, "home_h");
  1027. LOBYTE(v197) = 45;
  1028. sub_805D90(&v182, v144);
  1029. LOBYTE(v197) = 1;
  1030. if ( v183 )
  1031. CXStr::FreeRep(v183);
  1032. v145 = sub_8061C0(&v182);
  1033. sub_7FF500(v134, (int)v145, (int)v185, 5, 0.0);
  1034. v146 = 9.0;
  1035. v147 = 0.0;
  1036. v148 = 0;
  1037. v149 = 0;
  1038. while ( 1 )
  1039. {
  1040. if ( v148 >= 5 )
  1041. __debugbreak();
  1042. *(float *)((char *)v3 + v149 + 13456) = v147;
  1043. *(_DWORD *)((char *)v3 + v149 + 13448) = 0;
  1044. *(float *)((char *)v3 + v149 + 13452) = v147;
  1045. *(float *)((char *)v3 + v149 + 13464) = v147;
  1046. v151 = v147;
  1047. v152 = v146;
  1048. v153 = v151;
  1049. *(float *)((char *)v3 + v149 + 13460) = v152;
  1050. if ( v148 >= 5 )
  1051. __debugbreak();
  1052. *(_DWORD *)((char *)v3 + v149 + 13448) = *(&v188 + v148);
  1053. if ( v148 >= 5 )
  1054. __debugbreak();
  1055. *(float *)((char *)v3 + v149 + 13452) = *(float *)&v187[v148];
  1056. if ( v148 >= 5 )
  1057. __debugbreak();
  1058. *(float *)((char *)v3 + v149 + 13456) = *(float *)&v184[v148];
  1059. if ( v148 >= 5 )
  1060. __debugbreak();
  1061. *(float *)((char *)v3 + v149 + 13460) = *(float *)&v186[v148];
  1062. if ( v148 >= 5 )
  1063. __debugbreak();
  1064. v149 += 20;
  1065. *(float *)((char *)v3 + v149 + 13444) = *(float *)&v185[v148++];
  1066. if ( v149 >= 100 )
  1067. break;
  1068. v150 = v152;
  1069. v147 = v153;
  1070. v146 = v150;
  1071. }
  1072. v154 = sub_8061C0(&v181);
  1073. sub_7FF5D0(v134, v154);
  1074. v155 = sub_8061C0(&v181);
  1075. sub_7FF920(v134, v155);
  1076. v156 = sub_8061C0(&v181);
  1077. sub_7FFB40(v134, v156);
  1078. v157 = (void **)operator+((int)&v183, &v181, "CurrentMercenaryIndex");
  1079. LOBYTE(v197) = 46;
  1080. sub_805D90(&v182, v157);
  1081. LOBYTE(v197) = 1;
  1082. if ( v183 )
  1083. CXStr::FreeRep(v183);
  1084. v158 = sub_8061C0(&v182);
  1085. v159 = (void *)v177;
  1086. v160 = 0;
  1087. *((_DWORD *)v3 + 9811) = sub_80E1B0(v158, -1);
  1088. v179 = 0;
  1089. do
  1090. {
  1091. v161 = (unsigned int)sub_8061C0(&v181);
  1092. sub_8079C0((int)&v182, "%sMercenarySaveString%d", v161);
  1093. v162 = sub_8061C0(&v182);
  1094. v163 = (char *)sub_80E2B0(v159, (int)v162);
  1095. if ( v163 && *v163 )
  1096. {
  1097. CXStr::CXStr(&v180, v163);
  1098. v165 = __OFSUB__(*((_DWORD *)v3 + 8756), 10);
  1099. v164 = *((_DWORD *)v3 + 8756) - 10 < 0;
  1100. LOBYTE(v197) = 47;
  1101. if ( v164 ^ v165 )
  1102. {
  1103. v166 = *((_DWORD *)v3 + 8756);
  1104. v183 = (void *)v166;
  1105. if ( v166 >= 0 )
  1106. {
  1107. v167 = v166 + 1;
  1108. sub_50A090(v166 + 1);
  1109. v168 = *((_DWORD *)v3 + 8757);
  1110. if ( v168 )
  1111. {
  1112. v169 = (void **)(v168 + 4 * (_DWORD)v183);
  1113. *((_DWORD *)v3 + 8756) = v167;
  1114. sub_805D90(v169, (void **)&v180);
  1115. }
  1116. }
  1117. }
  1118. LOBYTE(v197) = 1;
  1119. if ( v180 )
  1120. CXStr::FreeRep(v180);
  1121. v160 = v179;
  1122. v159 = (void *)v177;
  1123. v180 = 0;
  1124. }
  1125. v160 = (char *)v160 + 1;
  1126. v179 = v160;
  1127. }
  1128. while ( (signed int)v160 < 10 );
  1129. if ( !*((_DWORD *)v3 + 8756) )
  1130. {
  1131. v170 = (void **)operator+((int)&v179, &v181, "MercenarySaveString");
  1132. LOBYTE(v197) = 48;
  1133. sub_805D90(&v182, v170);
  1134. LOBYTE(v197) = 1;
  1135. if ( v179 )
  1136. CXStr::FreeRep(v179);
  1137. v171 = sub_8061C0(&v182);
  1138. v172 = (char *)sub_80E2B0(v159, (int)v171);
  1139. if ( v172 && *v172 )
  1140. {
  1141. CXStr::CXStr(&v180, v172);
  1142. LOBYTE(v197) = 49;
  1143. sub_8018B0(&v180);
  1144. LOBYTE(v197) = 1;
  1145. if ( v180 )
  1146. CXStr::FreeRep(v180);
  1147. v180 = 0;
  1148. }
  1149. }
  1150. if ( *((_DWORD *)v3 + 9811) == -1 && *((_DWORD *)v3 + 8756) > 0 )
  1151. *((_DWORD *)v3 + 9811) = 0;
  1152. LOBYTE(v197) = 0;
  1153. if ( v182 )
  1154. CXStr::FreeRep(v182);
  1155. v182 = 0;
  1156. v197 = -1;
  1157. if ( v181 )
  1158. CXStr::FreeRep(v181);
  1159. result = 1;
  1160. }
  1161. else
  1162. {
  1163. LOBYTE(v197) = 0;
  1164. if ( v182 )
  1165. CXStr::FreeRep(v182);
  1166. v182 = 0;
  1167. v197 = -1;
  1168. if ( v181 )
  1169. CXStr::FreeRep(v181);
  1170. result = 0;
  1171. }
  1172. return result;
  1173. }
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!