--[Xa]-EDIT-v09---APEX[GG]v2

-- v09
v=[Link]()
if v==nil then
print("×× ERROR ××\n×× INVALID PROCESS SELECTED / OR NO ROOT ACCESS")
[Link](true) [Link]()
return
end

--●●●●●●●●●●●●●●●●●●●
--●●●●●●●●●●●●●●●●●●●
-- FOR CUSTOM VALUE
-- EDIT ONLY THE QUOTED HEX BELOW
if [Link]().x64 then
custom="h00F0271E" -- x64
else
custom="h440744E3" -- x32
end
--●●●●●●●●●●●●●●●●●●●
--●●●●●●●●●●●●●●●●●●●

apex=0
[Link](false)
print("----------------------------------------------------------------------------
--")
print("APEX[GG]v2")
print("[Link]
print("[Xa]-EDIT-v09-APEX[GG]v2")
print(" ~HACKING IS THE GAME~")
print("----------------------------------------------------------------------------
--")
print("In Collaboration With:")
print("")
print(" DARK DEMON @DRAGON_SCRIPTER")
print(" [Link]
print("")
print(" The LEGEND: BlackStarX19")
print("----------------------------------------------------------------------------
--")
print(" + Knowledge Share")
print(" + HACKERS HOUSE:")
print(" [Link]/Hackers_House_YT_chat_group")
print("----------------------------------------------------------------------------
--")
[Link](true) [Link]("101.1") [Link](false)

ENEX=[Link]("APEX[GG]v2\n[Link]
n\nHacking is the Game","[ENTER]",nil,"<EXIT>")
if ENEX~=1 then [Link](true) [Link]() return end
[Link]("WELCOME")

v=[Link]()
if v.x64 then
xbit="x64"
xtrue={"h20","h00","h80","hD2","hC0","h03","h5F","hD6"} -- true
xfalse={"h00","h00","h80","hD2","hC0","h03","h5F","hD6"} -- false
xtrueah="200080D2"
 xfalseah="000080D2"
xah2="C0035FD6"
xopc1t="MOV X0, #0x1"
xopc1f="MOV X0, #0x0"
xopc2="RET"
xopc1int="MOV X0, #0x0"
xopci1flt="MOV X0, #0x0"
else
xbit="x32"
xtrue={"h01","h00","hA0","hE3","h1E","hFF","h2F","hE1"} -- true
xfalse={"h00","h00","hA0","hE3","h1E","hFF","h2F","hE1"} -- false
xtrueah="0100A0E3"
xfalseah="0000A0E3"
xah2="1EFF2FE1"
xopc1t="MOVW R0, #1"
xopc1f="MOVW R0, #0"
xopc2="BX LR"
xopc1int="MOVW R0, #0 "
xopc1flt="MOVT RO, #0"
end

GN=[Link]().label
GV=[Link]().versionName
print(GN.." "..xbit)
-- libz short [Link][]
-- xand xAPEXx
libresult=0

liblist = [Link]()
if #(liblist)==0 then
print("×× LIB ERROR #01 ××\nNo Libs Found\nTry a Different Virtual
Environment \nor Try a Better Game Installation Method\nor Download Game From
'[Link]' ")
[Link](true) [Link]()
end

xpk = [Link]
liblist = [Link](xpk.."*.so")
ll=1 listlib={} listname={}
for i, v in ipairs(liblist) do
if liblist[i].state=="Xa" then
listlib[ll]=liblist[i].name:gsub(".*/", "")
listname[ll]=liblist[i].name:gsub(".*/", "")
ll=ll+1
libresult=1
end
end -- loop liblist

xsapkx=1
if libresult==0 then
xsapk={}
liblist=[Link]()
for i, v in ipairs(liblist) do
if liblist[i].state=="Xa" and
[Link](liblist[i].name,"split_config") then
xsapk[xsapkx]=liblist[i]["end"]-liblist[i].start
xsapkx=xsapkx+1
listlib[ll]=liblist[i].name:gsub(".*/", "")
 listname[ll]=liblist[i].name:gsub(".*/", "")
ll=ll+1
libresult=2
end
end
end

if libresult==2 then
lislitb=nil listlib={}
APEXQ=[Link]([Link](xsapk))
for i, v in ipairs(liblist) do
if liblist[i].state=="Xa" and liblist[i]["end"]-liblist[i].start==APEXQ
then
listlib[1]=liblist[i].start
libresult=3
end
end
end

if libresult==2 then [Link]("Split Apk Detected\nScript Error\nUnable to

Locate Correct Start Address")
[Link](true) [Link]() return
end

if libresult==0 then
print("×× LIB ERROR #02 ××\nNo Libs Found\nTry a Different Virtual
Environment \nor Try a Better Game Installation Method\nor Download Game From
'[Link]' ")
[Link](true) [Link]() return
end

::CHLIB::
if libresult==1 then
xchlibx=0
listlibl=#(listlib)
chlib=[Link](
listlib,{},"APEX[GG]v2\n[Link] SELECT LIB ]>>")

if chlib==nil then [Link](true) [Link]() return end

for i, v in ipairs(listlib) do
if chlib[i] then xchlibx=1 end
end

if xchlibx==0 then goto CHLIB return end

for i, v in ipairs(listlib) do
if chlib[i] then
libzz=tostring(listlib[i])
xxzyzxx=[Link](libzz)
for c=1,#(xxzyzxx) do
if xxzyzxx[c].state=="Xa" then
liby=c
xand=[Link](libzz)[liby].start
libz=libzz
break
end
end
end
 end
end

if libresult==3 then
xand=listlib[1]
libz=tostring(listlib[1])
end

if libresult==1 then
liblib=libz
else
liblib="Split Apk"
end

auto=[Link](GN.."\n"..xbit.." v("..GV..")\n\nStart Address:\n "..liblib.."\n

"..[Link]("%X",xand),"YES","NO","<[ EXIT ]>")
if auto==3 then [Link](true) [Link]() return end
if auto==2 then goto CHLIB end

print("----------------------------------------------------------------------------
--")
--███████████████████████
--███████████████████████
--███████████████████████
[Link](gg.REGION_CODE_APP)
[Link]("Please Wait..")
[Link]()
xxabc=[Link](7)
xxx={} xxx[1]={}
xxx[1].address=xxabc
xxx[1].flags=4
xxx=[Link](xxx)

--███████████████████████
BOOL=5
xINTFLOAT=0
xARMHEX=0
xOPCODES=0
MENU3=0
--███████████████████████
--███████████████████████
--███████████████████████

po="" pv="" REVERT=0

if v.x64 then nrule="" else nrule="( x32 No Negative Value )" end

function menu()
if MENU3==1 then menu3() return end
if REVERT==1 then
po2=[Link]("%X",tonumber(po)+4)
if #(po2)>8 then
act2=(#(po2)-8)+1
po2=[Link](po2,act2)
end
hvalrev1=[Link]("%X",APEXREV[1].value)
if #(hvalrev1)>8 then
act01=(#(hvalrev1)-8)+1
hvalrev1=[Link](hvalrev1,act01)
end
 hvalrev2=[Link]("%X",APEXREV[2].value)
if #(hvalrev2)>8 then
act02=(#(hvalrev2)-8)+1
hvalrev2=[Link](hvalrev2,act02)
end

xrevert=[Link]({
"REVERT",
"COPY + REVERT",
"DONT REVERT",
"COPY + DONT REVERT"},0,"LAST EDIT REVERT VALUES = \n"..po.."
h"..hvalrev1.."\n0x"..po2.." h"..hvalrev2)
copyhval="'h"..hvalrev1.."'\n'h"..hvalrev2.."'"

if xrevert==1 or xrevert==2 then

[Link](APEXREV)
[Link]("[√] REVERTED")

print("----------------------------------------------------------------------------
--")
print("## REVERTED ##")
print(po)
print(copyhval)
if xrevert==2 then
[Link](copyhval, false)
[Link]("REVERT + COPY\n"..copyhval)
end

print("----------------------------------------------------------------------------
--")
end

if xrevert==4 then
[Link](copyhval, false)
[Link]("Copied to Clipboard\n"..copyhval)
end

end -- if REVERT

menu2()
end -- menu()

--███████████████████████

function menu2()
p=[Link]({
"Search Class Name / Field Offset", --1
"Enter Method 0xOFFSET", --2
"True", --3
"False", --4
"Max Pos + int/float", --5
"Max Neg - int/float", --6
"Custom = "..custom, --7
"Enter Value "..nrule, --8
"INT ( +/- 2147418112 )", --9
"FLOAT ( +/- 3.4e37 )", --10
"Script It (.lua) ", --11
"# Get ARM/HEX + Op Codes #", --12
"<< LINKS >>", -- 13
 "[ EXIT SCRIPT ]"}, --14
{[2]=po,
[8]=pv},
{[1]="checkbox",
[2]="number",
[3]="checkbox",
[4]="checkbox",
[5]="checkbox",
[6]="checkbox",
[7]="checkbox",
[8]="number",
[9]="checkbox",
[10]="checkbox",
[11]="checkbox",
[12]="checkbox",
[13]="checkbox",
[14]="checkbox"})
if p==nil then [Link]("CANCELLED") return end
if p[14] then [Link]("[ EXIT ]") [Link](true) [Link]() return end
if p[1] then MENU3=1 menu3() return end
if p[13] then CONTACT() return end
po=p[2]
pv=p[8]

if p[3] or p[4] then dump() return end

if p[5] or p[6] then

local mmif=[Link]({
"INT",
"FLOAT"},0,"MAX +/- INT or FLOAT")
if mmif==nil then [Link]("CANCELLED") return end
if mmif==1 and p[5] then MAXINT() return end
if mmif==2 and p[5] then MAXFLO() return end
if mmif==1 and p[6] then MININT() return end
if mmif==2 and p[6] then MINFLO() return end
return end

if p[7] then customhex() return end

if p[8]=="0" then p[4]=true dump() return end

if p[9] or p[10] then dumpV() return end

end -- menu2

--███████████████████████

function dump()

if p[2]=="" or #(p[2])==0 or type(tonumber(p[2]))~="number" then

[Link]("INVALID OFFSET") return end

po=p[2]
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

hx=1
while hx<=8 do
xdump=nil
xdump={}
xdump[2]={}
xdump[2].address=xand + o

if p[3] then
xdump[2].value = xtrue[hx]
end

if p[4] then
xdump[2].value = xfalse[hx]
end

xdump[2].flags=1
[Link](xdump)
o=o+1 hx=hx+1
end

if p[3] then
[Link]("[ TRUE : 1 ]")
BOOL=1 XVE=1 BITCHA1=xtrueah
xxx[1].flags=4 xxx[1].value=1 [Link](xxx)
end

if p[4] then
[Link]("[ FALSE : 0 ]")
BOOL=0 XVE=0 BITCHA1=xfalseah
xxx[1].flags=4 xxx[1].value=0 [Link](xxx)
end

BITXHA2=xah2
FLAGS="Bool"
CONVERT()
end -- dump

--███████████████████████

function MAXINT()

if p[2]=="" or #(p[2])==0 or type(tonumber(p[2]))~="number" then

[Link]("INVALID OFFSET") return end

po=p[2]
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={} xdump[2]={} xdump[3]={}

xdump[2].address=xand+o
xdump[2].flags=4
xdump[3].address=xand+(o+4)
xdump[3].flags=4
if v.x64 then
xdump[2].value="~A8 MOV X0, #0x7FFFFFFF"
xdump[3].value="~A8 RET"
else
xdump[2].value="~A MOVT R0, #32767 "
xdump[3].value="~A BX LR"
end
[Link](xdump)
xxx[1].flags=4 xxx[1].value=2147418112 [Link](xxx)
[Link]("2147418112 INT")
XVE="2147418112"
BOOL=3 FLAGS="INT"
CONVERT()
end
--███████████████████████

function MAXFLO()

if p[2]=="" or #(p[2])==0 or type(tonumber(p[2]))~="number" then

[Link]("INVALID OFFSET") return end

po=p[2]
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={} xdump[2]={} xdump[3]={}

xdump[2].address=xand+o
xdump[2].flags=4
xdump[3].address=xand+(o+4)
xdump[3].flags=4
if v.x64 then
xdump[2].value="~A8 MOV X0, #0x7F800000"
xdump[3].value="~A8 RET"
else
xdump[2].value="~A MOVT R0, #32640 "
xdump[3].value="~A BX LR"
end
[Link](xdump)
xxx[1].flags=4 xxx[1].value=2139095040 [Link](xxx)
[Link]("Infinity Float")
XVE="∞ [ Infinity ]"
BOOL=4 FLAGS="Float"
CONVERT()
end
--███████████████████████

function MININT()

if p[2]=="" or #(p[2])==0 or type(tonumber(p[2]))~="number" then

[Link]("INVALID OFFSET") return end

po=p[2]
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={} xdump[2]={} xdump[3]={}

xdump[2].address=xand+o
xdump[2].flags=4
xdump[3].address=xand+(o+4)
xdump[3].flags=4
if v.x64 then
xdump[2].value="~A8 MOV X0, #-0x80000000"
xdump[3].value="~A8 RET"
else
xdump[2].value="~A MOVT R0, #32768 "
xdump[3].value="~A BX LR"
end
[Link](xdump)
xxx[1].flags=4 xxx[1].value=-2147483648 [Link](xxx)
[Link]("-2,147,483,648 INT ")
XVE="-2147483648"
BOOL=3 FLAGS="INT"
CONVERT()
end

--███████████████████████

function MINFLO()

if p[2]=="" or #(p[2])==0 or type(tonumber(p[2]))~="number" then

[Link]("INVALID OFFSET") return end

po=p[2]
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={} xdump[2]={} xdump[3]={}

xdump[2].address=xand+o
xdump[2].flags=4
xdump[3].address=xand+(o+4)
xdump[3].flags=4
if v.x64 then
xdump[2].value="~A8 MOV X0, #0xFF7F0000"
xdump[3].value="~A8 RET"
else
xdump[2].value="~A MOVT R0, #65407 "
xdump[3].value="~A BX LR"
end
[Link](xdump)
xxx[1].flags=16 xxx[1].value="-9.18354962e-41" [Link](xxx)
[Link]("-3.38953139e38 Float")
XVE="-3.38953139e38"
BOOL=3 FLAGS="FLOAT"
CONVERT()
end

--███████████████████████

function customhex()

if p[2]=="" or #(p[2])==0 or type(tonumber(p[2]))~="number" then

[Link]("INVALID OFFSET") return end

po=p[2]
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1
if v.x64 then
xEND="hC0035FD6" -- RET
else
xEND="h1EFF2FE1" -- BX LR
end
xdump=nil xdump={} xdump[2]={} xdump[3]={}
xdump[2].address=xand+o
xdump[2].flags=4
xdump[2].value=custom
xdump[3].address=xand+(o+4)
xdump[3].flags=4
xdump[3].value=xEND
[Link](xdump)
[Link](" "..custom)
end

--███████████████████████

function dumpV()

if p[8]=="" or #(p[8])==0 then [Link]("INVALED NUMBER") menu() return end

-----------------
if p[9] then
vali=tonumber(p[8])
if type(vali)~="number" then
[Link]("Please Enter a Valid Number\nNumerical Digits Only (0~9)
","OK",nil,"APEX[GG]v2")
menu()
return
end

if v.x64 then
if tonumber(p[8])<-2147483648 or tonumber(p[8])>2147483648 then
[Link]("INT Value Must be between\n -2147483648 /
+2147483648","OK",nil,"APEX[GG]v2")
menu()
return
end
if tonumber(p[8])<-1 and tonumber(p[8])>-65534 then
[Link]("INT Negative Value is Limited \n[√] -1\n[√] x < -65534\n[x]
-2 ~ -65534\n\nSorry, but I still have a lot to learn","OK",nil,"APEX[GG]v2")
menu()
return
end
else
if tonumber(p[8])<0 or tonumber(p[8])>2000000000 then
[Link]("## SORRY ##\n\nNegative INT Values are Not supported for
32bit\nINT Value Must be between\n0 and 2,000,000,000","OK",nil,"APEX[GG]v2")
menu()
return
end
end -- x64

dumpVI()
return
end -- p7 INT
------------------

if p[10] then
if v.x64 then
if tonumber(p[8])<-340000000000000000000000000000000000000 or
tonumber(p[8])>340000000000000000000000000000000000000 then
[Link]("FLOAT Value Must be between\n-3.4e+37 /
+3.4+e37","OK",nil,"APEX[GG]v2")
menu()
return
end
else
if tonumber(p[8])<0 or
tonumber(p[8])>340000000000000000000000000000000000000 then
[Link]("FLOAT Value Must be Between\n0 and 3e+37\n\nFor Large Value,
Please Don't use (e+). Enter the full value. ie:\
n999999999999999999999999999999...","OK",nil,"APEX[GG]v2 ")
menu()
return
end
end -- x64
dumpVF()
return
end -- p8
--------------------
end -- dumpV

-- ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

function dumpVI()
if v.x64 then
if tonumber(p[8])<65535 and tonumber(p[8])>-65535 then
dumpVIa()
return
end
else
if tonumber(p[8])<65535 and tonumber(p[8])>=0 then
dumpVIa()
return
end
end

dumpVIb()
end -- dumpVI
--------------------------------------------------------------------------
function dumpVIa()

if not v.x64 then

if tonumber(p[8])<0 then
[Link]("# SORRY # \nThis script does NOT support -negative values for
32bit devices. \n\n-Negative Values ARE supported for 64bit
Only.","OK",nil,"APEX[GG]v2")
menu()
return
end
end

if v.x64 and tonumber(p[8])==0 and p[9] then

FLAGS="FLOAT" BOOL=2 ZERO()
return end

xHEX=[Link]("%X",tonumber(p[8]))
if #(xHEX)>8 then
act=(#(xHEX)-8)+1
xHEX=[Link](xHEX,act)
end
[Link]()
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={}
xdump[2]={} xdump[3]={}
xdump[2].address=xand + o
xdump[2].flags=4
xdump[3].address=xand +(o+4)
xdump[3].flags=4
if v.x64 then
xdump[2].value="~A8 MOV X0, #0x"..xHEX
xdump[3].value="~A8 RET"
else
xdump[2].value="~A MOVW R0, #"..p[8].." "
xdump[3].value="~A BX LR"
end
[Link](xdump)
xxx[1].flags=4 xxx[1].value=p[8] [Link](xxx)
[Link](p[8].." INT")
BOOL=4 FLAGS="INT"
XVE=tonumber(p[8])
if tonumber(p[8])==0 then BOOL=2 end
CONVERT()
end -- dumpVIa
-----------------------------------------------------------
function dumpVIb()
wait() clear()
[Link](xxx)
x=p[8] t=d edit()
o=0 t=w offset() x=0 edit()
o=2 t=w offset() acx1=[Link](1)
acx0=acx1[1].value-1
acx2=acx1[1].value+1
o=-2 t=d offset() acxd1=[Link](1)
o=2 t=w offset() x=acx0 edit()
o=-2 t=d offset() acxd0=[Link](1)
o=2 t=w offset() x=acx2 edit()
o=-2 t=d offset() acxd2=[Link](1)
ac=tonumber(p[8])/65535
XXS=acxd0[1].value
XXT=acxd1[1].value
XXL=acxd2[1].value
[Link]("APEX[GG]")
::STARTOVERI::
XXCH=[Link]({
XXS,
XXT,
XXL},0,"YOUR EDIT VALUE = "..p[8].."\nSelect New Available Edit Value")
if XXCH==nil then x=0 edit() clear() [Link]("CANCELLED") return end
if XXCH==1 then x=XXS ac=tonumber(XXS)/65535 end
if XXCH==2 then x=XXT ac=tonumber(XXT)/65535 end
if XXCH==3 then x=XXL ac=tonumber(XXL)/65535 end

if tonumber(x)==0 then FLAGS="INT" BOOL=2 ZERO() return end

 if not v.x64 and x<0 then
[Link]("# SORRY # \nThis script does NOT support -negative values for 32bit
devices. \n\n-Negative Values ARE supported for 64bit Only.","OK",nil,"APEX[GG]v2")
goto STARTOVERI
end

t=d edit()
acx=[Link](1) clear()
ach=[Link]("%X",tonumber(acx[1].value))
if #(ach)>8 then
act=(#(ach)-8)+1
ach=[Link](ach,act)
end

o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={}
xdump[2]={} xdump[3]={}
xdump[2].address=xand + o
xdump[2].flags=4
xdump[3].address=xand +(o+4)
xdump[3].flags=4
if v.x64 then
xdump[2].value="~A8 MOV X0, #0x"..ach
xdump[3].value="~A8 RET"
else
xdump[2].value="~A MOVT R0, #"..ac.." "
xdump[3].value="~A BX LR"
end
[Link](xdump)
xxx[1].flags=4 xxx[1].value=x [Link](xxx)
[Link](x.." INT")
BOOL=3 XVE=x
FLAGS="INT"
CONVERT()
end -- dumpVIb

-- ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

function dumpVF()

if v.x64 then
dumpVF64()
else
dumpVF32()
end

end -- dumpVF
--▓▓▓▓▓▓▓▓▓▓▓
function dumpVF64()
wait() clear()
[Link](xxx)
o=0 t=f offset()
x=p[8] t=f edit()
o=0 t=w offset() x=0 edit()
o=2 t=w offset() acx1=[Link](1)
acx0=acx1[1].value-1
acx2=acx1[1].value+1
o=-2 t=f offset() acxd1=[Link](1)
o=2 t=w offset() x=acx0 edit()
o=-2 t=f offset() acxd0=[Link](1)
o=2 t=w offset() x=acx2 edit()
o=-2 t=f offset() acxd2=[Link](1)
ac=tonumber(p[8])/65535
XXS=acxd0[1].value
XXT=acxd1[1].value
XXL=acxd2[1].value
[Link]("APEX[GG]")
XXCH=[Link]({
XXS,
XXT,
XXL},0,"YOUR EDIT VALUE = "..p[8].."\nSelect New Available Edit Value")
if XXCH==nil then x=0 edit() clear() [Link]("CANCELLED") return end
if XXCH==1 then x=XXS end
if XXCH==2 then x=XXT end
if XXCH==3 then x=XXL end

if tonumber(x)==0 then FLAGS="Float" BOOL=2 ZERO() return end

t=f edit() o=0 t=d offset()

acx=[Link](1) clear()
ach=[Link]("%X",tonumber(acx[1].value))
if #(ach)>8 then
act=(#(ach)-8)+1
ach=[Link](ach,act)
end

o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={}
xdump[2]={} xdump[3]={}
xdump[2].address=xand + o
xdump[2].flags=4
xdump[2].value="~A8 MOV X0, #0x"..ach
xdump[3].address=xand +(o+4)
xdump[3].flags=4
xdump[3].value="~A8 RET"
[Link](xdump)
[Link](x.." Float")
BOOL=3 FLAGS="Float"
XVE=x
CONVERT()
end -- dumpVF64

--▓▓▓▓▓▓▓▓▓▓▓
function dumpVF32()
wait() clear() [Link](xxx)
o=0 t=f offset()
x=p[8] t=f edit()
o=0 t=w offset() x=0 edit()
o=2 t=w offset() acx1=[Link](1)
if tonumber(acx1[1].value)<0 then
[Link]("# SORRY / ERROR #\n\n I haven't mastered 32bit op codes yet. \n
Unfortunately I am unable to properly format this float value. \n Please Enter a
different Value","OK",nil,"APEX[GG]v2")
clear() menu()
return
end
acx0=acx1[1].value-1
acx2=acx1[1].value+1
o=-2 t=f offset() acxd1=[Link](1)
o=2 t=w offset() x=acx0 edit()
o=-2 t=f offset() acxd0=[Link](1)
o=2 t=w offset() x=acx2 edit()
o=-2 t=f offset() acxd2=[Link](1)
XXS=acxd0[1].value
XXT=acxd1[1].value
XXL=acxd2[1].value
[Link]("APEX[GG]v2")
::STARTOVERF::
XXCH=[Link]({
XXS,
XXT,
XXL},0,"YOUR EDIT VALUE = "..p[8].."\nSelect New Available Edit Value")
if XXCH==nil then x=0 edit() clear() [Link]("CANCELLED") return end
if XXCH==1 then x=XXS end
if XXCH==2 then x=XXT end
if XXCH==3 then x=XXL end

if x<0 then
[Link]("# SORRY # \nThis script does NOT support -negative values for 32bit
devices. \n\n-Negative Values ARE supported for 64bit Only.","OK",nil,"APEX[GG]v2")
goto STARTOVERF
end

t=f edit() o=2 t=w offset()

XVAL=[Link](1)
if tonumber(XVAL[1].value)<0 then
[Link]("# SORRY / ERROR #\n\n I haven't mastered 32bit op codes yet. \n
Unfortunately I am unable to properly format this float value. \n Please Enter a
different Value","OK",nil,"APEX[GG]v2")
clear() menu()
return
end
clear()
XVAL=XVAL[1].value
o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

xdump=nil xdump={}
xdump[2]={} xdump[3]={}
xdump[2].address=xand+o
xdump[2].flags=4
xdump[2].value="~A MOVT R0, #"..XVAL.." "
xdump[3].address=xand+(o+4)
xdump[3].flags=4
xdump[3].value="~A BX LR"
[Link](xdump)
[Link](x.." Float")
BOOL=3 FLAGS="Float"
XVE=x
CONVERT()
end -- dumpVF32

--███████████████████████

function ZERO()
hx=1 o=tonumber(p[2])

APEXREV=nil
APEXREV={} APEXREV[1]={} APEXREV[2]={}
APEXREV[1].address=xand+o
APEXREV[1].flags=4
APEXREV[2].address=xand+(o+4)
APEXREV[2].flags=4
clear() [Link](APEXREV)
APEXREV=nil APEXREV=[Link](2)
clear() REVERT=1

while hx<=8 do
xdump=nil
xdump={}
xdump[2]={}
xdump[2].address=xand + o
xdump[2].value = xfalse[hx]
xdump[2].flags=1
[Link](xdump)
o=o+1 hx=hx+1
end
[Link]("0 "..FLAGS)
BOOL=2 XVE="0"
if FLAGS=="INT" then flgs=4 else flgs=16 end
xxx[1].flags=flgs xxx[1].value=0 [Link](xxx)
CONVERT()
end -- ZERO
--███████████████████████
function CONVERT()
PREP=nil CAHX1=nil CAHX2=nil XT=nil
PREP={} CAHX1={} CAHX2={}
SPACE=" "
XVE=[Link](XVE,"E","e")
o=tonumber(p[2])
PREP={}
PREP[1]=xbit.." "..GN.." "..GV
PREP[2]=libz
PREP[3]=SPACE
PREP[4]="Offset = "..p[2]
PREP[5]=SPACE
PREP[6]=FLAGS.." Value ="

if BOOL==0 then xbool=" [ False : 0 ]" end

if BOOL==1 then xbool=" [ True : 1 ]" end
if BOOL==2 then xbool=" [ Zero ]" end
if BOOL>=3 then xbool="" end
PREP[7]=SPACE..XVE..xbool
PREP[8]=SPACE
if v.x64 then
PREP[9]="ARM64 ="
else
PREP[9]="ARM ="
end

if BOOL>2 then
clear()
o=tonumber(p[2])
FUCK={} FUCK[1]={} FUCK[2]={} FUCK[3]={} FUCK[4]={}
FUCK[1].address=xand+o
FUCK[1].flags=1
FUCK[2].address=(xand+o)+1
FUCK[2].flags=1
FUCK[3].address=(xand+o)+2
FUCK[3].flags=1
FUCK[4].address=(xand+o)+3
FUCK[4].flags=1
[Link](FUCK)
shit=[Link](4)
clear()
for i = 1,4 do
fuck=[Link]("%X",tonumber(shit[i].value))
if #(fuck)>2 then
subt=(#(fuck)-2)+1
fuck=[Link](fuck,subt)
end
if #(fuck)==0 then fuck="00"..fuck end
if #(fuck)==1 then fuck="0"..fuck end
CAHX1[i] = fuck
end -- for loop
CAHX1=[Link](CAHX1)
end -- BOOL>2

-- [Link](CAHX1)
BASS=CAHX1
if BOOL==1 then BASS=xtrueah end
if BOOL==0 then BASS=xfalseah end
 if BOOL==2 then BASS=xfalseah end

PREP[10]=SPACE..BASS
PREP[11]=SPACE..xah2
PREP[12]=SPACE
if v.x64 then
if FLAGS=="False" or BOOL==2 then
warning=" ( GG Errors 'MOV..#0x0' ) "
else
warning=""
end
else
warning=""
end
PREP[13]="Op Codes ="..warning

if BOOL>=3 then
if v.x64 then
AAA=[Link](tostring(xdump[2].value),"~A8 ","")
else
AAA=[Link](tostring(xdump[2].value),"~A ","")
end
PREP[13]=SPACE..AAA
end

if BOOL==2 then
if FLAGS=="INT" then
PREP[14]=SPACE..xopc1int
else
PREP[14]=SPACE..xopc1flt
end
end

if BOOL<=1 then
if FLAGS=="False" then
PREP[14]=SPACE..xopc1f
else
PREP[14]=SPACE..xopc1t
end
end

PREP[15]=SPACE..xopc2
APEXGG=[Link](PREP,"\n")
APEXAH={}
APEXAH[1]=BASS
APEXAH[2]=xah2
APEXAH=[Link](APEXAH,"\n")
APEXOP={}
APEXOP[1]=[Link](PREP[13]," ","")
APEXOP[2]=[Link](PREP[15]," ","")
APEXOP=[Link](APEXOP,"\n")
APEXTT={}
APEXTT[1]=libz
APEXTT[2]=p[2]
APEXTT[3]=APEXAH
APEXTT[4]=APEXOP
APEXTT=[Link](APEXTT,"\n")
print(" ")
print("-------------------------APEX[GG]v2-------------------------")
print(" ")
print(APEXGG)

if p[12] then
[Link]("APEX[GG]")
[Link](APEXGG,"OK",nil,"APEX[GG]v2")
ZBMP=[Link]({
"A- "..libz,
"B- "..p[2],
"C- Arm/Hex",
"D- Op Codes",
"E- [ A, B, C, D ]",
"F- Everything"},0,"COPY TO CLIPBOARD:")

if ZBMP==1 then [Link](libz) [Link]("COPIED\n"..libz) end

if ZBMP==2 then [Link](p[2]) [Link]("COPIED\n"..p[2]) end
if ZBMP==3 then [Link]('"h'..BASS..'"') [Link]("COPIED\n"..APEXAH)
end
if ZBMP==4 then [Link](APEXOP) [Link]("COPIED\n"..APEXOP) end
if ZBMP==5 then [Link](APEXTT) [Link]("COPIED\n"..APEXTT) end
if ZBMP==6 then [Link](APEXGG) [Link]("COPIED\n"..APEXGG) end
end -- p10

scriptit()

end -- CONVERT
--███████████████████████

function scriptit()
if libresult~=1 then [Link]("×× SCRIPT IT ××\nScrip it is Not Available for
Split Apk","OK",nil,"APEX[GG]V2")
return
end

S=nil S={}
S[1]="LibStart=[Link]('"..libzz.."')["..liby.."].start"
S[2]="APEXGG=nil"
S[3]="APEXGG={}"
S[4]="APEXGG[1]={}"
S[5]="APEXGG[2]={}"
S[6]="APEXGG[1].address=LibStart+"..p[2]
S[7]="APEXGG[1].value='h"..BASS.."'"
S[8]="APEXGG[1].flags=4"
S[9]="APEXGG[2].address=LibStart+("..p[2].."+0x4)"
S[10]="APEXGG[2].value='h"..xah2.."'"
S[11]="APEXGG[2].flags=4"
S[12]="[Link](APEXGG)"
SI=[Link](S,"\n")
print(" ")
print(SI)
if p[11] then
XSIX=[Link](SI,"YES","NO","COPY ?")
if XSIX==1 then
[Link](SI,false)
[Link]("COPIED...\n"..SI)
else
 [Link]("CANCELLED")
end
end --p9
end -- scriptit

--███████████████████████
--███████████████████████

function CONTACT()
CONT=[Link]({
"Telegram- APEX[GG]v2",
"Telegram- Hackers House",
"Telegram- BlackStarX19",
"Telegram- Dragon Hackz",
"Telegram- Lover1500"},0,"TAP TO COPY LINK TO CLIPBOARD")
if CONT==nil then menu() return end
if CONT==1 then [Link]("[Link] [Link]("Link
Copied") end
if CONT==2 then [Link]("[Link]
[Link]("Link Copied") end
if CONT==3 then [Link]("[Link]
[Link]("Link Copied") end
if CONT==4 then [Link]("[Link] [Link]("Link
Copied") end
if CONT==5 then [Link]("[Link] [Link]("Link
Copied") end
menu2()
end -- CONTACT
--█████████████████████
--█████████████████████
--█████████████████████
b = gg.TYPE_BYTE
d = gg.TYPE_DWORD
e = gg.TYPE_DOUBLE
f = gg.TYPE_FLOAT
w=gg.TYPE_WORD

function offset()
[Link]([Link]())
local results = [Link]([Link]())
for i, p in ipairs(results) do
results[i].address = results[i].address + o
results[i].flags = t
end
[Link](results)
[Link]([Link]())
end

function wait()
[Link]("Please Wait.. ")
end

function clear()
[Link]([Link]())
[Link]()
end
function search()
[Link]([Link]())
[Link]()
[Link](x,t)
end

function edit()
[Link]([Link]())
[Link](x,t)
end

function get()
[Link]([Link]())
end

function check()
[Link]([Link]())
local check = [Link]()
if check == 0 then
[Link]("× ERROR ×")
E = 0 else E = 1
end
cnt = check
end

--███████████████████████
--███████████████████████
--███████████████████████

xemu3=0
ICN="APEX[GG]v2"
IOX="0x"
ECN="Enter Class Name"
xECN=0
EOS="0x"
xEOS=0
EVT="Select Value Type"
xEVT=0
ERT="ANONYMOUS (A)"
xACO=gg.REGION_ANONYMOUS
ON="[√] "
OFF="[×] "
xSx=OFF

function menu3()
if xemu3==0 then
[Link]("Class Name Search is for UNITY Only\nPress the [Sx] Button for
Menu","OK",nil,"APEX[GG]V2")
xemu3=1
end

if xECN==1 and xEOS==1 and xEVT==1 then xSx=ON end

if #(ECN)==0 then ECN="Enter Class Name" xECN=0 end
if #(EOS) ==0 then EOS="Enter 0xOffset" xEOS=0 end
xchx=[Link]({
ECN,
EOS,
EVT,
ERT,
 xSx.."START",
"<[ BACK ]>"},0,"APEX[GG]v2\n[Link] Name Field
Offset")

if xchx==nil then [Link]("CANCELLED") return end

[Link]()
[Link](true)
if xchx==1 then enterclassname() return end
if xchx==2 then enteroffset() return end
if xchx==3 then selectvaluetype() return end
if xchx==4 then selectrange() return end
if xchx==5 then START() return end
if xchx==6 then [Link](false) MENU3=0 apex=0 [Link]() menu2()
return end
end

--███████████████████████

function enterclassname()
input=[Link]({"Paste / Enter Class Name"},{[1]=ECN},{[1]="text"})
if input==nil then menu3() return end
if #(input[1])==0 then [Link]("INCOMPLETE") xECN=0 enterclassname() return end
ECN=tostring(input[1])
if [Link](ECN,"%s") then [Link]("Class Name [×/√]\n\n× No Spaces ' '\n\n√
Underscore _\n√ AlphaNumeric Characters Only\n√ aA~zZ
0~9","OK",nil,"APEX[GG]V2") xECN=0 enterclassname() return end
xslen=#(tostring(ECN))
for i=1,xslen do
x=nil x=[Link](tostring(ECN),i)
if x==46 then
[Link]("Class Name [×/√]\n\n× No Periods ' . '\n\n√ Underscore _\n√
AlphaNumeric Characters \n√ aA~zZ 0~9","OK",nil,"APEX[GG]V2")
xECN=0
enterclassname() return
end
end
xECN=1
menu3()
return
end

--███████████████████████

function enteroffset()
input2=[Link]({"Paste / Enter 0xOffset"},{[1]=EOS},{[1]="number"})
if input2==nil then menu() return end
if #(input2[1])<3 then xEOS=0 [Link]("INCOMPLETE") enteroffset() return end
if type(tonumber(input2[1]))~="number" then [Link]("INVALID NUMBER") xEOS=0
enteroffset() return end
EOS=input2[1]
xEOS=1
menu3()
return
end

--███████████████████████

function selectvaluetype()
ggtype=[Link]({
 "Byte / Bool ",
"Word ",
"Dword / INT",
"Float",
"Qword",
"Double"},0,"APEX[GG]v2\nSELECT VALUE TYPE_")
if ggtype==nil then menu3() return end
if ggtype==1 then tz=1 EVT="Byte / Bool" end
if ggtype==2 then tz=2 EVT="Word" end
if ggtype==3 then tz=4 EVT="Dword / INT" end
if ggtype==4 then tz=16 EVT="Float" end
if ggtype==5 then tz=32 EVT="Qword" end
if ggtype==6 then tz=64 EVT="Double" end
xEVT=1
menu3()
return
end

--███████████████████████

function selectrange()
input3=[Link]({
"ANONYMOUS (A)",
"C_ALLOC (Ca)",
"OTHER (O)"},0,"APEX[GG]v2\nSELECT REGION")
if input3==nil then menu3() return end
if input3==1 then ERT="ANONYMOUS (A)" xACO=gg.REGION_ANONYMOUS end
if input3==2 then ERT="C_ALLOC (Ca)" xACO=gg.REGION_C_ALLOC end
if input3==3 then ERT="OTHER (O)" xACO=gg.REGION_OTHER end
menu3()
return
end

--███████████████████████

function START()
if xSx==OFF then
[Link]("Please Complete All Information:\nClass Name\n0xOffset\nValue Type\
nRegion","MENU",nil,"APEX[GG]v2")
menu3() return
end
SEARCH()
end

--███████████████████████

function SEARCH()
[Link](true) [Link](200)
[Link]("Please Wait..")
[Link]()
[Link](gg.REGION_OTHER | gg.REGION_C_ALLOC)
[Link](":"..ECN,1)

if [Link]()==0 then
gl=[Link]()
xerror=[Link]("×× ERROR "..gl.." ××\n"..ECN.."\nNot
Found","OK","MENU","APEX[GG]V2")
if xerror==2 then menu3() return end
return
 end

x=nil x=[Link](1)
[Link]([Link]())
[Link](tonumber(x[1].value),1)
x=nil x=[Link]([Link]())
[Link]()
for i, v in ipairs(x) do
x[i].address=x[i].address-1
x[i].flags=1
end
x=[Link](x)
a={} aa=1
for i, v in pairs(x) do
if x[i].value==0 then
a[aa]={}
a[aa].address=x[i].address
a[aa].flags=1
aa=aa+1
end
end

if #(a)==0 then
[Link]()
gl=[Link]()
xerror=[Link]("×× ERROR "..gl.." ××\nClass Name With Pointer Not
Found","OK","MENU","APEX[GG]V2")
x=nil a=nil aa=nil
if xerror==2 then menu3() return end
return
end

x=nil
for i, v in ipairs(a) do
a[i].address=a[i].address+#(ECN)+1
a[i].flags=1
end
a=[Link](a)
ba=nil ba={} bb=1
for i, v in ipairs(a) do
if a[i].value==0 then
ba[bb]={}
ba[bb].address=a[i].address
ba[bb].flags=1
bb=bb+1
end
end

if #(ba)==0 then
[Link]()
gl=[Link]()
xerror=[Link]("×× ERROR "..gl.." ××\nClass Name With Pointer Not
Found","OK","MENU","APEX[GG]V2")
x=nil a=nil aa=nil ba=nil bb=nil
if xerror==2 then menu3() return end
return
end

a=nil
 for i, v in ipairs(ba) do
ba[i].address=ba[i].address-#(ECN)
ba[i].flags=1
end
[Link](ba)

[Link](0)

if [Link]()==0 then
[Link]()
gl=[Link]()
xerror=[Link]("×× ERROR "..gl.." ××\nNo Pointer Results From Class
Name","OK","MENU","APEX[GG]V2")
ba=nil
if xerror==2 then menu3() return end
return
end

x=[Link]([Link]())
[Link]()
if v.x64 then o1=48 o2=56 o3=-8 o4=16 vt=32 else o1=24 o2=28 o3=-4 o4=-8 vt=4 end
error=0
::xTRYAGAINx::
y=nil y={} z=nil z={}
for i, v in ipairs(x) do
y[i]={}
y[i].address=x[i].address+o1
y[i].flags=vt
z[i]={}
z[i].address=x[i].address+o2
z[i].flags=vt
end
y=[Link](y)
z=[Link](z)
p=nil p={} xx=1
for i, v in ipairs(y) do
if y[i].value==z[i].value and #(tostring(y[i].value))>=8 then
p[xx]=y[i].value
xx=xx+1
end
end
xx=nil y=nil z=nil

if #(p)==0 and error==0 then

if v.x64 then o1=32 o2=40 else o1=16 o2=20 end
error=2
goto xTRYAGAINx
end

if #(p)==0 and error==2 then

gl=[Link]()
xerror=[Link]("×× ERROR "..gl.." ××\nClass Name Header Value Not
Found","OK","MENU","APEX[GG]V2")
x=nil
if xerror==2 then menu3() return end
return
end

[Link](xACO)
[Link]() xxzx=1
for i, v in ipairs(p) do
[Link]("Please Wait...")
[Link](tonumber(p[i]),vt)
o=o3 t=vt offset() xshit=tonumber(p[i]) refinenot()
o=o4 offset() refinenot() o=o3 offset()
xx=nil xx=[Link]([Link]())
if [Link]()~=0 then
[Link]()
for q=1,#(xx) do
xx[q].name="APEX[GG]v2"
end
[Link](xx)
xxzx=xxzx+1
end
[Link]()
end
x=nil p=nil xx=nil q=nil

if xxzx==1 then
[Link]()
gl=[Link]()
xerror=[Link]("×× ERROR "..gl.." ××\nNo Class Name Header Value Found in
Region (A)\n\nMaybe This Function Hasn't Propigated Yet.","OK","MENU","APEX[GG]V2")
if xerror==2 then menu3() return end
xxzx=nil return
end

[Link](false)
xxzx=nil
load={} remove={} xx=1
x=[Link]()
for i, v in ipairs(x) do
if x[i].name=="APEX[GG]v2" then
load[xx]={}
load[xx].address=x[i].address+tonumber(EOS)
load[xx].flags=tz
remove[xx]={}
remove[xx]=x[i]
xx=xx+1
end
end
load=[Link](load)
[Link](load)

if [Link]()==0 then
for i, v in ipairs(load) do
load[i].address=load[i].address
load[i].flags=1
end
[Link](load)
[Link]("## NOTICE ##\n\n × Value Type '"..EVT.."' is Not Valid at Offset
'"..tostring(EOS).."'\n\n √ Value Type 'Byte' Has Been Loaded
Instead","OK","APEX[GG]V2")
end

[Link](remove)
[Link]("SUCCESS")
[Link](true)

end -- search

--███████████████████████

function refinenot()
[Link](xshit,t,false,gg.SIGN_NOT_EQUAL)
end

--███████████████████████
--███████████████████████
--███████████████████████

while true do

if [Link]() or apex==0 then

apex=1 [Link](false)
[Link]("APEX[GG]v2")
menu()
end

if MENU3==1 then
while true do
if apex==0 then apex=1 break end
if [Link]() then
menu3()
end
end
end

end