PennyFlo

LUA = 'WILS2M'
GLabel = 'Penny & Flo'
GProcess = 'dk.tactile.mansionstory'
GVersion = '(vAU.02)'
xbit = 64
LibResult = 1
xlib = 'libil2cpp.so'
xREV = 1  I={}
xCNE = 1
xSSE = 1
XbitX = 1
printx = '---------------------------------------------------------------'
expire='free'
print(printx)
xTAGx = 'wils2m'
print(xTAGx)
xMOTOx = 'Have fun'
print(xMOTOx)
xLINKx="https://t.me/HxE_Chat"
xLINK1x="https://www.tiktok.com/@hxesq"
print(xLINKx)
print(xLINK1x)
print(LUA)
print(GLabel..'  '..GVersion)
--███████████████████████
--███████████████████████
--███████████████████████
-- APEX[GG]v2
apex=1
gg.setVisible(false)
v=gg.getTargetInfo()
    if v==nil then
        print("×× ERROR ××\n×× INVALID PROCESS SELECTED / OR NO ROOT ACCESS")
        gg.setVisible(true) os.exit()
        return
    end

HxEmenu = ('            ⚡HxE Menu by wils2m⚡\
           ❦ ════ •⊰❂ - ❂⊱• ════ ❦\
                     ⛥🇮‌🇳‌🇫‌🇴‌⛥\
  🎮🅖🅐🅜🅔🎮 : '..GLabel..'\
  🎰🅥🅔🅡🅢🎰 : '..GVersion..'\
    🎰🅐🅡🅜🎰   : '..xbit..'\
\
⏳Exᴘɪʀᴇᴅ Date⏳ : '..expire..'\
 🎁 Encryption 🎁 :  '..expire..'\
            ❦ ════ •⊰❂ - ❂⊱• ════ ❦')

gg.alert(HxEmenu)

gg.alert("                           Patch Note\
           ❦ ════ •⊰❂ - ❂⊱• ════ ❦\
- NEW V.4\
- Level hack\
- No Ads\
................................................\
- HxE script menu\
- Auto update implemented\
- Auto win\
- Free Stars\
- No tutorials\
- Battlepass activated\
- Coins hack\
            ❦ ════ •⊰❂ - ❂⊱• ════ ❦\
")

A={} for i = 1,100 do A[i]={} end

------------------------------------------------------------------------------
gg.setRanges(gg.REGION_ANONYMOUS)
------------------------------------------------------------------------------
OFF="× " ON="√ "
AWT=OFF FT=OFF CS=OFF NT=OFF SP=OFF NA=OFF
CV="" LV=""

function menu()
apex=0
gg.toast(xTAGx)
gg.setRanges(gg.REGION_ANONYMOUS)
mc=gg.multiChoice({
    AWT.."Auto-Win Tile Game",
    NT.."No Tutorials",
    FT.."Free Tasks",
    SP.."Season Pass",
    NA.."No Ads",
    "Coins",
    "Level",
    "[ EXIT ]"},
    {},xTAGx.."\n"..xLINKx.."\n"..GLabel.." "..GVersion.." "..xBITx)

    if mc==nil then cancel() return end
    if mc[1] then autowintile() end
    if mc[2] then tutorials() end
    if mc[3] then freetasks() end
    if mc[4] then seasonpass() end
    if mc[5] then noads() end
    if mc[6] then coins() end
    if mc[7] then level() end


xhaX={
    AWT.."Auto-Win Tile Game",
    NT.."No Tutorials",
    FT.."Free Tasks",
    SP.."Season Pass (Activate --> Play --> Restart Game)",
    NA.."No Ads",
    "Coins"..CV,
    "Level"..LV,
    }
xhaX=table.concat(xhaX, "\n")
xhaX=tostring(xhaX)

    if mc[8] then exit() return end

gg.toast("[√] Complete")
gg.alert(GLabel.." "..GVersion.." "..xBITx.."\n\n"..xhaX,"OK",nil,xTAGx)

end
--███████████████████████
-- public class CollectSlotAssignSystem : System // TypeDefIndex:
-- public bool get_IsGoalComplete() { }
A[1].class="CollectSlotAssignSystem"
A[1].method="get_IsGoalComplete"

function autowintile()
x=1
if A[1].error==1 then error() return end
    for i = A[1].start, A[1].finish do o=I[i]
        if AWT==OFF then arm() else revert() end
    end
    if AWT==OFF then AWT=ON else AWT=OFF end
end

--███████████████████████
-- public class NormalLevel : BlastLevel // TypeDefIndex:
-- public override bool get_HasTutorial() { }
A[2].method="get_HasTutorial"

function tutorials()
x=0
if A[2].error==1 then error() return end
    for i = A[2].start, A[2].finish do o=I[i]
        if NT==OFF then arm() else revert() end
    end
    if NT==OFF then NT=ON else NT=OFF end
end

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

-- public class TaskInfo : ITaskInfo // TypeDefIndex:
-- public int get_StarsRequired() { }
A[3].class="TaskInfo"
A[3].method="get_StarsRequired"

function freetasks()
x=0
if A[3].error==1 then error() return end
    for i = A[3].start, A[3].finish do o=I[i]
        if FT==OFF then arm() else revert() end
    end
    if FT==OFF then FT=ON else FT=OFF end
end

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

--// Namespace: TactileModules.SeasonPass
--public class SeasonPassInstanceCustomData : FeatureInstanceCustomData
-- public bool get_SeasonPassPurchased() { }
A[4].method="get_SeasonPassPurchased"

--public int get_AccumulatedPoints()
--0xE11598

function seasonpass()
x=1
if A[4].error==1 then error() return end
    for i = A[4].start, A[4].finish do o=I[i]
        if SP==OFF then arm() else revert() end
    end
    if SP==OFF then SP=ON else SP=OFF end
end

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

-- public abstract class SpecialOfferBase : ISpecialOfferBase // TypeDefIndex:
-- public bool IsActivated() { }
A[5].class="SpecialOfferBase"
A[5].method="IsActivated"
A[6].class="SpecialOfferBase"
A[6].method="Activate"

function noads()
if A[5].error==1 or A[6]==1 then error() return end
x=0
    for i = A[5].start, A[6].finish do o=I[i]
        if NA==OFF then arm() else revert() end
    end
    if NA==OFF then NA=ON else NA=OFF end
end
--███████████████████████

function coins()
clear() wait()
x="17179869184;31244010177691652;30962698417012803;7209065::29"
t=32 search() x=31244010177691652 refine()
check() if E==0 then error() return end
o=-16 offset() wait() gg.searchPointer(0)
check() if E==0 then error() return end
o=8 t=4 offset()
check() if E==0 then error() return end

::CPROMPT::
    cp=gg.prompt({
    "How Many Coins Do You Have?",
    "How Many Coins Do You Want?"})
    if cp==nil then clear() cancel() return end
    if #(cp[1])==0 then gg.alert("×× Data Incomplete ××","OK",nil,xTAGx) goto CPROMPT end
    if #(cp[2])==0 then gg.alert("×× Data Incomplete ××","OK",nil,xTAGx) goto CPROMPT end
    if type(tonumber(cp[1]))~="number" then gg.alert("×× Data Incorrect ××","OK",nil,xTAGx) goto CPROMPT end
    if type(tonumber(cp[2]))~="number" then gg.alert("×× Data Incorrect ××","OK",nil,xTAGx) goto CPROMPT end
    if tonumber(cp[2])>2000000000 then gg.alert("×× NO MORE THAN 2,000,000,000 ××","OK",nil,xTAGx) goto CPROMPT end

x=tonumber(cp[1]) refine()
check() if E==0 then clear() error() return end
x=tonumber(cp[2]) edit() clear()
gg.alert("Coins = "..x.."\nEarn Coins to See Changes","OK",nil,xTAGx)
CV=" = "..x
end

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

-- public class PersistableState : IPersistableState<PersistableState>, IPersistableState // TypeDefIndex:
-- PersistableState
-- private string <LastLevelSessionId>k__BackingField; // 0x10

function level()
LA=gg.alert("##  LEVEL  ##\nUse Only if Above Level 10\n2,000,000,000 is MAX Level Edit\nDo NOT Exceed the Max Level For Game, Check Leaderboard for Current Version Max Level.\n\n## It is a Long Search,  Please Wait..","OK","CANCEL",xTAGx)
    if LA==2 then cancel() return end
::LEVEL::
lvp=gg.prompt({"Current Level","Level You Want"})
    if lvp==nil then cancel() return end
    if #(lvp[1])==0 then goto LEVEL return end
    if #(lvp[2])==0 then goto LEVEL return end
    if type(tonumber(lvp[1]))~="number" then goto LEVEL return end
    if type(tonumber(lvp[2]))~="number" then goto LEVEL return end
    lvn1=tonumber(lvp[1])-1
    lvn2=tonumber(lvp[2])-1
    if lvn1<10 or lvn1>2000000000 then error() goto LEVEL return end
    if lvn2<10 or lvn2>2000000000 then error() goto LEVEL return end

clear() wait() x="PersistableState" o=0x10 t=4 class()
x=lvn1 refine() check() if E==0 then error() return end
x=lvn2 edit() clear() LV=" = "..lvn2+1
end

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

--███████████████████████
--███████████████████████
--███████████████████████
    if v.processName~=GProcess then
        print("This Script is For:\n    "..GLabel.."\n    "..GProcess.."\nYou Selected:\n    "..v.label.."\n    "..v.processName)
        gg.setVisible (true) os.exit()
        return
    end
------------------------------------------------------------------------------
    if v.x64 then bitx=64 xBITx="[x64]" else bitx=32 xBITx="[x32]" end
        print(xBITx)
        print(printx)
------------------------------------------------------------------------------
    if XbitX==1 then
        if bitx~=xbit then
            print("This Script is For "..xbit.."bit Process\nYour Process is "..bitx.."bit")
            gg.setVisible(true) os.exit()
            return
        end
    end

--███████████████████████
    if LibResult==1 then
    xAPEXx={} xXx=0
    xLibRes=0
    libx=gg.getRangesList()
        if #(libx)==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 'apkcombo.com' ")
        gg.setVisible(true)
        os.exit()
        end
    libx=gg.getRangesList(xlib)
        if #(libx)==0 then
        print("×× No "..xlib.." Found")
        xLibRes=2
        goto APEX_SPLIT
        end
    xlibn=0
        for i, v in ipairs(libx) do
            if libx[i].state=="Xa" then
            xXx=xXx+1
            xAPEXx[xXx]=libx[i].start
            xLibRes=1
            end
        end
        if xLibRes==0 then
        print("×× LIB ERROR #03 ××\nNo "..xlib.." Found in Xa\nTry a Different Virtual Environment \nor Try a Better Game Installation Method\nor Download Game From 'apkcombo.com' ")
        gg.setVisible(true)
        os.exit()
        end

        ::APEX_SPLIT::
        if xLibRes==2 then
        splitapk=0
        libx=gg.getRangesList()
            for i, v in ipairs(libx) do
                if libx[i].state=="Xa" and string.match(libx[i].name,"split_config") then
                splitapk=1
                end
            end
            if splitapk==1 then
            xsapk={} xsapkx=0
                for i, v in ipairs(libx) do
                    if libx[i].state=="Xa" then
                    xsapkx=xsapkx+1
                    xsapk[xsapkx]=libx[i]["end"]-libx[i].start
                    end
                end
                if xsapkx~=0 then
                APEXQ=math.max(table.unpack(xsapk))
                    for i, v in ipairs(libx) do
                        if libx[i].state=="Xa" and libx[i]["end"]-libx[i].start==APEXQ then
                        xXx=xXx+1
                       xAPEXx[xXx]=libx[i].start
                        print("√√ Split Apk Lib Found\n√√ "..libx[i].name)
                        xLibRes=1
                        end
                    end
                end
            end

             if splitapk==0 and xLibRes~=1 then
             print("×× No split_config Lib Found")
             xc=1 xt={}
             libx=gg.getRangesList()
                 for i, v in ipairs(libx) do
                     if libx[i].state=="Xa" then
                     xt[xc]=tonumber(libx[i]["end"]-libx[i].start)
                     xc=xc+1
                     end
                 end
             APEXQ=math.max(table.unpack(xt))
                 for i, v in ipairs(libx) do
                     if libx[i].state=="Xa" and libx[i]["end"]-libx[i].start==APEXQ then
                     xXx=xXx+1
                     xAPEXx[xXx]=libx[i].start
                     print("√√ math.max Xa Lib Found\n√√ "..libx[i].name)
                     xLibRes=1
                     end
                 end
            end

            if xLibRes~=1 then
            print("×× Correct Lib Not Found ××\n×× Direct/Split Config/Xa Max ××")
            gg.setVisible(true)
            os.exit()
             return
            end
        end
    end
--███████████████████████
function arm()
o=tonumber(o)
    for XxX=1,#(xAPEXx) do
        xdump=nil xdump={}
        if type(x)~="table" then
        xdump[1]={} xdump[2]={}
        xdump[1].address=xAPEXx[XxX] + o
        xdump[1].flags=4
            if x==0 then xdump[1].value=xfalse end
            if x==1 then xdump[1].value=xtrue end
            if x~=0 and x~=1 then xdump[1].value=x end
        xdump[2].address=xAPEXx[XxX]+(o+4)
        xdump[2].flags=4
        xdump[2].value=xEND
        else
        cc=0
            for c=1,#(x) do
            xdump[c]={}
            xdump[c].address=xAPEXx[XxX]+o+cc
            xdump[c].flags=4
            xdump[c].value=tostring(x[c])
            cc=cc+4
            end
        end
    gg.setValues(xdump)
    end
end
------------------------------------------------------------------------------
function revert()
    for XxX=1,#(xAPEXx) do
    REVERT=nil REVERT={} xRx=nil xRx=1
        for i, v in ipairs(ORIG) do
            if tonumber(xAPEXx[XxX]+o)==ORIG[i].address then
                if type(x)~="table" then
                    REVERT[xRx]={}
                    REVERT[xRx].address=xAPEXx[XxX]+o
                    REVERT[xRx].flags=4
                    REVERT[xRx].value=ORIG[i].value
                    xRx=xRx+1
                    REVERT[xRx]={}
                    REVERT[xRx].address=xAPEXx[XxX]+o+4
                    REVERT[xRx].flags=4
                    REVERT[xRx].value=ORIG[i+1].value
                    xRx=xRx+1
                else
                offcnt=0 tnuc=0
                    for dfg=1,#(x) do
                    REVERT[xRx]={}
                    REVERT[xRx].address=xAPEXx[XxX]+o+offcnt
                    REVERT[xRx].flags=4
                    REVERT[xRx].value=ORIG[i+tnuc].value
                    offcnt=offcnt+4 tnuc=tnuc+1 xRx=xRx+1
                    end
                end
            gg.setValues(REVERT)
            break
            end
            -- xRx+1
        end
    end
end
--███████████████████████
if v.x64 then
xtrue="h200080D2" -- MOV X0, #0x1
xfalse="h000080D2" -- MOV X0, #0x0
xEND="hC0035FD6" -- RET
else
xtrue="h0100A0E3" -- MOVW R0, #1
xfalse="h0000A0E3" -- MOVW R0, #0
xEND="h1EFF2FE1" -- BX LR
end

--███████████████████████
b=1 w=2 d=4 f=16 q=32 e=64

------------------------------------------------------------------------------

function class()
gg.clearResults()
gg.setRanges(gg.REGION_OTHER | gg.REGION_C_ALLOC)
gg.searchNumber(":"..x,1)
    if gg.getResultsCount()==0 then E=0 return end
apexu=nil apexu=gg.getResults(1)
gg.getResults(gg.getResultsCount())
gg.refineNumber(tonumber(apexu[1].value),1)
apexu=nil apexu=gg.getResults(gg.getResultsCount())
gg.clearResults()
    for i, v in ipairs(apexu) do apexu[i].address=apexu[i].address-1 apexu[i].flags=1
    end
apexu=gg.getValues(apexu) apexa={} apexaa=1
    for i, v in pairs(apexu) do
        if apexu[i].value==0 then
        apexa[apexaa]={} apexa[apexaa].address=apexu[i].address apexa[apexaa].flags=1 apexaa=apexaa+1
        end
    end
if #(apexa)==0 then gg.clearResults() E=0 return end
u=nil
    for i, v in ipairs(apexa) do apexa[i].address=apexa[i].address+#(x)+1 apexa[i].flags=1
    end
apexa=gg.getValues(apexa) apexs=nil apexs={} apexbb=1
    for i, v in ipairs(apexa) do
        if apexa[i].value==0 then apexs[apexbb]={} apexs[apexbb].address=apexa[i].address apexs[apexbb].flags=1 apexbb=apexbb+1
        end
    end
if #(apexs)==0 then gg.clearResults() E=0 return end
apexa=nil
    for i, v in ipairs(apexs) do apexs[i].address=apexs[i].address-#(x) apexs[i].flags=1
    end
gg.loadResults(apexs)
gg.searchPointer(0)
if gg.getResultsCount()==0 then E=0 return end
apexu=gg.getResults(gg.getResultsCount())
gg.clearResults()
if gg.getTargetInfo().x64 then apexo1=48 apexo2=56 apexvt=32 else apexo1=24 apexo2=28 apexvt=4 end
ERROR=0
::TRYAGAIN::
apexy=nil apexy={} apexz=nil apexz={}
    for i, v in ipairs(apexu) do
    apexy[i]={} apexy[i].address=apexu[i].address+apexo1 apexy[i].flags=apexvt
    apexz[i]={} apexz[i].address=apexu[i].address+apexo2 apexz[i].flags=apexvt
    end
apexy=gg.getValues(apexy) apexz=gg.getValues(apexz) apexp=nil apexp={} apexxx=1
    for i, v in ipairs(apexy) do
        if apexy[i].value==apexz[i].value and #(tostring(apexy[i].value))>=8 then
        apexp[apexxx]=apexy[i].value
        apexxx=apexxx+1
        end
    end
apexxx=nil apexy=nil apexz=nil
    if #(apexp)==0 and ERROR==0 then
        if gg.getTargetInfo().x64 then apexo1=32 apexo2=40 else apexo1=16 apexo2=20 end
    ERROR=2
    goto TRYAGAIN
    end
if #(apexp)==0 and ERROR==2 then E=0 return end
gg.setRanges(gg.REGION_ANONYMOUS)
gg.clearResults() apexxxx=1
    for i, v in ipairs(apexp) do
    gg.toast("Please Wait...")
    gg.searchNumber(tonumber(apexp[i]),apexvt)
        if gg.getResultsCount()~=0 then
        apexxx=nil apexxx=gg.getResults(gg.getResultsCount()) gg.clearResults()
            for apexq=1,#(apexxx) do apexxx[apexq].name="APEX[GG]v2"
            end
        gg.addListItems(apexxx) apexxxx=apexxxx+1
        end
    gg.clearResults()
    end
apexu=nil apexp=nil apexxx=nil apexq=nil
if apexxxx==1 then gg.clearResults() E=0 return end
apexxxx=nil apexload={} apexremove={} apexxx=1
apexu=gg.getListItems()
    for i, v in ipairs(apexu) do
        if apexu[i].name=="APEX[GG]v2" then
        apexload[apexxx]={} apexload[apexxx].address=apexu[i].address+o apexload[apexxx].flags=t
        apexremove[apexxx]={} apexremove[apexxx]=apexu[i] apexxx=apexxx+1
        end
    end
apexload=gg.getValues(apexload) gg.loadResults(apexload) gg.removeListItems(apexremove)
end
--███████████████████████
-- APEX[GG]v2
------------------------------------------------------------------------------
function clear()
gg.getResults(gg.getResultsCount())
gg.clearResults()
end
------------------------------------------------------------------------------
function get()
gg.getResults(gg.getResultsCount())
end
------------------------------------------------------------------------------
function search()
gg.getResults(gg.getResultsCount())
gg.clearResults()
gg.searchNumber(x,t)
end
------------------------------------------------------------------------------
function refine()
gg.refineNumber(x,t)
end
------------------------------------------------------------------------------
function refinenot()
gg.refineNumber(x,t,false,gg.SIGN_NOT_EQUAL)
end
------------------------------------------------------------------------------
function edit()
gg.getResults(gg.getResultsCount())
gg.editAll(x,t)
end
------------------------------------------------------------------------------
function check()
E=nil E=gg.getResultsCount()
end
------------------------------------------------------------------------------
function offset()
o=tonumber(o) addoff=nil
addoff=gg.getResults(gg.getResultsCount())
    for i, v in ipairs(addoff) do
        addoff[i].address=addoff[i].address+o
        addoff[i].flags=t
    end
gg.loadResults(addoff)
end
------------------------------------------------------------------------------
function freeze()
frz=nil
frz=gg.getResults(gg.getResultsCount())
    for i, v in ipairs(frz) do
        frz[i].freeze = true
    end
gg.addListItems(frz)
end
------------------------------------------------------------------------------
function cancel()
gg.toast("CANCELLED")
end
------------------------------------------------------------------------------
function wait()
gg.toast("Please Wait..")
end
------------------------------------------------------------------------------
function error()
gg.toast("× ERROR ×")
gg.sleep(1000)
end
------------------------------------------------------------------------------
function exit()
gg.getListItems()
gg.clearList()
gg.getResults(gg.getResultsCount())
gg.clearResults()
gg.toast("[ EXIT ]")
    if xhaX~=nil then
        print(printx)
        print(xhaX)
        print(printx)
    end
gg.setVisible(true)
os.exit()
return
end

--███████████████████████
if v.x64 then off1=-16 typ=32 else off1=-8 typ=4 end
gg.setRanges(gg.REGION_OTHER | gg.REGION_C_ALLOC | gg.REGION_ANONYMOUS)

ATOTAL=0
for i = 1,100 do
    if A[i].method==nil then break end
    ATOTAL=ATOTAL+1
end

ASTART=1 AEND=0 ATABT=ATOTAL+1 ATAB=1
S=0
    while ATAB<=ATOTAL do
    ::AUTOSTART::
    gg.setVisible(false)
        if ATAB>ATOTAL then break goto FINISHED end
    gg.toast("Please Wait.. [ "..ATABT-ATAB.." ]")
    A[ATAB].error=1
    ANAME=nil ANAME={}
    if A[ATAB].name~=nil then
        for i = 1,#(tostring(A[ATAB].name)) do
            ANAME[i]=string.byte(A[ATAB].name,i)
        end
    else
        A[ATAB].name=0
    end
    ACLASS=nil ACLASS={}
    if A[ATAB].class~=nil then
        for i = 1,#(tostring(A[ATAB].class))+1 do
            if i == #(tostring(A[ATAB].class))+1 then
                ACLASS[i]=0
            else
                ACLASS[i]=string.byte(A[ATAB].class,i)
            end
        end
    else
        A[ATAB].class=0
    end

                ASTART=AEND+1
                clear() t=1
                gg.searchNumber(":"..tostring(A[ATAB].method),1)
                xm=gg.getResults(2) gg.getResults(gg.getResultsCount())
                check()
                    if E==0 then ATAB=ATAB+1
                        if ATAB>ATOTAL then break return end
                    goto AUTOSTART return
                    end
                x=xm[1].value..";"..xm[2].value.."::2" refine()
                x=xm[1].value refine()
                o=-1 offset() x=0 refine() oo=#(tostring(A[ATAB].method))
                o=oo+1 offset() refine() o=-oo offset()
                check()
                    if E==0 then ATAB=ATAB+1
                        if ATAB>ATOTAL then break return end
                    goto AUTOSTART return
                    end
                gg.searchPointer(0) xcount=gg.getResultsCount()
                xpoint=gg.getResults(xcount,nil, nil, nil, nil, nil, nil, nil,gg.POINTER_READ_ONLY)
                    if #(xpoint)==0 then ATAB=ATAB+1
                        if ATAB>ATOTAL then break return end
                    goto AUTOSTART return
                    end
                clear()
                    for xp=1,#(xpoint) do
                    xpoint[xp].address=xpoint[xp].address+off1
                    xpoint[xp].flags=typ
                    end
                gg.loadResults(xpoint)
                xoff=gg.getResults(#(xpoint),nil, nil, nil, nil, nil, nil, nil, gg.POINTER_EXECUTABLE)
                    if #(xoff)==0 then ATAB=ATAB+1
                        if ATAB>ATOTAL then break return end
                    goto AUTOSTART return
                    end
                    xfin=1
                    while xfin<=#(xoff) do
                    ::XFIN::
                        if xfin>#(xoff) then ATAB=ATAB+1
                            if ATAB>ATOTAL then break return end
                        goto AUTOSTART return
                        end
                        if gg.getTargetInfo().x64 then
                            xadd=tonumber(xoff[xfin].value)
                        else
                            xadd=string.format("%X",tonumber(xoff[xfin].value))
                            xadd=string.sub(tostring(xadd), -8,-1)
                            xadd=tonumber("0x"..xadd)
                        end
                    gval1=nil gval1={} gval1[1]={}
                        if gg.getTargetInfo().x64 then gvo=24 gvo1=16 gvo2=24 else gvo=12 gvo1=8 gvo2=12 end
                    gval1[1].address=xoff[xfin].address+gvo
                    gval1[1].flags=typ
                    gval1=gg.getValues(gval1)
                        if gg.getTargetInfo().x64 then
                            gval=tonumber(gval1[1].value)
                        else
                            gval=string.format("%X",tonumber(gval1[1].value))
                            gval=string.sub(tostring(gval), -8,-1)
                            gval=tonumber("0x"..gval)
                        end
                    gval2=nil gval2={} gval2[1]={} gval2[2]={}
                    gval2[1].address=gval+gvo1
                    gval2[1].flags=typ
                    gval2[2].address=gval+gvo2
                    gval2[2].flags=typ
                    gval2=gg.getValues(gval2)
                        if gg.getTargetInfo().x64 then
                            gval21=tonumber(gval2[1].value)
                            gval22=tonumber(gval2[2].value)
                        else
                            gval21=string.format("%X",tonumber(gval2[1].value))
                            gval21=string.sub(tostring(gval21), -8,-1)
                            gval21=tonumber("0x"..gval21)
                            gval22=string.format("%X",tonumber(gval2[2].value))
                            gval22=string.sub(tostring(gval22), -8,-1)
                            gval22=tonumber("0x"..gval22)
                        end
                         xrefine=0
                         if A[ATAB].class~=0 then
                            for xyz=1,#(ACLASS) do
                                gvalc={} gvalc[1]={}
                                gvalc[1].address=gval21+(xyz-1)
                                gvalc[1].flags=1
                                gvalc=gg.getValues(gvalc)
                                if gvalc[1].value~=ACLASS[xyz] then xrefine=1 break xfin=xfin+1 goto XFIN end
                            end
                        end

                        if A[ATAB].name~=0 then
                            for xyz=1,#(ANAME) do
                                gvalc={} gvalc[1]={}
                                gvalc[1].address=gval22+(xyz-1)
                                gvalc[1].flags=1
                                gvalc=gg.getValues(gvalc)
                                    if gvalc[1].value~=ANAME[xyz] then xrefine=1 break xfin=xfin+1 goto XFIN end
                            end
                        end

                         if xrefine==0 then
                        A[ATAB].start=ASTART AEND=AEND+1
                        A[ATAB].finish=AEND
                        A[ATAB].error=0
                        clear() I[AEND]=xadd-xAPEXx[xXx]
                        end
                    xfin=xfin+1
                    end -- xfin
    ATAB=ATAB+1
    end -- ATAB

---------------------------------------------------

::FINISHED::
 xBAR=0
    for i = 1, ATOTAL do
        if A[i].error~=0 then xBAR=xBAR+1 end
    end
    if xBAR>=ATOTAL  then
        gg.toast("×× FAILURE ××") gg.alert("× AUTO UPDATE FAILURE ×","EXIT",nil, xTAGx)
        exit()
        return
    end
    if xBAR>=1 then gg.toast("× ERROR ×") gg.alert("× Auto Update Errors\nSome/All Hacks May Not Work","OK",nil, xTAGx)
    else gg.toast("√ SUCCESS") gg.alert("\n√ Auto Update Success\n\n'Hacking is the Game'","OK",nil, xTAGx)
    end
--███████████████████████
--███████████████████████
if xREV==1 then
xRx=1 ORIG={} xREV={}
    for XxX=1,#(xAPEXx) do
        for i, v in ipairs(I) do
        thiscunt=0
            for dfg=1,7 do
            ORIG[xRx]={}
            ORIG[xRx].address=xAPEXx[XxX]+tonumber(I[i])+thiscunt
            ORIG[xRx].flags=4
            xRx=xRx+1
            thiscunt=thiscunt+4
            end
        end
    end
ORIG=gg.getValues(ORIG)
end
--███████████████████████
while true do
    if gg.isVisible() or apex==1 then
        gg.setVisible(false) apex=0
        menu()
    end
end