API tools faq
paste
Advertisement
TexlzAye

Alora V1.0.3 (Tex Fuscator)

TexlzAye
Mar 20th, 2019
198
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.79 KB | None | 0 0
raw download clone embed print report
  1. --[[
  2. Alora (Tex Fuscator) v1.0.3 by Alora Development
  3. ]]
  4. local llIIlIlIIllllIlIlIlIIlIlIlIllllIllI = {'\27','\76','\117','\97','\81','\0','\1','\4','\8','\4','\8','\0','\7','\0',
  5. '\0','\0','\0','\0','\0','\0','\60','\101','\118','\97','\108','\62','\0','\3','\0','\0','\0','\7','\0','\0','\0','\0','\0',
  6. '\0','\5','\8','\0','\0','\0','\5','\0','\0','\0','\69','\64','\0','\0','\128','\0','\128','\0','\192','\0','\0','\0','\1',
  7. '\129','\0','\0','\220','\0','\0','\1','\156','\64','\0','\0','\30','\0','\128','\0','\3','\0','\0','\0','\4','\6','\0','\0',
  8. '\0','\0','\0','\0','\0','\112','\114','\105','\110','\116','\0','\4','\11','\0','\0','\0','\0','\0','\0','\0','\108','\111',
  9. '\97','\100','\115','\116','\114','\105','\110','\103','\0','\4','\6','\0','\0','\0','\0','\0','\0','\0','\72','\101','\108',
  10. '\108','\111','\0','\0','\0','\0','\0','\8','\0','\0','\0','\4','\0','\0','\0','\5','\0','\0','\0','\6','\0','\0','\0','\6',
  11. '\0','\0','\0','\6','\0','\0','\0','\6','\0','\0','\0','\6','\0','\0','\0','\7','\0','\0','\0','\2','\0','\0','\0','\25',
  12. '\0','\0','\0','\0','\0','\0','\0','\77','\84','\69','\52','\78','\122','\81','\52','\77','\106','\85','\48','\79','\68',
  13. '\69','\50','\77','\68','\81','\122','\77','\68','\65','\52','\0','\1','\0','\0','\0','\7','\0','\0','\0','\25','\0','\0',
  14. '\0','\0','\0','\0','\0','\86','\74','\105','\101','\102','\103','\107','\111','\77','\86','\66','\69','\73','\85','\79',
  15. '\78','\105','\117','\110','\101','\117','\115','\78','\51','\0','\2','\0','\0','\0','\7','\0','\0','\0','\0','\0','\0','\0'
  16. }
  17.  
  18. local IlIIlIlIIIlllIlIlIIlIlIlIlIIIlIIIII = {
  19. "ABC", "ABx", "ABC", "ABC",
  20. "ABC", "ABx", "ABC", "ABx",
  21. "ABC", "ABC", "ABC", "ABC",
  22. "ABC", "ABC", "ABC", "ABC",
  23. "ABC", "ABC", "ABC", "ABC",
  24. "ABC", "ABC", "AsBx", "ABC",
  25. "ABC", "ABC", "ABC", "ABC",
  26. "ABC", "ABC", "ABC", "AsBx",
  27. "AsBx", "ABC", "ABC", "ABC",
  28. "ABx", "ABC",}
  29. III1lllI111I1l1lIII1lllI111I1l1lIII1lllI111I1l1lIII1lllI111I1l1l = table.concat
  30. local llllIIlIllIIlIllIIllIlIlIIlIIIllIlI = {
  31. "MOVE", "LOADK", "LOADBOOL", "LOADNIL",
  32. "GETUPVAL", "GETGLOBAL", "GETTABLE", "SETGLOBAL",
  33. "SETUPVAL", "SETTABLE", "NEWTABLE", "SELF",
  34. "ADD", "SUB", "MUL", "DIV",
  35. "MOD", "POW", "UNM", "NOT",
  36. "LEN", "CONCAT", "JMP", "EQ",
  37. "LT", "LE", "TEST", "TESTSET",
  38. "CALL", "TAILCALL", "RETURN", "FORLOOP",
  39. "FORPREP", "TFORLOOP", "SETLIST", "CLOSE",
  40. "CLOSURE", "VARARG"
  41. };
  42. local function get_bits(input, n, n2)
  43. if n2 then
  44. local total = 0
  45. local digitn = 0
  46. for i = n, n2 do
  47. total = total + 2^digitn*get_bits(input, i)
  48. digitn = digitn + 1
  49. end
  50. return total
  51. else
  52. local pn = 2^(n-1)
  53. return (input % (pn + pn) >= pn) and 1 or 0
  54. end
  55. end
  56. local function lIlIIIlllIlIIIIlIIIllIlIIIIIlIlIlll(IlIlllllllIllIlIllIlIlllIIIIIlIIlll)
  57. local index = 1
  58. local big_endian = false
  59. local int_size;
  60. local size_t;
  61. local get_int, get_size_t;
  62. local get_int8, get_int32, get_int64, get_float64, get_string;
  63. do
  64. function get_int8()
  65. local a = IlIlllllllIllIlIllIlIlllIIIIIlIIlll:byte(index, index);
  66. index = index + 1
  67. return a
  68. end
  69. function get_int32()
  70. local a, b, c, d = IlIlllllllIllIlIllIlIlllIIIIIlIIlll:byte(index, index + 3);
  71. index = index + 4;
  72. return d*16777216 + c*65536 + b*256 + a
  73. end
  74. function get_int64()
  75. local a = get_int32();
  76. local b = get_int32();
  77. return b*4294967296 + a;
  78. end
  79. function get_float64()
  80. local a = get_int32()
  81. local b = get_int32()
  82. return (-2*get_bits(b, 32)+1)*(2^(get_bits(b, 21, 31)-1023))*
  83. ((get_bits(b, 1, 20)*(2^32) + a)/(2^52)+1)
  84. end
  85. function get_string(len)
  86. local str;
  87. if len then
  88. str = IlIlllllllIllIlIllIlIlllIIIIIlIIlll:sub(index, index + len - 1);
  89. index = index + len;
  90. else
  91. len = get_size_t();
  92. if len == 0 then return; end
  93. str = IlIlllllllIllIlIllIlIlllIIIIIlIIlll:sub(index, index + len - 1);
  94. index = index + len;
  95. end
  96. return str;
  97. end
  98. end
  99. local function decode_chunk()
  100. local chunk;
  101. local instructions = {};
  102. local constants = {};
  103. local prototypes = {};
  104. local debug = {
  105. lines = {};
  106. };
  107. chunk = {
  108. instructions = instructions;
  109. constants = constants;
  110. prototypes = prototypes;
  111. debug = debug;
  112. };
  113. local num;
  114. chunk.name = get_string();
  115. chunk.first_line = get_int();
  116. chunk.last_line = get_int();
  117. if chunk.name then chunk.name = chunk.name:sub(1, -2); end
  118. chunk.upvalues = get_int8();
  119. chunk.arguments = get_int8();
  120. chunk.varg = get_int8();
  121. chunk.stack = get_int8();
  122. do
  123. num = get_int();
  124. for i = 1, num do
  125. local instruction = {
  126. };
  127. local llIIlIlIIllllIlIlIlIIlIlIlIllllIllI = get_int32();
  128. local opcode = get_bits(llIIlIlIIllllIlIlIlIIlIlIlIllllIllI, 1, 6);
  129. local type = IlIIlIlIIIlllIlIlIIlIlIlIlIIIlIIIII[opcode + 1];
  130. instruction.opcode = opcode;
  131. instruction.type = type;
  132. instruction.A = get_bits(llIIlIlIIllllIlIlIlIIlIlIlIllllIllI, 7, 14);
  133. if type == "ABC" then
  134. instruction.B = get_bits(llIIlIlIIllllIlIlIlIIlIlIlIllllIllI, 24, 32);
  135. instruction.C = get_bits(llIIlIlIIllllIlIlIlIIlIlIlIllllIllI, 15, 23);
  136. elseif type == "ABx" then
  137. instruction.Bx = get_bits(llIIlIlIIllllIlIlIlIIlIlIlIllllIllI, 15, 32);
  138. elseif type == "AsBx" then
  139. instruction.sBx = get_bits(llIIlIlIIllllIlIlIlIIlIlIlIllllIllI, 15, 32) - 131071;
  140. end
  141. instructions[i] = instruction;
  142. end
  143. end
  144. do
  145. num = get_int();
  146. for i = 1, num do
  147. local constant = {
  148. };
  149. local type = get_int8();
  150. constant.type = type;
  151. if type == 1 then
  152. constant.llIIlIlIIllllIlIlIlIIlIlIlIllllIllI = (get_int8() ~= 0);
  153. elseif type == 3 then
  154. constant.llIIlIlIIllllIlIlIlIIlIlIlIllllIllI = get_float64();
  155. elseif type == 4 then
  156. constant.llIIlIlIIllllIlIlIlIIlIlIlIllllIllI = get_string():sub(1, -2);
  157. end
  158. constants[i-1] = constant;
  159. end
  160. end
  161. do
  162. num = get_int();
  163. for i = 1, num do
  164. prototypes[i-1] = decode_chunk();
  165. end
  166. end
  167. do
  168. local llIIlIlIIllllIlIlIlIIlIlIlIllllIllI = debug.lines
  169. num = get_int();
  170. for i = 1, num do
  171. llIIlIlIIllllIlIlIlIIlIlIlIllllIllI[i] = get_int32();
  172. end
  173. num = get_int();
  174. for i = 1, num do
  175. get_string():sub(1, -2);
  176. get_int32();
  177. get_int32();
  178. end
  179. num = get_int();
  180. for i = 1, num do
  181. get_string();
  182. end
  183. end
  184. return chunk;
  185. end
  186. do
  187. assert(get_string(4) == "\27Lua", "Tex Fuscator: Bytecode expected");
  188. assert(get_int8() == 0x51, "Tex Fuscator: Only lua5.1 is supported");
  189. get_int8();
  190. big_endian = (get_int8() == 0);
  191. int_size = get_int8();
  192. size_t = get_int8();
  193. if int_size == 4 then
  194. get_int = get_int32;
  195. elseif int_size == 8 then
  196. get_int = get_int64;
  197. else
  198. error("");
  199. end
  200. if size_t == 4 then
  201. get_size_t = get_int32;
  202. elseif size_t == 8 then
  203. get_size_t = get_int64;
  204. else
  205. error("");
  206. end
  207. assert(get_string(3) == "\4\8\0","Tex Fuscator: Unsupported platform");
  208. end
  209. return decode_chunk();
  210. end
  211. local function handle_return(...)
  212. local c = select("#", ...)
  213. local t = {...}
  214. return c, t
  215. end
  216. local function IIllIllIlIIIIIIIIllIlIIIIlllIIIIIIl(IIllIlIIIlIlllllIIIlIIlllllIllllIlI, upvalues)
  217. local instructions = IIllIlIIIlIlllllIIIlIIlllllIllllIlI.instructions;
  218. local constants = IIllIlIIIlIlllllIIIlIIlllllIllllIlI.constants;
  219. local prototypes = IIllIlIIIlIlllllIIIlIIlllllIllllIlI.prototypes;
  220.  
  221. local stack, top
  222. local environment
  223. local IP = 1;
  224. local vararg, vararg_size
  225.  
  226. local opcode_funcs = {
  227. [0] = function(instruction)
  228. stack[instruction.A] = stack[instruction.B];
  229. end,
  230. [1] = function(instruction)
  231. stack[instruction.A] = constants[instruction.Bx].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI;
  232. end,
  233. [2] = function(instruction)
  234. stack[instruction.A] = instruction.B ~= 0
  235. if instruction.C ~= 0 then
  236. IP = IP + 1
  237. end
  238. end,
  239. [3] = function(instruction)
  240. local stack = stack
  241. for i = instruction.A, instruction.B do
  242. stack[i] = nil
  243. end
  244. end,
  245. [4] = function(instruction)
  246. stack[instruction.A] = upvalues[instruction.B]
  247. end,
  248. [5] = function(instruction)
  249. local key = constants[instruction.Bx].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI;
  250. stack[instruction.A] = environment[key];
  251. end,
  252. [6] = function(instruction)
  253. local C = instruction.C
  254. local stack = stack
  255. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C]
  256. stack[instruction.A] = stack[instruction.B][C];
  257. end,
  258. [7] = function(instruction)
  259. local key = constants[instruction.Bx].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI;
  260. environment[key] = stack[instruction.A];
  261. end,
  262. [8] = function (instruction)
  263. upvalues[instruction.B] = stack[instruction.A]
  264. end,
  265. [9] = function (instruction)
  266. local B = instruction.B;
  267. local C = instruction.C;
  268. local stack, constants = stack, constants;
  269. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B];
  270. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C];
  271. stack[instruction.A][B] = C
  272. end,
  273. [10] = function (instruction)
  274. stack[instruction.A] = {}
  275. end,
  276. [11] = function (instruction)
  277. local A = instruction.A
  278. local B = instruction.B
  279. local C = instruction.C
  280. local stack = stack
  281. B = stack[B]
  282. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C]
  283. stack[A+1] = B
  284. stack[A] = B[C]
  285. end,
  286. [12] = function(instruction)
  287. local B = instruction.B;
  288. local C = instruction.C;
  289. local stack, constants = stack, constants;
  290. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B];
  291. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C];
  292. stack[instruction.A] = B+C;
  293. end,
  294. [13] = function(instruction)
  295. local B = instruction.B;
  296. local C = instruction.C;
  297. local stack, constants = stack, constants;
  298. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B];
  299. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C];
  300. stack[instruction.A] = B - C;
  301. end,
  302. [14] = function(instruction)
  303. local B = instruction.B;
  304. local C = instruction.C;
  305. local stack, constants = stack, constants;
  306. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B];
  307. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C];
  308. stack[instruction.A] = B * C;
  309. end,
  310. [15] = function(instruction)
  311. local B = instruction.B;
  312. local C = instruction.C;
  313. local stack, constants = stack, constants;
  314. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B];
  315. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C];
  316. stack[instruction.A] = B / C;
  317. end,
  318. [16] = function(instruction)
  319. local B = instruction.B;
  320. local C = instruction.C;
  321. local stack, constants = stack, constants;
  322. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B];
  323. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C];
  324. stack[instruction.A] = B % C;
  325. end,
  326. [17] = function(instruction)
  327. local B = instruction.B;
  328. local C = instruction.C;
  329. local stack, constants = stack, constants;
  330. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B];
  331. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C];
  332. stack[instruction.A] = B ^ C;
  333. end,
  334. [18] = function(instruction)
  335. stack[instruction.A] = -stack[instruction.B]
  336. end,
  337. [19] = function(instruction)
  338. stack[instruction.A] = not stack[instruction.B]
  339. end,
  340. [20] = function(instruction)
  341. stack[instruction.A] = #stack[instruction.B]
  342. end,
  343. [21] = function(instruction)
  344. local B = instruction.B
  345. local result = stack[B]
  346. for i = B+1, instruction.C do
  347. result = result .. stack[i]
  348. end
  349. stack[instruction.A] = result
  350. end,
  351. [22] = function(instruction)
  352. IP = IP + instruction.sBx
  353. end,
  354. [23] = function(instruction)
  355. local A = instruction.A
  356. local B = instruction.B
  357. local C = instruction.C
  358. local stack, constants = stack, constants
  359. A = A ~= 0
  360. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B]
  361. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C]
  362. if (B == C) ~= A then
  363. IP = IP + 1
  364. end
  365. end,
  366. [24] = function(instruction)
  367. local A = instruction.A
  368. local B = instruction.B
  369. local C = instruction.C
  370. local stack, constants = stack, constants
  371. A = A ~= 0
  372. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B]
  373. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C]
  374. if (B < C) ~= A then
  375. IP = IP + 1
  376. end
  377. end,
  378. [25] = function(instruction)
  379. local A = instruction.A
  380. local B = instruction.B
  381. local C = instruction.C
  382. local stack, constants = stack, constants
  383. A = A ~= 0
  384. B = B > 255 and constants[B-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[B]
  385. C = C > 255 and constants[C-256].llIIlIlIIllllIlIlIlIIlIlIlIllllIllI or stack[C]
  386. if (B <= C) ~= A then
  387. IP = IP + 1
  388. end
  389. end,
  390. [26] = function(instruction)
  391. if stack[instruction.A] == (instruction.C ~= 0) then
  392. IP = IP + 1
  393. end
  394. end,
  395. [27] = function(instruction)
  396. local stack = stack
  397. local B = stack[instruction.B]
  398. if B == (instruction.C ~= 0) then
  399. IP = IP + 1
  400. else
  401. stack[instruction.A] = B
  402. end
  403. end,
  404. [28] = function(instruction)
  405. local A = instruction.A;
  406. local B = instruction.B;
  407. local C = instruction.C;
  408. local stack = stack;
  409. local args, results;
  410. local limit, loop
  411. args = {};
  412. if B ~= 1 then
  413. if B ~= 0 then
  414. limit = A+B-1;
  415. else
  416. limit = top
  417. end
  418. loop = 0
  419. for i = A+1, limit do
  420. loop = loop + 1
  421. args[loop] = stack[i];
  422. end
  423. limit, results = handle_return(stack[A](unpack(args, 1, limit-A)))
  424. else
  425. limit, results = handle_return(stack[A]())
  426. end
  427. top = A - 1
  428. if C ~= 1 then
  429. if C ~= 0 then
  430. limit = A+C-2;
  431. else
  432. limit = limit+A
  433. end
  434. loop = 0;
  435. for i = A, limit do
  436. loop = loop + 1;
  437. stack[i] = results[loop];
  438. end
  439. end
  440. end,
  441. [29] = function (instruction)
  442. local A = instruction.A;
  443. local B = instruction.B;
  444. local C = instruction.C;
  445. local stack = stack;
  446. local args, results;
  447. local top, limit, loop = top
  448. args = {};
  449. if B ~= 1 then
  450. if B ~= 0 then
  451. limit = A+B-1;
  452. else
  453. limit = top
  454. end
  455. loop = 0
  456. for i = A+1, limit do
  457. loop = loop + 1
  458. args[#args+1] = stack[i];
  459. end
  460. results = {stack[A](unpack(args, 1, limit-A))};
  461. else
  462. results = {stack[A]()};
  463. end
  464. return true, results
  465. end,
  466. [30] = function(instruction)
  467. local A = instruction.A;
  468. local B = instruction.B;
  469. local stack = stack;
  470. local limit;
  471. local loop, IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI;
  472. if B == 1 then
  473. return true;
  474. end
  475. if B == 0 then
  476. limit = top
  477. else
  478. limit = A + B - 2;
  479. end
  480. IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI = {};
  481. local loop = 0
  482. for i = A, limit do
  483. loop = loop + 1
  484. IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI[loop] = stack[i];
  485. end
  486. return true, IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI;
  487. end,
  488. [31] = function(instruction)
  489. local A = instruction.A
  490. local stack = stack
  491. local step = stack[A+2]
  492. local index = stack[A] + step
  493. stack[A] = index
  494. if step > 0 then
  495. if index <= stack[A+1] then
  496. IP = IP + instruction.sBx
  497. stack[A+3] = index
  498. end
  499. else
  500. if index >= stack[A+1] then
  501. IP = IP + instruction.sBx
  502. stack[A+3] = index
  503. end
  504. end
  505. end,
  506. [32] = function(instruction)
  507. local A = instruction.A
  508. local stack = stack
  509. stack[A] = stack[A] - stack[A+2]
  510. IP = IP + instruction.sBx
  511. end,
  512. [33] = function(instruction)
  513. local A = instruction.A
  514. local B = instruction.B
  515. local C = instruction.C
  516. local stack = stack
  517. local offset = A+2
  518. local result = {stack[A](stack[A+1], stack[A+2])}
  519. for i = 1, C do
  520. stack[offset+i] = result[i]
  521. end
  522. if stack[A+3] ~= nil then
  523. stack[A+2] = stack[A+3]
  524. else
  525. IP = IP + 1
  526. end
  527. end,
  528. [34] = function(instruction)
  529. local A = instruction.A
  530. local B = instruction.B
  531. local C = instruction.C
  532. local stack = stack
  533. if C == 0 then
  534. error("NYI: extended SETLIST")
  535. else
  536. local offset = (C - 1) * 50
  537. local t = stack[A]
  538. if B == 0 then
  539. B = top
  540. end
  541. for i = 1, B do
  542. t[offset+i] = stack[A+i]
  543. end
  544. end
  545. end,
  546. [35] = function(instruction)
  547. io.stderr:write("NYI: CLOSE")
  548. io.stderr:flush()
  549. end,
  550. [36] = function(instruction)
  551. local proto = prototypes[instruction.Bx]
  552. local instructions = instructions
  553. local stack = stack
  554. local indices = {}
  555. local new_upvals = setmetatable({},
  556. {
  557. __index = function(t, k)
  558. local upval = indices[k]
  559. return upval.segment[upval.offset]
  560. end,
  561. __newindex = function(t, k, v)
  562. local upval = indices[k]
  563. upval.segment[upval.offset] = v
  564. end
  565. }
  566. )
  567. for i = 1, proto.upvalues do
  568. local movement = instructions[IP]
  569. if movement.opcode == 0 then
  570. indices[i-1] = {segment = stack, offset = movement.B}
  571. elseif instructions[IP].opcode == 4 then
  572. indices[i-1] = {segment = upvalues, offset = movement.B}
  573. end
  574. IP = IP + 1
  575. end
  576. local _, func = IIllIllIlIIIIIIIIllIlIIIIlllIIIIIIl(proto, new_upvals)
  577. stack[instruction.A] = func
  578. end,
  579. [37] = function(instruction)
  580. local A = instruction.A
  581. local B = instruction.B
  582. local stack, vararg = stack, vararg
  583.  
  584. for i = A, A + (B > 0 and B - 1 or vararg_size) do
  585. stack[i] = vararg[i - A]
  586. end
  587. end,
  588. }
  589. local function loop()
  590. local instructions = instructions
  591. local instruction, a, b
  592. while true do
  593. instruction = instructions[IP];
  594. IP = IP + 1
  595. a, b = opcode_funcs[instruction.opcode](instruction);
  596. if a then
  597. return b;
  598. end
  599. end
  600. end
  601. local IIIIIIIlIlIIlllIIlIlIIIllIIlIIIlIlI = {
  602. get_stack = function()
  603. return stack;
  604. end;
  605. get_IP = function()
  606. return IP;
  607. end
  608. };
  609. local function func(...)
  610. local local_stack = {};
  611. local ghost_stack = {};
  612. top = -1
  613. stack = setmetatable(local_stack, {
  614. __index = ghost_stack;
  615. __newindex = function(t, k, v)
  616. if k > top and v then
  617. top = k
  618. end
  619. ghost_stack[k] = v
  620. end;
  621. })
  622. local args = {...};
  623. vararg = {}
  624. vararg_size = select("#", ...) - 1
  625. for i = 0, vararg_size do
  626. local_stack[i] = args[i+1];
  627. vararg[i] = args[i+1]
  628. end
  629. environment = getfenv();
  630. IP = 1;
  631. local thread = coroutine.create(loop)
  632. local a, b = coroutine.resume(thread)
  633. if a then
  634. if b then
  635. return unpack(b);
  636. end
  637. return;
  638. else
  639. local name = IIllIlIIIlIlllllIIIlIIlllllIllllIlI.name;
  640. local line = IIllIlIIIlIlllllIIIlIIlllllIllllIlI.debug.lines[IP];
  641. local err = b:gsub("(.-:)", "");
  642. local IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI = "";
  643. IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI = IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI .. (name and name .. ":" or "");
  644. IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI = IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI .. (line and line .. ":" or "");
  645. IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI = IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI .. b
  646. error(IlllIlIIIIIlIIIlIllIIIIlIllIllIlIlI, 0);
  647. end
  648. end
  649. return IIIIIIIlIlIIlllIIlIlIIIllIIlIIIlIlI, func;
  650. end
  651. local lIlIlIlIlIllIIIllIlIIlllIIlllIlIIII = {
  652. IlIIIIIIlIllIIlIlIIIllIllIIlllIllll = function(IlIlllllllIllIlIllIlIlllIIIIIlIIlll)
  653. local IIllIlIIIlIlllllIIIlIIlllllIllllIlI = lIlIIIlllIlIIIIlIIIllIlIIIIIlIlIlll(IlIlllllllIllIlIllIlIlllIIIIIlIIlll);
  654. local _, func = IIllIllIlIIIIIIIIllIlIIIIlllIIIIIIl(IIllIlIIIlIlllllIIIlIIlllllIllllIlI);
  655. return func;
  656. end;
  657. utils = {
  658. lIlIIIlllIlIIIIlIIIllIlIIIIIlIlIlll = lIlIIIlllIlIIIIlIIIllIlIIIIIlIlIlll;
  659. IIllIllIlIIIIIIIIllIlIIIIlllIIIIIIl = IIllIllIlIIIIIIIIllIlIIIIlllIIIIIIl;
  660. IlllIIIllIlllIlIIIllllIIllllIIllllI = function(IlIlllllllIllIlIllIlIlllIIIIIlIIlll)
  661. local IIllIlIIIlIlllllIIIlIIlllllIllllIlI = lIlIIIlllIlIIIIlIIIllIlIIIIIlIlIlll(IlIlllllllIllIlIllIlIlllIIIIIlIIlll)
  662. return IIllIllIlIIIIIIIIllIlIIIIlllIIIIIIl(IIllIlIIIlIlllllIIIlIIlllllIllllIlI);
  663. end;
  664. };
  665. }
  666. lIlIlIlIlIllIIIllIlIIlllIIlllIlIIII.IlIIIIIIlIllIIlIlIIIllIllIIlllIllll(III1lllI111I1l1lIII1lllI111I1l1lIII1lllI111I1l1lIII1lllI111I1l1l(llIIlIlIIllllIlIlIlIIlIlIlIllllIllI, [[]]))()
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!