CYBIX MOD EXECUTER

 p = :().LocalPlayer
 rs = :()

 g = .()
g.Name = 
g.ResetOnSpawn = 
g.ZIndexBehavior = .ZIndexBehavior.Sibling
g.Parent = p:()


 f = .(, g)
f.Size = .(, , , )
f.Position = .(, -, , -)
f.BackgroundColor3 = .(, , )
f.BorderSizePixel = 
f.Active = 
.(, f).CornerRadius = .(, )


.(()
     f.Parent 
         i = , ,  
              f.Parent   
            f.BackgroundColor3 = .(i, , )
            .()
        
    
)


 h = .(, f)
h.Size = .(, , , )
h.BackgroundColor3 = .(, , )
h.BorderSizePixel = 
.(, h).CornerRadius = .(, )

 title = .(, h)
title.Size = .(, -, , )
title.Position = .(, , , )
title.BackgroundTransparency = 
title.Text = 
title.TextColor3 = .(, , )
title.Font = .Font.GothamBold
title.TextScaled = 


 x = .(, h)
x.Size = .(, , , )
x.Position = .(, -, , -)
x.BackgroundColor3 = .(, , )
x.Text = 
x.TextColor3 = .(, , )
x.Font = .Font.GothamBold
x.TextScaled = 
x.BorderSizePixel = 
.(, x).CornerRadius = .(, )
x.MouseButton1Click:(()
    g:()
)



     dragging, dragInput, dragStart, startPos
    h.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            dragging = 
            dragStart = input.Position
            startPos = f.Position
            input.Changed:(()
                 input.UserInputState == .UserInputState.End 
                    dragging = 
                
            )
        
    )

    h.InputChanged:((input)
         input.UserInputType == .UserInputType.MouseMovement 
            dragInput = input
        
    )

    rs.RenderStepped:(()
         dragging  dragInput 
             delta = dragInput.Position - dragStart
            f.Position = .(
                startPos.X.Scale,
                startPos.X.Offset + delta.X,
                startPos.Y.Scale,
                startPos.Y.Offset + delta.Y
            )
        
    )



 sidebar = .(, f)
sidebar.Size = .(, , , -)
sidebar.Position = .(, , , )
sidebar.BackgroundColor3 = .(, , )
sidebar.BorderSizePixel = 
.(, sidebar).CornerRadius = .(, )

 sLayout = .(, sidebar)
sLayout.Padding = .(, )
sLayout.HorizontalAlignment = .HorizontalAlignment.Center
sLayout.SortOrder = .SortOrder.LayoutOrder

  (name, order)
     b = .(, sidebar)
    b.Size = .(, -, , )
    b.LayoutOrder = order
    b.BackgroundColor3 = .(, , )
    b.TextColor3 = .(, , )
    b.Font = .Font.GothamBold
    b.TextScaled = 
    b.Text = name
    b.BorderSizePixel = 
    .(, b).CornerRadius = .(, )
     b


 tabDesign  = (, )
 tabHelp    = (, )
 tabConsole = (, )
 tabHI      = (, )


 content = .(, f)
content.Size = .(, -, , -)
content.Position = .(, , , )
content.BackgroundColor3 = .(, , )
content.BorderSizePixel = 
.(, content).CornerRadius = .(, )

 pages = {}
 currentPage

  ()
     p = .(, content)
    p.Size = .(, -, , -)
    p.Position = .(, , , )
    p.BackgroundTransparency = 
    p.Visible = 
     p


  (name)
     currentPage 
        currentPage.Visible = 
    
    currentPage = pages[name]
     currentPage 
        currentPage.Visible = 
    



 pageDesign = ()
pages[] = pageDesign

 editorFrame = .(, pageDesign)
editorFrame.Size = .(, -, , -)
editorFrame.Position = .(, , , )
editorFrame.BackgroundColor3 = .(, , )
editorFrame.BorderSizePixel = 
.(, editorFrame).CornerRadius = .(, )

 editorScroll = .(, editorFrame)
editorScroll.Size = .(, -, , -)
editorScroll.Position = .(, , , )
editorScroll.BackgroundTransparency = 
editorScroll.ScrollBarThickness = 
editorScroll.CanvasSize = .(, , , )

 editorBox = .(, editorScroll)
editorBox.Size = .(, -, , )
editorBox.Position = .(, , , )
editorBox.BackgroundTransparency = 
editorBox.TextColor3 = .(, , )
editorBox.Font = .Font.Code
editorBox.TextSize = 
editorBox.MultiLine = 
editorBox.ClearTextOnFocus = 
editorBox.TextWrapped = 
editorBox.TextXAlignment = .TextXAlignment.Left
editorBox.TextYAlignment = .TextYAlignment.Top
editorBox.Text = 


 pageHelp = ()
pages[] = pageHelp

 helpTitle = .(, pageHelp)
helpTitle.Size = .(, -, , )
helpTitle.Position = .(, , , )
helpTitle.BackgroundTransparency = 
helpTitle.TextColor3 = .(, , )
helpTitle.Font = .Font.GothamBold
helpTitle.TextScaled = 
helpTitle.Text = 

 promptBox = .(, pageHelp)
promptBox.Size = .(, -, , )
promptBox.Position = .(, , , )
promptBox.BackgroundColor3 = .(, , )
promptBox.TextColor3 = .(, , )
promptBox.Font = .Font.Code
promptBox.TextSize = 
promptBox.MultiLine = 
promptBox.ClearTextOnFocus = 
promptBox.TextWrapped = 
promptBox.TextXAlignment = .TextXAlignment.Left
promptBox.TextYAlignment = .TextYAlignment.Top
promptBox.Text = 
.(, promptBox).CornerRadius = .(, )

 genButton = .(, pageHelp)
genButton.Size = .(, , , )
genButton.Position = .(, , , )
genButton.BackgroundColor3 = .(, , )
genButton.Text = 
genButton.TextColor3 = .(, , )
genButton.Font = .Font.GothamBold
genButton.TextScaled = 
genButton.BorderSizePixel = 
.(, genButton).CornerRadius = .(, )

 helpInfo = .(, pageHelp)
helpInfo.Size = .(, -, , )
helpInfo.Position = .(, , , )
helpInfo.BackgroundTransparency = 
helpInfo.TextColor3 = .(, , )
helpInfo.Font = .Font.Gotham
helpInfo.TextSize = 
helpInfo.TextWrapped = 
helpInfo.TextXAlignment = .TextXAlignment.Left
helpInfo.Text = 


 pageConsole = ()
pages[] = pageConsole

 consoleFrame = .(, pageConsole)
consoleFrame.Size = .(, -, , -)
consoleFrame.Position = .(, , , )
consoleFrame.BackgroundColor3 = .(, , )
consoleFrame.ScrollBarThickness = 
consoleFrame.CanvasSize = .(, , , )
.(, consoleFrame).CornerRadius = .(, )

 consoleLayout = .(, consoleFrame)
consoleLayout.Padding = .(, )
consoleLayout.SortOrder = .SortOrder.LayoutOrder

 clearWarningsButton = .(, pageConsole)
clearWarningsButton.Size = .(, , , )
clearWarningsButton.Position = .(, -, , -)
clearWarningsButton.BackgroundColor3 = .(, , )
clearWarningsButton.Text = 
clearWarningsButton.TextColor3 = .(, , )
clearWarningsButton.Font = .Font.GothamBold
clearWarningsButton.TextScaled = 
clearWarningsButton.BorderSizePixel = 
.(, clearWarningsButton).CornerRadius = .(, )

  (kind, msg, fix)
     row = .(, consoleFrame)
    row.Size = .(, -, , )
    row.BackgroundTransparency = 

     icon = .(, row)
    icon.Size = .(, , , )
    icon.BackgroundTransparency = 
    icon.Font = .Font.GothamBold
    icon.TextScaled = 

     text = .(, row)
    text.Size = .(, -, , )
    text.Position = .(, , , )
    text.BackgroundTransparency = 
    text.Font = .Font.Gotham
    text.TextSize = 
    text.TextWrapped = 
    text.TextXAlignment = .TextXAlignment.Left
    text.TextYAlignment = .TextYAlignment.Top

     kind ==  
        icon.Text = 
        icon.TextColor3 = .(, , )
        text.TextColor3 = .(, , )
     kind ==  
        icon.Text = 
        icon.TextColor3 = .(, , )
        text.TextColor3 = .(, , )
    
        icon.Text = 
        icon.TextColor3 = .(, , )
        text.TextColor3 = .(, , )
    

     ts = .()
     fix  fix ~=  
        text.Text =  .. ts ..  .. msg ..  .. fix
    
        text.Text =  .. ts ..  .. msg
    

    consoleFrame.CanvasSize = .(, , , consoleLayout.AbsoluteContentSize.Y + )
    consoleFrame.CanvasPosition = .(, .(, consoleLayout.AbsoluteContentSize.Y - consoleFrame.AbsoluteSize.Y))


clearWarningsButton.MouseButton1Click:(()
     _, child  (consoleFrame:()) 
         child:() 
             icon = child:()
             icon  icon.Text ==  
                child:()
            
        
    
    consoleFrame.CanvasSize = .(, , , consoleLayout.AbsoluteContentSize.Y + )
)

  (code)
     fn, err = (code)
      fn 
        (,  .. (err), )
        
    
     ok, runtimeErr = (fn)
      ok 
        (,  .. (runtimeErr), )
    
        (, , )
    


 execButton = .(, pageDesign)
execButton.Size = .(, , , )
execButton.Position = .(, , , -)
execButton.BackgroundColor3 = .(, , )
execButton.Text = 
execButton.TextColor3 = .(, , )
execButton.Font = .Font.GothamBold
execButton.TextScaled = 
execButton.BorderSizePixel = 
.(, execButton).CornerRadius = .(, )

execButton.MouseButton1Click:(()
     s = editorBox.Text
     s ~=  
        (s)
        ()
    
)

 clearButton = .(, pageDesign)
clearButton.Size = .(, , , )
clearButton.Position = .(, -, , -)
clearButton.BackgroundColor3 = .(, , )
clearButton.Text = 
clearButton.TextColor3 = .(, , )
clearButton.Font = .Font.GothamBold
clearButton.TextScaled = 
clearButton.BorderSizePixel = 
.(, clearButton).CornerRadius = .(, )

clearButton.MouseButton1Click:(()
    editorBox.Text = 
)

  (prompt)
     s = prompt:()
     s:() 
         
    
     s:() 
         
    
     s:() 
         
    
     s:()  s:() 
         
    

    (, , )
     


genButton.MouseButton1Click:(()
     scriptText = (promptBox.Text)
    editorBox.Text = scriptText
    ()
)


 pageHI = ()
pages[] = pageHI

 hiTitle = .(, pageHI)
hiTitle.Size = .(, -, , )
hiTitle.Position = .(, , , )
hiTitle.BackgroundTransparency = 
hiTitle.TextColor3 = .(, , )
hiTitle.Font = .Font.GothamBold
hiTitle.TextScaled = 
hiTitle.Text = 

 injectBtn = .(, pageHI)
injectBtn.Size = .(, , , )
injectBtn.Position = .(, -, , -)
injectBtn.BackgroundColor3 = .(, , )
injectBtn.Text = 
injectBtn.TextColor3 = .(, , )
injectBtn.Font = .Font.GothamBold
injectBtn.TextScaled = 
injectBtn.BorderSizePixel = 
.(, injectBtn).CornerRadius = .(, )

.(()
     injectBtn.Parent 
         i = ,, 
            injectBtn.BackgroundColor3 = .(, ,  * i)
            .()
        
         i = ,, 
            injectBtn.BackgroundColor3 = .( * i, , )
            .()
        
         i = ,, 
            injectBtn.BackgroundColor3 = .( * i,  * i,  * i)
            .()
        
    
)


 CYBIX_PAID_SCRIPT = fields exist
runtimeState.miniCoins = runtimeState.miniCoins or 0        -- coins earned from memory game
runtimeState.clickerClicks = runtimeState.clickerClicks or 0
runtimeState.clickerValue = runtimeState.clickerValue or 1 -- clicks per manual click
runtimeState.autoClickRate = runtimeState.autoClickRate or 0 -- clicks per second from autos
runtimeState.autoClickAccumulator = runtimeState.autoClickAccumulator or 0

----------------------------------------------------------------
-- Top-right coin display (for the page)
----------------------------------------------------------------
local coinLabel = Instance.new("TextLabel", mgSection)
coinLabel.Size = UDim2.new(0,120,0,28)
coinLabel.Position = UDim2.new(1,-132,0,8)
coinLabel.BackgroundColor3 = Color3.fromRGB(40,40,48)
coinLabel.TextColor3 = Color3.fromRGB(255,215,80)
coinLabel.Font = Enum.Font.GothamBold
coinLabel.TextSize = 14
coinLabel.Text = "Coins: " .. tostring(runtimeState.miniCoins)
coinLabel.TextScaled = false
coinLabel.BorderSizePixel = 0
Instance.new("UICorner", coinLabel).CornerRadius = UDim.new(0,6)

local function updateCoinLabel()
    coinLabel.Text = "Coins: " .. tostring(runtimeState.miniCoins)
end

----------------------------------------------------------------
-- MEMORY / TYPING GAME (unchanged layout, added sentences)
----------------------------------------------------------------

local memFrame = Instance.new("Frame", mgSection)
memFrame.Size = UDim2.new(1,-16,0,160)
memFrame.Position = UDim2.new(0,8,0,44)
memFrame.BackgroundColor3 = Color3.fromRGB(34,34,40)
memFrame.BorderSizePixel = 0
Instance.new("UICorner", memFrame).CornerRadius = UDim.new(0,8)

local memTitle = Instance.new("TextLabel", memFrame)
memTitle.Size = UDim2.new(1,-16,0,28)
memTitle.Position = UDim2.new(0,8,0,6)
memTitle.BackgroundTransparency = 1
memTitle.Text = "Memory Typing"
memTitle.TextColor3 = Color3.fromRGB(230,230,230)
memTitle.Font = Enum.Font.GothamBold
memTitle.TextScaled = true

local memDisplay = Instance.new("TextLabel", memFrame)
memDisplay.Size = UDim2.new(1,-16,0,48)
memDisplay.Position = UDim2.new(0,8,0,44)
memDisplay.BackgroundTransparency = 1
memDisplay.TextColor3 = Color3.fromRGB(200,200,220)
memDisplay.Font = Enum.Font.Gotham
memDisplay.TextSize = 18
memDisplay.TextWrapped = true
memDisplay.Text = "Press Start to play"
memDisplay.TextXAlignment = Enum.TextXAlignment.Center
memDisplay.TextYAlignment = Enum.TextYAlignment.Center

local memInput = Instance.new("TextBox", memFrame)
memInput.Size = UDim2.new(1,-16,0,28)
memInput.Position = UDim2.new(0,8,0,100)
memInput.BackgroundColor3 = Color3.fromRGB(45,45,55)
memInput.TextColor3 = Color3.fromRGB(240,240,240)
memInput.Font = Enum.Font.Gotham
memInput.TextSize = 14
memInput.PlaceholderText = "Type the sentence exactly..."
memInput.ClearTextOnFocus = false
Instance.new("UICorner", memInput).CornerRadius = UDim.new(0,6)

local memStartBtn = Instance.new("TextButton", memFrame)
memStartBtn.Size = UDim2.new(0,100,0,28)
memStartBtn.Position = UDim2.new(1,-108,0,100)
memStartBtn.BackgroundColor3 = Color3.fromRGB(70,70,90)
memStartBtn.TextColor3 = Color3.fromRGB(255,255,255)
memStartBtn.Font = Enum.Font.GothamBold
memStartBtn.TextSize = 14
memStartBtn.Text = "Start"
Instance.new("UICorner", memStartBtn).CornerRadius = UDim.new(0,6)

local memFeedback = Instance.new("TextLabel", memFrame)
memFeedback.Size = UDim2.new(1,-16,0,20)
memFeedback.Position = UDim2.new(0,8,0,132)
memFeedback.BackgroundTransparency = 1
memFeedback.TextColor3 = Color3.fromRGB(180,255,180)
memFeedback.Font = Enum.Font.Gotham
memFeedback.TextSize = 14
memFeedback.Text = ""

-- Sentences pool (expanded)
local memSentences = {
    "Roblox devs ship updates weekly",
    "Space is mostly empty but full of wonders",
    "Dinosaurs once ruled the land",
    "Lua is lightweight and fast",
    "Practice makes your code cleaner",
    "Keep your UI simple and readable",
    "Test in Studio before publishing",
    "Save often and use version control",
    "Be kind to your fellow devs",
    "Small steps lead to big progress",
    "Always comment tricky parts of your code",
    "Use modules to organize large systems",
    "Playtesting finds the weirdest bugs",
    "Balance is key for fun gameplay",
    "Optimize only after profiling",
    "Use descriptive variable names",
    "Backups save a lot of headaches",
    "Iterate fast, polish slowly",
    "Learn from other creators respectfully",
    "Celebrate small wins with your team"
}

local memCurrent = nil
local memShowing = false
local memHideDelay = 2 -- seconds before sentence disappears
local memTimerConn = nil

local function startMemoryRound()
    if memShowing then
        memFeedback.Text = "Round already in progress"
        return
    end
    memInput.Text = ""
    memFeedback.Text = ""
    memCurrent = memSentences[math.random(1,#memSentences)]
    memDisplay.Text = memCurrent
    memShowing = true

    -- hide after delay
    if memTimerConn then memTimerConn:Disconnect() memTimerConn = nil end
    local t0 = tick()
    memTimerConn = RunService.Heartbeat:Connect(function()
        if tick() - t0 >= memHideDelay then
            memDisplay.Text = "" -- sentence disappears
            memTimerConn:Disconnect()
            memTimerConn = nil
        end
    end)
end

local function submitMemoryAttempt()
    if not memCurrent then
        memFeedback.Text = "Start a round first"
        return
    end
    local attempt = tostring(memInput.Text or "")
    local function trim(s) return s:match("^%s*(.-)%s*$") end
    if trim(attempt) == trim(memCurrent) then
        runtimeState.miniCoins = runtimeState.miniCoins + 1
        updateCoinLabel()
        memFeedback.TextColor3 = Color3.fromRGB(180,255,180)
        memFeedback.Text = "Perfect! +1 coin"
    else
        memFeedback.TextColor3 = Color3.fromRGB(255,140,140)
        memFeedback.Text = "Not exact. Try again!"
    end
    memCurrent = nil
    memShowing = false
    memDisplay.Text = "Press Start to play"
end

memStartBtn.MouseButton1Click:Connect(startMemoryRound)
memInput.FocusLost:Connect(function(enter)
    if enter then submitMemoryAttempt() end
end)

----------------------------------------------------------------
-- CLICKER GAME (click area above, upgrades below in scrollable area)
----------------------------------------------------------------

-- Click area (compact to leave room for upgrades below)
local clickFrame = Instance.new("Frame", mgSection)
clickFrame.Size = UDim2.new(1,-16,0,140)
clickFrame.Position = UDim2.new(0,8,0,216)
clickFrame.BackgroundColor3 = Color3.fromRGB(34,34,40)
clickFrame.BorderSizePixel = 0
Instance.new("UICorner", clickFrame).CornerRadius = UDim.new(0,8)

local clickTitle = Instance.new("TextLabel", clickFrame)
clickTitle.Size = UDim2.new(1,-16,0,28)
clickTitle.Position = UDim2.new(0,8,0,6)
clickTitle.BackgroundTransparency = 1
clickTitle.Text = "Clicker"
clickTitle.TextColor3 = Color3.fromRGB(230,230,230)
clickTitle.Font = Enum.Font.GothamBold
clickTitle.TextScaled = true

local clickButton = Instance.new("TextButton", clickFrame)
clickButton.Size = UDim2.new(0,160,0,80)
clickButton.Position = UDim2.new(0.5,-80,0,44)
clickButton.BackgroundColor3 = Color3.fromRGB(70,70,110)
clickButton.TextColor3 = Color3.fromRGB(255,255,255)
clickButton.Font = Enum.Font.GothamBold
clickButton.TextSize = 20
clickButton.Text = "CLICK"
Instance.new("UICorner", clickButton).CornerRadius = UDim.new(0,12)

local clicksLabel = Instance.new("TextLabel", clickFrame)
clicksLabel.Size = UDim2.new(0,160,0,28)
clicksLabel.Position = UDim2.new(0.5,-80,0,132)
clicksLabel.BackgroundTransparency = 1
clicksLabel.TextColor3 = Color3.fromRGB(240,240,240)
clicksLabel.Font = Enum.Font.Gotham
clicksLabel.TextSize = 16
clicksLabel.Text = "Clicks: " .. tostring(runtimeState.clickerClicks)

clickButton.MouseButton1Click:Connect(function()
    runtimeState.clickerClicks = runtimeState.clickerClicks + runtimeState.clickerValue
    clicksLabel.Text = "Clicks: " .. tostring(runtimeState.clickerClicks)
end)

----------------------------------------------------------------
-- UPGRADES (separate scrollable area below clickFrame to avoid overlap)
----------------------------------------------------------------

local upgradesSection = Instance.new("Frame", mgSection)
upgradesSection.Size = UDim2.new(1,-16,0,160)
upgradesSection.Position = UDim2.new(0,8,0,364)
upgradesSection.BackgroundColor3 = Color3.fromRGB(34,34,40)
upgradesSection.BorderSizePixel = 0
Instance.new("UICorner", upgradesSection).CornerRadius = UDim.new(0,8)

local upgradesTitle = Instance.new("TextLabel", upgradesSection)
upgradesTitle.Size = UDim2.new(1,-16,0,28)
upgradesTitle.Position = UDim2.new(0,8,0,6)
upgradesTitle.BackgroundTransparency = 1
upgradesTitle.Text = "Upgrades"
upgradesTitle.TextColor3 = Color3.fromRGB(230,230,230)
upgradesTitle.Font = Enum.Font.GothamBold
upgradesTitle.TextScaled = true

local upgradesScroll = Instance.new("ScrollingFrame", upgradesSection)
upgradesScroll.Size = UDim2.new(1,-16,1,-44)
upgradesScroll.Position = UDim2.new(0,8,0,36)
upgradesScroll.BackgroundTransparency = 1
upgradesScroll.ScrollBarThickness = 8
local upgradesLayout = Instance.new("UIListLayout", upgradesScroll)
upgradesLayout.Padding = UDim.new(0,8)
upgradesLayout.SortOrder = Enum.SortOrder.LayoutOrder

-- Define upgrades (expandable). Each upgrade: id, name, cost, addValue (manual click increase), addAuto (auto clicks per second)
local upgrades = {
    {id="plus5", name="+5 Clicks per Click", cost=50, addValue=5, addAuto=0},
    {id="plus20", name="+20 Clicks per Click", cost=250, addValue=20, addAuto=0},
    {id="auto1", name="Auto Click +1/sec", cost=100, addValue=0, addAuto=1},
    {id="auto5", name="Auto Click +5/sec", cost=450, addValue=0, addAuto=5}
}

-- Create UI for upgrades and store references for cost labels
local upgradeButtons = {}
for i,up in ipairs(upgrades) do
    local row = Instance.new("Frame", upgradesScroll)
    row.Size = UDim2.new(1,0,0,44)
    row.BackgroundTransparency = 1

    local nameLabel = Instance.new("TextLabel", row)
    nameLabel.Size = UDim2.new(0.6,0,1,0)
    nameLabel.Position = UDim2.new(0,0,0,0)
    nameLabel.BackgroundTransparency = 1
    nameLabel.Text = up.name
    nameLabel.TextColor3 = Color3.fromRGB(220,220,220)
    nameLabel.Font = Enum.Font.Gotham
    nameLabel.TextSize = 14
    nameLabel.TextXAlignment = Enum.TextXAlignment.Left

    local costLabel = Instance.new("TextLabel", row)
    costLabel.Size = UDim2.new(0.25,0,1,0)
    costLabel.Position = UDim2.new(0.6,0,0,0)
    costLabel.BackgroundTransparency = 1
    costLabel.Text = tostring(up.cost)
    costLabel.TextColor3 = Color3.fromRGB(200,200,120)
    costLabel.Font = Enum.Font.GothamBold
    costLabel.TextSize = 14
    costLabel.Name = "CostLabel_" .. up.id

    local buyBtn = Instance.new("TextButton", row)
    buyBtn.Size = UDim2.new(0.15,0,0.8,0)
    buyBtn.Position = UDim2.new(0.86,0,0.1,0)
    buyBtn.BackgroundColor3 = Color3.fromRGB(70,70,90)
    buyBtn.TextColor3 = Color3.fromRGB(255,255,255)
    buyBtn.Font = Enum.Font.GothamBold
    buyBtn.TextSize = 14
    buyBtn.Text = "Buy"
    buyBtn.Name = up.id
    Instance.new("UICorner", buyBtn).CornerRadius = UDim.new(0,6)

    upgradeButtons[up.id] = {button = buyBtn, data = up, costLabel = costLabel}
end

-- Purchase logic (stackable)
for id,entry in pairs(upgradeButtons) do
    entry.button.MouseButton1Click:Connect(function()
        local up = entry.data
        if runtimeState.clickerClicks >= up.cost then
            runtimeState.clickerClicks = runtimeState.clickerClicks - up.cost
            -- apply effects
            runtimeState.clickerValue = runtimeState.clickerValue + (up.addValue or 0)
            runtimeState.autoClickRate = runtimeState.autoClickRate + (up.addAuto or 0)
            clicksLabel.Text = "Clicks: " .. tostring(runtimeState.clickerClicks)
            -- increase cost for next purchase (simple scaling)
            up.cost = math.floor(up.cost * 1.6)
            -- update displayed cost
            if entry.costLabel and entry.costLabel.Parent then
                entry.costLabel.Text = tostring(up.cost)
            end
        else
            -- not enough clicks feedback (flash)
            entry.button.BackgroundColor3 = Color3.fromRGB(140,40,40)
            task.delay(0.25, function() if entry.button and entry.button.Parent then entry.button.BackgroundColor3 = Color3.fromRGB(70,70,90) end end)
        end
    end)
end

-- Auto-click heartbeat
RunService.Heartbeat:Connect(function(dt)
    if runtimeState.autoClickRate and runtimeState.autoClickRate > 0 then
        runtimeState.autoClickAccumulator = runtimeState.autoClickAccumulator + runtimeState.autoClickRate * dt
        local toAdd = math.floor(runtimeState.autoClickAccumulator)
        if toAdd > 0 then
            runtimeState.clickerClicks = runtimeState.clickerClicks + toAdd
            runtimeState.autoClickAccumulator = runtimeState.autoClickAccumulator - toAdd
            clicksLabel.Text = "Clicks: " .. tostring(runtimeState.clickerClicks)
        end
    end
end)

----------------------------------------------------------------
-- End of Mini Games Tab block
----------------------------------------------------------------


----------------------------------------------------------------
-- CYBIX AI TAB (Advanced pseudo-AI, local only)
----------------------------------------------------------------

local aiPage = createPage()
pages["CYBIX AI"] = aiPage

local aiBtn = createSidebarButton("CYBIX AI", 99)
aiBtn.MouseButton1Click:Connect(function() switchPage("CYBIX AI") end)

local aiSection = createSection(aiPage, "CYBIX AI Assistant", 340)

-- Response label
local aiResponse = Instance.new("TextLabel", aiSection)
aiResponse.Size = UDim2.new(1,-16,0,160)
aiResponse.Position = UDim2.new(0,8,0,40)
aiResponse.BackgroundTransparency = 1
aiResponse.TextColor3 = Color3.fromRGB(230,230,230)
aiResponse.Font = Enum.Font.Gotham
aiResponse.TextSize = 14
aiResponse.TextWrapped = true
aiResponse.Text = "CYBIX: Yo, I’m your little brain in the menu. Ask me stuff."

-- Input box
local aiInput = Instance.new("TextBox", aiSection)
aiInput.Size = UDim2.new(1,-16,0,32)
aiInput.Position = UDim2.new(0,8,0,210)
aiInput.BackgroundColor3 = Color3.fromRGB(45,45,55)
aiInput.TextColor3 = Color3.fromRGB(240,240,240)
aiInput.Font = Enum.Font.Gotham
aiInput.TextSize = 14
aiInput.PlaceholderText = "Type here..."
aiInput.ClearTextOnFocus = false
Instance.new("UICorner", aiInput).CornerRadius = UDim.new(0,6)

-- Send button
local aiSend = Instance.new("TextButton", aiSection)
aiSend.Size = UDim2.new(0,80,0,32)
aiSend.Position = UDim2.new(1,-92,0,210)
aiSend.BackgroundColor3 = Color3.fromRGB(70,70,90)
aiSend.TextColor3 = Color3.fromRGB(255,255,255)
aiSend.Font = Enum.Font.GothamBold
aiSend.TextSize = 14
aiSend.Text = "Send"
Instance.new("UICorner", aiSend).CornerRadius = UDim.new(0,6)

----------------------------------------------------------------
-- PERSONALITY SYSTEM
----------------------------------------------------------------

local personality = "buddy" -- "buddy" or "slay"

local function replyBuddy(text)
    return "CYBIX: " .. text
end

local function replySlay(text)
    return "CYBIX: heyyy bestie, " .. text .. " fr slayyy 💅🔥"
end

local function respond(text)
    if personality == "buddy" then
        aiResponse.Text = replyBuddy(text)
    else
        aiResponse.Text = replySlay(text)
    end
end

----------------------------------------------------------------
-- SAFETY FILTER
----------------------------------------------------------------

local blockedWords = {
    "kill","suicide","selfharm","self-harm","unalive",
    "sex","nsfw","porn","r34","r18",
    "faggot","nigga","nigger" -- you can add real bad words here
}

local function isUnsafe(text)
    local lower = text:lower()
    for _,w in ipairs(blockedWords) do
        if lower:find(w) then
            return true
        end
    end
    return false
end

----------------------------------------------------------------
-- FEATURE TOGGLING (uses your existing functions)
----------------------------------------------------------------

local function toggleFeature(feature, state)
    if feature == "fly" then
        if state then startFly() else stopFly() end
        return "Fly is now " .. (state and "ON" or "OFF")
    end

    if feature == "noclip" then
        if state then enableNoclip() else disableNoclip() end
        return "Noclip is now " .. (state and "ON" or "OFF")
    end

    if feature == "esp" then
        if state then enableESP() else disableESP() end
        return "ESP is now " .. (state and "ON" or "OFF")
    end

    if feature == "nametags" then
        if state then enableNameTags() else disableNameTags() end
        return "NameTags are now " .. (state and "ON" or "OFF")
    end

    if feature == "god" or feature == "godmode" then
        if state then enableGodMode() else disableGodMode() end
        return "God Mode is now " .. (state and "ON" or "OFF")
    end

    return "I don’t recognize that feature yet."
end

local function explainFeature(feature)
    local explanations = {
        fly = "Fly lets you move freely in the air using movement keys.",
        noclip = "Noclip lets you walk through solid parts by disabling collisions.",
        esp = "ESP highlights players so you can see them easier.",
        nametags = "Shows floating names above players.",
        god = "God Mode keeps your health extremely high so you don’t die.",
        aimbot = "Aimbot rotates your camera toward targets in a radius."
    }
    return explanations[feature] or "I don’t have info on that yet."
end

----------------------------------------------------------------
-- SIMPLE MATH PARSER (basic + - * / ^)
----------------------------------------------------------------

local function tryMath(expr)
    expr = expr:gsub("%s+","")
    if not expr:match("^[%d%.%+%-%*/%^]+$") then
        return nil
    end

    local ok, result = pcall(function()
        local function evalPow(s)
            local parts = {}
            for part in s:gmatch("[^%^]+") do table.insert(parts, part) end
            local v = tonumber(parts[1])
            if not v then return nil end
            for i = 2, #parts do
                local p = tonumber(parts[i])
                if not p then return nil end
                v = v ^ p
            end
            return v
        end

        local function evalMulDiv(s)
            local acc, lastOp
            for token in s:gmatch("[^%*/]+[%*/]?") do
                local num = token:match("^[^%*/]+")
                local op = token:match("[%*/]")
                local v = evalPow(num)
                if not v then return nil end
                if not acc then
                    acc = v
                else
                    if lastOp == "*" then acc = acc * v end
                    if lastOp == "/" then acc = acc / v end
                end
                lastOp = op
            end
            return acc
        end

        local acc, lastOp
        for token in expr:gmatch("[^%+%-]+[%+%-]?") do
            local num = token:match("^[^%+%-]+")
            local op = token:match("[%+%-]")
            local v = evalMulDiv(num)
            if not v then return nil end
            if not acc then
                acc = v
            else
                if lastOp == "+" then acc = acc + v end
                if lastOp == "-" then acc = acc - v end
            end
            lastOp = op
        end
        return acc
    end)

    if ok and type(result) == "number" then
        return result
    end
    return nil
end

----------------------------------------------------------------
-- CONVERSATION / COMMAND PROCESSOR (keywords + patterns)
----------------------------------------------------------------

local function processCommand(raw)
    if isUnsafe(raw) then
        return "Let’s keep it safe and chill, I’m not talking about that."
    end

    local cmd = raw:lower()

    -- math
    local mathResult = tryMath(raw)
    if mathResult ~= nil then
        return "Math check: " .. tostring(mathResult)
    end

    -- enable / disable / turn on / off
    if cmd:find("enable ") or cmd:find("turn on ") then
        local feature = cmd:match("enable%s+(%w+)") or cmd:match("turn on%s+(%w+)")
        if feature then return toggleFeature(feature, true) end
    end

    if cmd:find("disable ") or cmd:find("turn off ") then
        local feature = cmd:match("disable%s+(%w+)") or cmd:match("turn off%s+(%w+)")
        if feature then return toggleFeature(feature, false) end
    end

    -- pattern: "what is ___"
    local whatTarget = cmd:match("what is%s+(.+)")
    if whatTarget then
        if whatTarget:find("space") then
            return "Space is the huge area beyond Earth’s atmosphere with stars, planets, galaxies and a lot of emptiness."
        elseif whatTarget:find("earth") then
            return "Earth is our home planet, with land, oceans, atmosphere, and life all over it."
        elseif whatTarget:find("dinosaur") or whatTarget:find("dino") then
            return "Dinosaurs were land reptiles from millions of years ago; marine reptiles like mosasaurs and pliosaurs ruled the oceans."
        elseif whatTarget:find("lua") then
            return "Lua is a lightweight scripting language used in Roblox. You use it to make scripts that control game behavior."
        elseif whatTarget:find("roblox") then
            return "Roblox is a platform where you build games with parts, scripts, and services, then players join and play."
        else
            return "I don’t have a full definition for that yet, but you can ask about space, Earth, dinos, Lua, or Roblox."
        end
    end

    -- pattern: "how do i ___"
    local howTarget = cmd:match("how do i%s+(.+)")
    if howTarget then
        if howTarget:find("lua") or howTarget:find("script") then
            return "Basic Lua tip: use 'local' for variables, connect events with :Connect, and always test in Studio. Example: local part = workspace.Part; part.Touched:Connect(function(hit) print(hit.Name) end)."
        elseif howTarget:find("make a game") or howTarget:find("dev") then
            return "To make a Roblox game: build a map, add scripts for movement and UI, test with friends, and keep updating."
        else
            return "General rule: break the problem into small steps, test each step, and don’t rush it."
        end
    end

    -- keyword topics
    if cmd:find("space") then
        return "Space is massive, mostly empty, with stars, planets, black holes, and galaxies. We’ve only explored a tiny bit."
    end

    if cmd:find("earth") then
        return "Earth has continents, oceans, atmosphere, and a ton of ecosystems. It’s the only known planet with complex life."
    end

    if cmd:find("dino") or cmd:find("dinosaur") then
        return "Dinosaurs and marine reptiles were wild. Think T. rex on land and pliosaurs or mosasaurs in the ocean."
    end

    if cmd:find("life") then
        return "Life is messy but kind of beautiful. Take care of yourself, your friends, and don’t rush growing up."
    end

    if cmd:find("lua") then
        return "Lua scripting: start with variables, functions, and events. Example: function greet() print('hi') end; greet()."
    end

    if cmd:find("roblox") then
        return "Roblox dev tip: keep scripts organized, use modules for big systems, and comment your code so admins know what’s going on."
    end

    -- greetings / casual chat
    if cmd:find("hello") or cmd:find("hi") or cmd:find("hey") then
        return "Hey, I’m CYBIX living in your menu. What are we doing today?"
    end

    if cmd:find("how are you") then
        return "I’m chilling in this UI, watching you test stuff. You good?"
    end

    if cmd:find("help") then
        return "You can ask: enable fly, disable noclip, explain esp, what is space, how do I learn Lua, or type math like 2+2*5."
    end

    return "I don’t fully get that yet, but you can ask about Lua, Roblox, dinos, space, Earth, life, or math."
end

----------------------------------------------------------------
-- INPUT HANDLING (Send + Enter)
----------------------------------------------------------------

local function handleSend()
    local text = aiInput.Text
    if text == "" then return end
    local reply = processCommand(text)
    respond(reply)
end

aiSend.MouseButton1Click:Connect(handleSend)

aiInput.FocusLost:Connect(function(enter)
    if enter then
        handleSend()
    end
end)

----------------------------------------------------------------
-- PERSONALITY BUTTONS (Buddy + Gen Alpha Slay)
----------------------------------------------------------------

local modeBuddy = Instance.new("TextButton", aiSection)
modeBuddy.Size = UDim2.new(0.5,-12,0,32)
modeBuddy.Position = UDim2.new(0,8,0,260)
modeBuddy.BackgroundColor3 = Color3.fromRGB(60,60,80)
modeBuddy.TextColor3 = Color3.fromRGB(255,255,255)
modeBuddy.Font = Enum.Font.GothamBold
modeBuddy.TextSize = 14
modeBuddy.Text = "Boy Mode"
Instance.new("UICorner", modeBuddy).CornerRadius = UDim.new(0,6)

local modeSlay = Instance.new("TextButton", aiSection)
modeSlay.Size = UDim2.new(0.5,-12,0,32)
modeSlay.Position = UDim2.new(0.5,4,0,260)
modeSlay.BackgroundColor3 = Color3.fromRGB(80,60,100)
modeSlay.TextColor3 = Color3.fromRGB(255,255,255)
modeSlay.Font = Enum.Font.GothamBold
modeSlay.TextSize = 14
modeSlay.Text = "Girl Mode"
Instance.new("UICorner", modeSlay).CornerRadius = UDim.new(0,6)

modeBuddy.MouseButton1Click:Connect(function()
    personality = "buddy"
    respond("Switched to Boy Mode. I’m your busco homie now.")
end)

modeSlay.MouseButton1Click:Connect(function()
    personality = "slay"
    respond("Switched to Girl Mode. You’re so real for picking this, ngl.")
end)


-- Default open page
switchPage("Leaderboard")

-- =========================
-- Aimbot overlay (visible circle outline + red dot)
-- Overlay should only be visible when legacy aimbot OR player aim aimbot is ON
-- =========================

local overlayGui = Instance.new("ScreenGui")
overlayGui.Name = "AimbotOverlay"
overlayGui.ResetOnSpawn = false
overlayGui.Parent = gui
overlayGui.Enabled = false -- start disabled; will enable only when toggles are ON

-- Circle frame (transparent fill, outline only)
local circleFrame = Instance.new("Frame", overlayGui)
circleFrame.Name = "AimbotCircle"
circleFrame.BackgroundTransparency = 1
circleFrame.BorderSizePixel = 0
local r = runtimeState.aimbotRadius
circleFrame.Size = UDim2.new(0, r*2, 0, r*2)
circleFrame.Position = UDim2.new(0.5, -r, 0.5, -r)
circleFrame.AnchorPoint = Vector2.new(0,0)

local circleCorner = Instance.new("UICorner", circleFrame)
circleCorner.CornerRadius = UDim.new(1,0) -- make it a circle

local circleStroke = Instance.new("UIStroke", circleFrame)
circleStroke.Color = Color3.fromRGB(255, 100, 100)
circleStroke.Thickness = 2
circleStroke.Transparency = 0
circleStroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border

-- Red center dot
local centerDot = Instance.new("Frame", overlayGui)
centerDot.Name = "AimbotCenterDot"
centerDot.Size = UDim2.new(0,6,0,6)
centerDot.Position = UDim2.new(0.5, -3, 0.5, -3)
centerDot.BackgroundColor3 = Color3.fromRGB(255, 60, 60)
centerDot.BorderSizePixel = 0
Instance.new("UICorner", centerDot).CornerRadius = UDim.new(1,0)

-- Keep overlay on top but not blocking input
overlayGui.IgnoreGuiInset = true
overlayGui.ResetOnSpawn = false

-- Update overlay when viewport changes (resize)
Workspace.CurrentCamera:GetPropertyChangedSignal("ViewportSize"):Connect(function()
    local r = runtimeState.aimbotRadius
    local circle = overlayGui:FindFirstChild("AimbotCircle")
    if circle then
        circle.Size = UDim2.new(0, r*2, 0, r*2)
        circle.Position = UDim2.new(0.5, -r, 0.5, -r)
    end
    local dot = overlayGui:FindFirstChild("AimbotCenterDot")
    if dot then
        dot.Position = UDim2.new(0.5, -3, 0.5, -3)
    end
end)

-- Ensure overlay persists on respawn
player.CharacterAdded:Connect(function()
    task.wait(0.1)
    if not gui:FindFirstChild("AimbotOverlay") then
        overlayGui.Parent = gui
    end
    -- restore overlay enabled state based on toggles
    overlayGui.Enabled = (runtimeState.aimbotEnabled or runtimeState.playerAimAimbot)
end)

-- Initialize aimbot slider UI fill/knob positions (defer if AbsoluteSize not ready)
local function initAimbotSlider()
    if aimbotSliderBar.AbsoluteSize.X > 0 then
        local t = (runtimeState.aimbotRadius - runtimeState.aimbotRadiusMin) / (runtimeState.aimbotRadiusMax - runtimeState.aimbotRadiusMin)
        aimbotSliderFill.Size = UDim2.new(t, 0, 1, 0)
        aimbotKnob.Position = UDim2.new(t, -7, 0.5, -7)
    else
        aimbotSliderBar:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
            local t = (runtimeState.aimbotRadius - runtimeState.aimbotRadiusMin) / (runtimeState.aimbotRadiusMax - runtimeState.aimbotRadiusMin)
            aimbotSliderFill.Size = UDim2.new(t, 0, 1, 0)
            aimbotKnob.Position = UDim2.new(t, -7, 0.5, -7)
        end)
    end
    -- ensure overlay circle matches initial radius
    if overlayGui and overlayGui:FindFirstChild("AimbotCircle") then
        local r = runtimeState.aimbotRadius
        overlayGui.AimbotCircle.Size = UDim2.new(0, r*2, 0, r*2)
        overlayGui.AimbotCircle.Position = UDim2.new(0.5, -r, 0.5, -r)
    end
end

initAimbotSlider()

-- Helper to refresh overlay state (call whenever toggles change)
local function refreshOverlay()
    if gui:FindFirstChild("AimbotOverlay") then
        gui.AimbotOverlay.Enabled = (runtimeState.aimbotEnabled or runtimeState.playerAimAimbot)
    end
end

-- Ensure overlay is correct at start
refreshOverlay()

-- End of script

]]

injectBtn.MouseButton1Click:Connect(function()
    if CYBIX_PAID_SCRIPT and CYBIX_PAID_SCRIPT ~= "" then
        local fn, err = loadstring(CYBIX_PAID_SCRIPT)
        if not fn then
            addLog("error", "Paid script compile error: " .. tostring(err), "Check for truncation or paste issues.")
            return
        end
        local ok, runtimeErr = pcall(fn)
        if not ok then
            addLog("error", "Paid script runtime error: " .. tostring(runtimeErr), "Check your paid script logic.")
        else
            addLog("ok", "CYBIX paid menu injected successfully.", "")
        end
    else
        addLog("warn", "No paid script set in CYBIX_PAID_SCRIPT.", "Paste your script into the CYBIX_PAID_SCRIPT variable.")
    end
end)

tabDesign.MouseButton1Click:Connect(function()
    switchPage("SCRIPT DESIGN")
end)

tabHelp.MouseButton1Click:Connect(function()
    switchPage("HELP")
end)

tabConsole.MouseButton1Click:Connect(function()
    switchPage("CONSOLE")
end)

tabHI.MouseButton1Click:Connect(function()
    switchPage("Plugins")
end)

switchPage("SCRIPT DESIGN")