API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 19th, 2018
56
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.73 KB | None | 0 0
raw download clone embed print report
  1. #pragma once
  2. #include "stdafx.h"
  3. #include "../Menu/Menu.h"
  4. #include "Misc.h"
  5. #include "Aimbot.h"
  6. #include "../Utils/LocalInfo.h"
  7. #include "../Menu/SettingsManager.h"
  8.  
  9. namespace FakeLag
  10. {
  11. bool infakelag = false;
  12.  
  13. void doFakeLag()
  14. {
  15. float lbyDelta = Settings.GetSetting(Tab_Ragebot, AntiAim_LBYDelta;
  16. if (lbyDelta && ((Hacks.LocalPlayer->GetVelocity().Length2D() < .1f) || (Settings.GetSetting(Tab_Ragebot, Ragebot_FakeWalk) && GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_FakeWalkButton))))) {
  17. switch (((int)Hacks.CurrentCmd->command_number) % 11)
  18. {
  19. case 0: Hacks.SendPacket = true; break;
  20. case 1: Hacks.SendPacket = true; break;
  21. case 2: Hacks.SendPacket = true; break;
  22. case 3: Hacks.SendPacket = false; break;
  23. case 4: Hacks.SendPacket = true; break;
  24. case 5: Hacks.SendPacket = true; break;
  25. case 6: Hacks.SendPacket = true; break;
  26. case 7: Hacks.SendPacket = false; break;
  27. case 8: Hacks.SendPacket = false; break;
  28. case 9: Hacks.SendPacket = true; break;
  29. case 10: Hacks.SendPacket = true; break;
  30. }
  31. }
  32.  
  33. else {
  34. static int ticks = 0;
  35. int flTimer = -1;
  36. bool lastfltick = -1;
  37. int factor = Settings.GetSetting(Tab_Misc, Misc_FakeLagAmount) / 13;
  38. auto tmpLagTicks = Settings.GetSetting(Tab_Misc, Misc_FakeLagAmount) / 13;
  39. auto Velocity = Hacks.LocalPlayer->GetVecVelocity().Length() * Interfaces.pGlobalVars->interval_per_tick;
  40. int fakeLagType = Settings.GetSetting(Tab_Misc, Misc_FakeLag);
  41. if (fakeLagType > 0 && Settings.GetSetting(Tab_Ragebot, Ragebot_AimbotEnabled))
  42. {
  43. switch (fakeLagType)
  44. {
  45. case 2: // Factor
  46. {
  47. ticks++;
  48. if (ticks < Settings.GetSetting(Tab_Misc, Misc_FakeLagAmount))
  49. {
  50. infakelag = true;
  51. Hacks.SendPacket = false;
  52. }
  53. else
  54. {
  55. infakelag = false;
  56. Hacks.SendPacket = true;
  57. ticks = 0;
  58. }
  59.  
  60. break;
  61. }
  62.  
  63. case 3: // Adaptive
  64. {
  65. do {
  66. factor = tmpLagTicks;
  67. if ((tmpLagTicks * Velocity) > 68.f)
  68. break;
  69. tmpLagTicks += 1;
  70. if (((tmpLagTicks + 1) * Velocity) > 68.f)
  71. break;
  72. tmpLagTicks += 2;
  73. }
  74.  
  75. while (tmpLagTicks <= 12);
  76.  
  77. if (flTimer > factor)
  78. {
  79. Hacks.SendPacket = true;
  80. infakelag = false;
  81. flTimer = -1;
  82. }
  83. else
  84. {
  85. if (flTimer == factor)
  86. lastfltick = true;
  87. Hacks.SendPacket = false;
  88. infakelag = true;
  89. }
  90.  
  91. flTimer++;
  92.  
  93. break;
  94. }
  95. }
  96. }
  97. }
  98. }
  99. }
  100.  
  101. #define TIME_TO_TICKS( dt ) ( (int)( 0.5f + (float)(dt) / se::Interfaces::GlobalVars()->interval_per_tick ) )
  102.  
  103. class AntiAim
  104. {
  105. public:
  106. float MyLowerBody = 0.0f;
  107. bool flip2 = false;
  108. float flip2angle = 0.0f;
  109. bool start = false;
  110. bool jitter = false;
  111. bool flip = false;
  112. bool ShouldAA = true;
  113. int current = 0;
  114. bool bSwitch;
  115. float OldLBY;
  116. float LBYBreakerTimer;
  117. float LastLBYUpdateTime;
  118. float TickCountLBYUpdate;
  119.  
  120. private:
  121.  
  122. int TicksUntilUpdate()
  123. {
  124. if (!Hacks.LocalPlayer)
  125. return INT_MAX;
  126.  
  127. float LBY = Hacks.LocalPlayer->GetLowerBodyYawTarget123();
  128.  
  129. if (g_tick >= TickCountLBYUpdate) TickCountLBYUpdate = g_tick + TIME_TO_TICKS(1.1f);
  130.  
  131. return (TickCountLBYUpdate - g_tick);
  132. }
  133.  
  134. void doFakeWalk()
  135. {
  136. auto pLocal = Hacks.LocalPlayer;
  137. if (!pLocal) return;
  138. if (GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_FakeWalkButton)))
  139. {
  140. static int packet = 0;
  141. packet++;
  142.  
  143. if ((packet > 4) && (packet < 12)) {
  144. Hacks.SendPacket = false;
  145. if (pLocal->GetVelocity().Length2D() > 100.f) {
  146. Hacks.CurrentCmd->forwardmove = 0;
  147. Hacks.CurrentCmd->sidemove = 0;
  148. }
  149. else if (pLocal->GetVelocity().Length2D() > 35.f) {
  150. Hacks.CurrentCmd->forwardmove *= .05f;
  151. Hacks.CurrentCmd->sidemove *= .05f;
  152. }
  153. }
  154. else if (packet < 14) {
  155. Hacks.SendPacket = false;
  156. Hacks.CurrentCmd->forwardmove = 0;
  157. Hacks.CurrentCmd->sidemove = 0;
  158. }
  159. else {
  160. Hacks.SendPacket = true;
  161. Hacks.CurrentCmd->forwardmove = 0;
  162. Hacks.CurrentCmd->sidemove = 0;
  163. //stopTick(pLocal, pCmd);
  164. packet = 0;
  165. }
  166. }
  167.  
  168. void AtTargets(Vector& viewangles)
  169. {
  170. if (Settings.GetSetting(Tab_Ragebot, AntiAim_AtTargets) != 1)
  171. {
  172. if (Aimbot.Target != Vector(0, 0, 0))
  173. {
  174. Misc::CalcAngle(Hacks.LocalPlayer->GetVecOrigin(), Aimbot.Target + Hacks.LocalPlayer->GetVecOrigin(), viewangles);
  175. }
  176. else if (Settings.GetSetting(Tab_Ragebot, AntiAim_AtTargets) == 2)
  177. ShouldAA = false;
  178. }
  179. }
  180.  
  181.  
  182. void jittertime()
  183. {
  184. static clock_t start1_t1 = clock();
  185. double timeSoFar1 = (double)(clock() - start1_t1) / CLOCKS_PER_SEC;
  186. if (timeSoFar1 < 0.05)
  187. return;
  188. jitter = !jitter;
  189. start1_t1 = clock();
  190. }
  191.  
  192. void fliptime()
  193. {
  194. static clock_t start_t1 = clock();
  195. double timeSoFar = (double)(clock() - start_t1) / CLOCKS_PER_SEC;
  196. if (timeSoFar < 4.0)
  197. return;
  198. start_t1 = clock();
  199. }
  200.  
  201.  
  202.  
  203. void Yaw(int index, Vector& views, bool yFlip, int ChokedPackets, bool sFlip)
  204. {
  205. int yaw = 0;
  206. static float addj;
  207. float temp;
  208. static float trigger;
  209. int random;
  210. int maxJitter;
  211. int Add = 0;
  212. static int SpinYaw = 0;
  213. float JitterAng = 0;
  214. static float StoredAng = 0;
  215. jittertime();
  216. fliptime();
  217.  
  218. static int last = 0;
  219. int help = {};
  220. int Fake = rand() % 3;
  221. static int Spin[2] = { 0, 0 };
  222. for (int& s : Spin)
  223. if (s > 180)
  224. s -= 360;
  225. else if (s < -180)
  226. s += 360;
  227.  
  228. long currentTime_ms = std::chrono::duration_cast< std::chrono::seconds >(std::chrono::system_clock::now().time_since_epoch()).count();
  229. static long timeStamp = currentTime_ms;
  230.  
  231. timeStamp = currentTime_ms;
  232.  
  233.  
  234. switch (index)
  235. {
  236. case 0: // Off
  237. break;
  238. case 1: // Off
  239. break;
  240.  
  241. case 2: // Shuffle
  242. {
  243. static bool left;
  244. if (GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_ShuffleLeft)))
  245. left = true;
  246. else if (GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_ShuffleRight)))
  247. left = false;
  248. int jitter_shuffle = Settings.GetSetting(Tab_Ragebot, Ragebot_JatterRandha);
  249. float jitter = rand() % (jitter_shuffle + 1);
  250.  
  251. float lbyDelta = Settings.GetSetting(Tab_Ragebot, AntiAim_LBYDelta;
  252. if (lbyDelta && ((Hacks.LocalPlayer->GetVelocity().Length2D() < .1f) || (Settings.GetSetting(Tab_Ragebot, Ragebot_FakeWalk) && GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_FakeWalkButton))))) {
  253. if (left)
  254. {
  255. //if (TicksUntilUpdate() <= 1) pCmd->viewangles.x = -89.f;
  256. if (!TicksUntilUpdate() || Hacks.SendPacket) views.y = views.y + 90 + lbyDelta;
  257. else views.y += 90;
  258. }
  259. else
  260. {
  261. if (!TicksUntilUpdate() || Hacks.SendPacket) views.y = views.y - 90 + lbyDelta;
  262. else views.y -= 90;
  263. }
  264. }
  265. if (left)
  266. {
  267. if (Hacks.SendPacket)
  268. {
  269. views.y -= 90;
  270. if (yFlip)
  271. views.y -= jitter;
  272. else
  273. views.y += jitter;
  274. }
  275. else
  276. views.y += 90;
  277. }
  278. else
  279. {
  280. if (Hacks.SendPacket)
  281. {
  282. if (yFlip)
  283. views.y -= jitter;
  284. else
  285. views.y += jitter;
  286. views.y += 90;
  287. }
  288. else
  289. views.y -= 90;
  290. }
  291.  
  292. break;
  293. }
  294. case 3: // Spin
  295. {
  296. float spin = Settings.GetSetting(Tab_Ragebot, Ragebot_SpinSpeed) * (Hacks.LocalPlayer->GetTickBase() * Interfaces.pGlobalVars->interval_per_tick);
  297. while (spin > 180)
  298. spin -= 360;
  299. while (spin < 180)
  300. spin += 360;
  301. views.y = spin;
  302. break;
  303. }
  304.  
  305. case 4: // Sideways
  306. {
  307. static bool wilupdate;
  308. static float LastLBYUpdateTime = 0;
  309.  
  310. static bool left;
  311. if (GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_ShuffleLeft)))
  312. left = true;
  313. else if (GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_ShuffleRight)))
  314. left = false;
  315.  
  316. float server_time = Hacks.LocalPlayer->GetTickBase() * Interfaces.pGlobalVars->interval_per_tick;
  317. if (server_time >= LastLBYUpdateTime) {
  318. LastLBYUpdateTime = server_time + 1.1f;
  319. wilupdate = true;
  320. }
  321. else {
  322. wilupdate = false;
  323. }
  324. // LZ Do edgeScan
  325. if (!Hacks.SendPacket) {
  326. if (left)
  327. views.y -= 90.f;
  328. else
  329. views.y += 90.f;
  330. }
  331. else {
  332. if (left)
  333. views.y += 90.f;
  334. else
  335. views.y -= 90.f;
  336. }
  337. if (wilupdate)
  338. {
  339. Hacks.SendPacket = false;
  340.  
  341. if (left)
  342. views.y -= 180.f;
  343. else
  344. views.y += 180.f;
  345. }
  346. }
  347. case 5: // Zero
  348. {
  349. {
  350. float add;
  351. if (Hacks.SendPacket)
  352. {
  353. if (Settings.GetSetting(Tab_Ragebot, AntiAim_CustomYawMinus))
  354. add = -Settings.GetSetting(Tab_Ragebot, AntiAim_CustomYaw);
  355. else add = Settings.GetSetting(Tab_Ragebot, AntiAim_CustomYaw);
  356. }
  357. else
  358. {
  359. if (Settings.GetSetting(Tab_Ragebot, AntiAim_CustomFakeYawMinus))
  360. add = -Settings.GetSetting(Tab_Ragebot, AntiAim_CustomFakeYaw);
  361. else add = Settings.GetSetting(Tab_Ragebot, AntiAim_CustomFakeYaw);
  362. }
  363.  
  364. views.y = add;
  365. }
  366. break;
  367. }
  368. case 6: // Backward
  369. {
  370. views.y -= 180;
  371. break;
  372. }
  373. case 7: // LBY Breaker
  374. {
  375. static bool flip;
  376. static bool flip2;
  377. static bool flip3;
  378.  
  379. static bool left;
  380. if (GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_ShuffleLeft)))
  381. left = true;
  382. else if (GetAsyncKeyState(Settings.GetSetting(Tab_Ragebot, Ragebot_ShuffleRight)))
  383. left = false;
  384.  
  385. flip = !flip;
  386. flip2 = !flip2;
  387. flip3 = flip2 + flip;
  388.  
  389.  
  390. if (flip)
  391. {
  392. if (!Hacks.SendPacket)
  393. {
  394. if (flip2)
  395.  
  396. views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() + 180.0f;
  397. else if (flip2)
  398. views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() - 180.0f;
  399. else if (flip2)
  400. views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() + 180.0f;
  401. else if (flip2)
  402. views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() - 180.0f;
  403. else if (flip2)
  404. views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() - 180.0f;
  405.  
  406. }
  407. }
  408. else
  409. {
  410. if (Hacks.SendPacket)
  411. {
  412. if (flip3)
  413. {
  414. views.y += 90;
  415. }
  416. else
  417. {
  418. views.y -= 90;
  419. }
  420. }
  421. }
  422. break;
  423. }
  424. break;
  425. case 8: // 180 Jitter
  426. {
  427. switch (Hacks.CurrentCmd->tick_count % 3)
  428. {
  429. case 0: views.y -= 160; break;
  430. case 1: views.y -= 180; break;
  431. case 2: views.y -= 200; break;
  432. }
  433. }
  434. break;
  435. case 9: // Jitter LBY
  436. {
  437. float LBY = Hacks.LocalPlayer->GetLowerBodyYaw();
  438. int add = 0;
  439. switch (Hacks.CurrentCmd->tick_count % 15) {
  440. case 0: add = 45; break;
  441. case 1: add = -45; break;
  442. case 2: add = 90; break;
  443. case 3: add = -90; break;
  444. case 4: add = 135; break;
  445. case 5: add = -135; break;
  446. case 6: add = 25; break;
  447. case 7: add = -25; break;
  448. case 8: add = 45; break;
  449. case 9: add = -45; break;
  450. case 10: add = 165; break;
  451. case 11: add = -165; break;
  452. case 12: add = 225; break;
  453. case 13: add = -225; break;
  454. case 14: add = 320; break;
  455. case 15: add = -320; break;
  456. }
  457. if (yFlip) views.y += LBY + add;
  458. else views.y += LBY - add;
  459. }
  460. break;
  461. case 10: // Opposite
  462. {
  463. switch (Hacks.CurrentCmd->tick_count % 3)
  464. {
  465. case 0: views.y += 320; break;
  466. case 1: views.y += 360; break;
  467. case 2: views.y += 400; break;
  468. }
  469. }
  470. break;
  471. case 11: //Sideways IMP
  472. {
  473. static int jitterangle = 0;
  474.  
  475. if (jitterangle <= 1)
  476. {
  477. views.y += 135;
  478. }
  479. else if (jitterangle > 1 && jitterangle <= 3)
  480. {
  481. views.y += 225;
  482. }
  483.  
  484. static int iChoked = -1;
  485. iChoked++;
  486. if (iChoked < 1)
  487. {
  488. Hacks.SendPacket = false;
  489. if (jitterangle <= 1)
  490. {
  491. views.y += 45;
  492. jitterangle += 1;
  493. }
  494. else if (jitterangle > 1 && jitterangle <= 3)
  495. {
  496. views.y -= 45;
  497. jitterangle += 1;
  498. }
  499. else
  500. {
  501. jitterangle = 0;
  502. }
  503. }
  504. else
  505. {
  506. Hacks.SendPacket = true;
  507. iChoked = -1;
  508. }
  509. }
  510. break;
  511. case 12: // Fake 1
  512. {
  513. switch (Hacks.LocalPlayer->GetTickBase() % 150)
  514. {
  515. case 0: views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() - 180; break;
  516. case 1: views.y += Hacks.LocalPlayer->GetLowerBodyYaw() + 180; break;
  517. case 2: views.y += 180; break;
  518. case 3: views.y -= 90; break;
  519. case 4: views.y += Hacks.LocalPlayer->GetLowerBodyYaw() - 90; break;
  520. case 5: views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() + 90; break;
  521. case 6: if (Hacks.SendPacket)
  522. views.y += Hacks.LocalPlayer->GetLowerBodyYaw() + 90;
  523. else views.y -= Hacks.LocalPlayer->GetLowerBodyYaw() + 90;
  524. break;
  525. }
  526. views.y -= rand() % 180;
  527. }break;
  528. case 13: // Fake 2
  529. {
  530. if (!Settings.GetSetting(Tab_Misc, Misc_AntiUntrusted)) {
  531. if (Hacks.LocalPlayer->GetVecVelocity().Length2D() > 300)
  532. {
  533. views.y += 15.13423;
  534. }
  535. else {
  536. views.y -= 50.9999055523;
  537. }
  538. }
  539. else {
  540. if (Hacks.CurrentCmd->buttons & IN_ATTACK) {
  541. views.y += 150.656645363;
  542. }
  543. else
  544. views.y -= 147.4788437875;
  545. }
  546. }
  547. break;
  548. case 14: // Fake 3
  549. {
  550. static int spin = 0;
  551. static bool flip = true;
  552. flip = !flip;
  553.  
  554. if (Hacks.CurrentCmd->buttons & IN_ATTACK)
  555. {
  556. Hacks.SendPacket = true;
  557. spin += 25;
  558. views.y = spin;
  559. }
  560. if (!flip)
  561. {
  562. Hacks.SendPacket = true;
  563. views.y += 90 + rand() % 20;
  564. }
  565. else
  566. {
  567. Hacks.SendPacket = false;
  568. if (Hacks.LocalPlayer->GetFlags() & FL_ONGROUND)
  569. views.y += 180;
  570. else
  571. views.y -= -90;
  572. }
  573. }
  574. break;
  575. case 15: //Fake 4
  576. if (sFlip)
  577. if (Hacks.SendPacket)
  578. views.y -= 90;
  579. else views.y += 90;
  580. else
  581. if (!Hacks.SendPacket)
  582. views.y -= 90;
  583. else views.y += 90;
  584. break;
  585. case 16: // Fake 5
  586. {
  587. static int choke = -1;
  588. static bool flip;
  589. static bool flip2;
  590. flip = !flip;
  591. flip2 = !flip2;
  592.  
  593. if (Hacks.LocalPlayer->GetVecVelocity().Length2D() < 1)
  594. {
  595. if (choke < 6)
  596. {
  597. choke++;
  598. sFlip ? views.y -= 90 : views.y += 90;
  599. Hacks.SendPacket = true;
  600. }
  601. else
  602. {
  603. choke = -1;
  604. Hacks.SendPacket = false;
  605. views.y -= 180;
  606. }
  607. }
  608. else
  609. {
  610. if (Hacks.SendPacket)
  611. flip ? views.y -= 175 : views.y += 175;
  612. else
  613. {
  614. views.y = 180;
  615. }
  616. }
  617. break;
  618. }
  619. }
  620. Hacks.CurrentCmd->viewangles = views;
  621. }
  622.  
  623.  
  624. void Pitch(Vector& views, bool yFlip, int ChokedPackets, bool sFlip)
  625. {
  626. int pitch = Settings.GetSetting(Tab_Ragebot, AntiAim_Pitch);
  627. switch (pitch)
  628. {
  629. case 0: // Off
  630. break;
  631. case 1: // Off
  632. break;
  633. case 2: // Emotion
  634. views.x = 88.99;
  635. break;
  636. case 3: // Down
  637. views.x = 179.99;
  638. break;
  639. case 4: // Up
  640. views.x = -179.99;
  641. break;
  642. }
  643. Hacks.CurrentCmd->viewangles = views;
  644. }
  645.  
  646.  
  647. void AA(Vector& views)
  648. {
  649.  
  650. static bool flip;
  651. flip = rand() % 2 == 1 ? false : true;
  652. flip = !flip;
  653. static bool sFlip = false;
  654. static int ChokedPackets = -1;
  655. ChokedPackets++;
  656. if ((Interfaces.pGlobalVars->tickcount % 100) > 1 && (Interfaces.pGlobalVars->tickcount % 100) < 50)
  657. sFlip = true;
  658. else sFlip = false;
  659. AtTargets(views);
  660.  
  661. if (Settings.GetSetting(Tab_Misc, Misc_FakeLag) >= 2)
  662. {
  663. if (ChokedPackets < Settings.GetSetting(Tab_Misc, Misc_FakeLagAmount))
  664. {
  665. Hacks.SendPacket = false;
  666. Yaw(Settings.GetSetting(Tab_Ragebot, AntiAim_Yaw), views, flip, ChokedPackets, sFlip); // Real yaw
  667. Pitch(views, flip, ChokedPackets, sFlip);
  668. }
  669. else
  670. {
  671. Hacks.SendPacket = true;
  672. Yaw(Settings.GetSetting(Tab_Ragebot, AntiAim_FakeYaw), views, flip, ChokedPackets, sFlip); // Fake yaw
  673. Pitch(views, flip, ChokedPackets, sFlip);
  674. ChokedPackets = -1;
  675. }
  676. }
  677. else
  678. {
  679. if (ChokedPackets < 1) {
  680. Hacks.SendPacket = false;
  681. Pitch(views, flip, ChokedPackets, sFlip);
  682. Yaw(Settings.GetSetting(Tab_Ragebot, AntiAim_Yaw), views, flip, ChokedPackets, sFlip); // Real yaw
  683. }
  684. else
  685. {
  686. Hacks.SendPacket = true;
  687. Pitch(views, flip, ChokedPackets, sFlip);
  688. Yaw(Settings.GetSetting(Tab_Ragebot, AntiAim_FakeYaw), views, flip, ChokedPackets, sFlip); // Fake yaw
  689. ChokedPackets = -1;
  690. }
  691. }
  692. views.y += Settings.GetSetting(Tab_Ragebot, AntiAim_FakeOffset);
  693. }
  694.  
  695. public:
  696. void Run()
  697. {
  698. if (!Settings.GetSetting(Tab_Ragebot, AntiAim_Enabled))
  699. return;
  700. if (Hacks.LocalPlayer->GetMoveType() == MOVETYPE_LADDER)
  701. return;
  702. if (Hacks.CurrentCmd->buttons & IN_USE)
  703. return;
  704.  
  705. ShouldAA = true;
  706.  
  707. if (Settings.GetSetting(Tab_Ragebot, Ragebot_FakeWalk))
  708. doFakeWalk();
  709.  
  710. if (ShouldAA)
  711. AA(Hacks.CurrentCmd->viewangles);
  712. }
  713. } AA;
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!