Keyless
inf money READ DESC
lucaswewq1 1 year ago 1.8K views 2Run it
Copy the script and paste it into your executor.
inf money READ DESC.lua 路 1,754 lines
= ;
= ;
= ;
= ;
assert = assert;
= ;
string_format = .format;
table_move = .move;
table_pack = .pack;
table_unpack = .unpack;
table_create = .create;
table_insert = .insert;
table_remove = .remove;
table_concat = .concat;
coroutine_create = .create;
coroutine_yield = .yield;
coroutine_resume = .resume;
coroutine_close = .close;
buffer_fromstring = buffer.fromstring;
buffer_len = buffer.len;
buffer_readu8 = buffer.readu8;
buffer_readu32 = buffer.readu32;
buffer_readstring = buffer.readstring;
buffer_readf32 = buffer.readf32;
buffer_readf64 = buffer.readf64;
bit32_bor = bit32.bor;
bit32_band = bit32.band;
bit32_btest = bit32.btest;
bit32_rshift = bit32.rshift;
bit32_lshift = bit32.lshift;
bit32_extract = bit32.extract;
ttisnumber = (v)
(v) ==
;
ttisstring = (v)
(v) ==
;
ttisboolean = (v)
(v) ==
;
ttisfunction = (v)
(v) ==
;
opList = {
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
},
{
,
,
,
}
}
LUA_MULTRET = -
LUA_GENERALIZED_TERMINATOR = -
()
{
vectorCtor = ()
()
,
vectorSize = ,
useNativeNamecall = ,
namecallHandler = ()
()
,
extensions = {},
callHooks = {},
errorHandling = ,
generalizedIteration = ,
allowProxyErrors = ,
useImportConstants = ,
staticEnvironment = {},
decodeOp = (op)
op
}
;
(luau_settings)
((luau_settings) == , )
((luau_settings.vectorCtor) == , )
((luau_settings.vectorSize) == , )
((luau_settings.useNativeNamecall) == , )
((luau_settings.namecallHandler) == , )
((luau_settings.extensions) == , )
((luau_settings.callHooks) == , )
((luau_settings.errorHandling) == , )
((luau_settings.generalizedIteration) == , )
((luau_settings.allowProxyErrors) == , )
((luau_settings.staticEnvironment) == , )
((luau_settings.useImportConstants) == , )
((luau_settings.decodeOp) == , )
;
(module, protoid)
proto;
(protoid == )
proto = module.mainProto
proto = module.protoList[protoid]
;
size = -
(proto.lineinfoenabled, )
pc = , proto.sizecode
line = proto.instructionlineinfo[pc]
size = (line >= size line) size
;
i, subid proto.protos
maxline = (module, subid)
size = (maxline >= size maxline) size
;
size
;
(module, protoid, depth, callback, size)
proto;
protoid ==
proto = module.mainProto
proto = module.protoList[protoid]
;
(proto.lineinfoenabled, )
buffer = {}
pc = , proto.sizecode
inst = proto.code[pc]
line = proto.instructionlineinfo[pc]
(inst.opcode ~= )
;
hits = inst.E;
(buffer[line] ) > hits
buffer[line] = buffer[line]
buffer[line] = hits
;
(proto.debugname, proto.linedefined, depth, buffer, size)
i, subid proto.protos
(module, subid, depth + , callback, size)
;
(module, protoid, callback)
((module) == , )
((protoid) == protoid == , )
((callback) == , )
(module, protoid, , callback, (module))
;
(static, count, k0, k1, k2)
res = static[k0]
count < res ==
res
;
res = res[k1]
count < res ==
res
;
res = res[k2]
res
;
(bytecode, luau_settings)
luau_settings ==
luau_settings = ()
(luau_settings)
;
stream;
(bytecode) ==
stream = (bytecode)
stream = bytecode
;
cursor = ;
()
byte = (stream, cursor)
cursor = cursor + ;
byte
;
()
word = (stream, cursor)
cursor = cursor + ;
word
;
()
float = (stream, cursor)
cursor = cursor + ;
float
;
()
double = (stream, cursor)
cursor = cursor + ;
double
;
()
result = ;
i = ,
value = ()
result = (result, ((value, ), i * ))
(value, )
;
result
;
()
size = ()
size ==
str = (stream, cursor, size)
cursor = cursor + size;
str
;
luauVersion = ()
typesVersion = ;
luauVersion ==
(, )
luauVersion < luauVersion >
(, )
luauVersion >=
typesVersion = ()
;
stringCount = ()
stringList = (stringCount)
i = , stringCount
stringList[i] = ()
;
(codeList)
value = luau_settings.(())
opcode = (value, )
opinfo = opList[opcode + ]
opname = opinfo[]
opmode = opinfo[]
kmode = opinfo[]
usesAux = opinfo[]
inst = {
opcode = opcode;
opname = opname;
opmode = opmode;
kmode = kmode;
usesAux = usesAux
}
(codeList, inst)
opmode ==
inst.A = ((value, ), )
opmode ==
inst.A = ((value, ), )
inst.B = ((value, ), )
opmode ==
inst.A = ((value, ), )
inst.B = ((value, ), )
inst.C = ((value, ), )
opmode ==
inst.A = ((value, ), )
temp = ((value, ), )
temp <
inst.D = temp
inst.D = temp -
opmode ==
temp = ((value, ), )
temp <
inst.E = temp
inst.E = temp -
;
usesAux
aux = ()
inst.aux = aux;
(codeList, {
value = aux,
opname =
})
;
usesAux
;
(inst, k)
kmode = inst.kmode;
kmode ==
inst.K = k[inst.aux + ]
kmode ==
inst.K = k[inst.C + ]
kmode ==
inst.K = k[inst.D + ]
kmode ==
extend = inst.aux;
count = (extend, )
id0 = ((extend, ), )
inst.K0 = k[id0 + ]
inst.KC = count;
count ==
id1 = ((extend, ), )
inst.K1 = k[id1 + ]
count ==
id1 = ((extend, ), )
id2 = ((extend, ), )
inst.K1 = k[id1 + ]
inst.K2 = k[id2 + ]
;
luau_settings.useImportConstants
inst.K = (luau_settings.staticEnvironment, count, inst.K0, inst.K1, inst.K2)
kmode ==
inst.K = (inst.aux, , ) == ;
inst.KN = (inst.aux, , ) ==
kmode ==
inst.K = k[(inst.aux, , ) + ]
inst.KN = (inst.aux, , ) ==
kmode ==
inst.K = k[inst.B + ]
kmode ==
inst.K = (inst.aux, )
;
(bytecodeid)
maxstacksize = ()
numparams = ()
nups = ()
isvararg = () ~= ;
luauVersion >=
()
typesize = ()
cursor = cursor + typesize
;
sizecode = ()
codelist = (sizecode)
skipnext = ;
i = , sizecode
skipnext
skipnext = ;
;
skipnext = (codelist)
;
debugcodelist = (sizecode)
i = , sizecode
debugcodelist[i] = codelist[i].opcode
;
sizek = ()
klist = (sizek)
i = , sizek
kt = ()
k;
kt ==
k =
kt ==
k = () ~=
kt ==
k = ()
kt ==
k = stringList[()]
kt ==
k = ()
kt ==
dataLength = ()
k = (dataLength)
i = , dataLength
k[i] = ()
kt ==
k = ()
kt ==
x, y, z, w = (), (), (), ()
luau_settings.vectorSize ==
k = luau_settings.(x, y, z, w)
k = luau_settings.(x, y, z)
;
klist[i] = k
;
i = , sizecode
(codelist[i], klist)
;
sizep = ()
protolist = (sizep)
i = , sizep
protolist[i] = () +
;
linedefined = ()
debugnameindex = ()
debugname;
debugnameindex ~=
debugname = stringList[debugnameindex]
debugname =
;
lineinfoenabled = () ~= ;
instructionlineinfo = ;
lineinfoenabled
linegaplog2 = ()
intervals = ((sizecode - ), linegaplog2) + ;
lineinfo = (sizecode)
abslineinfo = (intervals)
lastoffset = ;
j = , sizecode
lastoffset = lastoffset + ()
lineinfo[j] = lastoffset
;
lastline = ;
j = , intervals
lastline = lastline + ()
abslineinfo[j] = lastline % ( ^ )
;
instructionlineinfo = (sizecode)
i = , sizecode
(instructionlineinfo, abslineinfo[(i - , linegaplog2) + ] + lineinfo[i])
;
() ~=
sizel = ()
i = , sizel
()
()
()
()
;
sizeupvalues = ()
i = , sizeupvalues
()
;
{
maxstacksize = maxstacksize;
numparams = numparams;
nups = nups;
isvararg = isvararg;
linedefined = linedefined;
debugname = debugname;
sizecode = sizecode;
code = codelist;
debugcode = debugcodelist;
sizek = sizek;
k = klist;
sizep = sizep;
protos = protolist;
lineinfoenabled = lineinfoenabled;
instructionlineinfo = instructionlineinfo;
bytecodeid = bytecodeid
}
;
typesVersion ==
index = ()
index ~=
()
index = ()
;
protoCount = ()
protoList = (protoCount)
i = , protoCount
protoList[i] = (i - )
;
mainProto = protoList[() + ]
(cursor == (stream), )
mainProto.debugname =
{
stringList = stringList;
protoList = protoList;
mainProto = mainProto;
typesVersion = typesVersion
}
;
(module, env, luau_settings)
luau_settings ==
luau_settings = ()
(luau_settings)
;
(module) ~=
module = (module, luau_settings)
;
protolist = module.protoList;
mainProto = module.mainProto;
breakHook = luau_settings.callHooks.breakHook;
stepHook = luau_settings.callHooks.stepHook;
interruptHook = luau_settings.callHooks.interruptHook;
panicHook = luau_settings.callHooks.panicHook;
alive = ;
()
alive =
;
(module, proto, upvals)
(...)
debugging, stack, protos, code, varargs;
luau_settings.errorHandling
debugging, stack, protos, code, varargs = ...
passed = (...)
stack = (proto.maxstacksize)
varargs = {
len = ,
list = {}
}
(passed, , proto.numparams, , stack)
proto.numparams < passed.n
start = proto.numparams + ;
len = passed.n - proto.numparams;
varargs.len = len;
(passed, start, start + len - , , varargs.list)
;
passed = ;
debugging = {
pc = ,
name =
}
protos = proto.protos;
code = proto.code
;
top, pc, open_upvalues, generalized_iterators = -, , ({}, {
__mode =
}), ({}, {
__mode =
})
constants = proto.k;
debugopcodes = proto.debugcode;
extensions = luau_settings.extensions;
handlingBreak = ;
inst, op;
alive
handlingBreak
inst = code[pc]
op = inst.opcode
;
handlingBreak = ;
debugging.pc = pc;
debugging.top = top;
debugging.name = inst.opname;
pc = pc + ;
stepHook
(stack, debugging, proto, module, upvals)
;
op ==
op ==
breakHook
results = .((stack, debugging, proto, module, upvals))
results[]
(results, , #results)
;
pc = pc - ;
op = debugopcodes[pc]
handlingBreak =
op ==
stack[inst.A] =
op ==
stack[inst.A] = inst.B == ;
pc = pc + inst.C
op ==
stack[inst.A] = inst.D
op ==
stack[inst.A] = inst.K
op ==
stack[inst.A] = stack[inst.B]
op ==
kv = inst.K;
stack[inst.A] = extensions[kv] env[kv]
pc = pc +
op ==
kv = inst.K;
env[kv] = stack[inst.A]
pc = pc +
op ==
uv = upvals[inst.B + ]
stack[inst.A] = uv.store[uv.index]
op ==
uv = upvals[inst.B + ]
uv.store[uv.index] = stack[inst.A]
op ==
i, uv open_upvalues
uv.index >= inst.A
uv.value = uv.store[uv.index]
uv.store = uv;
uv.index =
open_upvalues[i] =
op ==
luau_settings.useImportConstants
stack[inst.A] = inst.K
count = inst.KC;
k0 = inst.K0;
import = extensions[k0] env[k0]
count ==
stack[inst.A] = import
count ==
stack[inst.A] = import[inst.K1]
count ==
stack[inst.A] = import[inst.K1][inst.K2]
;
pc = pc +
op ==
stack[inst.A] = stack[inst.B][stack[inst.C]]
op ==
stack[inst.B][stack[inst.C]] = stack[inst.A]
op ==
index = inst.K;
stack[inst.A] = stack[inst.B][index]
pc = pc +
op ==
index = inst.K;
stack[inst.B][index] = stack[inst.A]
pc = pc +
op ==
stack[inst.A] = stack[inst.B][inst.C + ]
op ==
stack[inst.B][inst.C + ] = stack[inst.A]
op ==
newPrototype = protolist[protos[inst.D + ]]
nups = newPrototype.nups;
upvalues = (nups)
stack[inst.A] = (module, newPrototype, upvalues)
i = , nups
pseudo = code[pc]
pc = pc + ;
= pseudo.A;
==
upvalue = {
value = stack[pseudo.B],
index =
}
upvalue.store = upvalue;
upvalues[i] = upvalue
==
index = pseudo.B;
prev = open_upvalues[index]
prev ==
prev = {
index = index,
store = stack
}
open_upvalues[index] = prev
;
upvalues[i] = prev
==
upvalues[i] = upvals[pseudo.B + ]
op ==
A = inst.A;
B = inst.B;
kv = inst.K;
sb = stack[B]
stack[A + ] = sb;
pc = pc + ;
useFallback = ;
useNativeHandler = luau_settings.useNativeNamecall;
useNativeHandler
nativeNamecall = luau_settings.namecallHandler;
callInst = code[pc]
callOp = callInst.opcode;
callA, callB, callC = callInst.A, callInst.B, callInst.C;
stepHook
(stack, debugging, proto, module, upvals)
;
interruptHook
(stack, debugging, proto, module, upvals)
;
params;
callB ==
params = top - callA
params = callB -
;
ret_list = ((kv, (stack, callA + , callA + params)))
ret_list[] ==
useFallback = ;
pc = pc + ;
inst = callInst;
op = callOp;
debugging.pc = pc;
debugging.name = inst.opname;
(ret_list, )
ret_num = ret_list.n - ;
callC ==
top = callA + ret_num -
ret_num = callC -
;
(ret_list, , ret_num, callA, stack)
;
useFallback
stack[A] = sb[kv]
op ==
interruptHook
(stack, debugging, proto, module, upvals)
;
A, B, C = inst.A, inst.B, inst.C;
params;
B ==
params = top - A
params = B -
;
func = stack[A]
ret_list = (((stack, A + , A + params)))
ret_num = ret_list.n;
C ==
top = A + ret_num -
ret_num = C -
;
(ret_list, , ret_num, A, stack)
op ==
interruptHook
(stack, debugging, proto, module, upvals)
;
A = inst.A;
B = inst.B;
b = B - ;
nresults;
b == LUA_MULTRET
nresults = top - A +
nresults = B -
;
(stack, A, A + nresults - )
op ==
pc = pc + inst.D
op ==
interruptHook
(stack, debugging, proto, module, upvals)
;
pc = pc + inst.D
op ==
stack[inst.A]
pc = pc + inst.D
op ==
stack[inst.A]
pc = pc + inst.D
op ==
stack[inst.A] == stack[inst.aux]
pc = pc + inst.D
pc = pc +
op ==
stack[inst.A] <= stack[inst.aux]
pc = pc + inst.D
pc = pc +
op ==
stack[inst.A] < stack[inst.aux]
pc = pc + inst.D
pc = pc +
op ==
stack[inst.A] == stack[inst.aux]
pc = pc +
pc = pc + inst.D
op ==
stack[inst.A] <= stack[inst.aux]
pc = pc +
pc = pc + inst.D
op ==
stack[inst.A] < stack[inst.aux]
pc = pc +
pc = pc + inst.D
op ==
stack[inst.A] = stack[inst.B] + stack[inst.C]
op ==
stack[inst.A] = stack[inst.B] - stack[inst.C]
op ==
stack[inst.A] = stack[inst.B] * stack[inst.C]
op ==
stack[inst.A] = stack[inst.B] / stack[inst.C]
op ==
stack[inst.A] = stack[inst.B] % stack[inst.C]
op ==
stack[inst.A] = stack[inst.B] ^ stack[inst.C]
op ==
stack[inst.A] = stack[inst.B] + inst.K
op ==
stack[inst.A] = stack[inst.B] - inst.K
op ==
stack[inst.A] = stack[inst.B] * inst.K
op ==
stack[inst.A] = stack[inst.B] / inst.K
op ==
stack[inst.A] = stack[inst.B] % inst.K
op ==
stack[inst.A] = stack[inst.B] ^ inst.K
op ==
value = stack[inst.B]
value
stack[inst.A] = stack[inst.C]
stack[inst.A] = value
op ==
value = stack[inst.B]
value
stack[inst.A] = value
stack[inst.A] = stack[inst.C]
op ==
value = stack[inst.B]
value
stack[inst.A] = inst.K
stack[inst.A] = value
op ==
value = stack[inst.B]
value
stack[inst.A] = value
stack[inst.A] = inst.K
op ==
B, C = inst.B, inst.C;
success, s = (table_concat, stack, , B, C)
success
s = stack[B]
i = B + , C
s = s .. stack[i]
;
stack[inst.A] = s
op ==
stack[inst.A] = stack[inst.B]
op ==
stack[inst.A] = -stack[inst.B]
op ==
stack[inst.A] = #stack[inst.B]
op ==
stack[inst.A] = (inst.aux)
pc = pc +
op ==
template = inst.K;
serialized = {}
_, id template
serialized[constants[id + ]] =
;
stack[inst.A] = serialized
op ==
A = inst.A;
B = inst.B;
c = inst.C - ;
c == LUA_MULTRET
c = top - B +
;
(stack, B, B + c - , inst.aux, stack[A])
pc = pc +
op ==
A = inst.A;
limit = stack[A]
(limit)
number = (limit)
number ==
()
;
stack[A] = number;
limit = number
;
step = stack[A + ]
(step)
number = (step)
number ==
()
;
stack[A + ] = number;
step = number
;
index = stack[A + ]
(index)
number = (index)
number ==
()
;
stack[A + ] = number;
index = number
;
step >
(index <= limit)
pc = pc + inst.D
(limit <= index)
pc = pc + inst.D
op ==
interruptHook
(stack, debugging, proto, module, upvals)
;
A = inst.A;
limit = stack[A]
step = stack[A + ]
index = stack[A + ] + step;
stack[A + ] = index;
step >
index <= limit
pc = pc + inst.D
limit <= index
pc = pc + inst.D
op ==
interruptHook
(stack, debugging, proto, module, upvals)
;
A = inst.A;
res = inst.K;
top = A + ;
it = stack[A]
(luau_settings.generalizedIteration == ) (it)
vals = {
(stack[A + ], stack[A + ])
}
(vals, , res, A + , stack)
stack[A + ] ~=
stack[A + ] = stack[A + ]
pc = pc + inst.D
pc = pc +
ok, vals = (generalized_iterators[inst], it, stack[A + ], stack[A + ])
ok
(vals)
;
vals == LUA_GENERALIZED_TERMINATOR
generalized_iterators[inst] = ;
pc = pc +
(vals, , res, A + , stack)
stack[A + ] = stack[A + ]
pc = pc + inst.D
op ==
(stack[inst.A])
((, (stack[inst.A])))
;
pc = pc + inst.D
op ==
pc = pc +
op ==
(stack[inst.A])
((, (stack[inst.A])))
;
pc = pc + inst.D
op ==
A = inst.A;
b = inst.B - ;
b == LUA_MULTRET
b = varargs.len;
top = A + b -
;
(varargs.list, , b, A, stack)
op ==
newPrototype = protolist[inst.K + ]
nups = newPrototype.nups;
upvalues = (nups)
stack[inst.A] = (module, newPrototype, upvalues)
i = , nups
pseudo = code[pc]
pc = pc + ;
= pseudo.A;
==
upvalue = {
value = stack[pseudo.B],
index =
}
upvalue.store = upvalue;
upvalues[i] = upvalue
==
upvalues[i] = upvals[pseudo.B + ]
op ==
op ==
kv = inst.K;
stack[inst.A] = kv;
pc = pc +
op ==
interruptHook
(stack, debugging, proto, module, upvals)
;
pc = pc + inst.E
op ==
op ==
inst.E = inst.E +
op ==
()
op ==
stack[inst.A] = inst.K - stack[inst.C]
op ==
stack[inst.A] = inst.K / stack[inst.C]
op ==
op ==
pc = pc +
op ==
pc = pc +
op ==
iterator = stack[inst.A]
luau_settings.generalizedIteration (iterator)
loopInstruction = code[pc + inst.D]
generalized_iterators[loopInstruction] ==
(...)
r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72, r73, r74, r75, r76, r77, r78, r79, r80, r81, r82, r83, r84, r85, r86, r87, r88, r89, r90, r91, r92, r93, r94, r95, r96, r97, r98, r99, r100, r101, r102, r103, r104, r105, r106, r107, r108, r109, r110, r111, r112, r113, r114, r115, r116, r117, r118, r119, r120, r121, r122, r123, r124, r125, r126, r127, r128, r129, r130, r131, r132, r133, r134, r135, r136, r137, r138, r139, r140, r141, r142, r143, r144, r145, r146, r147, r148, r149, r150, r151, r152, r153, r154, r155, r156, r157, r158, r159, r160, r161, r162, r163, r164, r165, r166, r167, r168, r169, r170, r171, r172, r173, r174, r175, r176, r177, r178, r179, r180, r181, r182, r183, r184, r185, r186, r187, r188, r189, r190, r191, r192, r193, r194, r195, r196, r197, r198, r199, r200 ...
({r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,r32,r33,r34,r35,r36,r37,r38,r39,r40,r41,r42,r43,r44,r45,r46,r47,r48,r49,r50,r51,r52,r53,r54,r55,r56,r57,r58,r59,r60,r61,r62,r63,r64,r65,r66,r67,r68,r69,r70,r71,r72,r73,r74,r75,r76,r77,r78,r79,r80,r81,r82,r83,r84,r85,r86,r87,r88,r89,r90,r91,r92,r93,r94,r95,r96,r97,r98,r99,r100,r101,r102,r103,r104,r105,r106,r107,r108,r109,r110,r111,r112,r113,r114,r115,r116,r117,r118,r119,r120,r121,r122,r123,r124,r125,r126,r127,r128,r129,r130,r131,r132,r133,r134,r135,r136,r137,r138,r139,r140,r141,r142,r143,r144,r145,r146,r147,r148,r149,r150,r151,r152,r153,r154,r155,r156,r157,r158,r159,r160,r161,r162,r163,r164,r165,r166,r167,r168,r169,r170,r171,r172,r173,r174,r175,r176,r177,r178,r179,r180,r181,r182,r183,r184,r185,r186,r187,r188,r189,r190,r191,r192,r193,r194,r195,r196,r197,r198,r199,r200})
;
(LUA_GENERALIZED_TERMINATOR)
;
generalized_iterators[loopInstruction] = (gen_iterator)
;
pc = pc + inst.D
op ==
kn = inst.KN;
(stack[inst.A] == ) ~= kn
pc = pc + inst.D
pc = pc +
op ==
kv = inst.K;
kn = inst.KN;
ra = stack[inst.A]
((ra) (ra == kv)) ~= kn
pc = pc + inst.D
pc = pc +
op ==
kv = inst.K;
kn = inst.KN;
ra = stack[inst.A]
(ra == kv) ~= kn
pc = pc + inst.D
pc = pc +
op ==
kv = inst.K;
kn = inst.KN;
ra = stack[inst.A]
(ra == kv) ~= kn
pc = pc + inst.D
pc = pc +
op ==
stack[inst.A] = .(stack[inst.B] / stack[inst.C])
op ==
stack[inst.A] = .(stack[inst.B] / inst.K)
( .. inst.opname .. .. op)
;
i, uv open_upvalues
uv.value = uv.store[uv.index]
uv.store = uv;
uv.index =
open_upvalues[i] =
;
i, iter generalized_iterators
(iter)
generalized_iterators[i] =
;
;
(...)
passed = (...)
stack = (proto.maxstacksize)
varargs = {
len = ,
list = {}
}
(passed, , proto.numparams, , stack)
proto.numparams < passed.n
start = proto.numparams + ;
len = passed.n - proto.numparams;
varargs.len = len;
(passed, start, start + len - , , varargs.list)
;
passed = ;
debugging = {
pc = ,
name =
}
result;
luau_settings.errorHandling
result = ((luau_execute, debugging, stack, proto.protos, proto.code, varargs))
result = (, (debugging, stack, proto.protos, proto.code, varargs))
;
result[]
(result, , result.n)
message = result[]
panicHook
(message, stack, debugging, proto, module, upvals)
;
(message) ==
luau_settings.allowProxyErrors
(message)
message = (message)
;
proto.lineinfoenabled
((, proto.debugname, proto.instructionlineinfo[debugging.pc], debugging.pc, debugging.name, message), )
((, proto.debugname, debugging.pc, debugging.name, message), )
;
luau_settings.errorHandling
wrapped
luau_execute
;
(module, mainProto), luau_close
;
(data)
b =
output = {}
map = {}
i = , #b
map[b:(i, i)] = i -
;
map[] = ;
i = ;
len = #data;
i <= len
c1 = map[data:(i, i)]
c2 = map[data:(i + , i + )]
c3 = map[data:(i + , i + )]
c4 = map[data:(i + , i + )]
c1 == c2 ==
;
b1 = bit32.(bit32.(c1, ), bit32.(c2, ))
output[#output + ] = .(b1)
data:(i + , i + ) ~=
b2 = bit32.(bit32.(bit32.(c2, ), ), bit32.(c3, ))
output[#output + ] = .(b2)
;
data:(i + , i + ) ~=
b3 = bit32.(bit32.(bit32.(c3, ), ), c4)
output[#output + ] = .(b3)
;
i = i +
;
.(output)
;
LZW_CODE_SIZE = ;
LZW_MAX_CODE = ( ^ LZW_CODE_SIZE) - ;
LZW_CLEAR_CODE = ;
LZW_EOF_CODE = ;
(data)
reader = {}
byteIndex = ;
bitPos = ;
len = #data;
reader.(bits)
code = ;
i = , bits -
byteIndex > len
;
byte = data:(byteIndex)
bit = bit32.(byte, bitPos)
bit ==
code = bit32.(code, bit32.(, i))
;
bitPos = bitPos + ;
bitPos ==
byteIndex = byteIndex + ;
bitPos =
;
code
;
reader
;
(input)
dict = {}
dictSize = ;
i = ,
dict[i] = .(i)
;
reader = (input)
result = {}
code = reader.(LZW_CODE_SIZE)
code == code ~= LZW_CLEAR_CODE
()
;
oldCode = reader.(LZW_CODE_SIZE)
oldCode == oldCode == LZW_EOF_CODE
;
result[#result + ] = dict[oldCode]
oldString = dict[oldCode]
newCode = reader.(LZW_CODE_SIZE)
newCode == newCode == LZW_EOF_CODE
;
newCode == LZW_CLEAR_CODE
dict = {}
dictSize = ;
i = ,
dict[i] = .(i)
;
oldCode = reader.(LZW_CODE_SIZE)
oldCode == oldCode == LZW_EOF_CODE
;
oldString = dict[oldCode]
result[#result + ] = oldString;
;
newString;
dict[newCode]
newString = dict[newCode]
newCode == dictSize
newString = oldString .. oldString:(, )
( .. (newCode) .. )
;
result[#result + ] = newString;
dictSize <= LZW_MAX_CODE
dict[dictSize] = oldString .. newString:(, )
dictSize = dictSize +
;
oldCode = newCode;
oldString = newString
;
.(result)
;
(str)
(str) ~=
()
;
#str ==
;
fromB64 = (str)
(fromB64)
;
((), ())()Features
- !!YOU NEED TO LAUNCH WAIT A SEC
- EXECUTE
- WAIT A SEC
- RETURN
- inf money
- infinite money