View difference between Paste ID: Um7jNcJh and QJXWtq0k

 if game:GetService("CoreGui"):FindFirstChild("ow menu | Premium Panel v0.0.1") then
     require(game:GetService("ReplicatedStorage").Framework.Modules.Client["5 | Message"]).New("Another menu is found. \n Please execute again.")
         for i = 0,5 do
             game:GetService("CoreGui")["ow menu | Premium Panel v0.0.1"]:Destroy()
         end
 elseif not game:GetService("CoreGui"):FindFirstChild("ow menu | Premium Panel v0.0.1") then
     print("Starting.. All seems fine.")
 end
 --------------------------
 require(game:GetService("ReplicatedStorage").Framework.Modules.Client["5 | Message"]).New("Press OK to start ow menu.")
 
 if game.PlaceId == 6284583030 then
     local start = tick()
     repeat task.wait() until game:isLoaded()
     repeat task.wait() until game:GetService("Players")
     repeat task.wait() until game:GetService("Players").LocalPlayer
     repeat task.wait() until game:GetService("Players").LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
     repeat task.wait() until game:GetService("Players").LocalPlayer.PlayerGui.Main.Enabled
     repeat task.wait() until game:GetService("Workspace"):FindFirstChild('__MAP')
 end
 
 
 -- init
 local library = loadstring(game:HttpGet("https://raw.githubusercontent.com/inceldom/skid/main/guish.lua"))()
 local venyx = library.new("ow menu | Premium Panel v0.0.1", 5013109572)
 
 -- themes
 local themes = {
 Background = Color3.fromRGB(23, 0, 1),
 Glow = Color3.fromRGB(255, 95, 95),
 Accent = Color3.fromRGB(23, 0, 1),
 LightContrast = Color3.fromRGB(44, 13, 19),
 DarkContrast = Color3.fromRGB(23, 0, 1),
 TextColor = Color3.fromRGB(255, 105, 138)
 }
 
 
 local GC = getconnections or get_signal_cons
 if GC then
     for i,v in pairs(GC(game.Players.LocalPlayer.Idled)) do
         if v["Disable"] then
             v["Disable"](v)
         elseif v["Disconnect"] then
             v["Disconnect"](v)
         end
     end
 else
     print("Unlucky.")
     local vu = game:GetService("VirtualUser")
     game:GetService("Players").LocalPlayer.Idled:connect(function()
         vu:Button2Down(Vector2.new(0,0),workspace.CurrentCamera.CFrame)
         wait(1)
         vu:Button2Up(Vector2.new(0,0),workspace.CurrentCamera.CFrame)
     end)
 end
 
 
 
 -------------------------------------------------------------------------------------------------
 
 --locales
 
 local GameLibrary = require(game:GetService("ReplicatedStorage"):WaitForChild("Framework"):WaitForChild("Library"))
 local Network = GameLibrary.Network
 local Run_Service = game:GetService("RunService")
 local rs = Run_Service.RenderStepped
 local CurrencyOrder = {"Halloween Candy", "Tech Coins", "Fantasy Coins", "Coins", "Diamonds",}
 
 local IMightKillMyselfCauseOfThis = {
         --Misc
         ['VIP'] = {'VIP'};
         --Spawn
         ['Town'] = {'Town', 'Town FRONT'};
         ['Forest'] = {'Forest', 'Forest FRONT'};
         ['Beach'] = {'Beach', 'Beach FRONT'};
         ['Mine'] = {'Mine', 'Mine FRONT'};
         ['Winter'] = {'Winter', 'Winter FRONT'};
         ['Glacier'] = {'Glacier', 'Glacier Lake'};
         ['Desert'] = {'Desert', 'Desert FRONT'};
         ['Volcano'] = {'Volcano', 'Volcano FRONT'};
         -- Fantasy init
         ['Enchanted Forest'] = {'Enchanted Forest', 'Enchanted Forest FRONT'};
         ['Ancient'] = {'Ancient'};
         ['Samurai'] = {'Samurai', 'Samurai FRONT'};
         ['Candy'] = {'Candy'};
         ['Haunted'] = {'Haunted', 'Haunted FRONT'};
         ['Hell'] = {'Hell'};
         ['Heaven'] = {'Heaven'};
         -- Tech
         ['Ice Tech'] = {'Ice Tech'};
         ['Tech City'] = {'Tech City'; 'Tech City FRONT'};
         ['Dark Tech'] = {'Dark Tech'; 'Dark Tech FRONT'};
         ['Steampunk'] = {'Steampunk'; 'Steampunk FRONT'};
 		['Alien Lab'] = {"Alien Forest"; "Alien Lab FRONT"};
 		['Alien Forest'] = {"Alien Forest"; "Alien Forest FRONT"};
     }
 
     local AreaListLoc = { --These match the IMightKillMyselfCuaseOfThis table
         'All'; 'VIP';
-        'Ice Tech'; 'Tech City'; 'Dark Tech'; 'Steampunk';
+
         'Enchanted Forest'; 'Ancient'; 'Samurai'; 'Candy'; 'Haunted'; 'Hell'; 'Heaven';
         'Ice Tech'; 'Tech City'; 'Dark Tech'; 'Steampunk'; 'Alien Lab'; 'Alien Forest';
     }
 
 
 
     local Chests = {
         'All';
         -- Spawn
         "Magma Chest",
         -- Fantasy
-        "Giant Tech Chest"; "Giant Steampunk Chest";
+
         -- Tech
         "Giant Tech Chest"; "Giant Steampunk Chest"; "Giant Alien Chest";
     }
 
 
 
 local function SecondsToClock(seconds)
         local days = math.floor(seconds / 86400)
         seconds = seconds - days * 86400
         local hours = math.floor(seconds / 3600 )
         seconds = seconds - hours * 3600
         local minutes = math.floor(seconds / 60)
         seconds = seconds - minutes * 60
 
         return string.format("%d d, %d h, %d m, %d s.",days,hours,minutes,seconds)
       end
 
 
 
 --5012544693
 -------------------------------------------------------------------------------------------------
 -- credits page
 local page = venyx:addPage("Developers", 5832745520)
 local Credits1 = page:addSection("Main Developer:")
 
 Credits1:addButton("ow#3295", function(dsclink)
     if dsclink then
         venyx:Notify("Discord ID Copied", "You can paste it.")
     end
     setclipboard('ow#3295')
 end)
 
 ----------------------------------
 
 local Credits2 = page:addSection("Discord:")
 
 Credits2:addButton("Copy Discord Link", function(dsclink)
     if dsclink then
         venyx:Notify("Discord Link Copied", "You can paste it.")
     end
     setclipboard('https://discord.gg/p4jjhBq6vS')
 end)
 
 
 
 -------------------------------------------------------------------------------------------------
 -- page1
 
 
 local page = venyx:addPage("Auto farm", 1379498635)
 local section1 = page:addSection("Auto farm.")
 local section2 = page:addSection("Automated stuff.")
 -------------------------------------------------------------------------------------------------
 -- Misc page
 local page = venyx:addPage("Miscellaneous", 37219625)
 local misc1 = page:addSection("Miscellaneous.")
 --local misc2 = page:addSection("Open menus.")
 
 -------------------------------------------------------------------------------------------------
 
 -- Egg page
 local page = venyx:addPage("Eggs", 5094819983)
 local eggs1 = page:addSection("Automated egg opener")
 -------------------------------------------------------------------------------------------------
 
 -- Pets page
 local page = venyx:addPage("Pets", 329532393)
 local pets1 = page:addSection("Automated fuse.")
 local pets2 = page:addSection("Automated golden or rainbow.")
 --local pets3 = page:addSection("Automated enchant | Temporarily disabled.")
 local pets4 = page:addSection("Automated dark matter.")
 
 -------------------------------------------------------------------------------------------------
 
 -- Troll page
 --local page = venyx:addPage("Troll", 329532393)
 --local troll1 = page:addSection("Troll")
 
 -------------------------------------------------------------------------------------------------
 -- Settings page
 local page = venyx:addPage("Settings", 5107159171)
 local Settings1 = page:addSection("Settings.")
 local Settings2 = page:addSection("Theme.")
 Settings1:addKeybind("Toggle keybind.", Enum.KeyCode.RightShift, function(menu)
 venyx:toggle()
 end, function(menu)
 end)
 
 ------------
 
 
 
 
 ------------
 
 Settings1:addButton("Destroy Menu", function(destroygui)
     game:GetService("CoreGui")["ow menu | Premium Panel v0.0.1"]:Destroy()
     print("Old menu destroyed.")
 end)
 -------------------------------------------------------------------------------------------------
 
 local MethodList = {'Normal', 'Chest', 'Multi Target', 'Lowest Value (Multi)', 'Highest Value', '[TESTING] Highest Value', 'Nearest'}
 
 section1:addDropdown("Method", MethodList, function(methodfunc)
     if methodfunc then
         _G.methodfunc = methodfunc
     end
     print("Selected method: ", methodfunc)
 end)
 
 --------------------------------
 
 
 local ItemToFarmList = {'All', 'Magma Chest', 'Enchanted Chest', 'Hell Chest', 'Haunted Chest', 'Angel Chest', 'Grand Heaven Chest', 'Giant Tech Chest', 'Giant Steampunk Chest'}
 
 section1:addDropdown("Item to farm", ItemToFarmList, function(itemtofarmfunc)
     if itemtofarmfunc then
         _G.itemtofarmfunc = itemtofarmfunc
     end
     print("Selected item: ", itemtofarmfunc)
 end)
 
 --------------------------------
 
 --local WorldList = {"Spawn", "Fantasy", "Tech"}
 
 --section1:addDropdown("Select World", WorldList, function(worldfunc)
 --    if worldfunc then
 --        _G.worldfunc = worldfunc
 --    end
 --    print("World: ", worldfunc)
 --end)
 --------------------------------
 
 
 --local Coins = {}
 --for i,v in pairs(game.ReplicatedStorage.Game.Coins:GetChildren()) do
 --    for i2,v2 in pairs(v:GetChildren()) do
 --        table.insert(Coins, v2.Name)
 --    end
 --end
 --table.foreach(Coins, print)
 
 
 
 section1:addDropdown("Select location", AreaListLoc, function(mapafunc)
     if mapafunc then
         _G.mapafunc = mapafunc
     end
     print("Selected area: ", mapafunc)
 end)
 
 -------------------------------------------------------------------------------------------------
 
 local AreaWorldTable = {}
 for _, v in pairs(game:GetService("ReplicatedStorage").Game.Coins:GetChildren()) do
     for _, b in pairs(v:GetChildren()) do
         table.insert(AreaWorldTable, b.Name)
     end
     table.insert(AreaWorldTable, v.Name)
 end
 
 -------------------------
 
 function AllChests()
     local returntable = {}
     local ListCoins = game.workspace['__THINGS']['__REMOTES']["get coins"]:InvokeServer({})[1]
     for i,v in pairs(ListCoins) do
         local shit = v
         shit["index"] = i
         for aa,bb in pairs(AreaWorldTable) do
             if string.find(v.n, bb) then
                 local thing = string.gsub(v.n, bb.." ", "")
                 if table.find(Chests, thing) then
                     shit.n = thing
                     table.insert(returntable, shit)
                 end
             end
         end
     end
     return returntable
 end
 
 
 -------------------------------
 
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "buy egg")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "join coin")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("a", "farm coin")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("a", "claim orbs")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("a", "change pet target")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "get trade")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "add trade pet")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "remove trade pet")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "convert to dark matter")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "redeem dark matter pet")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "redeem rank rewards")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "redeem vip rewards")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("a", "toggle setting")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("a", "activate boost")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "use golden machine")
 workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "use rainbow machine")
 -------------------------------
 
 function FarmCoin(CoinID, PetID)
     game.workspace['__THINGS']['__REMOTES']["join coin"]:InvokeServer({[1] = CoinID, [2] = {[1] = PetID}})
     game.workspace['__THINGS']['__REMOTES']["farm coin"]:FireServer({[1] = CoinID, [2] = PetID})
 end
 
 -------------------------------
 
 --function GetMyPets()
 --   local returntable = {}
 --   for i,v in pairs(GameLibrary.Save.Get().Pets) do
 --       if v.e then
 --           table.insert(returntable, v.uid)
 --       end
 --   end
 --   return returntable
 --end
 
 local Library = require(game:GetService("ReplicatedStorage").Framework.Library)
 local IDToName = {}
 local NameToID = {}
 for i,v in pairs(Library.Directory.Pets ) do
     IDToName[i] = v.name
     NameToID[v.name] = i
 end
 
 function GetMyPets()
        local returntable = {}
        for i,v in pairs(GameLibrary.Save.Get().Pets) do
            if v.e then
                table.insert(returntable, v.uid)
            end
        end
        return returntable
     end
 
 function GetPets()
         local MyPets = {}
         for i,v in pairs(GameLibrary.Save.Get().Pets) do
             --if (not _G.AllowMythicals) or (_G.AllowMythicals and (PettoRarity[v.id] ~= 'Mythical' and PettoRarity[v.id] ~= 'Exclusive' and not string.find(IDToName[v.id]:lower(), "maskot"))) then
                 local ThingyThingyTempTypeThing = (v.g and 'Gold') or (v.r and 'Rainbow') or (v.dm and 'Dark Matter') or 'Normal'
                 local TempString = ThingyThingyTempTypeThing .. IDToName[v.id]
                 if MyPets[TempString] then
                     table.insert(MyPets[TempString], v.uid)
                 else
                     MyPets[TempString] = {}
                     table.insert(MyPets[TempString], v.uid)
                 end
             --end
         end
         return MyPets
     end
 
 --function GetPets()
 --        local MyPets = {}
 --        for i,v in pairs(GameLibrary.Save.Get().Pets) do
 --            --if (not _G.AllowMythicals) or (_G.AllowMythicals and (not PettoRarity[v.id] ~= 'Mythical' and PettoRarity[v.id] ~= 'Exclusive')) then
 --                local ThingyThingyTempTypeThing = (v.g and 'Gold') or (v.r and 'Rainbow') or (v.dm and 'Dark Matter') or 'Normal'
 --                local TempString = ThingyThingyTempTypeThing .. IDToName[v.id]
 --                if MyPets[TempString] then
 --                    table.insert(MyPets[TempString], v.uid)
 --                else
 --                    MyPets[TempString] = {}
 --                    table.insert(MyPets[TempString], v.uid)
 --                end
 --            end
 --        --end
 --        return MyPets
 --    end
 
 --------------------------
 
 --function GetCoins(area)
 --    local returntable = {}
 --    local ListCoins = game.workspace['__THINGS']['__REMOTES']["get coins"]:InvokeServer({})[1]
 --    for i,v in pairs(ListCoins) do
 --        if _G.mapafunc == 'All' or table.find(IMightKillMyselfCauseOfThis[_G.mapafunc], v.a) then
 --            local shit = v
 --            shit["index"] = i
 --            table.insert(returntable, shit)
 --         end
 --    end
 --    return returntable
 --end
 
 function GetCoins(area, exclude)
     exclude = exclude or {}
     local Areas = (IMightKillMyselfCauseOfThis)
     local returntable = {}
     local ListCoins = game.workspace['__THINGS']['__REMOTES']["get coins"]:InvokeServer({})[1]
     for i,v in pairs(ListCoins) do
         if _G.mapafunc == 'All' or table.find(Areas[_G.mapafunc], v.a) and not table.find(exclude ,v.n) then
             local shit = v
             shit["index"] = i
             table.insert(returntable, shit)
          end
     end
     return returntable
 end
 --------------------------
 
 --function GetCoinTable(area)
 --    local CoinTable = GetCoins(area)
 --    function getKeysSortedByValue(tbl, sortFunction)
 --        local keys = {}
 --        for key in pairs(tbl) do
 --            table.insert(keys, key)
 --        end
 --        table.sort(
 --            keys,
 --            function(a, b)
 --                return sortFunction(tbl[a].h, tbl[b].h)
 --            end
 --        )
 --        return keys
 --    end
 --    local sortedKeys = getKeysSortedByValue(CoinTable, function(a, b) return a > b end)
 --    local newCoinTable = {}
 --
 --    for i,v in pairs(sortedKeys) do
 --        table.insert(newCoinTable, CoinTable[v])
 --    end
 --
 --    return newCoinTable
 --end
 
 function GetCoinTable(area, Type, exclude)
     exclude = exclude or {}
     local CoinTable = GetCoins(area, exclude)
     local function getKeysSortedByValue(tbl, sortFunction)
         local keys = {}
         for key in pairs(tbl) do
             table.insert(keys, key)
         end
         table.sort(
             keys,
             function(a, b)
                 return sortFunction(tbl[a].h, tbl[b].h)
             end
         )
         return keys
     end
     local sortedKeys
     if Type == 'Highest' then
         sortedKeys = getKeysSortedByValue(CoinTable, function(a, b) return a > b end)
     elseif Type == 'Lowest' then
         sortedKeys = getKeysSortedByValue(CoinTable, function(a, b) return a < b end)
     end
     local newCoinTable = {}
 
     for i,v in pairs(sortedKeys) do
         table.insert(newCoinTable, CoinTable[v])
     end
 
     return newCoinTable
 end
 
 -------------------------
 
 if _G.MyConnection then _G.MyConnection:Disconnect() end
     _G.MyConnection = game.Workspace.__THINGS.Orbs.ChildAdded:Connect(function(Orb)
         game.Workspace.__THINGS.__REMOTES["claim orbs"]:FireServer({{Orb.Name}})
     end)
 
 section1:addToggle("Enable automated farm", false, function(farmingtogglefunc)
 if farmingtogglefunc == true then
     _G.FarmingToggle = true
 elseif farmingtogglefunc == false or destroygui then
     _G.FarmingToggle = false
 end
 
         local CurrentFarmingPets = {}--skidded from https://v3rmillion.net/showthread.php?tid=1137512
         while _G.FarmingToggle do
             local pethingy = GetMyPets()
             local cointhiny = nil
 
         --local CurrentFarmingPets = {}
         --while rs:wait() and _G.FarmingToggle == false do
         --    local pethingy = GetPets()
 
         --if _G.methodfunc == 'Normal' then
         --    local cointhiny = GetCoins(_G.mapafunc)
         --    for i = 1, #cointhiny do
         --        if _G.FarmingToggle and game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index) then
         --            for _, bb in pairs(pethingy) do
         --                if _G.FarmingToggle and game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index) then
         --                    spawn(function()
         --                        FarmCoin(cointhiny[i].index, bb)
         --                    end)
         --                end
         --            end
         --            repeat rs:wait() until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index)
         --        end
         --    end
 
             if _G.methodfunc == 'Normal' then
                 local cointhiny = GetCoins(_G.mapafunc)
                 for i = 1, #cointhiny do
                     if _G.FarmingToggle and game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index) then
                         for _, bb in pairs(pethingy) do
                             coroutine.wrap(function()
                                 FarmCoin(cointhiny[i].index, bb)
                             end)()
                         end
                         repeat task.wait(0.001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index) or not _G.FarmingToggle or _G.methodfunc ~= 'Normal'
                     end
                 end
 
         --    elseif _G.methodfunc == 'Chest' then
         --        for i,v in pairs(AllChests()) do
         --            if (v.n == _G.itemtofarmfunc) or (_G.itemtofarmfunc == 'All') then
         --                local starttick = tick()
         --                for a, b in pairs(pethingy) do
         --                    pcall(function() FarmCoin(v.index, b) end)
         --                end
         --                repeat task.wait(0.001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(v.index) or #game:GetService("Workspace")["__THINGS"].Coins[v.index].Pets:GetChildren() == 0
         --                --warn(v.n .. " has been broken in", tick()-starttick)
         --            end
         --        end
 
             elseif _G.methodfunc == 'Chest' then
                 for i,v in pairs(AllChests()) do
                     if (v.n == _G.itemtofarmfunc) or (_G.itemtofarmfunc == 'All') then
                         local starttick = tick()
                         for a, b in pairs(pethingy) do
                             coroutine.wrap(function()
                                 FarmCoin(v.index, b)
                             end)()
                         end
                         repeat task.wait(0.001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(v.index) or #game:GetService("Workspace")["__THINGS"].Coins[v.index].Pets:GetChildren() == 0 or not _G.FarmingToggle or _G.methodfunc ~= 'Chest'
                         --warn(v.n .. " has been broken in", tick()-starttick)
                     end
                 end
 
             --elseif _G.methodfunc == 'Multi Target' then
         --    local cointhiny = GetCoins(_G.mapafunc)
         --    for i = 1, #cointhiny do
         --        if i%#pethingy == #pethingy-1 then wait() end
         --        if not CurrentFarmingPets[pethingy[i%#pethingy+1]] or CurrentFarmingPets[pethingy[i%#pethingy+1]] == nil then
         --            spawn(function()
         --                CurrentFarmingPets[pethingy[i%#pethingy+1]] = 'Farming'
         --                FarmCoin(cointhiny[i].index, pethingy[i%#pethingy+1])
         --                repeat rs:wait() until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index) or #game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index).Pets:GetChildren() == 0
         --                CurrentFarmingPets[pethingy[i%#pethingy+1]] = nil
         --            end)
         --        end
         --    end
 
             elseif _G.methodfunc == 'Multi Target' then
                 local cointhiny = GetCoins(_G.mapafunc)
                 for i = 1, #cointhiny do
                     if not CurrentFarmingPets[pethingy[i%#pethingy+1]] or CurrentFarmingPets[pethingy[i%#pethingy+1]] == nil then
                         coroutine.wrap(function()
                             CurrentFarmingPets[pethingy[i%#pethingy+1]] = 'Farming'
                             FarmCoin(cointhiny[i].index, pethingy[i%#pethingy+1])
                             repeat task.wait(0.001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index) or #game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index).Pets:GetChildren() == 0 or not _G.FarmingToggle or _G.methodfunc ~= 'Multi Target'
                             CurrentFarmingPets[pethingy[i%#pethingy+1]] = nil
                         end)()
                     end
                 end
 
             elseif _G.methodfunc == 'Lowest Value (Multi)' then
                 local cointhiny = GetCoinTable(_G.mapafunc, "Lowest")
                 for i = 1, (#cointhiny >= #pethingy and #pethingy or #cointhiny) do
                     if not CurrentFarmingPets[pethingy[i%#pethingy+1]] or CurrentFarmingPets[pethingy[i%#pethingy+1]] == nil then
                         coroutine.wrap(function()
                             CurrentFarmingPets[pethingy[i%#pethingy+1]] = 'Farming'
                             FarmCoin(cointhiny[i].index, pethingy[i%#pethingy+1])
                             repeat task.wait(0.0001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index) or #game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[i].index).Pets:GetChildren() == 0 or not _G.FarmingToggle or _G.methodfunc ~= 'Lowest Value (Multi)'
                             CurrentFarmingPets[pethingy[i%#pethingy+1]] = nil
                         end)()
                     end
                 end
 
             --elseif _G.methodfunc == 'Highest Value' then
         --    local cointhiny = GetCoinTable(_G.mapafunc)
         --    for a,b in pairs(pethingy) do
         --        spawn(function() FarmCoin(cointhiny[1].index, b) end)
         --    end
         --    repeat rs:wait() until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[1].index) or #game:GetService("Workspace")["__THINGS"].Coins[cointhiny[1].index].Pets:GetChildren() == 0
 
             elseif _G.methodfunc == 'Highest Value' then
                 local cointhiny = GetCoinTable(_G.mapafunc, "Highest")
                 if #cointhiny >= 1 then
                     for a,b in pairs(pethingy) do
                         coroutine.wrap(function()
                             FarmCoin(cointhiny[1].index, b)
                         end)()
                     end
                     repeat task.wait(0.001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[1].index) or #game:GetService("Workspace")["__THINGS"].Coins[cointhiny[1].index].Pets:GetChildren() == 0 or not _G.FarmingToggle or _G.methodfunc ~= 'Highest Value'
                 else
                     task.wait()
                 end
 
             elseif _G.methodfunc == '[TESTING] Highest Value' then
                 local cointhiny = GetCoinTable(_G.mapafunc, "Highest")
                 if #cointhiny >= 3 then
                     local CurrentFarmingPets = {}
                     for a = 1, 3 do
                         coroutine.wrap(function()
                             if CurrentFarmingPets[a] == nil then
                                 for petnum = a, #pethingy, 3 do
                                     coroutine.wrap(function()
                                         if not CurrentFarmingPets[a] then CurrentFarmingPets[a] = {} end
                                         if CurrentFarmingPets[a] ~= nil and game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[a].index) and not table.find(CurrentFarmingPets[a], pethingy[petnum]) then
                                             table.insert(CurrentFarmingPets[a], pethingy[petnum])
                                             FarmCoin(cointhiny[a].index, pethingy[petnum])
                                         end
                                     end)()
                                 end
                                 repeat task.wait(0.001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(cointhiny[a].index) or #game:GetService("Workspace")["__THINGS"].Coins[cointhiny[a].index].Pets:GetChildren() == 0  or not _G.FarmingToggle or _G.methodfunc ~= '[TESTING] Highest Value'
                                 CurrentFarmingPets[a] = nil
                             end
                         end)()
                     end
                 else
                     task.wait()
                 end
 
             --elseif _G.methodfunc == 'Nearest' then
         --    local NearestOne = nil
         --    local NearestDistance = math.huge
         --    for i,v in pairs(game:GetService("Workspace")["__THINGS"].Coins:GetChildren()) do
         --        if (v.POS.Position - game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude < NearestDistance then
         --            NearestOne = v
         --            NearestDistance = (v.POS.Position - game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude
         --        end
         --    end
         --    for a,b in pairs(pethingy) do
         --        spawn(function() FarmCoin(NearestOne.Name, b) end)
         --    end
 
             elseif _G.methodfunc == 'Nearest' then
                 local cointable = game:GetService("Workspace")["__THINGS"].Coins:GetChildren()
                 table.sort(cointable, function(i, v)
                     return (game.Players.LocalPlayer.Character.HumanoidRootPart.Position - i.POS.Position).magnitude < (game.Players.LocalPlayer.Character.HumanoidRootPart.Position - v.POS.Position).magnitude
                 end)
                 local NearestOne = cointable[1]
                 if NearestOne ~= nil then
                     for a,b in pairs(pethingy) do
                         coroutine.wrap(function()
                             if NearestOne ~= nil then
                                 FarmCoin(NearestOne.Name, b)
                             end
                         end)()
                     end
                     repeat task.wait(0.001) until not game:GetService("Workspace")["__THINGS"].Coins:FindFirstChild(NearestOne.Name) or #game:GetService("Workspace")["__THINGS"].Coins[NearestOne.Name].Pets:GetChildren() == 0
                 else
                     task.wait()
                 end
             end
         end
     end)
 
 
 -------------------------------------------------------------------------------------------------
 -- Farming Addons
 --
 --section1:addToggle("Auto Collect Orbs", false, function(autocollecting)
 --
 --if autocollecting == true then
 --    _G.CollectOrbs = true
 --elseif autocollecting == false or destroygui then
 --    _G.CollectOrbs = false
 --    end
 --
 --function CollectOrbs()
 --   local ohTable1 = {[1] = {}}
 --   for i,v in pairs(game.workspace['__THINGS'].Orbs:GetChildren()) do
 --       ohTable1[1][i] = v.Name
 --        end
 --   game.workspace['__THINGS']['__REMOTES']["claim orbs"]:FireServer(ohTable1)
 --    end
 --
 --while wait() and _G.CollectOrbs do
 --      pcall(function() CollectOrbs() end)
 --end
 --end)
 
 ---------------
 
 section2:addToggle("Auto use triple damage", false, function(autotripledamage)
 
 if autotripledamage == true then
     _G.TripleDamage1 = true
 elseif autotripledamage == false or destroygui then
     _G.TripleDamage1 = false
     end
 
 
 while wait(5) do
   if _G.TripleDamage1 then
     if not game:GetService("Players").LocalPlayer.PlayerGui.Main.Boosts:FindFirstChild("Triple Damage") then
         workspace.__THINGS.__REMOTES["activate boost"]:FireServer({[1] = "Triple Damage"})
     print("Triple damage boost checked")
     end
   end
 end
 end)
 ---------------
 
 section2:addToggle("Auto use triple coins", false, function(autotriplecoins)
 
 if autotriplecoins == true then
     _G.TripleCoins1 = true
 elseif autotriplecoins == false or destroygui then
     _G.TripleCoins1 = false
     end
 
 while wait(5) do
     if _G.TripleCoins1 then
         if not game:GetService("Players").LocalPlayer.PlayerGui.Main.Boosts:FindFirstChild("Triple Coins") then
             workspace.__THINGS.__REMOTES["activate boost"]:FireServer({[1] = "Triple Coins"})
         print("Triple coin boost checked")
     end
   end
 end
 end)
 
 ----------
 
 
 
 ------------------
 -- Misc
 
 
 
 --misc1:addButton("Better Search", function(bettersearchmessage)
  --   require(game:GetService("ReplicatedStorage").Framework.Modules.Client["5 | Message"]).New("Better Search Loaded \nNow you can use type: \n- Pet Name \n- Pet Nickname \n- Pet Rarity (Exclusive, Mythical, Legendary, Epic, Rare, Basic) \n- Pet Type (Dark Natter, Rainbow, Gold and Normal \n- Enchants like Royalty etc")
  ---   print("Pet Counter Loaded")
  --   loadstring(game:HttpGet('https://pastebinp.com/raw/JUEtgq95'))()
 --end)
 
 ------------------
 
 --misc1:addButton("Pet Counter", function(petcountermessage)
    -- print("Pet Counter Loaded")
    -- loadstring(game:HttpGet("https://raw.githubusercontent.com/owedits/fartsfx/main/pcounfart.lua", true))()
   --  if petcountermessage then
   --      venyx:Notify("Pet Counter Started", "Click F9 to check counted pets")
   --  end
 --end)
 
 -------------------------------------------------------------------------------------------------
 --page2
 
 local pathToScript = game.Players.LocalPlayer.PlayerScripts.Scripts.Game['Open Eggs']
 local oldFunc = getsenv(pathToScript).OpenEgg
 ----
 local Eggs = {}
 for i,v in pairs(game.ReplicatedStorage.Game.Eggs:GetChildren()) do
     for i2,v2 in pairs(v:GetChildren()) do
         table.insert(Eggs, v2.Name)
     end
 end
 
 eggs1:addDropdown("Select egg", Eggs, function(eggor)
     if eggor then
         _G.Egg = eggor
     end
     --print("Text: ", eggor)
     --print("_G.Egg: ", _G.Egg)
 end)
 
 ----
 eggs1:addToggle("Remove egg opening animation", false, function(delanimation)
     if delanimation == true then
         getsenv(pathToScript).OpenEgg = function() return end
     else
         getsenv(pathToScript).OpenEgg = oldFunc
     end
 end)
 
 -------------------------------------------------------------------------------------------------
 
 eggs1:addToggle("Use triple eggs | Only if you have the pass", false, function(triplegamepass)
 
 if triplegamepass == true then
     _G.TripleEgg = true
 elseif triplegamepass == false or destroygui then
     _G.TripleEgg = false
     end
 end)
 
 _G.TripleEgg = false
 
 -------------------------------------------------------------------------------------------------
 
 
 ----------------------------
 
 eggs1:addToggle("Enable automated egg opener.", false, function(dropegg)
 shared.toggle3drop = dropegg
 end)
 local openeegg = eggor
 game:GetService("RunService").RenderStepped:connect(function()
 if shared.toggle3drop then
     --print("Egg: ", _G.Egg)
     --print("Triple Egg GamePasse: ", _G.TripleEgg)
     local ohTable1 = {
     	[1] = _G.Egg,
     	[2] = _G.TripleEgg
     }
     workspace.__THINGS.__REMOTES["buy egg"]:InvokeServer(ohTable1)
     wait(0.5)
     end
 end)
 
 
 -------------------------------------------------------------------------------------------------
 --Pets
 
 
 local GameLibrary = require(game:GetService("ReplicatedStorage"):WaitForChild("Framework"):WaitForChild("Library"))
 local IDToName = {}
 local NameToID = {}
 local PettoRarity = {}
 local RarityTable = {}
 local PetNamesTable = {}
 local PetNamesTable = {}
 
 for i,v in pairs(GameLibrary.Directory.Pets) do
     IDToName[i] = v.name
     NameToID[v.name] = i
     PettoRarity[i] = v.rarity
     if not table.find(RarityTable, v.rarity) then
         table.insert(RarityTable, v.rarity)
     end
     table.insert(PetNamesTable, v.name)
 end
 
 
 --fuse
 --local PetsList = {'Vampire Bat', 'Werewolf'}
 pets1:addDropdown("Select pet", PetNamesTable, function(petfunc)
     if petfunc then
         _G.SelectedPet = petfunc
         _G.FuseList = {
             {
                 [_G.SelectedPet] = _G.PetCount or 3;
             };
         }
     end
     print("Selected pet: ",  _G.SelectedPet)
 end)
 ------------------------------------------
 local TypeList = {'Normal', 'Gold', 'Rainbow'}
 pets1:addDropdown("Select pet type", TypeList, function(typefunc)
 if typefunc then
     _G.Type = typefunc
 end
 print("Selected type: ", _G.Type)
 end)
 ------------------------------------------
 pets1:addSlider("Select pet amount", 3, 3, 12, function(countfusefunc)
 if countfusefunc then
     _G.PetCount = countfusefunc
     _G.FuseList = {
         {
             [_G.SelectedPet] = _G.PetCount or 3;
         };
     }end
 --print("Selected Count: ", _G.PetCount)
 end)
 ------------------------------------------
 pets1:addToggle("Enable automated fuse", false, function(autofusefunc)
 if autofusefunc == true then
     _G.Enabled = true
     print("_G.Enabled: ", _G.Enabled)
     print("Selected count: ", _G.PetCount)
     print("Selected type: ", _G.Type)
     print("Selected pet: ", _G.SelectedPet)
     loadstring(game:HttpGet('https://raw.githubusercontent.com/inceldom/skid/main/fuzefart.lua'))() -- runs script as I use while wait and _G.enabled so loop ends when _G.enabled is false
 elseif autofusefunc == false then
     _G.Enabled = false
     print("_G.Enabled: ", _G.Enabled)
 end
 --Set globals so script doesn't error--
 _G.Enabled = false
 _G.Type = "Rainbow"
 _G.FuseList = {{}}
 end)
 ---------------------------------------
 --auto gold/rainbow
 
 pets2:addSlider("Select pet amount", 0, 1, 6, function(countcombinefunc)
     if countcombinefunc then
         _G.CountCombineFunc1 = countcombinefunc
     end
     --print("Selected Combine Count: ", _G.CountCombineFunc1)
 end)
 
 ------------------------------------------
 
 pets2:addToggle("Auto golden", false, function(togglegoldfunc)
 
 if togglegoldfunc == true then
     _G.ToggleGold = true
 elseif togglegoldfunc == false then
     _G.ToggleGold = false
 end
 end)
 
 
 pets2:addToggle("Auto rainbow", false, function(toggleraibowfunc)
 
 if toggleraibowfunc == true then
     _G.ToggleRainbow = true
 elseif toggleraibowfunc == false then
     _G.ToggleRainbow = false
 end
 end)
 
 ---------------------------------------
 
 --pets2:addToggle("Allow Mythical", false, function(allowmythicalfunc)
 
 --_G.AllowMythicals = false
 
 --if allowmythicalfunc == true then
 --    _G.AllowMythicals = true
 --elseif allowmythicalfunc == false then
 --    _G.AllowMythicals = false
 --end
 --end)
 
 ---------------------------------------
 
 pets2:addToggle("Enable automated golden or rainbow", false, function(autocombinefunc)
 
 if autocombinefunc == true then
     _G.AutoCom = true
 elseif autocombinefunc == false then
     _G.AutoCom = false
 end
 
 while wait() and _G.AutoCom do
     for i, v in pairs(GetPets()) do
         if #v >= _G.CountCombineFunc1 and _G.AutoCom then
             if string.find(i, "Normal") and _G.AutoCom and _G.ToggleGold then
                 local Args = {}
                 for eeeee = 1, _G.CountCombineFunc1 do
                     Args[#Args+1] = v[#Args+1]
                 end
                 Library.Network.Invoke("use golden machine", Args)
 
             elseif string.find(i, "Gold") and _G.AutoCom and _G.ToggleRainbow then
                 local Args = {}
                 for eeeee = 1, _G.CountCombineFunc1 do
                     Args[#Args+1] = v[#Args+1]
                 end
                 Library.Network.Invoke("use rainbow machine", Args)
             end
         end
     end
 end
 
 --spawn(function()
 --    while wait() and _G.AutoCom do
 --        if not _G.ToggleGold and not _G.ToggleRainbow then
 --            repeat wait(1) until _G.ToggleGold or _G.ToggleRainbow
 --        end
 --        if tonumber(_G.CountCombineFunc1) == nil then
 --            repeat wait() until tonumber(_G.CountCombineFunc1) ~= nil
 --        end
 --        for i, v in pairs(GetPets()) do
 --            if #v >= _G.CountCombineFunc1 and (_G.ToggleGold or _G.ToggleRainbow) then
 --                if string.find(i, "Normal") and _G.ToggleGold then
 --                    local Args = {}
 --                    for eeeee = 1, _G.CountCombineFunc1 do
 --                        Args[#Args+1] = v[#Args+1]
 --                    end
 --                    GameLibrary.Network.Invoke("use golden machine", Args)
 --                elseif string.find(i, "Gold") and _G.ToggleRainbow then
 --                    local Args = {}
 --                    for eeeee = 1, _G.CountCombineFunc1 do
 --                        Args[#Args+1] = v[#Args+1]
 --                    end
 --                    GameLibrary.Network.Invoke("use rainbow machine", Args)
 --                end
 --            end
 --        end
 --    end
 --end)
 end)
 
 ---------------------------------------------------
 --enchanting
 
 --local EnchantsList = {
 --    'Magnet',
 --    'Royalty',
 --    'Glittering',
 --    'Tech Coins',
 --    'Fantasy Coins',
 --    'Coins',
 --    'Teamwork',
 --    'Diamonds',
 --    'Strength',
 --    'Chests',
 --    'Presents',
 --    'Agility',
 --    'Charm'
 --}
 --
 --pets3:addDropdown("Select Enchant", EnchantsList, function(selectenchantfunc)
 --    if selectenchantfunc then
 --        _G.SelEnchant1 = selectenchantfunc
 --    end
 --    print("Selected Enchant: ", _G.SelEnchant1)
 --end)
 --
 ---------------------------
 --
 --local EnchantLevel = {1, 2, 3, 4, 5}
 --pets3:addDropdown("Select Level", EnchantLevel, function(selectnumlevel)
 --    if selectnumlevel then
 --        _G.SelLevel1 = selectnumlevel
 --    end
 --    print("Selected Level: ", _G.SelLevel1)
 --end)
 --
 ---------------------------
 --
 --pets3:addButton("Start Enchant Equiped", function()
 --
 --_G.SelEnchant1 = 'Tech Coins'
 --_G.SelLevel1 = 5
 --_G.EMERGENCYSTOP = false
 --
 --local Wanted = {
 --[_G.SelEnchant1] = _G.SelLevel1 or 1;
 --}
 --
 --local PettoRarity = {}
 --local a = require(game:GetService("ReplicatedStorage").Framework.Modules["1 | Directory"].Pets["Grab All Pets"])
 --for i, v in pairs(a) do
 --PettoRarity[i] = v.rarity
 --end
 --
 --function GetPetTable(PetUID)
 --local Library = require(game:GetService("ReplicatedStorage").Framework.Library)
 --for i, v in pairs(Library.Save.Get().Pets) do
 --    if v.uid == PetUID then
 --        return v
 --    end
 --end
 --end
 --workspace.__THINGS.__REMOTES.MAIN:FireServer("b", "enchant pet")
 --wait(0.5)
 --local Library = require(game:GetService("ReplicatedStorage").Framework.Library)
 --for i, v in pairs(Library.Save.Get().Pets) do
 --if v.e and PettoRarity[v.id] ~= 'Mythical' and not _G.EMERGENCYSTOP then
 --    local haspower = false
 --    repeat wait()
 --        if GetPetTable(v.uid).powers then
 --            for a, b in pairs(GetPetTable(v.uid).powers) do
 --                warn(b[1], b[2])
 --                print(Wanted[b[1]])
 --                if Wanted[b[1]] ~= nil and not haspower and not _G.EMERGENCYSTOP then
 --                    if Wanted[b[1]] <= b[2] then
 --                        haspower = true
 --                        warn("Pet", v.uid, "has", b[1], b[2])
 --                    end
 --                end
 --            end
 --            if not haspower and not _G.EMERGENCYSTOP then
 --                print("Yea we kinda need new enchantments on", v.uid)
 --
 --                workspace.__THINGS.__REMOTES["enchant pet"]:InvokeServer({[1] = v.uid})
 --                wait(0.1)
 --            end
 --        else
 --            warn("taking", v.uid,'\'s enchanting virginity lol')
 --            workspace.__THINGS.__REMOTES["enchant pet"]:InvokeServer({[1] = v.uid})
 --            wait(0.1)
 --        end
 --    until haspower == true or Library.Save.Get().Diamonds < 10000 or _G.EMERGENCYSTOP
 --end
 --end
 --
 ----loadstring(game:HttpGet('https://raw.githubusercontent.com/owedits/fartsfx/main/enchfart.lua'))()
 --end)
 -------------------------
 
 --pets3:addButton("FORCE STOP ENCHANT", function(emergstop)
 --    if emergstop then
 --        _G.EMERGENCYSTOP = true
 --    end
 --    print("Emergency Enchant Stop")
 --end)
 
 
 
 
 -------------------------------------------------------------------------------------------------
 --Dark Matter
 
 pets4:addButton("Remaining Time Check", function()
         local PetList = {}
         for i,v in pairs(GameLibrary.Directory.Pets) do
         PetList[i] = v.name
         end
 
         local returnstring = ""
         for i,v in pairs(GameLibrary.Save.Get().DarkMatterQueue) do
             local timeleft = 'Ready.'
             if math.floor(v.readyTime - os.time()) > 0 then
                 timeleft = SecondsToClock(math.floor(v.readyTime - os.time()))
             end
             local stringthing = PetList[v.petId] .." going to be ready in: ".. timeleft
             returnstring = returnstring .. stringthing .. "\n"
         end
         require(game:GetService("ReplicatedStorage").Framework.Modules.Client["5 | Message"]).New(returnstring)
 end)
 
 
 -------------------------------
 
 pets4:addDropdown("Select pet to dark matter", PetNamesTable, function(value)
 
 if value then
     _G.NameOfPet = value
 end
 print("dark matter enabled", value)
 end)
 
 -------------------------------
 
 pets4:addSlider("Select amount of pets to dark matter", 0, 1, 6, function(countdarkmatterfunc)
     if countdarkmatterfunc then
         _G.CountDarkMatterFunc1 = countdarkmatterfunc
     end
     --print("Selected Dark Matter Count: ", _G.CountDarkMatterFunc1)
 end)
 
 
 -------------------------------
 
 pets4:addToggle("Enable auto-making dark matter pets", false, function(automakedarkmatters)
 
 if automakedarkmatters == true then
     _G.AutoMakeDarkMatter = true
 elseif automakedarkmatters == false then
     _G.AutoMakeDarkMatter = false
 end
 
 
     while task.wait() and _G.AutoMakeDarkMatter do
         local Save = GameLibrary.Save.Get()
         local Slots = Save.DarkMatterSlots
         local Queued = 0
         for a, b in pairs(Save.DarkMatterQueue) do
             Queued = Queued + 1
         end
         local Slots = Slots - Queued
         for count = 1, Slots do
             if Slots - count >= 0 then
                 local PetList = {}
                 for i,v in pairs(GameLibrary.Save.Get().Pets) do
                     if #PetList < _G.CountDarkMatterFunc1 and v.r and IDToName[v.id] == _G.NameOfPet then
                         table.insert(PetList, v.uid)
                     end
                 end
                 if #PetList >= _G.CountDarkMatterFunc1 then
                     local tablething = {[1] = {}}
                     for eeek = 1, _G.CountDarkMatterFunc1 do
                         tablething[1][eeek] = PetList[eeek]
                     end
                     workspace.__THINGS.__REMOTES["convert to dark matter"]:InvokeServer(tablething)
                 end
             end
         end
         task.wait(15)
     end
 end)
 
 -------------------------------
 pets4:addToggle("Enable auto-claiming dark matter pets", false, function(autoclaimdark)
 
 if autoclaimdark == true then
     _G.AutoClaimDarkMatter = true
 elseif autoclaimdark == false then
     _G.AutoClaimDarkMatter = false
 end
 
 spawn(function()
     while task.wait() and _G.AutoClaimDarkMatter do
         for i,v in pairs(GameLibrary.Save.Get().DarkMatterQueue) do
             if math.floor(v.readyTime - os.time()) < 0 then
                 workspace.__THINGS.__REMOTES["redeem dark matter pet"]:InvokeServer({[1] = i})
             end
             end
         task.wait(15)
     end
 end)
 end)
 
 
 -------------------------------------------------------------------------------------------------
 --page3
 
 
 section2:addToggle("Auto collect rewards [Both VIP and Rank.]", false, function(autorewards)
 
 if autorewards == true then
     _G.AutoRewards1 = true
 elseif autorewards == false then
     _G.AutoRewards1 = false
 end
 
 while task.wait() and _G.AutoRewards1 do
 	workspace.__THINGS.__REMOTES["redeem vip rewards"]:InvokeServer({})
 	workspace.__THINGS.__REMOTES["redeem rank rewards"]:InvokeServer({})
 end
 
 
 --shared.toggle3rewards = rewards
 --game:GetService("RunService").RenderStepped:connect(function()
 --if shared.toggle3rewards then
 --    workspace.__THINGS.__REMOTES["redeem vip rewards"]:InvokeServer({})
 --    workspace.__THINGS.__REMOTES["redeem rank rewards"]:InvokeServer({})
 --end
 
 
 --if shared.toggle3rewards == true then
     --if game:GetService("Workspace")["__MAP"].Interactive["Rank Rewards"].Pad.BillboardGui.Timer.Text == "Redeem!" and game:GetService("Workspace")["__MAP"].Interactive["Rank Rewards"].Pad.BillboardGui.Timer.Text == "Redeem!"  then
     --local Library = require(game:GetService("ReplicatedStorage").Framework.Library)
     --Library.Network.Invoke("redeem rank rewards", {})
     --end
     --end
 end)
 
 section2:addButton("Stats Tracker", function()
     loadstring(game:HttpGet('https://raw.githubusercontent.com/inceldom/skid/main/trak.lua'))()
     print("Stats tracked activated")
 end)
 -------------------------------------------------------------------------------------------------
 
 
 misc1:addToggle("Give gamepasses [Some are visual.]", false, function(gamepasses)
 shared.toggle3gamepasses = gamepasses
 game:GetService("RunService").RenderStepped:connect(function()
 if shared.toggle3gamepasses then
     local main = debug.getupvalues(require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library")).Save.Get)[2][game.Players.LocalPlayer].save.Gamepasses
 		table.insert(main,18674296)
 		table.insert(main,18674298)
 		table.insert(main,18674321)
 		table.insert(main,21176989)
 		table.insert(main,21583760)
 		table.insert(main,21641016)
 		table.insert(main,22596039)
 		table.insert(main,18674307)
     end
 end)
 end)
 -------------------------------------------------------------------------------------------------
 
 
 
 -------------------------------------------------------------------------------------------------
 
 misc1:addButton("Anti afk", function()
 print("Anti Afk Loaded")
 local GC = getconnections or get_signal_cons
 if GC then
     for i,v in pairs(GC(game.Players.LocalPlayer.Idled)) do
         if v["Disable"] then
             v["Disable"](v)
         elseif v["Disconnect"] then
             v["Disconnect"](v)
         end
     end
 else
     print("Unlucky.")
     local vu = game:GetService("VirtualUser")
     game:GetService("Players").LocalPlayer.Idled:connect(function()
         vu:Button2Down(Vector2.new(0,0),workspace.CurrentCamera.CFrame)
         wait(1)
         vu:Button2Up(Vector2.new(0,0),workspace.CurrentCamera.CFrame)
     end)
 end
 
 local VirtualUser=game:service'VirtualUser'
 game:service'Players'.LocalPlayer.Idled:connect(function()
 VirtualUser:CaptureController()
 VirtualUser:ClickButton2(Vector2.new())
 end)
 end)
 -------------------------------------------------------------------------------------------------
 
 local function ByeLAG()
         game:GetService("Players").LocalPlayer.PlayerScripts.Scripts.GUIs["Coin Rewards HUD"].Disabled = true
         local a = game:GetService("Workspace")["__DEBRIS"]
         local b = a:Clone()
         b.Parent = a.Parent
         a:Destroy()
         for _,v in pairs(b:GetChildren()) do
             if v.Name == 'RewardBillboard' then
                 v:Destroy()
             end
         end
         if game:GetService("Players").LocalPlayer.PlayerGui.Settings.Frame.Container.ShowOtherPets.Toggle.Label.Text == "Yes" then
             workspace.__THINGS.__REMOTES["toggle setting"]:FireServer({[1] = "ShowOtherPets"})
         end
     end
 
 --misc1:addButton("Lag Reduction", function(AutoAntiLag)
    -- if AutoAntiLag then
     --    ByeLAG()
    -- end
   --  print("Lag Reduction Loaded")
 --end)
 
 -------------------------------------------------------------------------------------------------
 
 misc1:addButton("Lag reducer [Good for AFKing.]", function()
     loadstring(game:HttpGet('https://raw.githubusercontent.com/inceldom/skid/main/fps.lua'))()
     print("Lag reducer activated")
 end)
 
 -------------------------------------------------------------------------------------------------
 --Remote Things
 --misc2:addButton("Pet Collection", function()
   --  game:GetService("Players").LocalPlayer.PlayerGui.Collection.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.Collection.Enabled
 --end)
 
 --	misc2:addButton("Fuse Pets", function()
 --		game:GetService("Players").LocalPlayer.PlayerGui.FusePets.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.FusePets.Enabled
 --	end)
 
 --	misc2:addButton("Gold Machine", function()
 --		game:GetService("Players").LocalPlayer.PlayerGui.Golden.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.Golden.Enabled
 --	end)
 
 --	misc2:addButton("Rainbow Machine", function()
 	--	game:GetService("Players").LocalPlayer.PlayerGui.Rainbow.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.Rainbow.Enabled
 --	end)
 
 --	misc2:addButton("Dark Matter Machine", function()
 --		game:GetService("Players").LocalPlayer.PlayerGui.DarkMatter.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.DarkMatter.Enabled
 --	end)
 
 --	misc2:addButton("Merchant", function()
 --		game:GetService("Players").LocalPlayer.PlayerGui.Merchant.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.Merchant.Enabled
 --	end)
 
 --	misc2:addButton("Enchant", function()
 --		game:GetService("Players").LocalPlayer.PlayerGui.EnchantPets.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.EnchantPets.Enabled
 --	end)
 
 --	misc2:addButton("Spooky Upgrades", function()
 	--	game:GetService("Players").LocalPlayer.PlayerGui.SpookyUpgrades.Enabled = not game:GetService("Players").LocalPlayer.PlayerGui.SpookyUpgrades.Enabled
 	--end)
 
 -------------------------------------------------------------------------------------------------
 --Troll Page
 
 --	troll1:addButton("Visual Dupe Gems", function()
 --	function comma_value(amount)
 --	  local formatted = amount
 --	  while true do
 --		formatted, k = string.gsub(formatted, "^(-?%d+)(%d%d%d)", '%1,%2')
 --		if (k == 0) then
 --		  break
 --		end
 --	  end
 --	  return formatted
 --	end
 --
 --	local diamonds = game.Players.LocalPlayer.PlayerGui.Main.Right.Diamonds.Amount
 --	local old = diamonds.Text
 --	local oldNumber = string.gsub(old, ",", "")
 --	local newNumber = oldNumber * 2
 --	local new = comma_value(newNumber)
 --	local newString = tostring(new)
 --	diamonds.Text = newString
 --	end)
 
 
 -------------------------------------------------------------------------------------------------
 for theme, color in pairs(themes) do -- all in one theme changer, i know, im cool
 Settings2:addColorPicker(theme, color, function(color3)
 venyx:setTheme(theme, color3)
 end)
 end
 -------------------------------------------------------------------------------------------------
 
 
 -- load
 venyx:SelectPage(venyx.pages[1], true)