SHARE
TWEET

Untitled

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