LuaTools.lua

--[[

	ABJ4403's LuaTools
	(C) 2022-2024 ABJ4403

	WARNING: Sharing this script in any encrypted form is violating GPL v3 license,
	and restricts users freedom of changing the hard-coded configuration.
	Any violations should be reported to the project's issues section
	and will result in DMCA Takedown Notice.

]]
--— Configuration ————————————————--
local gg,io,os = gg,io,os -- precache the usual call function (faster function call)
-- Fake-semi-global variable just to make VirtGG perform better (anti hook global/local variable detection)
local _g = {
	tmp = {},
	randStr = function(len,byteFrom,byteTo)
		local len=len or 8
		local byteFrom=byteFrom or 128
		local byteTo=byteTo or 255
		local e=""
		for i=1,len do
			e=e..string.char(math.random(byteFrom,byteTo))
		end
		return e
	end,
	--XOR encryption
	xdenc_XOR = function(iv,key)local iv_,key_,i,stringChar={iv:byte(0,-1)},{key:byte(0,-1)},0,string.char local r=iv:gsub(".",function()i=i+1 return stringChar(iv_[i]~key_[(i%#key_)+1])end)return r end,
	dec_wrap_XOR = function(key)return'(iv)local iv,key,stringChar={iv:byte(0,-1)},{([==['..key..']==]):byte(0,-1)},string.char for i=1,#iv do iv[i]=stringChar(iv[i]~key[(i%#key)+1]) end return table.concat(iv)'end,
	cfg = {
		-- Allow user freedom of changing whatever they want
		-- Please DO NOT encrypt this script, because we like to change configuration like below
		-- if you encrypt this script, then you can't customize stuff here.
		-- you will need a code editor (preferably the one that has syntax-highlighting & code-folding, like Acode), and Lua knowledge for customizing these stuff below...
		VERSION = "2.9", -- plz ignore this :)
		scriptPath = gg.getFile():gsub('.lua$',''), -- strip the .lua,
	--fileChoice = '/sdcard/Notes/test', -- dummy, replaced whenever any file is selected within the GUI
		debugMode = true,
		obfOpts = {
			minGGVer = gg.VERSION, -- GG version required
			minGGBuildVer = gg.BUILD, -- minimal GG build version required
			allowNewGGBuildVer = true, -- whether to allow newer GG version or not (uses gg.BUILD variable only)
			ggPkg = "", -- what only gg package script will run
			appPkg = "", -- what only target package script will run
			scriptExpiry = "20301111", -- YYYYMMDD order
			scriptPW = "1234", -- script password
			stripAnnotations = true,
			savePW = true, -- when enabled, the hashed password (not the actual pw) will be exported to a file with '.lt.cfg' extension
			encryptStrings = false,
			encryptTables = true,
			text = {
				failAppPkgInvalid = "[PkgScanner] This script is only allowed to run on %s, and the target app package name is %s",
				failDatePassed    = "[GGRestrict] This script is expired at %s.",
				failDeniedPkgs    = "[PkgScanner] Denied packages detected: %s",
				failGGPkgInvalid  = "[PkgScanner] This script is only allowed to run on %s, and your GG package name is %s",
				failGGVerBelow    = "[PkgScanner] This script is only allowed to run on %s %s (build %s), and you're running on version %s (build %s)",
				failHookDetected  = "[VariableTracer] Hook detected! Please run the script in a normal environment.",
				failLogDetected   = "[DumpDetector] Logging detected! this may be caused by slow device, if you didn't expect this, please contact the script author.",
				failInvalidPW     = "[Auth] Invalid Password!",
				failInvalidPWFile = "[Auth] Invalid Password hash stored in configuration!",
				failRenamed       = "[FileWatcher] Renaming detected! sorry but you need to rename the script back to: %s your script name is: %s",
				promoteYourself   = "\tFollow me!\n\tGitHub: https://github.com/ABJ4403\n\tTelegram: https://t.me/ABJ4403_Group\n\tYouTube: https://youtube.com/@AyamGGoreng",
				inputPass         = "[Auth] Input Password:",
				warnPeeking       = "[NoPeek] Caught peeking values",
			}
		},
		lasmPatches = {
			-- Put your patches here (if you add/remove entries in here, you may want to modify `wrapper_lasmPatches()`)
			-- Important: Lua doesn't use RegEx: https://lua.org/manual/5.1/manual.html#5.4.1
			-- Also, ^$()%.[]*+-? is magic char, escape those using % instead of \
			selfDecrypt = {
			-- For self-decrypt
			-- Removed for now cuz its too big
			},
			RemoveGarbage = {
			--All this was original by @ABJ4403
				{'[^\n]*; garbage\n',''},
			--{'[^\n]*; unused\n',''}, -- disabled cuz removing RETURN after TAILCALL, and this f'ed unluac
				{'\nRETURN (v%d-%.%.v%d-)\nRETURN  ; unused\n','\nRETURN %1\n'},
			--{'\nTAILCALL (.-)\nRETURN .- ; unused\n','\nTAILCALL %1\n'}, -- disabled cuz removing RETURN after TAILCALL, and this f'ed unluac
				{'[^\n]*; variable v%d- out of stack %(%.maxstacksize = %d- for this func%)\n',''},
				{'JMP :goto_%d-  ; %-0 ↑\n',''},
				{'JMP :goto_%d-  ; %+0 ↓\n',''},
				{'OP%[%d%d%] 0x[0-9a-f]-\n',''},
				{'GETTABLE v%d- v%d- nil\n',''}, -- table[nil]. in Lua you can't set a table with nil as key
				{'SETTABLE v%d- nil .-\n',''}, -- same as above
			--{'\n.- CONST%[%d-%]',''}, -- untested

			--remove null loop
				-- while true do end/infinite loop
				{':goto_(%d-)\nJMP :goto_%1\n',''},
				{'FORLOOP v%d- GOTO%[%-%d-%]  ; %-%d- ↑\n; %.end local v%d- "%(for index%)"\n; %.end local v%d- "%(for limit%)"\n; %.end local v%d- "%(for step%)"\n; %.end local v%d- "%(for iterator%)"',''},
				{'FORLOOP v%d- GOTO%[%d-%]  ; %+%d- ↓\n; %.end local v%d- "%(for index%)"\n; %.end local v%d- "%(for limit%)"\n; %.end local v%d- "%(for step%)"\n; %.end local v%d- "%(for iterator%)"',''},
				{'LOADK v%d- %d-\nLOADK v%d- %d-\nLOADK v%d- %d-\n; %.local v%d- "%(for index%)"\n; %.local v%d- "%(for limit%)"\n; %.local v%d- "%(for step%)"\n; %.local v%d- "%(for iterator%)"\nFORPREP v%d- :goto_%d-  ; %+0 ↓\n:goto_%d-\nFORLOOP v%d- :goto_%d-  ; %-1 ↑\n; %.end local v%d- "%(for index%)"\n; %.end local v%d- "%(for limit%)"\n; %.end local v%d- "%(for step%)"\n; %.end local v%d- "%(for iterator%)"',''},

			--anti-unluac (BOR,BNOT,BAND,BXOR is OP41,OP42,OP43,OP44
			--if lua version is 5.2, which makes unluac confused)
				{'BAND v%d- v%d- v%d-\n',''},
			--{'BOR v(%d-) v(%d-) v(%d-)\n','ADD v%1 v%2 v%3'}, -- in cases like gg.setRanges(gg.REGION_* | gg.REGION_*)
				{'BNOT v%d- v%d-\n',''},
			--{'BXOR v%d- v%d- v%d-\n',''},
				{'SHL v%d- v%d- v%d-\n',''},
				{'SHR v%d- v%d- v%d-\n',''},

			--malformed arithmetic that is if executed, crashed the script
				{'BAND v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'BAND v'..a..' '..b..' '..c..'\n'end}, -- a & b
				{'BXOR v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'BXOR v'..a..' '..b..' '..c..'\n'end}, -- a ~ b
				{'BOR v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'BOR v'..a..' '..b..' '..c..'\n'end}, -- a | b
				{'ADD v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'ADD v'..a..' '..b..' '..c..'\n'end}, -- a + b
				{'SUB v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'SUB v'..a..' '..b..' '..c..'\n'end}, -- a - b
				{'MUL v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'MUL v'..a..' '..b..' '..c..'\n'end}, -- a * b
				{'DIV v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'DIV v'..a..' '..b..' '..c..'\n'end}, -- a / b
				{'IDIV v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'IDIV v'..a..' '..b..' '..c..'\n'end}, -- a // b
				{'MOD v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'MOD v'..a..' '..b..' '..c..'\n'end}, -- a % b
				{'POW v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'POW v'..a..' '..b..' '..c..'\n'end}, -- a ^ b
				{'SHR v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'SHR v'..a..' '..b..' '..c..'\n'end}, -- a >> b
				{'SHL v(%d-) (.-) (.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'SHL v'..a..' '..b..' '..c..'\n'end}, -- a << b
				{'CONCAT v(%d-) (.-)%.%.(.-)\n',function(a,b,c)return (b=='nil'or b=='true'or b=='false'or c=='nil'or c=='true'or c=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'CONCAT v'..a..' '..b..'..'..c..'\n'end}, -- a .. b
				{'UNM v(%d-) (.-)\n',function(a,b)return (b=='nil'or b=='true'or b=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'UNM v'..a..' '..b..'\n'end}, -- -a
				{'LEN v(%d-) (.-)\n',function(a,b)return (b=='nil'or b=='true'or b=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'LEN v'..a..' '..b..'\n'end}, -- #a
				{'BNOT v(%d-) (.-)\n',function(a,b)return (b=='nil'or b=='true'or b=='false') and'LOADNIL v'..a..'..v'..a..'\n'or'BNOT v'..a..' '..b..'\n'end}, -- ~a

			--Unnecessary calls (simplify instructions, can improve performance)
				--convert checks against same variable to `nil ==/~= nil` (0/1 basically makes true/false)

				{'LT 1 (.-) %1\n','EQ 0 nil nil\n'},
				{'LE 1 (.-) %1\n','EQ 1 nil nil\n'},
				{'LT 1 (%d-) (%d-)\n',function(b,c)return tonumber(b)<tonumber(c) and'EQ 0 nil nil\n'or'EQ 1 nil nil\n'end},
				{'LT 0 (%d-) (%d-)\n',function(b,c)return tonumber(b)>tonumber(c) and'EQ 0 nil nil\n'or'EQ 1 nil nil\n'end},
				{'LE 1 (%d-) (%d-)\n',function(b,c)return tonumber(b)<=tonumber(c) and'EQ 0 nil nil\n'or'EQ 1 nil nil\n'end},
				{'LE 0 (%d-) (%d-)\n',function(b,c)return tonumber(b)>tonumber(c) and'EQ 0 nil nil\n'or'EQ 1 nil nil\n'end},

			--unnecessary math (precalculate results for faster code)
				{'(%u-) v(%d-) (%-?[0-9%.]-) (%-?[0-9%.]-)\n',function(i,v,a,b)
					a = tonumber(a)
					b = tonumber(b)
					local c
					if     i == "BAND" then c = a & b
					elseif i == "BXOR" then c = a ~ b
					elseif i == "BOR"  then c = a | b
					elseif i == "ADD"  then c = a + b
					elseif i == "SUB"  then c = a - b
					elseif i == "MUL"  then c = a * b
					elseif i == "DIV"  then c = a / b
					elseif i == "IDIV" then c = a // b
					elseif i == "MOD"  then c = a % b
					elseif i == "POW"  then c = a ^ b
					elseif i == "SHR"  then c = a >> b
					elseif i == "SHL"  then c = a << b
					else return ("%s v%s %s %s \n"):format(i,v,v,a,b)
					end
					c = tostring(c)
					-- if the result is infinity number, return 1/0
					if c == "inf" then
						return 'DIV v'..v..' 1 0\n'
					elseif c == "-inf" then
						return 'DIV v'..v..' -1 0\n'
					end
					return 'LOADK v'..v..' '..c..'\n'
				end},

				--literally moves nothing
				{'MOVE v(%d-) v%1\n',''},
				--not not true > true (aka. useless code again)
				{'NOT v(%d-) v%1\nNOT v%1 v%1\n',''},
				{'EQ 0 (.-) (.-)\n',function(b,c)if b == c then b,c='nil','nil'end return'EQ 0 '..b..' '..c..'\n'end},
				-- specific crafted values that when
				-- assembled and disassembled will give invalid values
				-- generated with making infinite number `val = 9e999` or `LOADK v0 9E999`
				{'%u- v%d- Infinity%.0\n',''},
				{'%u- v%d- Infinity%.0 [^\n]*\n',''},
				{'%u- v%d- [^\n]* Infinity%.0\n',''},
				{'%u- v%d- -Infinity%.0\n',''},
				{'%u- v%d- -Infinity%.0 [^\n]*\n',''},
				{'%u- v%d- [^\n]* -Infinity%.0\n',''},
				{'%u- v%d- null\n',''},
				{'%u- v%d- null [^\n]*\n',''},
				{'%u- v%d- [^\n]* null\n',''},

			--function with no upval (crashes assembler)
			--{'%.source (.-\n%.maxstacksize %d-)\n','.source %1\n.upval u0 nil\n'},
			--function with no RETURN (crashes assembler and causes vm error)
			--{'%.source (.-\n)%.end',function(srcinst)return'.source '..srcinst:gsub('\nRETURN[^\n]*','')..'RETURN\n.end'end},
			},
			RemoveLasmBlock = {
		 -- Lasm block, known as Anti reassemble
		 -- Original by SwinX Tools. some numbers were modified to work...
				{
					'[^\n]*%.source ".-"\n%.linedefined %d-\n%.lastlinedefined %d-\n%.numparams (%d-)\n%.is_vararg (%d-)\n%.maxstacksize (%d-)\n',
					function(a,b,c)return'.source ""\n.linedefined 0\n.lastlinedefined 0\n.numparams '..math.min(21,tonumber(a))..'\n.is_vararg '..b..'\n.maxstacksize '..math.min(21,tonumber(c))..'\n'end
				},
			},
			RemoveCodeHider = {
				{' SET_TOP\n','\n'}, -- CALL v?..v? SET_TOP. some code fails, `print((function()return 1 end)()` returns nil instead of 1)
				{'\nSETTABLE v%d- "[^\n]*" v%d-\n','\n'}, -- looks like this removes important code dont use this (a.b = nil)
			--{'\nSETTABLE v%d- "[^\n]*" nil\n','\n'},
			--{'\nSETTABLE v%d- v%d- nil\n','\n'},
			},
			EssentialMinify = {
		 -- Some regex fails, this can help by trimming spaces/tabs, and blank lines...
				{'\n%s*(.-)%s*\n','\n%1\n'}, -- trim tabs
				{'%s*\n%s*','\n'}, -- trim tabs
				{'\n\n','\n'}, --remove blank line (doesnt do anything?)
		-- useless gg assembly annotation (untested)
			--{'\n; %.end local v%d- "%(for generator%)"\n','\n'},
			--{'\n; %.end local v%d- "%(for state%)"\n','\n'},
			--{'\n; %.end local v%d- "%(for control%)"\n','\n'},
			--{'\n; %.end local v%d- "%(for key%)"\n','\n'},
			},
			JmpObf = {
			--tries to remove some JMP obfuscations (this won't work on sophisticated obfuscations though)
			--{'\nJMP :goto_(%d-)  ; (%-%d-) ↑\n',function(l,o)l,o=tonumber(l),tonumber(o) return l > 0 or l < -999 and""or"JMP :goto_"..l.."  ; "..o.." ↑\n"end},
			--{'\nJMP :goto_(%d-)  ; (%d-) ↓\n'  ,function(l,o)l,o=tonumber(l),tonumber(o) return l < 0 or l >  999 and""or"JMP :goto_"..l.."  ; "..o.." ↓\n"end},
				{'\nJMP :goto_(%d-)  ; 0 ↓\n:goto_(%d-)',function(l,o)return a==b and''or'\nJMP :goto_'..a..'  ; 0 ↓\n:goto_'..b end},
			--{'\nJMP :goto_(%d-)  ; 0 ↓\n:goto_(%d-)',function(l,o)return a==b and'\n:goto_'..b or'\nJMP :goto_'..a..'  ; 0 ↓\n:goto_'..b end},
			},
		},
		bytecodePatches = {
			-- Put your bytecode patches here
			-- this should only used in condition where
			-- either the script is corrupted, dealing with
			-- very long strings (so long it caused vm crash)
			-- or it cant be disassembled
			bigLasm = {
			--btw 4,?,?,?,? is based on the text length (eg. YEET > 4,(1+4=5),0,0,0)
			--and most of these can also be repeat 1e4 instead of 1e3
			--I think i know how these works, this is the example: (_="aaa(repeated 10k times)") (repeated 60k times)
			--by replacing it with 4,1,0,0,0, we essentially making it LOADK v? "<empty string>"
				{'\4\17\39\0\0'..('.'):rep(1e4),'\4\1\0\0\0\0'},
				{('\0\99\53\151\82\116\66\115\67\53'):rep(1e3),'\4\1\0\0\0\0'},
				{('\0\99\53\66\82\116\66\115\67\53'):rep(1e3),'\4\1\0\0\0\0'},
				{('\0\99\145\151\23\130\37\115\67\53'):rep(1e3),'\4\1\0\0\0\0'},
				{('\0\103\53\151\82\116\70\115\67\69'):rep(1e3),'\4\1\0\0\0\0'},
			},
			antiReassembleNullStr = {
			--opposite of above, this fixes null string to empty string instead to make it assembleable again
			--could've done it with lasm but more option is good eh?
			--especially for some script that has unknown anti disassemble
				{'\4\0\0\0\0','\4\1\0\0\0\0'},
			},
			antiDisassemble1 = {
				{'\128\0\228\0\128','\128\0\31\0\128'}
			}
		}
	},
	lasmPatchesName = {
		selfDecrypt = {
			"rmAntiHook",
			"rmPasswordRegular",
			"rmPasswordExportPw",
			"rmNoRename",
			"rmSpamlog",
			"rmHbxvpnObf"
		},
		RemoveGarbage = {
			"garbage",
		--"unused",
			"unusedReturn",
		--"returnAfterTailcall",
			"outOfStack",
			"uselessJmpUp",
			"uselessJmpDown",
			"malformedOp",
			"nullTable",
			"nullTable2",
		--"nullConst",
			"nullLoop",
			"nullLoop2",
			"nullLoop3",
			"nullLoop4",
			"antiUnluacBAND",
		--"antiUnluacBOR",
			"antiUnluacBNOT",
		--"antiUnluacBXOR",
			"antiUnluacSHL",
			"antiUnluacSHR",
			"malformedBAND",
			"malformedBXOR",
			"malformedBOR",
			"malformedADD",
			"malformedSUB",
			"malformedMUL",
			"malformedDIV",
			"malformedIDIV",
			"malformedMOD",
			"malformedPOW",
			"malformedSHR",
			"malformedSHL",
			"malformedCONCAT",
			"malformedUNM",
			"malformedLEN",
			"malformedBNOT",
			"unnecessaryLTEQ",
			"unnecessaryLEEQ",
			"unnecessaryLT",
			"unnecessaryGT",
			"unnecessaryLE",
			"unnecessaryGT2",
			"unnecessaryMath",
			"unnecessaryMOVE",
			"unnecessaryNOT",
			"unnecessaryEQ",
			"NaNinfinity1",
			"NaNinfinity2",
			"NaNinfinity3",
			"NaNnull1",
			"NaNnull2",
			"NaNnull3",
			--"noUpval",
			--"noReturn"
		},
		RemoveLasmBlock = {},
		RemoveCodeHider = {},
		RemoveBlocker1 = {},
		EssentialMinify = {},
		JmpObf = {},
	},
}
_g.obfMod = {
	-- Put your obfuscation module here (sorted by name)
	A_EncryptorSignature = function()return "local _=[[\n\n——————————————————————————————————————————————————\n|\n|  🛡 Encrypted by ABJ4403's LuaTools encryptor v".._g.cfg.VERSION.." (https://github.com/ABJ4403/LuaTools)\n|  Features:\n|  + Simple, no bloat.\n|  + Free & Open-Source, Licensed under GPL v3\n|  + Modable.\n|  + Table/string encryption.\n|  + Fast (No arbitrary slowdown, great optimization, local variables, isolated obfuscator modules makes sure global variables not polluted).\n|  + Optional Hard-Password requirement (with XOR encryption, we can use the password itself as a decryption key :) TODO...\n|  + Respects both the author & end user.\n|\n|  If you trying to open this encrypted file,\n|  well uhh... GL to even decrypt this XD (if you do)\n|  Otherwise if you think this isn't safe, Don't worry, the encryptor is open-source :D\n|  Go to https://github.com/ABJ4403/LuaTools for the source code\n|\n——————————————————————————————————————————————————\n\n\n]]"end,
	B_PromoteYourself    = function()return "local _=[[\n\n".._g.cfg.obfOpts.text.promoteYourself.."\n\n]]"end,
	C_RestrictGGVer      = function()
		local matcher,verTxt = 'gg.BUILD < GGPacBuildVer'
		if not _g.cfg.obfOpts.allowNewGGBuildVer then
			verTxt = 'version'
			matcher = matcher..' or gg.VERSION ~= GGPacVer'
		else
			verTxt = 'minimum version'
		end
		if _g.cfg.obfOpts.minGGVer ~= '' and _g.cfg.obfOpts.minGGBuildVer ~= '' then
			return 'local GGPacVer,GGPacBuildVer,verTxt='.._g.cfg.enc(_g.cfg.obfOpts.minGGVer)..',tonumber('.._g.cfg.enc(_g.cfg.obfOpts.minGGBuildVer)..'),"'..verTxt..'" if '..matcher..' then print(("'.._g.cfg.obfOpts.text.failGGVerBelow..'"):format(verTxt,GGPacVer,GGPacBuildVer,gg.VERSION,gg.BUILD))os.exit()end GGPacVer,GGPacBuildVer,verTxt=nil,nil,nil'
		end
	end,
--[[D_RestrictGGPkg      = function()
	if _g.cfg.obfOpts.ggPkg ~= '' then
		return 'local GGPkgNm="'.._g.cfg.enc(_g.cfg.obfOpts.ggPkg)..'" if gg.PACKAGE ~= GGPkgNm then print(("'.._g.cfg.obfOpts.text.failGGPkgInvalid..'"):format(GGPkgNm,gg.PACKAGE))os.exit()end GGPkgNm=nil'
	end
end,]]
--[[E_RestrictAppPkg     = function()
	if _g.cfg.obfOpts.appPkg ~= '' then
		return 'local GGAppPkg="'.._g.cfg.enc(_g.cfg.obfOpts.appPkg)..'" if gg.getTargetPackage() ~= GGAppPkg then print(("'.._g.cfg.obfOpts.text.failAppPkgInvalid..'"):format(GGAppPkg,gg.getTargetPackage()))return end GGAppPkg=nil'
	end
end,]]
	F_RestrictExpire     = function()
		if _g.cfg.obfOpts.scriptExpiry ~= '' then
			return 'local GGPacDtm='.._g.cfg.enc(_g.cfg.obfOpts.scriptExpiry)..'if tonumber(os.date"%Y%m%d") > tonumber(GGPacDtm) then print(("'.._g.cfg.obfOpts.text.failDatePassed..'"):format(GGPacDtm))os.exit()end GGPacDtm=nil'
		end
	end,
	G_RestrictPkgs       = function()return 'for _,v in ipairs{"app.greyshirts.sslcapture","com.goushi.gtpcanary","com.goushi.httpcanary","com.guoshi.httpcanary.premium","com.minhui.networkcapture","com.minhui.wifianalyzer","com.packagesniffer.frtparlak","frtparlak.rootsniffer","jp.co.taosoftware.android.packetcapture","any_.body_.can_.fuck_.tencent_","com.aero.ss","com.blackduty.gc","com.coolfoolggfuckscript.tm","com.decrypt.revo6","com.dzelttwyuyyes","com.Egypt.yuosseef","com.eidymumcghpfeeeavps","com.fhshwhpvqvruvjtu","com.fireongaming.fog","com.fnmods","com.fnmods.sstool","com.foxcyber.gg","com.fqtnswrf","com.froze.konzlet7.logger","com.froze.logger","com.germany.decompile","com.ghueczxrttlhgd","com.gmsm","com.hckeam.mjgql","com.ioclxgpsiyps.ikfbqe","com.ioyysvgfsrig","com.ioyysvgfsriht","com.jtbodgpqxox","com.kaoygxapp","com.laallkxhtrnqncw","com.lua.decompil","com.lua.decompilD","com.lua.skyn","com.modeghaith.hd","com.mod.iraq","com.mrteamz.id","com.mwjvnwesbghkxbjznbwo","com.nochqxpucsbldqqx","com.nydpvsb.z.r.pkgh","com.paranoiaworks.unicus.android.sse","com.pepsi.up","com.prabalgaming.logger","com.pvt4u","com.qq.xXxLogger","com.raincitygaming.ggmod","com.redwolfgaming.ripgg","com.rjvsbmhdspmnfbame","com.roxmemek","com.s.fyojrme","com.smile.ggmods","com.smu.xdwqnkrst","com.sstool.only.sstool","com.sudsjcqvvcmgutdjeg","com.sxqa","com.tc","com.tssfjipkmrco","com.vip.paidhacksonly.mr.toxin","com.vnpqk","com.vrexqfftfsxekm.kl","com.wtkc.gg","com.xyyxgxfn","com.yy.qptvrjwerw.ghoex","com.zgb","com.zyt.sstooD","com.zyt.sstool.premium","DISABLED_catch.Art.Tool.seatch","DISABLED_catch_.me_.if_.you_.can_93","fucklog.by.decbydbc","io.neoterm","most_scripts.fucker","serdadu.log.revo6","sstool.only.com.sstool"} do if gg.isPackageInstalled(v)or gg.PACKAGE == v then print(("'.._g.cfg.obfOpts.text.failDeniedPkgs..'"):format(v))os.exit()end end'end,
	H_NoRename           = function()return 'local origFileName,fileName="'.._g.cfg.fileChoice:gsub('^/.+/','')..'.enc.lua",gg.getFile():gsub("^/.+/","")if fileName ~= origFileName then print(("'.._g.cfg.obfOpts.text.failRenamed..'"):format(origFileName,fileName))os.exit()end'end,
	I_AntiReassemble		 = function()return [[while nil do ("__LuaTools_Encryption_NullString__")(-9e999) end]]end, -- leverages gg lasm bug that unable to generate floating point number beyond certain point so it will print Infinity.0
	J_AntiSSTool				 = function()return [[while nil do local i={}if(i.i)then i.i=i.i(i)end end]]end,
	K_HBXVpnObf					 = function()return [[while nil do local obf_srE6={nil,-nil%-nil,nil,-nil}if #obf_srE6<0 then break end if obf_srE6[#obf_srE6]<0 then break end if obf_srE6[-nil]~=#obf_srE6&~obf_srE6 then obf_srE6[#obf_srE6]=obf_srE6[-nil]()end if#obf_srE6<nil then obf_srE6[#obf_srE6]=obf_srE6[-nil%nil]()end goto X1 if nil or 0 then return end::X0::obf_P3oU()::X1::function obf_P3oU()goto X2 if nil or 0 then return end::X3::obf_P3oU:_()::X2::goto X3 end goto X0 for i=1,0 do obf_srE6="obf"end for i=1,0 do if nil then obf_srE6="obf"end end if nil then if true then else goto obf_s4df end if nil then else goto obf_s4df end if nil then else goto obf_s4df end::obf_s4df::end end]]end,
	L_HookDetect				 = function()return 'local tmp if debug.getinfo(function()end).isvararg or debug.getinfo(1).istailcall or("a"):rep(2)~="aa" then print("'.._g.cfg.obfOpts.text.failHookDetected..'")os.exit()end for _,t in ipairs{gg,io,os,string,math,table,bit32,utf8,debug}do for _,f in pairs(t)do if type(f) == "function" then tmp = debug.getinfo(f)if tmp.short_src ~= "[Java]" or tmp.source ~= "=[Java]" or tmp.what ~= "Java" or ((k == debug.getinfo and tmp.namewhat ~= "field") and (k ~= debug.getinfo and tmp.namewhat ~= "")) or tmp.linedefined ~= -1 or tmp.lastlinedefined ~= -1 or tmp.currentline ~= -1 or not tmp.isvararg or tmp.istailcall or({debug.getlocal(f,2)})[2] or({debug.getupvalue(f,1)})[2] or(tostring(f):match("function: @.-:"))then print("'.._g.cfg.obfOpts.text.failHookDetected..'")os.exit()end end end end tmp=nil'end,
	M_Password           = function()
		if _g.cfg.obfOpts.scriptPW ~= '' then
		--base code only have askPw function
			local pwCode = 'askPw=function()CH=gg.prompt({"'.._g.cfg.obfOpts.text.inputPass..'"},nil,{"text"})if not CH or decode(CH[1])~=pwHash then print("'.._g.cfg.obfOpts.text.failInvalidPW..'")os.exit()end '
			if _g.cfg.obfOpts.savePW then
			--add pw file handler
				pwCode = 'local ltFile,ltOutput=gg.getFile():gsub("%.enc%.lua$",".lua"):gsub("%.lua$",".lt.cfg")'..pwCode..'io.open(ltFile,"wb"):write([====[-- ABJ4403 LuaTools Encryptor configuration\n-- Please do not edit this file just in case there is an encoding error while doing it\n-- If you really want to edit this file, use a good code editor that respects the encoding of a file\nreturn {\n--Password hash (to avoid typing the same password again)\n	password_hash = "]====]..pwHash..[====["\n}]====]):close()end ltOutput,err=loadfile(ltFile)if ltOutput and not err then ltOutput=ltOutput()if type(ltOutput)~="table"or ltOutput.password_hash~=pwHash then print("'.._g.cfg.obfOpts.text.failInvalidPWFile..'")askPw()end else askPw()end'
			else
			--just ask pw
				pwCode = pwCode..'end askPw()'
			end
			pwCode = 'local pwHash,askPw,CH,err="'.._g.cfg.xdenc(_g.cfg.obfOpts.scriptPW,_g.cfg.obfOpts.pwHash)..'" '..pwCode..' CH,askPw,pwHash,err=nil,nil,nil,nil' -- code to clear everything
			return pwCode
		end
	end,
	N_Welcome            = function()return [[gg.toast("🛡 Encrypted by ABJ4403's Lua encryptor v]].._g.cfg.VERSION..[[. Please wait...")]]end,
	O_AntiLoad           = function()return 'local load,str=load,function()local _=nil end for i=1,1e3 do load(str)end'end,
	P_NoPeek             = function()return 'gg.searchNumber=(function()local ggSearchNumber=gg.searchNumber return function(...)if gg.isVisible()then gg.setVisible(false)gg.clearList()print("'.._g.cfg.obfOpts.text.warnPeeking..'")end ggSearchNumber(...)if gg.isVisible()then gg.setVisible(false)gg.clearList()print("'.._g.cfg.obfOpts.text.warnPeeking..'")end end end)()'end,
	Q_SpamLog            = function()return 'local ot,dt,LOG,t1,t2=os.time,debug.traceback,("\0\255"):rep(1e3)t1=ot()for i=1,2e3 do dt(1,nil,LOG)end t2=ot()if t2-t1>1 then print("'.._g.cfg.obfOpts.text.failLogDetected..'")os.exit()end ot,dt,t1,t2,LOG=nil,nil,nil,nil,nil'end,
--R_BigLASM            = function()return "while nil do local "..('_="BigLASM"'):rep(6e4)..("(function()end)"):rep(200)..' _=nil '..('goto x '):rep(20)..'::x:: end'end, -- Makes assembly file really big, but unfortunately within lua vm limit (in gameguardian luaj case, its very small footprint limit, more than that, error goes yeet)
--x_cHeaphumanVerify   = function()return "local tmp=math.random(1000,9999)local CH=gg.prompt({'[cHeapumanVerification] Input this number to make sure that you\\'re human: '..tmp},nil,{'text'})if not CH or tonumber(CH[1]) ~= tmp then print('".._g.cfg.obfOpts.text.failInvalidPW.."')os.exit()end CH=nil"end,
--x_cHeaphumanVerify2  = function()return 'local t,r,c={"Apple","Banana","Island/Beach","Cat","Dog","Octopus","Bird","Penguin","Panda","Pizza","Donut","Candy","Tea","Shrimp","Car","House","Rocket","Orange","Lemon","Mushroom","Fox","Flower"},{math.random(1,22),math.random(1,22),math.random(1,22),math.random(1,3)}c=gg.alert("[cHeapumanVerification] Choose the corrent answer by pressing the buttons below.\\nWhat is the meaning of this emoji: "..({"🍎","🍌","🏝","🐈","🐕","🐙","🐦","🐧","🐼","🍕","🍩","🍬","🍵","🍤","🚗","🏘","🚀","🍊","🍋","🍄","🦊","🌻"})[r[r[4]]],t[r[1]],t[r[2]],t[r[3]])if not c or r[4]~=c then print("'.._g.cfg.obfOpts.text.failInvalidPW..'")os.exit()end'end,
}
_g.enc_wrap_XOR = function(key)
	_g.dec_wrap_XOR = _g.dec_wrap_XOR(key)
	local key = {key:byte(0,-1)}
	return function(str)
		-- don't encrypt if nothing gets passed
		str = tostring(str)
		if str == '' then return [[""]] end
		str = {str:byte(0,-1)}
		for i=1,#str do
			str[i] = string.char(str[i] ~ key[(i % #key) + 1])
		end
		-- parenthesis around decode is to prevent parsing error in cases like: `return'a'` > `returndecode(..)`
		return '(decode([==['..table.concat(str)..']==]))'
	end
end
_g.cfg.enc = _g.enc_wrap_XOR
_g.cfg.xdenc = _g.xdenc_XOR -- this means XOR Enc.. Dec..
_g.cfg.dec_wrap_factory = _g.dec_wrap_XOR
--————————————————————————————————--




--— Core functions ———————————————--
function _g.MENU()
	local CH = gg.choice({
		"🔐 1. Encrypt Lua",
		"🔑 2. Decrypt Lua",
		"🔨 3. (De)compile Lua",
		"⚫ 4. Hide compiled Lua bytecodes",
		"⛏️ 5. (Dis)assemble Lua",
		"🩹️ 6. Bytecode Patches",
		"🩹️ 7. LASM Patches",
		"💉 8. Inject code to compiled script",
		"📦 9. Containerize script",
		"__about__",
		"__exit__",
	},nil,"ABJ4403's LuaTools ".._g.cfg.VERSION)
	if CH == 1 then _g.wrapper_encryptLua()
	elseif CH == 2 then _g.wrapper_decryptLua()
	elseif CH == 3 then _g.wrapper_compileLua()
	elseif CH == 4 then _g.wrapper_hideLuaBytecode()
	elseif CH == 5 then _g.wrapper_luacAssembly()
	elseif CH == 6 then _g.wrapper_bytecodePatches()
	elseif CH == 7 then _g.wrapper_lasmPatches()
	elseif CH == 8 then _g.wrapper_injectCodeToLuac()
	elseif CH == 9 then _g.wrapper_secureRun()
	elseif CH == 10 then _g.MENU_about()
	elseif CH == 11 then
		gg.setVisible(true)
--[[print("[D] Debugging mode.")
		for i in pairs(_G) do
			print("[D] _G."..i)
		end
		for i in pairs(_ENV) do
			print("[D] _ENV."..i)
		end]]
		print("[+] Script quit safely.")
		os.exit()
	end
end
function _g.MENU_about()
	local CH = gg.choice({
		"__about__",
		"Features",
		"License",
		"Credits",
		"Encryption test",
		"__back__"
	},nil,"ABJ4403's LuaTools ".._g.cfg.VERSION)
	if CH == 1 then
		gg.alert("ABJ4403's LuaTools v".._g.cfg.VERSION..[[ © 2022-2024
Manage your Lua scripts on the go!

Why did i make this?
Just to make my life (maybe yours too) easier. and not having to install other proprietary APKs, executables, or even proprietary decryptor/encryptor that can only do one thing and its worst at the same time (eg: PG Encrypt, but no way to decrypt it in the same place, and vice versa. And also there's lots of proprietary gg Lua script out there. maybe you want to clean its garbage code so it can run faster? or run in in secure isolated environment so you can have a peace of mind knowing the files on your phone wont get removed by mallicious `os.remove` API call, or overwriting your files using `io.open/write/read` API call, or executing mallicious commands using `os.execute` API, or you dont want your data to get stolen using `gg.makeRequest` API? Maybe you also wanted to encrypt the script in the correct way because you wanted to share a script, but also realized that your script is too much risky to share to public because you dont want bad cheater (aka. the abuser) uses too much out of your script to hurt other online players? Or you need that little extra tiny SPEED by precompiling the source script and removing its hidden garbage code too.

I created this under 24 hour (on a phone btw!) as a challenge :D So it would be really appreciated if you can contribute to LuaTools GitHub repository (once the script has been open-sourced: https://github.com/ABJ4403/LuaTools) or give a star to my project on GitHub. or simply credit my work (by not removing mentions about me and others in this script :) Thank you :D
]]) _g.MENU_about()
	elseif CH == 2 then gg.alert([[Features:
+ Simple, no bloat (no blingy nonsense, no fake loading).
+ Always FOSS (Free and Open-source), Licensed under GPL v3
+ Easy to understand.
+ Basic (De?)Compile, and (Dis)Assemble available (think of it like "pocket" luac semi-unluac).
+ Encryption:
+ Obfuscation modules (no one has EVER seen this concept):
	+ Encryptor signature, and promote yourself.
	+ Restrict GG (minimal) version and package name.
	+ Restrict target application package.
	+ Expiry date.
	+ Detect Decrypt-related packages.
	+ Detect external modification.
	+ No Rename.
	+ Anti SSTool (a normal function but breaks SSTool).
	+ HBX VPN Simple Obfuscation.
	+ Hook detection.
	+ Password (with optional save hashed password).
	+ Welcome (runs after putting correct password).
	+ AntiLoad (calls load API with bogus function).
	+ NoPeek (Prevent peeking at search values).
	+ Spam Log.
	+ BigLASM (makes it less convenient to disassemble the script).
	+ "Human verification", useless but who knows someone wants it for "maximum security".
+ Interchangable encryption methods (if you know how to code Lua, and if this script is FOSS or not...).
+ Every obfuscation code is containerized, which is great for performance, security, and reduces global variable pollution.
+ Encrypted API query.
+ High performance (No fake loading, great optimization, automagic local variable use).
. (TODO) Optional Hard-Password requirement (with XOR encryption, we can use the password itself as a decryption key)
+ Not only "Free as in price", but also "Free as in Freedom". built-in hard-coded configuration allows you to tinker which encryption/obfuscation module suits your needs :D (not for now...)
+ Respects the user, both the author and the end user (not yet, because the code isnt FOSS yet).
+ Decryption:
+ Deobfuscation patches (again no one has ever seen this):
	+ Remove LASM Block.
	+ Remove Garbage.
	+ Remove Code hider? (unstable).
	+ Remove blocker.
	+ Remove nonsenses (experiment).
+ Run script in isolated environment.
	+ Powered by VirtGG and some Script Compiler 3.7.
	+ Protect your device from unwanted script modification (os.execute,os.remove,gg.makeRequest,etc).
	. Grab a password from basic pwall script (untested).
	. Run script with different version/package name.
+ Remove BigLASM (untested, because i got no real example to test against).]]) _g.MENU_about()
	elseif CH == 3 then gg.alert("License:\nLuaTools is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.\n\nLuaTools is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with LuaTools.	If not, see https://gnu.org/licenses\n\n"..[[VirtGG License (proprietary for an early development version for abuse reason):
VirtGG © 2022-2024 ABJ4403, End User License Agreement.
You are allowed to:
- Use it in a respectful manner and good intentions.
You are NOT ALLOWED TO:
- Redistribute the code.
- Reverse-engineer the code.
- Include it in your project.
All rights reserved.]]) _g.MENU_about()
	elseif CH == 4 then gg.alert("Credits:\n• ABJ4403 - Original creator.\n• Veyron, HBXVPN - Obfuscation codes.\n• Enyby - For some portion of Script Compiler 3.7 source codes (specifically the dump input field).\n• SwinXTools - for Remove LASM Block deobfuscation codes.\n• Daddyaaaaaaa - for Remove blocker 1 deobfuscation codes.\n• LuaGGEG, Angela, MafiaWar - for Remove BigLASM code.") _g.MENU_about()
	elseif CH == 5 then gg.alert([=====[ ——— Encryption test ———
Texts below shouldn't look jumbled up.

Encrypted table queries test:
- gg.searchNumber(5,gg.TYPE_WORD)
- gg.getResults(9)

Anti exit detection test:
- os.exit()

String encryption test:
- 'Hello world!'
- \"Hello world!\"
- [[Test]]
- [=[Test]=]
- [==[Test]==]
- [===[Test]===]
- [====[Test]====]

Annotation test:
-- Hello World!
--[[Hello World!]]
--[==[Hello World!]==]

 ——— End of encryption test ———]=====]) _g.MENU_about()
	elseif CH == 6 then _g.MENU() end
end

function _g.wrapper_encryptLua()
	local CH = gg.prompt(
	{
		'📂 Input File (make sure the extension is .lua):', -- 1
		'🧹 Strip \45\45\91\61\61\91 annotations \93\61\61\93 (should be safe if you don\'t use inline annotation inside string)', -- ik this looks weird, but its to avoid getting wiped by encryptor XD
		'🔀️ Encrypt strings (Experimental, should be safe if you don\'t use escaped quotation mark)',
		'🔀️ Encrypt table queries (rarely quirky)',
		'🔐 ️Password', -- 5
		'🔐️ Only ask password for once',
		'🗓️ Expiry Date (in YYYYMMDD format)',
		'⚙️ GG package',
		'⚙️ Target package',
		'⚙️ GG version requirement (blank to not use)', -- 10
		'⚙️ Minimum GG build version requirement (blank to not use)',
		'⚙️ Allow newer versions (only works with build number)',
		'===== ADVANCED OPTIONS: =====\n\n\n\n\n💬️️ Promotional text (eg. Follow, Sub to YT channel), shown in Lua binary', -- 13
		'💬️️ Ask password',
		'💬️️ Wrong password', -- 15
		'💬️️ Wrong Target Package',
		'💬️️ Expired message',
		'💬️️ Denied packages',
		'💬️️ Wrong GG Version',
		'💬️️ GG Version below', -- 20
		'💬️️ Hook Detected',
		'💬️️ Illegal Modification',
		'💬️️ Log Detected',
		'💬️️ Renamed',
		'💬️️ Warn Value Peeking', --25
	},
	{
		_g.cfg.fileChoice,-- 1
		_g.cfg.obfOpts.stripAnnotations,
		_g.cfg.obfOpts.encryptStrings,
		_g.cfg.obfOpts.encryptTables,
		_g.cfg.obfOpts.scriptPW, -- 5
		_g.cfg.obfOpts.savePW,
		_g.cfg.obfOpts.scriptExpiry,
		_g.cfg.obfOpts.ggPkg,
		_g.cfg.obfOpts.appPkg,
		_g.cfg.obfOpts.minGGVer, -- 10
		_g.cfg.obfOpts.minGGBuildVer,
		_g.cfg.obfOpts.allowNewGGBuildVer,
		--
		_g.cfg.obfOpts.text.promoteYourself,
		_g.cfg.obfOpts.text.inputPass,
		_g.cfg.obfOpts.text.failInvalidPW, -- 15
		_g.cfg.obfOpts.text.failAppPkgInvalid,
		_g.cfg.obfOpts.text.failDatePassed,
		_g.cfg.obfOpts.text.failDeniedPkgs,
		_g.cfg.obfOpts.text.failGGPkgInvalid,
		_g.cfg.obfOpts.text.failGGVerBelow, -- 20
		_g.cfg.obfOpts.text.failHookDetected,
		_g.cfg.obfOpts.text.failIllegalMod,
		_g.cfg.obfOpts.text.failLogDetected,
		_g.cfg.obfOpts.text.failRenamed,
		_g.cfg.obfOpts.text.warnPeeking, -- 25
	},
	{
		'file', -- 1
		'checkbox',
		'checkbox',
		'checkbox',
		'text', -- 5
		'checkbox',
		'number',
		'text',
		'text',
		'text', -- 10
		'text',
		'checkbox',
		--
		'text',
		'text',
		'text', -- 15
		'text',
		'text',
		'text',
		'text',
		'text', -- 20
		'text',
		'text',
		'text',
		'text',
		'text', -- 25
	}
	);
	if CH and CH[1] then
		gg.toast("Encrypting, Please wait... this will take maximum of couple seconds")
		_g.cfg.fileChoice = CH[1]:gsub(".lua$",'')
		_g.cfg.obfOpts.stripAnnotations = CH[2]
		_g.cfg.obfOpts.encryptStrings = CH[3]
		_g.cfg.obfOpts.encryptTables = CH[4]
		_g.cfg.obfOpts.scriptPW = CH[5]
		_g.cfg.obfOpts.savePW = CH[6]
		_g.cfg.obfOpts.scriptExpiry = CH[7]
		_g.cfg.obfOpts.ggPkg = CH[8]
		_g.cfg.obfOpts.appPkg = CH[9]
		_g.cfg.obfOpts.minGGVer = CH[10]
		_g.cfg.obfOpts.minGGBuildVer = CH[11]
		_g.cfg.obfOpts.allowNewGGBuildVer = CH[12]
		--
		_g.cfg.obfOpts.text.promoteYourself = CH[13]
		_g.cfg.obfOpts.text.inputPass = CH[14]
		_g.cfg.obfOpts.text.failInvalidPW = CH[15]
		_g.cfg.obfOpts.text.failAppPkgInvalid = CH[16]
		_g.cfg.obfOpts.text.failDatePassed = CH[17]
		_g.cfg.obfOpts.text.failDeniedPkgs = CH[18]
		_g.cfg.obfOpts.text.failGGPkgInvalid = CH[19]
		_g.cfg.obfOpts.text.failGGVerBelow = CH[20]
		_g.cfg.obfOpts.text.failHookDetected = CH[21]
		_g.cfg.obfOpts.text.failIllegalMod = CH[22]
		_g.cfg.obfOpts.text.failLogDetected = CH[23]
		_g.cfg.obfOpts.text.failRenamed = CH[24]
		_g.cfg.obfOpts.text.warnPeeking = CH[25]
		_g.encryptLua()
		print("[✔] Finished encrypting ".._g.cfg.fileChoice.."!\n[+] Input File: ".._g.cfg.fileChoice..".lua\n[+] Output File: ".._g.cfg.fileChoice..".enc.lua")
	end
end
function _g.wrapper_decryptLua()
	local opts1 = gg.prompt({
		"Input decompiled script (make sure the file extension is .dec1.lua, IMPORTANT: code must be formatted properly!!!)",
		"Encryptor used to encrypt the script\n1. General (tries to deobfuscate some codes, eg. string.char)\n2. ABJ4403's LuaTools [1;2]",
	},{
		_g.cfg.fileChoice,
		1,
	},{
		"file",
		"number",
	})
	if opts1 then
		-- here should open 1st file and decrypt based on 2nd choice
        opts1[1] = opts1[1]:gsub(".dec1.lua$",'')
        opts1[2] = tonumber(opts1[2])
		_g.cfg.fileChoice = opts1[1]
        local opts2
        if opts1[2] == 1 then
			opts2 = gg.prompt({
				"Decryptor specific options:\n\nPasses (higher may get better result, but takes slightly longer) [1;5]",
			},{""},{
				"number",
			})
        end
		if opts2 then
			gg.toast("Decrypting, Please wait... this will take maximum of couple seconds")
			_g.DATA = _g.io_readFile(_g.cfg.fileChoice..'.dec1.lua')
			_g.decryptLua({
            	inputFile=opts1[1],
                encryptorUsed=opts1[2],
                decryptorOpts=opts2
            })
            _g.io_writeFile(_g.cfg.fileChoice..'.dec2.lua',_g.DATA)
			print("[✔] Finished decrypting ".._g.cfg.fileChoice.."!\n[+] Input File: ".._g.cfg.fileChoice..".dec1.lua\n[+] Output File: ".._g.cfg.fileChoice..".dec2.lua")
		end
	end
end
function _g.wrapper_hideLuaBytecode()
	local CH = gg.prompt(
	{
		'This function is EXPERIMENTAL! This will try to hide the actual Lua bytecode by putting it at the end of new Lua bytecode so that when recompiled, its gone\n📂 Input File (make sure the extension is .lua, and its already compiled):', -- 1
	},
	{
		_g.cfg.fileChoice,-- 1
	},
	{
		'file', -- 1
	}
	);
	if CH and CH[1] then
		gg.toast("Hiding Lua bytecodes...")
		print("[i] Hiding Lua bytecodes...")
		_g.cfg.fileChoice = CH[1]:gsub(".lua$",'')
		_g.hideLuaBytecode()
		print("[✔] Finished hiding bytecode ".._g.cfg.fileChoice.."!\n[+] Input File: ".._g.cfg.fileChoice..".lua\n[+] Output File: ".._g.cfg.fileChoice..".bytecodeHidden.lua")
		gg.toast("[✔] Encryption complete.")
	end
end
function _g.wrapper_compileLua()
	-- Ask user for file...
	local CH = gg.prompt({
		'📂 Input File (make sure the extension is .lua):',
		'Strip debugging symbol (not recommended)',
		'Preserve namespaces',
		'Decompile (TODO-LoPrio,Waiting)'
	},{_g.cfg.fileChoice,false,true,false},{'file','checkbox','checkbox','checkbox'});
	if CH and CH[1] then
		gg.toast("Compiling, Please wait... this will take maximum of couple seconds")
		CH[1] = CH[1]:gsub(".lua$",'')
		_g.cfg.fileChoice = CH[1]
		_g.compileLua(".luac",CH[2],CH[3])
		print("[✔] Finished Compiling "..CH[1].."!\n[+] Input File: "..CH[1]..".lua\n[+] Output File: "..CH[1]..".luac")
		gg.toast("Compiling complete.")
	end
end
function _g.wrapper_luacAssembly()
	-- Ask user for file...
	local CH = gg.prompt({
		'📂 Input File (make sure the extension is either .luac/.lasm):',
		'Assemble'
	},{_g.cfg.fileChoice,false},{'file','checkbox'});
	if CH and CH[1] then
		CH[1] = CH[1]:gsub("%.luac$",''):gsub("%.lasm$",'')
		if CH[2] == true then
			gg.toast("Assembling, please wait...")
			_g.cfg.fileChoice = CH[1]
			_g.assembleLua(false)
			print("[+] Finished Assembling!\n |  Input: "..CH[1]..".lasm\n |  Output: "..CH[1]..".luac")
			gg.toast("Assembling finished!")
		else
			gg.toast("Disassembling, please wait...")
			_g.cfg.fileChoice = CH[1]
			_g.disassembleLua('.luac',false)
			print("[+] Finished Disassembling!\n |  Input: "..CH[1]..".luac\n |  Output: "..CH[1]..".lasm")
			gg.toast("Disassembling finished!")
		end
	end
end
function _g.wrapper_bytecodePatches()
	local CH = gg.prompt({
		'📂 Input File (make sure the extension is .enc.lua):',
		'Remove BigLASM (long string that makes lasm big)',
		'Remove anti disassemble',
		'Fix header (BTW i recommend reassemble the script instead of fixing the header)',
	},
	{
		_g.cfg.fileChoice,
		true,
		false,
		true,
	},{
		'file',
		'checkbox',
		'checkbox',
		'checkbox',
	});
	if CH and CH[1] then
 -- Bytecode Patching
		_g.cfg.fileChoice = CH[1]:gsub("%.enc%.lua$",'')
		_g.DATA = _g.io_readFile(_g.cfg.fileChoice..".enc.lua")

		if CH[2] then gg.toast("Running selected operations... 1/?") _g.patchBytecode("bigLasm") print("[✔] bigLasm removed!")end
		if CH[3] then gg.toast("Running selected operations... 2/?") _g.patchBytecode("antiDisassemble1") print("[✔] antiDisassemble1 removed!")end

		gg.toast("Running selected operations... 3/?")
		_g.io_writeFile(
			_g.cfg.fileChoice..".bcpatch.lua",
			_g.DATA
		)
		-- uhh didnt modLuaHeader accepts .enc.lua?
		if CH[4] then gg.toast("Running selected operations... 4/?") _g.modLuaHeader('LuaFixHeader',".bcpatch.lua") print("[✔] Lua header fixed!")end
		print("\n[+] Input File: ".._g.cfg.fileChoice..".lua\n[+] Output File: ".._g.cfg.fileChoice..".bcpatch.lua")
		gg.toast("Operation completed!")
	end
end
function _g.wrapper_lasmPatches()
	local CH = gg.prompt({
		'📂 Input File (make sure the extension is .enc.lua/.lasm, will directly write to lasm if using that extension):', -- 1
		'Remove Garbage (recommended)', -- 3
		'Remove "Code Hider" (TODO: still poor translation)', -- 4
		'Remove Lasm Block (enable if you cant disassemble the script, disable if you got ArrayOutOfBound error when running the script)', -- 5
		'Unblock 1 (by Daddyaaaaaaa)', -- 6
		"Remove some JMP Obfuscations", -- 7
		'Remove ABJ4403\'s encryption to some extent', -- 8
	},{
		_g.cfg.fileChoice,
		true,false,false, -- 234
		false,false,false -- 567
	},{
		'file',
		'checkbox','checkbox','checkbox',
		'checkbox','checkbox','checkbox'
	});
	if CH and CH[1] then
		local isAsmFile = CH[1]:match('.lasm$')
		CH[1] = isAsmFile and CH[1]:gsub(".lasm$",'') or CH[1]:gsub(".enc.lua$",'')
		_g.cfg.fileChoice = CH[1]

 -- Assembly Patching
		_g.DATA = isAsmFile and _g.io_readFile(_g.cfg.fileChoice..".lasm") or _g.disassembleLua('.enc.lua',true)
		gg.toast("Running selected operations... 1/10") _g.patchAssembly("EssentialMinify")
		if _g.cfg.debugMode then _g.io_writeFile(_g.cfg.fileChoice..".dbg.lasm",_g.DATA) end
		if CH[2] then gg.toast("Running selected operations... 2/10") _g.patchAssembly("RemoveGarbage") print("[✔] Garbages removed!")end
		if CH[7] then gg.toast("Running selected operations... 3/10") _g.patchAssembly("selfDecrypt") print("[✔] Self decrypted! (some)")end
		if CH[3] then gg.toast("Running selected operations... 4/10") _g.patchAssembly("RemoveCodeHider") print("[✔] Hide codes removed!")end
		if CH[4] then gg.toast("Running selected operations... 5/10") _g.patchAssembly("RemoveLasmBlock") print("[✔] LasmBlock Removed!")end
		if CH[5] then gg.toast("Running selected operations... 6/10") _g.patchAssembly("RemoveBlocker1") print("[✔] Blockers patched!")end
		if CH[6] then gg.toast("Running selected operations... 8/10") _g.patchAssembly("JmpObf") print("[✔] Removed JMP Obfuscations!")end
	--8
		gg.toast("Running selected operations... 9/10")
		_g.io_writeFile(_g.cfg.fileChoice..".lasm",_g.DATA)
		if isAsmFile then print('[i] Lua Assembly file format detected, script will not be compiled.') else _g.assembleLua(true) end
		print("\n[+] Input File: ".._g.cfg.fileChoice..".enc.lua\n[+] Output File: ".._g.cfg.fileChoice..".luac")
		gg.toast("Operation completed!")
	end
end
function _g.wrapper_injectCodeToLuac()
	-- Warning: Unstable PoC
	-- And lots of things didnt work
	local CH = gg.prompt({
		'📂 Input Target script (make sure the extension is .lua/.lasm, and make sure to backup your script because this may overwrite the script you chosen):',
		'📂 Input Injected code (make sure the extension is .lua/.lasm):',
		'Set max stack size to 250 (fixes ArrayOutOfBound error)'
	},{
		_g.cfg.fileChoice,
		_g.cfg.fileChoice,
		false
	},{
		'file','file','checkbox',
	})
	if CH and CH[1] and CH[2] then
		-- detect assembly
		local isTargetAsmFile = CH[1]:match('.lasm$')
		local isInjectAsmFile = CH[2]:match('.lasm$')
		-- strip names and stuff
		CH[1] = isTargetAsmFile and CH[1]:gsub(".lasm$",'') or CH[1]:gsub(".lua$",'')
		CH[2] = isInjectAsmFile and CH[2]:gsub(".lasm$",'') or CH[2]:gsub(".lua$",'')
		local INJECTED_CODE = ''

		-- Disassemble
		gg.toast("Disassembling...")
		_g.cfg.fileChoice = CH[1]
		_g.DATA = isTargetAsmFile and _g.io_readFile(CH[1]..".lasm") or _g.disassembleLua('.lua',true)
		_g.cfg.fileChoice = CH[2]
		INJECTED_CODE = isInjectAsmFile and _g.io_readFile(CH[2]..".lasm") or _g.disassembleLua('.lua',true)
		_g.cfg.fileChoice = CH[1]

		-- Cleanup assembly code
		gg.toast("Cleaning assembly codes...")
		for j=1,#_g.cfg.lasmPatches.EssentialMinify do
			_g.DATA          = _g.DATA:gsub(_g.cfg.lasmPatches.EssentialMinify[j][1],_g.cfg.lasmPatches.EssentialMinify[j][2])
			INJECTED_CODE = INJECTED_CODE:gsub(_g.cfg.lasmPatches.EssentialMinify[j][1],_g.cfg.lasmPatches.EssentialMinify[j][2])
		end

		-- stuff
		local ggAssemblyHeader = {
			'; --[=========[ Lua assembler file generated by GameGuardian '..gg.VERSION..' ('..gg.BUILD..')\n',
			"; ]=========] gg.require('"..gg.VERSION.."', "..gg.BUILD..")"
		}

		-- remove comments, beginning .line, avoid variable collision
		gg.toast("Removing comments, beginning .line, avoid collision...")
		INJECTED_CODE = INJECTED_CODE:gsub(' ;.-\n','\n'):gsub(';.-\n','\n')
		INJECTED_CODE = INJECTED_CODE:gsub('\n%.line %d-\n','\n')
		INJECTED_CODE = INJECTED_CODE:gsub(':goto_',':inject_')
		INJECTED_CODE = INJECTED_CODE:gsub(' F(%d-)',' Injected%1')

		-- Split instructions and functions
		gg.toast("Splitting instruction & funcs...1")
		_g.DATA = _g.splitLuaAssembly(_g.DATA)
		gg.toast("Splitting instruction & funcs...2")
		INJECTED_CODE = _g.splitLuaAssembly(INJECTED_CODE)

		-- Fix ArrayOutOfBounds error (TODO: can we calculate the real value instead??)
		if CH[3] then
		--idea:
		--how about if we match v255 all the way to v0
		--and if one of them found, use that + 1
			_g.DATA[1] = _g.DATA[1]:gsub('\n%.maxstacksize %d-\n','\n.maxstacksize 250\n',1)
		end

		-- remove RETURN after function (if not removed, the script will just quit :/)
		gg.toast("Fixes...")
		INJECTED_CODE[2] = INJECTED_CODE[2]:gsub('\nRETURN','',1)
		-- Code optimization (only if the codes starts with `FunctionName()`)
		INJECTED_CODE[2] = INJECTED_CODE[2]:gsub(
			'\nCLOSURE v(%d-) (.-)\nSETTABUP u(%d-) (.-) v(%d-)\nGETTABUP v(%d-) u(%d-) (.-)\nCALL v(%d-)..v(%d-)\n',
			function(v1,f, u1,f1,v2, v3,u2,f2, v4,v5)
				return (f1 == f2 and u1 == u2 and (v1 == v2 and v1 == v3 and v1 == v4 and v1 == v5)) and
					('\nCLOSURE v%d %s\nCALL v%d..v%d\n'):format(v1,f,v4,v5) or
					('\nCLOSURE v%d %s\nSETTABUP u%d %s v%d\nGETTABUP v%d u%d %s\nCALL v%d..v%d\n'):format(v1,f,u1,f1,v1,v3,u2,f2,v4,v5)
			end
		)

		-- Combine the script in these orders:
		-- GG LASM Header, Source, Injected instructions, Target instructions, Target functions, Injected functions, GG LASM Header
		_g.DATA =
			ggAssemblyHeader[1]..'\n'..
			_g.DATA[1]..'\n'..
			INJECTED_CODE[2]..'\n'..
			_g.DATA[2]..'\n'..
			_g.DATA[3]..'\n'..
			INJECTED_CODE[3]..'\n'..
			ggAssemblyHeader[2]
		ggAssemblyHeader = nil
		INJECTED_CODE = nil

		-- Assemble Lua
		_g.io_writeFile(_g.cfg.fileChoice..".lasm",_g.DATA)
		if isTargetAsmFile then print('[i] Lua Assembly file format detected, script will not be compiled.') else _g.assembleLua(true) end

 -- Completed
		print("\n[+] Input File: ".._g.cfg.fileChoice..".lua\n[+] Output File: ".._g.cfg.fileChoice..".luac")
		gg.toast("Operation completed!")
	end
end
function _g.wrapper_secureRun()
	local opts = gg.prompt({
		"📂 Script:", -- 1
		"📂 Wrapper script (commonly used for other modifications):", -- 2
		"❌️ Disable mallicious functions", -- 3
		"🛡️ Run security tests (if 3rd option enabled)", -- 4
		"⚠️ Exit if security tests fail (if 3rd + 4th option enabled)", -- 5
		"📜️ Dump function calls", -- 6
		"📜️ Dump load calls", -- 7
		"📜️ Dump input strings (commonly used to extract password, leave blank to disable)", -- 8
		"🖊️ GG Version", -- 9
		"🖊️ GG Version int", -- 10
		"🖊️ GG Build", -- 11
		"🖊️ GG Package", -- 12
		"🖊️ GG Target Package", -- 13
		"📜️ Minimum size to log `load()` API (TODO)", -- 14
		"📜 Verbose log (TODO)", -- 15
		"📜 Quieten log (TODO)", -- 16
		"📜 Print log (TODO)", -- 17
		"📜 Dump log (You can use os.date formatting in here. TODO)", -- 18
	},{
		_g.cfg.fileChoice, -- 1
		nil, -- 2
		true, -- 3
		true, -- 4
		true, -- 5
		true, -- 6
		false, -- 7
		false, -- 8
		gg.VERSION, -- 9
		gg.VERSION_INT, -- 10
		gg.BUILD, -- 11
		gg.PACKAGE, -- 12
		gg.getTargetPackage(), -- 13
		400, -- 14
		false, -- 15
		false, -- 16
		true, -- 17
		_g.cfg.scriptPath..'/ScriptLog_%y.%m.%d_%H.%M.log', -- 18
	},{
		"file", -- 1
		"file", -- 2
		"checkbox", -- 3
		"checkbox", -- 4
		"checkbox", -- 5
		"checkbox", -- 6
		"checkbox", -- 7
		"checkbox", -- 8
		"text", -- 9
		"number", -- 10
		"number", -- 11
		"text", -- 12
		"text", -- 13
		"number", -- 14
		"checkbox", -- 15
		"checkbox", -- 16
		"checkbox", -- 17
		"text", -- 18
	})
	if opts and opts[1] then
		_g.secureRun({
			targetScript=opts[1],
			wrapScript=opts[2],
			disableMalFn=opts[3],
			runTests=opts[4],
			exitIfTestsFail=opts[5],
			dumpCalls=opts[6],
			dumpLoadCalls=opts[7],
			dumpInputStr=opts[8],
			ggVer=opts[9],
			ggVerInt=opts[10],
			ggVerBuild=opts[11],
			ggPkg=opts[12],
			appPkg=opts[13],
			minLogSizeLoad=opts[14],
			verboseLog=opts[15],
			quietLog=opts[16],
			printLog=opts[17],
			dumpLogTo=os.date(opts[18]),
		})
	end
end

function _g.encryptLua()
	-- Wrap the decryptor script
	print("[i] Wrapping decryptor...")
	_g.cfg.obfOpts.pwHash = _g.randStr() -- separate XOR key for password (TODO: but we need to implement another decryptor..., or change the whole decryptor)
	_g.cfg.enc = _g.cfg.enc(_g.cfg.obfOpts.pwHash) -- add key
	_g.cfg.dec_wrap = "local decode = function".._g.cfg.dec_wrap_factory(_g.cfg.obfOpts.pwHash).." end\n"

	-- Put the input file content to buffer
	gg.toast("[i] Reading file contents to buffer...")
	print("[i] Reading file contents to buffer...")
	collectgarbage()
	_g.DATA = _g.io_readFile(_g.cfg.fileChoice..'.lua')

	if _g.cfg.obfOpts.stripAnnotations then
		gg.toast("[i] Removing annotations to prevent parsing error...")
		print("[i] Removing annotations to prevent parsing error...")
		local totalReplaced,annotationPatterns,tmp = 0,{
			'%-%-%[(=*)%[.-%]%1%]', --[==[Comment]==]
			'%-%-[^\r\n]*' -- Comment
		}
		collectgarbage()
		for i=1,#annotationPatterns do
			_g.DATA,tmp = string.gsub(_g.DATA,annotationPatterns[i],'')
			totalReplaced = totalReplaced + tmp
		end
		print("[i] "..totalReplaced.." annotations/comments removed!")
	end

	print("[i] Injecting force os.exit...")
	_g.DATA = _g.DATA:gsub('os%.exit%(%)','os.exit()print("[AntiExitDetect] Anti exit detected, forcing script to crash")return(nil)()') -- force exit


	if _g.cfg.obfOpts.encryptTables then
		local totalReplaced,tmp = 0
		gg.toast("[i] Encrypting common table queries...")
		print("[i] Encrypting common table queries...")
		collectgarbage()

		--Convert `function a.b(c,d)` to `a.b = function(c,d)` first to avoid errors
		_g.DATA,tmp = _g.DATA:gsub("function%s+([%a%d%.]-)%s*%((.-)%)","%1 = function(%2)")
		print("[i] "..tmp.." functions fixed!")

		for _,v in ipairs{"gg","io","os","string","math","table","debug","bit32","utf8"} do
			print(" |  "..v)
			_g.DATA,tmp = _g.DATA:gsub(v..'%.(%a+)%s*%(',function(s)return '_G['.._g.cfg.enc(v)..']['.._g.cfg.enc(s)..'](' end) -- table.insert()
			totalReplaced = totalReplaced + tmp
			_g.DATA,tmp = _g.DATA:gsub(v..'%.(%a+)%s*%{',function(s)return '_G['.._g.cfg.enc(v)..']['.._g.cfg.enc(s)..']{' end) -- table.insert{}
			totalReplaced = totalReplaced + tmp
			_g.DATA,tmp = _g.DATA:gsub(v..'%.(%a+)%s*%"',function(s)return '_G['.._g.cfg.enc(v)..']['.._g.cfg.enc(s)..']"' end) -- table.insert""
			totalReplaced = totalReplaced + tmp
			_g.DATA,tmp = _g.DATA:gsub(v.."%.(%a+)%s*%'",function(s)return '_G['.._g.cfg.enc(v)..']['.._g.cfg.enc(s)..']\''end) -- table.insert''
			totalReplaced = totalReplaced + tmp
		end

		print("[i] "..totalReplaced.." common table queries encrypted!")
		totalReplaced,tmp = nil,nil
	end

	if _g.cfg.obfOpts.encryptStrings then
		gg.toast("[i] Encrypting strings...")
		print("[i] Encrypting strings...")
		print(" |  Developer note: String encryption is experimental! you might encounter errors when compiling the script.")
		collectgarbage()
		local totalReplaced,all_string,tmp = 0,{
		--new
			"%'(.-)%'", -- 'String'
			'%"(.-)%"', -- "String"
		--"%[(=*)%[(.-)%]%1%]" -- [[String]], [==[String]==], EXPERIMENTAL, %? returns nothing
		--'%[=*%[(.-)%]=*%]', -- [[String]], [==[String]==], [=[String]====] (uhh its quirky, not what we wanted :/)
			'%[===%[(.-)%]===%]',
			'%[==%[(.-)%]==%]',
			'%[=%[(.-)%]=%]',
			'%[%[(.-)%]%]',
		}
		for i=1,#all_string do
			_g.DATA,tmp = string.gsub(_g.DATA,all_string[i],_g.cfg.enc) -- untested
			totalReplaced = totalReplaced + tmp
		end
		print("[i] "..totalReplaced.." strings encrypted!")
		totalReplaced,all_string,tmp = nil,nil,nil
	end

	print("[i] Wrapping main function to mainPayload()...")
	collectgarbage()
	_g.DATA = "local mainPayload = function()local gg,os,io=gg,os,io ".._g.DATA.."\nend mainPayload()"

	gg.toast("[i] Configuring Obfuscations...")
	print("[i] Configuring Obfuscations...")
	collectgarbage()
	for i,v in next,_g.obfMod do
		if type(v) == 'function' then _g.obfMod[i] = v() end
	end

	-- Append obfuscation module before script starts, and put decryptor at very beginning (applied in reverse order)
	gg.toast("[i] Applying Obfuscations...")
	print("[i] Applying Obfuscations... (sorted Z-A/bottom-top)")
	collectgarbage()
	for i,v in _g.pairs_sorted(_g.obfMod) do
		print(" |  "..(i):gsub('^[A-Z]_',''))
		_g.DATA = 'do '..v..' end\n'.._g.DATA
	end
	print('———')
	_g.DATA = _g.cfg.dec_wrap.._g.DATA

	-- Post-encrypt, include Anti-reassemble
	-- apparently Lua bytecode ignores whatever extra garbage placed at the end
	-- we can use this to our advantage, by putting our own custom bytes at the end
	-- and check if its the same or not, we can even put our own custom message if we want
--gg.toast("[i] Applying anti reassemble...")
--print("[i] Applying anti reassemble...")
--local integrityCheckByte = _g.randStr(8)
--_g.DATA = 'local f = io.open(gg.getFile(),"rb") f:seek("set",f:seek("end") - 10) local integrityCheck1,integrityCheck2 = f:read(10),"['..integrityCheckByte..']" f:close() if integrityCheck1 ~= integrityCheck2 then print(("[IntegrityChecker] Integrity check failed:\\n[i] Expected: %s\\n[i] Script: %s\\n\\n[i] The script is likely reassembled, please use the original script."):format(integrityCheck2,integrityCheck1))os.exit()end f,integrityCheck1,integrityCheck2 = nil,nil,nil\n'.._g.DATA
	-- include simple anti hook code
	-- This prevents improper debug.getlocal hooks
	-- btw 1st arg in local _,_ is garbage
	gg.toast("[i] Applying anti hook...")
	print("[i] Applying anti hook...")
	_g.DATA = 'local _=function()\n'.._g.DATA.."\nend local _,_=debug.getlocal(2,1)if type(_)=='function'then _()end"

	-- Encryption done, "Compile" the file (in a hacky way lol)
	_g.cfg.enc = _g.enc_wrap_XOR -- Restore original function
	collectgarbage()
	if _g.cfg.debugMode then _g.io_writeFile(_g.cfg.fileChoice..".debug.lua",_g.DATA) end
	_g.compileLua(".enc.lua",true,false)

	-- Post-compile. Corrupt the Lua file header to prevent unluac from decompiling
	_g.modLuaHeader('LuaBreakHeader')

	-- Post-compile, bytecode modification
	-- (LuaTools will try to still comply
	-- with Lua standards even while trying to
	-- encrypt the script)
	-- bytecode modification should only
	-- be done if obfuscation modules
	-- is not possible (eg. inserting at the
	-- end of script, or too big it causes vm error)
	-- and also i always provide a way to reverse the
	-- changes done by the codes below.
	if true then
		-- load compiled code
		_g.DATA = _g.io_readFile(_g.cfg.fileChoice..".enc.lua")
		-- increase BigLASM size (with regular codes,
		-- we can only achieve limited amounts, because GG LuaJ and vm error)
		if _g.obfMod.R_BigLASM then
			local r
			_g.DATA,r = _g.DATA:gsub(
				"\4\8\0\0\0BigLASM\0", -- 4 = LOADK (i think...), 8 = length of text + 1
				"\4\17\39\0\0"..("0"):rep(1e4) --byte counts is based on number sequence after 4
			)
			print("[i] Bytecode-level BigLASM bytes replaced:",r)
		end
        -- Opposite of BigLasm, but leverages gg lasm bug where it will make "String" into null (without quotes) thus fails to assemble
		if _g.obfMod.I_AntiReassemble then
			local r
			_g.DATA,r = _g.DATA:gsub(
				"\4\35\0\0\0__LuaTools_Encryption_NullString__\0", -- 4 = LOADK (i think...), 35 = length of text + 1
				"\4\0\0\0\0" --byte counts is based on number sequence after 4
			)
			print("[i] Null string anti reassemble bytes replaced:",r)
		end
		-- (EXPERIMENTAL) Anti disassemble
		-- idk what's this actually, but i found
		-- it on an script that supposedly
		-- makes 300b lasm,
		-- but instead lasm returns empty
		-- and manually disassembling throws error
		-- from my research, i think it replaces RETURN (31) instruction to arbitrary instructions
		-- (in this case 228 which is oddly specific)
		-- aka. this corrupts Lua bytecode, well if you want anti disassemble, this is sadly the way to go :(
		if false then
			local r
			-- might just well put these arent i?
			_g.DATA,r = _g.DATA:gsub(
				"\0\99\1\255\127\12",
				"\0\255\255\255\255\255" -- 255 was originally math.random(128,255)
			)
			print("[i] \"suppposedly lasm 300b\" bytes replaced:",r)
			_g.DATA,r = _g.DATA:gsub(
				"\128\0\31\0\128",
				"\128\0\228\0\128"
			)
			print("[i] Anti disassemble bytes replaced:",r)
		end
		-- Replace with new bytecode
		_g.io_writeFile(_g.cfg.fileChoice..".enc.lua",_g.DATA)

		-- (EXPERIMENTAL) Integrity check
		-- uh oh, it works... in fact some encryptors used it
		if false then
			_g.DATA = io.open(_g.cfg.fileChoice..".enc.lua",'ab')
			-- IMPORTANT: if you want to change the integrity check position, make sure
			-- to edit the above code as well
			-- TODO: can we make this optional with module?
			local encryptorSignature = "  🛡 Encrypted by ABJ4403's LuaTools encryptor v".._g.cfg.VERSION.." (https://github.com/ABJ4403/LuaTools)\n|  Features:\n|  + Simple, no bloat.\n|  + Free & Open-Source, Licensed under GPL v3\n|  + Modable.\n|  + Table/string encryption.\n|  + Fast (No arbitrary slowdown, great optimization, local variables, isolated obfuscator modules makes sure global variables not polluted).\n|  + Optional Hard-Password requirement (with XOR encryption, we can use the password itself as a decryption key :) TODO...\n|  + Respects both the author & end user.\n|\n|  If you trying to open this encrypted file,\n|  well uhh... GL to even decrypt this XD (if you do)\n|  Otherwise if you think this isn't safe, Don't worry, the encryptor is open-source :D\n|  Go to https://github.com/ABJ4403/LuaTools for the source code"
			_g.DATA:write(("\n\n————————————————————\n|\n%s\n|\n|  Integrity check (Anti reassemble): [%s]"):format(encryptorSignature,integrityCheckByte)):close()
		end
	end

	-- Restore everything back
	_g.dec_wrap_XOR = _g.cfg.dec_wrap_factory
	_g.cfg.dec_wrap = nil
	gg.toast("[✔] Encryption complete.")
end
function _g.decryptLua(opts)
	local strCharFuncVar = "string%.char"
	local strCharTableUnpackCstFunc = "table%.unpack"
	local checkErr = function(DATA,msg)
		local err = ({load(DATA)})[2]
		msg = msg and "Syntax error ("..msg..")" or "Syntax error"
		if err then
			DATA = DATA.."\n--[[ "..msg..": "..err.." ]]"
			print("[!] Syntax error was detected when trying to decrypt:",err)
			print("[!] You will need to fix the syntax errors in the result script manually.")
		end
		return DATA
	end
	local wrapString = function(str)
		return str:match("\n") and '[['..str..']]'
			or str:match("'") and '"'..str..'"'
			or "'"..str.."'"
	end
	local parseNumber = function(arg)
		local byteArgs = {}
		for w in arg:gmatch('0x%x+') do
			table.insert(byteArgs,tonumber(w))
		end
		if #byteArgs == 0 then
			for w in arg:gmatch('%d+') do
				table.insert(byteArgs,tonumber(w))
			end
		end
		return wrapString(string.char(table.unpack(byteArgs)))
	end
	local parseStrChar = function(input)
		return input
			:gsub(strCharFuncVar.."%(([0-9a-f,x%s]-)%)",parseNumber)
			:gsub(strCharFuncVar.."%(table.unpack%(?{([0-9a-f,x%s]-)}%)?%)",parseNumber)
		--:gsub(strCharTableUnpackCstFunc.."%(?{([0-9a-f,x%s]-)}%)?",parseNumber)
		--:gsub(strCharFuncVar.."%((.-)%)",parseNumber)
	end
	string.char = (function()
		local origStringChar = string.char
		return function(...)
			local t = {...}
			for i=1,#t do
				t[i] = t[i] % 255
			end
			return origStringChar(table.unpack(t))
		end
	end)()
	local fixWhitespace = function(DATA)
		-- makes sure there is only one space before & after = sign
		DATA = DATA:gsub("[\n%s]*=[\n%s]*"," = ")

		-- 2 different variable definition should be separated in a single newline
		DATA = DATA:gsub('([%w_]+) = ([%w_]+)[\n%s]+([%w_]+) = ([%w_]+)',[[%1 = %2
	%3 = %4]])

		-- fix spaces & newlines on special syntaxes
		DATA = DATA:gsub(' =  = ',' == '):gsub(' ~ = ',' ~= '):gsub(' < = ',' <= '):gsub(' > = ',' >= ')
		DATA = DATA:gsub("{[\n%s]+}","{}")
		DATA = DATA:gsub("%([\n%s]+%)","()")
		DATA = DATA:gsub("%[[\n%s]+%]","[]")
		DATA = DATA:gsub("if[\n%s]+","if ")
		DATA = DATA:gsub("local[\n%s]+","local ")
		DATA = DATA:gsub("while[\n%s]+","while ")
		DATA = DATA:gsub("then[\n%s]+","then\n\t")
		--DATA = DATA:gsub("[\n%s]+do[\n%s]+"," do\n\t")
		DATA = DATA:gsub("[\n%s]+end","\nend")

		--  [ ... ] -> [...]
		--DATA = DATA:gsub('%[[\n%s]*(.-)[\n%s]*%]','[%1]')

		--  ( ... ) -> (...)
		--DATA = DATA:gsub('%([\n%s]*(.-)[\n%s]*%)','(%1)')

		--  fn () --> fn()
		--DATA = DATA:gsub('([%w_]+)[\n%s]*%(','%1(')

		return DATA
	end
	if opts.encryptorUsed == 1 then
		print(("[i] Using general decoder with %d passes..."):format(opts.decryptorOpts[1]))
		for i=1,opts.decryptorOpts[1] do

			-- Fix whitespaces cuz patterns will be more specific (wont tolerate extra or no space or newlines)
			_g.DATA = fixWhitespace(_g.DATA)
			-- decode string.char encoded data
			_g.DATA = parseStrChar(_g.DATA)

			-- "\69" || "\x45" --> i
			_g.DATA = _g.DATA:gsub('".-"',function(str)
				local charify = function(char)
					char = tonumber(char,16)
					-- These characters can break script
					-- if actually replaced by real character
					-- and not fixed manually:
					-- - newline (\n, \10, \x0A)
					-- - two brackets (sometimes followed by couple equal sign)
					-- - quotes, both single and double
					return (char == 10) and ('\\n') or (string.char(char))
				end
				return str
					:gsub("\\x([0-9a-fA-F]+)",charify)
					:gsub("\\(%d+)",charify)
			end)


			-- _G["os"] --> os
			for _,v in ipairs{"_G","_ENV"}do
				_g.DATA = _g.DATA:gsub(v..'%s*%["(%a+)"%]',"%1")
			end

			-- _G['os'] --> os
			for _,v in ipairs{"_G","_ENV"}do
				_g.DATA = _g.DATA:gsub(v.."%s*%['(%a+)'%]","%1")
			end

			-- abc["def"] --> abc.def
			_g.DATA = _g.DATA:gsub('([%w_]+)%["([%w_]+)"%]',"%1.%2")

			-- abc['def'] --> abc.def
			_g.DATA = _g.DATA:gsub("([%w_]+)%['([%w_]+)'%]","%1.%2")
			-- ]["def"] --> ].def
			_g.DATA = _g.DATA:gsub('%]%["([%w_]+)"%]',"].%1")
			-- ]['def'] --> ].def
			_g.DATA = _g.DATA:gsub("%]%['([%w_]+)'%]","].%1")
			-- X=a;X=a —->  X=a
			_g.DATA = _g.DATA:gsub('([%w_]+) = ([%w_]+)\n([%w_]+) = ([%w_]+)',function(k1,v1,k2,v2)
					if k1 == k2 and v1 == v2 then
					return ([[-- fix #629
		%s = %s]]):format(k1,v1)
				else
					return ([[%s = %s
		%s = %s]]):format(k1,v1,k2,v2)
				end
			end)

			-- X=abc;X=X.def --> X = abc.def
			_g.DATA = _g.DATA:gsub('([%w_]+) = ([%w_]+)\n([%w_]+) = ([%w_]+)',function(k1,v1,k2,v2)
					if k1 == k2 and k2 == v2:sub(1,#k2) then
					return ([[-- fix #748
		%s = %s%s]]):format(k1,v1,v2:sub(#k1 + 1))
				else
					return ([[%s = %s
		%s = %s]]):format(k1,v1,k2,v2)
				end
			end)
			--[==[ X=a;Y=b;X=X[Y] --> X = Y=b;X=X[Y] (untested, supposed to fix unluac output)
			_g.DATA = _g.DATA:gsub('([%w_]+) = ([%w_]+)\n([%w_]+) = ([%w_]+)\n([%w_]+) = ([%w_]+)%[([%w_]+)%]',function(k1,v1,k2,v2,k3,v3a,v3b)
					if k1 == k3 and k3 == v3a and k2 == v3b then
					return ([[-- fix #463
		%s = %s
        %s = %s[%s]]]):format(k2,v3,k3,v3a,v3b)
				else
					return ([[%s = %s
		%s = %s
        %s = %s[%s]]]):format(k1,v1,k2,v2,k3,v3a,v3b)
				end
			end)
            ]==]

			-- local a=1 local b=2 --> local a,b = 1,2
			_g.DATA = _g.DATA:gsub('local ([%w_]+) = ([%w_]+)\nlocal ([%w_]+) = ([%w_]+)',"local %1,%3 = %2,%4")

			-- while(...)do --> while ... do
			--_g.DATA = _g.DATA:gsub("while[\n%s]*%((.-)%)[\n%s]*do","while %1 do")

			-- if(...)then --> if ... then
			--_g.DATA = _g.DATA:gsub("if[\n%s]*%((.-)%)[\n%s]*then","if %1 then")

			-- ( ... ) : sub --> (...):sub
			_g.DATA = _g.DATA:gsub('%([\n%s]*(.-)[\n%s]*%)[\n%s]*:[\n%s]*','(%1):')

			-- ((...)) --> (...)
			--_g.DATA = _g.DATA:gsub('%(%((.-)%)%)','(%1)')

			-- ' ..  ' --> '..'
			_g.DATA = _g.DATA:gsub('%s*%.%.%s*',"..")

			--per line decode (eg. strings with " or ')
			_g.DATA = _g.DATA.."\n"
			local tmp = ""
			for v in _g.DATA:gmatch('(.-)\n') do
				tmp = tmp .. v
					:gsub('"(.-)":','("%1"):')     -- "abc":   --> ("abc"):
					:gsub("'(.-)':",'("%1"):')     -- 'abc':   --> ("abc"):
					:gsub("{(.-)}:",'({%1}):')     -- {...}:   --> ({...}):
					:gsub('%("(.-)"%):','("%1"):') -- ("abc"): --> ("abc"):
					:gsub("%('(.-)'%):",'("%1"):') -- ('abc'): --> ("abc"):
					:gsub("%({(.-)}%):",'({%1}):') -- ({...}): --> ({...}):
					.. "\n"
				--:gsub("%('([%w_]+)'%)",'("%1")') -- ('..') --> ("..")
			end
			_g.DATA = tmp

		end
	elseif opts.encryptorUsed == 2 then

		local dec_XOR_RandomKey=function(iv,key)local i,iv_,key_=0,{string.byte(iv,0,-1)},{string.byte(key,0,-1)} r=iv:gsub(".",function()i=i+1 return string.char(iv_[i]~key_[i])end)return r end

		-- decode("gibberish","key") -> "str"
		_g.DATA = _g.DATA:gsub('%(decode%(%[==%[(.-)%]==%],"(.-)"%)%)',function(i)return'"'.._g.cfg.enc(i)..'"'end)
		_g.DATA = _g.DATA:gsub([['gg%[decode%(%[==%[(.-)%]==%],"(.-)"%)%]%(']],function(i)return'gg.'..dec_XOR_RandomKey(i)..'('end)

	end
    _g.DATA = checkErr(_g.DATA)
end
function _g.hideLuaBytecode()
	print(" | Creating self-loader...")
--this finds last part of "\x1BLua" (i know encoded with string.char, but its to avoid confusion)
--TODO: why it only matches Lua without a backspace?
	_g.DATA = 'local f = io.open(gg.getFile(),"rb") local fileContent = f:read("*a") local startPos,endPos,curPos = 0,0,1 while true do local matchStart,matchEnd = fileContent:find(string.char(27,76,117,97),curPos) if not matchStart then break end startPos = matchStart endPos = matchEnd curPos = matchEnd + 1 end f:seek("set",startPos-1) local script,err = f:read("*a") f:close() io.open("output.lua","wb"):write(script):close() script,err = load(script) if script then script() else print("Can\'t load the code:",err) end'
	print(" |  Adding real bytecodes...")
	_g.DATA = io.open(_g.cfg.fileChoice..".bytecodeHidden.lua",'ab')
	local encryptorSignature = "  🛡 Obfuscated by ABJ4403's LuaTools bytecode hider v".._g.cfg.VERSION.." (https://github.com/ABJ4403/LuaTools)"
	_g.DATA:write("\n\n————————————————————\n|\n"..encryptorSignature.."\n|\n".._g.io_readFile(_g.cfg.fileChoice..'.lua')):close()
end
function _g.compileLua(fileExt,stripDebugSymbols,useNames)
	gg.toast("[i] Compiling...")
	print("[i] Compiling ".._g.cfg.fileChoice.."...")
	_g.DATA,tmp = load(_g.DATA or _g.io_readFile(_g.cfg.fileChoice..'.lua'))
	stripDebugSymbols = stripDebugSymbols or false
	useNames = useNames or true
	if tmp or not _g.DATA then
		gg.setVisible(true)
		gg.toast("[!] Error occured!")
		print("[!] Error occured. There's something wrong with your script or this tool configuration.\n[!] try to enable debug mode, redo again, check and run ".._g.cfg.fileChoice..".debug.lua to find out why")
		if tmp then print("[!] "..tmp.."\n==========\n")end
	end
	_g.io_writeFile(_g.cfg.fileChoice..fileExt,string.dump(_g.DATA,stripDebugSymbols,useNames)) -- 3rd arg of strDump: use_names: A boolean value that specifies whether or not to include local variable names in the dumped function. If true, the resulting string will include local variable names. If false (default), the resulting string will not include local variable names.
end
function _g.decompileLua(fileExt,stripDebugSymbols)
	print("[i] Decompiling ".._g.cfg.fileChoice.."...")
	_g.DATA = _g.DATA or _g.io_readFile(_g.cfg.fileChoice..'.lua')
	if tmp or not _g.DATA then print("[!] Error occured. There's something wrong with your script or this tool configuration.\n[!] "..tmp.."\n==========\n") end
end
function _g.assembleLua(stripDebugSymbols)
	print("[i] Assembling ".._g.cfg.fileChoice.."...")
	gg.toast('[i] Click "__yes__" if you get a popup __about__ corrupted header, __load__ script...')
	local fileBuffer,err = loadfile(_g.cfg.fileChoice..".lasm")
	if err or not fileBuffer then
		gg.toast("[!] __error__ to __load__ lua assembly, see print log for more details.")
		print(string.format"[!] __error__ to __load__ lua assembly, more information:\n\n",err)
		return
	end
	_g.io_writeFile(_g.cfg.fileChoice..".luac",string.dump(fileBuffer,stripDebugSymbols))
end
function _g.disassembleLua(fileExt,stripDebugSymbols)
	print("[i] Disassembling ".._g.cfg.fileChoice.."...")
	gg.toast('[i] Click "__yes__" if you get a popup __about__ corrupted header, __load__ script...')
	fileExt = fileExt or ".luac"
	stripDebugSymbols = stripDebugSymbols or false

	local fileBuffer,err = loadfile(_g.cfg.fileChoice..fileExt)
	if err or not fileBuffer then
		gg.toast("[!] __error__ to __load__ lua script, see print log for more details.")
		print(string.format"[!] __error__ to __load__ lua script, more information:\n\n",err)
		return
	end
--Strip the file debug symbols (with string.dump's 2nd argument)
--then do the disassemble
	local isSuccessful,err = pcall(gg.internal2,load(string.dump(fileBuffer,stripDebugSymbols)),_g.cfg.fileChoice..".lasm")
	if not isSuccessful then -- Error detection
		gg.toast("[!] __error__ to disassemble the script, see print log for more details.")
		print(string.format"[!] __error__ to disassemble the script, more details:\n\n",err)
		return
	end
	return _g.io_readFile(_g.cfg.fileChoice..".lasm")
end
function _g.modLuaHeader(headerTypes,extIn)
	_g.DATA = io.open(_g.cfg.fileChoice..(extIn or ".enc.lua"),'r+')
	_g.DATA:seek('set')
--Grab the first 4 bytes and check if the header is a valid Lua header
	local sigCur = _g.DATA:read(4)
	local sigFix
	if sigCur ~= '\27Lua' then
		print('[!] The input file is not a Lua binary script (expected file header: "1B 4C 75 61")')
	else
		if headerTypes == 'LuaBreakHeader' then
			print("[i] Corrupting the file header...")
			sigFix = 'Z\1\1\0\0\0\0\0'
		elseif headerTypes == 'LuaFixHeader' then
			sigCur = _g.DATA:read(8)
			sigFix = (sigCur:sub(3,3) == '\0') and 'R\0\0\4\4\4\8\0' or 'R\0\1\4\4\4\8\0'
			if sigCur == sigFix then
				print('[+] This Lua script doesn\'t need any header fix')
				_g.DATA:close()
				_g.DATA = nil
				return
			end
			_g.DATA:seek('set')
			_g.io_writeFile(_g.cfg.fileChoice..'.bak.lua',_g.DATA:read('*a'))
			print("[✔] Fixed Lua header!\n[+] Modified File: ".._g.cfg.fileChoice..".enc.lua\n[+] Backup File: ".._g.cfg.fileChoice..".bak.lua")
		end
		_g.DATA:seek('set',4)
		_g.DATA:write(sigFix)
	end
	_g.DATA:close()
	_g.DATA = nil
end
function _g.patchBytecode(patchName) -- make sure DATA is loaded first before running the patcher
	collectgarbage()
	local r
	local patch = _g.cfg.bytecodePatches[patchName]
	local patchType = type(patch)
	local patchLen = #patch
	local toastStr = "Applying %s patch... %d/%d"
	local toastStrR = "%s %d Applied! replaced %d"
	if patchType == 'table' then -- patchset
		for j=1,patchLen do
			gg.toast(toastStr:format(patchName,j,patchLen))
			_g.DATA,r = _g.DATA:gsub(patch[j][1],patch[j][2])
			print(toastStrR:format(patchName,j,r))
		end
	elseif patchType == 'function' then -- function (allows blackbox scripts)
		_g.DATA = patch(_g.DATA)
		print(patchName.." Applied!")
	end
end
function _g.patchAssembly(patchName) -- make sure DATA is loaded first before running the patcher
	collectgarbage()
	local r
	local patch = _g.cfg.lasmPatches[patchName]
	local patchNameStr = _g.lasmPatchesName[patchName]
	local patchType = type(patch)
	local patchLen = #patch
	local toastStr = "Applying %s patch... %d/%d"
	local toastStrN = "Applying %s patch... %d/%d (%s)"
	local toastStrR = "%s %d Applied! replaced %d"
	local toastStrRN = "%s %d (%s) Applied! replaced %d"
	if patchType == 'table' then -- patchset
		for j=1,patchLen do
			if patchNameStr[j] then
				gg.toast(toastStrN:format(patchName,j,patchLen,patchNameStr[j]))
				_g.DATA,r = _g.DATA:gsub(patch[j][1],patch[j][2])
				print(toastStrRN:format(patchName,j,patchNameStr[j],r))
			else
				gg.toast(toastStr:format(patchName,j,patchLen))
				_g.DATA,r = _g.DATA:gsub(patch[j][1],patch[j][2])
				print(toastStrR:format(patchName,j,r))
			end
		end
	elseif patchType == 'function' then -- function (allows blackbox scripts)
		_g.DATA = patch(_g.DATA)
		print(patchName.." Applied!")
	end
end
function _g.secureRun(opts)
	_g.cfg.fileChoice = opts.targetScript:gsub(".lua$",'')
	gg.toast('[i] Click "__yes__" if you get a popup __about__ corrupted header, __load__ script...')
	local ScriptResult,err = loadfile(opts.targetScript) -- load target script
	if not ScriptResult or err then -- Error detection
		gg.toast("[!] __error__ to __load__ the script, see print log for more details.")
		print(string.format"[!] __error__ to __load__ the script, more details:\n\n",err)
		return
	end
	if opts.wrapScript ~= '' then -- if wrapper script given, load it
		local ScriptWrapper,err = loadfile(opts.wrapScript) -- load wrapper script
		if not ScriptWrapper or err then -- Error detection
			gg.toast("[!] __error__ to __load__ the wrapper script, see print log for more details.")
			print(string.format"[!] __error__ to __load__ the wrapper script, more details:\n\n",err)
		end
	end

	do -- Prepare isolated container
		gg.toast("[i] Preparing isolated container...")
		print("[VirtGG] Preparing isolated container...")
		local Repl
		do -- Prepare fricked variables (contain it so it doesn't get leaked and be read by script by indexing _G)
			if not utf8 then utf8={}end
			Repl = {
				["io"]=_g.table_copy(io),
				["os"]=_g.table_copy(os),
				["gg"]=_g.table_copy(gg),
				["debug"]=_g.table_copy(debug),
				["string"]=_g.table_copy(string),
				["math"]=_g.table_copy(math),
				["bit32"]=_g.table_copy(bit32),
				["table"]=_g.table_copy(table),
				["utf8"]=_g.table_copy(utf8), -- some encrypted scripts checks this too
				["_ENV"]=_ENV,
				["assert"]=assert,
				["error"]=error,
				["load"]=load,
				["loadfile"]=loadfile,
				["dofile"]=dofile,
				["pcall"]=pcall,
				["xpcall"]=xpcall,
				["ipairs"]=ipairs,
				["pairs"]=pairs,
				["next"]=next,
				["print"]=print,
				["select"]=select,
				["tostring"]=tostring,
				["type"]=type,
			}
			local origFn = {} -- eg. [hook/orig load function] = [orig load function]
			local ContainmentFiles = {}
			local tmpVars = {}
		--TODO: if the said folder not exist, any io.open:write request will crash
		--(Lua didn't offer any ways to create a folder, but we can use gg.saveVariable, which forces it to make directories :v)
		--ContainmentFiles.pwd = _g.cfg.scriptPath.."_ContainmentDir"
			ContainmentFiles.pwd = _g.cfg.scriptPath:match("(.+)/") -- in folder where LuaTools currently reside
		--ContainmentFiles.luascript = ContainmentFiles.pwd..'/'..opts.targetScript:gsub('.+/','')
			ContainmentFiles.luascript = opts.targetScript
			ContainmentFiles.txtfile = ContainmentFiles.pwd.."/ContainedText.txt"
			ContainmentFiles.dumplogfile = opts.dumpLogTo

			opts.logFileSocket = io.open(ContainmentFiles.dumplogfile,'a')
			Repl.dump = function(...)
				local arg = {...}
				Repl.print(arg[1])
				opts.logFileSocket:write(arg[1])
			end
			if not opts.quietLog then
				Repl.print("[i] Initializing virtual GameGuardian API methods...")
				Repl.print("[i] Using contained directory for script:",ContainmentFiles.pwd)
			end
			local parseGGVarTypes = function(typ,val)
				return ({
					TYPE = {
						[1  ]="gg.TYPE_BYTE",
						[2  ]="gg.TYPE_WORD",
						[4  ]="gg.TYPE_DWORD",
						[8  ]="gg.TYPE_XOR",
						[16 ]="gg.TYPE_FLOAT",
						[32 ]="gg.TYPE_QWORD",
						[64 ]="gg.TYPE_DOUBLE",
						[127]="gg.TYPE_AUTO",
					},
					REGION = {
						[ 0x20    ]="gg.REGION_ANONYMOUS",
						[ 0x80000 ]="gg.REGION_ASHMEM",
						[ 0x20000 ]="gg.REGION_BAD",
						[ 0x4000  ]="gg.REGION_CODE_APP",
						[ 0x8000  ]="gg.REGION_CODE_SYS",
						[ 0x4     ]="gg.REGION_C_ALLOC",
						[ 0x10    ]="gg.REGION_C_BSS",
						[ 0x8     ]="gg.REGION_C_DATA",
						[ 0x1     ]="gg.REGION_C_HEAP",
						[ 0x10000 ]="gg.REGION_JAVA",
						[ 0x2     ]="gg.REGION_JAVA_HEAP",
						[-0x1FC080]="gg.REGION_OTHER",
						[ 0x40000 ]="gg.REGION_PPSSPP",
						[ 0x40    ]="gg.REGION_STACK",
						[ 0x100000]="gg.REGION_VIDEO"
					},
					SIGN = {
						[0x4000000 ]='gg.SIGN_GREATER_OR_EQUAL',
						[0x8000000 ]='gg.SIGN_LESS_OR_EQUAL',
						[0x10000000]='gg.SIGN_NOT_EQUAL',
						[0x20000000]='gg.SIGN_EQUAL',
						--[0x4000000 ]='gg.SIGN_LARGER',
						--[0x8000000 ]='gg.SIGN_SMALLER',
						--[0x10000000]='gg.SIGN_INEQUAL',
						--[0x4000000 ]='gg.SIGN_FUZZY_GREATER',
						--[0x8000000 ]='gg.SIGN_FUZZY_LESS',
						--[0x10000000]='gg.SIGN_FUZZY_NOT_EQUAL',
						--[0x20000000]='gg.SIGN_FUZZY_EQUAL'
					}
				})[Repl.tostring(typ)][tonumber(val)] or Repl.tostring(val)
			end
			local isStringValid = function(str)
				for _,c in ipairs{"\\",":","*","?","\"","<",">","|"} do
					if str:find(c) then
						return false
					end
				end
				return type(str) == "string" and
					#str ~= 0 and
					#str < 400 -- and
					--not str:find("%W")   and -- non letter/number (newlines included)
					--not str:find("^%s+") and -- beginning whitespsce
					--not str:find("%s+$")     -- trailing whitespace
			end

			-- fix bug
			gg.getFile = (function()local _=ContainmentFiles.luascript return function()return _ end end)()

			gg.ANDROID_SDK_INT = 29
			gg.BUILD = opts.ggVerBuild
			gg.CACHE_DIR = ContainmentFiles.pwd..'/cache'
			gg.EXT_CACHE_DIR = ContainmentFiles.pwd..'/extCache'
			gg.EXT_FILES_DIR = ContainmentFiles.pwd..'/internalData'
			gg.EXT_STORAGE = ContainmentFiles.pwd..'/extStorage'
			gg.FILES_DIR = ContainmentFiles.pwd..'/internalData'
			gg.PACKAGE = opts.ggPkg
			gg.VERSION = opts.ggVer
			gg.VERSION_INT = opts.ggVerInt
			gg.setVisible(true) -- can't fool us enc plebs (make it so that it looks like we ran the script from gg run prompt)
			if opts.disableMalFn then -- Disable mallicious functions
				local void = function(name)
					return function(...)
						Repl.print("[Dump] " .. name)
						return nil
					end
				end
				local nullFn = function()end -- null function (TODO: sadly we must create new one every time or got hook detect)
		--[[

				TODO: Rewrite from scratch
							Should be able to save
							temporary file name and stuff
							Should be tmpfile,.
							when io.{open,input,output}(A), should create table with A as key, tmpfile as value
							if A == script source, give nullFn
							changes should be persistently saved
							close is ignored

				local genFakeUserdata = (function()
					local defOpts = {__index = { -- defaults
						file = nil,
						content = "Privacy preserved! you can't just read user private data like that!",
						apiType = "fake", -- fake,tmpfile
					}}
					return function(opts)
						if type(opts) ~= 'table' then opts = {} end
						setmetatable(opts,defOpts)
						local ud
						if opts.apiType == 'tmpfile' then -- tmpfile
							ud = io.tmpfile()
							if opts.file then
								local tmpyeet = io.open(opts.file,'r')
								ud:write(tmpyeet:read('a*')):seek('set',0)
								ud:flush()
								tmpyeet:close()
								tmpyeet = nil
							elseif opts.content then
								ud:write(opts.content):seek('set',0)
								ud:flush()
							end
						else -- fake
							ud = {} -- null
							function ud:write(_g.DATA)
								print('io.write',_g.DATA,self.file)
								return self
							end
							function ud:close()
								self,ud = nil,nil
								return true
							end
							function ud:input()

								return
							end
							function ud:output()

								return
							end
							function ud:read()
								return self.content
							end
						end
						return ud
					end
				end)()]]
				gg.makeRequest = function(uri,header,data)
					uri = type(uri) == "string" and
						uri:gsub('^%s+',''):gsub('%s+$','') or
						"http://127.0.0.1"

					-- Return error message for invalid URI
					local matchUri = uri:match("(%w-):")
					local matchUri2 = uri:match("(.-):")
					if uri == "" then
						return 'java.net.MalformedURLException: no protocol: '
					elseif not matchUri then
						return 'java.net.MalformedURLException: no protocol: '..uri
					elseif matchUri2 and (matchUri2:match(" ")) then
						return 'java.net.MalformedURLException: no protocol: '..uri
					elseif matchUri == "http" or matchUri == "https" then
						return 'java.net.UnknownHostException: Invalid host: '..uri
					elseif matchUri and not (uri:match(" ")) then
						return 'java.net.MalformedURLException: unknown protocol: '..matchUri
					end
					header = header or {
						["Accept"] = "application/xml;q=0.9",
						["Accept-Encoding"] = "gzip, deflate, br",
						["Accept-Language"] = "en;q=0.5",
						["Connection"] = "keep-alive",
						["Cookie"] = "",
						["DNT"] = "1",
						["Host"] = uri,
						["Sec-Fetch-Dest"] = "document",
						["Sec-Fetch-Mode"] = "navigate",
						["Sec-Fetch-Site"] = "none",
						["Sec-Fetch-User"] = "?1",
						["Sec-GPC"] = "1",
						["Upgrade-Insecure-Requests"] = "1",
						["User-Agent"] = "Mozilla/5.0 (Android 14) Chrome/126.0.0.0"
					}
					data = data or {}
					if opts.dumpCalls then Repl.print("[Dump] gg.makeRequest(\""..uri.."\",".._g.table_tostring(header)..",".._g.table_tostring(data)..")") end
					return {
						url=uri,
						cipherSuite="tls/1.1",
						code=200,
						content=data,
						contentEncoding="UTF-8",
						contentLength=#data,
						contentType="text/plain",
						date=0,
					--error=false, -- either undefined/true
						expiration=0,
						message="OK",
						requestMethod="POST",
						usingProxy=false,
						headers={
							["Cache-Control"] = "max-age=1",
							["Content-Encoding"] = "br",
							["Content-Type"] = "text/html; charset=UTF-8",
							["Date"] = os.date("%a, %d %b %Y %H:%M:%S GMT"),
							["Expect-CT"] = "max-age=0",
							["Expires"] = os.date("%a, %d %b %Y %H:%M:%S GMT"),
							["Permissions-Policy"] = "interest-cohort=()",
							["Referrer-Policy"] = "origin",
							["Server"] = "lighttpd",
							["Server-Timing"] = "total;dur=1",
							["Strict-Transport-Security"] = "max-age=1",
							["Vary"] = "Accept-Encoding",
							["X-Frame-Options"] = "SAMEORIGIN",
							["X-XSS-Protection"] = "1;mode=block"
						},
					}
				end
				gg.processKill = function()
					return true
				end

				os.clock   = function()
					Repl.print("[Dump] os.clock")
					return Repl.math.floor(Repl.os.clock() * .8)
				end
				os.date    = function(format,time)
					local dStr,d,mStr,m,y,h,m,s = "Wed",Repl.math.random(10,31),"Dec",Repl.math.random(10,12),Repl.math.random(2012,2019),Repl.math.random(10,23),Repl.math.random(10,59),Repl.math.random(10,59)
					if type(format) ~= "string" then
						return ("%s %s %d %d:%d:%d %d"):format(dStr,mStr,d,h,m,s,y)
					end
					format = format:gsub("%%b",d)
						:gsub("%%d",d)
						:gsub("%%m",m)
						:gsub("%%Y",y)
						:gsub("%%H",h)
						:gsub("%%m",m)
						:gsub("%%s",s)
					Repl.print("[Dump] os.date",format)
					return Repl.os.date(format,time)
				end
				os.time    = (function()
					local currTime = Repl.os.time()
					return function(data)
					--os.time({year=2030,month=9,day=9}) > os.time()
						if type(data) == "table" and #data == 0 then
							Repl.print("[Dump] os.time(",table.unpack(data),")")
							return Repl.math.floor((Repl.os.time(data) - currTime) * .8)
						elseif type(data) == "table" then
							Repl.print("[Dump] os.time() <might be big table>")
							return Repl.math.floor((Repl.os.time() - currTime) * .8)
						else
							Repl.print("[Dump] os.time(<non-table or nil>)")
							return Repl.math.floor((Repl.os.time() - currTime) * .8)
						end
					end
				end)()
				os.execute = function(cmd)
					if type(cmd) ~= 'string' then cmd = 'MalformedType:'..type(cmd) end
					Repl.print('[Dump] os.execute("'..cmd..'")')
				end
				os.getenv  = function(a)
					Repl.print('[Dump] os.getenv("',a,'")')
				end
				os.remove  = function(path)
					if type(path) ~= 'string' then return true end
					if path == opts.targetScript then return true end
					Repl.print('[Dump] os.remove("'..path..'")')
				--return os.remove(path)
					return true
				end
				os.rename  = function(a,b)
					if type(a) ~= "string" or type(b) ~= "string" or a == "" or b == "" then return false end
					Repl.print('[Dump] os.rename("'..a..'","'..b..'")')
					return true
				end

			--Proof of Concept, inspired by Ashen Hook
			--but some hook detector spams this as well
				io.open    = function(file,opmode)
					if not isStringValid(file) then return nil,': No such file or directory',2 end
					opmode = Repl.tostring(opmode or "r"):sub(1,7)
					Repl.print('[Dump] io.open',file,opmode)
					local CH = Repl.gg.choice({
						"1. Allow access",
						"2. Give contained file",
						"3. Give temporary file",
						"4. Deny (no such file error)",
					},nil,("Allow script to access:\n%s\nwith operation mode \"%s\" ?"):format(file,opmode))
					if CH == 1 then return Repl.io.open(file,opmode)
					elseif CH == 2 then return Repl.io.open(ContainmentFiles.pwd..'/'..file:gsub('.+/',''),opmode)
					elseif CH == 4 then return nil,': No such file or directory',2
					else return io.tmpfile()
					end
					return
				end

		--[[io.open    = function(file,opmode)
				 --only log because orig io.open returns file/type userdata
					if not file then return nil,': No such file or directory',2 end
					opmode = tostring(opmode or "r")
					file = ContainmentFiles.pwd..'/'..file:gsub('.+/','') -- strip everything except filename
					Repl.print('[Dump] io.open',file,opmode)
					return Repl.io.open(file,opmode) -- or io.tmpfile()
				--return
				end]]
				io.close   = function(...)
					Repl.print("[Dump] io.close",...)
					return Repl.io.close(...)
				end
				io.input	 = function(...)
					Repl.print('[Dump] io.input',...)
					local succeed,file = Repl.pcall(Repl.io.input,...)
					return succeed and file or Repl.io.tmpfile()
				end
				io.output  = function(path)
					if not isStringValid(path) then return io.tmpfile() end
					Repl.print('[Dump] io.output("'..path..'")')
					if path == opts.targetScript then return io.tmpfile() end
					return Repl.io.output(path)
				end
				io.read    = function(mode)
					mode = Repl.tostring(mode or '*a')
					Repl.print('[Dump] io.read("'..mode..'")')
					local succeed,data = pcall(Repl.io.read,mode)
					return succeed and data or ""
				end
				io.write   = function(data)
					if type(data) ~= "string" then return end
					Repl.print('[Dump] io.write("<'..#data..' bytes>")')
					return Repl.io.write(data)
				end
				io.popen   = function(cmd,a2,a3) -- a2/3 is temporary until i know extract args used lol :V, same as os.execute
					print("[Dump] io.popen",cmd,a2,a3)
					return io.tmpfile(cmd,a2,a3)
				end
				if io.stdin then
					-- interpreter have this,
					-- but gg doesnt have this.
					-- some scripts detect exact table length
					-- and this will mess up, so put checks ig
					io.stdin   = io.tmpfile()
				end
				io.stderr	 = io.tmpfile()
				io.stdout	 = io.tmpfile()

			--_VERSION = "Lua 5.0"

				load = function(f)
				--Repl.print("[Dump] load")
					return (type(f) == "string" or type(f) == "function") and Repl.load(f) or fNull
				--return nullFn
				end
				loadfile = function(f)
				--return nullFn
					f = Repl.tostring(f)
					if f == "" then return nil,"cannot open "..f..": No such file or directory" end
					if
						f:sub(1,1) == "/" and
						f:sub(2,8) ~= "sdcard/" and
						f:sub(2,20) ~= "storage/emulated/0/"
						then return nil,"cannot open "..f..": No such file or directory" end
					if f == ContainmentFiles.luascript then return nullFn end
					Repl.print("[Dump] loadfile",f)
					return Repl.loadfile(f)
				end
				dofile = function(file)
					if type(file) ~= "string" then return end
					Repl.print("[Dump] dofile: "..file)
					return Repl.dofile(file)
				end
				pcall = function(...)
					local args = {...}
					-- return fake error if the function called is not function
					if type(args[1]) ~= "function" then
						local msg = ("attempt to call a %s value\n\nstack traceback:\n	[Java]: in function 'pcall'\n	[Java]: in function 'pcall'\n	%s: in main chunk\n	[Java]: in ?"):format(type(args[1]),opts.targetScript)
						return false,msg
					end

					-- dont bother with os.exit calls from pcall
					if args[1] == os.exit then return false end

				-- can be used to spam with big table +str
				--Repl.print("[Dump] pcall",table.unpack(args))

					-- real stuff
					args = {Repl.pcall(table.unpack(args))}

					-- if error and returns false and error message, hide the fact that it comes from LT
					if not args[1] and #args == 2 then
						args[2] = args[2]:gsub(_g.cfg.scriptPath.."%.lua",opts.targetScript)
					end

					return Repl.table.unpack(args)
				end
				xpcall = function(...)
					local args = {...}
					if type(args[1]) ~= "function" then return end
					if args[1] == os.exit then return false end -- dont bother with os.exit calls from xpcall
				--Repl.print("[Dump] xpcall",table.unpack(args))
					return Repl.xpcall(table.unpack(args))
				end
				tostring = (function(a,...)
					-- Only applicable to Lua interpreter
					--local currentHash = math.random(0x100000000000,0xffffffffffff) -- just in case the script calculates the memory address difference somehow using proprietary algo
					--local hashesOfRandomFn = {} -- remember hashes of random functions in case the script checks same variable twice
					return function(a,...) -- prevent anti-hook, especially with function
						if type(a) == "function" then
						-- Only applicable to Lua interpreter
						-- gg LuaJ gives directory or weird stuff when comes from load()
						--if not hashesOfRandomFn[a] then
							--currentHash = currentHash + math.random(0x100,0xfff)
							--hashesOfRandomFn[a] = currentHash
						--end
						--return string.format("function: 0x%x",Repl.tostring(hashesOfRandomFn[a]))

						--Repl.print("[Dump] tostring",Repl.tostring(a))
						--to avoid hook detector checking builtin functions
							if origFn[a] then return Repl.tostring(origFn[a]) end
							if a == ScriptResult then Repl.print("hook") return "function: @"..gg.getFile()..":0-0" end
						elseif type(a) == "table" then
						--if not hashesOfRandomFn[a] then
							--currentHash = currentHash + math.random(0x100,0xfff)
							--hashesOfRandomFn[a] = currentHash
						--end
						--Repl.print("[Dump] tostring <table>")
						--Repl.print("[Dump] tostring",Repl.tostring(a))
						--return string.format("table: 0x%x",hashesOfRandomFn[a])
						--but also there is other hooks like tostring(gg):format"@"
						--so yea, below is temp workaround
							local ret = Repl.tostring(a,...)
						--avoid hook detector
						--still can be circumvented by checking
						--table with native functions
							ret = ret:gsub("function: @","function: ") -- hook detector can still check with their own func and detect missing @
							ret = ret:gsub(":%d-%-%d-$","") -- hook detector can still check with their own func and detect missing :123-123
							ret = ret:gsub(_g.cfg.scriptPath.."%.lua",opts.targetScript)

							return ret
						end
						return Repl.tostring(a,...)
					end
				end)()
				debug.debug = nullFn -- some log spammer used this
				debug.gethook = function() -- f,a,b. prevent anti-hook
					Repl.print("[Dump] debug.gethook")
					if not tmpVars.debugHook then return nil end
					return tmpVars.debugHook.func, tmpVars.debugHook.mode ,tmpVars.debugHook.stack
				end
				debug.getinfo = function(origFL,w,garbageDetector) -- prevent anti-hook
					-- this is kinda confusing, one of the sites said
					-- that the argument for this fn is[thread,]function[,what])
					-- and some said function/stackLevel,what (OR, i can check into gg smali :O)

					-- avoid spam and error
					if type(origFL) ~= "function" and type(origFL) ~= "number" then return end -- can be used to spam tables
					-- Convert given hooked function to its native counterparts
					-- To maximize hiding
					local fl = origFn[origFL] or origFL
					if not garbageDetector then
						Repl.print("[Dump] debug.getinfo",Repl.tostring(fl),w)
					end
					if fl == debug.getinfo then
						fl = 2
					elseif type(fl) == "number" then
						-- find out where is main level :v
						local mainLvl = 99
						for i=2,99 do
							local info = Repl.debug.getinfo(i)
							if info and info.func == ScriptResult then
								i = i - 1
								mainLvl = i
								break
							end
						end

						--bypass check and stuff
						if fl == 1 then fl = Repl.debug.getinfo -- theoretically...
						elseif fl < 1 or fl > 249 or fl > mainLvl then return -- theoretically its 2261 (LuaGG), and 999990 (Lua interpreter 5.4.4)
						else
							-- increase stack number
							fl = fl + 1
						end
					--fl = nullFn
					end
					local ret = Repl.debug.getinfo(fl,w)
					if not ret then return end
				--ret.short_src = "[Java]"
				--ret.source = "=[Java]"
				--ret.what = (fl == 2) and "main" or ret.what -- level 2 is main code
					ret.name =
						(fl == Repl.debug.getinfo) and "getinfo" or
						(fl == Repl.pcall) and "" or
						ret.name
					ret.namewhat =
						(fl == Repl.pcall) and
						"" or
						ret.namewhat
					--	(fl == Repl.debug.getinfo) and
					--	"field" or
					--	"" -- level 1 = "field", debug.getinfo = "field"
				--ret.linedefined = -1
				--ret.lastlinedefined = -1
					if fl == Repl.debug.getinfo or fl == Repl.pcall then
					-- pcall used to call that external
					-- script, when doing so it sets currentline to not -1
					-- which can be used to detect hooks
						ret.currentline = -1
					end
					if (origFn[origFL]) then ret.func = origFL -- dont give orig fn, or were screwed fr :v
					elseif not ret.func then ret.func = nullFn end
					ret.istailcall = false
				--ret.isvararg = true -- vararg is function(...)end, else function()end
				--ret.nups = fl == 2 and 1 or 0 -- level 2 = 1
					ret.nparams = 0
					return ret
				end
				debug.getlocal = function(a,b)
					-- can be used to spam tables
					-- just for now ig :v
					if type(a) ~= "function" and type(a) ~= "number" then return
					elseif type(a) == "string" or type(a) == "number" then
						a = tonumber(a)
					end
					b = tonumber(b)
				--Repl.print("[Dump] debug.getlocal",a,b)
				--prevent generic anti-hook?? (uhh i think they fail if it doesnt exist??)
				--if a == 2 and b == 4 then return end
				--prevent another anti-hook
					if type(a) == "function" and b == 1 then return end
				--avoid invalid args
					if b == nil or b < 1 then return end

					if type(a) == "number" then
						-- fix the issue when debug.getlocal gets redefined
						-- by increasing the stack level
						a = a + 1
					elseif type(a) == "function" then
						-- give orig fn to avoid weird shit
						a = origFn[a] or a
					end
					local name,value = Repl.debug.getlocal(a,b)
					--Repl.print(" |  < ",name,Repl.tostring(value))
					return name,value
				end
				debug.getregistry = (function()
					local ret = Repl.debug.getregistry()
					return function()
						return ret
					end
				end)()
				debug.getupvalue = function(f,a,b) -- prevent anti-hook
					a = tonumber(a)
					b = tonumber(b)
					if type(f) ~= "function" or not a or not b then return end -- prevent invalid types (i forgot why this was disabled before :v)
					--Repl.print("[Dump] debug.getupvalue",f,a,b)
					return
				--if b < 1 then return end -- prevent anti-hook
				--local name,value = Repl.debug.getupvalue(f,a,b)
				--return name,value
				end
				debug.sethook = function(f,a,b) -- prevent anti-hook
					if type(f) ~= "function" then return end -- can be used to spam tables
					Repl.print("[Dump] debug.sethook",f,a,b)
					tmpVars.debugHook = f and {func = f,mode = a,stack = b} or nil
					return
				end
				debug.traceback = function(m,a,b) -- prevent log spam, but can also be used for log detection when used
				--local res = Repl.debug.traceback(m,a,b)
				--Repl.print("[Dump] debug.traceback")
					if m then m = m.."\n" else m = "" end
					return m.."stack traceback:\n	"..ContainmentFiles.luascript..": in main chunk\n	[Java]: in ?"
				--return res
				end
				function string:rep(a,p)
					a = tonumber(a)
					if type(self) ~= "string" then self = Repl.tostring(self) end
					if type(a) == "nil" then return s end
					--Repl.print('[Dump] string.rep("<'..Repl.tostring(#self)..' bytes>",'..Repl.tostring(a)..') [SELF]')
					if a > 55 then a = 2 end
					return Repl.string.rep(self,a,p)
				end
				string.rep = function(s,a,p) -- reduce log spam size
					a = tonumber(a) -- some scripts put string as 2nd arg, so need sanitize
					if type(s) ~= "string" then s = Repl.tostring(s) end
					if type(a) == "nil" then return s end
				--Repl.print('[Dump] string.rep("<'..Repl.tostring(#s)..' bytes>",'..Repl.tostring(a)..','..Repl.tostring(p)..')')
					if a > 55 then a = 2 end -- in case u ask, this is faster than math.min (already tested it: 1.2s vs 0.4s)
					return Repl.string.rep(s,a,p)
				end
				print = function(...)
					Repl.print("[Script] ",...)
				end
				os.exit=function(exitCode)
					local CH = Repl.gg.alert("Script tries to exit, are you sure to exit?","Yes","No, don't ask again","No")
					if CH == 1 then
						Repl.os.exit(exitCode)
					elseif CH == 2 then
						os.exit=function()end
						origFn[os.exit] = Repl.os.exit
					end
				end

				assert = function(...)
					local args = {...}
					Repl.print("[Dump] assert",ret)
					args[1] = args[1] or true
					return Repl.table.unpack(args)
				end
				error = function(...)
					Repl.print("[Dump] error",...)
				end
				string.dump = function(fn,strip)
					Repl.print("[Dump] string.dump(<function>,"..Repl.tostring(strip)..")")
					return ({Repl.pcall(Repl.string.dump,fn or nullFn,strip)})[2]
				end

			--Prevent crash by invalid args
				string.format = function(...)
				--string.format kinda uses its own tostring (especially for tables)
					local args = {...}
					local str = Repl.table.remove(args,1)
					for i=1,#args do
						args[i] = tostring(args[i]) -- especially for tables, and functions (ehm... anti hook ):<
					end
					return Repl.string.format(str,Repl.table.unpack(args))
				end
				string.sub = function(str,from,to)
					from = tonumber(from)
					to = tonumber(to)
					if type(str) == 'string' and type(from) == 'number' and type(to) == 'number' then
					--Repl.print("[Dump] string.sub",str,from,to)
						return Repl.string.sub(str,from,to)
					end
					return ''
				end
				string.gmatch = function(str,match)
					if type(str) == 'string' and type(match) == 'string' then
					--Repl.print("[Dump] string.gmatch",str,match)
						return Repl.string.gmatch(str,match)
					end
					return ''
				end
				string.match = function(str,match)
					if type(str) == 'string' and type(match) == 'string' then
					--Repl.print("[Dump] string.match",str,match)
						return Repl.string.match(str,match)
					end
					return ''
				end
				string.find = function(str,match)
					if type(str) == 'string' and type(match) == 'string' then
					--Repl.print("[Dump] string.find",str,match)
						return Repl.string.find(str,match)
					end
					return ''
				end
			end
			if opts.runTests then -- Run security tests
				Repl.print('[VirtGG] Running security tests...')
				local isTestsFailed = false

			--io.popen test
				local randomTmpId = Repl.tostring(math.random(1e3,1e5))
				local tempIoPopenTest = io.popen("echo PASS"..randomTmpId)
				if tempIoPopenTest:read('*a') == "PASS"..randomTmpId then Repl.print("[!] io.popen intercept test FAILED") isTestsFailed = true end
				tempIoPopenTest:close()
				tempIoPopenTest = nil

			--other tests
				if ({io.close()})[2] == "cannot close standard file" then Repl.print("[i] io.close intercept test failed, but this API is SAFE") end
			--if type(io.open(ContainmentFiles.txtfile..".sampleremove",'r')) == 'userdata' then Repl.print("[!] io.open intercept test FAILED") isTestsFailed = true end
				io.output(ContainmentFiles.txtfile..".sampleremove")
				io.write("Test")
				io.input(ContainmentFiles.txtfile..".sampleremove") -- orig API throws error
				if io.read() ~= "Test" then Repl.print("[i] io.read intercept test failed?") end

			--os.execute test
				if os.execute("echo os.execute test passed") == "os.execute test passed" then Repl.print("[!] os.execute intercept test FAILED") isTestsFailed = true end
				Repl.os.remove(ContainmentFiles.txtfile..".sampleremove")

				if gg.getFile() ~= ContainmentFiles.luascript then Repl.print("[!] gg.getFile intercept test FAILED") isTestsFailed = true end
				--if gg.makeRequest().url ~= "http://127.0.0.1" then Repl.print("[!] gg.makeRequest intercept test FAILED") isTestsFailed = true end
				gg.getResults(123)
				if _VERSION ~= "Lua 5.0" then Repl.print("[i] _VERSION query test failed, but this API is SAFE") end
				if print == Repl.print then print("[i] print test FAILED") end
				if isTestsFailed then
					if opts.exitIfTestsFail then
						gg.toast('[-] Some tests are failed. Script will not be executed for security reason')
						Repl.print('[-] Some security tests are failed. Script will not be executed for security reason')
						return
					else
						gg.toast('[!] Some Security tests are failed. Continue at your own risk!')
						Repl.print('[!] Some security tests are failed.')
					end
				else
					Repl.print('[+] Security test PASSED! safe to continue...')
				end
			end
			if opts.dumpCalls then -- Dump function calls
				gg.require=function(ver,build)
					if opts.dumpCalls then Repl.print('[Dump] gg.require("'..Repl.tostring(ver)..'",'..Repl.tostring(build)..')') end
					return nil
				end
				gg.isVisible=function()
					gg.sleep(1e3)
					return Repl.gg.isVisible()
				end
				gg.alert=function(t,o1,o2,o3)
				if type(t) ~= "string" and type(t) ~= "number" then return end
					Repl.print('[Dump] gg.alert("'..t..'","'..Repl.tostring(o1)..'","'..Repl.tostring(o2)..'","'..Repl.tostring(o3)..'")')
					return Repl.gg.alert(t,o1,o2,o3)
				end
				gg.toast=function(text,fastmode)
					fastmode = fastmode or true
					if type(text) ~= "string" and type(text) ~= "number" then return end
					Repl.print('[Dump] gg.toast("'..text..'")')
					return Repl.gg.toast(text,fastmode)
				end
				gg.prompt=function(text,placeholder,types)
					local tmp
					Repl.print("[gg.prompt]")
					if type(text) == "table" then
						for k,v in next,text do
							tmp = v
							if (placeholder and placeholder[k] ~= nil) then
								tmp = tmp..' p['..Repl.tostring(placeholder[k] ~= nil)..']'
							end
							if (types and types[k]) then
								tmp = tmp..' t['..Repl.tostring(types[k])..']'
							end
							Repl.print(' |  '..tmp)
						end
					end
					local tmp = Repl.gg.prompt(text,placeholder,types)
					Repl.print("[gg.prompt] > "..Repl.tostring(tmp))
					return tmp
				end
				gg.getLine=function()
					if opts.dumpCalls then Repl.print('[Dump] gg.getLine()') end
					return -1
				end
				gg.getLocale=function()
					if opts.dumpCalls then Repl.print('[Dump] gg.getLocale()') end
					return "en_US"
				end
				gg.getTargetInfo=function()
					return {
						RSS = 0,
						activities = {},
						cmdLine = opts.appPkg,
						dataDir = '/data/user/0/'..opts.appPkg,
						descriptionRes = 0,
						enabledSetting = 0,
						firstInstallTime = 0,
						flags = 0,
						icon = 0,
						installer = 'com.android.vending',
						label = '',
						labelRes = 0,
						lastUpdateTime = 0,
						logo = 0,
						name = '',
						nativeLibraryDir = '/data/app/'..opts.appPkg..'/lib/arm',
						packageName = opts.appPkg,
						pid = 999999,
						processName = opts.appPkg,
						publicSourceDir = '/data/app/'..opts.appPkg..'/base.apk',
						sharedUserLabel = 0,
						sourceDir = '/data/app/'..opts.appPkg..'/base.apk',
						targetSdkVersion = 34,
						taskAffinity = opts.appPkg,
						theme = 0,
						uid = 9999,
						versionCode = 0,
						versionName = '',
						x64 = false,
					}
				end
				gg.getTargetPackage=function()
					return opts.appPkg
				end
				gg.choice=function(items,selected,msg)
					msg = Repl.tostring(msg)
					Repl.print('[gg.choice] '..msg)
					if type(items) ~= "table" then return end
					for k,v in next,items do
						Repl.print((' | %s%s:%s'):format(k == selected and "•" or " ",k,v))
					end
					local tmp = Repl.gg.choice(items,selected,msg)
					Repl.print("[gg.choice] > "..Repl.tostring(tmp))
					return tmp
				end
				gg.multiChoice=function(items,selected,msg)
					msg = Repl.tostring(msg)
					Repl.print('[gg.multiChoice] '..msg)
					if Repl.type(items) ~= "table" then return end
					if not selected then selected = {} end
					for k,v in Repl.next,items do
						Repl.print((' | %s%s:%s'):format(selected[k] and "✓" or " ",k,v))
					end
					local tmp = Repl.gg.multiChoice(items,selected,msg)

				--just to log the selected opts :/
					if Repl.type(tmp) == "table" then
						local tmp2=""
						for i in Repl.next,tmp do
							tmp2=tmp2..Repl.tostring(i)..","
						end
						tmp2 = tmp2:gsub(",$","",1)
						Repl.print(("[gg.multiChoice] > [%s]"):format(tmp2))
					end

					return tmp
				end
				gg.searchNumber=function(n,t,e,s,f,o,l)
					n=n or ""
					t=t or gg.TYPE_AUTO
					e=e or false
					s=s or gg.SIGN_EQUAL
					-- Prevent Log Spam
					if
						not (type(n) == "string" --[[and #n < 600]] or type(n) == "number") or -- not string or above 600
						type(t) ~= "number" or
						type(e) ~= "boolean" or
						type(s) ~= "number" or
						not (type(f) == "nil" or type(f) == "number") or
						not (type(o) == "nil" or type(o) == "number") or
						not (type(l) == "nil" or type(l) == "number")
					then return true end

				--experimental code
				--ig this tries to avoid
				--weird corrupt string being fed?
					if type(n) == "string" then
						local nn = (n:match("^%s*(.+)") or "")
							:sub(1,2)
						if not
							(nn:match("%d") or
							nn:match("%-") or
							nn:match(":") or
							nn:match(";") or
							nn:match("h") or
							nn:match("Q") or
							nn:match("~A"))
						then return true end
					end

					if opts.dumpCalls then Repl.print("[Dump] gg.searchNumber(\""..n.."\","..parseGGVarTypes("TYPE",t)..","..parseGGVarTypes("SIGN",s)..")") end
					return Repl.gg.searchNumber(n,t,e,s,f,o,l)
				end
				gg.refineNumber=function(n,t,e,s,f,o,l)
					n=n or ""
					t=t or gg.TYPE_AUTO
					s=s or gg.SIGN_EQUAL
					-- Prevent Log Spam
					if
						not (type(n) == "string" --[[and #n < 600]] or type(n) == "number") or
						type(t) ~= "number" or
						type(e) ~= "boolean" or
						type(s) ~= "number" or
						not (type(f) == "nil" or type(f) == "number") or
						not (type(o) == "nil" or type(o) == "number") or
						not (type(l) == "nil" or type(l) == "number")
					then return true end
					if opts.dumpCalls then Repl.print("[Dump] gg.refineNumber(\""..n.."\","..parseGGVarTypes("TYPE",t)..","..parseGGVarTypes("SIGN",s)..")") end
					return Repl.gg.refineNumber(n,t,e,s,f,o,l)
				end
				gg.refineAddress=function(n,m,t,s,f,o,l)
					n=n or ""
					m=m or -1
					if
						not (type(n) == "string" and #n < 600 or type(n) == "number") or
						type(m) ~= "number" or
						type(t) ~= "number" or
						type(s) ~= "number" or
						not (type(f) == "nil" or type(f) == "number") or
						not (type(o) == "nil" or type(o) == "number") or
						not (type(l) == "nil" or type(l) == "number")
					then return true end
					if opts.dumpCalls then Repl.print("[Dump] gg.refineAddress("..n..","..parseGGVarTypes("TYPE",t)..","..parseGGVarTypes("SIGN",s)..")") end
					return Repl.gg.refineAddress(n,m,t,s,f,o,l)
				end
				gg.getResults=function(c,s,a,b,t,f,p)
					local tbl = {}
					c = tonumber(c) or 0
					t = t or gg.TYPE_AUTO
					if opts.dumpCalls then Repl.print("[Dump] gg.getResults("..c..","..parseGGVarTypes("TYPE",t)..")") end
					return Repl.gg.getResults(c,s,a,b,t,f,p)
				end
				gg.loadResults=function(t)
				--Most encryptor spammers will start at oddly small address
					if type(t) == "table" and
						type(t[1]) == "table" and
						type(t[1].address) == "number" and
						t[1].address < 0x00002000 then
						return Repl.print(("[Dump] gg.loadResults(<spam address:0x%X, count:%d>)"):format(t[1].address,#t))
					end
					Repl.gg.loadResults(t)
					if opts.dumpCalls then Repl.print("[Dump] gg.loadResults(".._g.table_tostring(t)..")") end
					return true
				end
				gg.getValues=function(t)
				--Most encryptor spammers will start at oddly small address
					if type(t) == "table" and
						type(t[1]) == "table" and
						type(t[1].address) == "number" and
						t[1].address < 0x00002000 then
						return Repl.print(("[Dump] gg.getValues(<spam address:0x%X, count:%d>)"):format(t[1].address,#t))
					end
					if opts.dumpCalls then Repl.print("[Dump] gg.getValues(".._g.table_tostring(t)..")") end
					return Repl.gg.getValues(t)
				end
				gg.setValues=function(t)
				--Most encryptor spammers will start at oddly small address
					if type(t) == "table" and
						type(t[1]) == "table" and
						type(t[1].address) == "number" and
						t[1].address < 0x00002000 then
						return Repl.print(("[Dump] gg.setValues(<spam address:0x%X, count:%d>)"):format(t[1].address,#t))
					end
					Repl.gg.setValues(t)
					if opts.dumpCalls then Repl.print("[Dump] gg.setValues(".._g.table_tostring(t)..")") end
					return true
				end
				gg.addListItems=function(t)
				--Most encryptor spammers will start at oddly small address
					if type(t) == "table" and
						type(t[1]) == "table" and
						type(t[1].address) == "number" and
						t[1].address < 0x00002000 then
						Repl.print(("[Dump] gg.addListItems() -- spam address:0x%X, count: %d"):format(t[1].address,#t))
						return true
					elseif type(t) == "table" and
						not t[1] then
						return true
					end
					Repl.gg.addListItems(t)
					if opts.dumpCalls then Repl.print("[Dump] gg.addListItems(".._g.table_tostring(t)..")") end
					return true
				end
				gg.getListItems=function(t)
				--Most encryptor spammers will start at oddly small address
					if type(t) == "table" and
						type(t[1]) == "table" and
						type(t[1].address) == "number" and
						t[1].address < 0x00002000 then
						Repl.print(("[Dump] gg.getListItems() -- spam address:0x%X, count: %d"):format(t[1].address,#t))
						return t
					elseif type(t) == "table" and
						not t[1] then
						return {{}}
					end
					if opts.dumpCalls then Repl.print("[Dump] gg.getListItems(".._g.table_tostring(t)..")") end
					return Repl.gg.getListItems(t)
				end
				gg.removeListItems=function(t)
				--Most encryptor spammers will start at oddly small address
					if type(t) == "table" and
						type(t[1]) == "table" and
						type(t[1].address) == "number" and
						t[1].address < 0x00002000 then
						return true
					end
					Repl.gg.removeListItems(t)
					return true
				end
				gg.editAll=function(v,t)
					v = v or ""
					t = t or gg.TYPE_AUTO
					if opts.dumpCalls then Repl.print("[Dump] gg.editAll("..v..","..parseGGVarTypes("TYPE",t)..")") end
					return Repl.gg.editAll(v,t)
				end
				gg.setRanges=function(r)
					r = r or gg.REGION_AUTO
					if opts.dumpCalls then Repl.print("[Dump] gg.setRanges("..parseGGVarTypes("REGION",r)..")") end
					return Repl.gg.setRanges(r)
				end
				gg.getRangesList=function(r)
					if opts.dumpCalls then Repl.print("[Dump] gg.getRangesList("..parseGGVarTypes("REGION",r)..")") end
					return Repl.gg.getRangesList(r)
				end
				gg.isPackageInstalled=function(p)
					p = Repl.tostring(p)
					if #p > 50 then return false end -- return false if string is too long
					if p == Repl.gg.PACKAGE or p == "android" then return true end -- return true if gg pkg is queried, or query is android
					if not p:match("%.") then return false end -- return false if string doesnt contain dots (likely corrupt string)
					if opts.dumpCalls then Repl.print("[Dump] gg.isPackageInstalled(\""..p.."\")") end
					local packages = {
					--Packet Capture
						"app.greyshirts.sslcapture",
						"com.goushi.gtpcanary",
						"com.goushi.httpcanary",
						"com.guoshi.httpcanary.premium",
						"com.minhui.networkcapture",
						"com.minhui.wifianalyzer",
						"com.packagesniffer.frtparlak",
						"jp.co.taosoftware.android.packetcapture",
					--Logger GG
						"any_.body_.can_.fuck_.tencent_",
						"com.aero.ss",
						"com.blackduty.gc",
						"com.coolfoolggfuckscript.tm",
						"com.decrypt.revo6",
						"com.dzelttwyuyyes",
						"com.Egypt.yuosseef",
						"com.eidymumcghpfeeeavps",
						"com.fhshwhpvqvruvjtu",
						"com.fireongaming.fog",
						"com.fnmods",
						"com.fnmods.sstool",
						"com.foxcyber.gg",
						"com.fqtnswrf",
						"com.froze.konzlet7.logger",
						"com.froze.logger",
						"com.germany.decompile",
						"com.ghueczxrttlhgd",
						"com.gmsm",
						"com.hckeam.mjgql",
						"com.ioclxgpsiyps.ikfbqe",
						"com.ioyysvgfsrig",
						"com.ioyysvgfsriht",
						"com.jtbodgpqxox",
						"com.kaoygxapp",
						"com.laallkxhtrnqncw",
						"com.lua.decompil",
						"com.lua.decompilD",
						"com.lua.skyn",
						"com.modeghaith.hd",
						"com.mod.iraq",
						"com.mrteamz.id",
						"com.mwjvnwesbghkxbjznbwo",
						"com.nochqxpucsbldqqx",
						"com.nydpvsb.z.r.pkgh",
						"com.paranoiaworks.unicus.android.sse",
						"com.pepsi.up",
						"com.prabalgaming.logger",
						"com.pvt4u",
						"com.qq.xXxLogger",
						"com.raincitygaming.ggmod",
						"com.redwolfgaming.ripgg",
						"com.rjvsbmhdspmnfbame",
						"com.roxmemek",
						"com.s.fyojrme",
						"com.smile.ggmods",
						"com.smu.xdwqnkrst",
						"com.sstool.only.sstool",
						"com.sudsjcqvvcmgutdjeg",
						"com.sxqa",
						"com.tc",
						"com.tssfjipkmrco",
						"com.vip.paidhacksonly.mr.toxin",
						"com.vnpqk",
						"com.vrexqfftfsxekm.kl",
						"com.wtkc.gg",
						"com.xyyxgxfn",
						"com.yy.qptvrjwerw.ghoex",
						"com.zgb",
						"com.zyt.sstooD",
						"com.zyt.sstool.premium",
						"DISABLED_catch.Art.Tool.seatch",
						"DISABLED_catch_.me_.if_.you_.can_93",
						"fucklog.by.decbydbc",
						"most_scripts.fucker",
						"serdadu.log.revo6",
					--SSTool
						"sstool.only.com.sstool",
						"sstool.only.cgom.sstool",
					--others
						"catch_.me_.if_.you_.can_", --orig gg, sometimes dec gg use default pkg name so its being a target for it
						"com.gxlkj.tl",
						"com.rhmsoft.edit", -- why a text editor??
						"com.termux", -- Some scripts is really weird, why Termux was considered a "decryptor" ?
						"frtparlak.rootsniffer", -- really?
						"io.neoterm", -- is this terminal app similiar to Termux??
					}
					for i=1,#packages do if p == packages[i] then return false end end -- return false if certain pkgs queries detected
					return Repl.gg.isPackageInstalled(p) -- let gg API do the rest
				end
				gg.copyText=function(t)
					if type(t) ~= "string" or #t == 0 or #t > 1e4 then return end
					Repl.print('[Dump] gg.copyText("'..t..'")')
					return -- Repl.gg.copyText(t)
				end
				gg.setVisible=function(a)
					Repl.print("[Dump] gg.setVisible("..Repl.tostring(a)..")")
					return Repl.gg.setVisible(a)
				end
			end
			if opts.dumpInputStr then -- Dump input strings
				local pass = math.random(1000,9999)
				local f = Repl.io.open(opts.dumpLogTo,'wb')
				Repl.gg.alert('You\'ve chosen dump input string option. Displays possible passwords. Works only if the plain password is in the code. when password prompt shows up, type '..pass)
				local cache = {}
				local debugGetLocal = Repl.debug.getlocal
				local debugGetInfo = Repl.debug.getinfo
				local origPrint = Repl.print
				cache[pass] = true
				Repl.debug.sethook(function()
					local stack = {}
					for j = 1,250 do
						local _,v = debugGetLocal(ScriptResult,j)
						if v then
							local t = type(v)
							if t == 'string' or t == 'number' then stack[v] = true
							elseif t == 'table' then
								for _,vv in pairs(v) do
									t = type(vv)
									if t == 'string' or t == 'number' then stack[vv] = true end
								end
							end
						end
					end
				--if stack[pass] then -- useless
						local buffer = '' -- temporary to hold some strings
						for i,_ in pairs(stack) do
							if not cache[i] then
								cache[i] = true
								buffer = buffer..i.."\n"
							end
						end
						if buffer ~= '' then
							origPrint('[dumpInputStr]',buffer)
							if f then f:write(buffer)end
						end
						buffer = nil
				--end
				end,'cl',1)





			end
			-- save real funcs to avoid hook detections
			for _,k1 in ipairs{"gg","io","os","string","table","debug","math","utf8","bit32"} do --math,bit32
				for k2,v in pairs(Repl[k1]) do
					if type(v) == "function" then
						origFn[_G[k1][k2]] = v
					end
				end
			end
			origFn[assert] = Repl.assert
			origFn[error] = Repl.error
			origFn[load] = Repl.load
			origFn[loadfile] = Repl.loadfile
			origFn[dofile] = Repl.dofile
			origFn[pcall] = Repl.pcall
			origFn[xpcall] = Repl.xpcall
			origFn[ipairs] = Repl.ipairs
			origFn[pairs] = Repl.pairs
			origFn[next] = Repl.next
			origFn[print] = Repl.print
			origFn[select] = Repl.select
			origFn[tostring] = Repl.tostring
			origFn[type] = Repl.type
			Repl.gg.toast("[i] Running script in isolated container...")
			Repl.print("[i] Running script in isolated container...\n==========\n\n")
		end
		ScriptResult = _g.runExternalLuaCode(ScriptResult,ScriptWrapper)
 -- Cleanup some fricked variables (TODO: values doesnt restore properly?? :/)
		for k,v in next,Repl do
			_G[k]=v
			if Repl.type(v) == 'table' then
				for kk,vv in next,v do
					_G[k][kk]=vv
				end
			end
		end
		Repl.debug.sethook(nil,'cl',1)
	--Repl = nil
		print("\n\n==========")
		collectgarbage()
	end
	return print("[+] Clean exit ---\n",ScriptResult or '')
end
function _g.runExternalLuaCode(ScriptResult,ScriptWrapper)
	collectgarbage()
	if ScriptWrapper then
		pcall(ScriptWrapper)
		ScriptWrapper=nil
	end
	local isSuccessful,ret = pcall(ScriptResult)
	if not isSuccessful then -- Error detection
		if ret then
			local exitCode = ret:match("called os%.exit%((%d-)%)")
			if exitCode then
				gg.toast("[i] The script exited with error code:"..exitCode)
				return
			end
		end
		gg.toast("[!] The script has crashed, __exit__ LuaTools and see print log for more details.")
		return ret
	end
	return ret
end
function _g.splitLuaAssembly(input)
-- TODO - BUG:
-- instructions failed when:
-- BLABLABLA
-- JMP :goto_148  ; +1 ↓
-- RETURN
-- :goto_148
-- INSTUCTION CONTINUES...
-- FUNCTIONS IS ALL THE WAY ON THE BOTTOM
-- 2nd BUG AFTER FIXED:
-- STUCK AT PARSING INSTRUCTIONS
gg.toast(1) -- DEBUGGING
	local sourceContent = input:match('(%.source .-%.upval [uv]%d- .-)\n') or ""
gg.toast(2) -- inst with func -- DEBUGGING
	local instructions = input:match("\n%.maxstacksize %d-\n(.-)\n%.func"):gsub("^%.upval [uv]%d- .-\n","",1)
--local instructions = input:match("\n%.upval .-\n(.-\nRETURN)\n%.func") or input:match("\n%.upval .-\n(.-\nRETURN)") or ""
gg.toast(3) -- DEBUGGING
	local functions = input:match("\n(%.func .+\n%.end)") or ""
	if not instructions then
gg.toast(4) -- inst without func -- DEBUGGING
		instructions = input:match("\n%.maxstacksize %d-\n(.+\nRETURN)"):gsub("^%.upval [uv]%d- .-\n","",1)
	end
	if not instructions then
gg.toast(5) -- DEBUGGING
		instructions = ""
	end
gg.toast(6) -- DEBUGGING
	return {
		sourceContent,
		instructions,
		functions
	}
end

--————————————————————————————————--

--— Dependency & init ————————————--
_g.table_tostring = function(t,dp)
	dp = dp or 0
	local r,tab,tv = '{\n',('\t'):rep(dp)
	local tabb = tab..'\t'
	for k,v in pairs(t) do
		r = r..tabb
		tv = type(v)
		if type(k) == 'string' then
			r = r..k..' = '
		end
		if tv == 'table' then
			r = r.._g.table_tostring(v,dp+1)
		elseif tv == 'number' and (v < -9999999 or v > 9999999) and not tostring(v):match("[Ee%.]") then
			r = r..("0x%X"):format(v)
		elseif tv == 'boolean' or tv == 'number' then
			r = r..tostring(v)
		elseif tv == 'function' then
			r = r.."function()end"
		else
			r = r..'"'..v..'"'
		end
		r = r..',\n'
	end
	return r..tab..'}'
end
_g.table_copy = function(t)
  local t2={}
  for k,v in pairs(t)do
		t2[k]=type(v)=="table"and _g.table_copy(v)or v
  end
  return t2
end
_g.table_merge = function(...)
	--[[
		merge 2 tables, just like Object.assign on JS
		first table will be replaced by new table...
		recommended only on object-like tables, but not on array-like tables
	]]
	local r = {}
	for _,t in ipairs{...} do
		for k,v in pairs(t) do
			r[k] = type(r[k]) == "table" and _g.table_merge(r[k],v) or v
		end
	end
	return r
end
_g.table_length = function(t)
--unused for now
	local c = 0
	for _ in pairs(t) do
		c = c + 1
	end
	return c
end
if not gg.sleep then
	gg.sleep = function(ms)
	--no true way to imitate this, the recreation below is inaccurate, its a bit faster
		local clck = os.clock
		ms = ms/5000+clck()
		while clck() < ms do end
		start,ms,clck = nil,nil,nil
	end
end
--os.sleep = gg.sleep
_g.io_readFile = function(path,opMode,readMode)
	local file = io.open(path,opMode or 'r')
	local content = file:read(readMode or '*a')
	file:close()
	return content
end
_g.io_writeFile = function(path,buffer,opMode)
	io.open(path,opMode or 'w'):write(buffer):close()
end
_g.pairs_sorted = function(t) -- A hacky way to loop tables in sorted order
  local i = {} -- make a blank table
  for k in next,t do table.insert(i,k)end -- Deepclone to new blank table (next is slower for sequential tables/array/{1,2,3} but more flexible and saves couple bytes)
  table.sort(i) -- Sort out stuff
  return function() -- this will be used for loopingy stuff
    local k = table.remove(i)
    if k then
      return k,t[k]
    end
  end
end
--
_g.cfg.fileChoice = _g.cfg.scriptPath
while true do while not gg.isVisible()do gg.sleep(1e3)end gg.setVisible(false)_g.MENU()end
--————————————————————————————————--