Zenith

 N = {}
 Players = :()
 RunService = :()
 UserInputService = :()
 TweenService = :()
 Lighting = :()
N.CollectionService = :()
N.LocalizationService = :()
N.HttpService = :()

 player = Players.LocalPlayer
 playerGui = player:()

 isTouch = UserInputService.TouchEnabled
N.hasMouse = UserInputService.MouseEnabled


N.REQUIRE_GATE = 
N.GATE_ATTRIBUTE = 

N.SHOW_INTRO = 
N.PROJECT_NAME = 

  ()
	 ok, id = (()  N.LocalizationService.RobloxLocaleId )
	id = .(ok  (id)  )
	 p = .(id, , )
	 p ==      p ==     
	 


 DEFAULTS = {

	Aim = , AimHold = , AimPart = , Priority = ,
	Smooth = , Prediction = ,
	UseFov = , FovShow = , FovRadius = , FovThick = , FovColor = ,
	WallCheck = , IgnoreTeam = , IncludeNPCs = ,

	TpAuto = , TpUseFov = , TpMode = , TpOffset = , TpInterval = ,
	TpDmg = , TpDmgMin = , TpDmgMax = , TpDmgCd = ,

	Esp = , EspHighlight = ,
	EspFill = , EspFillTrans = , EspOutline = , EspOutTrans = ,
	EspTeamColor = , EspHealthColor = , EspAlwaysOnTop = ,
	EspNames = , EspHealth = , EspDist = , EspTextSize = ,
	EspBox = , EspBoxColor = , EspBoxThick = , EspBar = ,
	EspTracer = , EspTracerColor = , EspTracerFrom = ,
	EspHead = , EspHeadColor = , EspArrows = , EspArrowColor = ,
	EspVisCheck = , EspNPC = ,
	MotEsp = , MotAim = , MotMinSpeed = , MotMinSize = , MotDist = , MotMaxCount = , MotColor = , MotFillTrans = ,
	MotLabel = , MotSkipPlayers = ,
	CfgSlot = , FpsBoost = , FpsLevel = , FpsKeepChars = ,
	OrbitTime = , OrbitRadius = , OrbitSpeed = , OrbitHeight = , OrbitDir = , OrbitMaxStart = , OrbitReturn = , OrbitFace = ,
	SkyOn = , SkyPreset = , SkyTime = , SkyColor = , SkyCycle = , SkyDensity = , SkyStars = ,
	Chr = , ChrStyle = , ChrColor = , ChrColor2 = , ChrWho = , ChrMat = , ChrSpeed = , ChrAlpha = , CfgText = ,
	EspMaxDist = , EspHideTeam = ,

	SpeedOn = , Speed = , JumpOn = , JumpPower = ,
	InfJump = , Noclip = , Fly = , FlySpeed = , FlyStep = , FlyTickMs = , FlyVert = , FlyPitch = , FlySmooth = ,
	FlyMode = , FlyRamp = , FlyRampTime = , FlyHold = , FlyWalls = , FlyMaxSps = ,
	Spin = , SpinMode = , SpinSpeed = ,
	Bhop = , BhopMax = , BhopGain = ,

	Coins = , CoinName = , CoinInterval = , CoinRange = , CoinReturn = ,
	FullBright = , CamFovOn = , CamFov = ,
	GravityOn = , Gravity = ,
	Crosshair = , CrossSize = , CrossColor = ,
	Tpv = , TpvDist = , TpvFree = ,

	DrName = 
		.. ,
	DrExclude = ,
	DrEsp = , DrEspColor = , DrWarn = , DrWarnRadius = ,
	DrAim = , DrAimRange = , DrAutoFire = ,
	DrEvade = , DrEvadeRadius = , DrEvadeDist = , DrEvadeCd = ,

	AntiFling = , AfNoCollide = , AfClamp = , AfNoRagdoll = ,
	AfVoid = , AfNotify = , AfSpeed = , AfAng = ,
	AntiSit = , SitMode = , SitSpeed = , SitNotify = ,
	AntiFall = , FallHeight = , FallSpeed = , FallNotify = ,
	AntiFlick = , FlickDist = , FlickEnemyOnly = , FlickRevert = ,
	AntiBlind = , AbBlur = , AbBright = , AbGui = ,
	AbIgnore = ,

	Counter = , CtMode = , CtBehindOnly = , CtFace = ,
	CtRadius = , CtMinJump = , CtCooldown = , CtDelay = ,
	TpHl = , TpHlMin = , TpHlRange = , TpHlTime = , TpHlTeam = , TpHlColor = ,
	AimWarn = , AwAngle = , AwRange = , AwTime = , AwWall = , AwTeam = ,
	DtSpeed = , DtFly = , DtNoclip = , DtSpin = , DtHitbox = , DtInvis = , DtLag = ,
	DtReveal = , DtNotify = , DtTags = , DtThreshold = ,
	PullDist = , PullTime = , PullTeam = , PullUseFov = , PullHold = ,
	DtFreeze = , DtFreezeTime = , DtFreezeCool = ,
	DtSpeedMax = , DtFlyTime = , DtSpinRate = , DtHitboxSize = ,
	Susp = , SuspSnap = , SuspThreshold = , SuspTags = , SuspNotify = ,

	Lang = (),
	Accent = , MenuAlpha = , UiScale = , AutoScale = ,
	Toasts = , Quick = isTouch, Debug = ,
	KeyMenu = , KeyAim = , KeyTp = , KeyPanic = , KeyTpv = , KeyPull = , KeyFly = , KeyOrbit = ,
}

N.FEATURES = {
	, , , , , , , , , , , , , ,
	, , , , , , , , , , , ,
	, , , , ,
}

N.DEF_KEYS = {
	, , , , ,
	, , , ,
	, , , , , , , ,
}

 S = {}
 k, v  DEFAULTS  S[k] = v 

N.COLORS = {
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
}

N.CHR_COLORS = {
	{ , .(, , ) }, { , .(, , ) }, { , .(, , ) },
}
 _, c  N.COLORS  N.CHR_COLORS[#N.CHR_COLORS + ] = c 
N.CHR_COLOR_NAMES = {}
 i, c  N.CHR_COLORS  N.CHR_COLOR_NAMES[i] = c[] 
N.SKY_PRESET_NAMES = { , , , , , , , , ,  }
N.CHR_STYLE_NAMES = { , ,  }
N.CHR_WHO_NAMES = { , , ,  }
N.CHR_MAT_NAMES = { , , , ,  }
N.COLOR_NAMES = {}
 i, c  N.COLORS  N.COLOR_NAMES[i] = c[] 
  (idx)  N.COLORS[idx][] 

N.ACCENTS = {
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
	{ , .(, , ) },
}
N.ACCENT_NAMES = {}
 i, c  N.ACCENTS  N.ACCENT_NAMES[i] = c[] 

N.AIM_PART_NAMES = { , ,  }
N.PRIORITY_NAMES = { , ,  }
N.TRACER_FROM_NAMES = { , ,  }
N.TP_MODE_NAMES = { , ,  }
N.SPIN_MODE_NAMES = { , ,  }
N.FLY_MODE_NAMES = { , ,  }
N.ORBIT_DIR_NAMES = { , ,  }
N.FPS_LEVEL_NAMES = { , ,  }
N.SLOT_NAMES = { , , , ,  }
N.CT_MODE_NAMES = { , ,  }
N.SIT_MODE_NAMES = { , ,  }

N.LANG_CODES = { , ,  }
N.LANG_NAMES = { , ,  }
N.TR = {}
  (uk, en, ru) N.TR[uk] = { en = en, ru = ru } 

  (s)
	 code = N.LANG_CODES[S.Lang]  
	 code ==    s 
	 e = N.TR[s]
	 e  e[code]  s


N.langRefs = {}
  (obj, src, prop)
	prop = prop  
	N.langRefs[#N.langRefs + ] = { obj, src, prop }
	obj[prop] = (src)


(, , )
(, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , )

(, , ); (, , ); (, , )
(, , ); (, , ); (, , )
(, , )

(, , ); (, , ); (, , )
(, , )

(, , ); (, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , )

(, , ); (, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , ); (, , ); (, , )
(, , ); (, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , ); (, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , ); (, , ); (, , )
(, , ); (, , ); (, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )

(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , )
(, , ); (, , ); (, , )

(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )

(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , ); (, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , ); (, , )
(, , ); (, , ); (, , ); (, , ); (, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )

(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , ); (, , )

(, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , )
(, , )
(, , ); (, , )

(, , ); (, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )

(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )
(, , )

(, , )
(, , )
(, , ); (, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , ); (, , )
(, , )
(, , )
(, , ); (, , )
(, , )
(, , ); (, , )

(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )
(, , )
(, , )
(, , )
(, , ); (, , )
(, , ); (, , )
(, , ); (, , )
(, , )

(, , )
(, , )
(, , )
(, , ); (, , )
(, , )

 aimHeld = 
 overMenu = 
 lastAimPoint = .(, )
 lastTp, lastTpTry = , 
 spinAngle, spinOn = , 
 flyOn, bhopHV, bhopSet = , .zero, 
 flyAcc, flyRampT = , 
 flyRp = RaycastParams.()
flyRp.FilterType = .RaycastFilterType.Exclude
flyRp.RespectCanCollide = 
 currentTarget = 

 pulledChars = ({}, { __mode =  })
  (char)  t = char  pulledChars[char];  t ~=   t > .() 
 npcList, lastNpcScan = {}, 
 motionTargets = {}
 orig = {}
 noclipSaved = {}
 listening = 
 gateOpen = 
 splashActive = 
 charBorn = .()

 selfMoveUntil = 
  (t) selfMoveUntil = .() + (t  ) 

 Safe = { cf =  }

N.ARROWS = { , , , , , , ,  }
  (cam, pos)
	 rel = cam.CFrame:(pos)
	 a = .(rel.X, -rel.Z)
	 idx = .((a + .pi / ) / (.pi / )) %  + 
	 N.ARROWS[idx]


  ()  .CurrentCamera 
  (char)  char  char:() 
  (char)  char  char:() 

  (char)
	 hum = (char)
	 hum ~=   hum.Health > 


  (plr)
	 plr ~=   player.Team ~=   plr.Team == player.Team


  (char)
	 idx = S.AimPart
	 part
	 idx ==  
		part = char:()
	 idx ==  
		part = char:()  char:()
	
	 part  char:()


  ()
	 list = {}
	 _, inst  :() 
		 inst:() 
			 char = inst.Parent
			 char  char ~= player.Character   Players:(char) 
				list[#list + ] = char
			
		
	
	npcList = list


  (ignoreTeam)
	 out = {}
	 _, plr  Players:() 
		 plr ~= player  plr.Character   (ignoreTeam  (plr)) 
			out[#out + ] = { char = plr.Character, plr = plr }
		
	
	 S.IncludeNPCs 
		 _, char  npcList 
			 char.Parent  out[#out + ] = { char = char } 
		
	
	 out


N.C_BG = .(, , )
N.C_PANEL = .(, , )
N.C_ROW = .(, , )
N.C_ROW_HI = .(, , )
N.C_LINE = .(, , )
N.C_TEXT = .(, , )
N.C_DIM = .(, , )
 ACCENT = N.ACCENTS[S.Accent][]

  (name, fallback)
	 ok, f = (()  .Font[name] )
	 ok  f  fallback

N.FONT = (, .Font.SourceSans)
 FONT_B = (, .Font.SourceSansBold)
N.FONT_BRAND = (, FONT_B)
N.FONT_MONO = .Font.RobotoMono

N.TI_FAST = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)
  (obj, props, info)
	 ok = (() TweenService:(obj, info  N.TI_FAST, props):() )
	  ok   k, v  props  (() obj[k] = v )  


N.ROW_H = isTouch    
N.FOOT_H = 
N.HEAD_H = isTouch    
N.SIDE_W = isTouch    
N.DOCK_W = isTouch    
N.DOCK_H = isTouch    
N.TAB_PAD = isTouch    
N.TAB_PAD_ON = isTouch    
N.TAB_PAD_HOV = isTouch    
N.TOP_BAR = isTouch    
N.WIN_TOP = N.TOP_BAR + (isTouch    )
N.TXT = isTouch    

 UI = {}
N.accentRefs = {}
 widgets = {}
N.toggleLabels = {}
N.dockButtons = {}
 userMoved = 
 suspInfoLabel
 refreshSuspInfo
 dtInfoLabel, refreshDtInfo
 applyEspPreset, pullToggle, pullStop
 orbitStop, orbitStart, cfgInfoLabel
 applyVisuals, applyAccent, applyLang, startCoinLoop, disableAll, notify, droneReport

  (key, fn)
	widgets[key] = widgets[key]  {}
	.(widgets[key], fn)
	()


  (obj, prop)
	.(N.accentRefs, { obj, prop })
	obj[prop] = ACCENT


  (parent, radius)
	 c = .()
	radius = radius  
	 radius <   radius = .(radius, ) 
	c.CornerRadius = .(, radius)
	c.Parent = parent
	 c


  (parent, color, thickness, transparency)
	 s = .()
	s.ApplyStrokeMode = .ApplyStrokeMode.Border
	s.Color = color
	s.Thickness = thickness  
	s.Transparency = transparency  
	s.Parent = parent
	 s


  (parent, size, pos, text, textSize, color, font, align, noBind)
	 l = .()
	l.Size = size
	l.Position = pos
	l.BackgroundTransparency = 
	l.Text = text
	l.TextColor3 = color  N.C_TEXT
	l.Font = font  N.FONT
	l.TextSize = textSize  N.TXT
	l.TextXAlignment = align  .TextXAlignment.Left
	l.TextTruncate = .TextTruncate.AtEnd
	l.Parent = parent
	 text ~=    noBind  (l, text) 
	 l


  (key, value, silent)
	S[key] = value
	 _, r  widgets[key]  {}  () 
	 key ==   () 
	 key ==   () 
	 applyVisuals  () 
	 key ==   startCoinLoop  () 
	  silent  (value) ==   N.toggleLabels[key]  notify 
		(N.toggleLabels[key], value)
	




	 overlay = .()
	overlay.Name = 
	overlay.ResetOnSpawn = 
	overlay.ScreenInsets = .ScreenInsets.None
	overlay.DisplayOrder = 
	overlay.Parent = playerGui
	UI.overlay = overlay

	 circle = .()
	circle.AnchorPoint = .(, )
	circle.BackgroundTransparency = 
	circle.Visible = 
	circle.Parent = overlay
	(circle, )
	UI.circle = circle
	UI.circleStroke = (circle, .(, , ), , )

	 crossH = .()
	crossH.AnchorPoint = .(, )
	crossH.Position = .(, )
	crossH.BorderSizePixel = 
	crossH.Visible = 
	crossH.Parent = overlay
	 crossV = crossH:()
	crossV.Parent = overlay
	UI.crossH, UI.crossV = crossH, crossV

	 gui = .()
	gui.Name = 
	gui.ResetOnSpawn = 
	gui.ScreenInsets = .ScreenInsets.DeviceSafeInsets
	gui.DisplayOrder = 
	gui.Parent = playerGui
	UI.gui = gui

	 dock = .()
	dock.Name = 
	dock.AnchorPoint = .(, )
	dock.Position = .(, , , )
	dock.Size = .(N.DOCK_W, N.DOCK_H)
	dock.BackgroundTransparency = 
	dock.Parent = gui
	 isTouch 
		dock.AnchorPoint = .(, )
		dock.Position = .(, , , N.TOP_BAR)
		 dg = .()
		dg.CellSize = .(, )
		dg.CellPadding = .(, )
		dg.FillDirection = .FillDirection.Horizontal
		dg.FillDirectionMaxCells = 
		dg.SortOrder = .SortOrder.LayoutOrder
		dg.Parent = dock
	
		 dl = .()
		dl.Padding = .(, )
		dl.SortOrder = .SortOrder.LayoutOrder
		dl.VerticalAlignment = .VerticalAlignment.Center
		dl.Parent = dock
	
	UI.dock = dock

	UI.dockScale = .()
	UI.dockScale.Parent = dock

	 menuBtn = .()
	menuBtn.Size = .(isTouch  N.DOCK_W  , isTouch    )
	menuBtn.BackgroundColor3 = N.C_BG
	menuBtn.BackgroundTransparency = 
	menuBtn.AutoButtonColor = 
	menuBtn.TextColor3 = N.C_TEXT
	menuBtn.Font = FONT_B
	menuBtn.TextSize = isTouch    
	(menuBtn, )
	(menuBtn, )
	 mbs = (menuBtn, N.C_LINE, )
	menuBtn.MouseEnter:(()
		(menuBtn, { BackgroundTransparency =  })
		(mbs, { Color = ACCENT })
	)
	menuBtn.MouseLeave:(()
		(menuBtn, { BackgroundTransparency =  })
		(mbs, { Color = N.C_LINE })
	)
	 isTouch 
		menuBtn.LayoutOrder = 
		menuBtn.Parent = dock
	
		menuBtn.Position = .(, , , N.TOP_BAR)
		menuBtn.Parent = gui
	
	UI.menuBtn = menuBtn

	 toasts = .()
	toasts.AnchorPoint = .(, )
	toasts.Position = .(, , , )
	toasts.Size = .(, )
	toasts.AutomaticSize = .AutomaticSize.Y
	toasts.BackgroundTransparency = 
	toasts.Parent = gui
	 tl = .()
	tl.Padding = .(, )
	tl.HorizontalAlignment = .HorizontalAlignment.Center
	tl.SortOrder = .SortOrder.LayoutOrder
	tl.Parent = toasts
	UI.toasts = toasts

	 window = .()
	window.Name = 
	window.GroupTransparency = 
	window.Position = .(, N.WIN_TOP)
	window.Size = .(, )
	window.BackgroundColor3 = N.C_BG
	window.BorderSizePixel = 
	window.ClipsDescendants = 
	window.Visible = 
	window.Parent = gui
	(window, )
	UI.window = window

	(window, N.C_LINE, , )

	UI.scale = .()
	UI.scale.Parent = window

	 header = .()
	header.Size = .(, , , N.HEAD_H)
	header.BackgroundTransparency = 
	header.Parent = window
	UI.header = header
	 mark = .()
	mark.AnchorPoint = .(, )
	mark.Size = .(, )
	mark.Position = .(, , , )
	mark.BorderSizePixel = 
	mark.Rotation = 
	mark.Parent = header
	(mark, )
	(mark, )
	(header, .(, , , ), .(, ), N.PROJECT_NAME, , N.C_TEXT, N.FONT_BRAND, , )
	(header, .(, , , ), .(, ), , , N.C_DIM, N.FONT, , )

	 closeBtn = .()
	closeBtn.AnchorPoint = .(, )
	closeBtn.Position = .(, -, , )
	closeBtn.Size = .(, )
	closeBtn.BackgroundColor3 = N.C_ROW_HI
	closeBtn.BackgroundTransparency = 
	closeBtn.BorderSizePixel = 
	closeBtn.AutoButtonColor = 
	closeBtn.Text = 
	closeBtn.TextColor3 = N.C_DIM
	closeBtn.Font = FONT_B
	closeBtn.TextSize = 
	closeBtn.Parent = header
	(closeBtn, )
	 cbs = (closeBtn, N.C_LINE, , )
	closeBtn.MouseEnter:(()
		(closeBtn, { BackgroundTransparency = , TextColor3 = N.C_TEXT })
		(cbs, { Color = ACCENT, Transparency =  })
	)
	closeBtn.MouseLeave:(()
		(closeBtn, { BackgroundTransparency = , TextColor3 = N.C_DIM })
		(cbs, { Transparency =  })
	)
	UI.closeBtn = closeBtn

	 hLine = .()
	hLine.Position = .(, N.HEAD_H)
	hLine.Size = .(, , , )
	hLine.BackgroundColor3 = N.C_LINE
	hLine.BorderSizePixel = 
	hLine.Parent = window

	 sBg = .()
	sBg.Position = .(, N.HEAD_H + )
	sBg.Size = .(, N.SIDE_W, , -(N.HEAD_H +  + N.FOOT_H))
	sBg.BackgroundColor3 = N.C_PANEL
	sBg.BorderSizePixel = 
	sBg.Parent = window

	 sidebar = .()
	sidebar.Position = .(, N.HEAD_H + )
	sidebar.Size = .(, N.SIDE_W, , -(N.HEAD_H +  + N.FOOT_H))
	sidebar.BackgroundTransparency = 
	sidebar.BorderSizePixel = 
	sidebar.ScrollBarThickness = 
	sidebar.CanvasSize = .()
	sidebar.AutomaticCanvasSize = .AutomaticSize.Y
	sidebar.ScrollingDirection = .ScrollingDirection.Y
	sidebar.Parent = window
	 sl = .()
	sl.Padding = .(, )
	sl.SortOrder = .SortOrder.LayoutOrder
	sl.Parent = sidebar
	 sp = .()
	sp.PaddingTop, sp.PaddingBottom = .(, ), .(, )
	sp.PaddingLeft, sp.PaddingRight = .(, ), .(, )
	sp.Parent = sidebar
	UI.sidebar = sidebar

	 sLine = .()
	sLine.Position = .(N.SIDE_W, N.HEAD_H + )
	sLine.Size = .(, , , -(N.HEAD_H +  + N.FOOT_H))
	sLine.BackgroundColor3 = N.C_LINE
	sLine.BackgroundTransparency = 
	sLine.BorderSizePixel = 
	sLine.Parent = window

	 content = .()
	content.Position = .(N.SIDE_W + , N.HEAD_H + )
	content.Size = .(, -(N.SIDE_W + ), , -(N.HEAD_H +  + N.FOOT_H))
	content.BackgroundTransparency = 
	content.ClipsDescendants = 
	content.Parent = window
	UI.content = content

	 sweep = .()
	sweep.Position = .(N.SIDE_W + , N.HEAD_H + )
	sweep.Size = .(, , , )
	sweep.BorderSizePixel = 
	sweep.ZIndex = 
	sweep.Parent = window
	(sweep, )
	UI.sweep = sweep

	 fLine = .()
	fLine.AnchorPoint = .(, )
	fLine.Position = .(, , , -N.FOOT_H)
	fLine.Size = .(, , , )
	fLine.BackgroundColor3 = N.C_LINE
	fLine.BorderSizePixel = 
	fLine.Parent = window

	 footer = .()
	footer.AnchorPoint = .(, )
	footer.Position = .(, )
	footer.Size = .(, , , N.FOOT_H)
	footer.BackgroundTransparency = 
	footer.BorderSizePixel = 
	footer.Parent = window
	UI.footerL = (footer, .(, -, , ), .(, ), , , N.C_DIM, N.FONT, , )
	UI.footerR = (footer, .(, -, , ), .(, , , ), , , N.C_DIM, N.FONT, .TextXAlignment.Right, )

	 _, obj  { window, menuBtn, dock } 
		obj.MouseEnter:(() overMenu =  )
		obj.MouseLeave:(() overMenu =  )
	


  (text, color, force, life)
	  S.Toasts   force   
	 dur = life  
	 t = .()
	t.AutomaticSize = .AutomaticSize.X
	t.Size = .(, )
	t.BackgroundColor3 = N.C_BG
	t.BackgroundTransparency = 
	t.BorderSizePixel = 
	t.Text =  .. text .. 
	t.TextColor3 = N.C_TEXT
	t.TextTransparency = 
	t.Font = FONT_B
	t.TextSize = 
	t.Parent = UI.toasts
	(t, )
	 ts = (t, N.C_LINE, , )
	 mark = .()
	mark.AnchorPoint = .(, )
	mark.Size = .(, )
	mark.Position = .(, , , )
	mark.BackgroundColor3 = color  ACCENT
	mark.BorderSizePixel = 
	mark.BackgroundTransparency = 
	mark.Parent = t
	(mark, )
	 bar = .()
	bar.AnchorPoint = .(, )
	bar.Position = .(, , , -)
	bar.Size = .(, -, , )
	bar.BackgroundColor3 = color  ACCENT
	bar.BorderSizePixel = 
	bar.BackgroundTransparency = 
	bar.Parent = t
	(bar, )
	 info = TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out)
	(t, { BackgroundTransparency = , TextTransparency =  }, info)
	(ts, { Transparency =  }, info)
	(mark, { BackgroundTransparency =  }, info)
	bar.BackgroundTransparency = 
	(bar, { Size = .(, , , ) }, TweenInfo.(dur, .EasingStyle.Linear))
	.(dur, ()
		 out = TweenInfo.()
		(t, { BackgroundTransparency = , TextTransparency =  }, out)
		(ts, { Transparency =  }, out)
		(mark, { BackgroundTransparency =  }, out)
		(bar, { BackgroundTransparency =  }, out)
		.(, () t:() )
	)


  (name, fn)
	 ok, err = (fn)
	  ok 
		( .. name ..  .. (err))
		 msg = (err)
		 #msg >   msg = .(msg, , ) ..  
		(toast,  .. name ..  .. msg, .(, , ), , )
	


notify = (text, on)
	(.(, (text), on  ()  ()), on  ACCENT  N.C_DIM)


 lastNote = {}
  (key, enabled, src, color, every, ...)
	  enabled   
	 now = .()
	 now - (lastNote[key]  ) < (every  )   
	lastNote[key] = now
	 text = (, ...) >   .((src), ...)  (src)
	(text, color  ACCENT, )


 menuOpenState = 
 menuTween, menuRest = , 
  (open)
	 open ==   open =  menuOpenState 
	 win = UI.window
	 open == menuOpenState  win.Visible == open 
		 applyVisuals  () 
		
	
	menuOpenState = open
	 menuTween  menuTween:() menuTween =  

	  menuRest   win.Visible  menuRest = win.Position 
	 rest = menuRest
	 w = win.Size.X.Offset * UI.scale.Scale + 
	 away = .(rest.X.Scale, rest.X.Offset - w, rest.Y.Scale, rest.Y.Offset)

	 open 
		  win.Visible 
			win.Position = away
			win.GroupTransparency = 
			  isTouch  UI.content.GroupTransparency =  
		
		win.Visible = 
		(win, { GroupTransparency = S.MenuAlpha }, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out))
		  isTouch  (UI.content, { GroupTransparency =  }, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)) 
		menuTween = TweenService:(win, TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out), { Position = rest })
		menuTween.Completed:((state)
			 state == .PlaybackState.Completed 
				win.Position = rest
				menuRest = 
			
		)
		menuTween:()
	
		overMenu = 
		(win, { GroupTransparency =  }, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.In))
		 tw = TweenService:(win, TweenInfo.(, .EasingStyle.Quart, .EasingDirection.In), { Position = away })
		menuTween = tw
		tw.Completed:((state)
			 state == .PlaybackState.Completed   menuOpenState 
				win.Visible = 
				win.Position = rest
				menuRest = 
				 applyVisuals  () 
			
		)
		tw:()
	
	 applyVisuals  () 


UI.menuBtn.Activated:(() () )
UI.closeBtn.Activated:(() () )

  ()
	 a = UI.gui.AbsoluteSize
	 a.X <   a.Y <  
		 cam = ()
		 cam  cam.ViewportSize  .(, )
	
	 a


  ()
	 avail = ()
	 auto = 
	 S.AutoScale 
		 isTouch 
			auto = .(.(avail.X / , avail.Y / ), , )
		
			auto = .(.(avail.X / , avail.Y / ), , )
		
	
	 S.UiScale * auto


N.leftOff = ()
	  isTouch    
	 ().X <     
	 N.DOCK_W + 


  ()
	 avail = ()
	 sc = UI.scale.Scale
	 vw = UI.window.Size.X.Offset * sc
	 vh = UI.window.Size.Y.Offset * sc

	 x, y
	 userMoved 
		x, y = UI.window.Position.X.Offset, UI.window.Position.Y.Offset
	
		x = N.()
		y = N.WIN_TOP
	
	x = .(x, , .(avail.X - vw, ))
	y = .(y, , .(avail.Y - vh, ))
	UI.window.Position = .(x, y)


 dragging
UI.header.InputBegan:((input)
	 input.UserInputType == .UserInputType.Touch
		 input.UserInputType == .UserInputType.MouseButton1 
		dragging = {
			input = input,
			start = .(input.Position.X, input.Position.Y),
			pos = UI.window.Position,
		}
	
)

 pages = {}
 currentPage


  (page)
	 changed = currentPage ~= page
	currentPage = page
	 _, p  pages 
		 active = (p == page)
		  active  p.frame.Visible =  
		p.btn.BackgroundColor3 = N.C_ROW_HI
		 info = TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out)
		(p.btn, { BackgroundTransparency = active    , TextColor3 = active  N.C_TEXT  N.C_DIM }, info)
		(p.icon, { BackgroundColor3 = active  ACCENT  N.C_LINE, Size = active  .(, )  .(, ) }, info)
		(p.pad, { PaddingLeft = .(, active  N.TAB_PAD_ON  N.TAB_PAD) }, info)
	
	page.frame.Visible = 
	 changed  UI.window.Visible 
		page.frame.Position = .(, )
		  isTouch  UI.content.GroupTransparency =  
		(page.frame, { Position = .(, ) }, TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out))
		  isTouch  (UI.content, { GroupTransparency =  }, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)) 
		UI.sweep.Size = .(, , , )
		UI.sweep.BackgroundTransparency = 
		(UI.sweep, { Size = .(, -(N.SIDE_W + ), , ) }, TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out))
		.(, () (UI.sweep, { BackgroundTransparency =  }, TweenInfo.()) )
		(()
			 strip, btn = UI.sidebar, page.btn
			 y = btn.AbsolutePosition.Y - strip.AbsolutePosition.Y + strip.CanvasPosition.Y
			 target = .(y - strip.AbsoluteSize.Y /  + btn.AbsoluteSize.Y / , )
			(strip, { CanvasPosition = .(, target) }, TweenInfo.(, .EasingStyle.Quad))
		)
	
		page.frame.Position = .()
	


  (name)
	 frame = .()
	frame.Size = .(, )
	frame.BackgroundTransparency = 
	frame.BorderSizePixel = 
	frame.ScrollBarThickness = 
	frame.ScrollBarImageColor3 = N.C_LINE
	frame.CanvasSize = .()
	frame.AutomaticCanvasSize = .AutomaticSize.Y
	frame.ScrollingDirection = .ScrollingDirection.Y
	frame.Visible = 
	frame.Parent = UI.content

	 pad = .()
	pad.PaddingTop, pad.PaddingBottom = .(, ), .(, )
	pad.PaddingLeft, pad.PaddingRight = .(, ), .(, )
	pad.Parent = frame

	 list = .()
	list.Padding = .(, )
	list.SortOrder = .SortOrder.LayoutOrder
	list.Parent = frame

	 btn = .()
	btn.LayoutOrder = #pages + 
	btn.Size = .(, , , isTouch    )
	btn.BackgroundTransparency = 
	btn.BackgroundColor3 = N.C_ROW_HI
	btn.AutoButtonColor = 
	btn.TextColor3 = N.C_DIM
	btn.Font = FONT_B
	btn.TextSize = 
	btn.TextXAlignment = .TextXAlignment.Left
	btn.BorderSizePixel = 
	btn.Parent = UI.sidebar
	(btn, name)
	(btn, )
	 bp = .()
	bp.PaddingLeft = .(, N.TAB_PAD)
	bp.Parent = btn

	 icon = .()
	icon.AnchorPoint = .(, )
	icon.Size = .(, )
	icon.Position = .(, -, , )
	icon.BackgroundColor3 = N.C_LINE
	icon.BorderSizePixel = 
	icon.Visible =  isTouch
	icon.Parent = btn
	(icon, )

	 page = { frame = frame, btn = btn, icon = icon, pad = bp, n =  }
	.(pages, page)
	btn.MouseEnter:(()
		 currentPage ~= page 
			(btn, { BackgroundTransparency = , TextColor3 = N.C_TEXT })
			(bp, { PaddingLeft = .(, N.TAB_PAD_HOV) }, TweenInfo.(, .EasingStyle.Quint))
		
	)
	btn.MouseLeave:(()
		 currentPage ~= page 
			(btn, { BackgroundTransparency = , TextColor3 = N.C_DIM })
			(bp, { PaddingLeft = .(, N.TAB_PAD) }, TweenInfo.(, .EasingStyle.Quint))
		
	)
	btn.Activated:(() (page) )
	 page


  (page, height, clickable, filled)
	 row = .(clickable    )
	page.n += 
	row.LayoutOrder = page.n
	row.Size = .(, , , height)
	row.BackgroundColor3 = filled  N.C_PANEL  N.C_ROW_HI
	row.BackgroundTransparency = filled    
	row.BorderSizePixel = 
	 clickable 
		row.Text = 
		row.AutoButtonColor = 
		 restColor = filled  N.C_PANEL  N.C_ROW_HI
		 restAlpha = filled    
		 touchOnly = isTouch   N.hasMouse
		  touchOnly 
			row.MouseEnter:(()
				(row, { BackgroundColor3 = N.C_ROW_HI, BackgroundTransparency =  }, TweenInfo.(, .EasingStyle.Quad))
			)
			row.MouseLeave:(function()
				tween(row, { BackgroundColor3 = restColor, BackgroundTransparency = restAlpha }, TweenInfo.new(0.2, Enum.EasingStyle.Quad))
			end)
		end
		row.MouseButton1Down:Connect(function()
			tween(row, { BackgroundColor3 = N.C_LINE, BackgroundTransparency = 0 }, TweenInfo.new(0.05))
		end)
		row.MouseButton1Up:Connect(function()
			if touchOnly then
				tween(row, { BackgroundColor3 = restColor, BackgroundTransparency = restAlpha }, TweenInfo.new(0.22, Enum.EasingStyle.Quad))
			else
				tween(row, { BackgroundColor3 = N.C_ROW_HI }, TweenInfo.new(0.12))
			end
		end)
	end
	row.Parent = page.frame
	corner(row, 9)
	if filled then addStroke(row, N.C_LINE, 1, 0.35) end
	return row
end

local function addSection(page, text)
	page.n += 1
	local holder = Instance.new("Frame")
	holder.LayoutOrder = page.n
	holder.Size = UDim2.new(1, 0, 0, 34)
	holder.BackgroundTransparency = 1
	holder.Parent = page.frame
	local ln = Instance.new("Frame")
	ln.AnchorPoint = Vector2.new(0, 0.5)
	ln.Position = UDim2.new(0, 0, 0, 21)
	ln.Size = UDim2.new(1, 0, 0, 1)
	ln.BackgroundColor3 = N.C_LINE
	ln.BackgroundTransparency = 0.25
	ln.BorderSizePixel = 0
	ln.Parent = holder
	local lbl = makeText(holder, UDim2.fromOffset(0, 18), UDim2.fromOffset(0, 12), text, 12, ACCENT, FONT_B)
	lbl.AutomaticSize = Enum.AutomaticSize.X
	lbl.BackgroundColor3 = N.C_BG
	lbl.BackgroundTransparency = 0
	lbl.ZIndex = 2
	local lp = Instance.new("UIPadding")
	lp.PaddingLeft, lp.PaddingRight = UDim.new(0, 4), UDim.new(0, 10)
	lp.Parent = lbl
	acc(lbl, "TextColor3")
end

local function addToggle(page, key, text)
	N.toggleLabels[key] = text
	local row = makeRow(page, N.ROW_H, true)
	makeText(row, UDim2.new(1, -76, 1, 0), UDim2.fromOffset(14, 0), text, N.TXT)

	local track = Instance.new("Frame")
	track.AnchorPoint = Vector2.new(1, 0.5)
	track.Size = UDim2.fromOffset(40, 22)
	track.Position = UDim2.new(1, -14, 0.5, 0)
	track.BackgroundColor3 = N.C_LINE
	track.BorderSizePixel = 0
	track.Parent = row
	corner(track, 1000)

	local knob = Instance.new("Frame")
	knob.AnchorPoint = Vector2.new(0, 0.5)
	knob.Size = UDim2.fromOffset(16, 16)
	knob.Position = UDim2.new(0, 3, 0.5, 0)
	knob.BackgroundColor3 = N.C_DIM
	knob.BorderSizePixel = 0
	knob.Parent = track
	corner(knob, 1000)

	local first = true
	local on = false
	register(key, function()
		on = S[key]
		local tGoal = { BackgroundColor3 = on and ACCENT or N.C_LINE }
		local kGoal = {
			Position = on and UDim2.new(1, -19, 0.5, 0) or UDim2.new(0, 3, 0.5, 0),
			BackgroundColor3 = on and N.C_BG or N.C_DIM,
		}
		if first then
			first = false
			for p, v in tGoal do track[p] = v end
			for p, v in kGoal do knob[p] = v end
		else
			local info = TweenInfo.new(0.26, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
			tween(track, tGoal, info)
			tween(knob, kGoal, info)
			tween(knob, { Size = UDim2.fromOffset(16, 16) }, TweenInfo.new(0.22, Enum.EasingStyle.Back, Enum.EasingDirection.Out))
		end
	end)
	row.MouseButton1Down:Connect(function()
		tween(knob, { Size = UDim2.fromOffset(20, 16) }, TweenInfo.new(0.07))
	end)

	row.Activated:Connect(function() setValue(key, not S[key]) end)
end

local activeSlider

local function addSlider(page, key, text, minV, maxV, step, fmt)
	local row = makeRow(page, isTouch and 66 or 54, false)
	makeText(row, UDim2.new(1, -100, 0, 20), UDim2.fromOffset(14, 6), text, N.TXT)
	local valueLabel = makeText(row, UDim2.fromOffset(84, 20), UDim2.new(1, -98, 0, 6), "", 12, ACCENT, FONT_B, Enum.TextXAlignment.Right, true)

	local hit = Instance.new("TextButton")
	hit.AnchorPoint = Vector2.new(0.5, 1)
	hit.Size = UDim2.new(1, -28, 0, isTouch and 38 or 22)
	hit.Position = UDim2.new(0.5, 0, 1, -4)
	hit.BackgroundTransparency = 1
	hit.Text = ""
	hit.AutoButtonColor = false
	hit.Parent = row

	local track = Instance.new("Frame")
	track.AnchorPoint = Vector2.new(0, 0.5)
	track.Size = UDim2.new(1, 0, 0, 4)
	track.Position = UDim2.new(0, 0, 0.5, 0)
	track.BackgroundColor3 = N.C_LINE
	track.BorderSizePixel = 0
	track.Parent = hit
	corner(track, 1000)

	local fill = Instance.new("Frame")
	fill.Size = UDim2.new(0, 0, 1, 0)
	fill.BorderSizePixel = 0
	fill.Parent = track
	corner(fill, 1000)

	local hw, hh = isTouch and 20 or 16, isTouch and 20 or 16
	local knob = Instance.new("Frame")
	knob.AnchorPoint = Vector2.new(0.5, 0.5)
	knob.Size = UDim2.fromOffset(hw, hh)
	knob.BackgroundColor3 = N.C_TEXT
	knob.BorderSizePixel = 0
	knob.Parent = track
	corner(knob, 1000)

	local first = true
	local qin = TweenInfo.new(0.18, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
	register(key, function()
		local rel = math.clamp((S[key] - minV) / (maxV - minV), 0, 1)
		fill.BackgroundColor3 = ACCENT
		valueLabel.Text = string.format(tr(fmt), S[key])
		valueLabel.TextColor3 = ACCENT
		if first or (activeSlider and activeSlider.id == knob) then
			first = false
			fill.Size = UDim2.new(rel, 0, 1, 0)
			knob.Position = UDim2.new(rel, 0, 0.5, 0)
		else
			tween(fill, { Size = UDim2.new(rel, 0, 1, 0) }, qin)
			tween(knob, { Position = UDim2.new(rel, 0, 0.5, 0) }, qin)
		end
	end)

	local function setFromX(x)
		local rel = math.clamp((x - track.AbsolutePosition.X) / math.max(track.AbsoluteSize.X, 1), 0, 1)
		local value = math.floor((minV + rel * (maxV - minV)) / step + 0.5) * step
		setValue(key, math.clamp(value, minV, maxV))
	end

	hit.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.Touch
			or input.UserInputType == Enum.UserInputType.MouseButton1 then
			tween(knob, { Size = UDim2.fromOffset(hw + 6, hh + 6), BackgroundColor3 = ACCENT }, TweenInfo.new(0.1, Enum.EasingStyle.Quint))
			tween(track, { Size = UDim2.new(1, 0, 0, 6) }, TweenInfo.new(0.1))
			input.Changed:Connect(function()
				if input.UserInputState == Enum.UserInputState.End then
					tween(knob, { Size = UDim2.fromOffset(hw, hh), BackgroundColor3 = N.C_TEXT }, TweenInfo.new(0.16, Enum.EasingStyle.Quint))
					tween(track, { Size = UDim2.new(1, 0, 0, 4) }, TweenInfo.new(0.16))
				end
			end)
			activeSlider = { input = input, update = setFromX, page = page, id = knob }
			page.frame.ScrollingEnabled = false
			setFromX(input.Position.X)
		end
	end)
end

local function addCycle(page, key, text, names)
	local row = makeRow(page, N.ROW_H, true)
	makeText(row, UDim2.new(0.5, -14, 1, 0), UDim2.fromOffset(14, 0), text, N.TXT)
	local value = Instance.new("TextLabel")
	value.AnchorPoint = Vector2.new(1, 0.5)
	value.AutomaticSize = Enum.AutomaticSize.X
	value.Size = UDim2.fromOffset(0, 26)
	value.Position = UDim2.new(1, -10, 0.5, 0)
	value.BackgroundColor3 = N.C_PANEL
	value.BorderSizePixel = 0
	value.Font = FONT_B
	value.TextSize = 12
	value.TextColor3 = ACCENT
	value.Text = ""
	value.Parent = row
	corner(value, 1000)
	addStroke(value, N.C_LINE, 1, 0.4)
	local vpad = Instance.new("UIPadding")
	vpad.PaddingLeft, vpad.PaddingRight = UDim.new(0, 12), UDim.new(0, 12)
	vpad.Parent = value
	local cycFirst = true
	register(key, function()
		value.Text = tr(names[S[key]])
		value.TextColor3 = ACCENT
		if cycFirst then
			cycFirst = false
		else
			value.TextTransparency = 0.8
			value.Position = UDim2.new(1, 2, 0.5, 0)
			local info = TweenInfo.new(0.22, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
			tween(value, { TextTransparency = 0, Position = UDim2.new(1, -10, 0.5, 0) }, info)
		end
	end)
	row.Activated:Connect(function()
		setValue(key, S[key] % #names + 1)
	end)
end

local function addButton(page, text, callback)
	local row = makeRow(page, N.ROW_H, true, true)
	row.TextColor3 = N.C_TEXT
	row.Font = FONT_B
	row.TextSize = N.TXT
	bind(row, text)
	row.Activated:Connect(function()
		row.TextColor3 = ACCENT
		tween(row, { TextColor3 = N.C_TEXT }, TweenInfo.new(0.35, Enum.EasingStyle.Quad))
		callback()
	end)
end

local function addTextBox(page, key, text)
	local row = makeRow(page, N.ROW_H, false)
	makeText(row, UDim2.new(0.5, -14, 1, 0), UDim2.fromOffset(14, 0), text, N.TXT)
	local tb = Instance.new("TextBox")
	tb.AnchorPoint = Vector2.new(1, 0.5)
	tb.Size = UDim2.new(0.5, -20, 0, 28)
	tb.Position = UDim2.new(1, -10, 0.5, 0)
	tb.BackgroundColor3 = N.C_PANEL
	tb.TextColor3 = N.C_TEXT
	tb.Font = N.FONT
	tb.TextSize = 12
	tb.ClearTextOnFocus = false
	tb.Parent = row
	corner(tb, 8)
	addStroke(tb, N.C_LINE, 1, 0.5)
	register(key, function() tb.Text = tostring(S[key]) end)
	tb.FocusLost:Connect(function() setValue(key, tb.Text) end)
end

local function addTextArea(page, key, text, height)
	local row = makeRow(page, height or 96, false)
	makeText(row, UDim2.new(1, -28, 0, 20), UDim2.fromOffset(14, 6), text, N.TXT)
	local tb = Instance.new("TextBox")
	tb.Position = UDim2.fromOffset(10, 30)
	tb.Size = UDim2.new(1, -20, 1, -40)
	tb.BackgroundColor3 = N.C_PANEL
	tb.TextColor3 = N.C_TEXT
	tb.Font = N.FONT_MONO
	tb.TextSize = 11
	tb.TextWrapped = true
	tb.MultiLine = true
	tb.TextXAlignment = Enum.TextXAlignment.Left
	tb.TextYAlignment = Enum.TextYAlignment.Top
	tb.ClearTextOnFocus = false
	tb.Parent = row
	corner(tb, 8)
	addStroke(tb, N.C_LINE, 1, 0.5)
	local tbPad = Instance.new("UIPadding")
	tbPad.PaddingLeft, tbPad.PaddingRight = UDim.new(0, 6), UDim.new(0, 6)
	tbPad.PaddingTop, tbPad.PaddingBottom = UDim.new(0, 4), UDim.new(0, 4)
	tbPad.Parent = tb
	register(key, function() tb.Text = tostring(S[key]) end)
	tb.FocusLost:Connect(function() setValue(key, tb.Text) end)
end

local function addInfo(page, height)
	local row = makeRow(page, height or 64, false)
	local l = Instance.new("TextLabel")
	l.Size = UDim2.new(1, -28, 1, -16)
	l.Position = UDim2.fromOffset(14, 8)
	l.BackgroundTransparency = 1
	l.TextColor3 = N.C_DIM
	l.Font = N.FONT_MONO
	l.TextSize = 11
	l.TextWrapped = true
	l.TextXAlignment = Enum.TextXAlignment.Left
	l.TextYAlignment = Enum.TextYAlignment.Top
	l.Text = ""
	l.Parent = row
	return l
end

local function addKeybind(page, key, text)
	if isTouch and not N.hasMouse then return end
	local row = makeRow(page, N.ROW_H, true)
	makeText(row, UDim2.new(1, -110, 1, 0), UDim2.fromOffset(14, 0), text, N.TXT)
	local keyLabel = Instance.new("TextLabel")
	keyLabel.AnchorPoint = Vector2.new(1, 0.5)
	keyLabel.Size = UDim2.fromOffset(84, 26)
	keyLabel.Position = UDim2.new(1, -10, 0.5, 0)
	keyLabel.BackgroundColor3 = N.C_PANEL
	keyLabel.TextColor3 = N.C_TEXT
	keyLabel.Font = FONT_B
	keyLabel.TextSize = 12
	keyLabel.Parent = row
	corner(keyLabel, 8)
	addStroke(keyLabel, N.C_LINE, 1, 0.5)
	register(key, function()
		keyLabel.Text = (listening == key) and tr("натисни...") or S[key]
	end)
	row.Activated:Connect(function()
		listening = key
		for _, r in widgets[key] do r() end
	end)
end

local function addDock(text, key, onTap, onlyWhen)
	local b = Instance.new("TextButton")
	b.LayoutOrder = #N.dockButtons + 1
	b.Size = UDim2.fromOffset(N.DOCK_W, 30)
	b.BackgroundColor3 = N.C_BG
	b.BackgroundTransparency = 0.08
	b.AutoButtonColor = false
	b.Text = text
	b.TextColor3 = N.C_TEXT
	b.Font = FONT_B
	b.TextSize = 12
	b.Visible = false
	b.BorderSizePixel = 0
	b.Parent = UI.dock
	corner(b, 9)
	local s = addStroke(b, N.C_LINE, 1, 0)
	b.MouseEnter:Connect(function() tween(b, { BackgroundTransparency = 0 }) end)
	b.MouseLeave:Connect(function() tween(b, { BackgroundTransparency = 0.08 }) end)
	b.MouseButton1Down:Connect(function() tween(b, { BackgroundColor3 = N.C_ROW_HI }, TweenInfo.new(0.06)) end)
	b.MouseButton1Up:Connect(function() tween(b, { BackgroundColor3 = N.C_BG }, TweenInfo.new(0.1)) end)
	b.Activated:Connect(onTap)
	table.insert(N.dockButtons, { btn = b, only = onlyWhen })
	if key then
		register(key, function()
			tween(s, { Color = S[key] and ACCENT or N.C_LINE })
			tween(b, { TextColor3 = S[key] and ACCENT or N.C_TEXT })
		end)
	elseif onlyWhen then
		s.Color = Color3.fromRGB(80, 220, 140)
		b.TextColor3 = Color3.fromRGB(80, 220, 140)
	end
end

local lightingSaved, savedGravity

local function countActive()
	local n = 0
	for _, key in N.FEATURES do
		if S[key] then n += 1 end
	end
	return n
end

local function countDef()
	local n = 0
	for _, key in N.DEF_KEYS do
		if S[key] then n += 1 end
	end
	return n
end

local function updateFooter()
	local txt = string.format("%s: %d · %s: %d", tr("АКТИВНО"), countActive(), tr("ЗАХИСТ"), countDef())
	if S.Debug then
		local name = currentTarget and (currentTarget.plr and currentTarget.plr.Name or currentTarget.char.Name) or "—"
		txt = txt .. " · " .. tr("ЦІЛЬ") .. ": " .. name
	end
	UI.footerL.Text = txt
	UI.footerR.Text = isTouch and "" or (string.upper(S.KeyMenu) .. " — " .. tr("МЕНЮ"))
end

applyAccent = function()
	ACCENT = N.ACCENTS[S.Accent][2]
	for _, ref in N.accentRefs do ref[1][ref[2]] = ACCENT end
	if currentPage then selectTab(currentPage) end
	for _, list in widgets do
		for _, r in list do r() end
	end
end

applyLang = function()
	for i = #N.langRefs, 1, -1 do
		local r = N.langRefs[i]
		if r[1].Parent then
			r[1][r[3]] = tr(r[2])
		else
			table.remove(N.langRefs, i)
		end
	end
	for _, list in widgets do
		for _, r in list do r() end
	end
	updateFooter()
	if refreshSuspInfo then refreshSuspInfo() end
end

applyVisuals = function()

	UI.circle.Size = UDim2.fromOffset(S.FovRadius * 2, S.FovRadius * 2)
	UI.circleStroke.Color = colorOf(S.FovColor)
	UI.circleStroke.Thickness = S.FovThick
	local fovNeeded = (S.Aim and S.UseFov) or (S.TpAuto and S.TpUseFov) or UI.window.Visible
	UI.circle.Visible = S.FovShow and fovNeeded and (S.UseFov or S.TpUseFov)

	UI.window.BackgroundTransparency = 0
	if UI.window.Visible and menuOpenState and not menuRest then UI.window.GroupTransparency = S.MenuAlpha end
	local sc = effectiveScale()
	UI.scale.Scale = sc
	local avail = availSize()
	local leftOff = N.leftOff()
	local narrow = isTouch and avail.X < 560
	local topOff = N.WIN_TOP
	local w = math.clamp((avail.X - leftOff - 8) / sc, isTouch and 250 or 300, isTouch and 440 or 600)
	local h = math.clamp((avail.Y - topOff - 8) / sc, 200, 500)
	UI.window.Size = UDim2.fromOffset(w, h)
	placeWindow()

	UI.dock.Visible = gateOpen and not (narrow and menuOpenState)
	if isTouch then
		UI.dockScale.Scale = math.clamp((avail.Y - N.TOP_BAR - 8) / N.DOCK_H, 0.7, 1)
	else
		UI.dockScale.Scale = math.clamp((avail.Y - 20) / N.DOCK_H, 0.55, 1)
	end
	for _, rec in N.dockButtons do
		if rec.only then
			rec.btn.Visible = gateOpen and rec.only() == true
		else
			rec.btn.Visible = S.Quick
		end
	end

	UI.crossH.Visible, UI.crossV.Visible = S.Crosshair, S.Crosshair
	UI.crossH.Size = UDim2.fromOffset(S.CrossSize * 2, 2)
	UI.crossV.Size = UDim2.fromOffset(2, S.CrossSize * 2)
	UI.crossH.BackgroundColor3 = colorOf(S.CrossColor)
	UI.crossV.BackgroundColor3 = colorOf(S.CrossColor)

	if S.FullBright then
		if not lightingSaved then
			lightingSaved = {
				Brightness = Lighting.Brightness, ClockTime = Lighting.ClockTime,
				FogEnd = Lighting.FogEnd, GlobalShadows = N.fpsShadows ~= nil and N.fpsShadows or Lighting.GlobalShadows,
				Ambient = Lighting.Ambient, OutdoorAmbient = Lighting.OutdoorAmbient,
			}
		end
		Lighting.Brightness = 2
		Lighting.ClockTime = 14
		Lighting.FogEnd = 1e6
		Lighting.GlobalShadows = false
		Lighting.Ambient = Color3.fromRGB(178, 178, 178)
		Lighting.OutdoorAmbient = Color3.fromRGB(178, 178, 178)
	elseif lightingSaved then
		for prop, val in lightingSaved do Lighting[prop] = val end
		lightingSaved = nil
	end

	if S.GravityOn then
		if not savedGravity then savedGravity = workspace.Gravity end
		workspace.Gravity = S.Gravity
	elseif savedGravity then
		workspace.Gravity = savedGravity
		savedGravity = nil
	end

	updateFooter()
end

local function getAimPoint()
	local cam = getCamera()
	if isTouch and not N.hasMouse then
		return cam.ViewportSize / 2
	end
	if not overMenu then
		lastAimPoint = UserInputService:GetMouseLocation()
	end
	return lastAimPoint
end

local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Exclude

local function getTarget(useFov, motion)
	local cam = getCamera()
	if not cam then return nil end

	local point = getAimPoint()
	local camPos = cam.CFrame.Position
	local myChar = player.Character
	rayParams.FilterDescendantsInstances = myChar and { myChar } or {}

	local best, bestScore = nil, math.huge
	for _, t in collect(S.IgnoreTeam) do
		local char = t.char
		local hum, part = getHum(char), getAimPart(char)
		if hum and part and hum.Health > 0 then
			local sp, onScreen = cam:WorldToViewportPoint(part.Position)
			local d2 = (Vector2.new(sp.X, sp.Y) - point).Magnitude
			local dist = (part.Position - camPos).Magnitude

			local pass = true
			if useFov then pass = onScreen and d2 <= S.FovRadius end
			if pass and S.WallCheck then
				local hit = workspace:Raycast(camPos, part.Position - camPos, rayParams)
				pass = hit == nil or hit.Instance:IsDescendantOf(char)
			end

			if pass then
				local score
				if S.Priority == 1 then
					score = onScreen and d2 or (1e6 + dist)
				elseif S.Priority == 2 then
					score = dist
				else
					score = hum.Health
				end
				if score < bestScore then
					best, bestScore = t, score
				end
			end
		end
	end
	if motion then
		for _, m in motionTargets do
			local part = m.part
			if part and part.Parent then
				local sp, onScreen = cam:WorldToViewportPoint(part.Position)
				local d2 = (Vector2.new(sp.X, sp.Y) - point).Magnitude
				local dist = (part.Position - camPos).Magnitude
				local pass = true
				if useFov then pass = onScreen and d2 <= S.FovRadius end
				if pass and S.WallCheck then
					local hit = workspace:Raycast(camPos, part.Position - camPos, rayParams)
					pass = hit == nil or hit.Instance == part or hit.Instance:IsDescendantOf(m.model)
				end
				if pass then
					local score
					if S.Priority == 1 then
						score = onScreen and d2 or (1e6 + dist)
					else
						score = dist
					end
					if score < bestScore then
						best, bestScore = { char = m.model, part = part, motion = true }, score
					end
				end
			end
		end
	end
	return best
end

local function teleportNear(tChar, mode)
	local myChar = player.Character
	local myRoot = getRoot(myChar)
	local tRoot = getRoot(tChar)
	if not (isAlive(myChar) and myRoot and tRoot) then return false end

	lastTp = os.clock()

	local offset
	if mode == 1 then
		offset = -tRoot.CFrame.LookVector * S.TpOffset
	elseif mode == 2 then
		offset = tRoot.CFrame.RightVector * S.TpOffset
	else
		offset = Vector3.new(0, S.TpOffset, 0)
	end

	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { myChar, tChar }
	local pos = tRoot.Position + offset
	local hit = workspace:Raycast(tRoot.Position, offset, params)
	if hit then pos = hit.Position + hit.Normal * 2 end

	local cf
	if mode == 1 then
		cf = CFrame.new(pos) * tRoot.CFrame.Rotation
	else
		local look = Vector3.new(tRoot.Position.X, pos.Y, tRoot.Position.Z)
		cf = (look - pos).Magnitude > 0.05 and CFrame.lookAt(pos, look) or CFrame.new(pos)
	end

	markSelf()
	myChar:PivotTo(cf)
	myRoot.AssemblyLinearVelocity = Vector3.zero
	return true
end

local function teleportToTarget()
	local t = getTarget(S.TpUseFov)
	if not t then return false end
	return teleportNear(t.char, S.TpMode)
end

local function randomTeleport(char)
	local root = getRoot(char)
	if not root then return end

	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { char }

	local minD = math.min(S.TpDmgMin, S.TpDmgMax)
	local maxD = math.max(S.TpDmgMin, S.TpDmgMax)

	for _ = 1, 8 do
		local angle = math.rad(math.random(0, 359))
		local dist = math.random(minD, maxD)
		local origin = root.Position + Vector3.new(math.cos(angle) * dist, 50, math.sin(angle) * dist)
		local hit = workspace:Raycast(origin, Vector3.new(0, -200, 0), params)
		if hit and hit.Normal.Y > 0.7 then
			markSelf()
			char:PivotTo(CFrame.new(hit.Position + Vector3.new(0, 4, 0)))
			root.AssemblyLinearVelocity = Vector3.zero
			return
		end
	end
end

local lastDmgTp = 0
local function hookCharacter(char)
	local hum = char:WaitForChild("Humanoid", 10)
	if not hum then return end
	local last = hum.Health
	hum.HealthChanged:Connect(function(new)
		if S.TpDmg and new < last and new > 0 and os.clock() - lastDmgTp >= S.TpDmgCd then
			lastDmgTp = os.clock()
			randomTeleport(char)
		end
		last = new
	end)
end

player.CharacterAdded:Connect(function(char)
	orig = {}
	charBorn = os.clock()
	hookCharacter(char)
end)
if player.Character then task.spawn(hookCharacter, player.Character) end

local espObjs = {}
local updateEsp

do
	local espFolder = Instance.new("Folder")
	espFolder.Name = "FunModeESP"
	espFolder.Parent = playerGui

	local function createEsp(char)
		local hl = Instance.new("Highlight")
		hl.Name = "FunModeHighlight"
		hl.Adornee = char
		hl.Parent = char

		local bb = Instance.new("BillboardGui")
		bb.Name = "FunModeTag"
		bb.AlwaysOnTop = true
		bb.Size = UDim2.fromOffset(200, 44)
		bb.StudsOffset = Vector3.new(0, 3.6, 0)
		bb.Adornee = getRoot(char)
		bb.Parent = espFolder

		local function line(y)
			local l = Instance.new("TextLabel")
			l.Size = UDim2.new(1, 0, 0, 16)
			l.Position = UDim2.fromOffset(0, y)
			l.BackgroundTransparency = 1
			l.TextColor3 = Color3.new(1, 1, 1)
			l.TextStrokeTransparency = 0.3
			l.Font = Enum.Font.GothamBold
			l.Parent = bb
			return l
		end

		local bar = Instance.new("Frame")
		bar.AnchorPoint = Vector2.new(0.5, 0)
		bar.Position = UDim2.new(0.5, 0, 0, 34)
		bar.Size = UDim2.fromOffset(90, 5)
		bar.BackgroundColor3 = Color3.fromRGB(20, 20, 20)
		bar.BorderSizePixel = 0
		bar.Parent = bb

		local fill = Instance.new("Frame")
		fill.Size = UDim2.fromScale(1, 1)
		fill.BorderSizePixel = 0
		fill.Parent = bar

		return { hl = hl, bb = bb, name = line(0), info = line(16), bar = bar, fill = fill }
	end

	local function destroyEsp(char)
		local e = espObjs[char]
		if e then
			e.hl:Destroy()
			e.bb:Destroy()
			espObjs[char] = nil
		end
	end

	updateEsp = function()
		local cam = getCamera()
		if not cam then return end
		if not S.Esp and next(espObjs) == nil then return end

		local camPos = cam.CFrame.Position
		local seen = {}

		if S.Esp then
			for _, t in collect(false) do
				local char, plr = t.char, t.plr
				local hum, root = getHum(char), getRoot(char)
				if hum and root and hum.Health > 0 then
					local dist = (root.Position - camPos).Magnitude
					local hide = (S.EspHideTeam and isTeammate(plr))
						or (S.EspMaxDist < 5000 and dist > S.EspMaxDist)

					if not hide then
						seen[char] = true
						local e = espObjs[char]
						if not e then
							e = createEsp(char)
							espObjs[char] = e
						end

						local frac = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
						local fillColor = colorOf(S.EspFill)
						local outColor = colorOf(S.EspOutline)
						if S.EspTeamColor and plr and plr.Team then
							fillColor = plr.TeamColor.Color
							outColor = plr.TeamColor.Color
						end
						if S.EspHealthColor then
							fillColor = Color3.fromRGB(255, 60, 60):Lerp(Color3.fromRGB(60, 255, 90), frac)
						end

						e.hl.Enabled = S.EspHighlight
						e.hl.FillColor = fillColor
						e.hl.OutlineColor = outColor
						e.hl.FillTransparency = S.EspFillTrans
						e.hl.OutlineTransparency = S.EspOutTrans
						e.hl.DepthMode = S.EspAlwaysOnTop
							and Enum.HighlightDepthMode.AlwaysOnTop
							or Enum.HighlightDepthMode.Occluded

						e.bb.Enabled = S.EspNames or S.EspHealth or S.EspDist
						e.bb.Adornee = root

						e.name.Visible = S.EspNames
						e.name.TextSize = S.EspTextSize
						e.name.Text = plr and plr.DisplayName or char.Name

						local parts = {}
						if S.EspHealth then
							parts[#parts + 1] = string.format("%d HP", math.floor(hum.Health + 0.5))
						end
						if S.EspDist then
							parts[#parts + 1] = string.format(tr("%d ст"), math.floor(dist + 0.5))
						end
						e.info.Visible = #parts > 0
						e.info.TextSize = S.EspTextSize - 1
						e.info.Text = table.concat(parts, "  |  ")

						e.bar.Visible = S.EspHealth
						e.fill.Size = UDim2.fromScale(frac, 1)
						e.fill.BackgroundColor3 = Color3.fromRGB(255, 60, 60):Lerp(Color3.fromRGB(60, 255, 90), frac)
					end
				end
			end
		end

		for char in espObjs do
			if not seen[char] then destroyEsp(char) end
		end
	end
end

do
	local coinThread = false

	startCoinLoop = function()
		if coinThread or not S.Coins then return end
		coinThread = true
		task.spawn(function()
			local cache, lastScan = {}, 0
			while S.Coins do
				local char = player.Character
				local root = getRoot(char)
				local pattern = string.lower(S.CoinName)

				if root and isAlive(char) and pattern ~= "" then

					if os.clock() - lastScan > 3 then
						lastScan = os.clock()
						cache = {}
						for _, d in workspace:GetDescendants() do
							if d:IsA("BasePart") and string.find(string.lower(d.Name), pattern, 1, true) then
								local model = d:FindFirstAncestorOfClass("Model")
								if not (model and Players:GetPlayerFromCharacter(model)) then
									cache[#cache + 1] = d
								end
							end
						end
					end

					local best, bestDist = nil, S.CoinRange
					for _, coin in cache do
						if coin.Parent then
							local d = (coin.Position - root.Position).Magnitude
							if d <= bestDist then best, bestDist = coin, d end
						end
					end

					if best then
						local origin = root.CFrame
						markSelf(0.6)
						char:PivotTo(CFrame.new(best.Position))
						RunService.Heartbeat:Wait()
						if S.CoinReturn and char.Parent then
							markSelf(0.6)
							char:PivotTo(origin)
						end
					end
				end
				task.wait(S.CoinInterval)
			end
			coinThread = false
		end)
	end
end

disableAll = function()
	for _, key in N.FEATURES do
		if S[key] then setValue(key, false, true) end
	end
end

local function setDefense(on)
	for _, key in N.DEF_KEYS do setValue(key, on, true) end
end

local function enableAllAnticheat()
	setDefense(true)
	for _, key in { "AfNoCollide", "AfClamp", "AfNoRagdoll", "AfVoid", "AfNotify", "SitNotify", "FallNotify",
		"AbGui", "FlickRevert", "CtFace", "SuspTags", "SuspNotify", "DtReveal", "DtNotify", "DtTags" } do
		setValue(key, true, true)
	end
	toast(tr("Весь античіт увімкнено"), ACCENT, true)
end

local function resetAll()
	for k, v in DEFAULTS do
		if k ~= "Lang" then setValue(k, v, true) end
	end
end

N.ESP_PRESETS = {
	{ EspBox = false, EspBar = false, EspTracer = false, EspHead = true, EspArrows = false, EspNames = false, EspHealth = false, EspDist = false },
	{ EspBox = true, EspBar = true, EspTracer = false, EspHead = false, EspArrows = true, EspNames = true, EspHealth = true, EspDist = true },
	{ EspBox = true, EspBar = true, EspTracer = true, EspHead = true, EspArrows = true, EspNames = true, EspHealth = true, EspDist = true },
}
function applyEspPreset(n)
	local pr = N.ESP_PRESETS[n]
	if not pr then return end
	for k, v in pr do setValue(k, v, true) end
	setValue("Esp", true, true)
	toast(tr("Пресет застосовано"), ACCENT, true)
end

local function exportConfig()
	local out = {}
	for k, v in DEFAULTS do
		if k ~= "CfgText" and S[k] ~= v and (type(v) == "boolean" or type(v) == "number" or type(v) == "string") then out[k] = S[k] end
	end
	local ok, txt = pcall(function() return N.HttpService:JSONEncode(out) end)
	setValue("CfgText", ok and txt or "", true)
	toast(tr(ok and "Налаштування експортовано в поле нижче" or "Помилка експорту"), ACCENT, true)
end

local function importConfig()
	local ok, data = pcall(function() return N.HttpService:JSONDecode(S.CfgText) end)
	if not (ok and type(data) == "table") then
		toast(tr("Невірний формат налаштувань"), Color3.fromRGB(215, 80, 85), true)
		return
	end
	local n = 0
	for k, v in data do
		if k ~= "CfgText" and DEFAULTS[k] ~= nil and type(v) == type(DEFAULTS[k]) then
			setValue(k, v, true)
			n += 1
		end
	end
	toast(string.format(tr("Імпортовано: %d"), n), ACCENT, true)
end

local cfgSlots = {}
N.CFG_SKIP = { CfgText = true, Lang = true, CfgSlot = true }

local function cfgSimple(v)
	local t = type(v)
	return t == "boolean" or t == "number" or t == "string"
end

local function snapshotConfig()
	local out, n = {}, 0
	for k, v in DEFAULTS do
		if not N.CFG_SKIP[k] and cfgSimple(v) and S[k] ~= v then
			out[k] = S[k]
			n += 1
		end
	end
	return out, n
end

local function refreshCfgInfo()
	if not cfgInfoLabel then return end
	local lines = {}
	for i = 1, 5 do
		local slot = cfgSlots[i]
		local mark = i == S.CfgSlot and "> " or "  "
		if slot then
			lines[i] = string.format("%s%d  %s  (%d)", mark, i, slot.at, slot.count)
		else
			lines[i] = string.format("%s%d  %s", mark, i, tr("порожньо"))
		end
	end
	cfgInfoLabel.Text = table.concat(lines, "\n")
end

local function cfgSave()
	local data, n = snapshotConfig()
	cfgSlots[S.CfgSlot] = { data = data, count = n, at = os.date("%H:%M:%S") }
	refreshCfgInfo()
	toast(string.format(tr("Збережено у слот %d"), S.CfgSlot), ACCENT, true)
end

local function cfgApply(data)
	for k, v in DEFAULTS do
		if not N.CFG_SKIP[k] and cfgSimple(v) then
			local nv = data[k]
			if nv == nil then nv = v end
			if type(nv) == type(v) and S[k] ~= nv then setValue(k, nv, true) end
		end
	end
end

local function cfgLoad()
	local slot = cfgSlots[S.CfgSlot]
	if not slot then
		toast(tr("Слот порожній"), Color3.fromRGB(215, 80, 85), true)
		return
	end
	cfgApply(slot.data)
	toast(string.format(tr("Завантажено зі слота %d"), S.CfgSlot), ACCENT, true)
end

local function cfgClear()
	cfgSlots[S.CfgSlot] = nil
	refreshCfgInfo()
end

local function cfgToText()
	local slot = cfgSlots[S.CfgSlot]
	if not slot then
		toast(tr("Слот порожній"), Color3.fromRGB(215, 80, 85), true)
		return
	end
	local ok, txt = pcall(function() return N.HttpService:JSONEncode(slot.data) end)
	setValue("CfgText", ok and txt or "", true)
	toast(tr("Слот скопійовано в поле"), ACCENT, true)
end

local function cfgFromText()
	local ok, data = pcall(function() return N.HttpService:JSONDecode(S.CfgText) end)
	if not (ok and type(data) == "table") then
		toast(tr("Невірний формат налаштувань"), Color3.fromRGB(215, 80, 85), true)
		return
	end
	local n = 0
	for _ in data do n += 1 end
	cfgSlots[S.CfgSlot] = { data = data, count = n, at = os.date("%H:%M:%S") }
	refreshCfgInfo()
	toast(string.format(tr("Збережено у слот %d"), S.CfgSlot), ACCENT, true)
end

do

	local p = addTab("Приціл")
	addSection(p, "АВТОПРИЦІЛ")
	addToggle(p, "Aim", "Автоприціл")
	addToggle(p, "AimHold", "Тільки при утриманні ПКМ (ПК)")
	addCycle(p, "AimPart", "Куди цілитись", N.AIM_PART_NAMES)
	addCycle(p, "Priority", "Пріоритет цілі", N.PRIORITY_NAMES)
	addSlider(p, "Smooth", "Різкість наведення", 0.05, 1, 0.05, "%.2f")
	addSlider(p, "Prediction", "Передбачення руху", 0, 0.5, 0.01, "%.2f с")
	addSection(p, "КОЛО FOV")
	addToggle(p, "UseFov", "Обмежувати колом FOV")
	addToggle(p, "FovShow", "Показувати коло")
	addSlider(p, "FovRadius", "Радіус кола", 30, 800, 10, "%d px")
	addSlider(p, "FovThick", "Товщина лінії", 1, 6, 1, "%d")
	addCycle(p, "FovColor", "Колір кола", N.COLOR_NAMES)
	addSection(p, "ЦІЛІ")
	addToggle(p, "WallCheck", "Не цілитись крізь стіни")
	addToggle(p, "IgnoreTeam", "Ігнорувати свою команду")
	addToggle(p, "IncludeNPCs", "Включати NPC / манекени")
	addToggle(p, "MotAim", "Цілитись у все, що рухається")

	local t = addTab("ТП")
	addSection(t, "ТЕЛЕПОРТ ДО ЦІЛІ")
	addToggle(t, "TpAuto", "Авто-ТП до цілі")
	addButton(t, "ТП до цілі зараз", teleportToTarget)
	addCycle(t, "TpMode", "Позиція", N.TP_MODE_NAMES)
	addSlider(t, "TpOffset", "Відстань від цілі", 1, 20, 1, "%d ст")
	addSlider(t, "TpInterval", "Інтервал авто-ТП", 0.5, 10, 0.5, "%.1f с")
	addToggle(t, "TpUseFov", "Лише ціль у колі FOV")
	addSection(t, "ТП ПРИ ОТРИМАННІ УРОНУ")
	addToggle(t, "TpDmg", "Рандомний ТП при уроні")
	addSlider(t, "TpDmgMin", "Мін. дистанція", 5, 100, 5, "%d ст")
	addSlider(t, "TpDmgMax", "Макс. дистанція", 10, 200, 5, "%d ст")
	addSlider(t, "TpDmgCd", "Кулдаун", 0.5, 10, 0.5, "%.1f с")

	addSection(t, "ЛОКАЛЬНИЙ ПРИТЯГ ВОРОГА (лише у вас)")
	addButton(t, "Притягнути ціль зараз", function() if pullToggle then pullToggle() end end)
	addKeybind(t, "KeyPull", "Клавіша притягу (ПК)")
	addToggle(t, "PullHold", "Тримати клавішу замість перемикання")
	addToggle(t, "PullUseFov", "Лише ціль у колі FOV")
	addToggle(t, "PullTeam", "Включати свою команду")
	addSlider(t, "PullDist", "Відстань перед вами", 2, 20, 1, "%d ст")
	addSlider(t, "PullTime", "Тривалість", 1, 10, 0.5, "%.1f с")

	local e = addTab("ESP")
	addSection(e, "ЗАГАЛЬНЕ")
	addToggle(e, "Esp", "Увімкнути ESP")
	addToggle(e, "EspHighlight", "Підсвітка тіла")
	addToggle(e, "EspAlwaysOnTop", "Видно крізь стіни")
	addToggle(e, "EspHideTeam", "Ховати свою команду")
	addSlider(e, "EspMaxDist", "Дальність (5000 = без ліміту)", 100, 5000, 100, "%d")
	addSection(e, "КОЛЬОРИ")
	addCycle(e, "EspFill", "Колір заливки", N.COLOR_NAMES)
	addSlider(e, "EspFillTrans", "Прозорість заливки", 0, 1, 0.05, "%.2f")
	addCycle(e, "EspOutline", "Колір контуру", N.COLOR_NAMES)
	addSlider(e, "EspOutTrans", "Прозорість контуру", 0, 1, 0.05, "%.2f")
	addToggle(e, "EspTeamColor", "Колір за командою")
	addToggle(e, "EspHealthColor", "Колір заливки за HP")
	addSection(e, "ПІДПИСИ")
	addToggle(e, "EspNames", "Імена")
	addToggle(e, "EspHealth", "HP і смужка здоров'я")
	addToggle(e, "EspDist", "Дистанція")
	addSlider(e, "EspTextSize", "Розмір тексту", 10, 24, 1, "%d")
	addSection(e, "ВІЗУАЛИ")
	addToggle(e, "EspBox", "2D-бокс")
	addCycle(e, "EspBoxColor", "Колір боксу", N.COLOR_NAMES)
	addSlider(e, "EspBoxThick", "Товщина боксу", 1, 4, 1, "%d")
	addToggle(e, "EspBar", "Смужка HP збоку")
	addToggle(e, "EspTracer", "Трейсери")
	addCycle(e, "EspTracerColor", "Колір трейсерів", N.COLOR_NAMES)
	addCycle(e, "EspTracerFrom", "Початок трейсерів", N.TRACER_FROM_NAMES)
	addToggle(e, "EspHead", "Точка на голові")
	addCycle(e, "EspHeadColor", "Колір точки", N.COLOR_NAMES)
	addToggle(e, "EspArrows", "Стрілки до ворогів поза екраном")
	addCycle(e, "EspArrowColor", "Колір стрілок", N.COLOR_NAMES)
	addToggle(e, "EspVisCheck", "Колір за видимістю (червоний/зелений)")
	addToggle(e, "EspNPC", "Візуали також для NPC")
	addSection(e, "ВСЕ, ЩО РУХАЄТЬСЯ (крізь стіни)")
	addToggle(e, "MotEsp", "Підсвічувати рухомі об'єкти")
	addSlider(e, "MotMinSpeed", "Мін. швидкість руху", 1, 60, 1, "%d ст/с")
	addSlider(e, "MotMinSize", "Мін. розмір об'єкта", 0.2, 10, 0.2, "%.1f")
	addSlider(e, "MotDist", "Дальність пошуку", 50, 2000, 50, "%d")
	addSlider(e, "MotMaxCount", "Макс. об'єктів", 5, 120, 5, "%d")
	addCycle(e, "MotColor", "Колір", N.COLOR_NAMES)
	addSlider(e, "MotFillTrans", "Прозорість заливки", 0, 1, 0.05, "%.2f")
	addToggle(e, "MotLabel", "Підпис (назва, дистанція, швидкість)")
	addToggle(e, "MotSkipPlayers", "Пропускати гравців (вони вже в ESP)")
	addSection(e, "ПРЕСЕТИ ВІЗУАЛІВ")
	addButton(e, "Пресет: мінімум", function() applyEspPreset(1) end)
	addButton(e, "Пресет: стандарт", function() applyEspPreset(2) end)
	addButton(e, "Пресет: повний", function() applyEspPreset(3) end)

	local m = addTab("Рух")
	addSection(m, "ШВИДКІСТЬ І СТРИБОК")
	addToggle(m, "SpeedOn", "Власна швидкість")
	addSlider(m, "Speed", "Швидкість бігу", 16, 200, 2, "%d")
	addToggle(m, "JumpOn", "Власна сила стрибка")
	addSlider(m, "JumpPower", "Сила стрибка", 50, 300, 5, "%d")
	addToggle(m, "InfJump", "Нескінченний стрибок")
	addSection(m, "ПЕРЕСУВАННЯ")
	addToggle(m, "Noclip", "Noclip (крізь стіни)")
	addToggle(m, "Fly", "Політ")
	addKeybind(m, "KeyFly", "Клавіша польоту (ПК)")
	addCycle(m, "FlyMode", "Режим польоту", N.FLY_MODE_NAMES)
	addSlider(m, "FlyStep", "Довжина кроку", 1, 20, 1, "%d ст")
	addSlider(m, "FlyTickMs", "Інтервал між кроками", 20, 300, 10, "%d мс")
	addSlider(m, "FlyMaxSps", "Ліміт швидкості (ст/с)", 50, 250, 10, "%d")
	addSlider(m, "FlyVert", "Множник вертикалі", 10, 200, 10, "%d%%")
	addToggle(m, "FlyPitch", "Йти за нахилом камери")
	addToggle(m, "FlySmooth", "Плавно (без стрибків)")
	addToggle(m, "FlyRamp", "Розгін зі старту")
	addSlider(m, "FlyRampTime", "Час розгону", 0.1, 3, 0.1, "%.1f с")
	addToggle(m, "FlyHold", "Висіти в повітрі без руху")
	addToggle(m, "FlyWalls", "Зупинка об стіни (без ноуклипу)")
	addSection(m, "БАННІХОП")
	addToggle(m, "Bhop", "Банніхоп (затисни пробіл)")
	addSlider(m, "BhopMax", "Макс. швидкість банніхопу", 30, 200, 5, "%d")
	addSlider(m, "BhopGain", "Розгін у повітрі", 1, 10, 1, "%d")
	addSection(m, "БЛІЦ (оберт навколо ворога)")
	addKeybind(m, "KeyOrbit", "Клавіша бліцу (ПК)")
	addButton(m, "Бліц по цілі в колі FOV", function() if orbitStart then orbitStart() end end)
	addSlider(m, "OrbitTime", "Тривалість", 1, 8, 0.5, "%.1f с")
	addSlider(m, "OrbitRadius", "Радіус", 4, 40, 1, "%d ст")
	addSlider(m, "OrbitSpeed", "Швидкість обертання", 60, 720, 20, "%d °/с")
	addSlider(m, "OrbitHeight", "Висота над ціллю", -5, 15, 1, "%d ст")
	addCycle(m, "OrbitDir", "Напрямок", N.ORBIT_DIR_NAMES)
	addSlider(m, "OrbitMaxStart", "Макс. дистанція старту", 30, 200, 5, "%d ст")
	addToggle(m, "OrbitFace", "Тримати приціл на цілі")
	addToggle(m, "OrbitReturn", "Повертати назад після бліцу")
	addSection(m, "АНТИПРИЦІЛ")
	addToggle(m, "Spin", "Антиприціл")
	addCycle(m, "SpinMode", "Режим", N.SPIN_MODE_NAMES)
	addSlider(m, "SpinSpeed", "Швидкість крутилки", 60, 3000, 60, "%d °/с")

	local w = addTab("Світ")
	addSection(w, "ЗБІР МОНЕТ")
	addToggle(w, "Coins", "Авто-збір монет")
	addTextBox(w, "CoinName", "Назва об'єкта")
	addSlider(w, "CoinInterval", "Інтервал", 0.1, 2, 0.1, "%.1f с")
	addSlider(w, "CoinRange", "Радіус пошуку", 20, 2000, 20, "%d ст")
	addToggle(w, "CoinReturn", "Повертатись назад")
	addSection(w, "ПРОДУКТИВНІСТЬ (лише у вас)")
	addToggle(w, "FpsBoost", "Буст FPS (без тіней, легкі текстури)")
	addCycle(w, "FpsLevel", "Рівень буста", N.FPS_LEVEL_NAMES)
	addToggle(w, "FpsKeepChars", "Не чіпати персонажів")
	addSection(w, "ВІЗУАЛ")
	addToggle(w, "FullBright", "Повна яскравість")
	addToggle(w, "CamFovOn", "Власний FOV камери")
	addSlider(w, "CamFov", "FOV камери", 40, 120, 1, "%d°")
	addToggle(w, "GravityOn", "Власна гравітація")
	addSlider(w, "Gravity", "Гравітація", 10, 400, 10, "%d")
	addToggle(w, "Crosshair", "Хрестик у центрі")
	addSlider(w, "CrossSize", "Розмір хрестика", 4, 40, 1, "%d")
	addCycle(w, "CrossColor", "Колір хрестика", N.COLOR_NAMES)
	addToggle(w, "Tpv", "Вид від 3-ї особи")
	addSlider(w, "TpvDist", "Відстань камери", 4, 80, 1, "%d ст")
	addToggle(w, "TpvFree", "Вільний зум (колесо/щипок)")

	addSection(w, "НЕБО")
	addToggle(w, "SkyOn", "Змінювати небо")
	addCycle(w, "SkyPreset", "Пресет неба", N.SKY_PRESET_NAMES)
	addSlider(w, "SkyTime", "Час доби («Своє»)", 0, 24, 0.25, "%.2f")
	addCycle(w, "SkyColor", "Колір неба («Своє»)", N.COLOR_NAMES)
	addSlider(w, "SkyDensity", "Щільність атмосфери", 0, 0.8, 0.05, "%.2f")
	addSlider(w, "SkyCycle", "Швидкість зміни дня/ночі", 0, 5, 0.1, "%.1f")
	addToggle(w, "SkyStars", "Зорі вночі")
	addSection(w, "ПЕРЕФАРБУВАННЯ ГРАВЦІВ (лише у вас)")
	addToggle(w, "Chr", "Змінювати колір персонажів")
	addCycle(w, "ChrWho", "Кого фарбувати", N.CHR_WHO_NAMES)
	addCycle(w, "ChrStyle", "Стиль", N.CHR_STYLE_NAMES)
	addCycle(w, "ChrColor", "Колір", N.CHR_COLOR_NAMES)
	addCycle(w, "ChrColor2", "Другий колір (перелив)", N.CHR_COLOR_NAMES)
	addCycle(w, "ChrMat", "Матеріал", N.CHR_MAT_NAMES)
	addSlider(w, "ChrSpeed", "Швидкість переливу", 0.2, 5, 0.1, "%.1f")
	addSlider(w, "ChrAlpha", "Прозорість", 0, 0.9, 0.05, "%.2f")

	local dr = addTab("Дрони")
	addSection(dr, "ПОШУК ДРОНІВ")
	addTextArea(dr, "DrName", "Назви дронів (через кому)", 118)
	addTextArea(dr, "DrExclude", "Виключити (через кому)", 72)
	addButton(dr, "Перевірити: скільки знайдено", function() if droneReport then droneReport() end end)
	addSection(dr, "ВИЯВЛЕННЯ")
	addToggle(dr, "DrEsp", "Підсвітка дронів")
	addCycle(dr, "DrEspColor", "Колір підсвітки", N.COLOR_NAMES)
	addToggle(dr, "DrWarn", "Попередження про дрон")
	addSlider(dr, "DrWarnRadius", "Радіус попередження", 30, 400, 10, "%d ст")
	addSection(dr, "ЗБИВАННЯ")
	addToggle(dr, "DrAim", "Автоприціл на дрони")
	addSlider(dr, "DrAimRange", "Дальність прицілу", 30, 800, 10, "%d ст")
	addToggle(dr, "DrAutoFire", "Автовогонь по дрону")
	addSection(dr, "УХИЛЕННЯ")
	addToggle(dr, "DrEvade", "Авто-ухилення від дрона")
	addSlider(dr, "DrEvadeRadius", "Радіус спрацювання", 10, 120, 5, "%d ст")
	addSlider(dr, "DrEvadeDist", "Відстань ухилення", 10, 80, 5, "%d ст")
	addSlider(dr, "DrEvadeCd", "Кулдаун ухилення", 1, 10, 0.5, "%.1f с")

	local df = addTab("Захист")
	addSection(df, "ГОЛОВНЕ")
	addButton(df, "УВІМКНУТИ ВЕСЬ АНТИЧІТ", enableAllAnticheat)
	addSection(df, "АНТИФЛІНГ")
	addToggle(df, "AntiFling", "Антифлінг")
	addToggle(df, "AfNoCollide", "Без колізій з гравцями")
	addToggle(df, "AfClamp", "Гасити різкі поштовхи")
	addToggle(df, "AfNoRagdoll", "Не падати від ударів")
	addToggle(df, "AfVoid", "Повертати з прірви")
	addToggle(df, "AfNotify", "Сповіщати про флінг")
	addSlider(df, "AfSpeed", "Поріг швидкості", 100, 1500, 50, "%d")
	addSlider(df, "AfAng", "Поріг обертання", 20, 300, 10, "%d")
	addSection(df, "АНТИ-СИДІННЯ")
	addToggle(df, "AntiSit", "Анти-сидіння")
	addCycle(df, "SitMode", "Що блокувати", N.SIT_MODE_NAMES)
	addSlider(df, "SitSpeed", "Поріг швидкості сидіння", 20, 300, 10, "%d")
	addToggle(df, "SitNotify", "Сповіщати про блокування")
	addSection(df, "АНТИ-ПАДІННЯ")
	addToggle(df, "AntiFall", "Анти-падіння")
	addSlider(df, "FallHeight", "Макс. висота над землею", 60, 800, 20, "%d ст")
	addSlider(df, "FallSpeed", "Макс. швидкість падіння", 100, 800, 20, "%d")
	addToggle(df, "FallNotify", "Сповіщати про повернення")
	addSection(df, "АНТИ-ТП-ФЛІК")
	addToggle(df, "AntiFlick", "Анти-ТП-флік")
	addToggle(df, "FlickEnemyOnly", "Лише якщо поруч ворог")
	addToggle(df, "FlickRevert", "Повертати назад")
	addSlider(df, "FlickDist", "Мін. дальність примусового ТП", 20, 200, 5, "%d ст")
	addSection(df, "АНТИ-СЛІПОТА")
	addToggle(df, "AntiBlind", "Анти-сліпота")
	addSlider(df, "AbBlur", "Макс. розмиття", 0, 30, 1, "%d")
	addSlider(df, "AbBright", "Макс. яскравість спалаху", 0.05, 1, 0.05, "%.2f")
	addToggle(df, "AbGui", "Гасити білі екрани (GUI)")
	addTextBox(df, "AbIgnore", "Ігнорувати інтерфейси (через кому)")
	addSection(df, "БЕЗПЕЧНЕ МІСЦЕ")
	addButton(df, "Створити безпечне місце тут", function() if Safe.create then Safe.create() end end)
	addButton(df, "ТП у безпечне місце", function() if Safe.go then Safe.go() end end)
	addButton(df, "Видалити безпечне місце", function() if Safe.delete then Safe.delete() end end)
	addSection(df, "ЗАГАЛЬНЕ")
	addButton(df, "Вимкнути весь захист", function() setDefense(false) end)

	local dt = addTab("Детект")
	addSection(dt, "КОНТР-ТП")
	addToggle(dt, "Counter", "Контр-ТП, якщо тепнулись до мене")
	addCycle(dt, "CtMode", "Реакція", N.CT_MODE_NAMES)
	addToggle(dt, "CtBehindOnly", "Лише якщо опинились за спиною")
	addToggle(dt, "CtFace", "Розвертати камеру на ворога")
	addSlider(dt, "CtRadius", "Радіус спрацювання", 10, 80, 5, "%d ст")
	addSlider(dt, "CtMinJump", "Мін. дальність ТП ворога", 15, 150, 5, "%d ст")
	addSlider(dt, "CtCooldown", "Кулдаун", 0.5, 10, 0.5, "%.1f с")
	addSlider(dt, "CtDelay", "Затримка реакції", 0, 0.5, 0.05, "%.2f с")
	addSection(dt, "ТП ВОРОГІВ")
	addToggle(dt, "TpHl", "Підсвічувати ТП ворогів")
	addSlider(dt, "TpHlMin", "Мін. дальність ТП", 15, 200, 5, "%d ст")
	addSlider(dt, "TpHlRange", "Макс. відстань до мене", 100, 5000, 100, "%d ст")
	addSlider(dt, "TpHlTime", "Скільки тримати мітку", 1, 10, 0.5, "%.1f с")
	addToggle(dt, "TpHlTeam", "Включати свою команду")
	addCycle(dt, "TpHlColor", "Колір мітки", N.COLOR_NAMES)
	addSection(dt, "ПРИЦІЛ НА ВАС")
	addToggle(dt, "AimWarn", "Сповіщати про приціл на мене")
	addSlider(dt, "AwAngle", "Кут наведення", 2, 20, 1, "%d°")
	addSlider(dt, "AwRange", "Макс. дистанція", 50, 1000, 50, "%d ст")
	addSlider(dt, "AwTime", "Мін. час утримання", 0.2, 3, 0.1, "%.1f с")
	addToggle(dt, "AwWall", "Лише якщо немає стін")
	addToggle(dt, "AwTeam", "Включати свою команду")
	addSection(dt, "ПІДОЗРА НА АІМБОТ")
	addToggle(dt, "Susp", "Шукати підозрілих")
	addSlider(dt, "SuspSnap", "Поріг різкого повороту", 30, 160, 5, "%d°")
	addSlider(dt, "SuspThreshold", "Спрацювань до підозри", 2, 10, 1, "%d")
	addToggle(dt, "SuspTags", "Мітка над головою")
	addToggle(dt, "SuspNotify", "Сповіщати про підозрілих")
	suspInfoLabel = addInfo(dt, 92)
	addSection(dt, "СКАНЕР ЧІТІВ")
	addToggle(dt, "DtSpeed", "Спідхак")
	addToggle(dt, "DtFly", "Політ (fly)")
	addToggle(dt, "DtNoclip", "Ноуклип (крізь стіни)")
	addToggle(dt, "DtSpin", "Спінбот / крутилка")
	addToggle(dt, "DtHitbox", "Збільшені хітбокси")
	addToggle(dt, "DtInvis", "Невидимість")
	addToggle(dt, "DtLag", "Лаг-світч / телепорт-лаг")
	addToggle(dt, "DtReveal", "Показувати невидимих (мітка крізь стіни)")
	addToggle(dt, "DtFreeze", "Дебаф: застопорити підозрілого при піканні")
	addSlider(dt, "DtFreezeTime", "Тривалість дебафа (лише у вас)", 2, 3, 0.1, "%.1f с")
	addSlider(dt, "DtFreezeCool", "Перерва між дебафами", 1, 10, 0.5, "%.1f с")
	addToggle(dt, "DtTags", "Мітка над головою підозрілого")

	addToggle(dt, "DtNotify", "Сповіщати про підозрілих")
	addSlider(dt, "DtThreshold", "Спрацювань до підозри", 1, 8, 1, "%d")
	addSlider(dt, "DtSpeedMax", "Макс. швидкість гравця", 30, 250, 5, "%d")
	addSlider(dt, "DtFlyTime", "Час у повітрі без падіння", 1, 8, 0.5, "%.1f с")
	addSlider(dt, "DtSpinRate", "Поріг обертання (рад/с)", 6, 40, 1, "%d")
	addSlider(dt, "DtHitboxSize", "Макс. розмір хітбокса", 3, 12, 0.5, "%.1f")
	dtInfoLabel = addInfo(dt, 110)

	local s = addTab("Налашт.")
	addSection(s, "ВИГЛЯД МЕНЮ")
	addCycle(s, "Lang", "Мова", N.LANG_NAMES)
	addCycle(s, "Accent", "Акцентний колір", N.ACCENT_NAMES)
	addToggle(s, "AutoScale", "Авто-масштаб під екран")
	addSlider(s, "UiScale", "Масштаб меню", 0.7, 1.4, 0.05, "%.2f")
	addSlider(s, "MenuAlpha", "Прозорість меню", 0, 0.8, 0.05, "%.2f")
	addToggle(s, "Toasts", "Сповіщення про вмик/вимк")
	addToggle(s, "Quick", "Швидкі кнопки на екрані")
	addToggle(s, "Debug", "Діагностика (ціль у футері)")
	addSection(s, "КЛАВІШІ (ПК), BACKSPACE = ПРИБРАТИ")
	addKeybind(s, "KeyMenu", "Відкрити меню")
	addKeybind(s, "KeyAim", "Вмик/вимк автоприціл")
	addKeybind(s, "KeyTp", "ТП до цілі")
	addKeybind(s, "KeyTpv", "Вид від 3-ї особи (клавіша)")
	addKeybind(s, "KeyPanic", "Вимкнути все")
	addSection(s, "КОНФІГИ (слоти до закриття гри)")
	cfgInfoLabel = addInfo(s, 96)
	addCycle(s, "CfgSlot", "Слот", N.SLOT_NAMES)
	addButton(s, "Зберегти в слот", cfgSave)
	addButton(s, "Завантажити зі слота", cfgLoad)
	addButton(s, "Очистити слот", cfgClear)
	addButton(s, "Слот у поле (для копіювання)", cfgToText)
	addButton(s, "Поле у слот", cfgFromText)
	addSection(s, "ЕКСПОРТ / ІМПОРТ")
	addTextArea(s, "CfgText", "Налаштування (JSON)", 96)
	addButton(s, "Експортувати налаштування", exportConfig)
	addButton(s, "Імпортувати з поля", importConfig)
	addSection(s, "СКИДАННЯ")
	addButton(s, "Вимкнути всі функції", disableAll)
	addButton(s, "Скинути всі налаштування", resetAll)

	selectTab(pages[1])
	register("CfgSlot", refreshCfgInfo)

	addDock("AIM", "Aim", function() setValue("Aim", not S.Aim) end)
	addDock("TP", nil, function() teleportToTarget() end)
	addDock("PULL", nil, function() if pullToggle then pullToggle() end end)
	addDock("3P", "Tpv", function() setValue("Tpv", not S.Tpv) end)
	addDock("ESP", "Esp", function() setValue("Esp", not S.Esp) end)
	addDock("SPIN", "Spin", function() setValue("Spin", not S.Spin) end)
	addDock("ANTI", "AntiFling", function() setValue("AntiFling", not S.AntiFling) end)
	addDock("CTR", "Counter", function() setValue("Counter", not S.Counter) end)
	addDock("FLY", "Fly", function() setValue("Fly", not S.Fly) end)
	addDock("ORB", nil, function() if orbitStart then orbitStart() end end)
	addDock("OFF", nil, function()
		disableAll()
		if orbitStop then orbitStop() end
	end)

	addDock("SAFE", nil, function() if Safe.go then Safe.go() end end, function() return Safe.cf ~= nil end)
end

applyAccent()
applyVisuals()

local splashDone = false

local function fadeAll(container, t)
	local info = TweenInfo.new(t, Enum.EasingStyle.Quad)
	local function fade(o)
		if o:IsA("TextLabel") or o:IsA("TextButton") then
			TweenService:Create(o, info, { TextTransparency = 1, BackgroundTransparency = 1 }):Play()
		elseif o:IsA("Frame") then
			TweenService:Create(o, info, { BackgroundTransparency = 1 }):Play()
		elseif o:IsA("UIStroke") then
			TweenService:Create(o, info, { Transparency = 1 }):Play()
		end
	end
	fade(container)
	for _, d in container:GetDescendants() do fade(d) end
end

N.GLYPHS = {
	Z = { "11111", "00001", "00010", "00100", "01000", "10000", "11111" },
	E = { "11111", "10000", "10000", "11110", "10000", "10000", "11111" },
	N = { "10001", "11001", "10101", "10011", "10001", "10001", "10001" },
	I = { "11111", "00100", "00100", "00100", "00100", "00100", "11111" },
	T = { "11111", "00100", "00100", "00100", "00100", "00100", "00100" },
	H = { "10001", "10001", "10001", "11111", "10001", "10001", "10001" },
}

local function runSplash()
	if splashDone then return end
	splashDone = true
	if not N.SHOW_INTRO then return end
	splashActive = true

	local gui
	local function cleanup()
		splashActive = false
		local g = gui
		gui = nil
		if g then pcall(function() g:Destroy() end) end
	end

	task.delay(16, cleanup)

	local ok, err = pcall(function()
		local rng = Random.new()
		local t0 = os.clock()
		local chosen = false
		local qOut = TweenInfo.new(0.8, Enum.EasingStyle.Quart, Enum.EasingDirection.Out)
		local function later(t, fn)
			task.delay(t, function()
				if gui then fn() end
			end)
		end

		gui = Instance.new("ScreenGui")
		gui.Name = "FunModeIntro"
		gui.ResetOnSpawn = false
		gui.IgnoreGuiInset = true
		gui.DisplayOrder = 1000
		gui.Parent = playerGui

		local root = Instance.new("Frame")
		root.Size = UDim2.fromScale(1, 1)
		root.BackgroundColor3 = Color3.fromRGB(6, 7, 10)
		root.BackgroundTransparency = 1
		root.BorderSizePixel = 0
		root.Active = true
		root.Parent = gui
		TweenService:Create(root, TweenInfo.new(0.6), { BackgroundTransparency = 0.04 }):Play()

		local hair = Instance.new("Frame")
		hair.AnchorPoint = Vector2.new(0.5, 0.5)
		hair.Position = UDim2.fromScale(0.5, isTouch and 0.33 or 0.36)
		hair.Size = UDim2.new(0, 0, 0, 1)
		hair.BackgroundColor3 = ACCENT
		hair.BackgroundTransparency = 0.45
		hair.BorderSizePixel = 0
		hair.Parent = root
		TweenService:Create(hair, TweenInfo.new(1.0, Enum.EasingStyle.Quint, Enum.EasingDirection.Out),
			{ Size = UDim2.new(1, 0, 0, 1) }):Play()
		later(1.3, function()
			TweenService:Create(hair, TweenInfo.new(0.9, Enum.EasingStyle.Quad), { BackgroundTransparency = 1 }):Play()
		end)

		local cs = isTouch and 7 or 11
		local gridW = (#N.PROJECT_NAME * 5 + (#N.PROJECT_NAME - 1) * 2) * cs
		local gridH = 7 * cs
		local bannerH = gridH + (isTouch and 96 or 118)
		local bannerW = math.max(gridW + cs * 10, 300)

		local banner = Instance.new("Frame")
		banner.AnchorPoint = Vector2.new(0.5, 0.5)
		banner.Position = UDim2.fromScale(0.5, isTouch and 0.33 or 0.36)
		banner.Size = UDim2.fromOffset(bannerW, bannerH)
		banner.BackgroundTransparency = 1
		banner.Parent = root

		local bScale = Instance.new("UIScale")
		bScale.Scale = 0.94
		bScale.Parent = banner
		TweenService:Create(bScale, TweenInfo.new(2.2, Enum.EasingStyle.Quint, Enum.EasingDirection.Out), { Scale = 1 }):Play()

		local bStroke = addStroke(banner, N.C_LINE, 1, 1)
		later(1.4, function()
			TweenService:Create(bStroke, TweenInfo.new(0.6), { Transparency = 0 }):Play()
		end)

		local slats = 9
		for i = 1, slats do
			local s = Instance.new("Frame")
			s.BorderSizePixel = 0
			s.Size = UDim2.new(1, 0, 1 / slats, i < slats and 1 or 0)
			s.Position = UDim2.new(i % 2 == 0 and 1.8 or -1.8, 0, (i - 1) / slats, 0)
			local shade = 13 + (i % 3) * 2
			s.BackgroundColor3 = Color3.fromRGB(shade, shade + 1, shade + 6)
			s.Parent = banner
			later(0.15 + (i - 1) * 0.1, function()
				TweenService:Create(s, qOut, { Position = UDim2.new(0, 0, (i - 1) / slats, 0) }):Play()
			end)
		end

		local function edge(y, delayT)
			local f = Instance.new("Frame")
			f.AnchorPoint = Vector2.new(0.5, 0.5)
			f.Position = UDim2.new(0.5, 0, y, 0)
			f.Size = UDim2.new(0, 0, 0, 2)
			f.BackgroundColor3 = ACCENT
			f.BorderSizePixel = 0
			f.Parent = banner
			later(delayT, function()
				TweenService:Create(f, TweenInfo.new(0.8, Enum.EasingStyle.Quart, Enum.EasingDirection.Out),
					{ Size = UDim2.new(1, 0, 0, 2) }):Play()
			end)
			return f
		end
		edge(0, 1.5)
		edge(1, 1.6)

		local function bracket(ax, ay, d)
			local sx = ax == 0 and -1 or 1
			local sy = ay == 0 and -1 or 1
			local hz = Instance.new("Frame")
			hz.AnchorPoint = Vector2.new(ax, ay)
			hz.Position = UDim2.new(ax, sx * 30, ay, sy * 30)
			hz.Size = UDim2.fromOffset(0, 2)
			hz.BackgroundColor3 = ACCENT
			hz.BackgroundTransparency = 1
			hz.BorderSizePixel = 0
			hz.Parent = banner
			local vt = hz:Clone()
			vt.Size = UDim2.fromOffset(2, 0)
			vt.Parent = banner
			later(d, function()
				local info = TweenInfo.new(0.7, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
				local to = UDim2.new(ax, sx * 12, ay, sy * 12)
				TweenService:Create(hz, info, { Position = to, Size = UDim2.fromOffset(26, 2), BackgroundTransparency = 0 }):Play()
				TweenService:Create(vt, info, { Position = to, Size = UDim2.fromOffset(2, 26), BackgroundTransparency = 0 }):Play()
			end)
		end
		bracket(0, 0, 1.0)
		bracket(1, 0, 1.1)
		bracket(1, 1, 1.2)
		bracket(0, 1, 1.3)

		local progress = Instance.new("Frame")
		progress.AnchorPoint = Vector2.new(0, 1)
		progress.Position = UDim2.new(0, 0, 1, -6)
		progress.Size = UDim2.new(0, 0, 0, 1)
		progress.BackgroundColor3 = ACCENT
		progress.BackgroundTransparency = 0.3
		progress.BorderSizePixel = 0
		progress.Parent = banner

		local pct = makeText(banner, UDim2.fromOffset(60, 14), UDim2.new(1, -12, 1, -14), "000", 10, N.C_DIM, N.FONT_MONO,
			Enum.TextXAlignment.Right, true)
		pct.AnchorPoint = Vector2.new(1, 1)

		local grid = Instance.new("Frame")
		grid.AnchorPoint = Vector2.new(0.5, 0)
		grid.Position = UDim2.new(0.5, 0, 0, isTouch and 26 or 32)
		grid.Size = UDim2.fromOffset(gridW, gridH)
		grid.BackgroundTransparency = 1
		grid.Parent = banner

		local cells = {}
		local charset = N.PROJECT_NAME
		local n = 0
		for li = 1, #N.PROJECT_NAME do
			local g = N.GLYPHS[string.sub(N.PROJECT_NAME, li, li)]
			if g then
				local ox = (li - 1) * 7 * cs
				for r = 1, 7 do
					for c = 1, 5 do
						if string.sub(g[r], c, c) == "1" then
							n += 1
							local ch = string.sub(charset, (n - 1) % #charset + 1, (n - 1) % #charset + 1)
							local l = Instance.new("TextLabel")
							l.Size = UDim2.fromOffset(cs, cs)
							local fx, fy = ox + (c - 1) * cs, (r - 1) * cs
							l.BackgroundTransparency = 1
							l.Text = ch
							l.TextColor3 = ACCENT
							l.Font = N.FONT_MONO
							l.TextSize = cs + 1
							l.TextTransparency = 1
							l.Position = UDim2.fromOffset(fx + rng:NextInteger(-260, 260), fy + rng:NextInteger(-170, 170))
							l.Rotation = rng:NextInteger(-90, 90)
							l.Parent = grid
							cells[#cells + 1] = { l = l, x = fx, y = fy, ch = ch, start = 0, land = 0, done = false }
						end
					end
				end
			end
		end

		local assembleFrom, scanDur = 2.2, 4.0

		local scan = Instance.new("Frame")
		scan.AnchorPoint = Vector2.new(0.5, 0.5)
		scan.Position = UDim2.new(0, -cs, 0.5, 0)
		scan.Size = UDim2.new(0, 2, 1, 26)
		scan.BackgroundColor3 = ACCENT
		scan.BorderSizePixel = 0
		scan.Visible = false
		scan.ZIndex = 5
		scan.Parent = grid
		local trail = Instance.new("Frame")
		trail.AnchorPoint = Vector2.new(1, 0.5)
		trail.Position = UDim2.new(0, 0, 0.5, 0)
		trail.Size = UDim2.new(0, 46, 1, 0)
		trail.BackgroundColor3 = ACCENT
		trail.BorderSizePixel = 0
		trail.ZIndex = 5
		trail.Parent = scan
		local tg = Instance.new("UIGradient")
		tg.Transparency = NumberSequence.new({ NumberSequenceKeypoint.new(0, 1), NumberSequenceKeypoint.new(1, 0.8) })
		tg.Parent = trail
		later(assembleFrom - 0.1, function()
			scan.Visible = true
			TweenService:Create(scan, TweenInfo.new(scanDur, Enum.EasingStyle.Linear),
				{ Position = UDim2.new(0, gridW + cs, 0.5, 0) }):Play()
		end)
		later(assembleFrom + scanDur + 0.1, function()
			scan.Visible = false
		end)

		for _, cell in cells do
			local ts = assembleFrom + (cell.x + cs) / (gridW + cs * 2) * scanDur
			cell.land = ts + rng:NextNumber() * 0.2
			cell.start = math.max(cell.land - 0.75, 1.6)
			later(cell.start, function()
				TweenService:Create(cell.l, TweenInfo.new(cell.land - cell.start, Enum.EasingStyle.Quart, Enum.EasingDirection.Out),
					{ Position = UDim2.fromOffset(cell.x, cell.y), Rotation = 0, TextTransparency = 0.4 }):Play()
			end)
			later(cell.land, function()
				TweenService:Create(cell.l, TweenInfo.new(0.4), { TextTransparency = 0, TextColor3 = N.C_TEXT }):Play()
			end)
		end
		TweenService:Create(progress, TweenInfo.new(scanDur, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, 0, false, assembleFrom),
			{ Size = UDim2.new(1, 0, 0, 1) }):Play()

		task.spawn(function()
			local noise = "01<>/[]#=+-"
			while gui and not chosen do
				local now = os.clock() - t0
				for _, cell in cells do
					if now >= cell.start and now < cell.land + 0.15 then
						local k = rng:NextInteger(1, #noise)
						cell.l.Text = string.sub(noise, k, k)
					elseif not cell.done and now >= cell.land + 0.15 then
						cell.done = true
						cell.l.Text = cell.ch
					end
				end
				local p = math.clamp((now - assembleFrom) / scanDur, 0, 1)
				pct.Text = string.format("%03d", math.floor(p * 100 + 0.5))
				if now > assembleFrom + scanDur + 0.7 then break end
				task.wait(0.05)
			end
			for _, cell in cells do cell.l.Text = cell.ch end
			pct.Text = "100"
		end)

		local sub = Instance.new("TextLabel")
		sub.AnchorPoint = Vector2.new(0.5, 0)
		local subY = gridH + (isTouch and 40 or 50)
		sub.Position = UDim2.new(0.5, 0, 0, subY + 8)
		sub.Size = UDim2.fromOffset(300, 18)
		sub.BackgroundTransparency = 1
		sub.Text = "F U N   M O D E"
		sub.TextColor3 = N.C_DIM
		sub.Font = N.FONT_MONO
		sub.TextSize = 12
		sub.TextTransparency = 1
		sub.Parent = banner

		local bw = isTouch and 104 or 138
		local langBox = Instance.new("CanvasGroup")
		langBox.AnchorPoint = Vector2.new(0.5, 0)
		langBox.Position = UDim2.new(0.5, 0, isTouch and 0.33 or 0.36, bannerH / 2 + 30)
		langBox.Size = UDim2.fromOffset(math.max(bw * 3 + 100, 330), 104)
		langBox.BackgroundTransparency = 1
		langBox.GroupTransparency = 1
		langBox.Visible = false
		langBox.Parent = root

		makeText(langBox, UDim2.new(1, 0, 0, 18), UDim2.new(), "ОБЕРІТЬ МОВУ  /  CHOOSE LANGUAGE  /  ВЫБЕРИТЕ ЯЗЫК",
			isTouch and 9 or 10, N.C_DIM, N.FONT_MONO, Enum.TextXAlignment.Center, true)

		local btnRow = Instance.new("Frame")
		btnRow.Position = UDim2.fromOffset(0, 26)
		btnRow.Size = UDim2.new(1, 0, 0, 40)
		btnRow.BackgroundTransparency = 1
		btnRow.Parent = langBox
		local brl = Instance.new("UIListLayout")
		brl.FillDirection = Enum.FillDirection.Horizontal
		brl.HorizontalAlignment = Enum.HorizontalAlignment.Center
		brl.SortOrder = Enum.SortOrder.LayoutOrder
		brl.Padding = UDim.new(0, 36)
		brl.Parent = btnRow

		local countdown = makeText(langBox, UDim2.new(1, 0, 0, 18), UDim2.fromOffset(0, 74), "", 11, N.C_DIM, N.FONT_MONO,
			Enum.TextXAlignment.Center, true)

		local cdBar = Instance.new("Frame")
		cdBar.AnchorPoint = Vector2.new(0.5, 0)
		cdBar.Position = UDim2.new(0.5, 0, 0, 98)
		cdBar.Size = UDim2.new(1, -40, 0, 1)
		cdBar.BackgroundColor3 = ACCENT
		cdBar.BackgroundTransparency = 0.35
		cdBar.BorderSizePixel = 0
		cdBar.Parent = langBox

		local function choose(idx)
			if chosen then return end
			chosen = true
			setValue("Lang", idx, true)
			fadeAll(root, 0.55)
			TweenService:Create(bScale, TweenInfo.new(0.65, Enum.EasingStyle.Quart, Enum.EasingDirection.In), { Scale = 1.08 }):Play()
			task.wait(0.7)
			cleanup()
		end

		local hoverIn = TweenInfo.new(0.28, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
		for i = 1, 3 do
			local b = Instance.new("TextButton")
			b.LayoutOrder = i
			b.Size = UDim2.fromOffset(bw, 40)
			b.BackgroundColor3 = N.C_PANEL
			b.BorderSizePixel = 0
			b.AutoButtonColor = false
			b.Text = N.LANG_NAMES[i]
			b.TextColor3 = i == S.Lang and N.C_TEXT or N.C_DIM
			b.Font = FONT_B
			b.TextSize = isTouch and 13 or 14
			b.Parent = btnRow
			corner(b, 9)
			addStroke(b, N.C_LINE, 1)
			local ul = Instance.new("Frame")
			ul.AnchorPoint = Vector2.new(0.5, 1)
			ul.Position = UDim2.new(0.5, 0, 1, -5)
			ul.Size = UDim2.new(i == S.Lang and 1 or 0, i == S.Lang and -28 or 0, 0, 2)
			ul.BackgroundColor3 = ACCENT
			ul.BorderSizePixel = 0
			ul.Parent = b
			corner(ul, 1000)
			b.MouseEnter:Connect(function()
				tween(ul, { Size = UDim2.new(1, -28, 0, 2) }, hoverIn)
				tween(b, { TextColor3 = N.C_TEXT, BackgroundColor3 = N.C_ROW_HI }, hoverIn)
			end)
			b.MouseLeave:Connect(function()
				if i ~= S.Lang then tween(ul, { Size = UDim2.new(0, 0, 0, 2) }, hoverIn) end
				tween(b, { TextColor3 = i == S.Lang and N.C_TEXT or N.C_DIM, BackgroundColor3 = N.C_PANEL }, hoverIn)
			end)
			b.Activated:Connect(function()
				tween(ul, { Size = UDim2.new(1, -28, 0, 2) }, hoverIn)
				b.TextColor3 = ACCENT
				choose(i)
			end)
		end

		local skip = Instance.new("TextButton")
		skip.AnchorPoint = Vector2.new(1, 1)
		skip.Position = UDim2.new(1, -16, 1, -14)
		skip.Size = UDim2.fromOffset(120, 30)
		skip.BackgroundColor3 = N.C_PANEL
		skip.BorderSizePixel = 0
		skip.AutoButtonColor = false
		skip.TextColor3 = N.C_DIM
		skip.Font = FONT_B
		skip.TextSize = 12
		skip.Parent = root
		corner(skip, 9)
		bind(skip, "Пропустити")
		addStroke(skip, N.C_LINE, 1)
		skip.MouseEnter:Connect(function() tween(skip, { TextColor3 = N.C_TEXT }, hoverIn) end)
		skip.MouseLeave:Connect(function() tween(skip, { TextColor3 = N.C_DIM }, hoverIn) end)
		skip.Activated:Connect(function() choose(S.Lang) end)

		task.spawn(function()
			local ok2, err2 = pcall(function()
				task.wait(assembleFrom + scanDur + 0.6)
				if chosen then return end
				TweenService:Create(sub, TweenInfo.new(0.8, Enum.EasingStyle.Quint, Enum.EasingDirection.Out),
					{ TextTransparency = 0, Position = UDim2.new(0.5, 0, 0, subY) }):Play()
				task.wait(0.8)
				if chosen then return end

				langBox.Visible = true
				TweenService:Create(langBox, TweenInfo.new(0.7, Enum.EasingStyle.Quart, Enum.EasingDirection.Out),
					{ GroupTransparency = 0 }):Play()
				TweenService:Create(brl, TweenInfo.new(0.9, Enum.EasingStyle.Quint, Enum.EasingDirection.Out),
					{ Padding = UDim.new(0, 8) }):Play()
				TweenService:Create(cdBar, TweenInfo.new(5, Enum.EasingStyle.Linear), { Size = UDim2.new(0, 0, 0, 1) }):Play()
				local startLang = S.Lang
				for k = 5, 1, -1 do
					if chosen then return end
					countdown.Text = string.format(tr("Авто через %d"), k)
					task.wait(1)
				end
				choose(startLang)
			end)
			if not ok2 then
				warn("[ZENITH] intro: " .. tostring(err2))
				cleanup()
			end
		end)
	end)

	if not ok then
		warn("[ZENITH] intro: " .. tostring(err))
		cleanup()
	end
end

local function updateGate()
	local open = (not N.REQUIRE_GATE) or workspace:GetAttribute(N.GATE_ATTRIBUTE) == true
	if open ~= gateOpen then
		gateOpen = open
		UI.gui.Enabled = open
		UI.overlay.Enabled = open
		if not open then
			openMenu(false)
			disableAll()
		end
		applyVisuals()
	end
	if open and not splashDone then task.spawn(runSplash) end
end
workspace:GetAttributeChangedSignal(N.GATE_ATTRIBUTE):Connect(updateGate)
updateGate()

local fovSaved
local espTimer = 0

RunService:BindToRenderStep("FunModeRender", Enum.RenderPriority.Camera.Value + 1, function()
	local cam = getCamera()
	if not cam then return end

	local p = getAimPoint()
	UI.circle.Position = UDim2.fromOffset(p.X, p.Y)

	if S.CamFovOn then
		if not fovSaved then fovSaved = cam.FieldOfView end
		cam.FieldOfView = S.CamFov
	elseif fovSaved then
		cam.FieldOfView = fovSaved
		fovSaved = nil
	end

	local active = S.Aim and (not S.AimHold or not N.hasMouse or aimHeld)
	if active or S.Debug then
		currentTarget = getTarget(S.UseFov, S.MotAim)
	else
		currentTarget = nil
	end

	if active and currentTarget then
		local part = currentTarget.part or getAimPart(currentTarget.char)
		if part then
			local pos = part.Position + part.AssemblyLinearVelocity * S.Prediction
			cam.CFrame = cam.CFrame:Lerp(CFrame.lookAt(cam.CFrame.Position, pos), S.Smooth)
		end
	end
end)

local function flyUpdate(char, root, hum, dt)
		if S.Fly then
			local cam = getCamera()
			local move = hum.MoveDirection
			local dir = Vector3.zero
			if cam and move.Magnitude > 0.01 then
				dir = move
				if S.FlyPitch then
					local look = cam.CFrame.LookVector
					local flat = Vector3.new(look.X, 0, look.Z)
					local fwd = flat.Magnitude > 0.01 and move:Dot(flat.Unit) or 0
					dir += Vector3.new(0, look.Y * fwd, 0)
				end
			end
			if UserInputService:IsKeyDown(Enum.KeyCode.Space) or (isTouch and hum.Jump) then
				dir += Vector3.new(0, 1, 0)
			end
			if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift)
				or UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then
				dir -= Vector3.new(0, 1, 0)
			end
			dir = Vector3.new(dir.X, dir.Y * S.FlyVert / 100, dir.Z)
			local moving = dir.Magnitude > 0.05
			if moving and dir.Magnitude > 1 then dir = dir.Unit end

			if moving or S.FlyHold then root.AssemblyLinearVelocity = Vector3.zero end
			flyOn = true
			markSelf(0.6)

			local ramp = 1
			if S.FlyRamp then
				flyRampT = moving and math.min(flyRampT + dt, S.FlyRampTime) or 0
				ramp = 0.2 + 0.8 * flyRampT / math.max(S.FlyRampTime, 0.05)
			else
				flyRampT = 0
			end
			local step = S.FlyStep * ramp
			local tick = math.max(S.FlyTickMs / 1000, step / math.max(S.FlyMaxSps, 1))

			local function advance(dist)
				local delta = dir * dist
				if S.FlyWalls and not S.Noclip then
					flyRp.FilterDescendantsInstances = { char }
					local r = workspace:Raycast(root.Position, dir.Unit * (dist + 2), flyRp)
					if r then delta = dir.Unit * math.max(r.Distance - 2, 0) end
				end
				if delta.Magnitude > 0.01 then
					root.CFrame = root.CFrame + delta
					root.AssemblyLinearVelocity = Vector3.zero
				end
			end

			local mode = S.FlyMode
			if moving and (mode == 2 or mode == 3) then
				local sps = math.min(step / tick, S.FlyMaxSps)
				root.AssemblyLinearVelocity = dir * (mode == 3 and sps * 0.5 or sps)
			end
			if moving and mode ~= 2 then
				if S.FlySmooth then
					flyAcc = 0
					advance(step * math.min(dt / tick, 1))
				else
					flyAcc += dt
					if flyAcc >= tick then
						flyAcc = 0
						advance(step)
					end
				end
			else
				flyAcc = tick
			end
		elseif flyOn then
			flyOn = false
			root.AssemblyLinearVelocity = Vector3.new(0, math.min(root.AssemblyLinearVelocity.Y, 0), 0)
			markSelf(1.5)
		end
end

local flyErrShown = false
RunService.Heartbeat:Connect(function(dt)
	local char = player.Character
	local root, hum = getRoot(char), getHum(char)

	if (S.IncludeNPCs or S.EspNPC) and os.clock() - lastNpcScan > 2 then
		lastNpcScan = os.clock()
		scanNPCs()
	end

	if root and hum then

		if S.SpeedOn then
			if orig.walk == nil then orig.walk = hum.WalkSpeed end
			hum.WalkSpeed = S.Speed
		elseif orig.walk ~= nil then
			hum.WalkSpeed = orig.walk
			orig.walk = nil
		end

		if S.JumpOn then
			if orig.jump == nil then
				orig.jump = hum.JumpPower
				orig.useJP = hum.UseJumpPower
			end
			hum.UseJumpPower = true
			hum.JumpPower = S.JumpPower
		elseif orig.jump ~= nil then
			hum.UseJumpPower = orig.useJP
			hum.JumpPower = orig.jump
			orig.jump = nil
		end

		if S.TpAuto and os.clock() - lastTp >= S.TpInterval and os.clock() - lastTpTry >= 0.1 then
			lastTpTry = os.clock()
			teleportToTarget()
		end

		do
			local okF, errF = pcall(flyUpdate, char, root, hum, dt)
			if not okF and not flyErrShown then
				flyErrShown = true
				warn("[ZENITH] fly: " .. tostring(errF))
				pcall(toast, "Fly: " .. tostring(errF), Color3.fromRGB(255, 90, 90), true, 8)
			end
		end

		if S.Bhop and not S.Fly then
			local now = os.clock()
			local v = root.AssemblyLinearVelocity
			local move = hum.MoveDirection
			local keyHeld = UserInputService:IsKeyDown(Enum.KeyCode.Space)
			local touchHeld = isTouch and hum.Jump and now - bhopSet > 0.15
			local held = keyHeld or touchHeld
			local grounded = hum.FloorMaterial ~= Enum.Material.Air
			local seated = hum.SeatPart ~= nil or hum.Sit
			if held and not seated and hum.Health > 0 then
				if grounded then
					local carry = bhopHV
					if move.Magnitude < 0.01 then carry = Vector3.zero end
					local jp = hum.UseJumpPower and hum.JumpPower or math.sqrt(2 * workspace.Gravity * hum.JumpHeight)
					local hv = Vector3.new(v.X, 0, v.Z)
					if carry.Magnitude > hv.Magnitude then hv = carry end
					root.AssemblyLinearVelocity = Vector3.new(hv.X, jp, hv.Z)
					hum:ChangeState(Enum.HumanoidStateType.Jumping)
					bhopSet = now
					markSelf(0.6)
				elseif move.Magnitude > 0.01 then
					local wish = Vector3.new(move.X, 0, move.Z).Unit
					local hv = Vector3.new(v.X, 0, v.Z)
					local addSpeed = 12 - hv:Dot(wish)
					if addSpeed > 0 then
						hv += wish * math.min(addSpeed, S.BhopGain * 120 * dt)
					end
					if hv.Magnitude > S.BhopMax then hv = hv.Unit * S.BhopMax end
					root.AssemblyLinearVelocity = Vector3.new(hv.X, v.Y, hv.Z)
					bhopHV = hv
					markSelf(0.6)
				else
					bhopHV = Vector3.new(v.X, 0, v.Z)
				end
			else
				bhopHV = Vector3.zero
			end
		end

		if S.Spin then
			hum.AutoRotate = false
			spinOn = true
			local pos = root.Position
			if S.SpinMode == 1 then
				spinAngle = (spinAngle + S.SpinSpeed * dt) % 360
				root.CFrame = CFrame.new(pos) * CFrame.Angles(0, math.rad(spinAngle), 0)
			elseif S.SpinMode == 2 then
				root.CFrame = CFrame.new(pos) * CFrame.Angles(0, math.rad(math.random(0, 359)), 0)
			else
				local cam = getCamera()
				local look = cam and cam.CFrame.LookVector or Vector3.zAxis
				local flat = Vector3.new(look.X, 0, look.Z)
				if flat.Magnitude > 0.01 then
					root.CFrame = CFrame.lookAt(pos, pos - flat)
				end
			end
		elseif spinOn then
			hum.AutoRotate = true
			spinOn = false
		end
	end

	espTimer += dt
	if espTimer >= 0.1 then
		espTimer = 0
		updateEsp()
		if S.Debug then updateFooter() end
	end
end)

RunService.Stepped:Connect(function()
	local char = player.Character
	if S.Noclip and char then
		for _, p in char:GetDescendants() do
			if p:IsA("BasePart") and p.CanCollide then
				noclipSaved[p] = true
				p.CanCollide = false
			end
		end
	elseif next(noclipSaved) ~= nil then
		for p in noclipSaved do
			if p.Parent then p.CanCollide = true end
		end
		table.clear(noclipSaved)
	end
end)

UserInputService.JumpRequest:Connect(function()
	if S.InfJump then
		local hum = getHum(player.Character)
		if hum then hum:ChangeState(Enum.HumanoidStateType.Jumping) end
	end
end)

local ACTIONS = {
	KeyMenu = function() openMenu() end,
	KeyAim = function() setValue("Aim", not S.Aim) end,
	KeyTp = function() teleportToTarget() end,
	KeyTpv = function() setValue("Tpv", not S.Tpv) end,
	KeyPull = function() if pullToggle then pullToggle() end end,
	KeyFly = function() setValue("Fly", not S.Fly) end,
	KeyOrbit = function() if orbitStart then orbitStart() end end,
	KeyPanic = function()
		disableAll()
		if orbitStop then orbitStop() end
	end,
}

UserInputService.InputBegan:Connect(function(input, processed)
	if splashActive then return end

	if listening then
		if input.UserInputType == Enum.UserInputType.Keyboard then
			local name = input.KeyCode == Enum.KeyCode.Backspace and "None" or input.KeyCode.Name
			local k = listening
			listening = nil
			setValue(k, name, true)
		end
		return
	end

	if input.UserInputType == Enum.UserInputType.MouseButton2 then
		aimHeld = true
	end

	if processed or not gateOpen then return end
	if input.UserInputType == Enum.UserInputType.Keyboard then
		for key, action in ACTIONS do
			if S[key] ~= "None" and input.KeyCode.Name == S[key] then
				action()
			end
		end
	end
end)

UserInputService.InputChanged:Connect(function(input)

	if activeSlider then
		local same = input == activeSlider.input
		local mouseDrag = input.UserInputType == Enum.UserInputType.MouseMovement
			and activeSlider.input.UserInputType == Enum.UserInputType.MouseButton1
		if same or mouseDrag then
			activeSlider.update(input.Position.X)
		end
	end

	if dragging then
		local same = input == dragging.input
		local mouseDrag = input.UserInputType == Enum.UserInputType.MouseMovement
			and dragging.input.UserInputType == Enum.UserInputType.MouseButton1
		if same or mouseDrag then
			userMoved = true
			local d = Vector2.new(input.Position.X, input.Position.Y) - dragging.start
			UI.window.Position = UDim2.fromOffset(
				dragging.pos.X.Offset + d.X,
				dragging.pos.Y.Offset + d.Y
			)
			placeWindow()
		end
	end
end)

UserInputService.InputEnded:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton2 then
		aimHeld = false
	end
	if S.PullHold and pullStop and input.UserInputType == Enum.UserInputType.Keyboard
		and S.KeyPull ~= "None" and input.KeyCode.Name == S.KeyPull then
		pullStop()
	end
	if activeSlider and input == activeSlider.input then
		activeSlider.page.frame.ScrollingEnabled = true
		activeSlider = nil
	end
	if dragging and input == dragging.input then
		dragging = nil
	end
end)

local function watchCamera()
	local cam = getCamera()
	if cam then
		cam:GetPropertyChangedSignal("ViewportSize"):Connect(applyVisuals)
	end
end
watchCamera()
workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
	watchCamera()
	applyVisuals()
end)
UI.gui:GetPropertyChangedSignal("AbsoluteSize"):Connect(applyVisuals)

safeRun("drones", function()
	local DRONE_TAG = "Drone"
	local MAX_DRONE_SIZE = 60

	local TRANSLIT = {
		[0x430] = "a", [0x431] = "b", [0x432] = "v", [0x433] = "g", [0x491] = "g",
		[0x434] = "d", [0x435] = "e", [0x454] = "e", [0x451] = "e", [0x436] = "zh",
		[0x437] = "z", [0x438] = "i", [0x456] = "i", [0x457] = "i", [0x439] = "y",
		[0x43A] = "k", [0x43B] = "l", [0x43C] = "m", [0x43D] = "n", [0x43E] = "o",
		[0x43F] = "p", [0x440] = "r", [0x441] = "s", [0x442] = "t", [0x443] = "u",
		[0x444] = "f", [0x445] = "kh", [0x446] = "ts", [0x447] = "ch", [0x448] = "sh",
		[0x449] = "shch", [0x44A] = "", [0x44B] = "y", [0x44C] = "", [0x44D] = "e",
		[0x44E] = "yu", [0x44F] = "ya",
	}
	local LEET = { ["0"] = "o", ["1"] = "i", ["3"] = "e", ["4"] = "a", ["5"] = "s", ["7"] = "t", ["@"] = "a", ["$"] = "s" }
	local foldCache = {}

	local function fold(s)
		local cached = foldCache[s]
		if cached then return cached end

		local out = {}
		local ok = pcall(function()
			for _, cp in utf8.codes(s) do
				local c = cp
				if c >= 0x410 and c <= 0x42F then c += 32
				elseif c >= 0x400 and c <= 0x40F then c += 80
				elseif c == 0x490 then c = 0x491 end

				if c < 128 then
					local ch = string.lower(string.char(c))
					ch = LEET[ch] or ch
					if string.find(ch, "^%w+$") then out[#out + 1] = ch end
				elseif TRANSLIT[c] then
					out[#out + 1] = TRANSLIT[c]
				end
			end
		end)

		local result
		if ok then
			result = table.concat(out)
		else
			result = string.gsub(string.lower(s), "[^%w]", "")
		end
		foldCache[s] = result
		return result
	end

	local function parseList(text)
		local list = {}
		for token in string.gmatch(tostring(text), "[^,;\n]+") do
			local f = fold(token)
			if #f >= 3 then list[#list + 1] = f end
		end
		return list
	end

	local function matches(name, include, exclude)
		local f = fold(name)
		for _, ex in exclude do
			if string.find(f, ex, 1, true) then return false end
		end
		for _, inc in include do
			if string.find(f, inc, 1, true) then return true end
		end
		return false
	end

	local droneCache, enemyList = {}, {}
	local scanning, lastScan, forceScan = false, 0, true
	local lastEnemy = 0
	local lastNameKey = ""

	local function inAnyCharacter(inst)
		for _, plr in Players:GetPlayers() do
			local c = plr.Character
			if c and inst:IsDescendantOf(c) then return true end
		end
		return false
	end

	local function rescan()
		if scanning then return end
		scanning = true
		lastScan = os.clock()
		forceScan = false

		task.spawn(function()
			local include, exclude = parseList(S.DrName), parseList(S.DrExclude)
			local found, set, sizeCache = {}, {}, {}

			local function sizeOf(inst)
				local s = sizeCache[inst]
				if s then return s end
				if inst:IsA("Model") then
					s = inst:GetExtentsSize().Magnitude
				else
					s = inst.Size.Magnitude
				end
				sizeCache[inst] = s
				return s
			end

			local function consider(inst, checkSize)
				if not inst or not inst.Parent or set[inst] then return end
				if inAnyCharacter(inst) then return end

				local target = inst
				if inst:IsA("BasePart") then
					target = inst:FindFirstAncestorOfClass("Model") or inst
				end
				if checkSize and sizeOf(target) > MAX_DRONE_SIZE then

					if inst:IsA("BasePart") and target ~= inst and sizeOf(inst) <= MAX_DRONE_SIZE then
						target = inst
					else
						return
					end
				end
				if not set[target] then
					set[target] = true
					found[#found + 1] = target
				end
			end

			for _, inst in N.CollectionService:GetTagged(DRONE_TAG) do
				consider(inst, false)
			end

			if #include > 0 then
				local n = 0
				for _, inst in workspace:GetDescendants() do
					n += 1
					if n % 3000 == 0 then task.wait() end
					if inst.Parent and (inst:IsA("Model") or inst:IsA("BasePart")) then
						if matches(inst.Name, include, exclude) then
							consider(inst, true)
						end
					end
				end
			end

			local out = {}
			for _, m in found do
				local nested = false
				local p = m.Parent
				while p and p ~= workspace do
					if set[p] then nested = true break end
					p = p.Parent
				end
				if not nested then out[#out + 1] = m end
			end

			droneCache = out
			scanning = false
		end)
	end

	local function dronePos(m)
		if m:IsA("Model") then return m:GetPivot().Position end
		return m.Position
	end

	local function dronePart(m)
		if m:IsA("BasePart") then return m end
		return m.PrimaryPart or m:FindFirstChildWhichIsA("BasePart", true)
	end

	local function rebuildEnemies()
		local out = {}
		for _, m in droneCache do
			if m.Parent then
				local own, team = false, false
				local uid = m:GetAttribute("OwnerUserId")
				if uid == player.UserId then own = true end

				local ownerPlr = uid and Players:GetPlayerByUserId(uid)
				if not ownerPlr then
					for _, plr in Players:GetPlayers() do
						if string.find(m.Name, plr.Name, 1, true) then
							ownerPlr = plr
							break
						end
					end
				end
				if ownerPlr == player then own = true end
				if ownerPlr and isTeammate(ownerPlr) then team = true end

				if not own and not team then out[#out + 1] = m end
			end
		end
		enemyList = out
	end

	droneReport = function()
		forceScan = true
		rescan()
		task.spawn(function()
			while scanning do task.wait(0.05) end
			rebuildEnemies()
			toast(string.format(tr("Дронів знайдено: %d (ворожих: %d)"), #droneCache, #enemyList), ACCENT, true)
		end)
	end

	local espFolder = Instance.new("Folder")
	espFolder.Name = "FunModeDroneESP"
	espFolder.Parent = playerGui
	local dEsp = {}

	local function clearEsp()
		for m, e in dEsp do
			e.hl:Destroy()
			e.bb:Destroy()
			dEsp[m] = nil
		end
	end

	local function updateDroneEsp(rootPos)
		if not S.DrEsp then clearEsp() return end
		local seen = {}
		for _, m in enemyList do
			seen[m] = true
			local e = dEsp[m]
			if not e then
				local part = dronePart(m)
				if part then
					local hl = Instance.new("Highlight")
					hl.Adornee = m
					hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
					hl.FillTransparency = 0.5
					hl.Parent = espFolder

					local bb = Instance.new("BillboardGui")
					bb.Adornee = part
					bb.AlwaysOnTop = true
					bb.Size = UDim2.fromOffset(140, 18)
					bb.StudsOffset = Vector3.new(0, 2.5, 0)
					bb.Parent = espFolder

					local t = Instance.new("TextLabel")
					t.Size = UDim2.fromScale(1, 1)
					t.BackgroundTransparency = 1
					t.Font = Enum.Font.GothamBold
					t.TextSize = 13
					t.TextStrokeTransparency = 0.4
					t.Parent = bb

					e = { hl = hl, bb = bb, text = t }
					dEsp[m] = e
				end
			end
			if e then
				local c = colorOf(S.DrEspColor)
				e.hl.FillColor, e.hl.OutlineColor = c, c
				e.text.TextColor3 = c
				e.text.Text = string.format(tr("ДРОН %d ст"), math.floor((dronePos(m) - rootPos).Magnitude))
			end
		end
		for m, e in dEsp do
			if not seen[m] then
				e.hl:Destroy()
				e.bb:Destroy()
				dEsp[m] = nil
			end
		end
	end

	local warnLabel = makeText(UI.gui, UDim2.fromOffset(320, 28), UDim2.new(0.5, 0, 0.16, 0),
		"", 18, Color3.fromRGB(255, 70, 70), FONT_B, Enum.TextXAlignment.Center, true)
	warnLabel.AnchorPoint = Vector2.new(0.5, 0)
	warnLabel.TextStrokeTransparency = 0.4
	warnLabel.Visible = false

	local vig = Instance.new("Frame")
	vig.Size = UDim2.fromScale(1, 1)
	vig.BackgroundTransparency = 1
	vig.Active = false
	vig.Parent = UI.overlay
	local vigStroke = addStroke(vig, Color3.fromRGB(255, 40, 40), 14, 1)

	local espTimer2, lastEvade, lastFire = 0, 0, 0

	RunService:BindToRenderStep("FunModeDrones", Enum.RenderPriority.Camera.Value + 2, function(dt)
		local anyOn = S.DrEsp or S.DrWarn or S.DrAim or S.DrAutoFire or S.DrEvade
		local cam = getCamera()
		local char = player.Character
		local root = getRoot(char)

		if not (anyOn and gateOpen and cam and root) then
			warnLabel.Visible = false
			vigStroke.Transparency = 1
			clearEsp()
			return
		end

		local nameKey = S.DrName .. "|" .. S.DrExclude
		if nameKey ~= lastNameKey then
			lastNameKey = nameKey
			forceScan = true
		end
		if (forceScan or os.clock() - lastScan > 4) and not scanning then
			rescan()
		end
		if os.clock() - lastEnemy > 0.25 then
			lastEnemy = os.clock()
			rebuildEnemies()
		end

		local camPos = cam.CFrame.Position

		local nearest, nearestDist
		for _, m in enemyList do
			if m.Parent then
				local d = (dronePos(m) - root.Position).Magnitude
				if not nearestDist or d < nearestDist then nearest, nearestDist = m, d end
			end
		end

		espTimer2 += dt
		if espTimer2 >= 0.1 then
			espTimer2 = 0
			updateDroneEsp(root.Position)
		end

		if S.DrWarn and nearest and nearestDist <= S.DrWarnRadius then
			warnLabel.Text = string.format(tr("ДРОН %s %d ст"), arrowFor(cam, dronePos(nearest)), math.floor(nearestDist))
			warnLabel.Visible = true
			vigStroke.Transparency = 0.55 + 0.35 * math.sin(os.clock() * 10)
		else
			warnLabel.Visible = false
			vigStroke.Transparency = 1
		end

		local aimActive = S.DrAim and (not S.AimHold or not N.hasMouse or aimHeld)
		if aimActive or S.DrAutoFire then
			local point = getAimPoint()
			local bestPos, bestScore
			for _, m in enemyList do
				if m.Parent then
					local pos = dronePos(m)
					if (pos - camPos).Magnitude <= S.DrAimRange then
						local sp, onScreen = cam:WorldToViewportPoint(pos)
						if onScreen then
							local d2 = (Vector2.new(sp.X, sp.Y) - point).Magnitude
							if not bestScore or d2 < bestScore then
								bestPos, bestScore = pos, d2
							end
						end
					end
				end
			end

			if bestPos then
				if aimActive then
					cam.CFrame = cam.CFrame:Lerp(CFrame.lookAt(camPos, bestPos), math.max(S.Smooth, 0.35))
				end
				if S.DrAutoFire and os.clock() - lastFire > 0.12 then
					local dir = (bestPos - camPos).Unit
					if dir:Dot(cam.CFrame.LookVector) > 0.9962 then
						local tool = char:FindFirstChildOfClass("Tool")
						if tool then
							lastFire = os.clock()
							tool:Activate()
						end
					end
				end
			end
		end

		if S.DrEvade and nearest and nearestDist <= S.DrEvadeRadius
			and os.clock() - lastEvade >= S.DrEvadeCd and isAlive(char) then
			lastEvade = os.clock()
			local dpos = dronePos(nearest)
			local away = Vector3.new(root.Position.X - dpos.X, 0, root.Position.Z - dpos.Z)
			away = away.Magnitude > 0.1 and away.Unit or Vector3.new(1, 0, 0)

			local params = RaycastParams.new()
			params.FilterType = Enum.RaycastFilterType.Exclude
			params.FilterDescendantsInstances = { char }

			for _ = 1, 8 do
				local dir = CFrame.Angles(0, math.rad(math.random(-60, 60)), 0) * away
				local origin = root.Position + dir * S.DrEvadeDist + Vector3.new(0, 40, 0)
				local hit = workspace:Raycast(origin, Vector3.new(0, -150, 0), params)
				if hit and hit.Normal.Y > 0.7 then
					markSelf()
					char:PivotTo(CFrame.new(hit.Position + Vector3.new(0, 4, 0)))
					root.AssemblyLinearVelocity = Vector3.zero
					break
				end
			end
		end
	end)
end)

safeRun("anti-fling", function()
	local afSaved = setmetatable({}, { __mode = "k" })
	local afParts = {}
	local afRefresh = 0
	local flagged = {}
	local lastGood, lastGround = nil, nil
	local lastHum, lastBlock = nil, nil
	local scanT = 0
	local lastNC = nil

	local function refreshParts()
		afRefresh = os.clock()
		local fresh = {}
		for _, plr in Players:GetPlayers() do
			if isPulled(plr.Character) then continue end
			local char = plr.Character
			if plr ~= player and char then
				local parts = {}
				for _, d in char:GetDescendants() do
					if d:IsA("BasePart") then parts[#parts + 1] = d end
				end
				local old = afParts[char]
				fresh[char] = { plr = plr, parts = parts, on = old and old.on or false }
			end
		end
		afParts = fresh
	end

	local function restoreCollisions()
		for part in afSaved do
			if part.Parent then part.CanCollide = true end
			afSaved[part] = nil
		end
	end

	RunService.Stepped:Connect(function()
		local on = S.AntiFling and gateOpen
		local nc = on and S.AfNoCollide

		if lastNC ~= nc then
			lastNC = nc
			restoreCollisions()
			for _, e in afParts do e.on = false end
		end
		if not on then return end

		local now = os.clock()
		if now - afRefresh > 1 then refreshParts() end

		local myRoot = getRoot(player.Character)
		local myPos = myRoot and myRoot.Position

		for char, e in afParts do
			local r = getRoot(char)
			local near = myPos ~= nil and r ~= nil and (r.Position - myPos).Magnitude < 80

			local apply = char.Parent ~= nil and near and (nc or (flagged[e.plr] or 0) > now)
			if apply or e.on then
				for _, part in e.parts do
					if part.Parent then
						if apply then
							if part.CanCollide then
								afSaved[part] = true
								part.CanCollide = false
							end
						elseif afSaved[part] then
							part.CanCollide = true
							afSaved[part] = nil
						end
					end
				end
				e.on = apply and true or false
			end
		end
	end)

	local function applyStates(hum, block)
		pcall(function()
			hum:SetStateEnabled(Enum.HumanoidStateType.FallingDown, not block)
			hum:SetStateEnabled(Enum.HumanoidStateType.Ragdoll, not block)
		end)
	end

	RunService.Heartbeat:Connect(function(dt)
		local on = S.AntiFling and gateOpen

		if not on then
			if lastHum and lastBlock then applyStates(lastHum, false) end
			lastHum, lastBlock = nil, nil
			lastGood, lastGround = nil, nil
			return
		end

		local char = player.Character
		local root, hum = getRoot(char), getHum(char)
		if not (root and hum and hum.Health > 0) then
			lastGood, lastGround = nil, nil
			return
		end

		local wantBlock = S.AfNoRagdoll
		if lastHum ~= hum or lastBlock ~= wantBlock then
			if lastHum and lastHum ~= hum and lastBlock then applyStates(lastHum, false) end
			applyStates(hum, wantBlock)
			lastHum, lastBlock = hum, wantBlock
		end
		if wantBlock then
			local st = hum:GetState()
			if st == Enum.HumanoidStateType.FallingDown or st == Enum.HumanoidStateType.Ragdoll then
				hum:ChangeState(Enum.HumanoidStateType.GettingUp)
			end
		end

		local seated = hum.SeatPart ~= nil
		local vel = root.AssemblyLinearVelocity
		local horiz = Vector3.new(vel.X, 0, vel.Z).Magnitude
		local up = math.max(vel.Y, 0)

		local limit = S.AfSpeed
		if S.Fly then limit = math.max(limit, S.FlyMaxSps * 2.5) end
		if S.Bhop then limit = math.max(limit, S.BhopMax * 3) end
		if S.SpeedOn then limit = math.max(limit, S.Speed * 3) end
		if S.JumpOn then limit = math.max(limit, S.JumpPower * 3) end

		local angBad = root.AssemblyAngularVelocity.Magnitude > S.AfAng and not S.Spin
		local bad = S.AfClamp and not seated and (math.max(horiz, up) > limit or angBad)

		if bad then
			root.AssemblyLinearVelocity = Vector3.zero
			root.AssemblyAngularVelocity = Vector3.zero
			if lastGood then root.CFrame = lastGood end
			defNote("fling", S.AfNotify, "Антифлінг: удар погашено", Color3.fromRGB(255, 160, 80), 2)
		elseif not seated then
			lastGood = root.CFrame
			if hum.FloorMaterial ~= Enum.Material.Air then
				lastGround = root.CFrame + Vector3.new(0, 2, 0)
			end
		else
			lastGood = nil
		end

		if S.AfVoid and lastGround then
			local floorY = workspace.FallenPartsDestroyHeight + 80
			if root.Position.Y < floorY then
				markSelf(0.5)
				root.AssemblyLinearVelocity = Vector3.zero
				root.AssemblyAngularVelocity = Vector3.zero
				char:PivotTo(lastGround)
				defNote("void", S.AfNotify, "Антифлінг: повернено з прірви", Color3.fromRGB(255, 160, 80), 2)
			end
		end

		scanT += dt
		if scanT >= 0.1 then
			scanT = 0
			local now = os.clock()
			for _, plr in Players:GetPlayers() do
				if plr ~= player then
					local r = getRoot(plr.Character)
					if r then
						local ang = r.AssemblyAngularVelocity.Magnitude
						local lin = r.AssemblyLinearVelocity.Magnitude
						if ang > S.AfAng * 1.5 or lin > S.AfSpeed * 2 then
							if (flagged[plr] or 0) < now then
								defNote("fl_" .. plr.UserId, S.AfNotify, "Підозра на fling: %s",
									Color3.fromRGB(255, 120, 80), 4, plr.DisplayName)
							end
							flagged[plr] = now + 6
						end
					end
				end
			end
		end
	end)

	Players.PlayerRemoving:Connect(function(plr) flagged[plr] = nil end)
end)

safeRun("defense", function()
	local defFolder = Instance.new("Folder")
	defFolder.Name = "FunModeDefense"
	defFolder.Parent = playerGui

	local localFolder = Instance.new("Folder")
	localFolder.Name = "FunModeLocal"
	localFolder.Parent = workspace

	local function topLabel(y, color)
		local l = makeText(UI.gui, UDim2.fromOffset(380, 24), UDim2.new(0.5, 0, y, 0), "", 16, color, FONT_B,
			Enum.TextXAlignment.Center, true)
		l.AnchorPoint = Vector2.new(0.5, 0)
		l.TextStrokeTransparency = 0.4
		l.Visible = false
		return l
	end
	local awLabel = topLabel(0.21, Color3.fromRGB(255, 80, 80))
	local tpLabel = topLabel(0.26, Color3.fromRGB(255, 200, 80))

	local track = {}
	local jumpHooks = {}
	local function onEnemyJump(fn) jumpHooks[#jumpHooks + 1] = fn end

	RunService.Heartbeat:Connect(function(dt)
		if not gateOpen or not (S.Counter or S.TpHl) then
			if next(track) ~= nil then table.clear(track) end
			return
		end
		local now = os.clock()
		local base = math.max(15, dt * 250)

		for _, plr in Players:GetPlayers() do
			if isPulled(plr.Character) then continue end
			if plr ~= player then
				local char = plr.Character
				local root = getRoot(char)
				local rec = track[plr]

				if not (root and isAlive(char)) then
					track[plr] = nil
				elseif not rec or rec.root ~= root then
					track[plr] = { root = root, pos = root.Position, born = now }
				else
					local pos = root.Position
					local from = rec.pos
					local jump = (pos - from).Magnitude
					rec.pos = pos
					if jump >= base and now - rec.born > 1 then
						for _, fn in jumpHooks do fn(plr, char, from, pos, jump) end
					end
				end
			end
		end
	end)

	local enemyCd, lastCounter = {}, 0
	local faceChar, faceUntil = nil, 0

	local function trigger(plr, char)
		local now = os.clock()
		if now - lastCounter < S.CtCooldown then return end
		if now - (enemyCd[plr] or 0) < S.CtCooldown * 2 then return end
		lastCounter, enemyCd[plr] = now, now

		local name = plr.DisplayName
		if S.CtMode == 3 then
			toast(string.format(tr("До вас тепнувся: %s"), name), Color3.fromRGB(255, 120, 80), true)
			return
		end

		task.delay(S.CtDelay, function()
			if not (gateOpen and S.Counter) then return end
			if not (isAlive(char) and isAlive(player.Character)) then return end

			if S.CtMode == 1 then
				if teleportNear(char, 1) then
					toast(string.format(tr("Контр-ТП: %s"), name), ACCENT, true)
				end
			else
				toast(string.format(tr("Розворот на: %s"), name), ACCENT, true)
			end
			if S.CtFace then
				faceChar, faceUntil = char, os.clock() + 0.35
			end
		end)
	end

	onEnemyJump(function(plr, char, from, pos, jump)
		if not (S.Counter and gateOpen) or jump < S.CtMinJump or isTeammate(plr) then return end
		local myChar = player.Character
		local myRoot = getRoot(myChar)
		if not (myRoot and isAlive(myChar)) then return end

		local myPos = myRoot.Position
		if (pos - myPos).Magnitude > S.CtRadius or (from - myPos).Magnitude <= S.CtRadius then return end

		if S.CtBehindOnly then
			local cam = getCamera()
			local look = cam and cam.CFrame.LookVector or myRoot.CFrame.LookVector
			local lookFlat = Vector3.new(look.X, 0, look.Z)
			local flat = Vector3.new(pos.X - myPos.X, 0, pos.Z - myPos.Z)
			if flat.Magnitude > 0.1 and lookFlat.Magnitude > 0.1 and lookFlat.Unit:Dot(flat.Unit) >= -0.2 then
				return
			end
		end
		trigger(plr, char)
	end)

	RunService:BindToRenderStep("FunModeCounter", Enum.RenderPriority.Camera.Value + 3, function()
		if faceChar and os.clock() < faceUntil then
			local cam = getCamera()
			local part = faceChar:FindFirstChild("Head") or getRoot(faceChar)
			if cam and part then
				cam.CFrame = cam.CFrame:Lerp(CFrame.lookAt(cam.CFrame.Position, part.Position), 0.55)
			end
		elseif faceChar then
			faceChar = nil
		end
	end)

	local markers = {}
	local tpLabelPlr, tpLabelUntil = nil, 0

	local function clearMarker(plr)
		local m = markers[plr]
		if m then
			for _, o in m.objs do
				if o.Parent then o:Destroy() end
			end
			markers[plr] = nil
		end
	end

	local function showTpMarker(plr, char, pos)
		clearMarker(plr)
		local color = colorOf(S.TpHlColor)
		local objs = {}

		local anchor = Instance.new("Part")
		anchor.Anchored = true
		anchor.CanCollide, anchor.CanQuery, anchor.CanTouch = false, false, false
		anchor.Transparency = 1
		anchor.Size = Vector3.one
		anchor.Position = pos + Vector3.new(0, 4, 0)
		anchor.Parent = localFolder
		objs[#objs + 1] = anchor

		local bb = Instance.new("BillboardGui")
		bb.Adornee = anchor
		bb.AlwaysOnTop = true
		bb.Size = UDim2.fromOffset(170, 36)
		bb.MaxDistance = 1e5
		bb.Parent = defFolder
		objs[#objs + 1] = bb

		local l1 = makeText(bb, UDim2.new(1, 0, 0, 18), UDim2.new(), "" .. plr.DisplayName, 14, color, FONT_B,
			Enum.TextXAlignment.Center, true)
		l1.TextStrokeTransparency = 0.3
		local l2 = makeText(bb, UDim2.new(1, 0, 0, 16), UDim2.fromOffset(0, 18), "", 13, N.C_TEXT, FONT_B,
			Enum.TextXAlignment.Center, true)
		l2.TextStrokeTransparency = 0.3

		local ring = Instance.new("Part")
		ring.Anchored = true
		ring.CanCollide, ring.CanQuery, ring.CanTouch = false, false, false
		ring.Shape = Enum.PartType.Cylinder
		ring.Material = Enum.Material.Neon
		ring.Color = color
		ring.Transparency = 0.25
		ring.Size = Vector3.new(0.2, 2, 2)
		ring.CFrame = CFrame.new(pos - Vector3.new(0, 2.8, 0)) * CFrame.Angles(0, 0, math.rad(90))
		ring.Parent = localFolder
		objs[#objs + 1] = ring
		TweenService:Create(ring, TweenInfo.new(1.1, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
			{ Size = Vector3.new(0.2, 22, 22), Transparency = 1 }):Play()

		local hl = Instance.new("Highlight")
		hl.Adornee = char
		hl.FillColor, hl.OutlineColor = color, color
		hl.FillTransparency = 0.55
		hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
		hl.Parent = defFolder
		objs[#objs + 1] = hl

		markers[plr] = { objs = objs, char = char, born = os.clock(), life = S.TpHlTime, l2 = l2 }
		tpLabelPlr, tpLabelUntil = plr, os.clock() + math.min(S.TpHlTime, 2.5)
		tpLabel.TextColor3 = color
	end

	onEnemyJump(function(plr, char, from, pos, jump)
		if not (S.TpHl and gateOpen) or jump < S.TpHlMin then return end
		if isTeammate(plr) and not S.TpHlTeam then return end
		local myRoot = getRoot(player.Character)
		local dist = myRoot and (pos - myRoot.Position).Magnitude or 0
		if dist > S.TpHlRange then return end
		showTpMarker(plr, char, pos)
	end)

	local function updateMarkers()
		local now = os.clock()
		local cam = getCamera()
		local myRoot = getRoot(player.Character)

		for plr, m in markers do
			if not S.TpHl or not gateOpen or now - m.born > m.life or not m.char.Parent then
				clearMarker(plr)
			else
				local r = getRoot(m.char)
				local d = (myRoot and r) and (r.Position - myRoot.Position).Magnitude or 0
				m.l2.Text = string.format(tr("%d ст"), math.floor(d))
			end
		end

		local shown = false
		if S.TpHl and gateOpen and tpLabelPlr and now < tpLabelUntil and cam and myRoot then
			local r = getRoot(tpLabelPlr.Character)
			if r then
				tpLabel.Text = string.format(tr("ТП: %s %s %d ст"), tpLabelPlr.DisplayName,
					arrowFor(cam, r.Position), math.floor((r.Position - myRoot.Position).Magnitude))
				shown = true
			end
		end
		tpLabel.Visible = shown
	end

	local awRec = {}
	local awParams = RaycastParams.new()
	awParams.FilterType = Enum.RaycastFilterType.Exclude
	local awLast = 0

	local function scanAim()
		local now = os.clock()
		local myChar = player.Character
		local myRoot = getRoot(myChar)
		if not (myRoot and isAlive(myChar)) then
			table.clear(awRec)
			return nil
		end

		local target = myRoot.Position + Vector3.new(0, 1.5, 0)
		local best, bestSince

		for _, plr in Players:GetPlayers() do
			if isPulled(plr.Character) then continue end
			if plr ~= player and (S.AwTeam or not isTeammate(plr)) then
				local char = plr.Character
				local head = char and char:FindFirstChild("Head")
				local root = getRoot(char)
				if root and isAlive(char) then
					local part = head or root
					local origin = part.Position
					local look = part.CFrame.LookVector
					local to = target - origin
					local dist = to.Magnitude
					local hit = false

					if dist >= 3 and dist <= S.AwRange then
						local allowed = math.max(S.AwAngle, math.deg(math.atan(1.5 / dist)))
						local ang = math.deg(math.acos(math.clamp(look:Dot(to / dist), -1, 1)))
						hit = ang <= allowed
						if hit and S.AwWall then
							awParams.FilterDescendantsInstances = { char, myChar }
							hit = workspace:Raycast(origin, to, awParams) == nil
						end
					end

					local rec = awRec[plr]
					if hit then
						if not rec then
							rec = { since = now, last = now }
							awRec[plr] = rec
						end
						rec.last = now
						if now - rec.since >= S.AwTime and (not bestSince or rec.since < bestSince) then
							best, bestSince = { plr = plr, pos = origin, dist = dist }, rec.since
						end
					elseif rec and now - rec.last > 0.25 then
						awRec[plr] = nil
					end
				else
					awRec[plr] = nil
				end
			end
		end
		return best
	end

	local function updateAimWarn()
		local best = (S.AimWarn and gateOpen) and scanAim() or nil
		local cam = getCamera()
		if best and cam then
			awLabel.Text = string.format(tr("ПРИЦІЛ НА ВАС: %s %s %d ст"), best.plr.DisplayName,
				arrowFor(cam, best.pos), math.floor(best.dist))
			awLabel.TextTransparency = 0.05 + 0.3 * (0.5 + 0.5 * math.sin(os.clock() * 12))
			awLabel.Visible = true
			awLast = os.clock()
		elseif os.clock() - awLast > 0.3 then
			awLabel.Visible = false
		end
	end

	local suspRec = {}

	local function lookOf(char)
		local h = char:FindFirstChild("Head") or getRoot(char)
		return h, h and h.CFrame.LookVector
	end

	local function snappedOnTarget(plr, origin, prevLook, curLook)
		for _, other in Players:GetPlayers() do
			if other ~= plr then
				local oc = other.Character
				local part = oc and (oc:FindFirstChild("Head") or getRoot(oc))
				if part and isAlive(oc) then
					local to = part.Position - origin
					local d = to.Magnitude
					if d >= 5 and d <= 700 then
						local dir = to / d
						local err = math.deg(math.acos(math.clamp(curLook:Dot(dir), -1, 1)))
						if err <= 2.5 then
							local prevErr = math.deg(math.acos(math.clamp(prevLook:Dot(dir), -1, 1)))
							if prevErr >= 25 then return true end
						end
					end
				end
			end
		end
		return false
	end

	local function removeTag(rec)
		if rec.tag then
			rec.tag:Destroy()
			rec.tag = nil
		end
	end

	RunService.Heartbeat:Connect(function()
		if not (gateOpen and S.Susp) then return end
		local now = os.clock()
		for _, plr in Players:GetPlayers() do
			if isPulled(plr.Character) then continue end
			if plr ~= player then
				local char = plr.Character
				local head, look
				if char then head, look = lookOf(char) end
				if char and head and look and isAlive(char) then
					local rec = suspRec[plr]
					if not rec then
						rec = { score = 0, lastEvent = 0, decayT = now }
						suspRec[plr] = rec
					end
					if rec.look and rec.head == head then
						local ang = math.deg(math.acos(math.clamp(rec.look:Dot(look), -1, 1)))
						if ang >= S.SuspSnap and now - rec.lastEvent > 0.5
							and snappedOnTarget(plr, head.Position, rec.look, look) then
							rec.score += 1
							rec.lastEvent, rec.decayT = now, now
							if rec.score >= S.SuspThreshold and not rec.notified then
								rec.notified = true
								defNote("susp_" .. plr.UserId, S.SuspNotify, "Підозра на аімбот: %s",
									Color3.fromRGB(255, 90, 90), 15, plr.DisplayName)
							end
						end
					end
					rec.look, rec.head = look, head
				end
			end
		end
	end)

	refreshSuspInfo = function()
		if not suspInfoLabel then return end
		local list = {}
		for plr, rec in suspRec do
			if rec.score > 0 then
				list[#list + 1] = { name = plr.DisplayName, score = rec.score, flagged = rec.score >= S.SuspThreshold }
			end
		end
		table.sort(list, function(a, b) return a.score > b.score end)

		local lines = {}
		for i = 1, math.min(#list, 5) do
			local e = list[i]
			lines[#lines + 1] = string.format("%s%s  ×%d", e.flagged and "! " or "   ", e.name, e.score)
		end
		suspInfoLabel.Text = tr("Підозрілі") .. ":\n" .. (#lines > 0 and table.concat(lines, "\n") or tr("немає"))
	end

	task.spawn(function()
		while true do
			task.wait(1)
			local now = os.clock()
			for plr, rec in suspRec do
				if plr.Parent ~= Players then
					removeTag(rec)
					suspRec[plr] = nil
				else
					if rec.score > 0 and now - rec.decayT >= 20 then
						rec.score -= 1
						rec.decayT = now
					end
					local flagged = rec.score >= S.SuspThreshold
					if not flagged then rec.notified = false end

					local head = plr.Character and plr.Character:FindFirstChild("Head")
					if flagged and S.Susp and S.SuspTags and gateOpen and head then
						if not rec.tag or not rec.tag.Parent or rec.tag.Adornee ~= head then
							removeTag(rec)
							local bb = Instance.new("BillboardGui")
							bb.Adornee = head
							bb.AlwaysOnTop = true
							bb.Size = UDim2.fromOffset(90, 20)
							bb.StudsOffset = Vector3.new(0, 2.8, 0)
							bb.Parent = defFolder
							local l = makeText(bb, UDim2.fromScale(1, 1), UDim2.new(), "AIM?", 14,
								Color3.fromRGB(255, 90, 90), FONT_B, Enum.TextXAlignment.Center, true)
							l.TextStrokeTransparency = 0.3
							rec.tag = bb
						end
					else
						removeTag(rec)
					end
				end
			end
			refreshSuspInfo()
		end
	end)

	local VEHICLE_WORDS = {
		"vehicle", "car", "tank", "truck", "jeep", "heli", "boat", "bike", "apc", "buggy",
		"транспорт", "машин", "танк", "авто", "вертол", "човен",
	}

	local function isVehicleSeat(seat)
		if seat:IsA("VehicleSeat") then return true end
		local m = seat
		while m and m ~= workspace do
			if N.CollectionService:HasTag(m, "Vehicle") then return true end
			local n = string.lower(m.Name)
			for _, w in VEHICLE_WORDS do
				if string.find(n, w, 1, true) then return true end
			end
			m = m.Parent
		end
		return false
	end

	local function seatOwnerPlayer(seat)
		local model = seat:FindFirstAncestorOfClass("Model")
		while model do
			local plr = Players:GetPlayerFromCharacter(model)
			if plr then return plr end
			local parent = model.Parent
			model = parent and parent:FindFirstAncestorOfClass("Model") or nil
		end
		return nil
	end

	local function forcedSeat(seat)
		if S.SitMode == 3 then return true end
		if S.SitMode == 2 then return not isVehicleSeat(seat) end

		local owner = seatOwnerPlayer(seat)
		if owner and owner ~= player then return true end
		if not isVehicleSeat(seat) and seat.AssemblyLinearVelocity.Magnitude > S.SitSpeed then return true end
		return false
	end

	local groundCF, airSince = nil, nil
	local flickPrev, flickRoot = nil, nil
	local lastUnsit = 0

	RunService.Heartbeat:Connect(function(dt)
		if not gateOpen then return end
		local now = os.clock()
		local char = player.Character
		local root, hum = getRoot(char), getHum(char)

		if not (root and hum and hum.Health > 0) then
			groundCF, airSince, flickPrev, flickRoot = nil, nil, nil, nil
			return
		end
		if flickRoot ~= root then
			flickRoot, flickPrev, groundCF, airSince = root, nil, nil, nil
		end

		local pos = root.Position
		local vel = root.AssemblyLinearVelocity
		local seat = hum.SeatPart

		if S.AntiSit and seat and now - lastUnsit > 0.4 and forcedSeat(seat) then
			lastUnsit = now
			hum.Sit = false
			hum:ChangeState(Enum.HumanoidStateType.Jumping)
			local weld = seat:FindFirstChild("SeatWeld")
			if weld then pcall(function() weld:Destroy() end) end
			defNote("sit", S.SitNotify, "Анти-сидіння: вас зняли з сидіння", Color3.fromRGB(255, 160, 80), 2)
			seat = nil
		end

		local grounded = hum.FloorMaterial ~= Enum.Material.Air
		if grounded or seat then
			airSince = nil
			if grounded and not seat and vel.Y > -20 then groundCF = root.CFrame end
		else
			airSince = airSince or now
		end

		if S.AntiFall and groundCF and not seat and not S.Fly and now > selfMoveUntil then
			local h = pos.Y - groundCF.Position.Y
			local airTime = airSince and (now - airSince) or 0
			local ownLift = S.JumpOn or S.InfJump
			local tooHigh = (not ownLift) and airTime > 0.8 and h > S.FallHeight
			local tooFast = (not S.GravityOn) and vel.Y < -S.FallSpeed and h > 60
			if tooHigh or tooFast then
				markSelf(0.5)
				root.AssemblyLinearVelocity = Vector3.zero
				root.AssemblyAngularVelocity = Vector3.zero
				char:PivotTo(groundCF + Vector3.new(0, 3, 0))
				airSince, flickPrev = nil, nil
				defNote("fall", S.FallNotify, "Анти-падіння: повернуто на землю", Color3.fromRGB(255, 160, 80), 2)
				return
			end
		end

		local reverted = false
		if S.AntiFlick and flickPrev and not seat and now - charBorn > 2 and now > selfMoveUntil then
			local d = (pos - flickPrev).Magnitude
			local limit = math.max(S.FlickDist, (vel.Magnitude + 100) * dt * 2)
			if d >= limit then
				local near = not S.FlickEnemyOnly
				if not near then
					for _, plr in Players:GetPlayers() do
						if plr ~= player and not isTeammate(plr) then
							local r = getRoot(plr.Character)
							if r and ((r.Position - pos).Magnitude <= 40 or (r.Position - flickPrev).Magnitude <= 40) then
								near = true
								break
							end
						end
					end
				end
				if near then
					if S.FlickRevert then
						markSelf(0.5)
						root.AssemblyLinearVelocity = Vector3.zero
						char:PivotTo(CFrame.new(flickPrev) * root.CFrame.Rotation)
						reverted = true
						defNote("flick", true, "Анти-ТП-флік: повернуто назад", Color3.fromRGB(255, 160, 80), 2)
					else
						defNote("flick", true, "Анти-ТП-флік: вас перемістили", Color3.fromRGB(255, 160, 80), 2)
					end
				end
			end
		end
		if not reverted then flickPrev = pos end
	end)

	local abSaved = setmetatable({}, { __mode = "k" })
	local guiSaved, guiConns = {}, {}

	local function clampProp(inst, prop, limit, isMax)
		local cur = inst[prop]
		if (isMax and cur > limit) or ((not isMax) and cur < limit) then
			local s = abSaved[inst]
			if not s then
				s = {}
				abSaved[inst] = s
			end
			if s[prop] == nil then s[prop] = cur end
			inst[prop] = limit
			return true
		end
		return false
	end

	local function clampEffects(container)
		local changed = false
		for _, inst in container:GetChildren() do
			if inst:IsA("BlurEffect") then
				changed = clampProp(inst, "Size", S.AbBlur, true) or changed
			elseif inst:IsA("ColorCorrectionEffect") then
				changed = clampProp(inst, "Brightness", S.AbBright, true) or changed
				changed = clampProp(inst, "Brightness", -0.8, false) or changed
			elseif inst:IsA("BloomEffect") then
				changed = clampProp(inst, "Intensity", S.AbBright * 4, true) or changed
			elseif inst:IsA("SunRaysEffect") then
				changed = clampProp(inst, "Intensity", 0.4, true) or changed
			elseif inst:IsA("Atmosphere") then
				changed = clampProp(inst, "Density", 0.6, true) or changed
				changed = clampProp(inst, "Haze", 6, true) or changed
			end
		end
		return changed
	end

	local function restoreEffects()
		for inst, props in abSaved do
			if inst.Parent then
				for prop, v in props do
					pcall(function() inst[prop] = v end)
				end
			end
			abSaved[inst] = nil
		end
	end

	local function restoreGui()
		for inst, s in guiSaved do
			if inst.Parent then pcall(function() inst[s.prop] = s.value end) end
			if guiConns[inst] then guiConns[inst]:Disconnect() end
			guiConns[inst] = nil
			guiSaved[inst] = nil
		end
	end

	local function guiIgnored(inst)
		local sg = inst:FindFirstAncestorOfClass("ScreenGui")
		if not sg then return true end
		if string.sub(sg.Name, 1, 7) == "FunMode" then return true end
		local lname = string.lower(sg.Name)
		for token in string.gmatch(string.lower(S.AbIgnore), "[^,;]+") do
			token = string.gsub(token, "^%s+", "")
			token = string.gsub(token, "%s+$", "")
			if token ~= "" and string.find(lname, token, 1, true) then return true end
		end
		return false
	end

	local function checkGui(inst)
		if not (S.AntiBlind and S.AbGui and gateOpen) then return end
		if not inst.Parent or guiSaved[inst] then return end
		if os.clock() - charBorn < 3 then return end

		local cam = getCamera()
		if not cam then return end
		local isFrame = inst:IsA("Frame")
		local isImg = inst:IsA("ImageLabel")
		if not (isFrame or isImg) then return end

		local vp, sz = cam.ViewportSize, inst.AbsoluteSize
		if sz.X < vp.X * 0.8 or sz.Y < vp.Y * 0.8 then return end
		if guiIgnored(inst) then return end

		local c, t, prop
		if isFrame then
			c, t, prop = inst.BackgroundColor3, inst.BackgroundTransparency, "BackgroundTransparency"
		else
			c, t, prop = inst.ImageColor3, inst.ImageTransparency, "ImageTransparency"
		end
		if (c.R + c.G + c.B) / 3 < 0.82 or t > 0.6 then return end

		guiSaved[inst] = { prop = prop, value = t }
		inst[prop] = 0.93
		guiConns[inst] = inst:GetPropertyChangedSignal(prop):Connect(function()
			if S.AntiBlind and S.AbGui and gateOpen and inst[prop] < 0.93 then
				inst[prop] = 0.93
			end
		end)
		defNote("blind", S.AfNotify, "Анти-сліпота: ефект приглушено", Color3.fromRGB(255, 160, 80), 3)
	end

	playerGui.DescendantAdded:Connect(function(inst)
		if S.AntiBlind and S.AbGui and (inst:IsA("Frame") or inst:IsA("ImageLabel")) then
			task.delay(0.05, checkGui, inst)
		end
	end)

	local function blindTick()
		if S.AntiBlind and gateOpen then
			local c1 = clampEffects(Lighting)
			local cam = getCamera()
			local c2 = cam and clampEffects(cam) or false
			if c1 or c2 then
				defNote("blind", S.AfNotify, "Анти-сліпота: ефект приглушено", Color3.fromRGB(255, 160, 80), 3)
			end
		elseif next(abSaved) ~= nil then
			restoreEffects()
		end
		if not (S.AntiBlind and S.AbGui and gateOpen) and next(guiSaved) ~= nil then
			restoreGui()
		end
	end

	local slowT = 0
	RunService.Heartbeat:Connect(function(dt)
		slowT += dt
		if slowT < 0.1 then return end
		slowT = 0
		updateMarkers()
		updateAimWarn()
		blindTick()
	end)

	Players.PlayerRemoving:Connect(function(plr)
		track[plr], enemyCd[plr], awRec[plr] = nil, nil, nil
		clearMarker(plr)
		local rec = suspRec[plr]
		if rec then
			removeTag(rec)
			suspRec[plr] = nil
		end
	end)
end)

safeRun("safe-spot", function()
	local SAFE_COLOR = Color3.fromRGB(80, 220, 140)

	local folder = Instance.new("Folder")
	folder.Name = "FunModeSafe"
	folder.Parent = workspace

	local objs = {}
	local label
	local lastGo = 0

	local function clearMarker()
		for _, o in objs do
			if o.Parent then o:Destroy() end
		end
		objs, label = {}, nil
	end

	local function newPart(size, cf, transparency, shape)
		local p = Instance.new("Part")
		p.Anchored = true
		p.CanCollide, p.CanQuery, p.CanTouch = false, false, false
		p.CastShadow = false
		p.Material = Enum.Material.Neon
		p.Color = SAFE_COLOR
		p.Transparency = transparency
		if shape then p.Shape = shape end
		p.Size = size
		p.CFrame = cf
		p.Parent = folder
		objs[#objs + 1] = p
		return p
	end

	local function buildMarker(groundPos)
		clearMarker()

		local ring = newPart(Vector3.new(0.2, 7, 7),
			CFrame.new(groundPos + Vector3.new(0, 0.15, 0)) * CFrame.Angles(0, 0, math.rad(90)),
			0.2, Enum.PartType.Cylinder)
		TweenService:Create(ring,
			TweenInfo.new(1.1, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true),
			{ Transparency = 0.75 }):Play()

		local pillar = newPart(Vector3.new(0.5, 26, 0.5),
			CFrame.new(groundPos + Vector3.new(0, 13, 0)), 0.55)

		local bb = Instance.new("BillboardGui")
		bb.Adornee = pillar
		bb.AlwaysOnTop = true
		bb.Size = UDim2.fromOffset(150, 20)
		bb.StudsOffset = Vector3.new(0, 15, 0)
		bb.MaxDistance = 1e5
		bb.Parent = pillar
		label = makeText(bb, UDim2.fromScale(1, 1), UDim2.new(), "SAFE", 14, SAFE_COLOR, FONT_B,
			Enum.TextXAlignment.Center, true)
		label.TextStrokeTransparency = 0.3
	end

	local function findGround(root, char)
		local params = RaycastParams.new()
		params.FilterType = Enum.RaycastFilterType.Exclude
		params.FilterDescendantsInstances = { char, folder }
		local hit = workspace:Raycast(root.Position + Vector3.new(0, 2, 0), Vector3.new(0, -300, 0), params)
		return hit and hit.Position or nil
	end

	local WARN = Color3.fromRGB(255, 160, 80)

	Safe.create = function()
		local char = player.Character
		local root, hum = getRoot(char), getHum(char)
		if not (root and hum and hum.Health > 0) then
			toast(tr("Немає живого персонажа"), WARN, true)
			return
		end
		local ground = findGround(root, char)
		if not ground then
			toast(tr("Не вдалося: під вами немає землі"), WARN, true)
			return
		end

		local lift
		if hum.FloorMaterial ~= Enum.Material.Air then
			lift = root.Position.Y - ground.Y + 0.4
		elseif hum.RigType == Enum.HumanoidRigType.R6 then
			lift = 3.4
		else
			lift = hum.HipHeight + root.Size.Y / 2 + 0.4
		end

		Safe.cf = CFrame.new(ground + Vector3.new(0, lift, 0)) * root.CFrame.Rotation
		buildMarker(ground)
		applyVisuals()
		toast(tr("Безпечне місце створено"), SAFE_COLOR, true)
	end

	Safe.go = function()
		if not Safe.cf then
			toast(tr("Спершу створіть безпечне місце"), WARN, true)
			return
		end
		local char = player.Character
		local root, hum = getRoot(char), getHum(char)
		if not (root and hum and hum.Health > 0) then return end
		if os.clock() - lastGo < 0.4 then return end
		lastGo = os.clock()

		if hum.SeatPart then hum.Sit = false end
		markSelf(0.9)
		root.AssemblyLinearVelocity = Vector3.zero
		root.AssemblyAngularVelocity = Vector3.zero
		char:PivotTo(Safe.cf)
		toast(tr("ТП у безпечне місце"), SAFE_COLOR, true)
	end

	Safe.delete = function()
		if not Safe.cf then return end
		Safe.cf = nil
		clearMarker()
		applyVisuals()
		toast(tr("Безпечне місце видалено"), N.C_DIM, true)
	end

	task.spawn(function()
		while true do
			task.wait(0.2)
			local want = gateOpen and workspace or nil
			if folder.Parent ~= want then folder.Parent = want end
			if label and Safe.cf then
				local root = getRoot(player.Character)
				if root then
					label.Text = string.format(tr("SAFE · %d ст"), math.floor((root.Position - Safe.cf.Position).Magnitude))
				end
			end
		end
	end)
end)

safeRun("visuals", function()
	local overlay = UI.overlay
	local folder = Instance.new("Folder")
	folder.Name = "FunModeVisuals"
	folder.Parent = overlay

	local pool = {}
	local rp = RaycastParams.new()
	rp.FilterType = Enum.RaycastFilterType.Exclude

	local function mkFrame(parent)
		local f = Instance.new("Frame")
		f.BorderSizePixel = 0
		f.Visible = false
		f.Parent = parent
		return f
	end

	local function create()
		local e = {}
		e.box = mkFrame(folder)
		e.box.BackgroundTransparency = 1
		e.stroke = Instance.new("UIStroke")
		e.stroke.Parent = e.box
		e.barBg = mkFrame(folder)
		e.barBg.BackgroundColor3 = Color3.fromRGB(15, 15, 15)
		e.barFill = mkFrame(e.barBg)
		e.barFill.AnchorPoint = Vector2.new(0, 1)
		e.barFill.Position = UDim2.fromScale(0, 1)
		e.tracer = mkFrame(folder)
		e.tracer.AnchorPoint = Vector2.new(0.5, 0.5)
		e.dot = mkFrame(folder)
		e.dot.AnchorPoint = Vector2.new(0.5, 0.5)
		corner(e.dot, 9999)
		e.arrow = Instance.new("TextLabel")
		e.arrow.AnchorPoint = Vector2.new(0.5, 0.5)
		e.arrow.Size = UDim2.fromOffset(28, 28)
		e.arrow.BackgroundTransparency = 1
		e.arrow.Text = ">"
		e.arrow.Font = FONT_B
		e.arrow.TextSize = 24
		e.arrow.TextStrokeTransparency = 0.3
		e.arrow.Visible = false
		e.arrow.Parent = folder
		return e
	end

	local function hide(e)
		e.box.Visible, e.barBg.Visible, e.tracer.Visible, e.dot.Visible, e.arrow.Visible = false, false, false, false, false
	end

	local function destroy(char)
		local e = pool[char]
		if e then
			for _, o in { e.box, e.barBg, e.tracer, e.dot, e.arrow } do o:Destroy() end
			pool[char] = nil
		end
	end

	RunService:BindToRenderStep("FunModeVisuals", Enum.RenderPriority.Camera.Value + 4, function()
		local cam = getCamera()
		local any = S.EspBox or S.EspTracer or S.EspHead or S.EspArrows
		if not (gateOpen and cam and any) then
			for char in pool do destroy(char) end
			return
		end

		local vp = cam.ViewportSize
		local center = vp / 2
		local myChar = player.Character
		rp.FilterDescendantsInstances = myChar and { myChar } or {}
		local camPos = cam.CFrame.Position
		local seen = {}

		local list = collect(false)
		if S.EspNPC and not S.IncludeNPCs then
			for _, c in npcList do
				if c.Parent then list[#list + 1] = { char = c } end
			end
		end
		for _, t in list do
			local char, plr = t.char, t.plr
			local hum, root = getHum(char), getRoot(char)
			if hum and root and hum.Health > 0 and (plr or S.EspNPC) and char:IsDescendantOf(workspace) and not (S.EspHideTeam and isTeammate(plr)) then
				local dist = (root.Position - camPos).Magnitude
				if not (S.EspMaxDist < 5000 and dist > S.EspMaxDist) then
					seen[char] = true
					local e = pool[char]
					if not e then e = create() pool[char] = e end

					local color3 = nil
					if S.EspVisCheck then
						local head = char:FindFirstChild("Head") or root
						local h = workspace:Raycast(camPos, head.Position - camPos, rp)
						local visible = h == nil or h.Instance:IsDescendantOf(char)
						color3 = visible and Color3.fromRGB(60, 255, 90) or Color3.fromRGB(255, 60, 60)
					end

					local headPart = char:FindFirstChild("Head")
					local up = Vector3.new(0, 1, 0)
					local topPos = (headPart and headPart.Position or root.Position + up * 2) + up * ((headPart and headPart.Size.Y / 2 or 0.5) + 0.15)
					local feet = hum.RigType == Enum.HumanoidRigType.R6 and 3 or (hum.HipHeight + root.Size.Y / 2)
					local botPos = root.Position - up * (feet + 0.1)
					local tsp, tOn = cam:WorldToViewportPoint(topPos)
					local bsp, bOn = cam:WorldToViewportPoint(botPos)
					local rootSp, rootOn = cam:WorldToViewportPoint(root.Position)
					local onScreen = tsp.Z > 0 and bsp.Z > 0 and rootSp.Z > 0 and (tOn or bOn or rootOn)
					local minX, minY, maxX, maxY = 0, 0, 0, 0
					if onScreen then
						local h = math.max(bsp.Y - tsp.Y, 4)
						local w = h * 0.55
						minX, maxX = rootSp.X - w / 2, rootSp.X + w / 2
						minY, maxY = tsp.Y, tsp.Y + h
					end
					local frac = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)

					if S.EspBox and onScreen then
						e.box.Visible = true
						e.box.Position = UDim2.fromOffset(minX, minY)
						e.box.Size = UDim2.fromOffset(maxX - minX, maxY - minY)
						e.stroke.Thickness = S.EspBoxThick
						e.stroke.Color = color3 or colorOf(S.EspBoxColor)
						if S.EspBar then
							local h = maxY - minY
							e.barBg.Visible = true
							e.barBg.Position = UDim2.fromOffset(minX - 6, minY)
							e.barBg.Size = UDim2.fromOffset(3, h)
							e.barFill.Visible = true
							e.barFill.Size = UDim2.fromScale(1, frac)
							e.barFill.BackgroundColor3 = Color3.fromRGB(255, 60, 60):Lerp(Color3.fromRGB(60, 255, 90), frac)
						else
							e.barBg.Visible = false
						end
					else
						e.box.Visible, e.barBg.Visible = false, false
					end

					if S.EspTracer and onScreen then
						local from
						if S.EspTracerFrom == 1 then from = Vector2.new(vp.X / 2, vp.Y)
						elseif S.EspTracerFrom == 2 then from = center
						else from = getAimPoint() end
						local to = Vector2.new((minX + maxX) / 2, maxY)
						local diff = to - from
						e.tracer.Visible = true
						e.tracer.Size = UDim2.fromOffset(diff.Magnitude, 1)
						e.tracer.Position = UDim2.fromOffset((from.X + to.X) / 2, (from.Y + to.Y) / 2)
						e.tracer.Rotation = math.deg(math.atan2(diff.Y, diff.X))
						e.tracer.BackgroundColor3 = color3 or colorOf(S.EspTracerColor)
					else
						e.tracer.Visible = false
					end

					if S.EspHead and headPart then
						local hsp, hon = cam:WorldToViewportPoint(headPart.Position)
						if hon and hsp.Z > 0 then
							local r = math.clamp(300 / math.max(hsp.Z, 1), 3, 10)
							e.dot.Visible = true
							e.dot.Size = UDim2.fromOffset(r * 2, r * 2)
							e.dot.Position = UDim2.fromOffset(hsp.X, hsp.Y)
							e.dot.BackgroundColor3 = color3 or colorOf(S.EspHeadColor)
						else
							e.dot.Visible = false
						end
					else
						e.dot.Visible = false
					end

					if S.EspArrows and not onScreen then
						local rel = cam.CFrame:PointToObjectSpace(root.Position)
						local dir = Vector2.new(rel.X, rel.Z)
						if dir.Magnitude > 0.001 then
							dir = dir.Unit
							local radius = math.min(vp.X, vp.Y) * 0.38
							e.arrow.Visible = true
							e.arrow.Position = UDim2.fromOffset(center.X + dir.X * radius, center.Y + dir.Y * radius)
							e.arrow.Rotation = math.deg(math.atan2(dir.Y, dir.X))
							e.arrow.TextColor3 = color3 or colorOf(S.EspArrowColor)
						else
							e.arrow.Visible = false
						end
					else
						e.arrow.Visible = false
					end
				end
			end
		end

		for char in pool do
			if not seen[char] or not char.Parent then destroy(char) end
		end
	end)
end)

safeRun("cheat-scanner", function()
	local FLAG_TEXT = { speed = "SPEED", fly = "FLY", noclip = "NOCLIP", spin = "SPIN", hitbox = "HITBOX", invis = "INVIS", lag = "LAG" }
	local FLAG_KEY = { speed = "DtSpeed", fly = "DtFly", noclip = "DtNoclip", spin = "DtSpin", hitbox = "DtHitbox", invis = "DtInvis", lag = "DtLag" }
	local FLAG_ORDER = { "speed", "fly", "noclip", "spin", "hitbox", "invis", "lag" }
	local RED = Color3.fromRGB(255, 90, 90)
	local folder = Instance.new("Folder")
	folder.Name = "FunModeScan"
	folder.Parent = playerGui

	local recs = {}
	local rp = RaycastParams.new()
	rp.FilterType = Enum.RaycastFilterType.Exclude

	local function newRec()
		return { fc = {}, dec = {}, notified = {}, speedT = 0, flyT = 0, spinT = 0, stillT = 0, nc = {}, invisT = 0, skipUntil = 0 }
	end

	local quietUntil, lastFrame, myLastPos = 0, os.clock(), nil
	local StatsService = game:GetService("Stats")

	local function hit(plr, rec, flag, now)
		if now < quietUntil then return end
		if now - (rec.lastHit and rec.lastHit[flag] or 0) < 1.2 then return end
		rec.lastHit = rec.lastHit or {}
		rec.lastHit[flag] = now
		rec.fc[flag] = (rec.fc[flag] or 0) + 1
		rec.dec[flag] = now
		if rec.fc[flag] >= S.DtThreshold and not rec.notified[flag] then
			rec.notified[flag] = true
			defNote("scan_" .. plr.UserId .. flag, S.DtNotify, "Підозра (%s): %s", RED, 10, FLAG_TEXT[flag], plr.DisplayName)
		end
	end

	local function flagged(rec, flag)
		return (rec.fc[flag] or 0) >= S.DtThreshold and S[FLAG_KEY[flag]]
	end

	local function removeGui(rec)
		if rec.tag then rec.tag:Destroy() rec.tag = nil end
		if rec.mark then rec.mark:Destroy() rec.mark = nil end
	end

	local function stateIs(hum, ...)
		local ok, st = pcall(function() return hum:GetState() end)
		if not ok then return false end
		for _, e in { ... } do
			if st == e then return true end
		end
		return false
	end

	local vrp = RaycastParams.new()
	vrp.FilterType = Enum.RaycastFilterType.Exclude
	vrp.RespectCanCollide = true

	RunService:BindToRenderStep("FunModeFreeze", Enum.RenderPriority.Camera.Value + 5, function()
		if not (S.DtFreeze and gateOpen) then return end
		local now = os.clock()
		for plr, rec in recs do
			if rec.freezeUntil and rec.freezePivot then
				local char = plr.Character
				if now < rec.freezeUntil and char and char.Parent and rec.char == char then
					pcall(function()
						char:PivotTo(rec.freezePivot)
						char:SetAttribute("ZenithLocalMove", os.clock() + 2)
					end)
				else
					rec.freezeUntil, rec.freezePivot = nil, nil
				end
			end
		end
	end)

	local lastStep = 0
	RunService.Heartbeat:Connect(function()
		if not gateOpen or splashActive then return end
		local now = os.clock()
		local frameGap = now - lastFrame
		lastFrame = now
		if frameGap > 0.25 then quietUntil = now + 2 end
		local dt = now - lastStep
		if dt < 0.05 then return end
		lastStep = now
		local myChar = player.Character

		do
			local myRoot = getRoot(myChar)
			if myRoot then
				if myLastPos and (myRoot.Position - myLastPos).Magnitude > 50 then quietUntil = now + 2 end
				myLastPos = myRoot.Position
			end
			local okP, ping = pcall(function() return StatsService.Network.ServerStatsItem["Data Ping"]:GetValue() end)
			if okP and ping and ping > 350 then quietUntil = math.max(quietUntil, now + 1) end
		end
		local quiet = now < quietUntil
		local camNow = getCamera()

		for _, plr in Players:GetPlayers() do
			if isPulled(plr.Character) then
				local r = recs[plr]
				if r then r.pos, r.skipUntil = nil, os.clock() + 1.5 end
				continue
			end
			if plr ~= player then
				local char = plr.Character
				local root, hum = getRoot(char), getHum(char)
				local rec = recs[plr]
				if not rec then rec = newRec() recs[plr] = rec end

				if root and hum and hum.Health > 0 and char.Parent then
					local pos = root.Position
					local far = camNow and (camNow.CFrame.Position - pos).Magnitude > 350
					if quiet or far then rec.pos = nil end
					if rec.char ~= char then

						rec.char, rec.pos, rec.yaw = char, nil, nil
						rec.speedT, rec.flyT, rec.spinT, rec.stillT, rec.invisT = 0, 0, 0, 0, 0
						rec.skipUntil = now + 3
					end

					if rec.pos then
						local pdt = now - rec.t
						local delta = pos - rec.pos
						local dist = delta.Magnitude

						if dist > 60 then rec.skipUntil = now + 1.5 end
						local skip = now < rec.skipUntil
						local seated = hum.SeatPart ~= nil or hum.Sit
						local airborne = hum.FloorMaterial == Enum.Material.Air

						if not skip and pdt > 0 then

							local physical = stateIs(hum, Enum.HumanoidStateType.PlatformStanding, Enum.HumanoidStateType.FallingDown,
								Enum.HumanoidStateType.Physics, Enum.HumanoidStateType.Ragdoll, Enum.HumanoidStateType.GettingUp)
							if physical or char:FindFirstChildOfClass("ForceField") then rec.skipUntil = now + 1 end
							if S.DtSpeed and not seated and not airborne and not physical then
								local hs = Vector2.new(delta.X, delta.Z).Magnitude / pdt
								if hs > S.DtSpeedMax or (hs > 35 and hs > hum.WalkSpeed * 2.2) then
									rec.speedT += pdt
									if rec.speedT >= 0.6 then rec.speedT = 0 hit(plr, rec, "speed", now) end
								else
									rec.speedT = math.max(rec.speedT - pdt, 0)
								end
							end

							if S.DtFly and not seated and airborne and math.abs(delta.Y) / pdt < 3
								and not stateIs(hum, Enum.HumanoidStateType.Climbing, Enum.HumanoidStateType.Swimming,
									Enum.HumanoidStateType.Seated, Enum.HumanoidStateType.Ragdoll, Enum.HumanoidStateType.Dead) then
								rec.flyT += pdt
								if rec.flyT >= S.DtFlyTime then rec.flyT = 0 hit(plr, rec, "fly", now) end
							else
								rec.flyT = 0
							end

							if S.DtNoclip and dist > 0.8 and dist < 40 then
								rp.FilterDescendantsInstances = myChar and { char, myChar } or { char }
								local r = workspace:Raycast(rec.pos, delta, rp)
								if r and r.Instance.CanCollide and r.Instance.Transparency < 1
									and (r.Instance:IsA("Terrain") or r.Instance.Size.Magnitude > 6) then
									local list = rec.nc
									list[#list + 1] = now
									while #list > 0 and now - list[1] > 4 do table.remove(list, 1) end
									if #list >= 3 then rec.nc = {} hit(plr, rec, "noclip", now) end
								end
							end

							if S.DtLag then
								if dist < 0.05 then
									rec.stillT += pdt
								else
									if rec.stillT > 1 and dist > 12 and dist < 60 then hit(plr, rec, "lag", now) end
									rec.stillT = 0
								end
							end

							if S.DtSpin and rec.yaw then
								local look = root.CFrame.LookVector
								local yaw = math.atan2(-look.X, -look.Z)
								local d = math.abs((yaw - rec.yaw + math.pi) % (2 * math.pi) - math.pi)
								if d / pdt > S.DtSpinRate and dist / pdt < 40 then
									rec.spinT += pdt
									if rec.spinT >= 0.8 then rec.spinT = 0 hit(plr, rec, "spin", now) end
								else
									rec.spinT = math.max(rec.spinT - pdt, 0)
								end
							end
						end
					end
					rec.pos, rec.t = pos, now
					do
						local look = root.CFrame.LookVector
						rec.yaw = math.atan2(-look.X, -look.Z)
					end

					if S.DtFreeze then
						local cam = getCamera()
						local anyFlag = false
						for _, f in FLAG_ORDER do
							if flagged(rec, f) then anyFlag = true break end
						end
						if cam and anyFlag then
							local head = char:FindFirstChild("Head") or root
							local sp, on = cam:WorldToViewportPoint(head.Position)
							local vis = false
							if on and sp.Z > 0 then
								vrp.FilterDescendantsInstances = myChar and { char, myChar } or { char }
								local camPos = cam.CFrame.Position
								vis = workspace:Raycast(camPos, head.Position - camPos, vrp) == nil
							end
							if vis then rec.visPivot = char:GetPivot() end
							if rec.vis ~= nil and rec.vis ~= vis and now - (rec.lastFreeze or 0) > S.DtFreezeCool then
								local pv = vis and char:GetPivot() or rec.visPivot
								if pv then
									rec.freezePivot = pv
									rec.freezeUntil = now + S.DtFreezeTime
									rec.lastFreeze = now
								end
							end
							rec.vis = vis
						else
							rec.vis = nil
						end
					end

					if now - (rec.slowT or 0) > 0.5 then
						rec.slowT = now
						if S.DtHitbox then
							local head = char:FindFirstChild("Head")
							local big = math.max(root.Size.X, root.Size.Y, root.Size.Z) > S.DtHitboxSize
								or (head and math.max(head.Size.X, head.Size.Y, head.Size.Z) > S.DtHitboxSize * 0.8)
							rec.bigT = big and (rec.bigT or 0) + 1 or 0
							if big and rec.bigT >= 3 and now >= quietUntil then
								rec.fc.hitbox, rec.dec.hitbox = S.DtThreshold, now
								if not rec.notified.hitbox then
									rec.notified.hitbox = true
									defNote("scan_" .. plr.UserId .. "hitbox", S.DtNotify, "Підозра (%s): %s", RED, 10, "HITBOX", plr.DisplayName)
								end
							end
						end
						if S.DtInvis then
							local head = char:FindFirstChild("Head")
							local torso = char:FindFirstChild("UpperTorso") or char:FindFirstChild("Torso")
							if head and torso and head.Transparency >= 0.98 and torso.Transparency >= 0.98
								and not char:FindFirstChildOfClass("ForceField") then
								rec.invisT += 0.5
								if rec.invisT >= 2 then
									rec.fc.invis, rec.dec.invis = S.DtThreshold, now
									if not rec.notified.invis then
										rec.notified.invis = true
										defNote("scan_" .. plr.UserId .. "invis", S.DtNotify, "Підозра (%s): %s", RED, 10, "INVIS", plr.DisplayName)
									end
								end
							else
								rec.invisT = 0
							end
						end
					end
				end
			end
		end
	end)

	local function buildInfo()
		local list = {}
		for plr, rec in recs do
			local names = {}
			for _, f in FLAG_ORDER do
				if flagged(rec, f) then names[#names + 1] = FLAG_TEXT[f] end
			end
			if #names > 0 then list[#list + 1] = string.format("%s  %s", plr.DisplayName, table.concat(names, "·")) end
		end
		table.sort(list)
		local lines = {}
		for i = 1, math.min(#list, 6) do lines[i] = list[i] end
		return tr("Сканер: підозрілі") .. ":\n" .. (#lines > 0 and table.concat(lines, "\n") or tr("немає"))
	end
	refreshDtInfo = function()
		if dtInfoLabel then dtInfoLabel.Text = buildInfo() end
	end

	task.spawn(function()
		while true do
			task.wait(1)
			local now = os.clock()
			for plr, rec in recs do
				if plr.Parent ~= Players then
					removeGui(rec)
					recs[plr] = nil
				else
					local names = {}
					for _, f in FLAG_ORDER do
						if (rec.fc[f] or 0) > 0 and now - (rec.dec[f] or 0) >= 15 then
							rec.fc[f] -= 1
							rec.dec[f] = now
						end
						if (rec.fc[f] or 0) < S.DtThreshold then rec.notified[f] = false end
						if flagged(rec, f) then names[#names + 1] = FLAG_TEXT[f] end
					end

					local char = plr.Character
					local head = char and char:FindFirstChild("Head")
					local root = getRoot(char)
					if #names > 0 and S.DtTags and gateOpen and head then
						local txt = "" .. table.concat(names, " · ")
						if not rec.tag or not rec.tag.Parent or rec.tag.Adornee ~= head then
							if rec.tag then rec.tag:Destroy() end
							local bb = Instance.new("BillboardGui")
							bb.Adornee = head
							bb.AlwaysOnTop = true
							bb.Size = UDim2.fromOffset(190, 20)
							bb.StudsOffset = Vector3.new(0, 4.2, 0)
							bb.Parent = folder
							rec.tagLabel = makeText(bb, UDim2.fromScale(1, 1), UDim2.new(), txt, 13, RED, FONT_B, Enum.TextXAlignment.Center, true)
							rec.tagLabel.TextStrokeTransparency = 0.3
							rec.tag = bb
						end
						rec.tagLabel.Text = txt
					elseif rec.tag then
						rec.tag:Destroy()
						rec.tag = nil
					end

					if flagged(rec, "invis") and S.DtReveal and gateOpen and root then
						if not rec.mark or not rec.mark.Parent or rec.mark.Adornee ~= root then
							if rec.mark then rec.mark:Destroy() end
							local bb = Instance.new("BillboardGui")
							bb.Adornee = root
							bb.AlwaysOnTop = true
							bb.Size = UDim2.fromOffset(40, 40)
							bb.Parent = folder
							local l = makeText(bb, UDim2.fromScale(1, 1), UDim2.new(), "[ ]", 34, RED, FONT_B, Enum.TextXAlignment.Center, true)
							l.TextStrokeTransparency = 0.2
							rec.mark = bb
						end
					elseif rec.mark then
						rec.mark:Destroy()
						rec.mark = nil
					end
				end
			end
			refreshDtInfo()
		end
	end)
end)

safeRun("motion", function()
	local folder = Instance.new("Folder")
	folder.Name = "ZenithMotion"

	local cand, entries = {}, {}
	local lastScan, lastTick = 0, 0

	local function charOf(p)
		local m = p.Parent
		while m and m ~= workspace do
			if m:IsA("Model") and m:FindFirstChildOfClass("Humanoid") then return m end
			m = m.Parent
		end
		return nil
	end

	local function modelOf(p)
		local m = p.Parent
		while m and m ~= workspace do
			if m:IsA("Model") then return m end
			m = m.Parent
		end
		return p
	end

	local function clear(entry)
		for _, a in entry.adorn do pcall(function() a:Destroy() end) end
		if entry.label then pcall(function() entry.label:Destroy() end) end
	end

	local function clearAll()
		for g, entry in entries do clear(entry) end
		table.clear(entries)
		table.clear(motionTargets)
	end

	local function rescan()
		local list, n = {}, 0
		local myChar = player.Character
		local minSize = S.MotMinSize
		for _, d in workspace:GetDescendants() do
			if d:IsA("BasePart") and not d.Anchored and not d:IsA("Terrain") and d.Size.Magnitude >= minSize then
				if not (myChar and d:IsDescendantOf(myChar)) and not d:IsDescendantOf(folder) then
					local ch = charOf(d)
					local plrChar = ch and Players:GetPlayerFromCharacter(ch)
					if not (plrChar and S.MotSkipPlayers) then
						n += 1
						list[n] = d
						if n >= 2500 then break end
					end
				end
			end
		end
		cand = list
	end

	RunService.Heartbeat:Connect(function()
		local now = os.clock()
		if now - lastTick < 0.15 then return end
		lastTick = now

		local want = gateOpen and (S.MotEsp or S.MotAim)
		local cam = getCamera()
		if not (want and cam) then
			if next(entries) ~= nil or #motionTargets > 0 then clearAll() end
			return
		end
		if folder.Parent ~= cam then folder.Parent = cam end

		if now - lastScan > 2 then
			lastScan = now
			rescan()
		end

		local camPos = cam.CFrame.Position
		local active, order = {}, {}
		for _, p in cand do
			if p.Parent and not p.Anchored then
				local v = p.AssemblyLinearVelocity.Magnitude
				if v >= S.MotMinSpeed then
					local d = (p.Position - camPos).Magnitude
					if d <= S.MotDist then
						local g = modelOf(p)
						local rec = active[g]
						if not rec then
							rec = { g = g, main = p, speed = v, dist = d, parts = {} }
							active[g] = rec
							order[#order + 1] = rec
						end
						rec.parts[#rec.parts + 1] = p
						if p.Size.Magnitude > rec.main.Size.Magnitude then rec.main = p end
						if v > rec.speed then rec.speed = v end
						if d < rec.dist then rec.dist = d end
					end
				end
			end
		end
		table.sort(order, function(a, b) return a.dist < b.dist end)
		for i = #order, S.MotMaxCount + 1, -1 do order[i] = nil end

		table.clear(motionTargets)
		for _, rec in order do
			motionTargets[#motionTargets + 1] = { part = rec.main, model = rec.g, speed = rec.speed }
		end

		local color = colorOf(S.MotColor)
		local used = {}
		if S.MotEsp then
			for _, rec in order do
				local entry = entries[rec.g]
				if not entry then
					entry = { adorn = {}, seen = now }
					entries[rec.g] = entry
				end
				entry.seen = now
				used[rec.g] = true

				table.sort(rec.parts, function(a, b) return a.Size.Magnitude > b.Size.Magnitude end)
				local keep = {}
				for i = 1, math.min(#rec.parts, 6) do
					local part = rec.parts[i]
					keep[part] = true
					local a = entry.adorn[part]
					if not a then
						a = Instance.new("BoxHandleAdornment")
						a.Adornee = part
						a.Size = part.Size + Vector3.new(0.12, 0.12, 0.12)
						a.AlwaysOnTop = true
						a.ZIndex = 5
						a.Parent = folder
						entry.adorn[part] = a
					end
					a.Color3 = color
					a.Transparency = S.MotFillTrans
				end
				for part, a in entry.adorn do
					if not keep[part] or not part.Parent then
						pcall(function() a:Destroy() end)
						entry.adorn[part] = nil
					end
				end

				if S.MotLabel then
					local lb = entry.label
					if not lb then
						lb = Instance.new("BillboardGui")
						lb.AlwaysOnTop = true
						lb.Size = UDim2.fromOffset(150, 20)
						lb.LightInfluence = 0
						local t = Instance.new("TextLabel")
						t.Name = "T"
						t.Size = UDim2.fromScale(1, 1)
						t.BackgroundTransparency = 1
						t.Font = FONT_B
						t.TextSize = 12
						t.TextStrokeTransparency = 0.4
						t.Parent = lb
						lb.Parent = folder
						entry.label = lb
					end
					lb.Adornee = rec.main
					lb.StudsOffset = Vector3.new(0, rec.main.Size.Y / 2 + 1.5, 0)
					local t = lb:FindFirstChild("T")
					if t then
						t.TextColor3 = color
						local nm = rec.g.Name
						if #nm > 18 then nm = string.sub(nm, 1, 18) end
						t.Text = string.format("%s  %dст  %dст/с", nm, math.floor(rec.dist), math.floor(rec.speed))
					end
				elseif entry.label then
					entry.label:Destroy()
					entry.label = nil
				end
			end
		end

		for g, entry in entries do
			if not used[g] and now - entry.seen > 0.5 or not g.Parent then
				clear(entry)
				entries[g] = nil
			end
		end
	end)
end)

safeRun("orbit", function()
	local orb = nil
	local rp = RaycastParams.new()
	rp.FilterType = Enum.RaycastFilterType.Exclude
	rp.RespectCanCollide = true

	local function finish(silent)
		local o = orb
		if not o then return end
		orb = nil
		pcall(function() RunService:UnbindFromRenderStep("ZenithOrbitCam") end)
		local char = player.Character
		local root = getRoot(char)
		if S.OrbitReturn and char and root and o.startCF then
			markSelf(1.5)
			char:PivotTo(o.startCF)
			root.AssemblyLinearVelocity = Vector3.zero
		end
		if not silent then toast(tr("Бліц завершено"), ACCENT, true) end
	end
	orbitStop = function() finish(true) end

	orbitStart = function()
		if not gateOpen then return end
		if orb then finish() return end
		local myChar = player.Character
		local myRoot = getRoot(my