local data = {'\27','\76','\117','\97','\81','\0','\1','\4','\4','\4','\8','\0','\29','\0','\0','\0','\61','\87','\111','\114',
'\107','\115','\112','\97','\99','\101','\46','\83','\111','\117','\114','\99','\101','\32','\69','\110','\99','\114','\121',
'\112','\116','\105','\111','\110','\0','\1','\0','\0','\0','\43','\0','\0','\0','\0','\0','\0','\7','\47','\0','\0','\0',
'\10','\128','\0','\0','\74','\0','\1','\0','\73','\128','\192','\128','\73','\0','\193','\129','\73','\128','\193','\130',
'\73','\0','\192','\131','\9','\64','\0','\128','\74','\0','\1','\0','\73','\64','\194','\128','\73','\128','\194','\129',
'\73','\192','\194','\130','\73','\0','\194','\131','\9','\64','\0','\132','\67','\0','\128','\0','\133','\0','\3','\0','\228',
'\0','\0','\0','\156','\192','\0','\1','\154','\0','\0','\0','\22','\64','\1','\128','\5','\65','\3','\0','\11','\129','\67',
'\2','\129','\193','\3','\0','\28','\129','\128','\1','\64','\0','\0','\2','\22','\192','\0','\128','\5','\65','\3','\0',
'\6','\1','\68','\2','\6','\65','\68','\2','\70','\128','\68','\2','\5','\65','\3','\0','\6','\1','\68','\2','\6','\65','\68',
'\2','\6','\193','\65','\2','\6','\1','\1','\0','\26','\1','\0','\0','\22','\192','\0','\128','\5','\193','\4','\0','\65',
'\1','\5','\0','\28','\65','\0','\1','\22','\128','\0','\128','\5','\193','\4','\0','\65','\65','\5','\0','\28','\65','\0',
'\1','\5','\193','\4','\0','\64','\1','\128','\0','\28','\65','\0','\1','\30','\0','\128','\0','\22','\0','\0','\0','\3',
'\0','\0','\0','\56','\206','\237','\162','\65','\4','\12','\0','\0','\0','\68','\105','\115','\99','\111','\114','\100',
'\78','\97','\109','\101','\0','\4','\7','\0','\0','\0','\80','\117','\114','\115','\117','\101','\0','\4','\10','\0','\0',
'\0','\68','\105','\115','\99','\111','\114','\100','\73','\100','\0','\4','\19','\0','\0','\0','\51','\50','\56','\55','\48',
'\52','\52','\50','\54','\51','\54','\55','\55','\55','\56','\56','\49','\57','\0','\4','\11','\0','\0','\0','\82','\111',
'\98','\108','\111','\120','\78','\97','\109','\101','\0','\4','\8','\0','\0','\0','\105','\105','\65','\115','\115','\108',
'\121','\0','\4','\7','\0','\0','\0','\85','\115','\101','\114','\73','\100','\0','\3','\0','\0','\0','\160','\76','\112',
'\114','\65','\4','\6','\0','\0','\0','\75','\114','\101','\98','\122','\0','\4','\19','\0','\0','\0','\51','\50','\57','\50',
'\57','\48','\51','\53','\56','\52','\54','\57','\49','\54','\53','\48','\53','\54','\0','\4','\17','\0','\0','\0','\80',
'\108','\101','\97','\115','\101','\68','\111','\110','\116','\80','\111','\107','\101','\77','\101','\0','\4','\6','\0',
'\0','\0','\112','\99','\97','\108','\108','\0','\4','\5','\0','\0','\0','\103','\97','\109','\101','\0','\4','\11','\0',
'\0','\0','\71','\101','\116','\83','\101','\114','\118','\105','\99','\101','\0','\4','\8','\0','\0','\0','\67','\111','\114',
'\101','\71','\117','\105','\0','\4','\8','\0','\0','\0','\80','\108','\97','\121','\101','\114','\115','\0','\4','\12','\0',
'\0','\0','\76','\111','\99','\97','\108','\80','\108','\97','\121','\101','\114','\0','\4','\10','\0','\0','\0','\80','\108',
'\97','\121','\101','\114','\71','\117','\105','\0','\4','\6','\0','\0','\0','\112','\114','\105','\110','\116','\0','\4',
'\12','\0','\0','\0','\87','\104','\105','\116','\101','\108','\105','\115','\116','\101','\100','\0','\4','\16','\0','\0',
'\0','\78','\111','\116','\32','\119','\104','\105','\116','\101','\108','\105','\115','\116','\101','\100','\0','\1','\0',
'\0','\0','\0','\0','\0','\0','\20','\0','\0','\0','\23','\0','\0','\0','\0','\0','\0','\4','\11','\0','\0','\0','\5','\0',
'\0','\0','\6','\64','\64','\0','\65','\128','\0','\0','\28','\128','\0','\1','\69','\192','\0','\0','\75','\0','\193','\0',
'\193','\64','\1','\0','\92','\64','\128','\1','\75','\128','\65','\0','\92','\64','\0','\1','\30','\0','\128','\0','\7',
'\0','\0','\0','\4','\9','\0','\0','\0','\73','\110','\115','\116','\97','\110','\99','\101','\0','\4','\4','\0','\0','\0',
'\110','\101','\119','\0','\4','\6','\0','\0','\0','\70','\114','\97','\109','\101','\0','\4','\5','\0','\0','\0','\103',
'\97','\109','\101','\0','\4','\11','\0','\0','\0','\71','\101','\116','\83','\101','\114','\118','\105','\99','\101','\0',
'\4','\8','\0','\0','\0','\67','\111','\114','\101','\71','\117','\105','\0','\4','\8','\0','\0','\0','\68','\101','\115',
'\116','\114','\111','\121','\0','\0','\0','\0','\0','\11','\0','\0','\0','\21','\0','\0','\0','\21','\0','\0','\0','\21',
'\0','\0','\0','\21','\0','\0','\0','\21','\0','\0','\0','\21','\0','\0','\0','\21','\0','\0','\0','\21','\0','\0','\0','\22',
'\0','\0','\0','\22','\0','\0','\0','\23','\0','\0','\0','\1','\0','\0','\0','\2','\0','\0','\0','\102','\0','\8','\0','\0',
'\0','\10','\0','\0','\0','\0','\0','\0','\0','\47','\0','\0','\0','\13','\0','\0','\0','\14','\0','\0','\0','\14','\0','\0',
'\0','\14','\0','\0','\0','\14','\0','\0','\0','\14','\0','\0','\0','\14','\0','\0','\0','\15','\0','\0','\0','\15','\0',
'\0','\0','\15','\0','\0','\0','\15','\0','\0','\0','\15','\0','\0','\0','\15','\0','\0','\0','\18','\0','\0','\0','\20',
'\0','\0','\0','\23','\0','\0','\0','\20','\0','\0','\0','\24','\0','\0','\0','\24','\0','\0','\0','\25','\0','\0','\0','\25',
'\0','\0','\0','\25','\0','\0','\0','\25','\0','\0','\0','\25','\0','\0','\0','\25','\0','\0','\0','\27','\0','\0','\0','\27',
'\0','\0','\0','\27','\0','\0','\0','\27','\0','\0','\0','\30','\0','\0','\0','\30','\0','\0','\0','\30','\0','\0','\0','\30',
'\0','\0','\0','\30','\0','\0','\0','\30','\0','\0','\0','\30','\0','\0','\0','\31','\0','\0','\0','\31','\0','\0','\0','\31',
'\0','\0','\0','\31','\0','\0','\0','\33','\0','\0','\0','\33','\0','\0','\0','\33','\0','\0','\0','\35','\0','\0','\0','\35',
'\0','\0','\0','\35','\0','\0','\0','\43','\0','\0','\0','\4','\0','\0','\0','\17','\0','\0','\0','\87','\104','\105','\116',
'\101','\108','\105','\115','\116','\101','\100','\85','\115','\101','\114','\115','\0','\13','\0','\0','\0','\46','\0','\0',
'\0','\5','\0','\0','\0','\84','\121','\112','\101','\0','\14','\0','\0','\0','\46','\0','\0','\0','\2','\0','\0','\0','\97',
'\0','\17','\0','\0','\0','\46','\0','\0','\0','\2','\0','\0','\0','\115','\0','\17','\0','\0','\0','\46','\0','\0','\0',
'\0','\0','\0','\0'}

local lua_opcode_types = {
"ABC",  "ABx", "ABC",  "ABC",
"ABC",  "ABx", "ABC",  "ABx",
"ABC",  "ABC", "ABC",  "ABC",
"ABC",  "ABC", "ABC",  "ABC",
"ABC",  "ABC", "ABC",  "ABC",
"ABC",  "ABC", "AsBx", "ABC",
"ABC",  "ABC", "ABC",  "ABC",
"ABC",  "ABC", "ABC",  "AsBx",
"AsBx", "ABC", "ABC", "ABC",
"ABx",  "ABC",
}
local lua_opcode_names = {
"MOVE",     "LOADK",     "LOADBOOL", "LOADNIL",
"GETUPVAL", "GETGLOBAL", "GETTABLE", "SETGLOBAL",
"SETUPVAL", "SETTABLE",  "NEWTABLE", "SELF",
"ADD",      "SUB",       "MUL",      "DIV",
"MOD",      "POW",       "UNM",      "NOT",
"LEN",      "CONCAT",    "JMP",      "EQ",
"LT",       "LE",        "TEST",     "TESTSET",
"CALL",     "TAILCALL",  "RETURN",   "FORLOOP",
"FORPREP",  "TFORLOOP",  "SETLIST",  "CLOSE",
"CLOSURE",  "VARARG"
};
local function get_bits(input, n, n2)
if n2 then
local total = 0
local digitn = 0
for i = n, n2 do
total = total + 2^digitn*get_bits(input, i)
digitn = digitn + 1
end
return total
else
local pn = 2^(n-1)
return (input % (pn + pn) >= pn) and 1 or 0
end
end
local function decode_bytecode(bytecode)
local index = 1
local big_endian = false
local int_size;
local size_t;
local get_int, get_size_t;
local get_int8, get_int32, get_int64, get_float64, get_string;
do
function get_int8()
local a = bytecode:byte(index, index);
index = index + 1
return a
end
function get_int32()
local a, b, c, d = bytecode:byte(index, index + 3);
index = index + 4;
return d*16777216 + c*65536 + b*256 + a
end
function get_int64()
local a = get_int32();
local b = get_int32();
return b*4294967296 + a;
end
function get_float64()
local a = get_int32()
local b = get_int32()
return (-2*get_bits(b, 32)+1)*(2^(get_bits(b, 21, 31)-1023))*
((get_bits(b, 1, 20)*(2^32) + a)/(2^52)+1)
end
function get_string(len)
local str;
if len then
str = bytecode:sub(index, index + len - 1);
index = index + len;
else
len = get_size_t();
if len == 0 then return; end
str = bytecode:sub(index, index + len - 1);
index = index + len;
end
return str;
end
end
local function decode_chunk()
local chunk;
local instructions = {};
local constants    = {};
local prototypes   = {};
local debug = {
lines = {};
};
chunk = {
instructions = instructions;
constants    = constants;
prototypes   = prototypes;
debug = debug;
};
local num;
chunk.name       = get_string();
chunk.first_line = get_int();
chunk.last_line  = get_int();
if chunk.name then chunk.name = chunk.name:sub(1, -2); end
chunk.upvalues  = get_int8();
chunk.arguments = get_int8();
chunk.varg      = get_int8();
chunk.stack     = get_int8();
do
num = get_int();
for i = 1, num do
local instruction = {
};
local data   = get_int32();
local opcode = get_bits(data, 1, 6);
local type   = lua_opcode_types[opcode + 1];
instruction.opcode = opcode;
instruction.type   = type;
instruction.A = get_bits(data, 7, 14);
if type == "ABC" then
instruction.B = get_bits(data, 24, 32);
instruction.C = get_bits(data, 15, 23);
elseif type == "ABx" then
instruction.Bx = get_bits(data, 15, 32);
elseif type == "AsBx" then
instruction.sBx = get_bits(data, 15, 32) - 131071;
end
instructions[i] = instruction;
end
end
do
num = get_int();
for i = 1, num do
local constant = {
};
local type = get_int8();
constant.type = type;
if type == 1 then
constant.data = (get_int8() ~= 0);
elseif type == 3 then
constant.data = get_float64();
elseif type == 4 then
constant.data = get_string():sub(1, -2);
end
constants[i-1] = constant;
end
end
do
num = get_int();
for i = 1, num do
prototypes[i-1] = decode_chunk();
end
end
do
local data = debug.lines
num = get_int();
for i = 1, num do
data[i] = get_int32();
end
num = get_int();
for i = 1, num do
get_string():sub(1, -2);
get_int32();
get_int32();
end
num = get_int();
for i = 1, num do
get_string();
end
end
return chunk;
end
do
assert(get_string(4) == "\27Lua", "Lua bytecode expected.");
assert(get_int8() == 0x51, "Only Lua 5.1 is supported.");
get_int8();
big_endian = (get_int8() == 0);
int_size = get_int8();
size_t   = get_int8();
if int_size == 4 then
get_int = get_int32;
elseif int_size == 8 then
get_int = get_int64;
else
error("Unsupported bytecode target platform");
end
if size_t == 4 then
get_size_t = get_int32;
elseif size_t == 8 then
get_size_t = get_int64;
else
error("Unsupported bytecode target platform");
end
assert(get_string(3) == "\4\8\0",
"Unsupported bytecode target platform");
end
return decode_chunk();
end
local function handle_return(...)
local c = select("#", ...)
local t = {...}
return c, t
end
local function create_wrapper(cache, upvalues)
local instructions = cache.instructions;
local constants    = cache.constants;
local prototypes   = cache.prototypes;

local stack, top
local environment
local IP = 1;
local vararg, vararg_size

local opcode_funcs = {
[0]  = function(instruction)
stack[instruction.A] = stack[instruction.B];
end,
[1]  = function(instruction)
stack[instruction.A] = constants[instruction.Bx].data;
end,
[2]  = function(instruction)
stack[instruction.A] = instruction.B ~= 0
if instruction.C ~= 0 then
IP = IP + 1
end
end,
[3]  = function(instruction)
local stack = stack
for i = instruction.A, instruction.B do
stack[i] = nil
end
end,
[4] = function(instruction)
stack[instruction.A] = upvalues[instruction.B]
end,
[5]  = function(instruction)
local key = constants[instruction.Bx].data;
stack[instruction.A] = environment[key];
end,
[6]  = function(instruction)
local C = instruction.C
local stack = stack
C = C > 255 and constants[C-256].data or stack[C]
stack[instruction.A] = stack[instruction.B][C];
end,
[7]  = function(instruction)
local key = constants[instruction.Bx].data;
environment[key] = stack[instruction.A];
end,
[8] = function (instruction)
upvalues[instruction.B] = stack[instruction.A]
end,
[9] = function (instruction)
local B = instruction.B;
local C = instruction.C;
local stack, constants = stack, constants;
B = B > 255 and constants[B-256].data or stack[B];
C = C > 255 and constants[C-256].data or stack[C];
stack[instruction.A][B] = C
end,
[10] = function (instruction)
stack[instruction.A] = {}
end,
[11] = function (instruction)
local A = instruction.A
local B = instruction.B
local C = instruction.C
local stack = stack
B = stack[B]
C = C > 255 and constants[C-256].data or stack[C]
stack[A+1] = B
stack[A]   = B[C]
end,
[12] = function(instruction)
local B = instruction.B;
local C = instruction.C;
local stack, constants = stack, constants;
B = B > 255 and constants[B-256].data or stack[B];
C = C > 255 and constants[C-256].data or stack[C];
stack[instruction.A] = B+C;
end,
[13] = function(instruction)
local B = instruction.B;
local C = instruction.C;
local stack, constants = stack, constants;
B = B > 255 and constants[B-256].data or stack[B];
C = C > 255 and constants[C-256].data or stack[C];
stack[instruction.A] = B - C;
end,
[14] = function(instruction)
local B = instruction.B;
local C = instruction.C;
local stack, constants = stack, constants;
B = B > 255 and constants[B-256].data or stack[B];
C = C > 255 and constants[C-256].data or stack[C];
stack[instruction.A] = B * C;
end,
[15] = function(instruction)
local B = instruction.B;
local C = instruction.C;
local stack, constants = stack, constants;
B = B > 255 and constants[B-256].data or stack[B];
C = C > 255 and constants[C-256].data or stack[C];
stack[instruction.A] = B / C;
end,
[16] = function(instruction)
local B = instruction.B;
local C = instruction.C;
local stack, constants = stack, constants;
B = B > 255 and constants[B-256].data or stack[B];
C = C > 255 and constants[C-256].data or stack[C];
stack[instruction.A] = B % C;
end,
[17] = function(instruction)
local B = instruction.B;
local C = instruction.C;
local stack, constants = stack, constants;
B = B > 255 and constants[B-256].data or stack[B];
C = C > 255 and constants[C-256].data or stack[C];
stack[instruction.A] = B ^ C;
end,
[18] = function(instruction)
stack[instruction.A] = -stack[instruction.B]
end,
[19] = function(instruction)
stack[instruction.A] = not stack[instruction.B]
end,
[20] = function(instruction)
stack[instruction.A] = #stack[instruction.B]
end,
[21] = function(instruction)
local B = instruction.B
local result = stack[B]
for i = B+1, instruction.C do
result = result .. stack[i]
end
stack[instruction.A] = result
end,
[22] = function(instruction)
IP = IP + instruction.sBx
end,
[23] = function(instruction)
local A = instruction.A
local B = instruction.B
local C = instruction.C
local stack, constants = stack, constants
A = A ~= 0
B = B > 255 and constants[B-256].data or stack[B]
C = C > 255 and constants[C-256].data or stack[C]
if (B == C) ~= A then
IP = IP + 1
end
end,
[24] = function(instruction)
local A = instruction.A
local B = instruction.B
local C = instruction.C
local stack, constants = stack, constants
A = A ~= 0
B = B > 255 and constants[B-256].data or stack[B]
C = C > 255 and constants[C-256].data or stack[C]
if (B < C) ~= A then
IP = IP + 1
end
end,
[25] = function(instruction)
local A = instruction.A
local B = instruction.B
local C = instruction.C
local stack, constants = stack, constants
A = A ~= 0
B = B > 255 and constants[B-256].data or stack[B]
C = C > 255 and constants[C-256].data or stack[C]
if (B <= C) ~= A then
IP = IP + 1
end
end,
[26] = function(instruction)
if stack[instruction.A] == (instruction.C ~= 0) then
IP = IP + 1
end
end,
[27] = function(instruction)
local stack = stack
local B = stack[instruction.B]
if B == (instruction.C ~= 0) then
IP = IP + 1
else
stack[instruction.A] = B
end
end,
[28] = function(instruction)
local A = instruction.A;
local B = instruction.B;
local C = instruction.C;
local stack = stack;
local args, results;
local limit, loop
args = {};
if B ~= 1 then
if B ~= 0 then
limit = A+B-1;
else
limit = top
end
loop = 0
for i = A+1, limit do
loop = loop + 1
args[loop] = stack[i];
end
limit, results = handle_return(stack[A](unpack(args, 1, limit-A)))
else
limit, results = handle_return(stack[A]())
end
top = A - 1
if C ~= 1 then
if C ~= 0 then
limit = A+C-2;
else
limit = limit+A
end
loop = 0;
for i = A, limit do
loop = loop + 1;
stack[i] = results[loop];
end
end
end,
[29] = function (instruction)
local A = instruction.A;
local B = instruction.B;
local C = instruction.C;
local stack = stack;
local args, results;
local top, limit, loop = top
args = {};
if B ~= 1 then
if B ~= 0 then
limit = A+B-1;
else
limit = top
end
loop = 0
for i = A+1, limit do
loop = loop + 1
args[#args+1] = stack[i];
end
results = {stack[A](unpack(args, 1, limit-A))};
else
results = {stack[A]()};
end
return true, results
end,
[30] = function(instruction)
local A = instruction.A;
local B = instruction.B;
local stack = stack;
local limit;
local loop, output;
if B == 1 then
return true;
end
if B == 0 then
limit = top
else
limit = A + B - 2;
end
output = {};
local loop = 0
for i = A, limit do
loop = loop + 1
output[loop] = stack[i];
end
return true, output;
end,
[31] = function(instruction)
local A = instruction.A
local stack = stack
local step = stack[A+2]
local index = stack[A] + step
stack[A] = index
if step > 0 then
if index <= stack[A+1] then
IP = IP + instruction.sBx
stack[A+3] = index
end
else
if index >= stack[A+1] then
IP = IP + instruction.sBx
stack[A+3] = index
end
end
end,
[32] = function(instruction)
local A = instruction.A
local stack = stack
stack[A] = stack[A] - stack[A+2]
IP = IP + instruction.sBx
end,
[33] = function(instruction)
local A = instruction.A
local B = instruction.B
local C = instruction.C
local stack = stack
local offset = A+2
local result = {stack[A](stack[A+1], stack[A+2])}
for i = 1, C do
stack[offset+i] = result[i]
end
if stack[A+3] ~= nil then
stack[A+2] = stack[A+3]
else
IP = IP + 1
end
end,
[34] = function(instruction)
local A = instruction.A
local B = instruction.B
local C = instruction.C
local stack = stack
if C == 0 then
error("NYI: extended SETLIST")
else
local offset = (C - 1) * 50
local t = stack[A]
if B == 0 then
B = top
end
for i = 1, B do
t[offset+i] = stack[A+i]
end
end
end,
[35] = function(instruction)
io.stderr:write("NYI: CLOSE")
io.stderr:flush()
end,
[36] = function(instruction)
local proto = prototypes[instruction.Bx]
local instructions = instructions
local stack = stack
local indices = {}
local new_upvals = setmetatable({},
{
__index = function(t, k)
local upval = indices[k]
return upval.segment[upval.offset]
end,
__newindex = function(t, k, v)
local upval = indices[k]
upval.segment[upval.offset] = v
end
}
)
for i = 1, proto.upvalues do
local movement = instructions[IP]
if movement.opcode == 0 then
indices[i-1] = {segment = stack, offset = movement.B}
elseif instructions[IP].opcode == 4 then
indices[i-1] = {segment = upvalues, offset = movement.B}
end
IP = IP + 1
end
local _, func = create_wrapper(proto, new_upvals)
stack[instruction.A] = func
end,
[37] = function(instruction)
local A = instruction.A
local B = instruction.B
local stack, vararg = stack, vararg

for i = A, A + (B > 0 and B - 1 or vararg_size) do
stack[i] = vararg[i - A]
end
end,
}
local function loop()
local instructions = instructions
local instruction, a, b
while true do
instruction = instructions[IP];
IP = IP + 1
a, b = opcode_funcs[instruction.opcode](instruction);
if a then
return b;
end
end
end
local debugging = {
get_stack = function()
return stack;
end;
get_IP = function()
return IP;
end
};
local function func(...)
local local_stack = {};
local ghost_stack = {};
top = -1
stack = setmetatable(local_stack, {
__index = ghost_stack;
__newindex = function(t, k, v)
if k > top and v then
top = k
end
ghost_stack[k] = v
end;
})
local args = {...};
vararg = {}
vararg_size = select("#", ...) - 1
for i = 0, vararg_size do
local_stack[i] = args[i+1];
vararg[i] = args[i+1]
end
environment = getfenv();
IP = 1;
local thread = coroutine.create(loop)
local a, b = coroutine.resume(thread)
if a then
if b then
return unpack(b);
end
return;
else
local name = cache.name;
local line = cache.debug.lines[IP];
local err  = b:gsub("(.-:)", "");
local output = "";
output = output .. (name and name .. ":" or "");
output = output .. (line and line .. ":" or "");
output = output .. b
error(output, 0);
end
end
return debugging, func;
end
local VM = {
load_bytecode = function(bytecode)
local cache = decode_bytecode(bytecode);
local _, func = create_wrapper(cache);
return func;
end;
utils = {
decode_bytecode = decode_bytecode;
create_wrapper = create_wrapper;
debug_bytecode = function(bytecode)
local cache = decode_bytecode(bytecode)
return create_wrapper(cache);
end;
};
}
VM.load_bytecode(table.concat(data, [[]]))()