Flick Fricker OPEN SRC

 player = .Players.LocalPlayer
 character = player.Character  player.CharacterAdded:()
 runService = :()
 tweenService = :()
 userInputService = :()
 camera = .CurrentCamera
 mouse = player:()
 isSilentAimActive = 
 isFovCircleActive = 
 fov = 
 targetPart = 
 isTriggerBotActive = 
 isAimbotActive = 
 aimbotSmoothness = 
 aimbotKey = 
 aimbotMode = 
 aimbotEnabled = 
 menuKey = .KeyCode.Insert
 menuVisible = 
 flickFuckerUsers = {}
 textChatService = :()
 replicatedStorage = :()
 lastResponseTime = 
 RESPONSE_COOLDOWN = 

 savedConfigs = {}
 isfile  readfile  () 
     success, result = (()
         :():(())
    )
     success 
        savedConfigs = result
    


  savedConfigs[] 
    savedConfigs[] = {
        isSilentAimActive = ,
        isAimbotActive = ,
        aimbotSmoothness = ,
        aimbotKey = ,
        aimbotMode = ,
        isTriggerBotActive = ,
        isFovCircleActive = ,
        fov = ,
        targetPart = ,
        isEspActive = ,
        espSettings = {
            box = ,
            boxType = ,
            name = ,
            distance = ,
            health = ,
            skeleton = ,
            tracers = ,
            healthBarStyle = 
        },
        isRadarActive = ,
        isFovArrowsActive = ,
        isHitboxExpanderActive = ,
        hitboxSize = 
    }


  savedConfigs[] 
    savedConfigs[] = {
        isSilentAimActive = ,
        isAimbotActive = ,
        aimbotSmoothness = ,
        aimbotKey = ,
        aimbotMode = ,
        isTriggerBotActive = ,
        isFovCircleActive = ,
        fov = ,
        targetPart = ,
        isEspActive = ,
        espSettings = {
            box = ,
            boxType = ,
            name = ,
            distance = ,
            health = ,
            skeleton = ,
            tracers = ,
            healthBarStyle = 
        },
        isRadarActive = ,
        isFovArrowsActive = ,
        isHitboxExpanderActive = ,
        hitboxSize = 
    }


 isEspActive = 
 espSettings = {
    box = ,
    boxType = ,
    name = ,
    distance = ,
    health = ,
    skeleton = ,
    tracers = ,
    healthBarStyle = 
}

 isHitboxExpanderActive = 
 hitboxSize = 

 isRadarActive = 
 radarScale = 
 isFovArrowsActive = 

 theme = {
    primary = .(, , ),
    secondary = .(, , ),
    accent = .(, , ),
    background = .(, , ),
    surface = .(, , ),
    surfaceLight = .(, , ),
    text = .(, , ),
    textDim = .(, , ),
    success = .(, , ),
    danger = .(, , )
}

 fovCircle = .()
fovCircle.Thickness = 
fovCircle.NumSides = 
fovCircle.Radius = fov
fovCircle.Filled = 
fovCircle.Color = .(, , )
fovCircle.Transparency = 
fovCircle.Visible = isFovCircleActive

 espObjects = {}
 radarDots = {}
 fovArrows = {}

 radarBackground = .()
radarBackground.Thickness = 
radarBackground.NumSides = 
radarBackground.Radius = 
radarBackground.Filled = 
radarBackground.Color = .(, , )
radarBackground.Transparency = 
radarBackground.Visible = 

 radarBorder = .()
radarBorder.Thickness = 
radarBorder.NumSides = 
radarBorder.Radius = 
radarBorder.Filled = 
radarBorder.Color = theme.primary
radarBorder.Transparency = 
radarBorder.Visible = 

 radarPlayerArrow = {
    line1 = .(),
    line2 = .(),
    line3 = .()
}

 _, line  (radarPlayerArrow) 
    line.Thickness = 
    line.Color = theme.success
    line.Transparency = 
    line.Visible = 


 currentPage = 

 screenGui = .()
screenGui.Name = 
screenGui.ResetOnSpawn = 
screenGui.Parent = .CoreGui

 blur = .()
blur.Size = 
blur.Parent = .Lighting

 mainFrame = .()
mainFrame.Size = .(, , , )
mainFrame.Position = .(, -, , -)
mainFrame.BackgroundColor3 = theme.background
mainFrame.BorderSizePixel = 
mainFrame.Active = 
mainFrame.Draggable = 
mainFrame.ClipsDescendants = 
mainFrame.Parent = screenGui

 mainCorner = .()
mainCorner.CornerRadius = .(, )
mainCorner.Parent = mainFrame

 glowFrame = .()
glowFrame.Size = .(, , , )
glowFrame.Position = .(, , , )
glowFrame.AnchorPoint = .(, )
glowFrame.BackgroundTransparency = 
glowFrame.Image = 
glowFrame.ImageColor3 = theme.primary
glowFrame.ImageTransparency = 
glowFrame.ZIndex = 
glowFrame.Parent = mainFrame

 gradientBG = .()
gradientBG.Size = .(, , , )
gradientBG.BackgroundColor3 = theme.surface
gradientBG.BackgroundTransparency = 
gradientBG.BorderSizePixel = 
gradientBG.ZIndex = 
gradientBG.Parent = mainFrame

 gradientBGCorner = .()
gradientBGCorner.CornerRadius = .(, )
gradientBGCorner.Parent = gradientBG

 gradient = .()
gradient.Color = ColorSequence.{
    ColorSequenceKeypoint.(, theme.primary),
    ColorSequenceKeypoint.(, theme.secondary),
    ColorSequenceKeypoint.(, theme.accent)
}
gradient.Rotation = 
gradient.Parent = gradientBG

(()
     () 
         gradient  gradient.Parent 
            gradient.Rotation = gradient.Rotation + 
             gradient.Rotation >=  
                gradient.Rotation = 
            
        
    
)

 accentBar = .()
accentBar.Size = .(, , , )
accentBar.Position = .(, , , )
accentBar.BackgroundColor3 = theme.primary
accentBar.BorderSizePixel = 
accentBar.ZIndex = 
accentBar.Parent = mainFrame

 accentGradient = .()
accentGradient.Color = ColorSequence.{
    ColorSequenceKeypoint.(, theme.primary),
    ColorSequenceKeypoint.(, theme.secondary),
    ColorSequenceKeypoint.(, theme.accent)
}
accentGradient.Parent = accentBar

(()
     () 
         accentGradient  accentGradient.Parent 
            accentGradient.Offset = .(accentGradient.Offset.X + , )
             accentGradient.Offset.X >=  
                accentGradient.Offset = .(-, )
            
        
    
)

 titleBar = .()
titleBar.Size = .(, , , )
titleBar.BackgroundTransparency = 
titleBar.BorderSizePixel = 
titleBar.ZIndex = 
titleBar.Parent = mainFrame

 logo = .()
logo.Size = .(, , , )
logo.Position = .(, , , )
logo.BackgroundColor3 = theme.primary
logo.BorderSizePixel = 
logo.ZIndex = 
logo.Parent = titleBar

 logoCorner = .()
logoCorner.CornerRadius = .(, )
logoCorner.Parent = logo

 logoGradient = .()
logoGradient.Color = ColorSequence.{
    ColorSequenceKeypoint.(, theme.primary),
    ColorSequenceKeypoint.(, theme.secondary)
}
logoGradient.Rotation = 
logoGradient.Parent = logo

 logoText = .()
logoText.Size = .(, , , )
logoText.BackgroundTransparency = 
logoText.Text = 
logoText.TextColor3 = .(, , )
logoText.TextSize = 
logoText.Font = .Font.GothamBold
logoText.ZIndex = 
logoText.Parent = logo

 title = .()
title.Size = .(, , , )
title.Position = .(, , , )
title.BackgroundTransparency = 
title.Text = 
title.TextColor3 = theme.text
title.TextSize = 
title.Font = .Font.GothamBold
title.TextXAlignment = .TextXAlignment.Left
title.ZIndex = 
title.Parent = titleBar

 titleGradient = .()
titleGradient.Color = ColorSequence.{
    ColorSequenceKeypoint.(, theme.primary),
    ColorSequenceKeypoint.(, theme.accent)
}
titleGradient.Parent = title

 subtitle = .()
subtitle.Size = .(, , , )
subtitle.Position = .(, , , )
subtitle.BackgroundTransparency = 
subtitle.Text = 
subtitle.TextColor3 = theme.textDim
subtitle.TextSize = 
subtitle.Font = .Font.Gotham
subtitle.TextXAlignment = .TextXAlignment.Left
subtitle.ZIndex = 
subtitle.Parent = titleBar

 closeButton = .()
closeButton.Size = .(, , , )
closeButton.Position = .(, -, , )
closeButton.BackgroundColor3 = theme.danger
closeButton.BorderSizePixel = 
closeButton.Text = 
closeButton.TextColor3 = .(, , )
closeButton.TextSize = 
closeButton.Font = .Font.GothamBold
closeButton.ZIndex = 
closeButton.Parent = titleBar

 closeCorner = .()
closeCorner.CornerRadius = .(, )
closeCorner.Parent = closeButton

closeButton.MouseEnter:(()
    tweenService:(closeButton, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
    tweenService:(closeButton, TweenInfo.(), {Size = .(, , , )}):()
)

closeButton.MouseLeave:(()
    tweenService:(closeButton, TweenInfo.(), {BackgroundColor3 = theme.danger}):()
    tweenService:(closeButton, TweenInfo.(), {Size = .(, , , )}):()
)

 sidebarContainer = .()
sidebarContainer.Size = .(, , , -)
sidebarContainer.Position = .(, , , )
sidebarContainer.BackgroundColor3 = theme.surface
sidebarContainer.BackgroundTransparency = 
sidebarContainer.BorderSizePixel = 
sidebarContainer.ZIndex = 
sidebarContainer.Parent = mainFrame

 contentContainer = .()
contentContainer.Size = .(, -, , -)
contentContainer.Position = .(, , , )
contentContainer.BackgroundTransparency = 
contentContainer.BorderSizePixel = 
contentContainer.ClipsDescendants = 
contentContainer.ZIndex = 
contentContainer.ScrollBarThickness = 
contentContainer.ScrollBarImageColor3 = theme.primary
contentContainer.CanvasSize = .(, , , )
contentContainer.Parent = mainFrame

 pageIndicator = .()
pageIndicator.Size = .(, , , )
pageIndicator.Position = .(, , , )
pageIndicator.BackgroundColor3 = theme.primary
pageIndicator.BorderSizePixel = 
pageIndicator.ZIndex = 
pageIndicator.Parent = sidebarContainer

 indicatorCorner = .()
indicatorCorner.CornerRadius = .(, )
indicatorCorner.Parent = pageIndicator

 pageButtons = {}
 pages = {
    {name = , icon = },
    {name = , icon = },
    {name = , icon = },
    {name = , icon = }
}

 i, pageData  (pages) 
     pageButton = .()
    pageButton.Size = .(, -, , )
    pageButton.Position = .(, , ,  + (i - ) * )
    pageButton.BackgroundColor3 = theme.surface
    pageButton.BackgroundTransparency = 
    pageButton.BorderSizePixel = 
    pageButton.Text = 
    pageButton.ZIndex = 
    pageButton.Parent = sidebarContainer
    
     buttonIcon = .()
    buttonIcon.Size = .(, , , )
    buttonIcon.Position = .(, , , )
    buttonIcon.BackgroundTransparency = 
    buttonIcon.Text = pageData.icon
    buttonIcon.TextColor3 = theme.textDim
    buttonIcon.TextSize = 
    buttonIcon.Font = .Font.GothamBold
    buttonIcon.ZIndex = 
    buttonIcon.Parent = pageButton
    
     buttonLabel = .()
    buttonLabel.Size = .(, -, , )
    buttonLabel.Position = .(, , , )
    buttonLabel.BackgroundTransparency = 
    buttonLabel.Text = pageData.name
    buttonLabel.TextColor3 = theme.textDim
    buttonLabel.TextSize = 
    buttonLabel.Font = .Font.GothamBold
    buttonLabel.TextXAlignment = .TextXAlignment.Left
    buttonLabel.ZIndex = 
    buttonLabel.Parent = pageButton
    
    pageButtons[pageData.name] = {
        button = pageButton,
        icon = buttonIcon,
        label = buttonLabel
    }
    
    pageButton.MouseEnter:(()
         currentPage ~= pageData.name 
            tweenService:(buttonIcon, TweenInfo.(), {TextColor3 = theme.text}):()
            tweenService:(buttonLabel, TweenInfo.(), {TextColor3 = theme.text}):()
        
    )
    
    pageButton.MouseLeave:(()
         currentPage ~= pageData.name 
            tweenService:(buttonIcon, TweenInfo.(), {TextColor3 = theme.textDim}):()
            tweenService:(buttonLabel, TweenInfo.(), {TextColor3 = theme.textDim}):()
        
    )


  (name, position, defaultState, callback)
     toggleFrame = .()
    toggleFrame.Size = .(, , , )
    toggleFrame.Position = position
    toggleFrame.BackgroundColor3 = theme.surface
    toggleFrame.BorderSizePixel = 
    toggleFrame.ZIndex = 
    toggleFrame.Parent = contentContainer
    
     toggleCorner = .()
    toggleCorner.CornerRadius = .(, )
    toggleCorner.Parent = toggleFrame
    
     label = .()
    label.Size = .(, , , )
    label.Position = .(, , , )
    label.BackgroundTransparency = 
    label.Text = name
    label.TextColor3 = theme.text
    label.TextSize = 
    label.Font = .Font.GothamSemibold
    label.TextXAlignment = .TextXAlignment.Left
    label.ZIndex = 
    label.Parent = toggleFrame
    
     toggleBG = .()
    toggleBG.Size = .(, , , )
    toggleBG.Position = .(, -, , -)
    toggleBG.BackgroundColor3 = defaultState  theme.success  theme.surfaceLight
    toggleBG.BorderSizePixel = 
    toggleBG.ZIndex = 
    toggleBG.Parent = toggleFrame
    
     toggleBGCorner = .()
    toggleBGCorner.CornerRadius = .(, )
    toggleBGCorner.Parent = toggleBG
    
     toggleCircle = .()
    toggleCircle.Size = .(, , , )
    toggleCircle.Position = defaultState  .(, -, , -)  .(, , , -)
    toggleCircle.BackgroundColor3 = .(, , )
    toggleCircle.BorderSizePixel = 
    toggleCircle.ZIndex = 
    toggleCircle.Parent = toggleBG
    
     toggleCircleCorner = .()
    toggleCircleCorner.CornerRadius = .(, )
    toggleCircleCorner.Parent = toggleCircle
    
     toggleButton = .()
    toggleButton.Size = .(, , , )
    toggleButton.BackgroundTransparency = 
    toggleButton.Text = 
    toggleButton.ZIndex = 
    toggleButton.Parent = toggleFrame
    
     state = defaultState
    toggleButton.MouseButton1Click:(()
        state =  state
        (state)
        
        tweenService:(toggleBG, TweenInfo.(, .EasingStyle.Quart), {
            BackgroundColor3 = state  theme.success  theme.surfaceLight
        }):()
        
        tweenService:(toggleCircle, TweenInfo.(, .EasingStyle.Quart), {
            Position = state  .(, -, , -)  .(, , , -)
        }):()
    )
    
     toggleFrame


  (name, position, defaultValue, callback)
     inputFrame = .()
    inputFrame.Size = .(, , , )
    inputFrame.Position = position
    inputFrame.BackgroundColor3 = theme.surface
    inputFrame.BorderSizePixel = 
    inputFrame.ZIndex = 
    inputFrame.Parent = contentContainer
    
     inputCorner = .()
    inputCorner.CornerRadius = .(, )
    inputCorner.Parent = inputFrame
    
     label = .()
    label.Size = .(, , , )
    label.Position = .(, , , )
    label.BackgroundTransparency = 
    label.Text = name
    label.TextColor3 = theme.text
    label.TextSize = 
    label.Font = .Font.GothamSemibold
    label.TextXAlignment = .TextXAlignment.Left
    label.ZIndex = 
    label.Parent = inputFrame
    
     textBox = .()
    textBox.Size = .(, , , )
    textBox.Position = .(, -, , -)
    textBox.BackgroundColor3 = theme.surfaceLight
    textBox.BorderSizePixel = 
    textBox.Text = (defaultValue)
    textBox.TextColor3 = theme.primary
    textBox.TextSize = 
    textBox.Font = .Font.GothamBold
    textBox.PlaceholderText = 
    textBox.PlaceholderColor3 = theme.textDim
    textBox.ClearTextOnFocus = 
    textBox.ZIndex = 
    textBox.Parent = inputFrame
    
     textBoxCorner = .()
    textBoxCorner.CornerRadius = .(, )
    textBoxCorner.Parent = textBox
    
    textBox.FocusLost:((enterPressed)
         value = (textBox.Text)
         value 
            value = .(value, , )
            textBox.Text = (value)
            (value)
            
            tweenService:(textBox, TweenInfo.(), {BackgroundColor3 = theme.success}):()
            ()
            tweenService:(textBox, TweenInfo.(), {BackgroundColor3 = theme.surfaceLight}):()
        
            textBox.Text = (defaultValue)
            
            tweenService:(textBox, TweenInfo.(), {BackgroundColor3 = theme.danger}):()
            ()
            tweenService:(textBox, TweenInfo.(), {BackgroundColor3 = theme.surfaceLight}):()
        
    )
    
     inputFrame


  (name, position, min, max, defaultValue, callback)
     sliderFrame = .()
    sliderFrame.Size = .(, , , )
    sliderFrame.Position = position
    sliderFrame.BackgroundColor3 = theme.surface
    sliderFrame.BorderSizePixel = 
    sliderFrame.ZIndex = 
    sliderFrame.Parent = contentContainer
    
     sliderCorner = .()
    sliderCorner.CornerRadius = .(, )
    sliderCorner.Parent = sliderFrame
    
     label = .()
    label.Size = .(, , , )
    label.Position = .(, , , )
    label.BackgroundTransparency = 
    label.Text = name
    label.TextColor3 = theme.text
    label.TextSize = 
    label.Font = .Font.GothamSemibold
    label.TextXAlignment = .TextXAlignment.Left
    label.ZIndex = 
    label.Parent = sliderFrame
    
     valueLabel = .()
    valueLabel.Size = .(, , , )
    valueLabel.Position = .(, -, , )
    valueLabel.BackgroundColor3 = theme.surfaceLight
    valueLabel.BorderSizePixel = 
    valueLabel.Text = (defaultValue)
    valueLabel.TextColor3 = theme.primary
    valueLabel.TextSize = 
    valueLabel.Font = .Font.GothamBold
    valueLabel.ZIndex = 
    valueLabel.Parent = sliderFrame
    
     valueLabelCorner = .()
    valueLabelCorner.CornerRadius = .(, )
    valueLabelCorner.Parent = valueLabel
    
     sliderBG = .()
    sliderBG.Size = .(, -, , )
    sliderBG.Position = .(, , , -)
    sliderBG.BackgroundColor3 = theme.surfaceLight
    sliderBG.BorderSizePixel = 
    sliderBG.ZIndex = 
    sliderBG.Parent = sliderFrame
    
     sliderBGCorner = .()
    sliderBGCorner.CornerRadius = .(, )
    sliderBGCorner.Parent = sliderBG
    
     sliderFill = .()
    sliderFill.Size = .((defaultValue - min) / (max - min), , , )
    sliderFill.BackgroundColor3 = theme.primary
    sliderFill.BorderSizePixel = 
    sliderFill.ZIndex = 
    sliderFill.Parent = sliderBG
    
     sliderFillCorner = .()
    sliderFillCorner.CornerRadius = .(, )
    sliderFillCorner.Parent = sliderFill
    
     sliderGradient = .()
    sliderGradient.Color = ColorSequence.{
        ColorSequenceKeypoint.(, theme.primary),
        ColorSequenceKeypoint.(, theme.secondary)
    }
    sliderGradient.Parent = sliderFill
    
     sliderButton = .()
    sliderButton.Size = .(, , , )
    sliderButton.Position = .((defaultValue - min) / (max - min), -, , -)
    sliderButton.BackgroundColor3 = .(, , )
    sliderButton.BorderSizePixel = 
    sliderButton.ZIndex = 
    sliderButton.Parent = sliderBG
    
     sliderButtonCorner = .()
    sliderButtonCorner.CornerRadius = .(, )
    sliderButtonCorner.Parent = sliderButton
    
     dragging = 
    
    sliderButton.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            dragging = 
        
    )
    
    userInputService.InputEnded:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            dragging = 
        
    )
    
    userInputService.InputChanged:((input)
         dragging  input.UserInputType == .UserInputType.MouseMovement 
             mousePos = userInputService:().X
             sliderPos = sliderBG.AbsolutePosition.X
             sliderSize = sliderBG.AbsoluteSize.X
            
             value = .((mousePos - sliderPos) / sliderSize, , )
             actualValue = .(min + (max - min) * value)
            
            valueLabel.Text = (actualValue)
            (actualValue)
            
            tweenService:(sliderFill, TweenInfo.(), {Size = .(value, , , )}):()
            tweenService:(sliderButton, TweenInfo.(), {Position = .(value, -, , -)}):()
        
    )
    
     sliderFrame


  (name, position, options, defaultOption, callback)
     dropFrame = .()
    dropFrame.Size = .(, , , )
    dropFrame.Position = position
    dropFrame.BackgroundColor3 = theme.surface
    dropFrame.BorderSizePixel = 
    dropFrame.ZIndex = 
    dropFrame.Parent = contentContainer
    
     dropCorner = .()
    dropCorner.CornerRadius = .(, )
    dropCorner.Parent = dropFrame
    
     label = .()
    label.Size = .(, , , )
    label.Position = .(, , , )
    label.BackgroundTransparency = 
    label.Text = name
    label.TextColor3 = theme.text
    label.TextSize = 
    label.Font = .Font.GothamSemibold
    label.TextXAlignment = .TextXAlignment.Left
    label.ZIndex = 
    label.Parent = dropFrame
    
     dropdown = .()
    dropdown.Size = .(, , , )
    dropdown.Position = .(, -, , -)
    dropdown.BackgroundColor3 = theme.surfaceLight
    dropdown.BorderSizePixel = 
    dropdown.Text = defaultOption .. 
    dropdown.TextColor3 = theme.text
    dropdown.TextSize = 
    dropdown.Font = .Font.Gotham
    dropdown.ZIndex = 
    dropdown.Parent = dropFrame
    
     dropCorner2 = .()
    dropCorner2.CornerRadius = .(, )
    dropCorner2.Parent = dropdown
    
     currentIndex = 
     i, opt  (options) 
         opt == defaultOption 
            currentIndex = i
            
        
    
    
    dropdown.MouseButton1Click:(()
        currentIndex = currentIndex % #options + 
        dropdown.Text = options[currentIndex] .. 
        (options[currentIndex])
        
        tweenService:(dropdown, TweenInfo.(), {BackgroundColor3 = theme.primary}):()
        ()
        tweenService:(dropdown, TweenInfo.(), {BackgroundColor3 = theme.surfaceLight}):()
    )
    
     dropFrame


  ()
     contentHeight = 
     _, child  (contentContainer:()) 
         child:() 
            contentHeight = .(contentHeight, child.Position.Y.Offset + child.Size.Y.Offset)
        
    
    contentContainer.CanvasSize = .(, , , contentHeight + )


 pageContent = {}

  (name)
    savedConfigs[name] = {
        isSilentAimActive = isSilentAimActive,
        isAimbotActive = isAimbotActive,
        aimbotSmoothness = aimbotSmoothness,
        aimbotKey = aimbotKey,
        aimbotMode = aimbotMode,
        isTriggerBotActive = isTriggerBotActive,
        isFovCircleActive = isFovCircleActive,
        fov = fov,
        targetPart = targetPart,
        isEspActive = isEspActive,
        espSettings = {
            box = espSettings.box,
            boxType = espSettings.boxType,
            name = espSettings.name,
            distance = espSettings.distance,
            health = espSettings.health,
            skeleton = espSettings.skeleton,
            tracers = espSettings.tracers,
            healthBarStyle = espSettings.healthBarStyle
        },
        isRadarActive = isRadarActive,
        isFovArrowsActive = isFovArrowsActive,
        isHitboxExpanderActive = isHitboxExpanderActive,
        hitboxSize = hitboxSize
    }
    
     writefile 
         success, err = (()
            (, :():(savedConfigs))
        )
         success 
            ( .. name .. )
        
            ( .. (err))
        
    


  (name)
     savedConfigs[name] 
        savedConfigs[name] = 
        
         writefile 
             success, err = (()
                (, :():(savedConfigs))
            )
             success 
                ( .. name .. )
                 
            
                ( .. (err))
                 
            
        
    
     


  (name)
     savedConfigs[name] 
         config = savedConfigs[name]
        
        isSilentAimActive = config.isSilentAimActive
        isAimbotActive = config.isAimbotActive
        aimbotSmoothness = config.aimbotSmoothness
        aimbotKey = config.aimbotKey
        aimbotMode = config.aimbotMode
        isTriggerBotActive = config.isTriggerBotActive
        isFovCircleActive = config.isFovCircleActive
        fov = config.fov
        targetPart = config.targetPart
        isEspActive = config.isEspActive
        
         k, v  (config.espSettings) 
            espSettings[k] = v
        
        
        isRadarActive = config.isRadarActive
        isFovArrowsActive = config.isFovArrowsActive
        isHitboxExpanderActive = config.isHitboxExpanderActive
        hitboxSize = config.hitboxSize
        
        fovCircle.Radius = fov
        fovCircle.Visible = isFovCircleActive
        radarBackground.Visible = isRadarActive
        radarBorder.Visible = isRadarActive
        
         _, line  (radarPlayerArrow) 
            line.Visible = isRadarActive
        
        
         isEspActive 
             _, plr  (.Players:()) 
                  espObjects[plr]  plr ~= player 
                    (plr)
                
            
        
        
         
    
     


pageContent[] = ()
    contentContainer:()
    
     yPos = 
    
    (, .(, , , yPos), isSilentAimActive, (state)
        isSilentAimActive = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), isAimbotActive, (state)
        isAimbotActive = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), , , aimbotSmoothness, (value)
        aimbotSmoothness = value
    )
    yPos = yPos + 
    
    (, .(, , , yPos), {, , , , , , , }, aimbotKey, (value)
        aimbotKey = value
    )
    yPos = yPos + 
    
    (, .(, , , yPos), {, }, aimbotMode, (value)
        aimbotMode = value
         aimbotMode ==  
            aimbotEnabled = 
        
    )
    yPos = yPos + 
    
    (, .(, , , yPos), isTriggerBotActive, (state)
        isTriggerBotActive = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), isFovCircleActive, (state)
        isFovCircleActive = state
        fovCircle.Visible = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), , , fov, (value)
        fov = value
        fovCircle.Radius = value
    )
    yPos = yPos + 
    
    (, .(, , , yPos), {, , }, targetPart, (value)
        targetPart = value
    )
    
    ()


pageContent[] = ()
    contentContainer:()
    
     yPos = 
    
    (, .(, , , yPos), isEspActive, (state)
        isEspActive = state
         state 
             _, plr  (.Players:()) 
                  espObjects[plr]  plr ~= player 
                    (plr)
                
            
        
    )
    yPos = yPos + 
    
    (, .(, , , yPos), {, }, espSettings.boxType, (value)
        espSettings.boxType = value
    )
    yPos = yPos + 
    
    (, .(, , , yPos), espSettings.box, (state)
        espSettings.box = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), espSettings.name, (state)
        espSettings.name = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), espSettings.distance, (state)
        espSettings.distance = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), espSettings.health, (state)
        espSettings.health = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), espSettings.skeleton, (state)
        espSettings.skeleton = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), espSettings.tracers, (state)
        espSettings.tracers = state
    )
    yPos = yPos + 
    
    (, .(, , , yPos), isRadarActive, (state)
        isRadarActive = state
        radarBackground.Visible = state
        radarBorder.Visible = state
         _, line  (radarPlayerArrow) 
            line.Visible = state
        
    )
    yPos = yPos + 
    
    (, .(, , , yPos), , , radarScale, (value)
        radarScale = value
    )
    yPos = yPos + 
    
    (, .(, , , yPos), isFovArrowsActive, (state)
        isFovArrowsActive = state
    )
    
    ()


pageContent[] = ()
    contentContainer:()
    
     yPos = 
    
     infoFrame = .()
    infoFrame.Size = .(, , , )
    infoFrame.Position = .(, , , yPos)
    infoFrame.BackgroundColor3 = theme.surface
    infoFrame.BorderSizePixel = 
    infoFrame.ZIndex = 
    infoFrame.Parent = contentContainer
    
     infoCorner = .()
    infoCorner.CornerRadius = .(, )
    infoCorner.Parent = infoFrame
    
     infoGradient = .()
    infoGradient.Color = ColorSequence.{
        ColorSequenceKeypoint.(, theme.primary),
        ColorSequenceKeypoint.(, theme.secondary)
    }
    infoGradient.Transparency = NumberSequence.{
        NumberSequenceKeypoint.(, ),
        NumberSequenceKeypoint.(, )
    }
    infoGradient.Rotation = 
    infoGradient.Parent = infoFrame
    
     infoTitle = .()
    infoTitle.Size = .(, -, , )
    infoTitle.Position = .(, , , )
    infoTitle.BackgroundTransparency = 
    infoTitle.Text = 
    infoTitle.TextColor3 = theme.text
    infoTitle.TextSize = 
    infoTitle.Font = .Font.GothamBold
    infoTitle.TextXAlignment = .TextXAlignment.Left
    infoTitle.ZIndex = 
    infoTitle.Parent = infoFrame
    
     infoText = .()
    infoText.Size = .(, -, , )
    infoText.Position = .(, , , )
    infoText.BackgroundTransparency = 
    infoText.Text = 
    infoText.TextColor3 = theme.textDim
    infoText.TextSize = 
    infoText.Font = .Font.Gotham
    infoText.TextXAlignment = .TextXAlignment.Left
    infoText.TextYAlignment = .TextYAlignment.Top
    infoText.ZIndex = 
    infoText.Parent = infoFrame
    
    yPos = yPos + 
    
    (, .(, , , yPos), isHitboxExpanderActive, (state)
        isHitboxExpanderActive = state
    )
    yPos = yPos + 
    
(, .(, , , yPos), hitboxSize, (value)
    hitboxSize = value
)
yPos = yPos + 

 bypassButton = .()
bypassButton.Size = .(, , , )
bypassButton.Position = .(, , , yPos)
bypassButton.BackgroundColor3 = theme.surface
bypassButton.BorderSizePixel = 
bypassButton.Text = 
bypassButton.ZIndex = 
bypassButton.Parent = contentContainer

 bypassCorner = .()
bypassCorner.CornerRadius = .(, )
bypassCorner.Parent = bypassButton

 bypassLabel = .()
bypassLabel.Size = .(, , , )
bypassLabel.Position = .(, , , )
bypassLabel.BackgroundTransparency = 
bypassLabel.Text = 
bypassLabel.TextColor3 = theme.text
bypassLabel.TextSize = 
bypassLabel.Font = .Font.GothamSemibold
bypassLabel.TextXAlignment = .TextXAlignment.Left
bypassLabel.ZIndex = 
bypassLabel.Parent = bypassButton

 bypassClickButton = .()
bypassClickButton.Size = .(, , , )
bypassClickButton.Position = .(, -, , -)
bypassClickButton.BackgroundColor3 = theme.primary
bypassClickButton.BorderSizePixel = 
bypassClickButton.Text = 
bypassClickButton.TextColor3 = .(, , )
bypassClickButton.TextSize = 
bypassClickButton.Font = .Font.GothamBold
bypassClickButton.ZIndex = 
bypassClickButton.Parent = bypassButton

 bypassClickCorner = .()
bypassClickCorner.CornerRadius = .(, )
bypassClickCorner.Parent = bypassClickButton

bypassClickButton.MouseButton1Click:(()
    tweenService:(bypassClickButton, TweenInfo.(), {BackgroundColor3 = theme.success}):()
    bypassClickButton.Text = 
    
    (()
        (:())()
    )
    
    ()
    bypassClickButton.Text = 
    ()
    bypassClickButton.Text = 
    tweenService:(bypassClickButton, TweenInfo.(), {BackgroundColor3 = theme.primary}):()
)

bypassClickButton.MouseEnter:(()
    tweenService:(bypassClickButton, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
)

bypassClickButton.MouseLeave:(()
    tweenService:(bypassClickButton, TweenInfo.(), {BackgroundColor3 = theme.primary}):()
)

yPos = yPos + 

 crosshairToggle = (, .(, , , yPos), , (state)
     state 
        .Crosshair = .()
        .Crosshair.Thickness = 
        .Crosshair.NumSides = 
        .Crosshair.Radius = 
        .Crosshair.Filled = 
        .Crosshair.Color = .(, , )
        .Crosshair.Transparency = 
        .Crosshair.Visible = 
        
        .CrosshairLine1 = .()
        .CrosshairLine1.Thickness = 
        .CrosshairLine1.Color = .(, , )
        .CrosshairLine1.Transparency = 
        .CrosshairLine1.Visible = 
        
        .CrosshairLine2 = .()
        .CrosshairLine2.Thickness = 
        .CrosshairLine2.Color = .(, , )
        .CrosshairLine2.Transparency = 
        .CrosshairLine2.Visible = 
        
        .CrosshairLine3 = .()
        .CrosshairLine3.Thickness = 
        .CrosshairLine3.Color = .(, , )
        .CrosshairLine3.Transparency = 
        .CrosshairLine3.Visible = 
        
        .CrosshairLine4 = .()
        .CrosshairLine4.Thickness = 
        .CrosshairLine4.Color = .(, , )
        .CrosshairLine4.Transparency = 
        .CrosshairLine4.Visible = 
        
        .CrosshairConnection = runService.RenderStepped:(()
             centerX = camera.ViewportSize.X / 
             centerY = camera.ViewportSize.Y / 
            
            .Crosshair.Position = .(centerX, centerY)
            
             gap = 
             length = 
            
            .CrosshairLine1.From = .(centerX, centerY - gap)
            .CrosshairLine1.To = .(centerX, centerY - gap - length)
            
            .CrosshairLine2.From = .(centerX, centerY + gap)
            .CrosshairLine2.To = .(centerX, centerY + gap + length)
            
            .CrosshairLine3.From = .(centerX - gap, centerY)
            .CrosshairLine3.To = .(centerX - gap - length, centerY)
            
            .CrosshairLine4.From = .(centerX + gap, centerY)
            .CrosshairLine4.To = .(centerX + gap + length, centerY)
        )
    
         .Crosshair 
            .Crosshair:()
            .Crosshair = 
        
         .CrosshairLine1 
            .CrosshairLine1:()
            .CrosshairLine1 = 
        
         .CrosshairLine2 
            .CrosshairLine2:()
            .CrosshairLine2 = 
        
         .CrosshairLine3 
            .CrosshairLine3:()
            .CrosshairLine3 = 
        
         .CrosshairLine4 
            .CrosshairLine4:()
            .CrosshairLine4 = 
        
         .CrosshairConnection 
            .CrosshairConnection:()
            .CrosshairConnection = 
        
    
)
yPos = yPos + 

 statusFrame = .()
statusFrame.Size = .(, , , )

     statusFrame = .()
    statusFrame.Size = .(, , , )
    statusFrame.Position = .(, , , yPos)
    statusFrame.BackgroundColor3 = theme.surface
    statusFrame.BorderSizePixel = 
    statusFrame.ZIndex = 
    statusFrame.Parent = contentContainer
    
     statusCorner = .()
    statusCorner.CornerRadius = .(, )
    statusCorner.Parent = statusFrame
    
     statusTitle = .()
    statusTitle.Size = .(, -, , )
    statusTitle.Position = .(, , , )
    statusTitle.BackgroundTransparency = 
    statusTitle.Text = 
    statusTitle.TextColor3 = theme.text
    statusTitle.TextSize = 
    statusTitle.Font = .Font.GothamBold
    statusTitle.TextXAlignment = .TextXAlignment.Left
    statusTitle.ZIndex = 
    statusTitle.Parent = statusFrame
    
      (text, yOffset, active)
         dot = .()
        dot.Size = .(, , , )
        dot.Position = .(, , , yOffset)
        dot.BackgroundColor3 = active  theme.success  theme.danger
        dot.BorderSizePixel = 
        dot.ZIndex = 
        dot.Parent = statusFrame
        
         dotCorner = .()
        dotCorner.CornerRadius = .(, )
        dotCorner.Parent = dot
        
         statusLabel = .()
        statusLabel.Size = .(, -, , )
        statusLabel.Position = .(, , , yOffset - )
        statusLabel.BackgroundTransparency = 
        statusLabel.Text = text
        statusLabel.TextColor3 = theme.textDim
        statusLabel.TextSize = 
        statusLabel.Font = .Font.Gotham
        statusLabel.TextXAlignment = .TextXAlignment.Left
        statusLabel.ZIndex = 
        statusLabel.Parent = statusFrame
        
         dot
    
    
    (, , )
    (, , )
    (, , )
    
    ()


pageContent[] = ()
    contentContainer:()
    
     yPos = 
    
     keybindFrame = .()
    keybindFrame.Size = .(, , , )
    keybindFrame.Position = .(, , , yPos)
    keybindFrame.BackgroundColor3 = theme.surface
    keybindFrame.BorderSizePixel = 
    keybindFrame.ZIndex = 
    keybindFrame.Parent = contentContainer
    
     keybindCorner = .()
    keybindCorner.CornerRadius = .(, )
    keybindCorner.Parent = keybindFrame
    
     keybindTitle = .()
    keybindTitle.Size = .(, -, , )
    keybindTitle.Position = .(, , , )
    keybindTitle.BackgroundTransparency = 
    keybindTitle.Text = 
    keybindTitle.TextColor3 = theme.text
    keybindTitle.TextSize = 
    keybindTitle.Font = .Font.GothamBold
    keybindTitle.TextXAlignment = .TextXAlignment.Left
    keybindTitle.ZIndex = 
    keybindTitle.Parent = keybindFrame
    
     keybindButton = .()
    keybindButton.Size = .(, -, , )
    keybindButton.Position = .(, , , )
    keybindButton.BackgroundColor3 = theme.surfaceLight
    keybindButton.BorderSizePixel = 
    keybindButton.Text = menuKey.Name
    keybindButton.TextColor3 = theme.primary
    keybindButton.TextSize = 
    keybindButton.Font = .Font.GothamBold
    keybindButton.ZIndex = 
    keybindButton.Parent = keybindFrame
    
     keybindCorner2 = .()
    keybindCorner2.CornerRadius = .(, )
    keybindCorner2.Parent = keybindButton
    
     waitingForKey = 
    keybindButton.MouseButton1Click:(()
        waitingForKey = 
        keybindButton.Text = 
        keybindButton.TextColor3 = theme.accent
    )
    
    userInputService.InputBegan:((input, gameProcessed)
         waitingForKey  input.KeyCode ~= .KeyCode.Unknown 
            menuKey = input.KeyCode
            keybindButton.Text = input.KeyCode.Name
            keybindButton.TextColor3 = theme.primary
            waitingForKey = 
        
    )
    
    yPos = yPos + 
    
     configListFrame = .()
    configListFrame.Size = .(, , , )
    configListFrame.Position = .(, , , yPos)
    configListFrame.BackgroundColor3 = theme.surface
    configListFrame.BorderSizePixel = 
    configListFrame.ZIndex = 
    configListFrame.Parent = contentContainer
    
     configListCorner = .()
    configListCorner.CornerRadius = .(, )
    configListCorner.Parent = configListFrame
    
     configTitle = .()
    configTitle.Size = .(, -, , )
    configTitle.Position = .(, , , )
    configTitle.BackgroundTransparency = 
    configTitle.Text = 
    configTitle.TextColor3 = theme.text
    configTitle.TextSize = 
    configTitle.Font = .Font.GothamBold
    configTitle.TextXAlignment = .TextXAlignment.Left
    configTitle.ZIndex = 
    configTitle.Parent = configListFrame
    
      (configName, yOffset, parent)
         configBtn = .()
        configBtn.Size = .(, -, , )
        configBtn.Position = .(, , , yOffset)
        configBtn.BackgroundColor3 = theme.surfaceLight
        configBtn.BorderSizePixel = 
        configBtn.Text = 
        configBtn.ZIndex = 
        configBtn.Parent = parent
        
         configBtnCorner = .()
        configBtnCorner.CornerRadius = .(, )
        configBtnCorner.Parent = configBtn
        
         configNameLabel = .()
        configNameLabel.Size = .(, , , )
        configNameLabel.Position = .(, , , )
        configNameLabel.BackgroundTransparency = 
        configNameLabel.Text = configName
        configNameLabel.TextColor3 = theme.text
        configNameLabel.TextSize = 
        configNameLabel.Font = .Font.GothamSemibold
        configNameLabel.TextXAlignment = .TextXAlignment.Left
        configNameLabel.ZIndex = 
        configNameLabel.Parent = configBtn
        
         loadBtn = .()
        loadBtn.Size = .(, , , )
        loadBtn.Position = .(, -, , -)
        loadBtn.BackgroundColor3 = theme.success
        loadBtn.BorderSizePixel = 
        loadBtn.Text = 
        loadBtn.TextColor3 = .(, , )
        loadBtn.TextSize = 
        loadBtn.Font = .Font.GothamBold
        loadBtn.ZIndex = 
        loadBtn.Parent = configBtn
        
         loadBtnCorner = .()
        loadBtnCorner.CornerRadius = .(, )
        loadBtnCorner.Parent = loadBtn
        
        loadBtn.MouseButton1Click:(()
             success = (configName)
             success 
                tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
                ()
                tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = theme.success}):()
            
                tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = theme.danger}):()
                ()
                tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = theme.success}):()
            
        )
        
        loadBtn.MouseEnter:(()
            tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
        )
        
        loadBtn.MouseLeave:(()
            tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = theme.success}):()
        )
    
    
    (, , configListFrame)
    (, , configListFrame)
    
    yPos = yPos + 
    
     savedConfigsList = {}
     name, _  (savedConfigs) 
         name ~=   name ~=  
            .(savedConfigsList, name)
        
    
    
     savedConfigsHeight = .(,  + (#savedConfigsList * ))
    
     savedConfigsFrame = .()
    savedConfigsFrame.Size = .(, , , savedConfigsHeight)
    savedConfigsFrame.Position = .(, , , yPos)
    savedConfigsFrame.BackgroundColor3 = theme.surface
    savedConfigsFrame.BorderSizePixel = 
    savedConfigsFrame.ZIndex = 
    savedConfigsFrame.Parent = contentContainer
    
     savedConfigsCorner = .()
    savedConfigsCorner.CornerRadius = .(, )
    savedConfigsCorner.Parent = savedConfigsFrame
    
     savedConfigsTitle = .()
    savedConfigsTitle.Size = .(, -, , )
    savedConfigsTitle.Position = .(, , , )
    savedConfigsTitle.BackgroundTransparency = 
    savedConfigsTitle.Text =  .. #savedConfigsList .. 
    savedConfigsTitle.TextColor3 = theme.text
    savedConfigsTitle.TextSize = 
    savedConfigsTitle.Font = .Font.GothamBold
    savedConfigsTitle.TextXAlignment = .TextXAlignment.Left
    savedConfigsTitle.ZIndex = 
    savedConfigsTitle.Parent = savedConfigsFrame
    
     #savedConfigsList ==  
         noConfigsLabel = .()
        noConfigsLabel.Size = .(, -, , )
        noConfigsLabel.Position = .(, , , )
        noConfigsLabel.BackgroundTransparency = 
        noConfigsLabel.Text = 
        noConfigsLabel.TextColor3 = theme.textDim
        noConfigsLabel.TextSize = 
        noConfigsLabel.Font = .Font.Gotham
        noConfigsLabel.TextXAlignment = .TextXAlignment.Center
        noConfigsLabel.ZIndex = 
        noConfigsLabel.Parent = savedConfigsFrame
    
         i, configName  (savedConfigsList) 
             configBtn = .()
            configBtn.Size = .(, -, , )
            configBtn.Position = .(, , ,  + (i - ) * )
            configBtn.BackgroundColor3 = theme.surfaceLight
            configBtn.BorderSizePixel = 
            configBtn.Text = 
            configBtn.ZIndex = 
            configBtn.Parent = savedConfigsFrame
            
             configBtnCorner = .()
            configBtnCorner.CornerRadius = .(, )
            configBtnCorner.Parent = configBtn
            
             configNameLabel = .()
            configNameLabel.Size = .(, , , )
            configNameLabel.Position = .(, , , )
            configNameLabel.BackgroundTransparency = 
            configNameLabel.Text = configName
            configNameLabel.TextColor3 = theme.text
            configNameLabel.TextSize = 
            configNameLabel.Font = .Font.GothamSemibold
            configNameLabel.TextXAlignment = .TextXAlignment.Left
            configNameLabel.ZIndex = 
            configNameLabel.Parent = configBtn
            
             loadBtn = .()
            loadBtn.Size = .(, , , )
            loadBtn.Position = .(, -, , -)
            loadBtn.BackgroundColor3 = theme.success
            loadBtn.BorderSizePixel = 
            loadBtn.Text = 
            loadBtn.TextColor3 = .(, , )
            loadBtn.TextSize = 
            loadBtn.Font = .Font.GothamBold
            loadBtn.ZIndex = 
            loadBtn.Parent = configBtn
            
             loadBtnCorner = .()
            loadBtnCorner.CornerRadius = .(, )
            loadBtnCorner.Parent = loadBtn
            
             deleteBtn = .()
            deleteBtn.Size = .(, , , )
            deleteBtn.Position = .(, -, , -)
            deleteBtn.BackgroundColor3 = theme.danger
            deleteBtn.BorderSizePixel = 
            deleteBtn.Text = 
            deleteBtn.TextColor3 = .(, , )
            deleteBtn.TextSize = 
            deleteBtn.Font = .Font.GothamBold
            deleteBtn.ZIndex = 
            deleteBtn.Parent = configBtn
            
             deleteBtnCorner = .()
            deleteBtnCorner.CornerRadius = .(, )
            deleteBtnCorner.Parent = deleteBtn
            
            loadBtn.MouseButton1Click:(()
                 success = (configName)
                 success 
                    tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
                    ()
                    tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = theme.success}):()
                
            )
            
            deleteBtn.MouseButton1Click:(()
                 success = (configName)
                 success 
                    tweenService:(deleteBtn, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
                    ()
                    pageContent[]()
                
            )
            
            loadBtn.MouseEnter:(()
                tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
            )
            
            loadBtn.MouseLeave:(()
                tweenService:(loadBtn, TweenInfo.(), {BackgroundColor3 = theme.success}):()
            )
            
            deleteBtn.MouseEnter:(()
                tweenService:(deleteBtn, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
            )
            
            deleteBtn.MouseLeave:(()
                tweenService:(deleteBtn, TweenInfo.(), {BackgroundColor3 = theme.danger}):()
            )
        
    
    
    yPos = yPos + savedConfigsHeight + 
    
     customConfigFrame = .()
    customConfigFrame.Size = .(, , , )
    customConfigFrame.Position = .(, , , yPos)
    customConfigFrame.BackgroundColor3 = theme.surface
    customConfigFrame.BorderSizePixel = 
    customConfigFrame.ZIndex = 
    customConfigFrame.Parent = contentContainer
    
     customConfigCorner = .()
    customConfigCorner.CornerRadius = .(, )
    customConfigCorner.Parent = customConfigFrame
    
     customTitle = .()
    customTitle.Size = .(, -, , )
    customTitle.Position = .(, , , )
    customTitle.BackgroundTransparency = 
    customTitle.Text = 
    customTitle.TextColor3 = theme.text
    customTitle.TextSize = 
    customTitle.Font = .Font.GothamBold
    customTitle.TextXAlignment = .TextXAlignment.Left
    customTitle.ZIndex = 
    customTitle.Parent = customConfigFrame
    
     configNameBox = .()
    configNameBox.Size = .(, -, , )
    configNameBox.Position = .(, , , )
    configNameBox.BackgroundColor3 = theme.surfaceLight
    configNameBox.BorderSizePixel = 
    configNameBox.Text = 
    configNameBox.PlaceholderText = 
    configNameBox.PlaceholderColor3 = theme.textDim
    configNameBox.TextColor3 = theme.text
    configNameBox.TextSize = 
    configNameBox.Font = .Font.Gotham
    configNameBox.ClearTextOnFocus = 
    configNameBox.ZIndex = 
    configNameBox.Parent = customConfigFrame
    
     configNameBoxCorner = .()
    configNameBoxCorner.CornerRadius = .(, )
    configNameBoxCorner.Parent = configNameBox
    
     saveButton = .()
    saveButton.Size = .(, -, , )
    saveButton.Position = .(, , , )
    saveButton.BackgroundColor3 = theme.primary
    saveButton.BorderSizePixel = 
    saveButton.Text = 
    saveButton.TextColor3 = .(, , )
    saveButton.TextSize = 
    saveButton.Font = .Font.GothamBold
    saveButton.ZIndex = 
    saveButton.Parent = customConfigFrame
    
     saveButtonCorner = .()
    saveButtonCorner.CornerRadius = .(, )
    saveButtonCorner.Parent = saveButton
    
    saveButton.MouseButton1Click:(()
         configName = configNameBox.Text
         configName ~=  
            (configName)
            tweenService:(saveButton, TweenInfo.(), {BackgroundColor3 = theme.success}):()
            configNameBox.Text = 
            ()
            tweenService:(saveButton, TweenInfo.(), {BackgroundColor3 = theme.primary}):()
            ()
            pageContent[]()
        
    )
    
    saveButton.MouseEnter:(()
        tweenService:(saveButton, TweenInfo.(), {BackgroundColor3 = .(, , )}):()
    )
    
    saveButton.MouseLeave:(()
        tweenService:(saveButton, TweenInfo.(), {BackgroundColor3 = theme.primary}):()
    )
    
    ()


  (pageName)
    currentPage = pageName
    
     targetY =  + (({Aim = , Visuals = , Misc = , Settings = })[pageName]  ) * 
    tweenService:(pageIndicator, TweenInfo.(, .EasingStyle.Quart), {
        Position = UDim2.new(0, 0, 0, targetY)
    }):Play()
    
    for name, buttonData in pairs(pageButtons) do
        if name == pageName then
            tweenService:Create(buttonData.icon, TweenInfo.new(0.3), {TextColor3 = theme.primary}):Play()
            tweenService:Create(buttonData.label, TweenInfo.new(0.3), {TextColor3 = theme.text}):Play()
        else
            tweenService:Create(buttonData.icon, TweenInfo.new(0.3), {TextColor3 = theme.textDim}):Play()
            tweenService:Create(buttonData.label, TweenInfo.new(0.3), {TextColor3 = theme.textDim}):Play()
        end
    end
    
    for _, child in pairs(contentContainer:GetChildren()) do
        tweenService:Create(child, TweenInfo.new(0.2), {BackgroundTransparency = 1}):Play()
        for _, subChild in pairs(child:GetChildren()) do
            if subChild:IsA("TextLabel") or subChild:IsA("TextButton") then
                tweenService:Create(subChild, TweenInfo.new(0.2), {TextTransparency = 1}):Play()
            end
        end
    end
    
    wait(0.25)
    if pageContent[pageName] then
        pageContent[pageName]()
    end
    
    for _, child in pairs(contentContainer:GetChildren()) do
        child.BackgroundTransparency = 1
        tweenService:Create(child, TweenInfo.new(0.3), {BackgroundTransparency = 0}):Play()
        for _, subChild in pairs(child:GetChildren()) do
            if subChild:IsA("TextLabel") or subChild:IsA("TextButton") then
                subChild.TextTransparency = 1
                tweenService:Create(subChild, TweenInfo.new(0.3), {TextTransparency = 0}):Play()
            end
        end
    end
end

for name, buttonData in pairs(pageButtons) do
    buttonData.button.MouseButton1Click:Connect(function()
        switchPage(name)
    end)
end

switchPage("Aim")

local function isVisible(targetChar)
    if not targetChar or not targetChar:FindFirstChild("HumanoidRootPart") then
        return false
    end
    
    local origin = camera.CFrame.Position
    local direction = (targetChar.HumanoidRootPart.Position - origin).Unit * 500
    
    local ray = Ray.new(origin, direction)
    local hit, position = workspace:FindPartOnRayWithIgnoreList(ray, {character, camera})
    
    if hit and hit:IsDescendantOf(targetChar) then
        return true
    end
    
    return false
end

local function createESP(plr)
    if plr == player then return end
    
    local corners = {}
    for i = 1, 8 do
        local line = Drawing.new("Line")
        line.Visible = false
        line.Color = theme.primary
        line.Thickness = 2
        line.Transparency = 1
        table.insert(corners, line)
    end
    
    local espBox = Drawing.new("Square")
    espBox.Visible = false
    espBox.Color = theme.primary
    espBox.Thickness = 2
    espBox.Transparency = 1
    espBox.Filled = false
    
    local espName = Drawing.new("Text")
    espName.Visible = false
    espName.Color = Color3.fromRGB(255, 255, 255)
    espName.Text = plr.Name
    espName.Size = 14
    espName.Center = true
    espName.Outline = true
    espName.Font = 2
    
    local espDistance = Drawing.new("Text")
    espDistance.Visible = false
    espDistance.Color = theme.accent
    espDistance.Size = 12
    espDistance.Center = true
    espDistance.Outline = true
    espDistance.Font = 2
    
    local espHealth = Drawing.new("Text")
    espHealth.Visible = false
    espHealth.Color = theme.success
    espHealth.Size = 12
    espHealth.Center = true
    espHealth.Outline = true
    espHealth.Font = 2
    
    local espHealthBar = Drawing.new("Square")
    espHealthBar.Visible = false
    espHealthBar.Color = theme.success
    espHealthBar.Thickness = 1
    espHealthBar.Transparency = 1
    espHealthBar.Filled = true
    
    local espHealthBarBG = Drawing.new("Square")
    espHealthBarBG.Visible = false
    espHealthBarBG.Color = Color3.fromRGB(20, 20, 25)
    espHealthBarBG.Thickness = 1
    espHealthBarBG.Transparency = 0.7
    espHealthBarBG.Filled = true
    
    local espHealthBarOutline = Drawing.new("Square")
    espHealthBarOutline.Visible = false
    espHealthBarOutline.Color = Color3.fromRGB(0, 0, 0)
    espHealthBarOutline.Thickness = 1
    espHealthBarOutline.Transparency = 1
    espHealthBarOutline.Filled = false
    
    local skeletonLines = {}
    for i = 1, 6 do
        local line = Drawing.new("Line")
        line.Visible = false
        line.Color = theme.secondary
        line.Thickness = 2
        line.Transparency = 0.8
        table.insert(skeletonLines, line)
    end
    
    local tracer = Drawing.new("Line")
    tracer.Visible = false
    tracer.Color = theme.accent
    tracer.Thickness = 1
    tracer.Transparency = 0.6

    local nameTag = Drawing.new("Text")
    nameTag.Visible = false
    nameTag.Size = 16
    nameTag.Center = true
    nameTag.Outline = true
    nameTag.Font = 2
    nameTag.Text = "Flick Fucker User"
    
    espObjects[plr] = {
        box = espBox,
        corners = corners,
        name = espName,
        distance = espDistance,
        health = espHealth,
        healthBar = espHealthBar,
        healthBarBG = espHealthBarBG,
        healthBarOutline = espHealthBarOutline,
        skeleton = skeletonLines,
        tracer = tracer,
        nameTag = nameTag
    }
end

local function removeESP(plr)
    if espObjects[plr] then
        espObjects[plr].box:Remove()
        for _, corner in pairs(espObjects[plr].corners) do
            corner:Remove()
        end
        espObjects[plr].name:Remove()
        espObjects[plr].distance:Remove()
        espObjects[plr].health:Remove()
        espObjects[plr].healthBar:Remove()
        espObjects[plr].healthBarBG:Remove()
        espObjects[plr].healthBarOutline:Remove()
        for _, line in pairs(espObjects[plr].skeleton) do
            line:Remove()
        end
        espObjects[plr].tracer:Remove()
        if espObjects[plr].nameTag then
            espObjects[plr].nameTag:Remove()
        end
        espObjects[plr] = nil
    end
end

local function updateRadar()
    if not isRadarActive or not character or not character:FindFirstChild("HumanoidRootPart") then
        for _, line in pairs(radarPlayerArrow) do
            line.Visible = false
        end
        return
    end
    
    local radarSize = 100
    local radarX = 120
    local radarY = camera.ViewportSize.Y - 120
    
    radarBackground.Position = Vector2.new(radarX, radarY)
    radarBackground.Radius = radarSize
    radarBorder.Position = Vector2.new(radarX, radarY)
    radarBorder.Radius = radarSize
    
    local lookVector = character.HumanoidRootPart.CFrame.LookVector
    local angle = math.atan2(lookVector.Z, lookVector.X)
    
    local baseX = radarX
    local baseY = radarY
    
    local arrowLength = 15
    local tipX = baseX + math.cos(angle) * arrowLength
    local tipY = baseY + math.sin(angle) * arrowLength
    
    local wingLength = 8
    local wingAngle1 = angle + math.rad(150)
    local wingAngle2 = angle - math.rad(150)
    
    local wing1X = baseX + math.cos(wingAngle1) * wingLength
    local wing1Y = baseY + math.sin(wingAngle1) * wingLength
    
    local wing2X = baseX + math.cos(wingAngle2) * wingLength
    local wing2Y = baseY + math.sin(wingAngle2) * wingLength
    
    radarPlayerArrow.line1.From = Vector2.new(baseX, baseY)
    radarPlayerArrow.line1.To = Vector2.new(tipX, tipY)
    radarPlayerArrow.line1.Visible = true
    
    radarPlayerArrow.line2.From = Vector2.new(tipX, tipY)
    radarPlayerArrow.line2.To = Vector2.new(wing1X, wing1Y)
    radarPlayerArrow.line2.Visible = true
    
    radarPlayerArrow.line3.From = Vector2.new(tipX, tipY)
    radarPlayerArrow.line3.To = Vector2.new(wing2X, wing2Y)
    radarPlayerArrow.line3.Visible = true
    
    for plr, dot in pairs(radarDots) do
        if plr.Character and plr.Character:FindFirstChild("HumanoidRootPart") and plr.Character:FindFirstChild("Humanoid") and plr.Character.Humanoid.Health > 0 then
            local myHRP = character.HumanoidRootPart
            local theirHRP = plr.Character.HumanoidRootPart
            
            local offset = theirHRP.Position - myHRP.Position
            local distance = offset.Magnitude
            
            if distance < 500 * radarScale then
                local worldAngle = math.atan2(offset.Z, offset.X)
                local relativeAngle = worldAngle - angle
                local scale = math.min(distance / (5 * radarScale), radarSize - 10)
                
                local x = radarX + math.cos(relativeAngle) * scale
                local y = radarY + math.sin(relativeAngle) * scale
                
                dot.Position = Vector2.new(x, y)
                dot.Visible = true
            else
                dot.Visible = false
            end
        else
            dot.Visible = false
        end
    end
end

local function updateFovArrows()
    if not isFovArrowsActive then
        for _, arrow in pairs(fovArrows) do
            arrow.Visible = false
        end
        return
    end
    
    local centerX = camera.ViewportSize.X / 2
    local centerY = camera.ViewportSize.Y / 2
    
    local arrowIndex = 1
    for _, plr in pairs(game.Players:GetPlayers()) do
        if plr ~= player and plr.Character and plr.Character:FindFirstChild("HumanoidRootPart") and plr.Character:FindFirstChild("Humanoid") and plr.Character.Humanoid.Health > 0 then
            local pos, onScreen = camera:WorldToViewportPoint(plr.Character.HumanoidRootPart.Position)
            
            if not onScreen or (Vector2.new(pos.X, pos.Y) - Vector2.new(centerX, centerY)).Magnitude > fov then
                local angle = math.atan2(pos.Y - centerY, pos.X - centerX)
                local arrowDist = fov + 20
                
                local arrowX = centerX + math.cos(angle) * arrowDist
                local arrowY = centerY + math.sin(angle) * arrowDist
                
                if not fovArrows[arrowIndex] then
                    local arrow = Drawing.new("Triangle")
                    arrow.Thickness = 2
                    arrow.Filled = true
                    arrow.Color = theme.danger
                    arrow.Transparency = 0.8
                    fovArrows[arrowIndex] = arrow
                end
                
                local arrow = fovArrows[arrowIndex]
                local arrowSize = 12
                local tipX = arrowX + math.cos(angle) * arrowSize
                local tipY = arrowY + math.sin(angle) * arrowSize
                local baseAngle1 = angle + math.rad(150)
                local baseAngle2 = angle - math.rad(150)
                
                arrow.PointA = Vector2.new(tipX, tipY)
                arrow.PointB = Vector2.new(arrowX + math.cos(baseAngle1) * arrowSize, arrowY + math.sin(baseAngle1) * arrowSize)
                arrow.PointC = Vector2.new(arrowX + math.cos(baseAngle2) * arrowSize, arrowY + math.sin(baseAngle2) * arrowSize)
                arrow.Visible = true
                
                arrowIndex = arrowIndex + 1
            end
        end
    end
    
    for i = arrowIndex, #fovArrows do
        fovArrows[i].Visible = false
    end
end

local function updateESP()
    for plr, esp in pairs(espObjects) do
        if plr.Character and plr.Character:FindFirstChild("HumanoidRootPart") and plr.Character:FindFirstChild("Humanoid") and plr.Character.Humanoid.Health > 0 then
            local hrp = plr.Character.HumanoidRootPart
            local head = plr.Character:FindFirstChild("Head")
            local humanoid = plr.Character.Humanoid
            
            local vector, onScreen = camera:WorldToViewportPoint(hrp.Position)
            local visible = isVisible(plr.Character)
            
            if onScreen and isEspActive then
                local hrpVector = camera:WorldToViewportPoint(hrp.Position)
                local headVector = camera:WorldToViewportPoint(head.Position + Vector3.new(0, 0.5, 0))
                local legVector = camera:WorldToViewportPoint(hrp.Position - Vector3.new(0, 3, 0))
                
                local height = math.abs(headVector.Y - legVector.Y)
                local width = height / 2
                
                local boxColor = visible and theme.success or theme.danger
                
                if espSettings.box then
                    if espSettings.boxType == "corners" then
                        esp.box.Visible = false
                        
                        local cornerLength = math.min(width, height) * 0.25
                        local topLeft = Vector2.new(hrpVector.X - width / 2, hrpVector.Y - height / 2)
                        local topRight = Vector2.new(hrpVector.X + width / 2, hrpVector.Y - height / 2)
                        local bottomLeft = Vector2.new(hrpVector.X - width / 2, hrpVector.Y + height / 2)
                        local bottomRight = Vector2.new(hrpVector.X + width / 2, hrpVector.Y + height / 2)
                        
                        esp.corners[1].From = topLeft
                        esp.corners[1].To = Vector2.new(topLeft.X + cornerLength, topLeft.Y)
                        esp.corners[1].Color = boxColor
                        esp.corners[1].Visible = true
                        
                        esp.corners[2].From = topLeft
                        esp.corners[2].To = Vector2.new(topLeft.X, topLeft.Y + cornerLength)
                        esp.corners[2].Color = boxColor
                        esp.corners[2].Visible = true
                        
                        esp.corners[3].From = topRight
                        esp.corners[3].To = Vector2.new(topRight.X - cornerLength, topRight.Y)
                        esp.corners[3].Color = boxColor
                        esp.corners[3].Visible = true
                        
                        esp.corners[4].From = topRight
                        esp.corners[4].To = Vector2.new(topRight.X, topRight.Y + cornerLength)
                        esp.corners[4].Color = boxColor
                        esp.corners[4].Visible = true
                        
                        esp.corners[5].From = bottomLeft
                        esp.corners[5].To = Vector2.new(bottomLeft.X + cornerLength, bottomLeft.Y)
                        esp.corners[5].Color = boxColor
                        esp.corners[5].Visible = true
                        
                        esp.corners[6].From = bottomLeft
                        esp.corners[6].To = Vector2.new(bottomLeft.X, bottomLeft.Y - cornerLength)
                        esp.corners[6].Color = boxColor
                        esp.corners[6].Visible = true
                        
                        esp.corners[7].From = bottomRight
                        esp.corners[7].To = Vector2.new(bottomRight.X - cornerLength, bottomRight.Y)
                        esp.corners[7].Color = boxColor
                        esp.corners[7].Visible = true
                        
                        esp.corners[8].From = bottomRight
                        esp.corners[8].To = Vector2.new(bottomRight.X, bottomRight.Y - cornerLength)
                        esp.corners[8].Color = boxColor
                        esp.corners[8].Visible = true
                    else
                        for _, corner in pairs(esp.corners) do
                            corner.Visible = false
                        end
                        
                        esp.box.Color = boxColor
                        esp.box.Size = Vector2.new(width, height)
                        esp.box.Position = Vector2.new(hrpVector.X - width / 2, hrpVector.Y - height / 2)
                        esp.box.Visible = true
                    end
                else
                    esp.box.Visible = false
                    for _, corner in pairs(esp.corners) do
                        corner.Visible = false
                    end
                end
                
                if espSettings.name then
                    esp.name.Position = Vector2.new(hrpVector.X, headVector.Y - 18)
                    esp.name.Visible = true
                else
                    esp.name.Visible = false
                end
                
                if espSettings.distance then
                    local distance = math.floor((camera.CFrame.Position - hrp.Position).Magnitude)
                    esp.distance.Text = distance .. "m"
                    esp.distance.Position = Vector2.new(hrpVector.X, legVector.Y + 8)
                    esp.distance.Visible = true
                else
                    esp.distance.Visible = false
                end
                
                if espSettings.health then
                    local healthPercentage = math.floor((humanoid.Health / humanoid.MaxHealth) * 100)
                    
                    local barHeight = height
                    local barWidth = 4
                    local barX = hrpVector.X - width / 2 - 8
                    local barY = hrpVector.Y - height / 2
                    
                    esp.healthBarBG.Size = Vector2.new(barWidth, barHeight)
                    esp.healthBarBG.Position = Vector2.new(barX, barY)
                    esp.healthBarBG.Visible = true
                    
                    esp.healthBarOutline.Size = Vector2.new(barWidth + 2, barHeight + 2)
                    esp.healthBarOutline.Position = Vector2.new(barX - 1, barY - 1)
                    esp.healthBarOutline.Visible = true
                    
                    local currentHealthHeight = barHeight * (humanoid.Health / humanoid.MaxHealth)
                    esp.healthBar.Size = Vector2.new(barWidth, currentHealthHeight)
                    esp.healthBar.Position = Vector2.new(barX, barY + (barHeight - currentHealthHeight))
                    
                    if healthPercentage > 75 then
                        esp.healthBar.Color = theme.success
                    elseif healthPercentage > 50 then
                        esp.healthBar.Color = Color3.fromRGB(255, 255, 0)
                    elseif healthPercentage > 25 then
                        esp.healthBar.Color = Color3.fromRGB(255, 165, 0)
                    else
                        esp.healthBar.Color = theme.danger
                    end
                    esp.healthBar.Visible = true
                    
                    esp.health.Text = healthPercentage .. "%"
                    esp.health.Position = Vector2.new(barX + 2, barY - 15)
                    esp.health.Color = esp.healthBar.Color
                    esp.health.Visible = true
                else
                    esp.health.Visible = false
                    esp.healthBar.Visible = false
                    esp.healthBarBG.Visible = false
                    esp.healthBarOutline.Visible = false
                end
                
                if espSettings.skeleton then
                    local torso = plr.Character:FindFirstChild("Torso")
                    local leftArm = plr.Character:FindFirstChild("Left Arm")
                    local rightArm = plr.Character:FindFirstChild("Right Arm")
                    local leftLeg = plr.Character:FindFirstChild("Left Leg")
                    local rightLeg = plr.Character:FindFirstChild("Right Leg")
                    
                    if torso and head and leftArm and rightArm and leftLeg and rightLeg then
                        local connections = {
                            {head.Position, torso.Position},
                            {torso.Position, leftArm.Position},
                            {torso.Position, rightArm.Position},
                            {torso.Position, leftLeg.Position},
                            {torso.Position, rightLeg.Position},
                            {leftArm.Position, rightArm.Position}
                        }
                        
                        for i, connection in ipairs(connections) do
                            local startPos, startOnScreen = camera:WorldToViewportPoint(connection[1])
                            local endPos, endOnScreen = camera:WorldToViewportPoint(connection[2])
                            
                            if startOnScreen and endOnScreen and esp.skeleton[i] then
                                esp.skeleton[i].From = Vector2.new(startPos.X, startPos.Y)
                                esp.skeleton[i].To = Vector2.new(endPos.X, endPos.Y)
                                esp.skeleton[i].Visible = true
                            elseif esp.skeleton[i] then
                                esp.skeleton[i].Visible = false
                            end
                        end
                    end
                else
                    for _, line in pairs(esp.skeleton) do
                        line.Visible = false
                    end
                end
                
                if espSettings.tracers then
                    esp.tracer.From = Vector2.new(camera.ViewportSize.X / 2, camera.ViewportSize.Y)
                    esp.tracer.To = Vector2.new(hrpVector.X, legVector.Y)
                    esp.tracer.Color = boxColor
                    esp.tracer.Visible = true
                else
                    esp.tracer.Visible = false
                end
                if flickFuckerUsers[plr.UserId] then
                    for _, part in pairs(plr.Character:GetDescendants()) do
                        if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                            part.Color = Color3.fromRGB(255, 255, 0)
                            part.Material = Enum.Material.Neon
                        end
                    end
                    
                    local time = tick() * 3
                    local r = math.floor(math.sin(time) * 127 + 128)
                    local g = math.floor(math.sin(time + 2.1) * 127 + 128)
                    local b = math.floor(math.sin(time + 4.2) * 127 + 128)
                    
                    esp.nameTag.Color = Color3.fromRGB(r, g, b)
                    esp.nameTag.Position = Vector2.new(hrpVector.X, headVector.Y - 35)
                    esp.nameTag.Visible = true
                else
                    if esp.nameTag then
                        esp.nameTag.Visible = false
                    end
                end
            else
                esp.box.Visible = false
                for _, corner in pairs(esp.corners) do
                    corner.Visible = false
                end
                esp.name.Visible = false
                esp.distance.Visible = false
                esp.health.Visible = false
                esp.healthBar.Visible = false
                esp.healthBarBG.Visible = false
                esp.healthBarOutline.Visible = false
                for _, line in pairs(esp.skeleton) do
                    line.Visible = false
                end
                esp.tracer.Visible = false
            end
        else
            esp.box.Visible = false
            for _, corner in pairs(esp.corners) do
                corner.Visible = false
            end
            esp.name.Visible = false
            esp.distance.Visible = false
            esp.health.Visible = false
            esp.healthBar.Visible = false
            esp.healthBarBG.Visible = false
            esp.healthBarOutline.Visible = false
            for _, line in pairs(esp.skeleton) do
                line.Visible = false
            end
            esp.tracer.Visible = false
            if esp.nameTag then
                esp.nameTag.Visible = false
            end
        end
    end
end

local function getClosestPlayer()
    local closestPlayer = nil
    local shortestDistance = fov
    
    for _, v in pairs(game.Players:GetPlayers()) do
        if v ~= player and v.Character and v.Character:FindFirstChild(targetPart) and v.Character:FindFirstChild("Humanoid") then
            if v.Character.Humanoid.Health > 0 then
                local pos, onScreen = camera:WorldToViewportPoint(v.Character[targetPart].Position)
                if onScreen then
                    local magnitude = (Vector2.new(pos.X, pos.Y) - Vector2.new(camera.ViewportSize.X / 2, camera.ViewportSize.Y / 2)).Magnitude
                    
                    if magnitude < shortestDistance then
                        closestPlayer = v
                        shortestDistance = magnitude
                    end
                end
            end
        end
    end
    
    return closestPlayer
end

local function updateHitboxes()
    if isHitboxExpanderActive then
        for _, v in pairs(game.Players:GetPlayers()) do
            if v ~= player and v.Character and v.Character:FindFirstChild("HumanoidRootPart") then
                local hrp = v.Character.HumanoidRootPart
                hrp.Size = Vector3.new(hitboxSize, hitboxSize, hitboxSize)
                hrp.Transparency = 0.8
                hrp.CanCollide = false
            end
        end
    else
        for _, v in pairs(game.Players:GetPlayers()) do
            if v ~= player and v.Character and v.Character:FindFirstChild("HumanoidRootPart") then
                local hrp = v.Character.HumanoidRootPart
                hrp.Size = Vector3.new(2, 2, 1)
                hrp.Transparency = 1
                hrp.CanCollide = false
            end
        end
    end
end

closeButton.MouseButton1Click:Connect(function()
    tweenService:Create(mainFrame, TweenInfo.new(0.3, Enum.EasingStyle.Back, Enum.EasingDirection.In), {
        Size = UDim2.new(0, 0, 0, 0)
    }):Play()
    
    tweenService:Create(blur, TweenInfo.new(0.3), {Size = 0}):Play()
    
    wait(0.3)
    screenGui:Destroy()
    fovCircle:Remove()
    blur:Remove()
    radarBackground:Remove()
    radarBorder:Remove()
    for _, line in pairs(radarPlayerArrow) do
        line:Remove()
    end
    for _, dot in pairs(radarDots) do
        dot:Remove()
    end
    for _, arrow in pairs(fovArrows) do
        arrow:Remove()
    end
    for plr, _ in pairs(espObjects) do
        removeESP(plr)
    end
end)

mainFrame.Size = UDim2.new(0, 0, 0, 0)
mainFrame.Position = UDim2.new(0.5, 0, 0.5, 0)
mainFrame.AnchorPoint = Vector2.new(0.5, 0.5)

tweenService:Create(mainFrame, TweenInfo.new(0.5, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
    Size = UDim2.new(0, 550, 0, 450)
}):Play()

tweenService:Create(blur, TweenInfo.new(0.3), {Size = 5}):Play()

runService.RenderStepped:Connect(function()
    fovCircle.Position = Vector2.new(camera.ViewportSize.X / 2, camera.ViewportSize.Y / 2)
    updateHitboxes()
    updateRadar()
    updateFovArrows()
end)

runService.RenderStepped:Connect(function()
    if isAimbotActive and aimbotEnabled then
        local target = getClosestPlayer()
        if target and target.Character and target.Character:FindFirstChild(targetPart) then
            if isVisible(target.Character) then
                local targetPartObj = target.Character[targetPart]
                local targetPos = targetPartObj.Position
                local currentCFrame = camera.CFrame
                local targetCFrame = CFrame.new(currentCFrame.Position, targetPos)
                camera.CFrame = currentCFrame:Lerp(targetCFrame, 1 / aimbotSmoothness)
            end
        end
    end
end)

local currentTarget = nil
local lastShotTime = 0
local triggerBotDelay = 0.1

runService.RenderStepped:Connect(function()
    if isSilentAimActive then
        local target = getClosestPlayer()
        if target and target.Character and target.Character:FindFirstChild(targetPart) then
            currentTarget = target.Character[targetPart]
        else
            currentTarget = nil
        end
    else
        currentTarget = nil
    end
    
    if isTriggerBotActive then
        local target = getClosestPlayer()
        if target and target.Character and target.Character:FindFirstChild(targetPart) then
            if isVisible(target.Character) then
                local currentTime = tick()
                if currentTime - lastShotTime >= triggerBotDelay then
                    local targetPart = target.Character[targetPart]
                    local oldCFrame = camera.CFrame
                    camera.CFrame = CFrame.new(camera.CFrame.Position, targetPart.Position)
                    
                    wait(0.05)
                    
                    mouse1press()
                    wait(0.02)
                    mouse1release()
                    
                    wait(0.03)
                    camera.CFrame = oldCFrame
                    
                    lastShotTime = currentTime
                end
            end
        end
    end
end)

mouse.Button1Down:Connect(function()
    if isSilentAimActive and currentTarget then
        local oldCFrame = camera.CFrame
        camera.CFrame = CFrame.new(camera.CFrame.Position, currentTarget.Position)
        wait()
        camera.CFrame = oldCFrame
    end
end)

local keyMap = {
    ["RMB"] = Enum.UserInputType.MouseButton2,
    ["X"] = Enum.KeyCode.X,
    ["C"] = Enum.KeyCode.C,
    ["Z"] = Enum.KeyCode.Z,
    ["V"] = Enum.KeyCode.V,
    ["B"] = Enum.KeyCode.B,
    ["N"] = Enum.KeyCode.N,
    ["M"] = Enum.KeyCode.M
}

userInputService.InputBegan:Connect(function(input, gameProcessed)
    if not gameProcessed and isAimbotActive then
        local currentKey = keyMap[aimbotKey]
        
        if currentKey then
            if (input.UserInputType == currentKey) or (input.KeyCode == currentKey) then
                if aimbotMode == "Hold" then
                    aimbotEnabled = true
                elseif aimbotMode == "Toggle" then
                    aimbotEnabled = not aimbotEnabled
                end
            end
        end
    end
end)

userInputService.InputEnded:Connect(function(input, gameProcessed)
    if isAimbotActive and aimbotMode == "Hold" then
        local currentKey = keyMap[aimbotKey]
        
        if currentKey then
            if (input.UserInputType == currentKey) or (input.KeyCode == currentKey) then
                aimbotEnabled = false
            end
        end
    end
end)

runService.RenderStepped:Connect(function()
    updateESP()
end)

runService.RenderStepped:Connect(function()
    for userId, _ in pairs(flickFuckerUsers) do
        for _, plr in pairs(game.Players:GetPlayers()) do
            if plr.UserId == userId and plr ~= player and plr.Character then
                for _, part in pairs(plr.Character:GetDescendants()) do
                    if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                        part.Color = Color3.fromRGB(255, 255, 0)
                        part.Material = Enum.Material.Neon
                    end
                end
                
                if espObjects[plr] and espObjects[plr].nameTag then
                    local hrp = plr.Character:FindFirstChild("HumanoidRootPart")
                    local head = plr.Character:FindFirstChild("Head")
                    
                    if hrp and head then
                        local hrpVector, onScreen = camera:WorldToViewportPoint(hrp.Position)
                        local headVector = camera:WorldToViewportPoint(head.Position + Vector3.new(0, 0.5, 0))
                        
                        if onScreen then
                            local time = tick() * 3
                            local r = math.floor(math.sin(time) * 127 + 128)
                            local g = math.floor(math.sin(time + 2.1) * 127 + 128)
                            local b = math.floor(math.sin(time + 4.2) * 127 + 128)
                            
                            espObjects[plr].nameTag.Color = Color3.fromRGB(r, g, b)
                            espObjects[plr].nameTag.Position = Vector2.new(hrpVector.X, headVector.Y - 35)
                            espObjects[plr].nameTag.Visible = true
                        else
                            espObjects[plr].nameTag.Visible = false
                        end
                    end
                end
            end
        end
    end
end)

game.Players.PlayerAdded:Connect(function(plr)
    createESP(plr)
    
    local radarDot = Drawing.new("Circle")
    radarDot.Thickness = 1
    radarDot.NumSides = 20
    radarDot.Radius = 4
    radarDot.Filled = true
    radarDot.Color = theme.danger
    radarDot.Transparency = 1
    radarDot.Visible = false
    radarDots[plr] = radarDot
end)

game.Players.PlayerRemoving:Connect(function(plr)
    removeESP(plr)
    
    if radarDots[plr] then
        radarDots[plr]:Remove()
        radarDots[plr] = nil
    end
end)

for _, plr in pairs(game.Players:GetPlayers()) do
    if plr ~= player then
        createESP(plr)
        
        local radarDot = Drawing.new("Circle")
        radarDot.Thickness = 1
        radarDot.NumSides = 20
        radarDot.Radius = 4
        radarDot.Filled = true
        radarDot.Color = theme.danger
        radarDot.Transparency = 1
        radarDot.Visible = false
        radarDots[plr] = radarDot
    end
end

player.CharacterAdded:Connect(function(char)
    character = char
    wait(0.3)
end)

local flickFuckerUsers = {}
local textChatService = game:GetService("TextChatService")
local replicatedStorage = game:GetService("ReplicatedStorage")

local function markFlickFuckerUser(userId)
    if not flickFuckerUsers[userId] then
        flickFuckerUsers[userId] = true
        print("🔥 DETECTED FLICK FUCKER USER: " .. userId)
        
        for _, plr in pairs(game.Players:GetPlayers()) do
            if plr.UserId == userId and not espObjects[plr] and plr ~= player then
                createESP(plr)
            end
        end
    end
end

markFlickFuckerUser(player.UserId)

local function sendDetectionMessage()
    pcall(function()
        if textChatService:FindFirstChild("TextChannels") then
            local generalChannel = textChatService.TextChannels:FindFirstChild("RBXGeneral")
            if generalChannel then
                generalChannel:SendAsync(".")
            end
        end
        
        pcall(function()
            game:GetService("ReplicatedStorage").DefaultChatSystemChatEvents.SayMessageRequest:FireServer(".", "All")
        end)
        
        local marker = Instance.new("StringValue")
        marker.Name = "FF_User_" .. player.UserId
        marker.Value = "ACTIVE"
        marker.Parent = replicatedStorage
        
        game:GetService("Debris"):AddItem(marker, 5)
    end)
end

local function detectViaStorage()
    for _, obj in pairs(replicatedStorage:GetChildren()) do
        if obj:IsA("StringValue") and string.match(obj.Name, "FF_User_") then
            local userId = tonumber(string.match(obj.Name, "%d+"))
            if userId and userId ~= player.UserId then
                markFlickFuckerUser(userId)
            end
        end
    end
end

replicatedStorage.ChildAdded:Connect(function(child)
    if child:IsA("StringValue") and string.match(child.Name, "FF_User_") then
        local userId = tonumber(string.match(child.Name, "%d+"))
        if userId and userId ~= player.UserId then
            markFlickFuckerUser(userId)
        end
    end
end)

pcall(function()
    textChatService.MessageReceived:Connect(function(message)
        if message.Text == "." and message.TextSource then
            local userId = message.TextSource.UserId
            if userId ~= player.UserId then
                print("🔍 Detected '.' from UserID: " .. userId)
                markFlickFuckerUser(userId)
            end
        end
    end)
end)

pcall(function()
    local chatEvents = replicatedStorage:FindFirstChild("DefaultChatSystemChatEvents")
    if chatEvents then
        local onMessageDoneFiltering = chatEvents:FindFirstChild("OnMessageDoneFiltering")
        if onMessageDoneFiltering then
            onMessageDoneFiltering.OnClientEvent:Connect(function(messageData)
                if messageData and messageData.Message == "." then
                    local speaker = game.Players:FindFirstChild(messageData.FromSpeaker)
                    if speaker and speaker ~= player then
                        print("🔍 Detected '.' from: " .. speaker.Name)
                        markFlickFuckerUser(speaker.UserId)
                    end
                end
            end)
        end
    end
end)

spawn(function()
    wait(3)
    pcall(function()
        if textChatService:FindFirstChild("TextChannels") then
            local generalChannel = textChatService.TextChannels:FindFirstChild("RBXGeneral")
            if generalChannel then
                for _, message in pairs(generalChannel:GetChildren()) do
                    if message:IsA("TextChatMessage") and message.Text == "." and message.TextSource then
                        local userId = message.TextSource.UserId
                        if userId ~= player.UserId then
                            print("📜 Found old '.' from UserID: " .. userId)
                            markFlickFuckerUser(userId)
                        end
                    end
                end
            end
        end
    end)
end)

spawn(function()
    wait(3)
    pcall(function()
        local chatService = game:GetService("Chat")
        for _, plr in pairs(game.Players:GetPlayers()) do
            if plr ~= player then
            end
        end
    end)
end)

local hasSentInitial = false
spawn(function()
    wait(2)
    if not hasSentInitial then
        hasSentInitial = true
        print("📡 Sending initial detection message...")
        sendDetectionMessage()
        wait(1)
        detectViaStorage()
    end
end)

local playersAlreadyHere = {}
for _, plr in pairs(game.Players:GetPlayers()) do
    playersAlreadyHere[plr.UserId] = true
end

print("loading 1%")
print("loading 2%")
print("loading 3%")
print("loading anticheat bypass LITERALLY")
print("loading extra loading%")
print("loading done%")
print("loaded flick fucker enjoy! ( made by @.9177) ")

userInputService.InputBegan:Connect(function(input, gameProcessed)
    if not gameProcessed and input.KeyCode == menuKey then
        menuVisible = not menuVisible
        if menuVisible then
            mainFrame.Visible = true
            tweenService:Create(mainFrame, TweenInfo.new(0.3, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
                Size = UDim2.new(0, 550, 0, 450)
            }):Play()
            tweenService:Create(blur, TweenInfo.new(0.3), {Size = 5}):Play()
        else
            tweenService:Create(mainFrame, TweenInfo.new(0.3, Enum.EasingStyle.Back, Enum.EasingDirection.In), {
                Size = UDim2.new(0, 0, 0, 0)
            }):Play()
            tweenService:Create(blur, TweenInfo.new(0.3), {Size = 0}):Play()
            wait(0.3)
            mainFrame.Visible = false
        end
    end
end)

print(".9177")
print(".9177")