SHARE
TWEET

Alora V1.0.3 (Tex Fuscator)

TexlzAye Mar 20th, 2019 99 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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, [[]]))()
RAW Paste Data
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
 
Top