local N: any = {}
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")
local Lighting = game:GetService("Lighting")
N.CollectionService = game:GetService("CollectionService")
N.LocalizationService = game:GetService("LocalizationService")
N.HttpService = game:GetService("HttpService")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

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

-- true: працює лише коли в Workspace є атрибут FunMode = true
N.REQUIRE_GATE = false
N.GATE_ATTRIBUTE = "FunMode"
-- false: без інтро та вибору мови на старті
N.SHOW_INTRO = true
N.PROJECT_NAME = "ZENITH"

local function detectLang()
	local ok, id = pcall(function() return N.LocalizationService.RobloxLocaleId end)
	id = string.lower(ok and tostring(id) or "en")
	local p = string.sub(id, 1, 2)
	if p == "uk" then return 1 elseif p == "ru" then return 3 end
	return 2
end

local DEFAULTS = {

	Aim = false, AimHold = false, AimPart = 1, Priority = 1,
	Smooth = 0.3, Prediction = 0, AimMaxDist = 5000, AimSticky = true, AimYield = isTouch, AimMark = true,
	UseFov = true, FovShow = true, FovRadius = 180, FovThick = 2, FovColor = 3,
	WallCheck = false, IgnoreTeam = false, IncludeNPCs = false,

	TpAuto = false, TpUseFov = true, TpMode = 1, TpOffset = 4, TpInterval = 2,
	TpDmg = false, TpDmgMin = 15, TpDmgMax = 40, TpDmgCd = 1.5,

	Esp = false, EspHighlight = true,
	EspFill = 1, EspFillTrans = 0.5, EspOutline = 4, EspOutTrans = 0,
	EspTeamColor = false, EspHealthColor = false, EspAlwaysOnTop = true,
	EspNames = true, EspHealth = true, EspDist = true, EspTextSize = 14,
	EspBox = false, EspBoxColor = 4, EspBoxThick = 1, EspBar = true,
	EspTracer = false, EspTracerColor = 3, EspTracerFrom = 1,
	EspHead = false, EspHeadColor = 1, EspArrows = false, EspArrowColor = 5,
	EspVisCheck = false, EspNPC = false,
	MotEsp = false, MotAim = false, MotMinSpeed = 3, MotMinSize = 1.5, MotDist = 400, MotMaxCount = 40, MotColor = 5, MotFillTrans = 0.55,
	MotLabel = true, MotSkipPlayers = true,
	CfgSlot = 1, FpsBoost = false, FpsLevel = 2, FpsKeepChars = true,
	OrbitTime = 3, OrbitRadius = 12, OrbitSpeed = 240, OrbitHeight = 0, OrbitDir = 1, OrbitMaxStart = 80, OrbitReturn = true, OrbitFace = true,
	SkyOn = false, SkyPreset = 1, SkyTime = 14, SkyColor = 3, SkyCycle = 0, SkyDensity = 0.35, SkyStars = true,
	Chr = false, ChrStyle = 1, ChrColor = 1, ChrColor2 = 6, ChrWho = 1, ChrMat = 1, ChrSpeed = 1, ChrAlpha = 0, CfgText = "",
	EspMaxDist = 2000, EspHideTeam = false, EspOffX = 0, EspOffY = 0,

	SpeedOn = false, Speed = 32, JumpOn = false, JumpPower = 80,
	InfJump = false, InfJumpMode = 1, InfJumpCount = 2, InfJumpPower = 100, InfJumpCd = 0.12, InfJumpFx = true, InfJumpHud = true, Noclip = false, Fly = false, FlyStep = 4, FlyTickMs = 60, FlyVert = 100, FlyPitch = true, FlySmooth = false,
	FlyMode = 3, FlyRamp = false, FlyRampTime = 0.6, FlyHold = true, FlyWalls = true, FlyMaxSps = 200,
	Spin = false, SpinMode = 1, SpinSpeed = 720, SpinDir = 1, SpinRate = 20, SpinSway = 45, SpinRamp = true, SpinSafe = true, SpinNet = true,
	Bhop = false, BhopMax = 70, BhopGain = 3,

	Coins = false, CoinName = "Coin", CoinInterval = 0.3, CoinRange = 300, CoinReturn = false,
	FullBright = false, FbLevel = 100, FbNoFog = true, FbNoPost = true, FbDay = false, CamFovOn = false, CamFov = 90,
	GravityOn = false, Gravity = 40, GravPreset = 1, GravJump = true,
	Crosshair = false, CrossSize = 12, CrossColor = 2, CrossStyle = 1, CrossGap = 3, CrossThick = 2, CrossAlpha = 0,
	CrossOutline = true, CrossDynamic = true, CrossEnemy = true, CrossHit = true,
	Tpv = false, TpvDist = 12, TpvFree = true,

	DrName = "drone, dron, dr0ne, drohne, uav, fpv, quadcopter, quadrocopter, multicopter, quadro, kamikaze, bomber, "
		.. "дрон, дроны, дрони, беспилотник, безпілотник, бпла, квадрокоптер, мультикоптер, камикадзе, бомбер, бомбардировщик",
	DrExclude = "heli, вертол, гелікоптер",
	DrEsp = false, DrEspColor = 1, DrWarn = false, DrWarnRadius = 120,
	DrAim = false, DrAimRange = 250, DrAutoFire = false,
	DrEvade = false, DrEvadeRadius = 40, DrEvadeDist = 30, DrEvadeCd = 3,

	AntiFling = true, AfNoCollide = true, AfParts = true, AfClamp = true, AfNoRagdoll = true,
	AfVoid = true, AfPark = true, AfUnder = true, AfNotify = true, AfSpeed = 400, AfAng = 60,
	AntiSit = true, SitMode = 1, SitSpeed = 60, SitNotify = true,
	AntiFall = true, FallHeight = 220, FallSpeed = 260, FallNotify = true, FallMode = 1, FallSoft = 55, FallMark = true,
	AntiFlick = true, FlickDist = 45, FlickEnemyOnly = true, FlickRevert = true,
	AntiBlind = true, AbBlur = 8, AbBright = 0.35, AbGui = true,
	AbIgnore = "load, intro, menu, lobby, splash, death, spawn",

	Counter = true, CtMode = 1, CtBehindOnly = true, CtFace = true,
	CtRadius = 30, CtMinJump = 35, CtCooldown = 2, CtDelay = 0, CtSafe = true,
	TpHl = true, TpHlMin = 40, TpHlRange = 800, TpHlTime = 3, TpHlTeam = false, TpHlColor = 1,
	AimWarn = true, AwAngle = 6, AwRange = 400, AwTime = 0.6, AwWall = true, AwTeam = false,
	DtSpeed = true, DtFly = true, DtNoclip = true, DtSpin = true, DtHitbox = true, DtInvis = true, DtLag = true,
	DtReveal = true, DtNotify = true, DtTags = true, DtThreshold = 3,
	PullDist = 5, PullTime = 5, PullTeam = true, PullUseFov = true, PullHold = false,
	DtFreeze = true, DtFreezeTime = 2.5, DtFreezeCool = 3,
	GdLinks = true, GdSound = true, GdCage = true, GdRide = true, GdPlrCol = true,
	DtSpeedMax = 70, DtFlyTime = 2.5, DtSpinRate = 14, DtHitboxSize = 4.5,
	Susp = true, SuspSnap = 70, SuspThreshold = 4, SuspTags = true, SuspNotify = true,

	Lang = detectLang(),
	Accent = 4, MenuAlpha = 0.02, UiScale = 1, AutoScale = true,
	Toasts = true, Quick = isTouch, Debug = false,
	ThPreset = 1, ThBg = "171514", ThPanel = "1F1D1B", ThHover = "2A2724", ThLine = "3E3A35", ThText = "EEE8DE", ThDim = "989084", ThAccent = "",
	ThFont = 1, ThRound = 1, ThStroke = 1, ThTextSize = 0, ThDensity = 1, ThSpeed = 1,
	ThGrad = false, ThGradC1 = "2B2433", ThGradC2 = "171514", ThGradAngle = 135, ThGlow = 0, ThBlur = 0, ThImage = "", ThImageAlpha = 0.5, ThToastPos = 1,
	ThRulesOn = true, ThRules = "", ThCode = "", ThAuto = true,
	KeyMenu = "M", KeyAim = "F", KeyTp = "T", KeyPanic = "Delete", KeyTpv = "V", KeyPull = "Q", KeyFly = "G", KeyOrbit = "RightBracket", KeySpin = "None",
}

N.FEATURES = {
	"Aim", "Chr", "SkyOn", "TpAuto", "TpDmg", "Esp", "EspBox", "EspTracer", "EspHead", "EspArrows", "SpeedOn", "JumpOn", "InfJump", "Noclip",
	"Fly", "Spin", "Bhop", "MotEsp", "MotAim", "FpsBoost", "Coins", "FullBright", "Tpv", "CamFovOn", "GravityOn", "Crosshair",
	"DrEsp", "DrWarn", "DrAim", "DrAutoFire", "DrEvade",
}

N.DEF_KEYS = {
	"AntiFling", "AntiSit", "AntiFall", "AntiFlick", "AntiBlind",
	"Counter", "TpHl", "AimWarn", "Susp",
	"DtSpeed", "DtFly", "DtNoclip", "DtSpin", "DtHitbox", "DtInvis", "DtLag", "DtFreeze",
}

local S: any = {}
for k, v in DEFAULTS do S[k] = v end

N.THEME_KEYS = {
	"ThPreset", "ThBg", "ThPanel", "ThHover", "ThLine", "ThText", "ThDim", "ThAccent",
	"ThFont", "ThRound", "ThStroke", "ThTextSize", "ThDensity", "ThSpeed",
	"ThGrad", "ThGradC1", "ThGradC2", "ThGradAngle", "ThGlow", "ThBlur", "ThImage", "ThImageAlpha", "ThToastPos",
	"ThRulesOn", "ThRules", "ThCode", "ThAuto",
}
N.THEME_SET = {}
for _, k in N.THEME_KEYS do N.THEME_SET[k] = true end
N.SAVE_KEYS = { "ThPreset", "ThAccent", "Accent", "MenuAlpha", "UiScale", "AutoScale", "Toasts", "Quick" }
N.SAVE_SET = {}
for _, k in N.SAVE_KEYS do N.SAVE_SET[k] = true end

N.BLUR_NAME = "ZenithMenuBlur"
N.THEME_ROLES = { "bg", "panel", "hover", "line", "text", "dim", "accent" }
N.SAVE_REMOTE = "ZenithSaveRF"
N.THEME_PRESET_NAMES = { "Стандарт", "Північ", "Сніг", "Кіберпанк", "Аврора", "Багряний" }
N.THEME_DESC = {
	"",
	"Спокійна темна, синій акцент",
	"Світла й чиста, як папір",
	"Неон, світіння, гострі кути",
	"Скло: гра за меню розмита, плавний градієнт",
	"Чорно-червона, товсті лінії",
}
N.THEME_PRESETS = {
	{ bg = "171514", panel = "1F1D1B", hover = "2A2724", line = "3E3A35", text = "EEE8DE", dim = "989084", accent = "", font = 1, round = 1, stroke = 1, grad = false, glow = 0, alpha = 0.02 },
	{ bg = "0D1220", panel = "151C30", hover = "202B47", line = "2D3A5C", text = "E8EEFB", dim = "8D9BBE", accent = "5AA2FF", font = 1, round = 1.2, stroke = 1, grad = false, glow = 0.15, alpha = 0.02 },
	{ bg = "EDF1F8", panel = "FCFDFF", hover = "E1E8F4", line = "C2CDE1", text = "18213A", dim = "5B6782", accent = "2563EB", font = 2, round = 1.3, stroke = 1, tsize = 1, grad = false, glow = 0, alpha = 0.02, rules = "swap #50DC8C = #13804A" },
	{ bg = "0A0612", panel = "130C21", hover = "24173F", line = "4F2C86", text = "F6EDFF", dim = "A992D6", accent = "FF3FD9", font = 4, round = 0.35, stroke = 1.5, grad = true, c1 = "33105C", c2 = "0A0612", ang = 125, glow = 0.85, speed = 1.25, alpha = 0.02 },
	{ bg = "0C1A26", panel = "12283A", hover = "1B3A52", line = "35607F", text = "EAF8FF", dim = "9CC0D4", accent = "5EEAD4", font = 1, round = 1.7, stroke = 1, grad = true, c1 = "114A5C", c2 = "2A1B5E", ang = 135, glow = 0.35, blur = 10, alpha = 0.12 },
	{ bg = "120A0B", panel = "1B1011", hover = "301A1C", line = "5A2326", text = "F5E9E9", dim = "A98587", accent = "FF4D4D", font = 3, round = 0.3, stroke = 2, grad = false, glow = 0.4, alpha = 0.02 },
}
N.THEME_FONTS = {
	{ "GothamMedium", "GothamBold", "Michroma", "RobotoMono" },
	{ "SourceSans", "SourceSansBold", "SourceSansBold", "RobotoMono" },
	{ "Arial", "ArialBold", "ArialBold", "Code" },
	{ "Jura", "SciFi", "SciFi", "Code" },
	{ "RobotoMono", "Code", "Code", "RobotoMono" },
	{ "Arcade", "Arcade", "Arcade", "Arcade" },
	{ "Nunito", "FredokaOne", "FredokaOne", "RobotoMono" },
}
N.THEME_RANGE = {
	ThPreset = { 1, #N.THEME_PRESET_NAMES }, ThFont = { 1, #N.THEME_FONTS }, ThToastPos = { 1, 4 },
	ThRound = { 0, 2 }, ThStroke = { 0, 3 }, ThTextSize = { -3, 4 }, ThDensity = { 0.8, 1.4 }, ThSpeed = { 0.25, 4 },
	ThGradAngle = { 0, 360 }, ThGlow = { 0, 1 }, ThBlur = { 0, 24 }, ThImageAlpha = { 0, 1 },
	Accent = { 1, 8 }, MenuAlpha = { 0, 0.8 }, UiScale = { 0.7, 1.4 },
}
N.THEME_INT = { ThPreset = true, ThFont = true, ThToastPos = true, ThGradAngle = true, ThBlur = true, ThTextSize = true, Accent = true }
N.THEME_EXPORT = {}
for _, k in N.THEME_KEYS do
	if k ~= "ThCode" and k ~= "ThAuto" then N.THEME_EXPORT[#N.THEME_EXPORT + 1] = k end
end

N.COLORS = {
	{ "Червоний", Color3.fromRGB(255, 60, 60) },
	{ "Зелений", Color3.fromRGB(0, 220, 110) },
	{ "Блакитний", Color3.fromRGB(60, 200, 255) },
	{ "Білий", Color3.fromRGB(255, 255, 255) },
	{ "Жовтий", Color3.fromRGB(255, 220, 50) },
	{ "Фіолетовий", Color3.fromRGB(170, 90, 255) },
	{ "Помаранчевий", Color3.fromRGB(255, 150, 40) },
	{ "Рожевий", Color3.fromRGB(255, 100, 190) },
}

N.CHR_COLORS = {
	{ "Чорний", Color3.fromRGB(8, 8, 10) }, { "Сірий", Color3.fromRGB(110, 112, 120) }, { "Золотий", Color3.fromRGB(235, 180, 40) },
}
for _, c in N.COLORS do N.CHR_COLORS[#N.CHR_COLORS + 1] = c end
N.CHR_COLOR_NAMES = {}
for i, c in N.CHR_COLORS do N.CHR_COLOR_NAMES[i] = c[1] end
N.SKY_PRESET_NAMES = { "Ясний день", "Захід сонця", "Ніч", "Космос", "Рожева мрія", "Шторм", "Токсичний", "Неонова ніч", "Веселка (авто)", "Своє" }
N.CHR_STYLE_NAMES = { "Один колір", "Веселка", "Перелив двох кольорів" }
N.CHR_WHO_NAMES = { "Усі гравці", "Лише вороги", "Усі крім мене", "Лише я" }
N.CHR_MAT_NAMES = { "Без змін", "Пластик", "Неон", "Метал", "Скло" }
N.COLOR_NAMES = {}
for i, c in N.COLORS do N.COLOR_NAMES[i] = c[1] end
local function colorOf(idx) return N.COLORS[idx][2] end

N.ACCENTS = {
	{ "Сталевий", Color3.fromRGB(128, 168, 205) },
	{ "Зелений", Color3.fromRGB(118, 178, 126) },
	{ "Червоний", Color3.fromRGB(212, 98, 90) },
	{ "Бурштиновий", Color3.fromRGB(218, 162, 84) },
	{ "Фіолетовий", Color3.fromRGB(162, 134, 214) },
	{ "Білий", Color3.fromRGB(232, 227, 218) },
	{ "Бірюзовий", Color3.fromRGB(96, 184, 182) },
	{ "Рожевий", Color3.fromRGB(216, 126, 158) },
}
N.ACCENT_NAMES = {}
for i, c in N.ACCENTS do N.ACCENT_NAMES[i] = c[1] end

N.AIM_PART_NAMES = { "Голова", "Тулуб", "Корінь", "Найближча до прицілу" }
N.PRIORITY_NAMES = { "Ближче до кола", "Найближчий", "Найменше HP" }
N.TRACER_FROM_NAMES = { "Знизу", "Центр", "Курсор" }
N.TP_MODE_NAMES = { "За спину", "Збоку", "Над головою" }
N.SPIN_MODE_NAMES = { "Крутилка", "Хаос", "Назад до камери", "Хитавиця", "Ривки" }
N.JUMP_MODE_NAMES = { "Без ліміту", "Кілька стрибків", "Утримання" }
N.CROSS_STYLE_NAMES = { "Хрестик", "Т-подібний", "Крапка", "Коло", "Хрестик з крапкою" }
N.SPIN_DIR_NAMES = { "За годинниковою", "Проти годинникової", "Змінювати напрямок" }
N.FLY_MODE_NAMES = { "Телепорт", "Фізика", "Гібрид" }
N.ORBIT_DIR_NAMES = { "За годинниковою", "Проти годинникової", "Чергувати" }
N.FPS_LEVEL_NAMES = { "Легкий", "Сильний", "Максимум" }
N.SLOT_NAMES = { "Слот 1", "Слот 2", "Слот 3", "Слот 4", "Слот 5" }
N.CT_MODE_NAMES = { "ТП за спину ворогу", "Лише розвернутись", "Лише сповіщення" }
N.FALL_MODE_NAMES = { "Розумний", "Повернення на землю", "М'яка посадка" }
N.GRAV_NAMES = { "Своя", "Місяць", "Марс", "Звичайна", "Важка", "Майже невагомість" }
N.GRAV_PRESETS = { 0, 17, 38, 100, 200, 5 }
N.SIT_MODE_NAMES = { "Чужі й швидкі сидіння", "Усе, крім транспорту", "Усі сидіння" }

N.LANG_CODES = { "uk", "en", "ru" }
N.LANG_NAMES = { "Українська", "English", "Русский" }
N.TR = {}
local function T(uk, en, ru) N.TR[uk] = { en = en, ru = ru } end
T("ОБЕРІТЬ ФУНКЦІЇ", "CHOOSE FEATURES", "ВЫБЕРИТЕ ФУНКЦИИ")
T("Вибрати все", "Select all", "Выбрать все")
T("Зняти все", "Clear all", "Снять все")
T("Продовжити", "Continue", "Продолжить")
T("ФОНОВИЙ ЗАХИСТ (працює автоматично)", "BACKGROUND PROTECTION (automatic)", "ФОНОВАЯ ЗАЩИТА (автоматически)")
T("Скидати чужі прив'язки до вас", "Drop foreign attachments to you", "Сбрасывать чужие привязки к вам")
T("Не дати стояти на вашій голові", "Stop others riding on you", "Не давать стоять на вашей голове")
T("Проходити крізь клітки", "Walk through cages", "Проходить сквозь клетки")
T("Глушити гучні звуки гравців", "Mute loud player sounds", "Глушить громкие звуки игроков")
T("Гасити швидкі деталі поруч (кільця)", "Neutralize fast loose parts nearby (rings)", "Гасить быстрые свободные детали рядом (кольца)")
T("Антифлінг: швидку деталь поруч прибрано з колізій", "Antifling: fast part nearby removed from collisions", "Антифлинг: быструю деталь рядом убрали из коллизий")
T("Вимикати колізії гравців кожні 2 с", "Disable player collisions every 2 s", "Отключать коллизии игроков каждые 2 с")
T("Відчеплено чужі зв'язки з вашим персонажем", "Foreign attachments removed from you", "Отцеплены чужие связи с вашим персонажем")
T("Клітку навколо вас зроблено прохідною", "Cage around you made passable", "Клетка вокруг вас стала проходимой")
T("Гравець на вас не штовхатиме", "Player on top of you can't push you", "Игрок на вас не будет толкать")
T("Приглушено гучний звук від гравця", "Loud player sound muted", "Приглушён громкий звук игрока")
T("Відкрийте вкладку і позначте лише потрібні функції. Невибране вирізається з меню і не навантажує пристрій.",
	"Open a tab and tick only what you need. Anything left out is removed from the menu and costs nothing.",
	"Откройте вкладку и отметьте только нужное. Невыбранное вырезается из меню и не нагружает устройство.")
T("Вибрано: %d / %d", "Selected: %d / %d", "Выбрано: %d / %d")
T("Зсув ESP по X (калібрування)", "ESP offset X (calibration)", "Сдвиг ESP по X (калибровка)")
T("Зсув ESP по Y (калібрування)", "ESP offset Y (calibration)", "Сдвиг ESP по Y (калибровка)")
N.THEME_HELP = "Один рядок = одне правило:\nСелектор.Властивість = значення\nTextLabel.TextSize = 14\n#Window.BackgroundTransparency = 0.2\nFrame@line.BackgroundTransparency = 0.4\nUICorner.CornerRadius = 4\nswap #50DC8C = #00FF99\nРолі: @bg @panel @hover @line @text @dim @accent"
T(N.THEME_HELP,
	"One line = one rule:\nSelector.Property = value\nTextLabel.TextSize = 14\n#Window.BackgroundTransparency = 0.2\nFrame@line.BackgroundTransparency = 0.4\nUICorner.CornerRadius = 4\nswap #50DC8C = #00FF99\nRoles: @bg @panel @hover @line @text @dim @accent",
	"Одна строка = одно правило:\nСелектор.Свойство = значение\nTextLabel.TextSize = 14\n#Window.BackgroundTransparency = 0.2\nFrame@line.BackgroundTransparency = 0.4\nUICorner.CornerRadius = 4\nswap #50DC8C = #00FF99\nРоли: @bg @panel @hover @line @text @dim @accent")
T("ТЕМА МЕНЮ", "MENU THEME", "ТЕМА МЕНЮ"); T("КОЛЬОРИ (hex або r,g,b)", "COLORS (hex or r,g,b)", "ЦВЕТА (hex или r,g,b)")
T("ФОРМА І ТЕКСТ", "SHAPE AND TEXT", "ФОРМА И ТЕКСТ"); T("ФОН І ЕФЕКТИ", "BACKGROUND AND EFFECTS", "ФОН И ЭФФЕКТЫ")
T("ПРАВИЛА СТИЛЮ (як CSS)", "STYLE RULES (CSS-like)", "ПРАВИЛА СТИЛЯ (как CSS)"); T("ЕКСПОРТ / ІМПОРТ ТЕМИ", "THEME EXPORT / IMPORT", "ЭКСПОРТ / ИМПОРТ ТЕМЫ")
T("Готова тема", "Preset theme", "Готовая тема"); T("Зберігати тему автоматично", "Save theme automatically", "Сохранять тему автоматически")
T("Зберегти тему зараз", "Save theme now", "Сохранить тему сейчас"); T("Скинути тему до стандартної", "Reset theme to default", "Сбросить тему на стандартную")
T("Фон вікна", "Window background", "Фон окна"); T("Панелі", "Panels", "Панели"); T("Підсвітка рядка", "Row highlight", "Подсветка строки")
T("Лінії та рамки", "Lines and borders", "Линии и рамки"); T("Текст", "Text", "Текст"); T("Приглушений текст", "Dim text", "Приглушённый текст")
T("Акцент (порожньо = за списком)", "Accent (empty = from list)", "Акцент (пусто = из списка)")
T("Шрифт", "Font", "Шрифт"); T("Заокруглення", "Roundness", "Скругление"); T("Товщина ліній", "Line thickness", "Толщина линий")
T("Розмір тексту меню", "Menu text size", "Размер текста меню"); T("Щільність рядків", "Row density", "Плотность строк"); T("Швидкість анімацій", "Animation speed", "Скорость анимаций")
T("Градієнтний фон", "Gradient background", "Градиентный фон"); T("Градієнт: колір 1", "Gradient: color 1", "Градиент: цвет 1")
T("Градієнт: колір 2", "Gradient: color 2", "Градиент: цвет 2"); T("Градієнт: кут", "Gradient: angle", "Градиент: угол")
T("Свічення рамки", "Border glow", "Свечение рамки"); T("Розмиття гри за меню", "Game blur behind menu", "Размытие игры за меню")
T("Фонове зображення (ID)", "Background image (ID)", "Фоновое изображение (ID)"); T("Прозорість зображення", "Image transparency", "Прозрачность изображения")
T("Позиція сповіщень", "Notification position", "Позиция уведомлений"); T("Правила увімкнено", "Rules enabled", "Правила включены")
T("Правила (по одному в рядку)", "Rules (one per line)", "Правила (по одному в строке)"); T("Приклад правил у поле", "Insert example rules", "Пример правил в поле")
T("Тема (JSON)", "Theme (JSON)", "Тема (JSON)"); T("Експортувати тему", "Export theme", "Экспортировать тему")
T("Імпортувати тему з поля", "Import theme from field", "Импортировать тему из поля")
T("Стандарт", "Standard", "Стандарт"); T("Графіт", "Graphite", "Графит"); T("Північ", "Midnight", "Полночь"); T("Неон", "Neon", "Неон")
T("Світла", "Light", "Светлая"); T("М'ята", "Mint", "Мята"); T("Багряний", "Crimson", "Багровый"); T("Моно", "Mono", "Моно"); T("Власна", "Custom", "Своя")
T("Стандартний", "Standard", "Стандартный"); T("Класичний", "Classic", "Классический"); T("Техно", "Techno", "Техно")
T("Моноширинний", "Monospace", "Моноширинный"); T("Ретро", "Retro", "Ретро"); T("Заокруглений", "Rounded", "Закруглённый")
T("Угорі по центру", "Top center", "Сверху по центру"); T("Внизу по центру", "Bottom center", "Снизу по центру")
T("Угорі праворуч", "Top right", "Сверху справа"); T("Внизу праворуч", "Bottom right", "Снизу справа")
T("авто", "auto", "авто"); T("Невірний колір", "Invalid color", "Неверный цвет"); T("Тему скинуто", "Theme reset", "Тема сброшена")
T("Контраст тексту підвищено", "Text contrast increased", "Контраст текста повышен")
T("Тему експортовано в поле нижче", "Theme exported to the field below", "Тема экспортирована в поле ниже")
T("Невірний формат теми", "Invalid theme format", "Неверный формат темы")
T("Тему застосовано, параметрів: %d", "Theme applied, parameters: %d", "Тема применена, параметров: %d")
T("Правила вимкнено", "Rules are off", "Правила выключены"); T("Правил немає", "No rules", "Правил нет")
T("Правил: %d, замін кольору: %d, помилок: %d", "Rules: %d, color swaps: %d, errors: %d", "Правил: %d, замен цвета: %d, ошибок: %d")
T("рядок %d: %s", "line %d: %s", "строка %d: %s")
T("забагато правил", "too many rules", "слишком много правил"); T("невірний колір", "invalid color", "неверный цвет")
T("немає знака =", "missing =", "нет знака ="); T("немає властивості", "missing property", "нет свойства")
T("властивість не підтримується", "property not supported", "свойство не поддерживается"); T("порожній селектор", "empty selector", "пустой селектор")
T("невірне значення", "invalid value", "неверное значение")
T("Тему збережено", "Theme saved", "Тема сохранена"); T("Серверний скрипт збереження не знайдено", "Save server script not found", "Серверный скрипт сохранения не найден")
T("Збереження: підключення до сервера...", "Saving: connecting to server...", "Сохранение: подключение к серверу...")
T("Збереження: тему завантажено з сервера", "Saving: theme loaded from server", "Сохранение: тема загружена с сервера")
T("Збереження: підключено, збереженої теми ще немає", "Saving: connected, no saved theme yet", "Сохранение: подключено, сохранённой темы пока нет")
T("Збереження: записую...", "Saving: writing...", "Сохранение: записываю...")
T("Збереження: записано о %s", "Saving: saved at %s", "Сохранение: записано в %s")
T("Збереження: серверного скрипта немає, тема діє до виходу з гри", "Saving: server script not found, theme lasts until you leave the game", "Сохранение: серверного скрипта нет, тема действует до выхода из игры")
T("Збереження: DataStore недоступний (увімкни API Services), тема діє до виходу з гри", "Saving: DataStore unavailable (enable API Services), theme lasts until you leave the game", "Сохранение: DataStore недоступен (включи API Services), тема действует до выхода из игры")
T("Збереження: помилка сервера, пробую ще раз", "Saving: server error, retrying", "Сохранение: ошибка сервера, пробую ещё раз")
T("Збереження: автозбереження вимкнено, зберігай кнопкою нижче", "Saving: autosave is off, use the button below", "Сохранение: автосохранение выключено, сохраняй кнопкой ниже")
T("Аварійне скидання теми: утримуй кнопку МЕНЮ 3 секунди.", "Emergency theme reset: hold the MENU button for 3 seconds.", "Аварийный сброс темы: удерживай кнопку МЕНЮ 3 секунды.")
T("Сніг", "Snow", "Снег"); T("Кіберпанк", "Cyberpunk", "Киберпанк"); T("Аврора", "Aurora", "Аврора")
T("Спокійна темна, синій акцент", "Calm dark, blue accent", "Спокойная тёмная, синий акцент")
T("Світла й чиста, як папір", "Light and clean, like paper", "Светлая и чистая, как бумага")
T("Неон, світіння, гострі кути", "Neon, glow, sharp corners", "Неон, свечение, острые углы")
T("Скло: гра за меню розмита, плавний градієнт", "Frosted glass: game blurred behind the menu, soft gradient", "Стекло: игра за меню размыта, плавный градиент")
T("Чорно-червона, товсті лінії", "Black and red, thick lines", "Чёрно-красная, толстые линии")
T("Стандартний вигляд", "Standard look", "Стандартный вид")

local function tr(s)
	local code = N.LANG_CODES[S.Lang] or "uk"
	if code == "uk" then return s end
	local e = N.TR[s]
	return e and e[code] or s
end

N.langRefs = {}
local function bind(obj, src, prop)
	prop = prop or "Text"
	N.langRefs[#N.langRefs + 1] = { obj, src, prop }
	obj[prop] = tr(src)
end

T("МЕНЮ", "MENU", "МЕНЮ")
T("ВКЛ", "ON", "ВКЛ"); T("ВИКЛ", "OFF", "ВЫКЛ")
T("АКТИВНО", "ACTIVE", "АКТИВНО"); T("ЗАХИСТ", "DEFENSE", "ЗАЩИТА"); T("ЦІЛЬ", "TARGET", "ЦЕЛЬ")
T("натисни...", "press...", "нажми...")

T("Приціл", "Aim", "Прицел"); T("Рух", "Movement", "Движение"); T("Світ", "World", "Мир")
T("Дрони", "Drones", "Дроны"); T("Захист", "Defense", "Защита"); T("Детект", "Detect", "Детект")
T("Налашт.", "Settings", "Настр.")

T("%d ст", "%d st", "%d ст"); T("%d ст/с", "%d st/s", "%d ст/с"); T("%d мс", "%d ms", "%d мс"); T("ТП", "TP", "ТП");
T("%s  %dст  %dст/с", "%s  %dst  %dst/s", "%s  %dст  %dст/с"); T("%.1f с", "%.1f s", "%.1f с"); T("%.2f с", "%.2f s", "%.2f с")
T("%d °/с", "%d °/s", "%d °/с")

T("Червоний", "Red", "Красный"); T("Зелений", "Green", "Зелёный"); T("Блакитний", "Cyan", "Голубой")
T("Білий", "White", "Белый"); T("Жовтий", "Yellow", "Жёлтый"); T("Фіолетовий", "Purple", "Фиолетовый")
T("Помаранчевий", "Orange", "Оранжевый"); T("Рожевий", "Pink", "Розовый")
T("Сталевий", "Steel", "Стальной"); T("Бурштиновий", "Amber", "Янтарный")

T("АВТОПРИЦІЛ", "AUTO-AIM", "АВТОПРИЦЕЛ"); T("Автоприціл", "Auto-aim", "Автоприцел")
T("Тільки при утриманні ПКМ (ПК)", "Only while holding RMB (PC)", "Только при удержании ПКМ (ПК)")
T("Куди цілитись", "Aim at", "Куда целиться"); T("Пріоритет цілі", "Target priority", "Приоритет цели")
T("Різкість наведення", "Aim snap", "Резкость наведения"); T("Передбачення руху", "Motion prediction", "Упреждение движения")
T("КОЛО FOV", "FOV CIRCLE", "КРУГ FOV"); T("Обмежувати колом FOV", "Limit to FOV circle", "Ограничить кругом FOV")
T("Показувати коло", "Show circle", "Показывать круг"); T("Радіус кола", "Circle radius", "Радиус круга")
T("Товщина лінії", "Line thickness", "Толщина линии"); T("Колір кола", "Circle color", "Цвет круга")
T("ЦІЛІ", "TARGETS", "ЦЕЛИ"); T("Не цілитись крізь стіни", "Don't aim through walls", "Не целиться сквозь стены")
T("Ігнорувати свою команду", "Ignore my team", "Игнорировать свою команду")
T("Включати NPC / манекени", "Include NPCs / dummies", "Включать NPC / манекены")
T("Голова", "Head", "Голова"); T("Тулуб", "Torso", "Торс"); T("Корінь", "Root", "Корень")
T("Ближче до кола", "Closest to circle", "Ближе к кругу"); T("Найближчий", "Nearest", "Ближайший")
T("Найближча до прицілу", "Closest to crosshair", "Ближайшая к прицелу"); T("ПОВЕДІНКА", "BEHAVIOR", "ПОВЕДЕНИЕ")
T("Дальність прицілу (5000 = без ліміту)", "Aim range (5000 = unlimited)", "Дальность прицела (5000 = без лимита)")
T("Тримати ціль, не стрибати між ворогами", "Keep the target, don't hop between enemies", "Держать цель, не прыгать между врагами")
T("Слабшати, коли я сам кручу камеру", "Weaken while I turn the camera myself", "Ослаблять, когда я сам кручу камеру")
T("Позначати захоплену ціль кільцем", "Mark the locked target with a ring", "Отмечать захваченную цель кольцом")
T("Найменше HP", "Lowest HP", "Наименьшее HP")
T("Бірюзовий", "Teal", "Бирюзовый"); T("Рожевий", "Pink", "Розовый")
T("Візуали також для NPC", "Visuals for NPCs too", "Визуалы также для NPC"); T("ПРЕСЕТИ ВІЗУАЛІВ", "VISUAL PRESETS", "ПРЕСЕТЫ ВИЗУАЛОВ")
T("Пресет: мінімум", "Preset: minimal", "Пресет: минимум"); T("Пресет: стандарт", "Preset: standard", "Пресет: стандарт"); T("Пресет: повний", "Preset: full", "Пресет: полный")
T("Пресет застосовано", "Preset applied", "Пресет применён")
T("ЕКСПОРТ / ІМПОРТ", "EXPORT / IMPORT", "ЭКСПОРТ / ИМПОРТ"); T("Налаштування (JSON)", "Settings (JSON)", "Настройки (JSON)")
T("Експортувати налаштування", "Export settings", "Экспортировать настройки"); T("Імпортувати з поля", "Import from field", "Импортировать из поля")
T("Налаштування експортовано в поле нижче", "Settings exported to the field below", "Настройки экспортированы в поле ниже")
T("Помилка експорту", "Export error", "Ошибка экспорта"); T("Невірний формат налаштувань", "Invalid settings format", "Неверный формат настроек")
T("Імпортовано: %d", "Imported: %d", "Импортировано: %d")
T("ПЕРЕФАРБУВАННЯ ГРАВЦІВ (лише у вас)", "RECOLOR PLAYERS (local only)", "ПЕРЕКРАСКА ИГРОКОВ (только у вас)")
T("Змінювати колір персонажів", "Recolor characters", "Менять цвет персонажей"); T("Кого фарбувати", "Who to recolor", "Кого красить")
T("Усі гравці", "All players", "Все игроки"); T("Лише вороги", "Enemies only", "Только враги"); T("Усі крім мене", "Everyone but me", "Все кроме меня"); T("Лише я", "Only me", "Только я")
T("Стиль", "Style", "Стиль"); T("Один колір", "Solid", "Один цвет"); T("Веселка", "Rainbow", "Радуга"); T("Перелив двох кольорів", "Two-color fade", "Перелив двух цветов")
T("Колір", "Color", "Цвет"); T("Другий колір (перелив)", "Second color (fade)", "Второй цвет (перелив)")
T("Матеріал", "Material", "Материал"); T("Без змін", "Unchanged", "Без изменений"); T("Пластик", "Plastic", "Пластик"); T("Неон", "Neon", "Неон"); T("Метал", "Metal", "Металл"); T("Скло", "Glass", "Стекло")
T("Швидкість переливу", "Fade speed", "Скорость перелива"); T("Прозорість", "Transparency", "Прозрачность")
T("Чорний", "Black", "Чёрный"); T("Сірий", "Gray", "Серый"); T("Золотий", "Gold", "Золотой")
T("ГОЛОВНЕ", "MAIN", "ГЛАВНОЕ"); T("УВІМКНУТИ ВЕСЬ АНТИЧІТ", "ENABLE ALL ANTICHEAT", "ВКЛЮЧИТЬ ВЕСЬ АНТИЧИТ")
T("Весь античіт увімкнено", "All anticheat enabled", "Весь античит включён")
T("СКАНЕР ЧІТІВ", "CHEAT SCANNER", "СКАНЕР ЧИТОВ"); T("Спідхак", "Speed hack", "Спидхак"); T("Політ (fly)", "Fly", "Полёт (fly)")
T("Ноуклип (крізь стіни)", "Noclip (through walls)", "Ноуклип (сквозь стены)"); T("Спінбот / крутилка", "Spinbot", "Спинбот / крутилка")
T("Збільшені хітбокси", "Enlarged hitboxes", "Увеличенные хитбоксы"); T("Невидимість", "Invisibility", "Невидимость")
T("Лаг-світч / телепорт-лаг", "Lag switch / lag teleport", "Лаг-свитч / телепорт-лаг")
T("Показувати невидимих (тіло + мітка крізь стіни)", "Reveal invisible (body + marker through walls)", "Показывать невидимых (тело + метка сквозь стены)")
T("Мітка над головою підозрілого", "Tag above suspect's head", "Метка над головой подозреваемого")
T("Макс. швидкість гравця", "Max player speed", "Макс. скорость игрока"); T("Час у повітрі без падіння", "Hover time in air", "Время в воздухе без падения")
T("Поріг обертання (рад/с)", "Spin threshold (rad/s)", "Порог вращения (рад/с)"); T("Макс. розмір хітбокса", "Max hitbox size", "Макс. размер хитбокса")
T("Підозра (%s): %s", "Suspect (%s): %s", "Подозрение (%s): %s"); T("Сканер: підозрілі", "Scanner: suspects", "Сканер: подозрительные")
T("НЕБО", "SKY", "НЕБО"); T("Змінювати небо", "Change sky", "Менять небо"); T("Пресет неба", "Sky preset", "Пресет неба")
T("Час доби («Своє»)", "Time of day (Custom)", "Время суток («Своё»)"); T("Колір неба («Своє»)", "Sky color (Custom)", "Цвет неба («Своё»)")
T("Щільність атмосфери", "Atmosphere density", "Плотность атмосферы"); T("Швидкість зміни дня/ночі", "Day/night speed", "Скорость смены дня/ночи"); T("Зорі вночі", "Stars at night", "Звёзды ночью")
T("Ясний день", "Clear day", "Ясный день"); T("Захід сонця", "Sunset", "Закат"); T("Ніч", "Night", "Ночь"); T("Космос", "Space", "Космос")
T("Рожева мрія", "Pink dream", "Розовая мечта"); T("Шторм", "Storm", "Шторм"); T("Токсичний", "Toxic", "Токсичный"); T("Неонова ніч", "Neon night", "Неоновая ночь")
T("Веселка (авто)", "Rainbow (auto)", "Радуга (авто)"); T("Своє", "Custom", "Своё")
T("Дебаф: застопорити підозрілого при піканні", "Debuff: freeze suspect when peeking", "Дебаф: застопорить подозреваемого при выглядывании")
T("Тривалість дебафа (лише у вас)", "Debuff duration (local only)", "Длительность дебафа (только у вас)"); T("Перерва між дебафами", "Cooldown between debuffs", "Перерыв между дебафами")
T("Відстань перед вами", "Distance in front of you", "Расстояние перед вами"); T("Тривалість", "Duration", "Длительность")
T("Немає цілі для притягу", "No target to pull", "Нет цели для притягивания")
T("Притяг вимкнено", "Pull stopped", "Притягивание выключено"); T("Притяг: %s", "Pull: %s", "Притягивание: %s")
T("ЛОКАЛЬНИЙ ПРИТЯГ ВОРОГА (лише у вас)", "LOCAL ENEMY PULL (local only)", "ЛОКАЛЬНОЕ ПРИТЯГИВАНИЕ ВРАГА (только у вас)"); T("Притягнути ціль зараз", "Pull target now", "Притянуть цель сейчас")
T("Клавіша притягу (ПК)", "Pull key (PC)", "Клавиша притягивания (ПК)"); T("Тримати клавішу замість перемикання", "Hold key instead of toggle", "Держать клавишу вместо переключения")
T("Включати свою команду", "Include my team", "Включать свою команду")
T("ВІЗУАЛИ", "VISUALS", "ВИЗУАЛЫ"); T("2D-бокс", "2D box", "2D-бокс"); T("Колір боксу", "Box color", "Цвет бокса")
T("Товщина боксу", "Box thickness", "Толщина бокса"); T("Смужка HP збоку", "Side HP bar", "Полоска HP сбоку")
T("Трейсери", "Tracers", "Трейсеры"); T("Колір трейсерів", "Tracer color", "Цвет трейсеров")
T("Початок трейсерів", "Tracer origin", "Начало трейсеров"); T("Знизу", "Bottom", "Снизу"); T("Центр", "Center", "Центр"); T("Курсор", "Cursor", "Курсор")
T("Точка на голові", "Head dot", "Точка на голове"); T("Колір точки", "Dot color", "Цвет точки")
T("Стрілки до ворогів поза екраном", "Off-screen arrows", "Стрелки к врагам вне экрана"); T("Колір стрілок", "Arrow color", "Цвет стрелок")
T("Колір за видимістю (червоний/зелений)", "Visibility color (red/green)", "Цвет по видимости (красный/зелёный)")

T("ТЕЛЕПОРТ ДО ЦІЛІ", "TELEPORT TO TARGET", "ТЕЛЕПОРТ К ЦЕЛИ"); T("Авто-ТП до цілі", "Auto-TP to target", "Авто-ТП к цели")
T("ТП до цілі зараз", "TP to target now", "ТП к цели сейчас"); T("Позиція", "Position", "Позиция")
T("Відстань від цілі", "Distance from target", "Расстояние от цели"); T("Інтервал авто-ТП", "Auto-TP interval", "Интервал авто-ТП")
T("Лише ціль у колі FOV", "Only targets inside FOV", "Только цель в круге FOV")
T("ТП ПРИ ОТРИМАННІ УРОНУ", "TP WHEN DAMAGED", "ТП ПРИ ПОЛУЧЕНИИ УРОНА")
T("Рандомний ТП при уроні", "Random TP on damage", "Случайный ТП при уроне")
T("Мін. дистанція", "Min distance", "Мин. дистанция"); T("Макс. дистанція", "Max distance", "Макс. дистанция")
T("Кулдаун", "Cooldown", "Кулдаун")
T("За спину", "Behind", "За спину"); T("Збоку", "Beside", "Сбоку"); T("Над головою", "Above", "Над головой")

T("ЗАГАЛЬНЕ", "GENERAL", "ОБЩЕЕ"); T("Увімкнути ESP", "Enable ESP", "Включить ESP")
T("Підсвітка тіла", "Body highlight", "Подсветка тела"); T("Видно крізь стіни", "Visible through walls", "Видно сквозь стены")
T("Ховати свою команду", "Hide my team", "Скрывать свою команду")
T("Дальність (5000 = без ліміту)", "Range (5000 = unlimited)", "Дальность (5000 = без лимита)")
T("КОЛЬОРИ", "COLORS", "ЦВЕТА"); T("Колір заливки", "Fill color", "Цвет заливки")
T("Прозорість заливки", "Fill transparency", "Прозрачность заливки"); T("Колір контуру", "Outline color", "Цвет контура")
T("Прозорість контуру", "Outline transparency", "Прозрачность контура"); T("Колір за командою", "Team color", "Цвет по команде")
T("Колір заливки за HP", "Fill color by HP", "Цвет заливки по HP"); T("ПІДПИСИ", "LABELS", "ПОДПИСИ")
T("Імена", "Names", "Имена"); T("HP і смужка здоров'я", "HP and health bar", "HP и полоска здоровья")
T("Дистанція", "Distance", "Дистанция"); T("Розмір тексту", "Text size", "Размер текста")

T("ШВИДКІСТЬ І СТРИБОК", "SPEED AND JUMP", "СКОРОСТЬ И ПРЫЖОК"); T("Власна швидкість", "Custom speed", "Своя скорость")
T("Швидкість бігу", "Run speed", "Скорость бега"); T("Власна сила стрибка", "Custom jump power", "Своя сила прыжка")
T("Сила стрибка", "Jump power", "Сила прыжка"); T("Нескінченний стрибок", "Infinite jump", "Бесконечный прыжок")
T("ПЕРЕСУВАННЯ", "MOVEMENT", "ПЕРЕДВИЖЕНИЕ"); T("Noclip (крізь стіни)", "Noclip (through walls)", "Noclip (сквозь стены)")
T("ВСЕ, ЩО РУХАЄТЬСЯ (крізь стіни)", "EVERYTHING THAT MOVES (THROUGH WALLS)", "ВСЁ, ЧТО ДВИЖЕТСЯ (СКВОЗЬ СТЕНЫ)"); T("Підсвічувати рухомі об'єкти", "Highlight moving objects", "Подсвечивать движущиеся объекты")
T("Мін. швидкість руху", "Min movement speed", "Мин. скорость движения"); T("Мін. розмір об'єкта", "Min object size", "Мин. размер объекта")
T("Дальність пошуку", "Search range", "Дальность поиска"); T("Макс. об'єктів", "Max objects", "Макс. объектов")
T("Підпис (назва, дистанція, швидкість)", "Label (name, distance, speed)", "Подпись (имя, дистанция, скорость)"); T("Пропускати гравців (вони вже в ESP)", "Skip players (already in ESP)", "Пропускать игроков (они уже в ESP)")
T("Цілитись у все, що рухається", "Also aim at anything that moves", "Целиться во всё, что движется")
T("БЛІЦ (оберт навколо ворога)", "BLITZ (ORBIT AN ENEMY)", "БЛИЦ (ВРАЩЕНИЕ ВОКРУГ ВРАГА)"); T("Клавіша бліцу (ПК)", "Blitz key (PC)", "Клавиша блица (ПК)")
T("Бліц по цілі в колі FOV", "Blitz the target in FOV", "Блиц по цели в круге FOV"); T("Тривалість", "Duration", "Длительность"); T("Радіус", "Radius", "Радиус")
T("Швидкість обертання", "Rotation speed", "Скорость вращения"); T("Висота над ціллю", "Height above target", "Высота над целью"); T("Напрямок", "Direction", "Направление")
T("Макс. дистанція старту", "Max start distance", "Макс. дистанция старта"); T("Тримати приціл на цілі", "Keep aim on target", "Держать прицел на цели")
T("Повертати назад після бліцу", "Return after blitz", "Возвращать назад после блица")
T("За годинниковою", "Clockwise", "По часовой"); T("Проти годинникової", "Counter-clockwise", "Против часовой"); T("Чергувати", "Alternate", "Чередовать")
T("Бліц завершено", "Blitz finished", "Блиц завершён"); T("Бліц: немає цілі в колі FOV", "Blitz: no target in FOV circle", "Блиц: нет цели в круге FOV")
T("Бліц: ціль занадто далеко", "Blitz: target too far", "Блиц: цель слишком далеко"); T("Бліц: обертання навколо цілі", "Blitz: orbiting target", "Блиц: вращение вокруг цели")
T("КОНФІГИ (слоти до закриття гри)", "CONFIGS (slots until the game closes)", "КОНФИГИ (слоты до закрытия игры)"); T("Слот", "Slot", "Слот")
T("Слот 1", "Slot 1", "Слот 1"); T("Слот 2", "Slot 2", "Слот 2"); T("Слот 3", "Slot 3", "Слот 3"); T("Слот 4", "Slot 4", "Слот 4"); T("Слот 5", "Slot 5", "Слот 5")
T("Зберегти в слот", "Save to slot", "Сохранить в слот"); T("Завантажити зі слота", "Load from slot", "Загрузить из слота"); T("Очистити слот", "Clear slot", "Очистить слот")
T("Слот у поле (для копіювання)", "Slot to field (to copy)", "Слот в поле (для копирования)"); T("Поле у слот", "Field to slot", "Поле в слот")
T("Збережено у слот %d", "Saved to slot %d", "Сохранено в слот %d"); T("Завантажено зі слота %d", "Loaded from slot %d", "Загружено из слота %d")
T("Слот порожній", "Slot is empty", "Слот пуст"); T("Слот скопійовано в поле", "Slot copied to the field", "Слот скопирован в поле"); T("порожньо", "empty", "пусто")
T("ПРОДУКТИВНІСТЬ (лише у вас)", "PERFORMANCE (local only)", "ПРОИЗВОДИТЕЛЬНОСТЬ (только у вас)")
T("Буст FPS (без тіней, легкі текстури)", "FPS boost (no shadows, light textures)", "Буст FPS (без теней, лёгкие текстуры)")
T("Рівень буста", "Boost level", "Уровень буста"); T("Не чіпати персонажів", "Leave characters alone", "Не трогать персонажей")
T("Легкий", "Light", "Лёгкий"); T("Сильний", "Strong", "Сильный"); T("Максимум", "Maximum", "Максимум")
T("Політ", "Fly", "Полёт"); T("Режим польоту", "Fly mode", "Режим полёта"); T("Телепорт", "Teleport", "Телепорт"); T("Фізика", "Physics", "Физика"); T("Гібрид", "Hybrid", "Гибрид")
T("Клавіша польоту (ПК)", "Fly key (PC)", "Клавиша полёта (ПК)"); T("Довжина кроку", "Step length", "Длина шага")
T("Інтервал між кроками", "Step interval", "Интервал между шагами"); T("Ліміт швидкості (ст/с)", "Speed limit (st/s)", "Лимит скорости (ст/с)")
T("Множник вертикалі", "Vertical multiplier", "Множитель вертикали"); T("Йти за нахилом камери", "Follow camera pitch", "Идти по наклону камеры")
T("Плавно (без стрибків)", "Smooth (no hops)", "Плавно (без прыжков)"); T("Розгін зі старту", "Ramp up from start", "Разгон со старта")
T("Час розгону", "Ramp time", "Время разгона"); T("Висіти в повітрі без руху", "Hover when idle", "Висеть в воздухе без движения")
T("Зупинка об стіни (без ноуклипу)", "Stop at walls (without noclip)", "Остановка у стен (без ноуклипа)")
T("Банніхоп (затисни пробіл)", "Bunnyhop (hold jump)", "Банихоп (держи прыжок)"); T("Макс. швидкість банніхопу", "Bhop max speed", "Макс. скорость банихопа")
T("Розгін у повітрі", "Air acceleration", "Разгон в воздухе"); T("БАННІХОП", "BUNNYHOP", "БАНИХОП")
T("АНТИПРИЦІЛ", "ANTI-AIM", "АНТИПРИЦЕЛ"); T("Антиприціл", "Anti-aim", "Антиприцел")
T("Режим", "Mode", "Режим"); T("Швидкість крутилки", "Spin speed", "Скорость вращения")
T("Крутилка", "Spin", "Вращение"); T("Хаос", "Chaos", "Хаос")
T("Хитавиця", "Jitter", "Тряска"); T("Ривки", "Flicks", "Рывки")
T("Напрямок обертання", "Spin direction", "Направление вращения")
T("За годинниковою", "Clockwise", "По часовой"); T("Проти годинникової", "Counter-clockwise", "Против часовой"); T("Змінювати напрямок", "Alternate direction", "Менять направление")
T("Частота змін (Гц)", "Change rate (Hz)", "Частота смены (Гц)"); T("Розмах хитавиці / ривка", "Jitter / flick angle", "Размах тряски / рывка")
T("Плавний розгін і зупинка", "Smooth spin-up and stop", "Плавный разгон и остановка"); T("Не штовхати інших поруч", "Don't push others nearby", "Не толкать других рядом")
T("Клавіша антиприцілу (ПК)", "Anti-aim key (PC)", "Клавиша антиприцела (ПК)"); T("Плавно для інших гравців", "Smooth for other players", "Плавно для других игроков")
T("Сила яскравості", "Brightness strength", "Сила яркости"); T("Прибрати туман і серпанок", "Remove fog and haze", "Убрать туман и дымку")
T("Прибрати темні й розмиті ефекти", "Remove dark and blur effects", "Убрать тёмные и размытые эффекты"); T("Завжди день (14:00)", "Always daytime (14:00)", "Всегда день (14:00)")
T("Режим стрибка", "Jump mode", "Режим прыжка"); T("Без ліміту", "Unlimited", "Без лимита"); T("Кілька стрибків", "Several jumps", "Несколько прыжков"); T("Утримання", "Hold to repeat", "Удержание")
T("Стрибків у повітрі (режим «Кілька»)", "Air jumps (Several mode)", "Прыжков в воздухе (режим «Несколько»)"); T("Сила стрибка у повітрі", "Air jump power", "Сила прыжка в воздухе")
T("Пауза між стрибками", "Pause between jumps", "Пауза между прыжками"); T("Кільце під ногами при стрибку", "Ring under feet on jump", "Кольцо под ногами при прыжке")
T("Показувати лічильник стрибків", "Show jump counter", "Показывать счётчик прыжков")
T("Свій приціл у центрі", "Custom crosshair", "Свой прицел в центре"); T("Стиль прицілу", "Crosshair style", "Стиль прицела")
T("Хрестик", "Cross", "Крестик"); T("Т-подібний", "T-shape", "Т-образный"); T("Крапка", "Dot", "Точка"); T("Коло", "Circle", "Круг"); T("Хрестик з крапкою", "Cross with dot", "Крестик с точкой")
T("Довжина ліній / розмір", "Line length / size", "Длина линий / размер"); T("Розрив у центрі", "Center gap", "Разрыв в центре"); T("Товщина", "Thickness", "Толщина")
T("Прозорість прицілу", "Crosshair transparency", "Прозрачность прицела"); T("Колір прицілу", "Crosshair color", "Цвет прицела"); T("Чорна обводка", "Black outline", "Чёрная обводка")
T("Розширюється при русі, стрибку й пострілі", "Expands on move, jump and shot", "Расширяется при движении, прыжке и выстреле")
T("Червоний, коли ворог під прицілом", "Red when an enemy is under the crosshair", "Красный, когда враг под прицелом")
T("Маркер влучання (приблизний)", "Hit marker (approximate)", "Маркер попадания (приблизительный)")
T("Назад до камери", "Back to camera", "Спиной к камере")

T("Монет з назвою '%s' поруч не знайдено", "No coins named '%s' nearby", "Монет с названием '%s' рядом не найдено"); T("ЗБІР МОНЕТ", "COIN COLLECTING", "СБОР МОНЕТ"); T("Авто-збір монет", "Auto-collect coins", "Авто-сбор монет")
T("Назва об'єкта", "Object name", "Название объекта"); T("Інтервал", "Interval", "Интервал")
T("Радіус пошуку", "Search radius", "Радиус поиска"); T("Повертатись назад", "Return back", "Возвращаться назад")
T("ВІЗУАЛ", "VISUALS", "ВИЗУАЛ"); T("Повна яскравість", "Full brightness", "Полная яркость")
T("Власний FOV камери", "Custom camera FOV", "Свой FOV камеры"); T("FOV камери", "Camera FOV", "FOV камеры")
T("Власна гравітація", "Custom gravity", "Своя гравитация"); T("Гравітація", "Gravity", "Гравитация")
T("Пресет гравітації", "Gravity preset", "Пресет гравитации")
T("Своя", "Custom", "Своя"); T("Місяць", "Moon", "Луна"); T("Марс", "Mars", "Марс")
T("Звичайна", "Normal", "Обычная"); T("Важка", "Heavy", "Тяжёлая"); T("Майже невагомість", "Near zero-g", "Почти невесомость")
T("Стрибок за фізикою (вищий при слабкій гравітації)", "Physical jump (higher in low gravity)", "Прыжок по физике (выше при слабой гравитации)")
T("Вид від 3-ї особи", "Third-person view", "Вид от 3-го лица"); T("Відстань камери", "Camera distance", "Расстояние камеры")
T("Вільний зум (колесо/щипок)", "Free zoom (wheel/pinch)", "Свободный зум (колесо/щипок)"); T("Вид від 3-ї особи (клавіша)", "Third-person (key)", "Вид от 3-го лица (клавиша)")

T("ПОШУК ДРОНІВ", "DRONE SEARCH", "ПОИСК ДРОНОВ")
T("Назви дронів (через кому)", "Drone names (comma separated)", "Названия дронов (через запятую)")
T("Виключити (через кому)", "Exclude (comma separated)", "Исключить (через запятую)")
T("Перевірити: скільки знайдено", "Check: how many found", "Проверить: сколько найдено")
T("ВИЯВЛЕННЯ", "DETECTION", "ОБНАРУЖЕНИЕ"); T("Підсвітка дронів", "Drone highlight", "Подсветка дронов")
T("Колір підсвітки", "Highlight color", "Цвет подсветки"); T("Попередження про дрон", "Drone warning", "Предупреждение о дроне")
T("Радіус попередження", "Warning radius", "Радиус предупреждения"); T("ЗБИВАННЯ", "SHOOTING DOWN", "СБИВАНИЕ")
T("Автоприціл на дрони", "Auto-aim at drones", "Автоприцел на дроны"); T("Дальність прицілу", "Aim range", "Дальность прицела")
T("Автовогонь по дрону", "Auto-fire at drone", "Автоогонь по дрону"); T("УХИЛЕННЯ", "EVASION", "УКЛОНЕНИЕ")
T("Авто-ухилення від дрона", "Auto-evade drone", "Авто-уклонение от дрона")
T("Радіус спрацювання", "Trigger radius", "Радиус срабатывания"); T("Відстань ухилення", "Evade distance", "Дистанция уклонения")
T("Кулдаун ухилення", "Evade cooldown", "Кулдаун уклонения")
T("Дронів знайдено: %d (ворожих: %d)", "Drones found: %d (hostile: %d)", "Дронов найдено: %d (вражеских: %d)")
T("ДРОН %d ст", "DRONE %d st", "ДРОН %d ст"); T("ДРОН %s %d ст", "DRONE %s %d st", "ДРОН %s %d ст")

T("АНТИФЛІНГ", "ANTI-FLING", "АНТИФЛИНГ"); T("Антифлінг", "Anti-fling", "Антифлинг")
T("Без колізій з гравцями", "No player collisions", "Без коллизий с игроками")
T("Гасити різкі поштовхи", "Dampen sudden pushes", "Гасить резкие толчки")
T("Не падати від ударів", "Don't ragdoll from hits", "Не падать от ударов")
T("Повертати з прірви", "Return from the void", "Возвращать из пропасти")
T("Сповіщати про флінг", "Notify about fling", "Уведомлять о флинге")
T("Поріг швидкості", "Speed threshold", "Порог скорости"); T("Поріг обертання", "Spin threshold", "Порог вращения")
T("АНТИ-СИДІННЯ", "ANTI-SIT", "АНТИ-СИДЕНИЕ"); T("Анти-сидіння", "Anti-sit", "Анти-сидение")
T("Що блокувати", "What to block", "Что блокировать"); T("Поріг швидкості сидіння", "Seat speed threshold", "Порог скорости сиденья")
T("Сповіщати про блокування", "Notify on block", "Уведомлять о блокировке")
T("Чужі й швидкі сидіння", "Foreign & fast seats", "Чужие и быстрые сиденья")
T("Усе, крім транспорту", "All except vehicles", "Всё, кроме транспорта"); T("Усі сидіння", "All seats", "Все сиденья")
T("АНТИ-ПАДІННЯ", "ANTI-FREEFALL", "АНТИ-ПАДЕНИЕ"); T("Анти-падіння", "Anti-freefall", "Анти-падение")
T("Макс. висота над землею", "Max height above ground", "Макс. высота над землёй")
T("Макс. швидкість падіння", "Max fall speed", "Макс. скорость падения")
T("Сповіщати про порятунок", "Notify on rescue", "Уведомлять о спасении")
T("Спосіб порятунку", "Rescue method", "Способ спасения"); T("Розумний", "Smart", "Умный")
T("Повернення на землю", "Return to ground", "Возврат на землю"); T("М'яка посадка", "Soft landing", "Мягкая посадка")
T("Швидкість приземлення", "Landing speed", "Скорость приземления"); T("Показувати місце приземлення", "Show landing spot", "Показывать место приземления")
T("Анти-падіння: м'яка посадка", "Anti-freefall: soft landing", "Анти-падение: мягкая посадка"); T("ПОСАДКА  %d ст", "LANDING  %d st", "ПОСАДКА  %d ст")
T("АНТИ-ТП-ФЛІК", "ANTI-TP-FLICK", "АНТИ-ТП-ФЛИК"); T("Анти-ТП-флік", "Anti-TP-flick", "Анти-ТП-флик")
T("Мін. дальність примусового ТП", "Min forced TP distance", "Мин. дальность принудительного ТП")
T("Лише якщо поруч ворог", "Only if an enemy is nearby", "Только если рядом враг")
T("Повертати назад", "Revert position", "Возвращать назад")
T("АНТИ-СЛІПОТА", "ANTI-BLIND", "АНТИ-СЛЕПОТА"); T("Анти-сліпота", "Anti-blind", "Анти-слепота")
T("Макс. розмиття", "Max blur", "Макс. размытие"); T("Макс. яскравість спалаху", "Max flash brightness", "Макс. яркость вспышки")
T("Гасити білі екрани (GUI)", "Dim white screens (GUI)", "Гасить белые экраны (GUI)")
T("Ігнорувати інтерфейси (через кому)", "Ignore GUIs (comma separated)", "Игнорировать интерфейсы (через запятую)")
T("Вимкнути весь захист", "Disable all protection", "Выключить всю защиту")
T("Антифлінг: удар погашено", "Anti-fling: hit absorbed", "Антифлинг: удар погашен")
T("Антифлінг: повернено з прірви", "Anti-fling: returned from the void", "Антифлинг: возвращён из пропасти")
T("Антифлінг: повернено з-під карти", "Anti-fling: returned from under the map", "Антифлинг: возвращён из-под карты")
T("Антифлінг: %s заморожено подалі", "Anti-fling: %s frozen and parked away", "Антифлинг: %s заморожен и отведён подальше")
T("Рятувати з-під карти", "Rescue from under the map", "Спасать из-под карты")
T("Заморожувати флінгерів за 100 студів", "Freeze flingers 100 studs away", "Замораживать флингеров за 100 студов")
T("Підозра на fling: %s", "Fling suspected: %s", "Подозрение на fling: %s")
T("Анти-сидіння: вас зняли з сидіння", "Anti-sit: you were unseated", "Анти-сидение: вас сняли с сиденья")
T("Анти-падіння: повернуто на землю", "Anti-freefall: returned to the ground", "Анти-падение: возвращён на землю")
T("Анти-ТП-флік: повернуто назад", "Anti-TP-flick: moved back", "Анти-ТП-флик: возвращён назад")
T("Анти-ТП-флік: вас перемістили", "Anti-TP-flick: you were moved", "Анти-ТП-флик: вас переместили")
T("Анти-сліпота: ефект приглушено", "Anti-blind: effect dimmed", "Анти-слепота: эффект приглушён")

T("БЕЗПЕЧНЕ МІСЦЕ", "SAFE SPOT", "БЕЗОПАСНОЕ МЕСТО")
T("Створити безпечне місце тут", "Create safe spot here", "Создать безопасное место здесь")
T("ТП у безпечне місце", "TP to safe spot", "ТП в безопасное место")
T("Видалити безпечне місце", "Delete safe spot", "Удалить безопасное место")
T("Безпечне місце створено", "Safe spot created", "Безопасное место создано")
T("Безпечне місце видалено", "Safe spot deleted", "Безопасное место удалено")
T("Спершу створіть безпечне місце", "Create a safe spot first", "Сначала создайте безопасное место")
T("Не вдалося: під вами немає землі", "Failed: no ground below you", "Не удалось: под вами нет земли")
T("Немає живого персонажа", "No living character", "Нет живого персонажа")
T("SAFE · %d ст", "SAFE · %d st", "SAFE · %d ст")

T("КОНТР-ТП", "COUNTER-TP", "КОНТР-ТП")
T("Контр-ТП, якщо тепнулись до мене", "Counter-TP if someone TPs to me", "Контр-ТП, если телепортировались ко мне")
T("Реакція", "Reaction", "Реакция"); T("Лише якщо опинились за спиною", "Only if behind me", "Только если оказались за спиной")
T("Розвертати камеру на ворога", "Turn camera to enemy", "Разворачивать камеру на врага")
T("Мін. дальність ТП ворога", "Min enemy TP distance", "Мин. дальность ТП врага")
T("Затримка реакції", "Reaction delay", "Задержка реакции")
T("ТП за спину ворогу", "TP behind the enemy", "ТП за спину врагу"); T("Лише розвернутись", "Only turn around", "Только развернуться")
T("Лише сповіщення", "Notify only", "Только уведомление")
T("До вас тепнувся: %s", "%s teleported to you", "К вам телепортировался: %s")
T("Контр-ТП: %s", "Counter-TP: %s", "Контр-ТП: %s"); T("Розворот на: %s", "Turning to: %s", "Разворот на: %s")
T("Безпечний контр-ТП (не за карту)", "Safe counter-TP (never off the map)", "Безопасный контр-ТП (не за карту)")
T("Контр-ТП скасовано: %s поза безпечною зоною", "Counter-TP cancelled: %s is outside the safe zone", "Контр-ТП отменён: %s вне безопасной зоны")
T("Контр-ТП: повернуто назад", "Counter-TP: returned back", "Контр-ТП: возврат назад")
T("ТП ВОРОГІВ", "ENEMY TELEPORTS", "ТП ВРАГОВ"); T("Підсвічувати ТП ворогів", "Highlight enemy teleports", "Подсвечивать ТП врагов")
T("Мін. дальність ТП", "Min TP distance", "Мин. дальность ТП"); T("Макс. відстань до мене", "Max distance to me", "Макс. расстояние до меня")
T("Скільки тримати мітку", "Marker duration", "Сколько держать метку"); T("Включати свою команду", "Include my team", "Включать свою команду")
T("Колір мітки", "Marker color", "Цвет метки"); T("ТП: %s %s %d ст", "TP: %s %s %d st", "ТП: %s %s %d ст")
T("ПРИЦІЛ НА ВАС", "AIMED AT YOU", "ПРИЦЕЛ НА ВАС"); T("Сповіщати про приціл на мене", "Warn when aimed at me", "Предупреждать о прицеле на меня")
T("Кут наведення", "Aim angle", "Угол наведения"); T("Мін. час утримання", "Min hold time", "Мин. время удержания")
T("Лише якщо немає стін", "Only without walls", "Только без стен"); T("Макс. дистанція", "Max distance", "Макс. дистанция")
T("ПРИЦІЛ НА ВАС: %s %s %d ст", "AIMED AT YOU: %s %s %d st", "ПРИЦЕЛ НА ВАС: %s %s %d ст")
T("ПІДОЗРА НА АІМБОТ", "AIMBOT SUSPICION", "ПОДОЗРЕНИЕ НА АИМБОТ"); T("Шукати підозрілих", "Look for suspects", "Искать подозрительных")
T("Поріг різкого повороту", "Snap-turn threshold", "Порог резкого поворота")
T("Спрацювань до підозри", "Snaps before suspicion", "Срабатываний до подозрения")
T("Мітка над головою", "Tag above head", "Метка над головой"); T("Сповіщати про підозрілих", "Notify about suspects", "Уведомлять о подозрительных")
T("Підозра на аімбот: %s", "Aimbot suspected: %s", "Подозрение на аимбот: %s")
T("Підозрілі", "Suspects", "Подозрительные"); T("немає", "none", "нет")

T("ВИГЛЯД МЕНЮ", "MENU APPEARANCE", "ВИД МЕНЮ"); T("Мова", "Language", "Язык")
T("Акцентний колір", "Accent color", "Акцентный цвет"); T("Авто-масштаб під екран", "Auto-scale to screen", "Авто-масштаб под экран")
T("Масштаб меню", "Menu scale", "Масштаб меню"); T("Прозорість меню", "Menu transparency", "Прозрачность меню")
T("Сповіщення про вмик/вимк", "Toggle notifications", "Уведомления о вкл/выкл")
T("Швидкі кнопки на екрані", "On-screen quick buttons", "Быстрые кнопки на экране")
T("Діагностика (ціль у футері)", "Diagnostics (target in footer)", "Диагностика (цель в футере)")
T("КЛАВІШІ (ПК), BACKSPACE = ПРИБРАТИ", "KEYS (PC), BACKSPACE = CLEAR", "КЛАВИШИ (ПК), BACKSPACE = УБРАТЬ")
T("Відкрити меню", "Open menu", "Открыть меню"); T("Вмик/вимк автоприціл", "Toggle auto-aim", "Вкл/выкл автоприцел")
T("ТП до цілі", "TP to target", "ТП к цели"); T("Вимкнути все", "Disable all", "Выключить всё")
T("СКИДАННЯ", "RESET", "СБРОС"); T("Вимкнути всі функції", "Disable all features", "Выключить все функции")
T("Скинути всі налаштування", "Reset all settings", "Сбросить все настройки")

T("Авто через %d", "Auto in %d", "Авто через %d")
T("Пропустити", "Skip", "Пропустить")

local aimHeld = false
local overMenu = false
local lastAimPoint = Vector2.new(400, 300)
local lastTp, lastTpTry = 0, 0
local flyOn, bhopHV, bhopSet = false, Vector3.zero, 0
local flyAcc, flyRampT = 0, 0
local flyRp = RaycastParams.new()
flyRp.FilterType = Enum.RaycastFilterType.Exclude
flyRp.RespectCanCollide = true
local currentTarget = nil

local pulledChars = setmetatable({}, { __mode = "k" })
local function isPulled(char) local t = char and pulledChars[char]; return t ~= nil and t > os.clock() end
local npcList, lastNpcScan = {}, 0
local motionTargets = {}
local orig = {}
local noclipSaved = {}
local listening = nil
local gateOpen = true
local splashActive = false
local charBorn = os.clock()

local selfMoveUntil = 0
local function markSelf(t) selfMoveUntil = os.clock() + (t or 0.35) end

local Safe = { cf = nil }

N.ARROWS = { "12", "1:30", "3", "4:30", "6", "7:30", "9", "10:30" }
local function arrowFor(cam, pos)
	local rel = cam.CFrame:PointToObjectSpace(pos)
	local a = math.atan2(rel.X, -rel.Z)
	local idx = math.floor((a + math.pi / 8) / (math.pi / 4)) % 8 + 1
	return N.ARROWS[idx]
end

local function getCamera() return workspace.CurrentCamera end
local function getRoot(char) return char and char:FindFirstChild("HumanoidRootPart") end
local function getHum(char) return char and char:FindFirstChildOfClass("Humanoid") end

local function isAlive(char)
	local hum = getHum(char)
	return hum ~= nil and hum.Health > 0
end

local function isTeammate(plr)
	return plr ~= nil and player.Team ~= nil and plr.Team == player.Team
end

local function getAimPart(char)
	local idx = S.AimPart
	local part
	if idx == 1 then
		part = char:FindFirstChild("Head")
	elseif idx == 2 then
		part = char:FindFirstChild("UpperTorso") or char:FindFirstChild("Torso")
	end
	return part or char:FindFirstChild("HumanoidRootPart")
end

local function scanNPCs()
	local list = {}
	for _, inst in workspace:GetDescendants() do
		if inst:IsA("Humanoid") then
			local char = inst.Parent
			if char and char ~= player.Character and not Players:GetPlayerFromCharacter(char) then
				list[#list + 1] = char
			end
		end
	end
	npcList = list
end

local function collect(ignoreTeam)
	local out = {}
	for _, plr in Players:GetPlayers() do
		if plr ~= player and plr.Character and not (ignoreTeam and isTeammate(plr)) then
			out[#out + 1] = { char = plr.Character, plr = plr }
		end
	end
	if S.IncludeNPCs then
		for _, char in npcList do
			if char.Parent then out[#out + 1] = { char = char } end
		end
	end
	return out
end

N.OFF, N.CUT, N.secs = {}, {}, {}
N.C_BG = Color3.fromRGB(23, 21, 20)
N.C_PANEL = Color3.fromRGB(31, 29, 27)
N.C_ROW_HI = Color3.fromRGB(42, 39, 36)
N.C_LINE = Color3.fromRGB(62, 58, 53)
N.C_TEXT = Color3.fromRGB(238, 232, 222)
N.C_DIM = Color3.fromRGB(152, 144, 132)
local ACCENT = N.ACCENTS[S.Accent][2]

local function pickFont(name, fallback)
	local ok, f = pcall(function() return Enum.Font[name] end)
	return ok and f or fallback
end
N.FONT = pickFont("GothamMedium", Enum.Font.SourceSans)
local FONT_B = pickFont("GothamBold", Enum.Font.SourceSansBold)
N.FONT_BRAND = pickFont("Michroma", FONT_B)
N.FONT_MONO = Enum.Font.RobotoMono

N.TI_FAST = TweenInfo.new(0.12, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
local function tween(obj, props, info)
	local th = N.theme
	if th then
		local okT, np, ni = pcall(th.tw, obj, props, info)
		if okT then props, info = np, ni end
	end
	local ok = pcall(function() TweenService:Create(obj, info or N.TI_FAST, props):Play() end)
	if not ok then for k, v in props do pcall(function() obj[k] = v end) end end
end
N.ti = function(i) return N.theme and N.theme.ti(i) or i end

N.ROW_H = isTouch and 46 or 40
N.FOOT_H = 22
N.HEAD_H = isTouch and 44 or 44
N.SIDE_W = isTouch and 100 or 134
N.DOCK_W = isTouch and 96 or 56
N.DOCK_H = isTouch and 294 or 320
N.TAB_PAD = isTouch and 12 or 26
N.TAB_PAD_ON = isTouch and 16 or 31
N.TAB_PAD_HOV = isTouch and 12 or 29
N.TOP_BAR = isTouch and 58 or 44
N.WIN_TOP = N.TOP_BAR + (isTouch and 0 or 38)
N.TXT = isTouch and 14 or 13

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

local function register(key, fn)
	local cur = N.cur
	if cur and not cur.set[key] then
		cur.set[key] = true
		cur.keys[#cur.keys + 1] = key
	end
	local cr = N.curRow
	if cur and cr and not cr.set[key] then
		cr.set[key] = true
		cr.keys[#cr.keys + 1] = key
	end
	widgets[key] = widgets[key] or {}
	table.insert(widgets[key], fn)
	fn()
end

local function acc(obj, prop)
	table.insert(N.accentRefs, { obj, prop })
	obj[prop] = ACCENT
end

local function corner(parent, radius)
	local c = Instance.new("UICorner")
	radius = radius or 2
	if radius < 1000 then radius = math.min(radius, 14) end
	c.CornerRadius = UDim.new(0, radius)
	c.Parent = parent
	return c
end

local function addStroke(parent, color, thickness, transparency)
	local s = Instance.new("UIStroke")
	s.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
	s.Color = color
	s.Thickness = thickness or 1
	s.Transparency = transparency or 0
	s.Parent = parent
	return s
end

local function makeText(parent, size, pos, text, textSize, color, font, align, noBind)
	local l = Instance.new("TextLabel")
	l.Size = size
	l.Position = pos
	l.BackgroundTransparency = 1
	l.Text = text
	l.TextColor3 = color or N.C_TEXT
	l.Font = font or N.FONT
	l.TextSize = textSize or N.TXT
	l.TextXAlignment = align or Enum.TextXAlignment.Left
	l.TextTruncate = Enum.TextTruncate.AtEnd
	l.Parent = parent
	if text ~= "" and not noBind then bind(l, text) end
	return l
end

local function setValue(key, value, silent)
	if N.OFF[key] and value ~= false then return end
	S[key] = value
	for _, r in widgets[key] or {} do r() end
	if key == "Accent" then
		if N.theme then N.theme.onAccent() else applyAccent() end
	end
	if key == "Lang" then applyLang() end
	if key == "GravPreset" then
		local pct = value > 1 and N.GRAV_PRESETS[value]
		if pct then setValue("Gravity", pct, true) end
	elseif key == "Gravity" then
		local idx = 1
		for i = 2, #N.GRAV_PRESETS do
			if N.GRAV_PRESETS[i] == value then idx = i end
		end
		if S.GravPreset ~= idx then
			S.GravPreset = idx
			for _, r in widgets.GravPreset or {} do r() end
		end
	end
	if applyVisuals then applyVisuals() end
	if key == "Coins" and startCoinLoop then startCoinLoop() end
	if N.THEME_SET[key] and N.theme then N.theme.onSet(key) end
	if N.SAVE_SET[key] and N.save then N.save.mark(key) end
	if not silent and type(value) == "boolean" and N.toggleLabels[key] and notify then
		notify(N.toggleLabels[key], value)
	end
end

do

	local overlay = Instance.new("ScreenGui")
	overlay.Name = "FunModeOverlay"
	overlay.ResetOnSpawn = false
	overlay.ScreenInsets = Enum.ScreenInsets.None
	overlay.DisplayOrder = 99
	overlay.Parent = playerGui
	UI.overlay = overlay

	local circle = Instance.new("Frame")
	circle.AnchorPoint = Vector2.new(0.5, 0.5)
	circle.BackgroundTransparency = 1
	circle.Visible = false
	circle.Parent = overlay
	corner(circle, 9999)
	UI.circle = circle
	UI.circleStroke = addStroke(circle, Color3.new(1, 1, 1), 2, 0.15)

	local lockMark = Instance.new("Frame")
	lockMark.AnchorPoint = Vector2.new(0.5, 0.5)
	lockMark.BackgroundTransparency = 1
	lockMark.Size = UDim2.fromOffset(isTouch and 30 or 24, isTouch and 30 or 24)
	lockMark.Visible = false
	lockMark.Parent = overlay
	corner(lockMark, 9999)
	UI.lockMark = lockMark
	acc(addStroke(lockMark, ACCENT, 2, 0), "Color")

	local gui = Instance.new("ScreenGui")
	gui.Name = "FunModeGui"
	gui.ResetOnSpawn = false
	gui.ScreenInsets = Enum.ScreenInsets.DeviceSafeInsets
	gui.DisplayOrder = 100
	gui.Parent = playerGui
	UI.gui = gui

	local dock = Instance.new("Frame")
	dock.Name = "Dock"
	dock.AnchorPoint = Vector2.new(0, 0.5)
	dock.Position = UDim2.new(0, 6, 0.5, 0)
	dock.Size = UDim2.fromOffset(N.DOCK_W, N.DOCK_H)
	dock.BackgroundTransparency = 1
	dock.Parent = gui
	if isTouch then
		dock.AnchorPoint = Vector2.new(0, 0)
		dock.Position = UDim2.new(0, 6, 0, N.TOP_BAR)
		local dg = Instance.new("UIGridLayout")
		dg.CellSize = UDim2.fromOffset(46, 38)
		dg.CellPadding = UDim2.fromOffset(4, 4)
		dg.FillDirection = Enum.FillDirection.Horizontal
		dg.FillDirectionMaxCells = 2
		dg.SortOrder = Enum.SortOrder.LayoutOrder
		dg.Parent = dock
	else
		local dl = Instance.new("UIListLayout")
		dl.Padding = UDim.new(0, 5)
		dl.SortOrder = Enum.SortOrder.LayoutOrder
		dl.VerticalAlignment = Enum.VerticalAlignment.Center
		dl.Parent = dock
	end
	UI.dock = dock

	UI.dockScale = Instance.new("UIScale")
	UI.dockScale.Parent = dock

	local menuBtn = Instance.new("TextButton")
	menuBtn.Size = UDim2.fromOffset(isTouch and N.DOCK_W or 84, isTouch and 40 or 32)
	menuBtn.BackgroundColor3 = N.C_BG
	menuBtn.BackgroundTransparency = 0.08
	menuBtn.AutoButtonColor = false
	menuBtn.TextColor3 = N.C_TEXT
	menuBtn.Font = FONT_B
	menuBtn.TextSize = isTouch and 11 or 13
	bind(menuBtn, "МЕНЮ")
	corner(menuBtn, 9)
	local mbs = addStroke(menuBtn, N.C_LINE, 1)
	menuBtn.MouseEnter:Connect(function()
		tween(menuBtn, { BackgroundTransparency = 0 })
		tween(mbs, { Color = ACCENT })
	end)
	menuBtn.MouseLeave:Connect(function()
		tween(menuBtn, { BackgroundTransparency = 0.08 })
		tween(mbs, { Color = N.C_LINE })
	end)
	if isTouch then
		menuBtn.LayoutOrder = 0
		menuBtn.Parent = dock
	else
		menuBtn.Position = UDim2.new(0, 12, 0, N.TOP_BAR)
		menuBtn.Parent = gui
	end
	UI.menuBtn = menuBtn

	local toasts = Instance.new("Frame")
	toasts.AnchorPoint = Vector2.new(0.5, 0)
	toasts.Position = UDim2.new(0.5, 0, 0, 10)
	toasts.Size = UDim2.fromOffset(260, 0)
	toasts.AutomaticSize = Enum.AutomaticSize.Y
	toasts.BackgroundTransparency = 1
	toasts.Parent = gui
	local tl = Instance.new("UIListLayout")
	tl.Padding = UDim.new(0, 4)
	tl.HorizontalAlignment = Enum.HorizontalAlignment.Center
	tl.SortOrder = Enum.SortOrder.LayoutOrder
	tl.Parent = toasts
	UI.toasts = toasts

	local window = Instance.new("CanvasGroup")
	window.Name = "Window"
	window.GroupTransparency = 1
	window.Position = UDim2.fromOffset(12, N.WIN_TOP)
	window.Size = UDim2.fromOffset(480, 380)
	window.BackgroundColor3 = N.C_BG
	window.BorderSizePixel = 0
	window.ClipsDescendants = true
	window.Visible = false
	window.Parent = gui
	corner(window, 12)
	UI.window = window

	addStroke(window, N.C_LINE, 1, 0)

	UI.scale = Instance.new("UIScale")
	UI.scale.Parent = window

	local header = Instance.new("Frame")
	header.Size = UDim2.new(1, 0, 0, N.HEAD_H)
	header.BackgroundTransparency = 1
	header.Parent = window
	UI.header = header
	local mark = Instance.new("Frame")
	mark.AnchorPoint = Vector2.new(0, 0.5)
	mark.Size = UDim2.fromOffset(9, 9)
	mark.Position = UDim2.new(0, 16, 0.5, 0)
	mark.BorderSizePixel = 0
	mark.Rotation = 45
	mark.Parent = header
	corner(mark, 3)
	acc(mark, "BackgroundColor3")
	makeText(header, UDim2.new(0, 96, 1, 0), UDim2.fromOffset(34, 1), N.PROJECT_NAME, 14, N.C_TEXT, N.FONT_BRAND, nil, true)
	makeText(header, UDim2.new(0, 120, 1, 0), UDim2.fromOffset(136, 1), "fun mode", 12, N.C_DIM, N.FONT, nil, true)

	local closeBtn = Instance.new("TextButton")
	closeBtn.AnchorPoint = Vector2.new(1, 0.5)
	closeBtn.Position = UDim2.new(1, -10, 0.5, 0)
	closeBtn.Size = UDim2.fromOffset(28, 28)
	closeBtn.BackgroundColor3 = N.C_ROW_HI
	closeBtn.BackgroundTransparency = 1
	closeBtn.BorderSizePixel = 0
	closeBtn.AutoButtonColor = false
	closeBtn.Text = "X"
	closeBtn.TextColor3 = N.C_DIM
	closeBtn.Font = FONT_B
	closeBtn.TextSize = 12
	closeBtn.Parent = header
	corner(closeBtn, 8)
	local cbs = addStroke(closeBtn, N.C_LINE, 1, 1)
	closeBtn.MouseEnter:Connect(function()
		tween(closeBtn, { BackgroundTransparency = 0, TextColor3 = N.C_TEXT })
		tween(cbs, { Color = ACCENT, Transparency = 0 })
	end)
	closeBtn.MouseLeave:Connect(function()
		tween(closeBtn, { BackgroundTransparency = 1, TextColor3 = N.C_DIM })
		tween(cbs, { Transparency = 1 })
	end)
	UI.closeBtn = closeBtn

	local hLine = Instance.new("Frame")
	hLine.Position = UDim2.fromOffset(0, N.HEAD_H)
	hLine.Size = UDim2.new(1, 0, 0, 1)
	hLine.BackgroundColor3 = N.C_LINE
	hLine.BorderSizePixel = 0
	hLine.Parent = window

	local sBg = Instance.new("Frame")
	sBg.Position = UDim2.fromOffset(0, N.HEAD_H + 1)
	sBg.Size = UDim2.new(0, N.SIDE_W, 1, -(N.HEAD_H + 1 + N.FOOT_H))
	sBg.BackgroundColor3 = N.C_PANEL
	sBg.BorderSizePixel = 0
	sBg.Parent = window

	local sidebar = Instance.new("ScrollingFrame")
	sidebar.Position = UDim2.fromOffset(0, N.HEAD_H + 2)
	sidebar.Size = UDim2.new(0, N.SIDE_W, 1, -(N.HEAD_H + 2 + N.FOOT_H))
	sidebar.BackgroundTransparency = 1
	sidebar.BorderSizePixel = 0
	sidebar.ScrollBarThickness = 0
	sidebar.CanvasSize = UDim2.new()
	sidebar.AutomaticCanvasSize = Enum.AutomaticSize.Y
	sidebar.ScrollingDirection = Enum.ScrollingDirection.Y
	sidebar.Parent = window
	local sl = Instance.new("UIListLayout")
	sl.Padding = UDim.new(0, 4)
	sl.SortOrder = Enum.SortOrder.LayoutOrder
	sl.Parent = sidebar
	local sp = Instance.new("UIPadding")
	sp.PaddingTop, sp.PaddingBottom = UDim.new(0, 10), UDim.new(0, 8)
	sp.PaddingLeft, sp.PaddingRight = UDim.new(0, 8), UDim.new(0, 6)
	sp.Parent = sidebar
	UI.sidebar = sidebar

	local sLine = Instance.new("Frame")
	sLine.Position = UDim2.fromOffset(N.SIDE_W, N.HEAD_H + 2)
	sLine.Size = UDim2.new(0, 1, 1, -(N.HEAD_H + 2 + N.FOOT_H))
	sLine.BackgroundColor3 = N.C_LINE
	sLine.BackgroundTransparency = 0
	sLine.BorderSizePixel = 0
	sLine.Parent = window

	local content = Instance.new("CanvasGroup")
	content.Position = UDim2.fromOffset(N.SIDE_W + 1, N.HEAD_H + 2)
	content.Size = UDim2.new(1, -(N.SIDE_W + 1), 1, -(N.HEAD_H + 2 + N.FOOT_H))
	content.BackgroundTransparency = 1
	content.ClipsDescendants = true
	content.Parent = window
	UI.content = content

	local sweep = Instance.new("Frame")
	sweep.Position = UDim2.fromOffset(N.SIDE_W + 1, N.HEAD_H + 1)
	sweep.Size = UDim2.new(0, 0, 0, 1)
	sweep.BorderSizePixel = 0
	sweep.ZIndex = 4
	sweep.Parent = window
	acc(sweep, "BackgroundColor3")
	UI.sweep = sweep

	local fLine = Instance.new("Frame")
	fLine.AnchorPoint = Vector2.new(0, 1)
	fLine.Position = UDim2.new(0, 0, 1, -N.FOOT_H)
	fLine.Size = UDim2.new(1, 0, 0, 1)
	fLine.BackgroundColor3 = N.C_LINE
	fLine.BorderSizePixel = 0
	fLine.Parent = window

	local footer = Instance.new("Frame")
	footer.AnchorPoint = Vector2.new(0, 1)
	footer.Position = UDim2.fromScale(0, 1)
	footer.Size = UDim2.new(1, 0, 0, N.FOOT_H)
	footer.BackgroundTransparency = 1
	footer.BorderSizePixel = 0
	footer.Parent = window
	UI.footerL = makeText(footer, UDim2.new(0.75, -16, 1, 0), UDim2.fromOffset(16, 0), "", 11, N.C_DIM, N.FONT, nil, true)
	UI.footerR = makeText(footer, UDim2.new(0.25, -16, 1, 0), UDim2.new(0.75, 0, 0, 0), "", 11, N.C_DIM, N.FONT, Enum.TextXAlignment.Right, true)

	for _, obj in { window, menuBtn, dock } do
		obj.MouseEnter:Connect(function() overMenu = true end)
		obj.MouseLeave:Connect(function() overMenu = false end)
	end
end

local function toast(text, color, force, life)
	if not S.Toasts and not force then return end
	local dur = life or 1.8
	local t = Instance.new("TextLabel")
	t.AutomaticSize = Enum.AutomaticSize.X
	t.Size = UDim2.fromOffset(0, 32)
	t.BackgroundColor3 = N.C_BG
	t.BackgroundTransparency = 1
	t.BorderSizePixel = 0
	t.Text = "       " .. text .. "    "
	t.TextColor3 = N.C_TEXT
	t.TextTransparency = 1
	t.Font = FONT_B
	t.TextSize = 12
	t.Parent = UI.toasts
	corner(t, 9)
	local ts = addStroke(t, N.C_LINE, 1, 1)
	local mark = Instance.new("Frame")
	mark.AnchorPoint = Vector2.new(0, 0.5)
	mark.Size = UDim2.fromOffset(6, 6)
	mark.Position = UDim2.new(0, 11, 0.5, 0)
	mark.BackgroundColor3 = color or ACCENT
	mark.BorderSizePixel = 0
	mark.BackgroundTransparency = 1
	mark.Parent = t
	corner(mark, 1000)
	local bar = Instance.new("Frame")
	bar.AnchorPoint = Vector2.new(0, 1)
	bar.Position = UDim2.new(0, 11, 1, -3)
	bar.Size = UDim2.new(1, -22, 0, 2)
	bar.BackgroundColor3 = color or ACCENT
	bar.BorderSizePixel = 0
	bar.BackgroundTransparency = 1
	bar.Parent = t
	corner(bar, 1000)
	local info = TweenInfo.new(0.2, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
	tween(t, { BackgroundTransparency = 0.04, TextTransparency = 0 }, info)
	tween(ts, { Transparency = 0.2 }, info)
	tween(mark, { BackgroundTransparency = 0 }, info)
	bar.BackgroundTransparency = 0.3
	tween(bar, { Size = UDim2.new(0, 0, 0, 2) }, TweenInfo.new(dur, Enum.EasingStyle.Linear))
	task.delay(dur, function()
		local out = TweenInfo.new(0.18)
		tween(t, { BackgroundTransparency = 1, TextTransparency = 1 }, out)
		tween(ts, { Transparency = 1 }, out)
		tween(mark, { BackgroundTransparency = 1 }, out)
		tween(bar, { BackgroundTransparency = 1 }, out)
		task.delay(0.22, function() t:Destroy() end)
	end)
end

local function safeRun(name, fn)
	local ok, err = pcall(fn)
	if not ok then
		warn("[ZENITH] " .. name .. ": " .. tostring(err))
		local msg = tostring(err)
		if #msg > 70 then msg = string.sub(msg, 1, 70) .. "…" end
		pcall(toast, "" .. name .. ": " .. msg, Color3.fromRGB(255, 90, 90), true, 12)
	end
end

notify = function(text, on)
	toast(string.format("%s: %s", tr(text), on and tr("ВКЛ") or tr("ВИКЛ")), on and ACCENT or N.C_DIM)
end

local lastNote = {}
local function defNote(key, enabled, src, color, every, ...)
	if not enabled then return end
	local now = os.clock()
	if now - (lastNote[key] or 0) < (every or 2) then return end
	lastNote[key] = now
	local text = select("#", ...) > 0 and string.format(tr(src), ...) or tr(src)
	toast(text, color or ACCENT, true)
end

local menuOpenState = false
local menuTween, menuRest = nil, nil
local function openMenu(open)
	if open == nil then open = not menuOpenState end
	local win = UI.window
	if open == menuOpenState and win.Visible == open then
		if applyVisuals then applyVisuals() end
		return
	end
	menuOpenState = open
	if menuTween then menuTween:Cancel() menuTween = nil end

	if not menuRest or not win.Visible then menuRest = win.Position end
	local rest = menuRest
	local w = win.Size.X.Offset * UI.scale.Scale + 40
	local away = UDim2.new(rest.X.Scale, rest.X.Offset - w, rest.Y.Scale, rest.Y.Offset)

	if open then
		if not win.Visible then
			win.Position = away
			win.GroupTransparency = 1
			if not isTouch then UI.content.GroupTransparency = 1 end
		end
		win.Visible = true
		tween(win, { GroupTransparency = S.MenuAlpha }, TweenInfo.new(0.22, Enum.EasingStyle.Quad, Enum.EasingDirection.Out))
		if not isTouch then tween(UI.content, { GroupTransparency = 0 }, TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)) end
		menuTween = TweenService:Create(win, N.ti(TweenInfo.new(0.34, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)), { Position = rest })
		menuTween.Completed:Connect(function(state)
			if state == Enum.PlaybackState.Completed then
				win.Position = rest
				menuRest = nil
			end
		end)
		menuTween:Play()
	else
		overMenu = false
		tween(win, { GroupTransparency = 1 }, TweenInfo.new(0.16, Enum.EasingStyle.Quad, Enum.EasingDirection.In))
		local tw = TweenService:Create(win, N.ti(TweenInfo.new(0.18, Enum.EasingStyle.Quart, Enum.EasingDirection.In)), { Position = away })
		menuTween = tw
		tw.Completed:Connect(function(state)
			if state == Enum.PlaybackState.Completed and not menuOpenState then
				win.Visible = false
				win.Position = rest
				menuRest = nil
				if applyVisuals then applyVisuals() end
			end
		end)
		tw:Play()
	end
	if applyVisuals then applyVisuals() end
end

UI.menuBtn.Activated:Connect(function() openMenu() end)
UI.closeBtn.Activated:Connect(function() openMenu(false) end)

local function availSize()
	local a = UI.gui.AbsoluteSize
	if a.X < 50 or a.Y < 50 then
		local cam = getCamera()
		return cam and cam.ViewportSize or Vector2.new(800, 600)
	end
	return a
end

local function effectiveScale()
	local avail = availSize()
	local auto = 1
	if S.AutoScale then
		if isTouch then
			auto = math.clamp(math.min(avail.X / 760, avail.Y / 330), 0.9, 1.15)
		else
			auto = math.clamp(math.min(avail.X / 820, avail.Y / 480), 0.7, 1.1)
		end
	end
	return S.UiScale * auto
end

N.leftOff = function()
	if not isTouch then return 12 end
	if availSize().X < 560 then return 8 end
	return N.DOCK_W + 18
end

N.inset = function()
	local overlay = UI.overlay
	local insX = UI.gui.AbsolutePosition.X - overlay.AbsolutePosition.X
	local insY = UI.gui.AbsolutePosition.Y - overlay.AbsolutePosition.Y
	if insX < 1 and insY < 1 then
		local okz, zl, zt = pcall(function()
			local z = game:GetService("GuiService"):GetSafeZoneOffsets()
			local l = z.left or z.Left or z.Min and z.Min.X or z.X
			local t = z.top or z.Top or z.Min and z.Min.Y or z.Y
			return tonumber(l) or 0, tonumber(t) or 0
		end)
		if okz then insX, insY = zl, zt end
	end
	return math.max(insX, 0), math.max(insY, 0)
end

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

	local x, y
	if userMoved then
		x, y = UI.window.Position.X.Offset, UI.window.Position.Y.Offset
	else
		x = N.leftOff()
		y = N.WIN_TOP
	end
	x = math.clamp(x, 0, math.max(avail.X - vw, 0))
	y = math.clamp(y, 0, math.max(avail.Y - vh, 0))
	UI.window.Position = UDim2.fromOffset(x, y)
end

local dragging
UI.header.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.Touch
		or input.UserInputType == Enum.UserInputType.MouseButton1 then
		dragging = {
			input = input,
			start = Vector2.new(input.Position.X, input.Position.Y),
			pos = UI.window.Position,
		}
	end
end)

local pages = {}
local currentPage


local function selectTab(page)
	local changed = currentPage ~= page
	currentPage = page
	for _, p in pages do
		local active = (p == page)
		if not active then p.frame.Visible = false end
		p.btn.BackgroundColor3 = N.C_ROW_HI
		local info = TweenInfo.new(0.22, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
		tween(p.btn, { BackgroundTransparency = active and 0 or 1, TextColor3 = active and N.C_TEXT or N.C_DIM }, info)
		tween(p.icon, { BackgroundColor3 = active and ACCENT or N.C_LINE, Size = active and UDim2.fromOffset(8, 8) or UDim2.fromOffset(5, 5) }, info)
		tween(p.pad, { PaddingLeft = UDim.new(0, active and N.TAB_PAD_ON or N.TAB_PAD) }, info)
	end
	page.frame.Visible = true
	if changed and UI.window.Visible then
		page.frame.Position = UDim2.fromOffset(22, 0)
		if not isTouch then UI.content.GroupTransparency = 0.85 end
		tween(page.frame, { Position = UDim2.fromOffset(0, 0) }, TweenInfo.new(0.32, Enum.EasingStyle.Quint, Enum.EasingDirection.Out))
		if not isTouch then tween(UI.content, { GroupTransparency = 0 }, TweenInfo.new(0.26, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)) end
		UI.sweep.Size = UDim2.new(0, 0, 0, 1)
		UI.sweep.BackgroundTransparency = 0
		tween(UI.sweep, { Size = UDim2.new(1, -(N.SIDE_W + 1), 0, 1) }, TweenInfo.new(0.34, Enum.EasingStyle.Quint, Enum.EasingDirection.Out))
		task.delay(0.3, function() tween(UI.sweep, { BackgroundTransparency = 1 }, TweenInfo.new(0.25)) end)
		pcall(function()
			local strip, btn = UI.sidebar, page.btn
			local y = btn.AbsolutePosition.Y - strip.AbsolutePosition.Y + strip.CanvasPosition.Y
			local target = math.max(y - strip.AbsoluteSize.Y / 2 + btn.AbsoluteSize.Y / 2, 0)
			tween(strip, { CanvasPosition = Vector2.new(0, target) }, TweenInfo.new(0.22, Enum.EasingStyle.Quad))
		end)
	else
		page.frame.Position = UDim2.new()
	end
end

local function addTab(name)
	local frame = Instance.new("ScrollingFrame")
	frame.Size = UDim2.fromScale(1, 1)
	frame.BackgroundTransparency = 1
	frame.BorderSizePixel = 0
	frame.ScrollBarThickness = 3
	frame.ScrollBarImageColor3 = N.C_LINE
	frame.CanvasSize = UDim2.new()
	frame.AutomaticCanvasSize = Enum.AutomaticSize.Y
	frame.ScrollingDirection = Enum.ScrollingDirection.Y
	frame.Visible = false
	frame.Parent = UI.content

	local pad = Instance.new("UIPadding")
	pad.PaddingTop, pad.PaddingBottom = UDim.new(0, 6), UDim.new(0, 14)
	pad.PaddingLeft, pad.PaddingRight = UDim.new(0, 12), UDim.new(0, 14)
	pad.Parent = frame

	local list = Instance.new("UIListLayout")
	list.Padding = UDim.new(0, 3)
	list.SortOrder = Enum.SortOrder.LayoutOrder
	list.Parent = frame

	local btn = Instance.new("TextButton")
	btn.LayoutOrder = #pages + 1
	btn.Size = UDim2.new(1, 0, 0, isTouch and 42 or 38)
	btn.BackgroundTransparency = 1
	btn.BackgroundColor3 = N.C_ROW_HI
	btn.AutoButtonColor = false
	btn.TextColor3 = N.C_DIM
	btn.Font = FONT_B
	btn.TextSize = 12
	btn.TextXAlignment = Enum.TextXAlignment.Left
	btn.BorderSizePixel = 0
	btn.Parent = UI.sidebar
	bind(btn, name)
	corner(btn, 9)
	local bp = Instance.new("UIPadding")
	bp.PaddingLeft = UDim.new(0, N.TAB_PAD)
	bp.Parent = btn

	local icon = Instance.new("Frame")
	icon.AnchorPoint = Vector2.new(0.5, 0.5)
	icon.Size = UDim2.fromOffset(5, 5)
	icon.Position = UDim2.new(0, -14, 0.5, 0)
	icon.BackgroundColor3 = N.C_LINE
	icon.BorderSizePixel = 0
	icon.Visible = not isTouch
	icon.Parent = btn
	corner(icon, 1000)

	local page = { frame = frame, btn = btn, icon = icon, pad = bp, n = 0, name = name, fixed = name == "Налашт.", secs = {} }
	table.insert(pages, page)
	btn.MouseEnter:Connect(function()
		if currentPage ~= page then
			tween(btn, { BackgroundTransparency = 0.6, TextColor3 = N.C_TEXT })
			tween(bp, { PaddingLeft = UDim.new(0, N.TAB_PAD_HOV) }, TweenInfo.new(0.18, Enum.EasingStyle.Quint))
		end
	end)
	btn.MouseLeave:Connect(function()
		if currentPage ~= page then
			tween(btn, { BackgroundTransparency = 1, TextColor3 = N.C_DIM })
			tween(bp, { PaddingLeft = UDim.new(0, N.TAB_PAD) }, TweenInfo.new(0.18, Enum.EasingStyle.Quint))
		end
	end)
	btn.Activated:Connect(function() selectTab(page) end)
	return page
end

local function makeRow(page, height, clickable, filled)
	local row = Instance.new(clickable and "TextButton" or "Frame")
	page.n += 1
	row.LayoutOrder = page.n
	row.Size = UDim2.new(1, 0, 0, height)
	row.BackgroundColor3 = filled and N.C_PANEL or N.C_ROW_HI
	row.BackgroundTransparency = filled and 0 or 1
	row.BorderSizePixel = 0
	if clickable then
		row.Text = ""
		row.AutoButtonColor = false
		local restColor = filled and N.C_PANEL or N.C_ROW_HI
		local restAlpha = filled and 0 or 1
		local touchOnly = isTouch and not N.hasMouse
		if not touchOnly then
			row.MouseEnter:Connect(function()
				tween(row, { BackgroundColor3 = N.C_ROW_HI, BackgroundTransparency = 0 }, TweenInfo.new(0.14, Enum.EasingStyle.Quad))
			end)
			row.MouseLeave:Connect(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
	if N.cur then
		local rw = { obj = row, keys = {}, set = {} }
		N.cur.rows[#N.cur.rows + 1] = rw
		N.curRow = rw
	end
	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 rec = { name = text, page = page, holder = holder, rows = {}, keys = {}, set = {} }
	page.secs[#page.secs + 1] = rec
	N.secs[#N.secs + 1] = rec
	N.cur = rec
	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, sec)
	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, key = key, sec = sec })
	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 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.theme and N.theme.accentNow() or 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.key and N.OFF[rec.key]) or (rec.sec and N.CUT[rec.sec]) then
			rec.btn.Visible = false
		elseif rec.only then
			rec.btn.Visible = gateOpen and rec.only() == true
		else
			rec.btn.Visible = S.Quick
		end
	end


	if N.fbApply then N.fbApply() end
	if N.theme then N.theme.blur() 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
rayParams.RespectCanCollide = true

N.aimVis = setmetatable({}, { __mode = "k" })
N.aimCand = {}
N.aim = { lock = nil, look = nil, yieldUntil = 0, opts = {} }

local function partVisible(part, char, camPos, now)
	local rec = N.aimVis[part]
	if rec and now - rec.t < 0.07 then return rec.v end
	local hit = workspace:Raycast(camPos, part.Position - camPos, rayParams)
	local v = hit == nil or hit.Instance == part or hit.Instance:IsDescendantOf(char)
	if rec then
		rec.t, rec.v = now, v
	else
		N.aimVis[part] = { t = now, v = v }
	end
	return v
end

local function getTarget(useFov, motion, opts)
	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 now = os.clock()
	local prefer = opts and opts.prefer
	local maxDist = opts and opts.maxDist or math.huge
	local idx = S.AimPart
	local cand = N.aimCand
	local best, bestScore = nil, math.huge

	for _, t in collect(S.IgnoreTeam) do
		local char = t.char
		local hum = getHum(char)
		if hum and hum.Health > 0 then
			local head = char:FindFirstChild("Head")
			local torso = char:FindFirstChild("UpperTorso") or char:FindFirstChild("Torso")
			local root = char:FindFirstChild("HumanoidRootPart")
			if idx == 2 then
				cand[1], cand[2], cand[3] = torso, head, root
			elseif idx == 3 then
				cand[1], cand[2], cand[3] = root, torso, head
			else
				cand[1], cand[2], cand[3] = head, torso, root
			end

			local isPref = prefer ~= nil and char == prefer
			local lim = S.FovRadius * (isPref and 1.2 or 1)
			local chosen, cd2, cdist, cOn = nil, 0, 0, false
			local bestD2 = math.huge
			for i = 1, 3 do
				local part = cand[i]
				if part 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 = dist <= maxDist
					if pass and useFov then pass = onScreen and d2 <= lim end
					if pass and S.WallCheck then pass = partVisible(part, char, camPos, now) end
					if pass then
						if idx ~= 4 then
							chosen, cd2, cdist, cOn = part, d2, dist, onScreen
							break
						elseif d2 < bestD2 then
							bestD2 = d2
							chosen, cd2, cdist, cOn = part, d2, dist, onScreen
						end
					end
				end
			end

			if chosen then
				local score
				if S.Priority == 1 then
					score = cOn and cd2 or (1e6 + cdist)
				elseif S.Priority == 2 then
					score = cdist
				else
					score = hum.Health
				end
				if isPref then score *= 0.65 end
				if score < bestScore then
					best, bestScore = t, score
					t.aimPart = chosen
				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 isPref = prefer ~= nil and m.model == prefer
				local pass = dist <= maxDist
				if pass and useFov then pass = onScreen and d2 <= S.FovRadius * (isPref and 1.2 or 1) end
				if pass and S.WallCheck then pass = partVisible(part, m.model, camPos, now) end
				if pass then
					local score
					if S.Priority == 1 then
						score = onScreen and d2 or (1e6 + dist)
					else
						score = dist
					end
					if isPref then score *= 0.65 end
					if score < bestScore then
						best, bestScore = { char = m.model, part = part, motion = true }, score
					end
				end
			end
		end
	end

	cand[1], cand[2], cand[3] = nil, nil, nil
	return best
end

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

	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { myChar, tChar }

	if guard then
		local tp = tRoot.Position
		local v, w = tRoot.AssemblyLinearVelocity.Magnitude, tRoot.AssemblyAngularVelocity.Magnitude
		if not (v <= 110 and w <= 40 and tp.Magnitude < 1e6) then return false, "fast" end
		if isPulled(tChar) then return false, "pulled" end
		if guard.seen and not ((tp - guard.seen).Magnitude <= 40) then return false, "moved" end
		if guard.range and not ((tp - myRoot.Position).Magnitude <= guard.range) then return false, "far" end
		if tp.Y < workspace.FallenPartsDestroyHeight + 150 then return false, "deep" end
		if not workspace:Raycast(tp, Vector3.new(0, -120, 0), params) then return false, "void" end
	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 pos = tRoot.Position + offset
	local hit = workspace:Raycast(tRoot.Position, offset, params)
	if hit then pos = hit.Position + hit.Normal * 2 end
	if guard and not workspace:Raycast(pos + Vector3.new(0, 2, 0), Vector3.new(0, -60, 0), params) then
		return false, "void"
	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
N.espVis = setmetatable({}, { __mode = "k" })

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

	local HL_MAX = 28
	local RED, GREEN = Color3.fromRGB(255, 60, 60), Color3.fromRGB(60, 255, 90)

	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 = {}
		local entries = {}

		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)
						or not (dist < 1e9)
					if not hide then
						entries[#entries + 1] = { char = char, plr = plr, hum = hum, root = root, dist = dist }
					end
				end
			end
		end

		local cap = nil
		if #entries > HL_MAX then
			table.sort(entries, function(a, b) return a.dist < b.dist end)
			cap = HL_MAX
		end

		for i, en in entries do
			local char, plr, hum, root, dist = en.char, en.plr, en.hum, en.root, en.dist
			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 = RED:Lerp(GREEN, frac)
			end
			if S.EspVisCheck then
				local v = N.espVis[char]
				if v ~= nil then
					local c = v and GREEN or RED
					fillColor, outColor = c, c
				end
			end

			e.hl.Enabled = S.EspHighlight and (cap == nil or i <= cap)
			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.bb.MaxDistance = S.EspMaxDist < 5000 and S.EspMaxDist + 20 or 1e5

			local fade = math.clamp((dist - 250) / 350, 0, 0.8)
			e.name.Visible = S.EspNames
			e.name.TextSize = S.EspTextSize
			e.name.Text = plr and plr.DisplayName or char.Name
			e.name.TextTransparency = fade
			e.name.TextStrokeTransparency = 0.3 + fade * 0.7

			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.info.TextTransparency = fade
			e.info.TextStrokeTransparency = 0.3 + fade * 0.7

			e.bar.Visible = S.EspHealth
			e.bar.BackgroundTransparency = fade
			e.fill.Size = UDim2.fromScale(frac, 1)
			e.fill.BackgroundColor3 = RED:Lerp(GREEN, frac)
			e.fill.BackgroundTransparency = fade
		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 = {}, -10
			local visited = {}
			local warned = 0
			local home = nil

			local function scan(pattern)
				lastScan = os.clock()
				local map = {}
				for _, d in workspace:GetDescendants() do
					if d:IsA("BasePart") then
						local par = d.Parent
						local hitName = string.find(string.lower(d.Name), pattern, 1, true)
							or (par and par ~= workspace and string.find(string.lower(par.Name), pattern, 1, true))
						if hitName then
							local model = d:FindFirstAncestorOfClass("Model")
							if not (model and Players:GetPlayerFromCharacter(model)) then
								local key = (par and par ~= workspace) and par or d
								if not map[key] then map[key] = d end
							end
						end
					end
				end
				cache = map
			end

			local function pick(root)
				local now = os.clock()
				local best, bestKey, bestDist = nil, nil, S.CoinRange
				for key, part in cache do
					if part.Parent and (visited[key] or 0) < now and part.Transparency < 0.95 and part.CanTouch ~= false then
						local d = (part.Position - root.Position).Magnitude
						if d <= bestDist then best, bestKey, bestDist = part, key, d end
					end
				end
				return best, bestKey
			end

			while S.Coins do
				local char = player.Character
				local root = getRoot(char)
				local pattern = string.lower(S.CoinName)

				if gateOpen and root and isAlive(char) and pattern ~= "" then
					if os.clock() - lastScan > 3 then scan(pattern) end

					local best, key = pick(root)
					if not best and os.clock() - lastScan > 0.8 then
						scan(pattern)
						best, key = pick(root)
					end

					if best then
						if not home then home = root.CFrame end
						markSelf(math.max(S.CoinInterval, 0.3) + 0.6)
						visited[key] = os.clock() + 5
						char:PivotTo(CFrame.new(best.Position + Vector3.new(0, 3, 0)))
						root.AssemblyLinearVelocity = Vector3.zero
					elseif home and S.CoinReturn then
						markSelf(0.8)
						char:PivotTo(home)
						root.AssemblyLinearVelocity = Vector3.zero
						home = nil
					elseif os.clock() - warned > 20 then
						warned = os.clock()
						toast(string.format(tr("Монет з назвою '%s' поруч не знайдено"), S.CoinName), ACCENT, true)
					end
				end
				task.wait(math.max(S.CoinInterval, 0.3))
			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", "AfParts", "AfClamp", "AfNoRagdoll", "AfVoid", "AfPark", "AfUnder", "AfNotify", "SitNotify", "FallNotify",
		"AbGui", "FlickRevert", "CtFace", "SuspTags", "SuspNotify", "DtReveal", "DtNotify", "DtTags", "GdLinks", "GdSound", "GdCage", "GdRide", "GdPlrCol" } do
		setValue(key, true, true)
	end
	toast(tr("Весь античіт увімкнено"), ACCENT, true)
end

N.theme = (function()
	local TH = {}
	local weakK = { __mode = "k" }
	local seen = setmetatable({}, weakK)
	local texts = setmetatable({}, weakK)
	local corners = setmetatable({}, weakK)
	local strokes = setmetatable({}, weakK)
	local rowsH = setmetatable({}, weakK)
	local orig, over = {}, {}
	local rules, swapMap = {}, {}
	local hasSwap, rulesLive = false, false
	local errs = {}
	local nRules, nSwap = 0, 0
	local ready, bulk, quiet = false, false, true
	local blurWant, blurSize = false, -1
	local pending, flushQueued = {}, false
	local queued, queueOn = {}, false
	local winStroke, gradFrame, gradUI, imgLabel, blurFx
	local ROLES = N.THEME_ROLES
	local HEXKEY = { bg = "ThBg", panel = "ThPanel", hover = "ThHover", line = "ThLine", text = "ThText", dim = "ThDim", accent = "ThAccent" }
	local base = { bg = N.C_BG, panel = N.C_PANEL, hover = N.C_ROW_HI, line = N.C_LINE, text = N.C_TEXT, dim = N.C_DIM, accent = ACCENT }
	local cur = {}
	for r, c in base do cur[r] = c end
	local runPending

	local function trim(s) return (string.gsub(s, "^%s*(.-)%s*$", "%1")) end
	local function r255(v) return math.floor(v * 255 + 0.5) end
	local function ckey(c) return r255(c.R) * 65536 + r255(c.G) * 256 + r255(c.B) end
	local function hex(c) return string.format("%02X%02X%02X", r255(c.R), r255(c.G), r255(c.B)) end

	local NAMED = {
		white = "FFFFFF", black = "000000", red = "E5484D", green = "46C37B", blue = "4C8DFF", yellow = "F5D547",
		orange = "F59E42", purple = "A070FF", pink = "F472B6", cyan = "4DD8E8", gray = "8C8C8C", grey = "8C8C8C",
	}
	local function parseColor(s)
		if typeof(s) == "Color3" then return s end
		if type(s) ~= "string" then return nil end
		s = string.lower(trim(s))
		local role = string.match(s, "^@(%a+)$")
		if role then return cur[role] end
		s = NAMED[s] or s
		local h = string.match(s, "^#?(%x%x%x%x%x%x)$")
		if not h then
			local h3 = string.match(s, "^#?(%x%x%x)$")
			if h3 then h = (string.gsub(h3, "%x", "%0%0")) end
		end
		if h then
			return Color3.fromRGB(tonumber(string.sub(h, 1, 2), 16), tonumber(string.sub(h, 3, 4), 16), tonumber(string.sub(h, 5, 6), 16))
		end
		local inner = string.match(s, "^rgb%s*%((.*)%)$") or s
		local a, b, c = string.match(inner, "^(%d+)[%s,;]+(%d+)[%s,;]+(%d+)$")
		if a then
			return Color3.fromRGB(math.min(tonumber(a), 255), math.min(tonumber(b), 255), math.min(tonumber(c), 255))
		end
		return nil
	end
	TH.parseColor = parseColor
	TH.hex = hex

	local function lin(v)
		if v <= 0.03928 then return v / 12.92 end
		return ((v + 0.055) / 1.055) ^ 2.4
	end
	local function lum(c) return 0.2126 * lin(c.R) + 0.7152 * lin(c.G) + 0.0722 * lin(c.B) end
	local function ratio(a, b)
		local x, y = lum(a), lum(b)
		if x < y then x, y = y, x end
		return (x + 0.05) / (y + 0.05)
	end
	local function fix(fg, bg, want)
		if ratio(fg, bg) >= want then return fg, false end
		local t = lum(bg) > 0.35 and 0 or 1
		for k = 1, 20 do
			local f = k / 20
			local c = Color3.new(fg.R + (t - fg.R) * f, fg.G + (t - fg.G) * f, fg.B + (t - fg.B) * f)
			if ratio(c, bg) >= want then return c, true end
		end
		return Color3.new(t, t, t), true
	end

	local function uniq(tok)
		local owner = {}
		for r, c in base do
			if r ~= "accent" then owner[ckey(c)] = r end
		end
		for _, a in N.ACCENTS do owner[ckey(a[2])] = "accent" end
		for _, r in ROLES do
			local c = tok[r]
			local k = ckey(c)
			local tries = 0
			while owner[k] ~= nil and owner[k] ~= r and tries < 40 do
				tries += 1
				c = Color3.fromRGB(r255(c.R), r255(c.G), (r255(c.B) + 1) % 256)
				k = ckey(c)
			end
			tok[r] = c
			owner[k] = r
		end
	end

	local function computeTokens()
		local tok = {}
		for _, r in ROLES do
			local c = parseColor(S[HEXKEY[r]])
			if r == "accent" then
				c = c or N.ACCENTS[S.Accent][2]
			else
				c = c or base[r]
			end
			tok[r] = c
		end
		local changed = false
		local function guard(key, vs, want)
			local c, ch = fix(tok[key], tok[vs], want)
			if ch then
				tok[key] = c
				changed = true
			end
		end
		guard("text", "bg", 3)
		guard("text", "panel", 2.2)
		guard("dim", "bg", 1.6)
		guard("accent", "bg", 1.8)
		uniq(tok)
		return tok, changed
	end

	local function keyMap()
		local m = {}
		for r, c in base do
			if r ~= "accent" then m[ckey(c)] = r end
		end
		for _, a in N.ACCENTS do m[ckey(a[2])] = "accent" end
		for r, c in cur do m[ckey(c)] = r end
		return m
	end

	local CP = {
		Frame = { "BackgroundColor3" }, CanvasGroup = { "BackgroundColor3" },
		TextLabel = { "BackgroundColor3", "TextColor3" }, TextButton = { "BackgroundColor3", "TextColor3" },
		TextBox = { "BackgroundColor3", "TextColor3", "PlaceholderColor3" },
		ScrollingFrame = { "BackgroundColor3", "ScrollBarImageColor3" },
		ImageLabel = { "BackgroundColor3", "ImageColor3" }, ImageButton = { "BackgroundColor3", "ImageColor3" },
		UIStroke = { "Color" },
	}
	local TEXTC = { TextLabel = true, TextButton = true, TextBox = true }

	local function recolorOne(inst, m, tok)
		local props = CP[inst.ClassName]
		if not props then return end
		for i = 1, #props do
			local p = props[i]
			local v = inst[p]
			if typeof(v) == "Color3" then
				local r = m[ckey(v)]
				if r then
					local nc = tok[r]
					if v ~= nc then inst[p] = nc end
				end
			end
		end
	end

	local roleOfFont = {}
	roleOfFont[N.FONT_BRAND] = "brand"
	roleOfFont[N.FONT_MONO] = "mono"
	roleOfFont[N.FONT] = "reg"
	roleOfFont[FONT_B] = "bold"
	local function fontSet()
		local f = N.THEME_FONTS[S.ThFont] or N.THEME_FONTS[1]
		return {
			reg = pickFont(f[1], N.FONT), bold = pickFont(f[2], FONT_B),
			brand = pickFont(f[3], N.FONT_BRAND), mono = pickFont(f[4], N.FONT_MONO),
		}
	end

	local function setUnlessOver(inst, p, v)
		local o = over[inst]
		if o and o[p] ~= nil then return end
		if inst[p] ~= v then inst[p] = v end
	end

	local function textOne(inst, fs)
		local rec = texts[inst]
		if not rec then return end
		setUnlessOver(inst, "TextSize", math.clamp(rec[1] + S.ThTextSize, 6, 40))
		local f = rec[2] and fs[rec[2]]
		if f then setUnlessOver(inst, "Font", f) end
	end
	local function cornerOne(inst)
		local b = corners[inst]
		if not b then return end
		local f = S.ThRound
		local r
		if b >= 100 then
			r = f <= 0.01 and 0 or (f < 0.5 and 3 or b)
		else
			r = math.min(b * f, 24)
		end
		setUnlessOver(inst, "CornerRadius", UDim.new(0, r))
	end
	local function strokeOne(inst)
		local b = strokes[inst]
		if b then setUnlessOver(inst, "Thickness", b * S.ThStroke) end
	end
	local function rowOne(inst)
		local b = rowsH[inst]
		if not b then return end
		local sz = inst.Size
		setUnlessOver(inst, "Size", UDim2.new(sz.X.Scale, sz.X.Offset, 0, math.floor(b * S.ThDensity + 0.5)))
	end

	local function eachLive(set, fn, a)
		for inst in set do
			if inst.Parent then fn(inst, a) else set[inst] = nil end
		end
	end
	local function passText() eachLive(texts, textOne, fontSet()) end
	local function passShape()
		eachLive(corners, cornerOne)
		eachLive(strokes, strokeOne)
	end
	local function passRows() eachLive(rowsH, rowOne) end

	function TH.track(inst)
		if seen[inst] then return false end
		if string.sub(inst.Name, 1, 3) == "_zt" then return false end
		seen[inst] = true
		local cn = inst.ClassName
		if cn == "UICorner" then
			corners[inst] = inst.CornerRadius.Offset
		elseif cn == "UIStroke" then
			if inst ~= winStroke then strokes[inst] = inst.Thickness end
		elseif TEXTC[cn] then
			texts[inst] = { inst.TextSize, roleOfFont[inst.Font] }
		end
		if cn == "Frame" or cn == "TextButton" then
			local p = inst.Parent
			if p and p.ClassName == "ScrollingFrame" then
				local sz = inst.Size
				if sz.X.Scale == 1 and sz.X.Offset == 0 and sz.Y.Scale == 0 and sz.Y.Offset == N.ROW_H then rowsH[inst] = N.ROW_H end
			end
		end
		return true
	end

	local function applySecs()
		local g = S.ThGrad
		for _, rec in N.secs do
			local h = rec.holder
			if h and h.Parent then
				for _, c in h:GetChildren() do
					if c:IsA("Frame") then
						c.Visible = not g
					elseif c:IsA("TextLabel") then
						c.BackgroundTransparency = g and 1 or 0
					end
				end
			end
		end
	end

	local function applyBg()
		if not gradFrame then return end
		gradFrame.Visible = S.ThGrad
		applySecs()
		if S.ThGrad then
			gradUI.Color = ColorSequence.new(parseColor(S.ThGradC1) or cur.panel, parseColor(S.ThGradC2) or cur.bg)
			gradUI.Rotation = S.ThGradAngle
		end
		local id = S.ThImage
		if id ~= "" then
			imgLabel.Image = "rbxassetid://" .. id
			imgLabel.ImageTransparency = S.ThImageAlpha
		end
		imgLabel.Visible = id ~= ""
	end

	local function applyGlow()
		local ws = winStroke
		if not ws then return end
		local g = S.ThGlow
		if g > 0 then
			setUnlessOver(ws, "Color", cur.accent)
			setUnlessOver(ws, "Thickness", 1 + 3 * g)
			setUnlessOver(ws, "Transparency", 0.55 - 0.45 * g)
		else
			setUnlessOver(ws, "Color", cur.line)
			setUnlessOver(ws, "Thickness", S.ThStroke)
			setUnlessOver(ws, "Transparency", 0)
		end
	end

	local TPOS = {
		{ Vector2.new(0.5, 0), UDim2.new(0.5, 0, 0, 10), "Center", "Top" },
		{ Vector2.new(0.5, 1), UDim2.new(0.5, 0, 1, -10), "Center", "Bottom" },
		{ Vector2.new(1, 0), UDim2.new(1, -10, 0, 10), "Right", "Top" },
		{ Vector2.new(1, 1), UDim2.new(1, -10, 1, -10), "Right", "Bottom" },
	}
	local function applyToast()
		local p = TPOS[S.ThToastPos] or TPOS[1]
		local t = UI.toasts
		t.AnchorPoint = p[1]
		t.Position = p[2]
		local lay = t:FindFirstChildOfClass("UIListLayout")
		if lay then
			lay.HorizontalAlignment = Enum.HorizontalAlignment[p[3]]
			lay.VerticalAlignment = Enum.VerticalAlignment[p[4]]
		end
	end

	local function applyBlur()
		local want = S.ThBlur > 0 and UI.window.Visible and menuOpenState
		if want == blurWant and S.ThBlur == blurSize then return end
		blurWant, blurSize = want, S.ThBlur
		if want then
			if not (blurFx and blurFx.Parent) then
				blurFx = Instance.new("BlurEffect")
				blurFx.Name = N.BLUR_NAME
				blurFx.Size = 0
				blurFx.Parent = Lighting
			end
			tween(blurFx, { Size = S.ThBlur }, TweenInfo.new(0.25))
		elseif blurFx and blurFx.Parent then
			if S.ThBlur <= 0 then
				blurFx:Destroy()
				blurFx = nil
			else
				tween(blurFx, { Size = 0 }, TweenInfo.new(0.2))
			end
		end
	end
	TH.blur = applyBlur

	local PROPS, PROP_L = {}, {}
	local K_GUI = { Frame = true, TextLabel = true, TextButton = true, TextBox = true, ScrollingFrame = true, CanvasGroup = true, ImageLabel = true, ImageButton = true }
	local K_IMG = { ImageLabel = true, ImageButton = true }
	local function def(kind, cls, lo, hi, ...)
		for _, p in { ... } do
			local info = { name = p, kind = kind, cls = cls, lo = lo, hi = hi }
			PROPS[p] = info
			PROP_L[string.lower(p)] = info
		end
	end
	def("c", K_GUI, nil, nil, "BackgroundColor3", "BorderColor3")
	def("c", TEXTC, nil, nil, "TextColor3", "TextStrokeColor3")
	def("c", { TextBox = true }, nil, nil, "PlaceholderColor3")
	def("c", K_IMG, nil, nil, "ImageColor3")
	def("c", { ScrollingFrame = true }, nil, nil, "ScrollBarImageColor3")
	def("c", { UIStroke = true }, nil, nil, "Color")
	def("n", K_GUI, 0, 1, "BackgroundTransparency")
	def("n", TEXTC, 0, 1, "TextTransparency", "TextStrokeTransparency")
	def("n", K_IMG, 0, 1, "ImageTransparency")
	def("n", { ScrollingFrame = true }, 0, 1, "ScrollBarImageTransparency")
	def("n", { UIStroke = true }, 0, 1, "Transparency")
	def("n", TEXTC, 6, 48, "TextSize")
	def("n", TEXTC, 0.8, 3, "LineHeight")
	def("n", { UIStroke = true }, 0, 12, "Thickness")
	def("n", K_GUI, 0, 8, "BorderSizePixel")
	def("n", { ScrollingFrame = true }, 0, 20, "ScrollBarThickness")
	def("u", { UICorner = true }, 0, 40, "CornerRadius")
	def("u", { UIListLayout = true }, 0, 40, "Padding")
	def("u", { UIPadding = true }, 0, 40, "PaddingLeft", "PaddingRight", "PaddingTop", "PaddingBottom")
	def("e", TEXTC, nil, nil, "Font")

	local function parseValue(info, str)
		local k = info.kind
		if k == "c" then return parseColor(str) end
		if k == "n" then
			local n = tonumber(str)
			return n and math.clamp(n, info.lo, info.hi) or nil
		end
		if k == "u" then
			local a, b = string.match(str, "^(-?[%d%.]+)[%s,]+(-?[%d%.]+)$")
			if a then
				local sc, off = tonumber(a), tonumber(b)
				if sc and off then return UDim.new(math.clamp(sc, 0, 1), math.clamp(off, info.lo, info.hi)) end
				return nil
			end
			local n = tonumber(str)
			return n and UDim.new(0, math.clamp(n, info.lo, info.hi)) or nil
		end
		local name = string.match(str, "([%w_]+)$")
		if not name then return nil end
		local ok, v = pcall(function() return Enum.Font[name] end)
		return ok and v or nil
	end

	local function parseSel(s)
		s = trim(s)
		if s == "" then return nil end
		local sel = {}
		local body, role = string.match(s, "^(.-)@(%a+)$")
		if body == nil then
			body = s
		else
			sel.role = string.lower(role)
			body = trim(body)
		end
		if body == "*" or body == "" then
		elseif string.sub(body, 1, 1) == "#" then
			sel.name = string.sub(body, 2)
		else
			sel.class = body
		end
		return sel
	end

	local function parseRules(text)
		local out, sw, er = {}, {}, {}
		local ln = 0
		for raw in string.gmatch(text .. "\n", "([^\n]*)\n") do
			ln += 1
			local line = trim((string.gsub((string.gsub(raw, "%-%-.*$", "")), "//.*$", "")))
			if line ~= "" then
				if #out + #sw >= 80 then
					er[#er + 1] = { ln, "забагато правил" }
					break
				end
				local rest = string.match(line, "^[Ss][Ww][Aa][Pp]%s+(.+)$")
				if rest then
					local f, t = string.match(rest, "^(.-)%s*=%s*(.-)$")
					if not f then f, t = string.match(rest, "^(.-)%s*%->%s*(.-)$") end
					local ca, cb = parseColor(f), parseColor(t)
					if ca and cb then sw[#sw + 1] = { ca, cb } else er[#er + 1] = { ln, "невірний колір" } end
				else
					local lhs, val = string.match(line, "^(.-)%s*=%s*(.-)$")
					if not lhs or lhs == "" or val == "" then
						er[#er + 1] = { ln, "немає знака =" }
					else
						val = trim((string.gsub(val, ";%s*$", "")))
						local selStr, pname = string.match(lhs, "^(.*)%.([%w_]+)$")
						local info = selStr and PROP_L[string.lower(pname)]
						if not selStr then
							er[#er + 1] = { ln, "немає властивості" }
						elseif not info then
							er[#er + 1] = { ln, "властивість не підтримується" }
						else
							local sels = {}
							for part in string.gmatch(selStr .. ",", "([^,]*),") do
								local sel = parseSel(part)
								if sel then sels[#sels + 1] = sel end
							end
							if #sels == 0 then
								er[#er + 1] = { ln, "порожній селектор" }
							else
								out[#out + 1] = { sels = sels, info = info, prop = info.name, raw = val, line = ln }
							end
						end
					end
				end
			end
		end
		return out, sw, er
	end

	local function setOver(inst, p, v)
		local o = over[inst]
		if not o then
			o = {}
			over[inst] = o
			orig[inst] = {}
		end
		if o[p] == nil then orig[inst][p] = inst[p] end
		o[p] = v
		if inst[p] ~= v then inst[p] = v end
	end

	local function rolesOf(inst, m)
		local props = CP[inst.ClassName]
		local set
		if props then
			for i = 1, #props do
				local v = inst[props[i]]
				if typeof(v) == "Color3" then
					local r = m[ckey(v)]
					if r then
						set = set or {}
						set[r] = true
					end
				end
			end
		end
		return set
	end

	local function selOk(inst, sel, roles)
		if sel.name and inst.Name ~= sel.name then return false end
		if sel.class and not inst:IsA(sel.class) then return false end
		if sel.role and not (roles and roles[sel.role]) then return false end
		return true
	end

	local function applyRulesTo(inst, m)
		if inst == UI.menuBtn or inst.Parent == UI.menuBtn then return end
		local cn = inst.ClassName
		local roles
		for _, rule in rules do
			if rule.info.cls[cn] then
				for _, sel in rule.sels do
					if sel.role and roles == nil then roles = rolesOf(inst, m) or false end
					if selOk(inst, sel, roles or nil) then
						setOver(inst, rule.prop, rule.value)
						break
					end
				end
			end
		end
		if hasSwap then
			local props = CP[cn]
			if props then
				for i = 1, #props do
					local v = inst[props[i]]
					if typeof(v) == "Color3" then
						local to = swapMap[ckey(v)]
						if to then setOver(inst, props[i], to) end
					end
				end
			end
		end
	end

	local function showErrors()
		local l = N.themeErr
		if not l then return end
		local head
		if not S.ThRulesOn then
			head = tr("Правила вимкнено")
		elseif S.ThRules == "" then
			head = tr("Правил немає")
		else
			head = string.format(tr("Правил: %d, замін кольору: %d, помилок: %d"), nRules, nSwap, #errs)
		end
		local lines = { head }
		for i = 1, math.min(#errs, 4) do
			lines[#lines + 1] = string.format(tr("рядок %d: %s"), errs[i][1], tr(errs[i][2]))
		end
		l.Text = table.concat(lines, "\n")
	end
	TH.showErrors = showErrors

	local function buildRules()
		rules, swapMap, hasSwap, errs = {}, {}, false, {}
		nRules, nSwap = 0, 0
		if S.ThRulesOn and S.ThRules ~= "" then
			local parsed, sw, er = parseRules(S.ThRules)
			errs = er
			for _, r in parsed do
				local v = parseValue(r.info, r.raw)
				if v ~= nil then
					r.value = v
					rules[#rules + 1] = r
				else
					errs[#errs + 1] = { r.line, "невірне значення" }
				end
			end
			for _, p in sw do
				swapMap[ckey(p[1])] = p[2]
				nSwap += 1
			end
			hasSwap = nSwap > 0
			nRules = #rules
		end
		rulesLive = nRules > 0 or hasSwap
		if rulesLive then
			local m = keyMap()
			for inst in seen do
				if inst.Parent then applyRulesTo(inst, m) end
			end
		end
		showErrors()
	end

	local function restore()
		for inst, props in orig do
			if inst.Parent then
				for p, v in props do pcall(function() inst[p] = v end) end
			end
		end
		orig, over = {}, {}
	end

	local function fullApply()
		restore()
		local nt, changed = computeTokens()
		local m = keyMap()
		for inst in seen do
			if inst.Parent then recolorOne(inst, m, nt) else seen[inst] = nil end
		end
		cur = nt
		N.C_BG, N.C_PANEL, N.C_ROW_HI, N.C_LINE, N.C_TEXT, N.C_DIM = nt.bg, nt.panel, nt.hover, nt.line, nt.text, nt.dim
		applyAccent()
		passText()
		passShape()
		passRows()
		applyBg()
		applyGlow()
		applyToast()
		applyBlur()
		buildRules()
		if changed and not quiet then toast(tr("Контраст тексту підвищено"), ACCENT, true) end
	end

	local function rebuildRules()
		restore()
		passText()
		passShape()
		passRows()
		applyGlow()
		buildRules()
	end

	runPending = function()
		flushQueued = false
		local p = pending
		pending = {}
		local ok, err = pcall(function()
			if p.colors then
				fullApply()
				return
			end
			if p.rules then
				rebuildRules()
				return
			end
			if p.text then passText() end
			if p.shape then
				passShape()
				applyGlow()
			end
			if p.density then passRows() end
			if p.bg then applyBg() end
			if p.glow then applyGlow() end
			if p.blur then applyBlur() end
			if p.toast then applyToast() end
		end)
		if not ok then warn("[ZENITH] theme: " .. tostring(err)) end
	end

	local function schedule(kind)
		if not ready then return end
		pending[kind] = true
		if flushQueued then return end
		flushQueued = true
		task.defer(runPending)
	end

	local KIND = {
		ThBg = "colors", ThPanel = "colors", ThHover = "colors", ThLine = "colors", ThText = "colors", ThDim = "colors", ThAccent = "colors",
		ThFont = "text", ThTextSize = "text", ThRound = "shape", ThStroke = "shape", ThDensity = "density",
		ThGrad = "bg", ThGradC1 = "bg", ThGradC2 = "bg", ThGradAngle = "bg", ThImage = "bg", ThImageAlpha = "bg",
		ThGlow = "glow", ThBlur = "blur", ThToastPos = "toast", ThRulesOn = "rules", ThRules = "rules",
	}

	function TH.onAccent()
		if not ready then
			applyAccent()
			return
		end
		if bulk then return end
		if S.ThAccent ~= "" then
			S.ThAccent = ""
			for _, r in widgets.ThAccent or {} do r() end
		end
		schedule("colors")
	end

	function TH.onSet(key)
		if bulk then return end
		if key == "ThPreset" then
			if N.THEME_PRESETS[S.ThPreset] then TH.preset(S.ThPreset) end
			return
		end
		if key == "ThImage" then
			local id = string.match(tostring(S.ThImage), "%d+")
			id = id and string.sub(id, 1, 20) or ""
			if id ~= S.ThImage then
				S.ThImage = id
				for _, r in widgets.ThImage or {} do r() end
			end
		elseif key == "ThRules" and #S.ThRules > 3000 then
			S.ThRules = string.sub(S.ThRules, 1, 3000)
			for _, r in widgets.ThRules or {} do r() end
		end
		local kind = KIND[key]
		if kind then schedule(kind) end
	end

	function TH.preset(i)
		local p = N.THEME_PRESETS[i]
		if not p then return end
		local prev = bulk
		bulk = true
		local map = {
			ThBg = p.bg, ThPanel = p.panel, ThHover = p.hover, ThLine = p.line, ThText = p.text, ThDim = p.dim, ThAccent = p.accent,
			ThFont = p.font, ThRound = p.round, ThStroke = p.stroke or DEFAULTS.ThStroke, ThTextSize = p.tsize or 0,
			ThDensity = p.dens or 1, ThSpeed = p.speed or 1, ThGrad = p.grad, ThGlow = p.glow, ThBlur = p.blur or 0,
			ThToastPos = p.toast or 1, ThImage = "", ThImageAlpha = DEFAULTS.ThImageAlpha, ThRules = p.rules or "", ThRulesOn = true,
			ThGradC1 = p.c1 or DEFAULTS.ThGradC1, ThGradC2 = p.c2 or DEFAULTS.ThGradC2, ThGradAngle = p.ang or DEFAULTS.ThGradAngle,
			MenuAlpha = p.alpha or DEFAULTS.MenuAlpha,
		}
		for k, v in map do setValue(k, v, true) end
		bulk = prev
		schedule("colors")
	end

	function TH.reapply()
		if S.ThPreset ~= 1 then TH.preset(S.ThPreset) end
	end

	function TH.reset()
		setValue("ThPreset", 1, true)
		TH.preset(1)
		toast(tr("Тему скинуто"), ACCENT, true)
	end

	function TH.accentNow() return cur.accent end

	local function scaled(info)
		local sp = S.ThSpeed
		if sp == 1 then return info end
		local ok, r = pcall(function()
			return TweenInfo.new(info.Time / sp, info.EasingStyle, info.EasingDirection, info.RepeatCount, info.Reverses, (info.DelayTime or 0) / sp)
		end)
		return ok and r or info
	end
	TH.ti = scaled

	function TH.tw(obj, props, info)
		local ov = over[obj]
		if ov or hasSwap then
			local np = {}
			for k, v in props do
				local o = ov and ov[k]
				if o ~= nil then
					v = o
				elseif hasSwap and typeof(v) == "Color3" then
					v = swapMap[ckey(v)] or v
				end
				np[k] = v
			end
			props = np
		end
		return props, scaled(info or N.TI_FAST)
	end

	local function cleanValue(k, v)
		local d = DEFAULTS[k]
		if d == nil or type(v) ~= type(d) then return nil end
		if type(d) == "number" then
			local nv = tonumber(v)
			if not nv or nv ~= nv then return nil end
			local r = N.THEME_RANGE[k]
			if k == "ThPreset" and (nv < 1 or nv > #N.THEME_PRESETS) then return nil end
			if r then nv = math.clamp(nv, r[1], r[2]) end
			if N.THEME_INT[k] then nv = math.floor(nv + 0.5) end
			return nv
		elseif type(d) == "string" then
			local sv = tostring(v)
			if k == "ThBg" or k == "ThPanel" or k == "ThHover" or k == "ThLine" or k == "ThText" or k == "ThDim"
				or k == "ThAccent" or k == "ThGradC1" or k == "ThGradC2" then
				if sv == "" then return k == "ThAccent" and "" or nil end
				local c = parseColor(sv)
				return c and hex(c) or nil
			elseif k == "ThImage" then
				local id = string.match(sv, "%d+")
				return id and string.sub(id, 1, 20) or ""
			elseif k == "ThRules" then
				return string.sub(sv, 1, 3000)
			end
			return nil
		end
		return v
	end

	function TH.serialize(all)
		local out = {}
		for _, k in (all and N.SAVE_KEYS or N.THEME_EXPORT) do
			if S[k] ~= DEFAULTS[k] then out[k] = S[k] end
		end
		return N.HttpService:JSONEncode({ v = 1, k = out })
	end

	function TH.import(txt, withApp)
		local ok, data = pcall(function() return N.HttpService:JSONDecode(txt) end)
		if not ok or type(data) ~= "table" then return nil end
		local kv = type(data.k) == "table" and data.k or data
		local n = 0
		bulk = true
		for _, k in (withApp and N.SAVE_KEYS or N.THEME_EXPORT) do
			local nv = cleanValue(k, kv[k])
			if nv ~= nil then n += 1 else nv = DEFAULTS[k] end
			if S[k] ~= nv then
				setValue(k, nv, true)
				if k == "ThPreset" then TH.preset(nv) end
			end
		end
		bulk = false
		schedule("colors")
		return n
	end

	function TH.addPicker(page)
		local function part(parent, x, y, w, h, color, r)
			local f = Instance.new("Frame")
			f.Name = "_ztPv"
			f.Position = UDim2.fromOffset(x, y)
			f.Size = UDim2.fromOffset(w, h)
			f.BackgroundColor3 = color
			f.BorderSizePixel = 0
			f.Parent = parent
			if r > 0 then
				local c = Instance.new("UICorner")
				c.Name = "_ztCr"
				c.CornerRadius = UDim.new(0, r)
				c.Parent = f
			end
			return f
		end
		local function rim(parent, color)
			local st = Instance.new("UIStroke")
			st.Name = "_ztSt"
			st.Color = color
			st.Thickness = 1
			st.Parent = parent
		end
		local black = Color3.new(0, 0, 0)
		for i = 2, #N.THEME_PRESETS do
			local p = N.THEME_PRESETS[i]
			local row = makeRow(page, 68, true, true)
			local acc, dim = parseColor(p.accent) or black, parseColor(p.dim) or black
			local rr = math.clamp(math.floor(3 + 5 * p.round + 0.5), 2, 12)
			local pv = part(row, 12, 12, 60, 44, parseColor(p.bg) or black, rr)
			if p.grad then
				pv.BackgroundColor3 = Color3.new(1, 1, 1)
				local g = Instance.new("UIGradient")
				g.Name = "_ztGr"
				g.Color = ColorSequence.new(parseColor(p.c1) or black, parseColor(p.c2) or black)
				g.Rotation = p.ang or 135
				g.Parent = pv
			end
			rim(pv, (p.glow or 0) > 0.3 and acc or (parseColor(p.line) or black))
			part(pv, 7, 7, 22, 5, acc, 2)
			part(pv, 7, 16, 38, 3, dim, 1)
			part(pv, 7, 22, 28, 3, dim, 1)
			local pb = part(pv, 7, 30, 46, 9, parseColor(p.panel) or black, math.min(rr, 4))
			rim(pb, parseColor(p.line) or black)
			part(pb, 36, 2, 8, 5, acc, 2)

			local nm = makeText(row, UDim2.new(1, -150, 0, 22), UDim2.fromOffset(84, 10), N.THEME_PRESET_NAMES[i], N.TXT + 1, nil, FONT_B)
			local ds = makeText(row, UDim2.new(1, -150, 0, 28), UDim2.fromOffset(84, 34), N.THEME_DESC[i], 11, N.C_DIM)
			ds.TextWrapped = true
			ds.TextYAlignment = Enum.TextYAlignment.Top

			local dot = Instance.new("Frame")
			dot.AnchorPoint = Vector2.new(1, 0.5)
			dot.Size = UDim2.fromOffset(22, 22)
			dot.Position = UDim2.new(1, -14, 0.5, 0)
			dot.BackgroundColor3 = N.C_PANEL
			dot.BorderSizePixel = 0
			dot.Parent = row
			corner(dot, 1000)
			local dst = addStroke(dot, N.C_LINE, 1.5, 0)
			local core = Instance.new("Frame")
			core.AnchorPoint = Vector2.new(0.5, 0.5)
			core.Position = UDim2.fromScale(0.5, 0.5)
			core.Size = UDim2.fromOffset(10, 10)
			core.BackgroundColor3 = ACCENT
			core.BorderSizePixel = 0
			core.Parent = dot
			corner(core, 1000)

			local rs = row:FindFirstChildOfClass("UIStroke")
			register("ThPreset", function()
				local on = S.ThPreset == i
				core.Visible = on
				core.BackgroundColor3 = ACCENT
				nm.TextColor3 = on and ACCENT or N.C_TEXT
				dst.Color = on and ACCENT or N.C_LINE
				if rs then
					rs.Color = on and ACCENT or N.C_LINE
					rs.Transparency = on and 0 or 0.35
				end
			end)
			row.Activated:Connect(function() setValue("ThPreset", i) end)
		end
	end

	local function onAdded(inst)
		queued[#queued + 1] = inst
		if queueOn then return end
		queueOn = true
		task.defer(function()
			queueOn = false
			local q = queued
			queued = {}
			local m, fs = keyMap(), fontSet()
			local function one(d)
				if not TH.track(d) then return end
				recolorOne(d, m, cur)
				textOne(d, fs)
				cornerOne(d)
				strokeOne(d)
				if rowsH[d] then rowOne(d) end
				if rulesLive then applyRulesTo(d, m) end
			end
			for i = 1, #q do
				local inst2 = q[i]
				if inst2.Parent then
					one(inst2)
					for _, d in inst2:GetDescendants() do one(d) end
				end
			end
		end)
	end

	function TH.init()
		if ready then return end
		local win = UI.window
		winStroke = win:FindFirstChildOfClass("UIStroke")
		gradFrame = Instance.new("Frame")
		gradFrame.Name = "_ztGrad"
		gradFrame.Size = UDim2.fromScale(1, 1)
		gradFrame.BackgroundColor3 = Color3.new(1, 1, 1)
		gradFrame.BorderSizePixel = 0
		gradFrame.ZIndex = -2
		gradFrame.Visible = false
		gradFrame.Parent = win
		gradUI = Instance.new("UIGradient")
		gradUI.Name = "_ztGradUI"
		gradUI.Parent = gradFrame
		imgLabel = Instance.new("ImageLabel")
		imgLabel.Name = "_ztImg"
		imgLabel.Size = UDim2.fromScale(1, 1)
		imgLabel.BackgroundTransparency = 1
		imgLabel.BorderSizePixel = 0
		imgLabel.ScaleType = Enum.ScaleType.Crop
		imgLabel.ZIndex = -1
		imgLabel.Visible = false
		imgLabel.Parent = win
		for _, d in UI.gui:GetDescendants() do TH.track(d) end
		UI.gui.DescendantAdded:Connect(onAdded)
		ready = true
		pcall(fullApply)
		quiet = false

		local held = 0
		UI.menuBtn.MouseButton1Down:Connect(function()
			held += 1
			local id = held
			task.delay(3, function()
				if held == id then
					held += 1
					TH.reset()
				end
			end)
		end)
		for _, ev in { UI.menuBtn.MouseButton1Up, UI.menuBtn.MouseLeave } do
			ev:Connect(function() held += 1 end)
		end

		local acc = 0
		RunService.Heartbeat:Connect(function(dt)
			acc += dt
			if acc < 1 then return end
			acc = 0
			for inst, o in over do
				if inst.Parent then
					for p, v in o do
						if inst[p] ~= v then pcall(function() inst[p] = v end) end
					end
				end
			end
		end)
	end

	return TH
end)()

N.save = (function()
	local SV = { state = "wait", at = "", loaded = false, touched = false, pending = false, timer = false, busy = false, again = false, muted = false, fails = 0 }
	local rf
	local MSG = {
		wait = "Збереження: підключення до сервера...",
		loaded = "Збереження: тему завантажено з сервера",
		empty = "Збереження: підключено, збереженої теми ще немає",
		saving = "Збереження: записую...",
		saved = "Збереження: записано о %s",
		noserver = "Збереження: серверного скрипта немає, тема діє до виходу з гри",
		noapi = "Збереження: DataStore недоступний (увімкни API Services), тема діє до виходу з гри",
		err = "Збереження: помилка сервера, пробую ще раз",
		off = "Збереження: автозбереження вимкнено, зберігай кнопкою нижче",
	}

	local function getRemote(wait)
		if rf and rf.Parent then return rf end
		local RS = game:GetService("ReplicatedStorage")
		rf = RS:FindFirstChild(N.SAVE_REMOTE)
		if not rf and wait and wait > 0 then
			local ok, r = pcall(function() return RS:WaitForChild(N.SAVE_REMOTE, wait) end)
			rf = ok and r or nil
		end
		if rf and not rf:IsA("RemoteFunction") then rf = nil end
		return rf
	end

	function SV.refresh()
		local l = N.themeInfo
		if not l then return end
		local st = SV.state
		local line
		if st == "saved" then
			line = string.format(tr(MSG.saved), SV.at)
		else
			line = tr(MSG[st] or MSG.err)
		end
		l.Text = line
	end

	local function setState(st)
		SV.state = st
		SV.refresh()
	end

	function SV.flush(force)
		if SV.busy then
			SV.again = true
			return
		end
		if not (SV.loaded or force) then return end
		local r = getRemote(0)
		if not r then
			setState("noserver")
			return
		end
		SV.busy = true
		SV.pending = false
		setState("saving")
		task.spawn(function()
			local okEnc, payload = pcall(function() return N.theme.serialize(true) end)
			local ok, res = false, nil
			if okEnc then ok, res = pcall(function() return r:InvokeServer("set", payload) end) end
			SV.busy = false
			if ok and type(res) == "table" and res.ok then
				SV.fails = 0
				SV.at = os.date("%H:%M:%S")
				setState("saved")
				if force then toast(tr("Тему збережено"), ACCENT, true) end
			elseif ok and type(res) == "table" and res.err == "api" then
				setState("noapi")
			else
				SV.fails += 1
				setState("err")
				SV.pending = true
				if SV.fails < 5 then
					task.delay(8, function()
						if SV.pending and not SV.busy then SV.flush(true) end
					end)
				end
			end
			if SV.again then
				SV.again = false
				SV.flush(force)
			end
		end)
	end

	function SV.mark(key)
		if SV.muted then return end
		SV.touched = true
		if not (S.ThAuto or key == "ThAuto") then
			if SV.loaded then setState("off") end
			return
		end
		SV.pending = true
		if SV.timer then return end
		SV.timer = true
		task.delay(3, function()
			SV.timer = false
			if SV.pending then SV.flush() end
		end)
	end

	function SV.now()
		if not getRemote(0) then
			setState("noserver")
			toast(tr("Серверний скрипт збереження не знайдено"), Color3.fromRGB(215, 80, 85), true)
			return
		end
		SV.fails = 0
		SV.flush(true)
	end

	function SV.start()
		task.spawn(function()
			local r = getRemote(10)
			if not r then
				setState("noserver")
				return
			end
			for _ = 1, 3 do
				local ok, res = pcall(function() return r:InvokeServer("get") end)
				if ok and type(res) == "table" and res.ok then
					SV.loaded = true
					local data = res.data
					if SV.touched then
						SV.pending = true
						SV.flush()
					elseif type(data) == "string" and data ~= "" then
						SV.muted = true
						local n = N.theme.import(data, true)
						SV.muted = false
						setState(n and "loaded" or "empty")
					else
						setState("empty")
					end
					return
				end
				if ok and type(res) == "table" and res.err == "api" then
					setState("noapi")
					return
				end
				setState("err")
				task.wait(6)
			end
		end)
	end

	return SV
end)()

local function resetAll()
	for k, v in DEFAULTS do
		if k ~= "Lang" and not N.THEME_SET[k] then setValue(k, v, true) end
	end
	if N.theme then N.theme.reapply() 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 not N.THEME_SET[k] 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 not N.THEME_SET[k] 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 }
for k in N.THEME_SET do N.CFG_SKIP[k] = true end

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 с")
	addSlider(p, "AimMaxDist", "Дальність прицілу (5000 = без ліміту)", 50, 5000, 50, "%d")
	addSection(p, "ПОВЕДІНКА")
	addToggle(p, "AimSticky", "Тримати ціль, не стрибати між ворогами")
	addToggle(p, "AimYield", "Слабшати, коли я сам кручу камеру")
	addToggle(p, "AimMark", "Позначати захоплену ціль кільцем")
	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")
	addSlider(e, "EspOffX", "Зсув ESP по X (калібрування)", -200, 200, 1, "%d")
	addSlider(e, "EspOffY", "Зсув ESP по Y (калібрування)", -200, 200, 1, "%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", "Нескінченний стрибок")
	addCycle(m, "InfJumpMode", "Режим стрибка", N.JUMP_MODE_NAMES)
	addSlider(m, "InfJumpCount", "Стрибків у повітрі (режим «Кілька»)", 1, 10, 1, "%d")
	addSlider(m, "InfJumpPower", "Сила стрибка у повітрі", 50, 250, 10, "%d%%")
	addSlider(m, "InfJumpCd", "Пауза між стрибками", 0.05, 0.6, 0.01, "%.2f с")
	addToggle(m, "InfJumpFx", "Кільце під ногами при стрибку")
	addToggle(m, "InfJumpHud", "Показувати лічильник стрибків")
	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)
	addCycle(m, "SpinDir", "Напрямок обертання", N.SPIN_DIR_NAMES)
	addSlider(m, "SpinSpeed", "Швидкість крутилки", 60, 3000, 60, "%d °/с")
	addSlider(m, "SpinRate", "Частота змін (Гц)", 1, 60, 1, "%d")
	addSlider(m, "SpinSway", "Розмах хитавиці / ривка", 5, 180, 5, "%d °")
	addToggle(m, "SpinRamp", "Плавний розгін і зупинка")
	addToggle(m, "SpinSafe", "Не штовхати інших поруч")
	addToggle(m, "SpinNet", "Плавно для інших гравців")
	addKeybind(m, "KeySpin", "Клавіша антиприцілу (ПК)")

	local w = addTab("Світ")
	addSection(w, "ЗБІР МОНЕТ")
	addToggle(w, "Coins", "Авто-збір монет")
	addTextBox(w, "CoinName", "Назва об'єкта")
	addSlider(w, "CoinInterval", "Інтервал", 0.3, 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", "Повна яскравість")
	addSlider(w, "FbLevel", "Сила яскравості", 0, 100, 5, "%d%%")
	addToggle(w, "FbNoFog", "Прибрати туман і серпанок")
	addToggle(w, "FbNoPost", "Прибрати темні й розмиті ефекти")
	addToggle(w, "FbDay", "Завжди день (14:00)")
	addToggle(w, "CamFovOn", "Власний FOV камери")
	addSlider(w, "CamFov", "FOV камери", 40, 120, 1, "%d°")
	addToggle(w, "GravityOn", "Власна гравітація")
	addSlider(w, "Gravity", "Гравітація", 5, 300, 5, "%d%%")
	addCycle(w, "GravPreset", "Пресет гравітації", N.GRAV_NAMES)
	addToggle(w, "GravJump", "Стрибок за фізикою (вищий при слабкій гравітації)")
	addToggle(w, "Crosshair", "Свій приціл у центрі")
	addCycle(w, "CrossStyle", "Стиль прицілу", N.CROSS_STYLE_NAMES)
	addSlider(w, "CrossSize", "Довжина ліній / розмір", 2, 40, 1, "%d")
	addSlider(w, "CrossGap", "Розрив у центрі", 0, 24, 1, "%d")
	addSlider(w, "CrossThick", "Товщина", 1, 6, 1, "%d")
	addSlider(w, "CrossAlpha", "Прозорість прицілу", 0, 0.9, 0.05, "%.2f")
	addCycle(w, "CrossColor", "Колір прицілу", N.COLOR_NAMES)
	addToggle(w, "CrossOutline", "Чорна обводка")
	addToggle(w, "CrossDynamic", "Розширюється при русі, стрибку й пострілі")
	addToggle(w, "CrossEnemy", "Червоний, коли ворог під прицілом")
	addToggle(w, "CrossHit", "Маркер влучання (приблизний)")
	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, "ФОНОВИЙ ЗАХИСТ (працює автоматично)")
	N.cur.always = true
	addToggle(df, "GdLinks", "Скидати чужі прив'язки до вас")
	addToggle(df, "GdRide", "Не дати стояти на вашій голові")
	addToggle(df, "GdCage", "Проходити крізь клітки")
	addToggle(df, "GdSound", "Глушити гучні звуки гравців")
	addToggle(df, "GdPlrCol", "Вимикати колізії гравців кожні 2 с")
	addSection(df, "ГОЛОВНЕ")
	addButton(df, "УВІМКНУТИ ВЕСЬ АНТИЧІТ", enableAllAnticheat)
	addSection(df, "АНТИФЛІНГ")
	addToggle(df, "AntiFling", "Антифлінг")
	addToggle(df, "AfNoCollide", "Без колізій з гравцями")
	addToggle(df, "AfParts", "Гасити швидкі деталі поруч (кільця)")
	addToggle(df, "AfClamp", "Гасити різкі поштовхи")
	addToggle(df, "AfNoRagdoll", "Не падати від ударів")
	addToggle(df, "AfVoid", "Повертати з прірви")
	addToggle(df, "AfUnder", "Рятувати з-під карти")
	addToggle(df, "AfPark", "Заморожувати флінгерів за 100 студів")
	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", "Анти-падіння")
	addCycle(df, "FallMode", "Спосіб порятунку", N.FALL_MODE_NAMES)
	addSlider(df, "FallHeight", "Макс. висота над землею", 60, 800, 20, "%d ст")
	addSlider(df, "FallSpeed", "Макс. швидкість падіння", 100, 800, 20, "%d ст/с")
	addSlider(df, "FallSoft", "Швидкість приземлення", 30, 120, 5, "%d ст/с")
	addToggle(df, "FallMark", "Показувати місце приземлення")
	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", "Розвертати камеру на ворога")
	addToggle(dt, "CtSafe", "Безпечний контр-ТП (не за карту)")
	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, "ТЕМА МЕНЮ")
	N.theme.addPicker(s)
	addButton(s, "Стандартний вигляд", function() N.theme.reset() end)
	N.themeInfo = addInfo(s, 56)
	register("Lang", function() N.save.refresh() end)
	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)

	N.cur = nil
	N.curRow = nil
	selectTab(pages[1])
	register("CfgSlot", refreshCfgInfo)

	addDock("AIM", "Aim", function() setValue("Aim", not S.Aim) end)
	addDock("TP", nil, function() teleportToTarget() end, nil, "ТЕЛЕПОРТ ДО ЦІЛІ")
	addDock("PULL", nil, function() if pullToggle then pullToggle() end end, nil, "ЛОКАЛЬНИЙ ПРИТЯГ ВОРОГА (лише у вас)")
	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, nil, "БЛІЦ (оберт навколо ворога)")
	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.applySelection = function(sel)
	local keep = {}
	for _, rec in N.secs do
		for _, rw in rec.rows do
			if sel[rw] then
				for _, k in rw.keys do keep[k] = true end
			end
		end
	end
	local function kill(rw)
		for _, k in rw.keys do
			if not keep[k] then
				if type(S[k]) == "boolean" then
					if S[k] then setValue(k, false, true) end
					N.OFF[k] = true
				end
				widgets[k] = nil
			end
		end
		pcall(function() rw.obj:Destroy() end)
	end
	for _, rec in N.secs do
		if rec.always then
			rec.kept = true
		elseif not rec.page.fixed then
			local any = false
			for _, rw in rec.rows do
				if rw.can and sel[rw] then any = true end
			end
			rec.kept = any
			if not any then N.CUT[rec.name] = true end
			for _, rw in rec.rows do
				if (rw.can and not sel[rw]) or (not rw.can and not any) then kill(rw) end
			end
			if not any then pcall(function() rec.holder:Destroy() end) end
		end
	end
	for i = #pages, 1, -1 do
		local pg = pages[i]
		if not pg.fixed then
			local any = false
			for _, rec in pg.secs do
				if rec.kept then any = true break end
			end
			if not any then
				pcall(function() pg.frame:Destroy() end)
				pcall(function() pg.btn:Destroy() end)
				table.remove(pages, i)
			end
		end
	end
	if currentPage and not table.find(pages, currentPage) then currentPage = nil end
	if pages[1] then selectTab(pages[1]) end
	applyVisuals()
end

N.ART = {
	w = 44, h = 52, aw = 40, ah = 20,
	pal = { {132,86,60},{54,64,104},{34,42,72},{236,236,242},{222,166,58},{26,32,58},{44,54,92},{160,108,76},{30,150,148},{200,236,230},{26,22,24},{90,100,120},{66,20,28},{206,86,98} },
	body = { "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "..................00000000..................", "..................00000000..................", "..................00000000..................", "..................00000000..................", "..............1223000000003221..............", "...........2211123000000003211122...........", ".........22211112233344333221111222.........", "........2221111122333443332211111222........", ".......222111111123334433321111111222.......", "......22221111111223444332211111112222......", ".....2222211111111234444321111111122222.....", ".....2222111111111234444321111111112222.....", "....222221111111112344443211111111122222....", "...22222211111111112444421111111111222222...", "...22222211111111112444421111111111222222...", "...22222211111111111444411111111111222222...", "...22222111111111111444411111111111122222...", "...22222111111111111444411111111111122222...", "...22222111111111111144111111111111122222...", "..2222221111111111111441111111111111222222..", "..2222222111111111111441111111111112222222..", "..2222222111111111111111111111111112222222..", "..2222222211111111111221111111111122222222..", "..2222222211111111122222211111111122222222..", "..2222222221111112222222222111111222222222..", "..2222222221111222222222222221111222222222..", "..2222222222122222222222222222212222222222.." },
	sleeveL = { "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", ".....5555...................................", "....566665..................................", "...5666666..................................", "...56666665.................................", "...56666665.................................", "...5666666..................................", "...6666666..................................", "..56666665665...............................", "..566666666665..............................", "..5666666666665.............................", "..6666666666665.............................", "..6666666666665.............................", ".5666666666665..............................", ".566666666665...............................", ".66666666665................................", ".666666665..................................", ".56666665...................................", "..56665.....................................", "...555......................................", "............................................", "............................................", "............................................" },
	sleeveR = { "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "...................................5555.....", "..................................566665....", ".................................5666666....", ".................................56666665...", ".................................56666665...", ".................................56666666...", "..................................5666666...", "..............................556656666665..", "..............................566666666665..", ".............................5666666666665..", ".............................5666666666666..", ".............................5666666666666..", "..............................5666666666665.", "...............................566666666665.", "................................55666666666.", "..................................566666666.", "...................................55666665.", ".....................................56665..", "......................................555...", "............................................", "............................................", "............................................" },
	fistL = { "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", ".........777777.............................", "........77777777............................", "........77777777............................", "........70000007............................", "........70000007............................", "........77777777............................", ".........77777..............................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................" },
	fistR = { "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", ".............................474747.........", "............................77777777........", "............................77777777........", "............................70000007........", "............................70000007........", "............................77777777........", ".............................77777..........", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................" },
	head = { "............................................", "............................................", "............................................", ".....................77.....................", "..................77777777..................", ".................7777777777.................", "...............7777777777777................", "...............77778888887777...............", ".......8......7888988898898887..............", ".......8888.88898888888888888988............", "........888888888888888888888888............", "........888888888877777777888888............", "........888888877777777777777888............", ".......888807777777777777777777700..........", "......88.00077abaaaaaaaabaaaaa77000.........", ".........00077aaaaaaa77aaaaaaa77000.........", ".........00077aaaaaaa77aaaaaaa77000.........", ".........00077aaaaaaa77aaaaaaa77000.........", "..........007777777770077777777700..........", "............7777777770077777777.............", ".............777aaaaaaaaaaa7777.............", ".............777777777777777777.............", "..............777333333333c777..............", "..............777cccccccccc777..............", "...............77cccccccccc77...............", "...............77cccccccccc7................", ".................cccccccccc.................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................" },
	jaw = { "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "...................ddddd....................", ".................ccddddddcc.................", "..................7aaaaaa7..................", "...................aaaaaa...................", "....................aaaa....................", "....................aaaa....................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................", "............................................" },
	arm = { "........................................", "........................................", "........................................", "........................................", "........................................", "665555555555556335......................", "6666666666666663344.....................", "6666666666666663344.....................", "6666666666666663344.....................", "6666666666666663344.....................", "6666666666666663344.....................", "6666666666666663344.....................", "66666666666666633.......................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................" },
	fistC = { "........................................", "........................................", "........................................", "........................................", "........................................", "....................77777...............", "...................7777777..............", "..................770000077.............", "..................777777777.............", "..................770000077.............", "..................777777777.............", "...................7777777..............", "....................77777...............", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................", "........................................" },
	hand = { "........................................", "................................77......", "..............................7777......", "............................777777......", "..........................77777.........", "...................7777777777...7777....", "..................777777777.77777777....", "..................77777777777777777.....", ".................7777777777777..........", ".................7777777777777777777....", "..................777777777777777777....", "..................777777777.......7.....", "...................777777777777.........", "..................777777.777777777......", "..................777........77777......", "..................77............77......", ".................777....................", "..................77....................", "........................................", "........................................" },
}

N.GLYPHS = {
	Z = { "11111", "00001", "00010", "00100", "01000", "10000", "11111" },
	L = { "10000", "10000", "10000", "10000", "10000", "10000", "11111" },
	O = { "01110", "10001", "10001", "10001", "10001", "10001", "01110" },
	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(26, function()
		if not N.pickerStage then cleanup() end
	end)

	local ok, err = pcall(function()
		local chosen = false
		local function later(t, fn)
			task.delay(t, function()
				if gui and not chosen 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 stage, stScale, geo
		local autoSecs = 5

		local function layout()
			local scr = gui.AbsoluteSize
			if scr.X < 100 or scr.Y < 100 then
				local cam = workspace.CurrentCamera
				scr = cam and cam.ViewportSize or Vector2.new(800, 400)
			end
			local A = N.ART
			local wide = scr.X >= 600
			local tw = #N.PROJECT_NAME * 7 - 2
			local mR = isTouch and 44 or 16
			local cs = wide and math.clamp(math.floor(scr.Y * 0.6 / A.h), 3, 8)
				or math.clamp(math.floor(math.min(scr.X * 0.58 / (A.w + 18), scr.Y * 0.4 / A.h)), 3, 8)
			local figX = wide and scr.X * 0.25 or scr.X * 0.34
			local figY = wide and scr.Y * 0.54 or scr.Y * 0.6
			if wide then
				while cs > 3 and scr.X - mR - (figX + 52 * cs + 24) < 340 do cs -= 1 end
			end
			local availW = wide and (scr.X - mR - (figX + 52 * cs + 24)) or scr.X * 0.86
			local cs0 = math.clamp(math.floor(availW / tw), 3, 11)
			local bw = math.clamp(math.floor((availW - 16) / 3), 80, isTouch and 104 or 138)
			local zw = tw * cs0
			local halfW = math.max(zw, bw * 3 + 16, 330) / 2
			local colX = scr.X / 2
			if wide then
				colX = math.max(scr.X * 0.69, figX + 52 * cs + 24 + halfW)
				colX = math.min(colX, scr.X - mR - halfW)
			end
			local top
			if wide then
				top = math.max(isTouch and 14 or 24, math.floor((scr.Y - (7 * cs0 + 150)) / 2 - scr.Y * 0.04))
			else
				top = math.max(isTouch and 20 or 28, math.floor(scr.Y * 0.1))
			end
			return {
				cs = cs, cs0 = cs0, zw = zw, bw = bw, figX = figX, figY = figY, colX = colX,
				titleY = top + 3.5 * cs0, subY = top + 7 * cs0 + 12, langY = top + 7 * cs0 + 46,
			}
		end

		local function buildScene(L)
			local A = N.ART
			local cs, cs0, zw = L.cs, L.cs0, L.zw
			local psz = cs >= 4 and cs - 1 or cs
			local HEX = "0123456789abcdef"
			local rngH = Random.new()
			local queue = {}
			local function at(t, fn)
				queue[#queue + 1] = { t = t, fn = fn }
			end
			local tLaugh, tLaughEnd, tArm, tCharge, tOpen = 0.65, 1.5, 1.05, 1.42, 1.7

			stage = Instance.new("Frame")
			stage.Name = "HelloStage"
			stage.AnchorPoint = Vector2.new(0.5, 0.5)
			stage.Position = UDim2.fromScale(0.5, 0.5)
			stage.Size = UDim2.fromScale(1, 1)
			stage.BackgroundTransparency = 1
			stage.Parent = root
			stScale = Instance.new("UIScale")
			stScale.Parent = stage

			local fig = Instance.new("Frame")
			fig.AnchorPoint = Vector2.new(0.5, 0.5)
			fig.Size = UDim2.fromOffset(A.w * cs, A.h * cs)
			fig.Position = UDim2.fromOffset(L.figX, L.figY)
			fig.BackgroundTransparency = 1
			fig.Parent = stage

			local function group(parent, px, py)
				local g = Instance.new("Frame")
				g.Size = UDim2.fromOffset(0, 0)
				g.Position = UDim2.fromOffset(px * cs, py * cs)
				g.BackgroundTransparency = 1
				g.Parent = parent
				return g
			end

			local function fill(layer, parent, relX, relY, w)
				local out = {}
				for y, row in layer do
					for x = 1, w do
						local c = string.sub(row, x, x)
						if c ~= "." then
							local col = A.pal[string.find(HEX, c, 1, true)]
							local f = Instance.new("Frame")
							f.Size = UDim2.fromOffset(psz, psz)
							f.BorderSizePixel = 0
							f.BackgroundColor3 = Color3.fromRGB(col[1], col[2], col[3])
							f.BackgroundTransparency = 1
							local tx0, ty0 = (x - 1 - relX) * cs, (y - 1 - relY) * cs
							f.Position = UDim2.fromOffset(tx0, ty0)
							f.Parent = parent
							out[#out + 1] = { f = f, tp = UDim2.fromOffset(tx0, ty0), x = x - 1, y = y - 1 }
						end
					end
				end
				return out
			end

			local gBody = group(fig, 0, 0)
			local gL = group(fig, 0, 0)
			local gR = group(fig, 0, 0)
			local gHead = group(fig, 22, 28)
			local gJaw = group(gHead, 0, 0)
			local gArm = group(fig, 37, 33)
			local pBody = fill(A.body, gBody, 0, 0, A.w)
			local pL = fill(A.sleeveL, gL, 0, 0, A.w)
			local pL2 = fill(A.fistL, gL, 0, 0, A.w)
			local pR = fill(A.sleeveR, gR, 0, 0, A.w)
			local pR2 = fill(A.fistR, gR, 0, 0, A.w)
			local pHead = fill(A.head, gHead, 22, 28, A.w)
			local pJaw = fill(A.jaw, gJaw, 22, 28, A.w)
			local pArm = fill(A.arm, gArm, 0, 9, A.aw)
			local pFist = fill(A.fistC, gArm, 0, 9, A.aw)
			local pHand = fill(A.hand, gArm, 0, 9, A.aw)
			local armW = 1
			for _, p in pArm do
				if p.x > armW then armW = p.x end
			end

			local function assemble(list, delay0, span, dur)
				local info = TweenInfo.new(dur, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
				for _, p in list do
					p.f.Position = UDim2.fromOffset(p.tp.X.Offset + rngH:NextInteger(-150, 150), p.tp.Y.Offset + rngH:NextInteger(-110, 110))
					at(delay0 + rngH:NextNumber() * span, function()
						TweenService:Create(p.f, info, { Position = p.tp, BackgroundTransparency = 0 }):Play()
					end)
				end
			end
			assemble(pBody, 0.05, 0.4, 0.45)
			assemble(pL, 0.15, 0.35, 0.45)
			assemble(pL2, 0.25, 0.25, 0.4)
			assemble(pR, 0.15, 0.35, 0.45)
			assemble(pR2, 0.25, 0.25, 0.4)
			assemble(pHead, 0.15, 0.35, 0.45)
			assemble(pJaw, 0.4, 0.2, 0.3)

			local tx = Instance.new("Frame")
			tx.AnchorPoint = Vector2.new(0.5, 0.5)
			tx.Size = UDim2.fromOffset(zw, 7 * cs0)
			tx.Position = UDim2.fromOffset(L.colX, L.titleY)
			tx.BackgroundTransparency = 1
			tx.Parent = stage

			local function pix(word)
				local out = {}
				for li = 1, #word do
					local g = N.GLYPHS[string.sub(word, li, li)]
					if g then
						for r = 1, 7 do
							for c = 1, 5 do
								if string.sub(g[r], c, c) == "1" then
									out[#out + 1] = Vector2.new((li - 1) * 7 + c - 1, r - 1)
								end
							end
						end
					end
				end
				return out
			end
			local hp = pix("HELLO")
			local zp = pix(N.PROJECT_NAME)
			local hoff = (zw - (5 * 7 - 2) * cs0) / 2
			local hc = {}
			local hInfo = TweenInfo.new(0.45, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
			local hCol = TweenInfo.new(0.4)
			for i, v in hp do
				local f = Instance.new("Frame")
				f.Size = UDim2.fromOffset(cs0 - 1, cs0 - 1)
				f.BorderSizePixel = 0
				f.BackgroundColor3 = ACCENT
				f.BackgroundTransparency = 1
				local tp = UDim2.fromOffset(hoff + v.X * cs0, v.Y * cs0)
				f.Position = UDim2.fromOffset(hoff + v.X * cs0 + rngH:NextInteger(-110, 110), v.Y * cs0 + rngH:NextInteger(-80, 80))
				f.Parent = tx
				hc[i] = f
				at(0.1 + rngH:NextNumber() * 0.5, function()
					TweenService:Create(f, hInfo, { Position = tp, BackgroundTransparency = 0 }):Play()
					TweenService:Create(f, hCol, { BackgroundColor3 = N.C_TEXT }):Play()
				end)
			end

			local function pop(txt)
				local l = Instance.new("TextLabel")
				l.AnchorPoint = Vector2.new(0.5, 0.5)
				l.Size = UDim2.fromOffset(80, 26)
				l.Position = UDim2.fromOffset(A.w * cs * 0.9, A.h * cs * 0.08 + rngH:NextInteger(-5, 20))
				l.BackgroundTransparency = 1
				l.Text = txt
				l.TextColor3 = ACCENT
				l.Font = FONT_B
				l.TextSize = 20
				l.Rotation = rngH:NextInteger(-18, 18)
				l.Parent = fig
				TweenService:Create(l, TweenInfo.new(0.8, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
					{ Position = l.Position + UDim2.fromOffset(20, -50), TextTransparency = 1 }):Play()
				task.delay(0.9, function() l:Destroy() end)
			end

			local function palmPos()
				local a = math.rad(gArm.Rotation)
				return gArm.AbsolutePosition + Vector2.new(22 * cs * math.cos(a), 22 * cs * math.sin(a))
			end

			local function ring(r0, r1, dur, a0, a1, th)
				local c = palmPos() - stage.AbsolutePosition
				local f = Instance.new("Frame")
				f.AnchorPoint = Vector2.new(0.5, 0.5)
				f.Position = UDim2.fromOffset(c.X, c.Y)
				f.Size = UDim2.fromOffset(r0 * 2, r0 * 2)
				f.BackgroundTransparency = 1
				f.BorderSizePixel = 0
				f.Parent = stage
				corner(f, 1000)
				local info = TweenInfo.new(dur, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
				if th > 0 then
					local st = addStroke(f, ACCENT, th, a0)
					TweenService:Create(st, info, { Transparency = a1 }):Play()
				else
					f.BackgroundColor3 = N.C_TEXT
					f.BackgroundTransparency = a0
					TweenService:Create(f, info, { BackgroundTransparency = a1 }):Play()
				end
				TweenService:Create(f, info, { Size = UDim2.fromOffset(r1 * 2, r1 * 2) }):Play()
				task.delay(dur + 0.1, function() f:Destroy() end)
			end

			at(0.8, function() pop(rngH:NextNumber() > 0.5 and "HA" or "HAHA") end)
			at(1.08, function() pop(rngH:NextNumber() > 0.5 and "HA" or "HAHA") end)
			at(1.36, function() pop("HA") end)

			at(tArm, function()
				local fade = TweenInfo.new(0.15)
				for _, list in { pR, pR2 } do
					for _, p in list do
						TweenService:Create(p.f, fade, { BackgroundTransparency = 1 }):Play()
					end
				end
				local info = TweenInfo.new(0.3, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
				for _, p in pArm do
					p.f.Position = UDim2.fromOffset(0, 0)
					later(p.x / armW * 0.22, function()
						TweenService:Create(p.f, info, { Position = p.tp, BackgroundTransparency = 0 }):Play()
					end)
				end
			end)

			at(tArm + 0.26, function()
				local info = TweenInfo.new(0.22, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
				for _, p in pFist do
					p.f.Position = UDim2.fromOffset(0, 0)
					later(rngH:NextNumber() * 0.12, function()
						TweenService:Create(p.f, info, { Position = p.tp, BackgroundTransparency = 0 }):Play()
					end)
				end
			end)

			at(tCharge, function()
				ring(5.5 * cs, 1.2 * cs, tOpen - tCharge - 0.02, 1, 0.3, 2)
			end)

			local bxf = Instance.new("Frame")
			bxf.AnchorPoint = Vector2.new(0.5, 0.5)
			bxf.Size = UDim2.fromOffset(zw + 20, 7 * cs0 + 20)
			bxf.Position = UDim2.fromOffset(L.colX, L.titleY)
			bxf.BackgroundTransparency = 1
			bxf.Parent = stage
			local bl = math.clamp(math.floor(7 * cs0 * 0.6), 12, 26)
			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 = bxf
				local vt = hz:Clone()
				vt.Size = UDim2.fromOffset(2, 0)
				vt.Parent = bxf
				at(tOpen + 0.25 + d, function()
					local info = TweenInfo.new(0.6, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
					local to = UDim2.new(ax, sx * 4, ay, sy * 4)
					TweenService:Create(hz, info, { Position = to, Size = UDim2.fromOffset(bl, 2), BackgroundTransparency = 0 }):Play()
					TweenService:Create(vt, info, { Position = to, Size = UDim2.fromOffset(2, bl), BackgroundTransparency = 0 }):Play()
				end)
			end
			bracket(0, 0, 0)
			bracket(1, 0, 0.07)
			bracket(1, 1, 0.14)
			bracket(0, 1, 0.21)

			local scan = Instance.new("Frame")
			scan.AnchorPoint = Vector2.new(0.5, 0.5)
			scan.Position = UDim2.new(0, -cs0, 0.5, 0)
			scan.Size = UDim2.new(0, 2, 1, 14)
			scan.BackgroundColor3 = ACCENT
			scan.BorderSizePixel = 0
			scan.Visible = false
			scan.ZIndex = 5
			scan.Parent = tx
			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, 40, 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
			at(tOpen + 0.8, function()
				scan.Visible = true
				TweenService:Create(scan, TweenInfo.new(0.5, Enum.EasingStyle.Linear), { Position = UDim2.new(0, zw + cs0, 0.5, 0) }):Play()
				later(0.55, function() scan.Visible = false end)
			end)

			at(tOpen, function()
				for _, p in pFist do
					TweenService:Create(p.f, TweenInfo.new(0.08), { BackgroundTransparency = 1 }):Play()
				end
				local info = TweenInfo.new(0.34, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
				for _, p in pHand do
					p.f.Position = UDim2.fromOffset(22 * cs + rngH:NextInteger(-cs, cs), rngH:NextInteger(-cs, cs))
					later(rngH:NextNumber() * 0.1, function()
						TweenService:Create(p.f, info, { Position = p.tp, BackgroundTransparency = 0 }):Play()
					end)
				end
				ring(1.2 * cs, 11 * cs, 0.6, 0.05, 1, 3)
				ring(2 * cs, 6 * cs, 0.3, 0.4, 1, 0)
				later(0.09, function() ring(1.2 * cs, 7 * cs, 0.45, 0.35, 1, 2) end)
				for _, f in hc do
					TweenService:Create(f, TweenInfo.new(0.5, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
						Position = f.Position + UDim2.fromOffset(rngH:NextInteger(-90, 90), rngH:NextInteger(-80, 30)),
						BackgroundTransparency = 1,
					}):Play()
				end
				local from = palmPos() - tx.AbsolutePosition
				local fly = TweenInfo.new(0.72, Enum.EasingStyle.Quart, Enum.EasingDirection.Out)
				local tint = TweenInfo.new(0.35, Enum.EasingStyle.Quad, Enum.EasingDirection.Out, 0, false, 0.72)
				for _, v in zp do
					local f = Instance.new("Frame")
					f.BorderSizePixel = 0
					f.BackgroundColor3 = ACCENT
					f.BackgroundTransparency = 1
					f.Size = UDim2.fromOffset(2, 2)
					f.Position = UDim2.fromOffset(from.X, from.Y)
					f.Parent = tx
					local tp = UDim2.fromOffset(v.X * cs0, v.Y * cs0)
					later(0.05 + rngH:NextNumber() * 0.35, function()
						TweenService:Create(f, fly, { Position = tp, Size = UDim2.fromOffset(cs0 - 1, cs0 - 1), BackgroundTransparency = 0 }):Play()
						TweenService:Create(f, tint, { BackgroundColor3 = N.C_TEXT }):Play()
					end)
				end
			end)

			table.sort(queue, function(a, b) return a.t < b.t end)
			local qi = 1
			local t1 = os.clock()
			task.spawn(function()
				local okL, errL = pcall(function()
					while gui and not chosen do
						local t = os.clock() - t1
						while queue[qi] and queue[qi].t <= t do
							local fn = queue[qi].fn
							qi += 1
							local okQ, errQ = pcall(fn)
							if not okQ then warn("[ZENITH] intro event: " .. tostring(errQ)) end
						end
						local lt = math.max(t - tLaugh, 0)
						local amp = math.min(lt / 0.3, 1)
						if t > tLaughEnd then amp *= math.max(0, 1 - (t - tLaughEnd) / 0.35) end
						local env = 0.65 + 0.35 * math.sin(lt * 2.1)
						local pulse = math.abs(math.sin(lt * math.pi * 5.8))
						local breath = math.sin(t * 2.4) * 0.1 * cs
						local jaw = (0.25 + 0.75 * pulse) * env * amp
						gJaw.Position = UDim2.fromOffset(0, math.floor(jaw * 3 * cs + 0.5))
						gHead.Rotation = amp * (3.5 * math.sin(lt * 2.3) + 4 * (pulse - 0.5) * env) + 1.2 * math.sin(t * 1.7)
						gHead.Position = UDim2.fromOffset(22 * cs, 28 * cs - pulse * cs * 0.7 * env * amp + breath)
						local bx = math.sin(lt * 34) * cs * 0.12 * amp
						local by = pulse * cs * 0.5 * env * amp + breath * 0.6
						local sh = by + pulse * cs * 0.5 * env * amp
						gBody.Position = UDim2.fromOffset(bx, by)
						gL.Position = UDim2.fromOffset(bx, sh)
						if t < tArm then gR.Position = UDim2.fromOffset(bx, sh) end
						gArm.Position = UDim2.fromOffset(37 * cs + bx, 33 * cs + by)
						local rot = 0
						if t >= tArm then
							local u = t - tArm
							rot = 55 * math.exp(-5 * u) * math.cos(11 * u)
							if t > tCharge and t < tOpen then
								local k = (t - tCharge) / (tOpen - tCharge)
								rot += 2.6 * math.sin(k * math.pi) * math.sin((t - tCharge) * 70)
							end
							if t >= tOpen then
								local w = t - tOpen
								rot += 10 * math.exp(-1.9 * w) * math.sin(10 * w) + 2.5 * math.min(w / 1.4, 1) * math.sin(w * 3.2)
							end
						end
						gArm.Rotation = rot
						task.wait()
					end
				end)
				if not okL then warn("[ZENITH] intro frame: " .. tostring(errL)) end
			end)
			return { land = tOpen + 1.0 }
		end

		local L = layout()
		local okS, resS = pcall(buildScene, L)
		if okS then
			geo = resS
		else
			warn("[ZENITH] intro scene: " .. tostring(resS))
			if stage then pcall(function() stage:Destroy() end) end
			stage, stScale = nil, nil
			geo = { land = 0.3 }
		end

		local sub = Instance.new("TextLabel")
		sub.AnchorPoint = Vector2.new(0.5, 0)
		sub.Position = UDim2.fromOffset(L.colX, L.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.ZIndex = 3
		sub.Parent = root

		local bw = L.bw
		local langBox = Instance.new("CanvasGroup")
		langBox.AnchorPoint = Vector2.new(0.5, 0)
		langBox.Position = UDim2.fromOffset(L.colX, L.langY)
		langBox.Size = UDim2.fromOffset(math.max(bw * 3 + 56, 330), 104)
		langBox.BackgroundTransparency = 1
		langBox.GroupTransparency = 1
		langBox.Visible = false
		langBox.ZIndex = 3
		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, 20)
		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 skip
		local function showPicker()
			N.pickerStage = true
			local sel = {}
			local allRows = {}
			local function lbl(obj)
				if obj:IsA("TextButton") and obj.Text ~= "" then return obj.Text end
				for _, d in obj:GetChildren() do
					if d:IsA("TextLabel") and d.Text ~= "" then return d.Text end
				end
				return nil
			end
			for _, rec in N.secs do
				if not rec.page.fixed then
					for _, rw in rec.rows do
						rw.label = lbl(rw.obj)
						rw.can = not rec.always and rw.label ~= nil and (#rw.keys > 0 or rw.obj:IsA("TextButton"))
						if rw.can then allRows[#allRows + 1] = rw end
					end
				end
			end
			local total, count = #allRows, 0

			local scr = gui.AbsoluteSize
			local insL = math.max(UI.gui.AbsolutePosition.X, 0)
			local insR = math.max(scr.X - (UI.gui.AbsolutePosition.X + UI.gui.AbsoluteSize.X), 0)
			local insT = math.max(UI.gui.AbsolutePosition.Y, 0)
			local insB = math.max(scr.Y - (UI.gui.AbsolutePosition.Y + UI.gui.AbsoluteSize.Y), 0)
			local mx = math.max(insL, insR) + 14
			local my = math.max(insT, insB) + (scr.Y < 420 and 6 or 14)
			local compact = scr.Y < 420
			local topH = compact and 34 or 66
			local botH = isTouch and 50 or 56
			local wide = scr.X - mx * 2 >= 520

			local panel = Instance.new("CanvasGroup")
			panel.AnchorPoint = Vector2.new(0.5, 0.5)
			panel.Position = UDim2.new(0.5, 0, 0.5, 16)
			panel.Size = UDim2.new(1, -mx * 2, 1, -my * 2)
			panel.BackgroundTransparency = 1
			panel.GroupTransparency = 1
			panel.Parent = root
			local lim = Instance.new("UISizeConstraint")
			lim.MaxSize = Vector2.new(640, 480)
			lim.Parent = panel

			makeText(panel, UDim2.new(1, -170, 0, 24), UDim2.fromOffset(4, 2), "ОБЕРІТЬ ФУНКЦІЇ", compact and 15 or 17, N.C_TEXT, FONT_B)
			if not compact then
				local sub2 = makeText(panel, UDim2.new(1, -8, 0, 32), UDim2.fromOffset(4, 28),
					"Відкрийте вкладку і позначте лише потрібні функції. Невибране вирізається з меню і не навантажує пристрій.", 12, N.C_DIM, N.FONT)
				sub2.TextWrapped = true
				sub2.TextYAlignment = Enum.TextYAlignment.Top
			end
			local counter = makeText(panel, UDim2.fromOffset(160, 22), UDim2.new(1, -164, 0, 3), "", 13, ACCENT, FONT_B,
				Enum.TextXAlignment.Right, true)

			local scroll = Instance.new("ScrollingFrame")
			scroll.Position = UDim2.fromOffset(0, topH)
			scroll.Size = UDim2.new(1, 0, 1, -(topH + botH + 8))
			scroll.BackgroundColor3 = N.C_PANEL
			scroll.BorderSizePixel = 0
			scroll.ScrollBarThickness = isTouch and 5 or 4
			scroll.ScrollBarImageColor3 = N.C_LINE
			scroll.CanvasSize = UDim2.new()
			scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
			scroll.Parent = panel
			corner(scroll, 12)
			addStroke(scroll, N.C_LINE, 1, 0.2)
			local sp2 = Instance.new("UIPadding")
			sp2.PaddingTop, sp2.PaddingBottom = UDim.new(0, 8), UDim.new(0, 8)
			sp2.PaddingLeft, sp2.PaddingRight = UDim.new(0, 8), UDim.new(0, 10)
			sp2.Parent = scroll
			local sl2 = Instance.new("UIListLayout")
			sl2.Padding = UDim.new(0, 3)
			sl2.SortOrder = Enum.SortOrder.LayoutOrder
			sl2.Parent = scroll

			local order = 0
			local function mkRow(h, text, style, indent, parent)
				order += 1
				local r = Instance.new("TextButton")
				r.LayoutOrder = order
				r.Size = UDim2.new(1, 0, 0, h)
				r.BackgroundColor3 = N.C_ROW_HI
				r.BackgroundTransparency = 1
				r.BorderSizePixel = 0
				r.AutoButtonColor = false
				r.Text = ""
				r.Parent = parent or scroll
				corner(r, 9)
				local box = Instance.new("Frame")
				box.AnchorPoint = Vector2.new(0, 0.5)
				box.Size = UDim2.fromOffset(20, 20)
				box.Position = UDim2.new(0, 10 + indent, 0.5, 0)
				box.BackgroundColor3 = N.C_BG
				box.BorderSizePixel = 0
				box.Parent = r
				corner(box, 6)
				local bst = addStroke(box, N.C_LINE, 1)
				local fillF = Instance.new("Frame")
				fillF.AnchorPoint = Vector2.new(0.5, 0.5)
				fillF.Position = UDim2.fromScale(0.5, 0.5)
				fillF.Size = UDim2.fromOffset(0, 0)
				fillF.BackgroundColor3 = ACCENT
				fillF.BorderSizePixel = 0
				fillF.Parent = box
				corner(fillF, 4)
				local tcol = style == 1 and ACCENT or (style == 2 and N.C_DIM or N.C_TEXT)
				local tfont = style == 3 and N.FONT or FONT_B
				local tsize = style == 1 and 15 or (style == 2 and 12 or 13)
				local t = Instance.new("TextLabel")
				t.BackgroundTransparency = 1
				t.Size = UDim2.new(1, -(46 + indent + (style == 1 and 50 or 0)), 1, 0)
				t.Position = UDim2.fromOffset(40 + indent, 0)
				t.Text = text
				t.TextColor3 = tcol
				t.Font = tfont
				t.TextSize = tsize
				t.TextXAlignment = Enum.TextXAlignment.Left
				t.TextTruncate = Enum.TextTruncate.AtEnd
				t.Parent = r
				r.MouseEnter:Connect(function() tween(r, { BackgroundTransparency = 0.4 }) end)
				r.MouseLeave:Connect(function() tween(r, { BackgroundTransparency = 1 }) end)
				return r, fillF, bst, box
			end

			local tabUI, secUI, rowUI = {}, {}, {}
			local allBtn, contBtn
			local function paint(f, st, n, of)
				local sz = n == of and 12 or (n > 0 and 6 or 0)
				if of == 0 then sz = 0 end
				tween(f, { Size = UDim2.fromOffset(sz, sz) }, TweenInfo.new(0.2, Enum.EasingStyle.Back, Enum.EasingDirection.Out))
				tween(st, { Color = n > 0 and ACCENT or N.C_LINE })
			end
			local function countRows(list)
				local n, m = 0, 0
				for _, rw in list do
					if rw.can then
						m += 1
						if sel[rw] then n += 1 end
					end
				end
				return n, m
			end
			local function refresh()
				count = 0
				for _, rw in allRows do
					if sel[rw] then count += 1 end
				end
				for rw, ui in rowUI do paint(ui.fill, ui.st, sel[rw] and 1 or 0, 1) end
				for rec, ui in secUI do
					local n, m = countRows(rec.rows)
					paint(ui.fill, ui.st, n, m)
				end
				for pg, ui in tabUI do
					local n, m = 0, 0
					for _, rec in pg.secs do
						local a, b = countRows(rec.rows)
						n += a
						m += b
					end
					paint(ui.fill, ui.st, n, m)
					ui.cnt.Text = string.format("%d/%d", n, m)
				end
				counter.Text = string.format(tr("Вибрано: %d / %d"), count, total)
				allBtn.Text = count == total and tr("Зняти все") or tr("Вибрати все")
				tween(contBtn, { BackgroundTransparency = count > 0 and 0 or 0.65 })
			end
			local function setList(list, on)
				for _, rw in list do
					if rw.can then sel[rw] = on or nil end
				end
			end

			local secH = isTouch and 40 or 34
			for _, pg in pages do
				if not pg.fixed then
					local anyRow = false
					for _, rec in pg.secs do
						for _, rw in rec.rows do
							if rw.can then anyRow = true end
						end
					end
					if anyRow then
						local hr, hf, hs = mkRow(isTouch and 44 or 38, tr(pg.name), 1, 0)
						local cnt = Instance.new("TextLabel")
						cnt.AnchorPoint = Vector2.new(1, 0.5)
						cnt.Position = UDim2.new(1, -12, 0.5, 0)
						cnt.Size = UDim2.fromOffset(46, 20)
						cnt.BackgroundTransparency = 1
						cnt.TextColor3 = N.C_DIM
						cnt.Font = N.FONT
						cnt.TextSize = 12
						cnt.TextXAlignment = Enum.TextXAlignment.Right
						cnt.Text = ""
						cnt.Parent = hr
						tabUI[pg] = { fill = hf, st = hs, cnt = cnt }

						local hit = Instance.new("TextButton")
						hit.Size = UDim2.fromOffset(44, isTouch and 44 or 38)
						hit.BackgroundTransparency = 1
						hit.Text = ""
						hit.ZIndex = 3
						hit.Parent = hr
						hit.Activated:Connect(function()
							local n, m = 0, 0
							for _, rec in pg.secs do
								local a, b = countRows(rec.rows)
								n += a
								m += b
							end
							for _, rec in pg.secs do setList(rec.rows, n < m) end
							refresh()
						end)

						order += 1
						local body = Instance.new("Frame")
						body.LayoutOrder = order
						body.Size = UDim2.new(1, 0, 0, 0)
						body.AutomaticSize = Enum.AutomaticSize.Y
						body.BackgroundTransparency = 1
						body.Visible = false
						body.Parent = scroll
						local bl = Instance.new("UIListLayout")
						bl.Padding = UDim.new(0, 3)
						bl.SortOrder = Enum.SortOrder.LayoutOrder
						bl.Parent = body

						local built = false
						local function build()
							built = true
							for _, rec in pg.secs do
								local hasAny = false
								for _, rw in rec.rows do
									if rw.can then hasAny = true end
								end
								if hasAny then
									local sr, sf, ss = mkRow(isTouch and 36 or 30, tr(rec.name), 2, 14, body)
									secUI[rec] = { fill = sf, st = ss }
									sr.Activated:Connect(function()
										local n, m = countRows(rec.rows)
										setList(rec.rows, n < m)
										refresh()
									end)
									order += 1
									local grid2 = Instance.new("Frame")
									grid2.LayoutOrder = order
									grid2.Size = UDim2.new(1, 0, 0, 0)
									grid2.AutomaticSize = Enum.AutomaticSize.Y
									grid2.BackgroundTransparency = 1
									grid2.Parent = body
									local gl = Instance.new("UIGridLayout")
									gl.CellSize = wide and UDim2.new(0.5, -3, 0, secH) or UDim2.new(1, 0, 0, secH)
									gl.CellPadding = UDim2.fromOffset(6, 3)
									gl.SortOrder = Enum.SortOrder.LayoutOrder
									gl.Parent = grid2
									for _, rw in rec.rows do
										if rw.can then
											local r, f, st = mkRow(secH, rw.label, 3, wide and 22 or 28, grid2)
											rowUI[rw] = { fill = f, st = st }
											r.Activated:Connect(function()
												sel[rw] = (not sel[rw]) or nil
												refresh()
											end)
										end
									end
								end
							end
							refresh()
						end
						hr.Activated:Connect(function()
							if not built then build() end
							body.Visible = not body.Visible
						end)
					end
				end
			end

			local bottom = Instance.new("Frame")
			bottom.AnchorPoint = Vector2.new(0, 1)
			bottom.Position = UDim2.fromScale(0, 1)
			bottom.Size = UDim2.new(1, 0, 0, botH)
			bottom.BackgroundTransparency = 1
			bottom.Parent = panel

			allBtn = Instance.new("TextButton")
			allBtn.Size = UDim2.new(0.5, -5, 1, 0)
			allBtn.BackgroundColor3 = N.C_PANEL
			allBtn.BorderSizePixel = 0
			allBtn.AutoButtonColor = false
			allBtn.TextColor3 = N.C_TEXT
			allBtn.Font = FONT_B
			allBtn.TextSize = 17
			allBtn.Parent = bottom
			corner(allBtn, 12)
			local abs2 = addStroke(allBtn, N.C_LINE, 1)
			allBtn.MouseEnter:Connect(function()
				tween(allBtn, { BackgroundColor3 = N.C_ROW_HI })
				tween(abs2, { Color = ACCENT })
			end)
			allBtn.MouseLeave:Connect(function()
				tween(allBtn, { BackgroundColor3 = N.C_PANEL })
				tween(abs2, { Color = N.C_LINE })
			end)

			contBtn = Instance.new("TextButton")
			contBtn.AnchorPoint = Vector2.new(1, 0)
			contBtn.Position = UDim2.fromScale(1, 0)
			contBtn.Size = UDim2.new(0.5, -5, 1, 0)
			contBtn.BackgroundColor3 = ACCENT
			contBtn.BorderSizePixel = 0
			contBtn.AutoButtonColor = false
			contBtn.TextColor3 = N.C_BG
			contBtn.Font = FONT_B
			contBtn.TextSize = 17
			contBtn.Text = tr("Продовжити")
			contBtn.Parent = bottom
			corner(contBtn, 12)

			allBtn.Activated:Connect(function()
				setList(allRows, count ~= total)
				refresh()
			end)

			local done = false
			local function finish(all)
				if done then return end
				done = true
				local set = {}
				for _, rw in allRows do
					if all or sel[rw] then set[rw] = true end
				end
				local okA, errA = pcall(N.applySelection, set)
				if not okA then warn("[ZENITH] selection: " .. tostring(errA)) end
				TweenService:Create(panel, TweenInfo.new(0.4, Enum.EasingStyle.Quad), { GroupTransparency = 1 }):Play()
				TweenService:Create(root, TweenInfo.new(0.5), { BackgroundTransparency = 1 }):Play()
				task.wait(0.55)
				cleanup()
			end
			contBtn.Activated:Connect(function()
				if count == 0 then
					counter.TextColor3 = Color3.fromRGB(235, 90, 90)
					tween(counter, { TextColor3 = ACCENT }, TweenInfo.new(0.7))
					return
				end
				finish(false)
			end)
			task.delay(240, function()
				if gui and not done then finish(true) end
			end)

			refresh()
			tween(panel, { GroupTransparency = 0, Position = UDim2.fromScale(0.5, 0.5) },
				TweenInfo.new(0.6, Enum.EasingStyle.Quint, Enum.EasingDirection.Out))
		end

		local curtain
		local function choose(idx)
			if chosen then return end
			chosen = true
			setValue("Lang", idx, true)
			if stage and stage.Parent then
				curtain = Instance.new("Frame")
				curtain.Size = UDim2.fromScale(1, 1)
				curtain.BackgroundColor3 = root.BackgroundColor3
				curtain.BackgroundTransparency = 1
				curtain.BorderSizePixel = 0
				curtain.ZIndex = 2
				curtain.Parent = root
				TweenService:Create(curtain, TweenInfo.new(0.45, Enum.EasingStyle.Quad), { BackgroundTransparency = 0.04 }):Play()
				if stScale then
					TweenService:Create(stScale, TweenInfo.new(0.55, Enum.EasingStyle.Quart, Enum.EasingDirection.In), { Scale = 1.06 }):Play()
				end
			end
			TweenService:Create(langBox, TweenInfo.new(0.45, Enum.EasingStyle.Quad), { GroupTransparency = 1 }):Play()
			fadeAll(sub, 0.45)
			fadeAll(skip, 0.45)
			task.wait(0.55)
			if not gui then return end
			pcall(function()
				if stage then stage:Destroy() end
				if curtain then curtain:Destroy() end
				sub:Destroy()
				langBox:Destroy()
				skip:Destroy()
			end)
			local okP, errP = pcall(showPicker)
			if not okP then
				warn("[ZENITH] picker: " .. tostring(errP))
				cleanup()
			end
		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

		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.ZIndex = 4
		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(geo.land)
				if chosen then return end
				TweenService:Create(sub, TweenInfo.new(0.6, Enum.EasingStyle.Quint, Enum.EasingDirection.Out),
					{ TextTransparency = 0, Position = UDim2.fromOffset(L.colX, L.subY) }):Play()
				task.wait(0.35)
				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(autoSecs, Enum.EasingStyle.Linear), { Size = UDim2.new(0, 0, 0, 1) }):Play()
				local startLang = S.Lang
				for k = autoSecs, 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(dt)
	local cam = getCamera()
	if not cam then return end

	local p = getAimPoint()
	local ix, iy = N.inset()
	UI.circle.Position = UDim2.fromOffset(p.X + ix, p.Y + iy)
	if N.crossStep then N.crossStep(dt, cam, ix, iy) end

	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 A = N.aim
	local now = os.clock()
	local active = S.Aim and (not S.AimHold or not N.hasMouse or aimHeld)
	if active or S.Debug then
		local o = A.opts
		o.prefer = S.AimSticky and A.lock or nil
		o.maxDist = S.AimMaxDist < 5000 and S.AimMaxDist or nil
		currentTarget = getTarget(S.UseFov, S.MotAim, o)
	else
		currentTarget = nil
	end

	local part = nil
	if active and currentTarget then
		A.lock = currentTarget.char
		part = currentTarget.aimPart or currentTarget.part or getAimPart(currentTarget.char)
	else
		A.lock = nil
	end

	local marked = false
	if part then
		local camPos = cam.CFrame.Position
		local look = cam.CFrame.LookVector
		local k = 1
		if S.AimYield then
			if A.look and look:Dot(A.look) < 0.9999 then A.yieldUntil = now + 0.22 end
			if now < A.yieldUntil then k = 0.2 end
		end

		local vel = part.AssemblyLinearVelocity
		if vel.Magnitude > 120 then vel = vel.Unit * 120 end
		local pos = part.Position + vel * S.Prediction
		local m = (pos - camPos).Magnitude
		if m > 0.5 and m < 1e6 then
			local s = math.clamp(S.Smooth, 0.02, 1)
			local a = (1 - (1 - s) ^ (math.clamp(dt or 1 / 60, 0.001, 0.1) * 60)) * k
			cam.CFrame = cam.CFrame:Lerp(CFrame.lookAt(camPos, pos), a)
		end
		A.look = cam.CFrame.LookVector

		if S.AimMark and UI.lockMark then
			local sp, on = cam:WorldToViewportPoint(part.Position)
			if on and sp.Z > 0 then
				UI.lockMark.Position = UDim2.fromOffset(sp.X + ix, sp.Y + iy)
				marked = true
			end
		end
	else
		A.look = nil
	end
	if UI.lockMark then UI.lockMark.Visible = marked 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
N.spin = {
	ang = 0, spd = 0, sign = 1, flipAt = 0, tickAt = 0, k = 1, nearAt = 0, near = false, on = false,
	jit = 1, rnd = 0, flickNext = 0, flickUntil = 0, flickOff = 0,
}

do
	local Z = N.spin
	local HST = Enum.HumanoidStateType

	local function wrap180(a)
		return (a + 180) % 360 - 180
	end

	local function blocked(hum)
		if hum.Health <= 0 or hum.Sit or hum.SeatPart ~= nil then return true end
		local st = hum:GetState()
		return st == HST.Climbing or st == HST.Swimming or st == HST.Dead or st == HST.Ragdoll
			or st == HST.FallingDown or st == HST.PlatformStanding or st == HST.Physics
	end

	local function nearOthers(root, now)
		if now < Z.nearAt then return Z.near end
		Z.nearAt = now + 0.12
		local rp = root.Position
		local near = false
		for _, plr in Players:GetPlayers() do
			if plr ~= player then
				local r = getRoot(plr.Character)
				if r then
					local d = r.Position - rp
					if math.abs(d.Y) < 6 and Vector3.new(d.X, 0, d.Z).Magnitude < 6 then
						near = true
						break
					end
				end
			end
		end
		Z.near = near
		return near
	end

	N.spinUpdate = function(char, root, hum, dt)
		local want = S.Spin
		if not want and not Z.on then return end
		local now = os.clock()
		dt = math.clamp(dt or 1 / 60, 0.001, 0.1)

		if want and not Z.on then
			Z.on = true
			Z.spd = 0
			Z.k = 1
			Z.tickAt, Z.flickNext = now, now
			Z.flipAt = now + 1.4
			Z.sign = S.SpinDir == 2 and -1 or 1
			local lv = root.CFrame.LookVector
			Z.ang = math.deg(math.atan2(-lv.X, -lv.Z))
			Z.rnd = Z.ang
		end

		if not want and (S.SpinMode ~= 1 or not S.SpinRamp or math.abs(Z.spd) < 15) then
			Z.on, Z.spd = false, 0
			hum.AutoRotate = true
			root.AssemblyAngularVelocity = Vector3.zero
			return
		end

		local kT = 1
		if S.SpinSafe and want and nearOthers(root, now) then kT = 0.25 end
		Z.k += (kT - Z.k) * math.min(dt * 8, 1)
		local k = Z.k

		local camYaw = nil
		local cam = getCamera()
		if cam then
			local lv = cam.CFrame.LookVector
			if lv.X * lv.X + lv.Z * lv.Z > 1e-4 then
				camYaw = math.deg(math.atan2(-lv.X, -lv.Z)) + 180
			end
		end
		local ref = camYaw or Z.ang
		local mode = S.SpinMode
		local yaw

		if mode == 2 then
			if now >= Z.tickAt then
				Z.tickAt = Z.tickAt + 1 / math.max(S.SpinRate, 1)
				if Z.tickAt < now then Z.tickAt = now end
				Z.rnd = math.random() * 360
			end
			yaw = ref + wrap180(Z.rnd - ref) * k
		elseif mode == 3 then
			local d = wrap180(ref - Z.ang)
			if S.SpinRamp then
				local maxStep = (S.SpinSpeed > 360 and S.SpinSpeed or 360) * dt
				d = math.clamp(d, -maxStep, maxStep)
			end
			yaw = Z.ang + d
		elseif mode == 4 then
			if now >= Z.tickAt then
				Z.tickAt = Z.tickAt + 1 / math.max(S.SpinRate, 1)
				if Z.tickAt < now then Z.tickAt = now end
				Z.jit = -Z.jit
			end
			yaw = ref + Z.jit * S.SpinSway * k
		elseif mode == 5 then
			if now >= Z.flickNext then
				Z.flickNext = now + (0.4 + math.random() * 0.8) * 12 / math.max(S.SpinRate, 1)
				Z.flickUntil = now + 0.09
				Z.flickOff = (math.random() < 0.5 and -1 or 1) * S.SpinSway * (0.6 + 0.4 * math.random())
			end
			yaw = ref + (now < Z.flickUntil and Z.flickOff * k or 0)
		else
			if want and S.SpinDir == 3 and now >= Z.flipAt then
				Z.sign = -Z.sign
				Z.flipAt = now + 1.4
			end
			local target = want and Z.sign * S.SpinSpeed * k or 0
			if S.SpinRamp then
				local step = (S.SpinSpeed > 360 and S.SpinSpeed or 360) / 0.35 * dt
				Z.spd += math.clamp(target - Z.spd, -step, step)
			else
				Z.spd = target
			end
			yaw = Z.ang + Z.spd * dt
		end

		Z.ang = yaw % 360
		hum.AutoRotate = false
		if not blocked(hum) then
			root.CFrame = CFrame.new(root.Position) * CFrame.Angles(0, math.rad(Z.ang), 0)
			local w = (S.SpinNet and mode == 1) and math.rad(Z.spd) or 0
			root.AssemblyAngularVelocity = Vector3.new(0, w, 0)
		end
	end
end

N.jump = { n = 0, last = 0, armed = true, airT = 0, pend = nil }

do
	local J = N.jump
	local HST = Enum.HumanoidStateType
	local pips = nil
	local dots = {}

	local function ensurePips(count)
		if not pips then
			pips = Instance.new("Frame")
			pips.Name = "AirJumpPips"
			pips.AnchorPoint = Vector2.new(0.5, 1)
			pips.Position = UDim2.new(0.5, 0, 1, -118)
			pips.Size = UDim2.fromOffset(0, 14)
			pips.AutomaticSize = Enum.AutomaticSize.X
			pips.BackgroundTransparency = 1
			pips.Visible = false
			pips.Parent = UI.overlay
			local lay = Instance.new("UIListLayout")
			lay.FillDirection = Enum.FillDirection.Horizontal
			lay.HorizontalAlignment = Enum.HorizontalAlignment.Center
			lay.VerticalAlignment = Enum.VerticalAlignment.Center
			lay.Padding = UDim.new(0, 5)
			lay.Parent = pips
		end
		while #dots < count do
			local d = Instance.new("Frame")
			d.Size = UDim2.fromOffset(isTouch and 12 or 10, isTouch and 12 or 10)
			d.BorderSizePixel = 0
			d.LayoutOrder = #dots + 1
			d.Parent = pips
			corner(d, 9999)
			acc(d, "BackgroundColor3")
			dots[#dots + 1] = d
		end
		for i, d in dots do d.Visible = i <= count end
	end

	local function grounded(hum)
		return hum.FloorMaterial ~= Enum.Material.Air
	end

	local function blocked(hum)
		if hum.Health <= 0 or hum.Sit or hum.SeatPart ~= nil then return true end
		local st = hum:GetState()
		return st == HST.Climbing or st == HST.Swimming or st == HST.Dead or st == HST.Ragdoll
			or st == HST.FallingDown or st == HST.PlatformStanding or st == HST.Physics
	end

	local function ring(root, hum)
		if not S.InfJumpFx then return end
		local cam = workspace.CurrentCamera
		if not cam then return end
		local hip = hum.RigType == Enum.HumanoidRigType.R6 and 3 or (hum.HipHeight + root.Size.Y / 2)
		local r = Instance.new("Part")
		r.Name = "FunModeJumpFx"
		r.Shape = Enum.PartType.Cylinder
		r.Anchored = true
		r.CanCollide = false
		r.CanQuery = false
		r.CanTouch = false
		r.Massless = true
		r.CastShadow = false
		r.Material = Enum.Material.Neon
		r.Color = ACCENT
		r.Transparency = 0.2
		r.Size = Vector3.new(0.12, 1.6, 1.6)
		r.CFrame = CFrame.new(root.Position - Vector3.new(0, hip - 0.1, 0)) * CFrame.Angles(0, 0, math.pi / 2)
		r.Parent = cam
		TweenService:Create(r, TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
			{ Size = Vector3.new(0.04, 7.5, 7.5), Transparency = 1 }):Play()
		task.delay(0.5, function() r:Destroy() end)
	end

	local function doJump(hum, root, now)
		J.last = now
		J.armed = false
		J.n += 1
		markSelf(0.5)
		hum:ChangeState(HST.Jumping)
		local scale = math.clamp(S.InfJumpPower / 100, 0.3, 3)
		J.pend = scale ~= 1 and { n = 4, scale = scale } or nil
		ring(root, hum)
	end

	local function request()
		if not S.InfJump then return end
		local char = player.Character
		local hum, root = getHum(char), getRoot(char)
		if not (hum and root) then return end
		if grounded(hum) then
			J.armed = false
			return
		end
		local now = os.clock()
		if blocked(hum) or not J.armed or J.airT < 0.1 or now - J.last < S.InfJumpCd then return end
		if S.InfJumpMode == 2 and J.n >= S.InfJumpCount then return end
		doJump(hum, root, now)
	end

	UserInputService.JumpRequest:Connect(request)

	N.jumpUpdate = function(char, root, hum, dt)
		local on = S.InfJump
		local ground = grounded(hum)
		if ground then
			J.n, J.airT, J.pend = 0, 0, nil
		else
			J.airT += dt
		end

		if on then
			local now = os.clock()
			local held = UserInputService:IsKeyDown(Enum.KeyCode.Space) or (isTouch and hum.Jump)
			if not held then J.armed = true end

			local p = J.pend
			if p then
				local v = root.AssemblyLinearVelocity
				if v.Y > 8 then
					root.AssemblyLinearVelocity = Vector3.new(v.X, v.Y * p.scale, v.Z)
					J.pend = nil
				else
					p.n -= 1
					if p.n <= 0 then J.pend = nil end
				end
			end

			if S.InfJumpMode == 3 and held and not ground and J.airT > 0.12 and not blocked(hum)
				and now - J.last >= S.InfJumpCd then
				doJump(hum, root, now)
			end
		end

		if on and S.InfJumpMode == 2 and S.InfJumpHud then
			local count = math.clamp(S.InfJumpCount, 1, 10)
			ensurePips(count)
			local left = math.max(count - J.n, 0)
			for i, d in dots do d.BackgroundTransparency = i <= left and 0 or 0.8 end
			pips.Visible = not ground
		elseif pips and pips.Visible then
			pips.Visible = false
		end
	end
end

N.cross = {
	spread = 0, kick = 0, clickT = -9, hitT = -9, hitKill = false, onEnemy = false, rayT = 0, hpT = 0,
	hp = setmetatable({}, { __mode = "k" }), built = false,
}

do
	local C = N.cross
	local root, bars, barStroke, hits = nil, {}, {}, {}
	local dot, dotStroke, ring, ringStroke, ringOut, ringOutStroke
	local crp = RaycastParams.new()
	crp.FilterType = Enum.RaycastFilterType.Exclude
	crp.RespectCanCollide = true
	local RED = Color3.fromRGB(255, 70, 70)
	local BLACK = Color3.new(0, 0, 0)

	local function piece(parent, round)
		local f = Instance.new("Frame")
		f.AnchorPoint = Vector2.new(0.5, 0.5)
		f.BorderSizePixel = 0
		f.Parent = parent
		if round then corner(f, 9999) end
		return f
	end

	local function build()
		C.built = true
		root = Instance.new("Frame")
		root.Name = "FunModeCross"
		root.AnchorPoint = Vector2.new(0.5, 0.5)
		root.Size = UDim2.fromOffset(0, 0)
		root.BackgroundTransparency = 1
		root.Visible = false
		root.Parent = UI.overlay
		for i = 1, 4 do
			bars[i] = piece(root)
			barStroke[i] = addStroke(bars[i], BLACK, 1, 0)
		end
		dot = piece(root, true)
		dotStroke = addStroke(dot, BLACK, 1, 0)
		ringOut = piece(root, true)
		ringOut.BackgroundTransparency = 1
		ringOutStroke = addStroke(ringOut, BLACK, 3, 0)
		ring = piece(root, true)
		ring.BackgroundTransparency = 1
		ringStroke = addStroke(ring, Color3.new(1, 1, 1), 2, 0)
		for i = 1, 4 do
			hits[i] = piece(root)
			hits[i].Visible = false
		end
		UserInputService.InputBegan:Connect(function(input)
			local t = input.UserInputType
			if t == Enum.UserInputType.MouseButton1 or t == Enum.UserInputType.Touch then
				C.clickT = os.clock()
				if S.CrossDynamic then C.kick = 6 end
			end
		end)
	end

	local function layout(gap, color)
		local style = S.CrossStyle
		local L = S.CrossSize
		local T = isTouch and math.max(S.CrossThick, 2) or S.CrossThick
		local a = S.CrossAlpha
		local outline = S.CrossOutline
		local cross = style == 1 or style == 2 or style == 5
		local off = gap + L / 2
		for i = 1, 4 do
			local b = bars[i]
			local vis = cross and not (style == 2 and i == 1)
			b.Visible = vis
			if vis then
				if i <= 2 then
					b.Size = UDim2.fromOffset(T, L)
					b.Position = UDim2.fromOffset(0, i == 1 and -off or off)
				else
					b.Size = UDim2.fromOffset(L, T)
					b.Position = UDim2.fromOffset(i == 3 and -off or off, 0)
				end
				b.BackgroundColor3 = color
				b.BackgroundTransparency = a
				barStroke[i].Enabled = outline
				barStroke[i].Transparency = a
			end
		end

		local dotOn = style == 3 or style == 5
		dot.Visible = dotOn
		if dotOn then
			local d = style == 3 and (T * 2 + 2) or (T + 1)
			dot.Size = UDim2.fromOffset(d, d)
			dot.BackgroundColor3 = color
			dot.BackgroundTransparency = a
			dotStroke.Enabled = outline
			dotStroke.Transparency = a
		end

		local ringOn = style == 4
		ring.Visible = ringOn
		ringOut.Visible = ringOn and outline
		if ringOn then
			local d = math.max(L * 1.2 + gap * 2, 8)
			ring.Size = UDim2.fromOffset(d, d)
			ringOut.Size = UDim2.fromOffset(d, d)
			ringStroke.Color = color
			ringStroke.Thickness = T
			ringStroke.Transparency = a
			ringOutStroke.Thickness = T + 2
			ringOutStroke.Transparency = a
		end
	end

	local function hitMarker(now)
		local age = now - C.hitT
		if S.CrossHit and age < 0.25 then
			local k = age / 0.25
			local col = C.hitKill and RED or Color3.new(1, 1, 1)
			local r = (C.hitKill and 10 or 7) + k * 5
			local len = C.hitKill and 10 or 7
			for i = 1, 4 do
				local sx = (i == 1 or i == 4) and 1 or -1
				local sy = i <= 2 and -1 or 1
				local h = hits[i]
				h.Visible = true
				h.Size = UDim2.fromOffset(len, 2)
				h.Position = UDim2.fromOffset(sx * r, sy * r)
				h.Rotation = (sx * sy > 0) and 45 or -45
				h.BackgroundColor3 = col
				h.BackgroundTransparency = k * k
			end
		else
			for i = 1, 4 do hits[i].Visible = false end
		end
	end

	N.crossStep = function(dt, cam, ix, iy)
		if not S.Crosshair then
			if root and root.Visible then root.Visible = false end
			return
		end
		if not C.built then build() end
		local now = os.clock()
		dt = math.clamp(dt or 1 / 60, 0.001, 0.1)
		local char = player.Character
		local vps = cam.ViewportSize

		local target = 0
		if S.CrossDynamic then
			local r = getRoot(char)
			local hum = getHum(char)
			if r then
				local v = r.AssemblyLinearVelocity
				target = math.min(Vector3.new(v.X, 0, v.Z).Magnitude / 16 * 3, 10)
				if hum and hum.FloorMaterial == Enum.Material.Air then target += 5 end
			end
			target += C.kick
		end
		C.spread += (target - C.spread) * math.min(dt * 14, 1)
		C.kick = math.max(C.kick - dt * 30, 0)

		if S.CrossEnemy and now - C.rayT > 0.033 then
			C.rayT = now
			crp.FilterDescendantsInstances = char and { char } or {}
			local ray = cam:ViewportPointToRay(vps.X / 2, vps.Y / 2)
			local hit = workspace:Raycast(ray.Origin, ray.Direction * 1500, crp)
			local on = false
			if hit then
				local m = hit.Instance:FindFirstAncestorOfClass("Model")
				local h2 = m and getHum(m)
				if h2 and h2.Health > 0 then
					local plr = Players:GetPlayerFromCharacter(m)
					on = (plr ~= nil and plr ~= player and not isTeammate(plr)) or (plr == nil and S.IncludeNPCs)
				end
			end
			C.onEnemy = on
		elseif not S.CrossEnemy then
			C.onEnemy = false
		end

		if S.CrossHit and now - C.hpT > 0.1 then
			C.hpT = now
			for _, t in collect(false) do
				local h2, r2 = getHum(t.char), getRoot(t.char)
				if h2 and r2 and not isTeammate(t.plr) then
					local h = h2.Health
					local prev = C.hp[t.char]
					C.hp[t.char] = h
					if prev and h < prev - 0.4 and now - C.clickT < 0.5 then
						local sp, on = cam:WorldToViewportPoint(r2.Position)
						local near = on and sp.Z > 0 and (Vector2.new(sp.X, sp.Y) - vps / 2).Magnitude < 160
						if near or C.onEnemy then
							C.hitT, C.hitKill = now, h <= 0
						end
					end
				end
			end
		end

		root.Position = UDim2.fromOffset(vps.X / 2 + ix, vps.Y / 2 + iy)
		root.Visible = true
		local color = colorOf(S.CrossColor)
		if S.CrossEnemy and C.onEnemy then color = RED end
		layout(S.CrossGap + C.spread, color)
		hitMarker(now)
	end
end

N.fb = { saved = nil, acc = 0, post = setmetatable({}, { __mode = "k" }), atm = setmetatable({}, { __mode = "k" }) }

do
	local F = N.fb
	local GRAY = Color3.fromRGB(178, 178, 178)

	local function restorePost()
		for e, was in F.post do
			if e.Parent then e.Enabled = was end
			F.post[e] = nil
		end
	end

	local function restoreAtm()
		for a, v in F.atm do
			if a.Parent then
				a.Density = v[1]
				a.Haze = v[2]
			end
			F.atm[a] = nil
		end
	end

	local function scan(d)
		if S.FbNoPost then
			local bad = d:IsA("BlurEffect") or d:IsA("DepthOfFieldEffect")
				or (d:IsA("ColorCorrectionEffect") and (d.Brightness < -0.02 or d.Saturation < -0.3 or d.Contrast > 0.5))
			if bad and d.Name ~= N.BLUR_NAME and d.Enabled and F.post[d] == nil then
				F.post[d] = true
				d.Enabled = false
			end
		end
		if S.FbNoFog and d:IsA("Atmosphere") then
			if F.atm[d] == nil then F.atm[d] = { d.Density, d.Haze } end
			if d.Density ~= 0 then d.Density = 0 end
			if d.Haze ~= 0 then d.Haze = 0 end
		end
	end

	local function tick()
		if not S.FullBright then
			local sv = F.saved
			if sv then
				F.saved = nil
				for prop, val in sv do Lighting[prop] = val end
			end
			restorePost()
			restoreAtm()
			return
		end

		if not F.saved then
			F.saved = {
				Brightness = Lighting.Brightness, FogEnd = Lighting.FogEnd, Ambient = Lighting.Ambient,
				OutdoorAmbient = Lighting.OutdoorAmbient,
				GlobalShadows = N.fpsShadows ~= nil and N.fpsShadows or Lighting.GlobalShadows,
			}
			if S.FbDay then F.saved.ClockTime = Lighting.ClockTime end
		end
		local sv = F.saved
		if S.FbDay and sv.ClockTime == nil then sv.ClockTime = Lighting.ClockTime end

		if not S.SkyOn then
			local lvl = math.clamp(S.FbLevel / 100, 0, 1)
			Lighting.Brightness = sv.Brightness + (2 - sv.Brightness) * lvl
			Lighting.Ambient = sv.Ambient:Lerp(GRAY, lvl)
			Lighting.OutdoorAmbient = sv.OutdoorAmbient:Lerp(GRAY, lvl)
			if S.FbDay then Lighting.ClockTime = 14 end
			if S.FbNoFog then Lighting.FogEnd = 1e6 end
		end
		Lighting.GlobalShadows = false

		for _, d in Lighting:GetChildren() do scan(d) end
		local cam = workspace.CurrentCamera
		if cam then
			for _, d in cam:GetChildren() do scan(d) end
		end
		if not S.FbNoPost then restorePost() end
		if not S.FbNoFog then restoreAtm() end
	end

	N.fbApply = function()
		local ok, err = pcall(tick)
		if not ok and not N.fbErr then
			N.fbErr = true
			warn("[ZENITH] fullbright: " .. tostring(err))
		end
	end

	RunService.Heartbeat:Connect(function(dt)
		F.acc += dt
		if F.acc >= 0.25 then
			F.acc = 0
			if S.FullBright or F.saved then N.fbApply() end
		end
	end)
end

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

		do
			local okJ, errJ = pcall(N.jumpUpdate, char, root, hum, dt)
			if not okJ and not N.jumpErr then
				N.jumpErr = true
				warn("[ZENITH] jump: " .. tostring(errJ))
			end
		end

		do
			local okS, errS = pcall(N.spinUpdate, char, root, hum, dt)
			if not okS and not N.spinErr then
				N.spinErr = true
				warn("[ZENITH] spin: " .. tostring(errS))
			end
		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)

local ACTIONS = {
	KeyMenu = function() openMenu() end,
	KeyAim = function() setValue("Aim", not S.Aim) end,
	KeyTp = function() if not N.CUT["ТЕЛЕПОРТ ДО ЦІЛІ"] then teleportToTarget() end end,
	KeyTpv = function() setValue("Tpv", not S.Tpv) end,
	KeyPull = function() if pullToggle and not N.CUT["ЛОКАЛЬНИЙ ПРИТЯГ ВОРОГА (лише у вас)"] then pullToggle() end end,
	KeyFly = function() setValue("Fly", not S.Fly) end,
	KeySpin = function() setValue("Spin", not S.Spin) end,
	KeyOrbit = function() if orbitStart and not N.CUT["БЛІЦ (оберт навколо ворога)"] 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("gravity", function()
	local base, applied = nil, nil
	local jumpBase = setmetatable({}, { __mode = "k" })

	local function restoreJump()
		for hum, h in jumpBase do
			if hum.Parent then pcall(function() hum.JumpHeight = h end) end
			jumpBase[hum] = nil
		end
	end

	local function release()
		if base and applied and math.abs(workspace.Gravity - applied) < 0.05 then
			workspace.Gravity = base
		end
		base, applied = nil, nil
		restoreJump()
	end

	RunService.Heartbeat:Connect(function(dt)
		local on = S.GravityOn and gateOpen
		if not base then
			if not on then
				if next(jumpBase) then restoreJump() end
				return
			end
			local g = workspace.Gravity
			if not (g > 0) then return end
			base, applied = g, g
		end
		if not gateOpen then
			release()
			return
		end
		local cur = workspace.Gravity
		if math.abs(cur - applied) > 0.05 then
			if not on then
				base, applied = nil, nil
				restoreJump()
				return
			end
			base, applied = cur, cur
		end

		local goal = base
		if on then goal = base * math.clamp((tonumber(S.Gravity) or 100) / 100, 0.02, 10) end
		local nextG = applied + (goal - applied) * (1 - math.exp(-dt * 10))
		if math.abs(goal - nextG) < 0.05 then nextG = goal end
		if nextG ~= applied then
			workspace.Gravity = nextG
			applied = nextG
		end

		if on and S.GravJump then
			local hum = getHum(player.Character)
			if hum and hum.UseJumpPower == false and not S.JumpOn then
				local h0 = jumpBase[hum]
				if not h0 then
					h0 = hum.JumpHeight
					jumpBase[hum] = h0
				end
				local want = h0 * math.clamp(base / math.max(applied or 1, 1), 0.5, 12)
				if math.abs(hum.JumpHeight - want) > 0.01 then hum.JumpHeight = want end
			end
		elseif next(jumpBase) then
			restoreJump()
		end

		if not on and applied == base then
			base, applied = nil, nil
		end
	end)

	pcall(function()
		script.Destroying:Connect(release)
	end)
end)

safeRun("anti-fling", function()
	local afSaved = setmetatable({}, { __mode = "k" })
	local tracked = {}
	local flagged = {}
	local hist, histT = {}, 0
	local softT, spawnUntil = 0, 0
	local frozenRoot, freezeUntil = nil, 0
	local looseOff = {}
	local looseP, looseT = setmetatable({}, { __mode = "k" }), setmetatable({}, { __mode = "k" })
	local seatCache = setmetatable({}, { __mode = "k" })
	local shieldN = 0
	local overlap = OverlapParams.new()
	overlap.FilterType = Enum.RaycastFilterType.Exclude
	local lastRoot = nil
	local lastGround = nil
	local airT = 0
	local lastHum, lastBlock = nil, nil
	local lastNC = nil
	local PARK_DIST, BIG = 100, 1e7
	local under = { ref = nil, t = 0, cf = nil, ok = 0, void = 0, vy = nil }
	local underRp = RaycastParams.new()
	underRp.FilterType = Enum.RaycastFilterType.Exclude
	underRp.RespectCanCollide = true

	local function finite(v)
		local m = v.Magnitude
		return m == m and m < BIG
	end

	local function resetUnder()
		under.ref, under.cf, under.ok, under.void, under.vy = nil, nil, 0, 0, nil
		airT = 0
	end

	local function untrack(char)
		local e = tracked[char]
		if not e then return end
		for _, c in e.conns do c:Disconnect() end
		tracked[char] = nil
	end

	local function track(plr, char)
		if plr == player or tracked[char] then return end
		local e = {
			plr = plr, parts = {}, conns = {}, on = false, slot = plr.UserId % 7,
			parkUntil = 0, parked = false, parkPos = nil, realCF = nil,
			hotSince = nil, hotLast = 0, hops = {}, hopPos = nil, hopT = 0,
		}
		tracked[char] = e
		local function add(d)
			if d:IsA("BasePart") then e.parts[d] = true end
		end
		for _, d in char:GetDescendants() do add(d) end
		e.conns[1] = char.DescendantAdded:Connect(add)
		e.conns[2] = char.DescendantRemoving:Connect(function(d) e.parts[d] = nil end)
		e.conns[3] = char.AncestryChanged:Connect(function(_, parent)
			if not parent then untrack(char) end
		end)
	end

	local function watch(plr)
		if plr == player then return end
		plr.CharacterAdded:Connect(function(char) track(plr, char) end)
		if plr.Character then track(plr, plr.Character) end
	end

	for _, plr in Players:GetPlayers() do watch(plr) end
	Players.PlayerAdded:Connect(watch)
	Players.PlayerRemoving:Connect(function(plr)
		flagged[plr] = nil
		if plr.Character then untrack(plr.Character) end
	end)

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

	local function raise(e, secs, now)
		local plr = e.plr
		if (flagged[plr] or 0) < now and not S.AfPark then
			defNote("fl_" .. plr.UserId, S.AfNotify, "Підозра на fling: %s",
				Color3.fromRGB(255, 120, 80), 4, plr.DisplayName)
		end
		flagged[plr] = math.max(flagged[plr] or 0, now + secs)
		e.parkUntil = math.max(e.parkUntil, now + secs)
	end

	local function detect(e, root, now)
		local pos = root.Position
		local pp = e.parkPos
		if pp and (pos - pp).Magnitude < 0.05 then return end
		local lv, av = root.AssemblyLinearVelocity, root.AssemblyAngularVelocity
		local lm, am = lv.Magnitude, av.Magnitude
		if not (lm < BIG and am < BIG and pos.Magnitude < BIG) then
			e.hopPos = nil
			raise(e, 8, now)
			return
		end
		e.realCF = root.CFrame

		if am > S.AfAng * 1.5 or lm > S.AfSpeed * 2 then
			e.hotSince = e.hotSince or now
			e.hotLast = now
			if now - e.hotSince >= 0.25 then raise(e, 6, now) end
		elseif e.hotSince and now - e.hotLast > 0.2 then
			e.hotSince = nil
		end

		local prev = e.hopPos
		if prev then
			local d = (pos - prev).Magnitude
			if d >= 40 and d > lm * math.max(now - e.hopT, 0.016) * 1.6 + 12 then
				local list = e.hops
				list[#list + 1] = now
				while #list > 0 and now - list[1] > 1 do table.remove(list, 1) end
				if #list >= 6 then
					table.clear(list)
					raise(e, 8, now)
				end
			end
		end
		e.hopPos, e.hopT = pos, now
	end

	local function park(e, char, root, myRoot, now)
		local spot = myRoot.Position + Vector3.new(e.slot * 7 - 21, PARK_DIST, 0)
		if not e.parked then
			defNote("park_" .. e.plr.UserId, S.AfNotify, "Антифлінг: %s заморожено подалі",
				Color3.fromRGB(255, 120, 80), 6, e.plr.DisplayName)
		end
		e.parked, e.parkPos = true, spot
		pulledChars[char] = now + 0.6
		local ok = pcall(function() char:PivotTo(CFrame.new(spot)) end)
		local broken = not ok or not finite(root.Position)
		for part in e.parts do
			if part.Parent then
				if broken then part.CFrame = CFrame.new(spot) end
				part.AssemblyLinearVelocity = Vector3.zero
				part.AssemblyAngularVelocity = Vector3.zero
			end
		end
	end

	local function unpark(e, char, now)
		e.parked, e.parkPos, e.hopPos = false, nil, nil
		pulledChars[char] = now + 0.6
		local cf = e.realCF
		if cf and finite(cf.Position) then pcall(function() char:PivotTo(cf) end) 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 tracked do e.on = false end
		end
		if not on then
			local t = os.clock()
			for char, e in tracked do
				if e.parked then unpark(e, char, t) end
			end
			return
		end

		local now = os.clock()
		local myRoot = getRoot(player.Character)

		for char, e in tracked do
			local root = char.Parent and getRoot(char)
			local parkedNow = false
			if root then
				local userPull = isPulled(char) and not e.parked
				if not userPull then detect(e, root, now) end
				if S.AfPark and myRoot and not userPull and e.parkUntil > now then
					local hum = getHum(char)
					if hum and hum.SeatPart and finite(root.Position) then
						if e.parked then unpark(e, char, now) end
					else
						park(e, char, root, myRoot, now)
						parkedNow = true
					end
				elseif e.parked then
					unpark(e, char, now)
				end
			else
				e.hopPos = nil
			end

			if isPulled(char) and not parkedNow then continue end
			local apply = char.Parent ~= nil 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 topModel(part)
		local top = part
		while top.Parent and top.Parent ~= workspace do top = top.Parent end
		return top
	end

	local function hasSeat(model)
		local c = seatCache[model]
		if c == nil then
			c = false
			for _, d in model:GetDescendants() do
				if d:IsA("Seat") or d:IsA("VehicleSeat") then c = true break end
			end
			seatCache[model] = c
		end
		return c
	end

	local function shieldInfo(part)
		if N.CollectionService:HasTag(part, "ZG_Keep") then return false end
		local m = part:FindFirstAncestorOfClass("Model")
		if m and m:FindFirstChildOfClass("Humanoid") then return false end
		local top = topModel(part)
		return true, top:IsA("Model") and hasSeat(top)
	end

	local function fastPart(part, k)
		return not (part.AssemblyLinearVelocity.Magnitude <= S.AfSpeed * 0.4 * k)
			or not (part.AssemblyAngularVelocity.Magnitude <= S.AfAng * 2 * k)
	end

	local function hopped(part, now)
		local pos = part.Position
		local prev, pt = looseP[part], looseT[part]
		if not prev then
			looseP[part], looseT[part] = pos, now
			return false
		end
		local dt = now - pt
		if dt < 0.03 then return false end
		looseP[part], looseT[part] = pos, now
		if dt > 0.5 then return false end
		return not ((pos - prev).Magnitude / dt <= S.AfSpeed)
	end

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

	RunService.Stepped:Connect(function()
		local on = S.AntiFling and gateOpen and S.AfParts
		if not on then
			if next(looseOff) ~= nil then restoreLoose() end
			return
		end
		shieldN += 1
		if shieldN % 2 ~= 0 then return end
		local now = os.clock()
		for part, due in looseOff do
			if not part.Parent then
				looseOff[part] = nil
			elseif now >= due then
				part.CanCollide = true
				looseOff[part] = nil
			end
		end
		local myChar = player.Character
		local myRoot = getRoot(myChar)
		if not myRoot then return end
		overlap.FilterDescendantsInstances = { myChar }
		local myHum = getHum(myChar)
		local mySeat = myHum and myHum.SeatPart
		local myAssembly = mySeat and mySeat.AssemblyRootPart
		for _, p in workspace:GetPartBoundsInRadius(myRoot.Position, 90, overlap) do
			if looseOff[p] then
				if fastPart(p, 0.5) then looseOff[p] = now + 3 end
			elseif not p.Anchored and p.CanCollide and (fastPart(p, 1) or hopped(p, now)) then
				local ok, vehicle = shieldInfo(p)
				if ok and (not vehicle or fastPart(p, 2.7)) and not (myAssembly and p.AssemblyRootPart == myAssembly) then
					looseOff[p] = now + 3
					p.CanCollide = false
					defNote("loose", S.AfNotify, "Антифлінг: швидку деталь поруч прибрано з колізій", Color3.fromRGB(255, 160, 80), 4)
				end
			end
		end
	end)

	local function freezeRoot(root)
		if root.Anchored then return end
		root.Anchored = true
		frozenRoot = root
		freezeUntil = os.clock() + 0.35
	end

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

	local function jumpVel(hum)
		local v = hum.JumpPower
		if hum.UseJumpPower == false then
			v = math.sqrt(2 * workspace.Gravity * (hum.JumpHeight or 7.2))
		end
		return tonumber(v) or 50
	end

	local function underStep(char, root, hum, vel, now, dt)
		local pos = root.Position
		local vy = vel.Y
		local prevVy = under.vy
		under.vy = vy
		if hum.FloorMaterial ~= Enum.Material.Air then
			if vel.Magnitude < 450 and vy > -20 then
				if now > (N.homeHold or 0) then
					under.ref, under.t = pos, now
					under.ok += 1
					if under.ok >= 3 then under.cf = root.CFrame end
				end
			else
				under.ok = 0
			end
			under.void = 0
			return
		end
		under.ok = 0
		local ref = under.ref
		if not ref then return end
		local t = now - under.t
		local drop = ref.Y - pos.Y
		local g = workspace.Gravity
		local fast = drop > 0.5 * g * t * t + 14 + hum.HipHeight
		local falling = false
		if not fast and drop > 14 and vy <= -30 then
			local acc = prevVy and (vy - prevVy) / math.max(dt, 0.004) or 0
			falling = acc <= -0.5 * g or vy <= -150
		end
		if not (fast or falling) then
			under.void = 0
			return
		end
		under.void += dt
		if under.void < 0.12 then return end
		underRp.FilterDescendantsInstances = { char }
		if workspace:Raycast(pos, Vector3.new(0, -3000, 0), underRp) then
			under.ref, under.void = nil, 0
			return
		end
		if (not fast or workspace.StreamingEnabled) and not workspace:Raycast(pos, Vector3.new(0, 3000, 0), underRp) then
			return
		end
		local target = under.cf or lastGround
		if not target then return end
		under.ref, under.void = nil, 0
		markSelf(0.6)
		root.AssemblyLinearVelocity = Vector3.zero
		root.AssemblyAngularVelocity = Vector3.zero
		char:PivotTo(target + Vector3.new(0, 2, 0))
		hist = {}
		defNote("under", S.AfNotify, "Антифлінг: повернено з-під карти", Color3.fromRGB(255, 160, 80), 2)
	end

	RunService.Heartbeat:Connect(function(dt)
		local on = S.AntiFling and gateOpen
		local now = os.clock()
		if frozenRoot and (not on or now >= freezeUntil or not frozenRoot.Parent) then
			if frozenRoot.Parent then
				frozenRoot.AssemblyLinearVelocity = Vector3.zero
				frozenRoot.AssemblyAngularVelocity = Vector3.zero
				frozenRoot.Anchored = false
			end
			frozenRoot = nil
		end

		if not on then
			if lastHum and lastBlock then applyStates(lastHum, false) end
			lastHum, lastBlock = nil, nil
			hist, lastGround, lastRoot = {}, nil, nil
			resetUnder()
			return
		end

		local char = player.Character
		local root, hum = getRoot(char), getHum(char)
		if not (root and hum and hum.Health > 0) then
			hist, lastGround, lastRoot = {}, nil, nil
			resetUnder()
			return
		end
		if frozenRoot then return end
		if lastRoot ~= root then
			lastRoot = root
			hist, softT = {}, 0
			spawnUntil = now + 0.35
			resetUnder()
		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 angV = root.AssemblyAngularVelocity
		local broken = not (finite(vel) and finite(angV) and finite(root.Position))
		local horiz = Vector3.new(vel.X, 0, vel.Z).Magnitude
		local up = math.max(vel.Y, 0)
		local down = math.max(-vel.Y, 0)
		local jv = jumpVel(hum)

		local limit = math.max(S.AfSpeed, jv * 3)
		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 soft = math.max(limit * 0.45, hum.WalkSpeed * 3.5, jv * 2)
		if S.Fly or S.Bhop or S.SpeedOn then soft = limit end
		if horiz > soft and not seated and now > selfMoveUntil then
			softT += dt
		else
			softT = 0
		end

		local fallLimit = math.max(limit, S.FallSpeed * 1.8) * math.max(1, math.sqrt(workspace.Gravity / 196.2))
		local angBad = angV.Magnitude > S.AfAng and not S.Spin and not N.spin.on
		local hard = math.max(horiz, up) > limit or down > fallLimit
		local bad = S.AfClamp and not seated and (broken or (now > spawnUntil and (hard or angBad or softT > 0.3)))

		if bad then
			local target
			for i = #hist, 1, -1 do
				if hist[i].t <= now - 0.25 then target = hist[i].cf break end
			end
			target = target or (hist[1] and hist[1].cf) or lastGround or under.cf
			root.AssemblyLinearVelocity = Vector3.zero
			root.AssemblyAngularVelocity = Vector3.zero
			if target then
				markSelf(0.4)
				root.CFrame = target
			end
			hist, softT = {}, 0
			freezeRoot(root)
			defNote("fling", S.AfNotify, "Антифлінг: удар погашено", Color3.fromRGB(255, 160, 80), 2)
		elseif not seated then
			histT += dt
			local calm = horiz < soft and up < soft and down < limit * 0.5 and angV.Magnitude < S.AfAng * 0.5
			if histT >= 0.08 then
				histT = 0
				if calm then
					hist[#hist + 1] = { t = now, cf = root.CFrame }
					while #hist > 0 and now - hist[1].t > 3 do table.remove(hist, 1) end
				end
			end
			if calm and hum.FloorMaterial ~= Enum.Material.Air and now > (N.homeHold or 0) then
				lastGround = root.CFrame + Vector3.new(0, 2, 0)
			end
		else
			hist = {}
		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

		if hum.FloorMaterial == Enum.Material.Air and not seated and not S.Fly and not S.Noclip then
			airT += dt
		else
			airT = 0
		end
		if S.AfVoid and airT > 1.6 and vel.Y < -70 and not broken and now > selfMoveUntil and now > spawnUntil then
			local home = under.cf or lastGround
			if home and home.Position.Y - root.Position.Y > 80 then
				underRp.FilterDescendantsInstances = { char }
				if not workspace:Raycast(root.Position, Vector3.new(0, -4000, 0), underRp) then
					airT = 0
					markSelf(0.6)
					root.AssemblyLinearVelocity = Vector3.zero
					root.AssemblyAngularVelocity = Vector3.zero
					char:PivotTo(home + Vector3.new(0, 2, 0))
					hist = {}
					defNote("void", S.AfNotify, "Антифлінг: повернено з прірви", Color3.fromRGB(255, 160, 80), 2)
				end
			end
		end

		local underOk = S.AfUnder and not seated and not S.Fly and not S.Noclip and now > spawnUntil and not broken
		if underOk and now > selfMoveUntil then
			underStep(char, root, hum, vel, now, dt)
		elseif underOk then
			under.ok, under.void, under.vy = 0, 0, nil
		else
			under.ref, under.ok, under.void, under.vy = nil, 0, 0, nil
		end
	end)
end)

N.fall = { snaps = {}, snapT = 0, air = nil, soft = false, softAt = 0, hold = nil, retry = 0 }

do
	local F = N.fall
	local HST = Enum.HumanoidStateType
	local ORANGE = Color3.fromRGB(255, 160, 80)
	local rp = RaycastParams.new()
	rp.FilterType = Enum.RaycastFilterType.Exclude
	rp.RespectCanCollide = true
	local rpFor = nil
	local pad, hud = nil, nil

	local function hideMark()
		local r = pad
		pad = nil
		if r then
			TweenService:Create(r, TweenInfo.new(0.25), { Transparency = 1 }):Play()
			task.delay(0.3, function() r:Destroy() end)
		end
		if hud then hud.Visible = false end
	end

	local function showMark(hit, d, now)
		local cam = workspace.CurrentCamera
		if cam then
			if not (pad and pad.Parent) then
				pad = Instance.new("Part")
				pad.Name = "FunModeFallMark"
				pad.Shape = Enum.PartType.Cylinder
				pad.Anchored = true
				pad.CanCollide = false
				pad.CanQuery = false
				pad.CanTouch = false
				pad.Massless = true
				pad.CastShadow = false
				pad.Material = Enum.Material.Neon
				pad.Size = Vector3.new(0.1, 7, 7)
				pad.Parent = cam
			end
			pad.Color = ACCENT
			pad.Transparency = 0.5 + 0.12 * math.sin(now * 7)
			pad.CFrame = CFrame.new(hit.Position + Vector3.new(0, 0.06, 0)) * CFrame.Angles(0, 0, math.pi / 2)
		end
		if not hud then
			hud = Instance.new("TextLabel")
			hud.Name = "FallHud"
			hud.AnchorPoint = Vector2.new(0.5, 0.5)
			hud.Position = UDim2.new(0.5, 0, 0.68, 0)
			hud.Size = UDim2.fromOffset(0, 28)
			hud.AutomaticSize = Enum.AutomaticSize.X
			hud.BackgroundColor3 = N.C_BG
			hud.BackgroundTransparency = 0.08
			hud.BorderSizePixel = 0
			hud.TextColor3 = N.C_TEXT
			hud.Font = FONT_B
			hud.TextSize = 12
			hud.Parent = UI.overlay
			corner(hud, 9)
			local hp = Instance.new("UIPadding")
			hp.PaddingLeft, hp.PaddingRight = UDim.new(0, 14), UDim.new(0, 14)
			hp.Parent = hud
			acc(addStroke(hud, N.C_LINE, 1, 0), "Color")
		end
		hud.Visible = true
		hud.Text = string.format(tr("ПОСАДКА  %d ст"), math.floor(d))
	end

	local function record(root, hum, now, vel, pos)
		if now - F.snapT < 0.35 then return end
		local hv = math.sqrt(vel.X * vel.X + vel.Z * vel.Z)
		local ws2 = hum.WalkSpeed * 2
		if hv > (ws2 > 40 and ws2 or 40) or vel.Y > 30 or vel.Y < -30 then return end
		F.snapT = now
		local hit = workspace:Raycast(pos, Vector3.new(0, -8, 0), rp)
		if not hit then return end
		local s = { cf = root.CFrame, hh = pos.Y - hit.Position.Y }
		if not (s.hh >= 1 and s.hh <= 8) then s.hh = 3 end
		local part = hit.Instance
		if part and part.AssemblyLinearVelocity.Magnitude > 2 then
			s.part, s.rel = part, part.CFrame:ToObjectSpace(root.CFrame)
		end
		local list = F.snaps
		list[#list + 1] = s
		if #list > 6 then table.remove(list, 1) end
	end

	local function returnPoint()
		local list = F.snaps
		for i = #list, 1, -1 do
			local s = list[i]
			local cf = s.cf
			if s.part and s.part.Parent then cf = s.part.CFrame * s.rel end
			local p = cf.Position
			local hit = workspace:Raycast(p + Vector3.new(0, 5, 0), Vector3.new(0, -14, 0), rp)
			if hit then
				return CFrame.new(p.X, hit.Position.Y + s.hh + 0.5, p.Z) * cf.Rotation
			end
		end
		return nil
	end

	local function doReturn(char, root, now)
		if now < F.retry then return false end
		local dest = returnPoint()
		if not dest then
			F.retry = now + 0.5
			return false
		end
		markSelf(0.5)
		root.AssemblyLinearVelocity = Vector3.zero
		root.AssemblyAngularVelocity = Vector3.zero
		char:PivotTo(dest)
		F.air, F.hold = nil, nil
		defNote("fall", S.FallNotify, "Анти-падіння: повернуто на землю", ORANGE, 2)
		return true
	end

	N.fallReset = function()
		F.snaps, F.snapT, F.air, F.hold, F.retry = {}, 0, nil, nil, 0
		F.soft = false
		hideMark()
	end

	N.fallUpdate = function(char, root, hum, now, seat)
		if not S.AntiFall then
			if F.soft or pad or (hud and hud.Visible) then
				F.soft, F.hold = false, nil
				hideMark()
			end
			F.air = nil
			return false
		end
		if rpFor ~= char then
			rpFor = char
			rp.FilterDescendantsInstances = { char }
		end
		local pos, vel = root.Position, root.AssemblyLinearVelocity
		local st = hum:GetState()
		local grounded = hum.FloorMaterial ~= Enum.Material.Air
		local free = seat == nil and st ~= HST.Climbing and st ~= HST.Swimming
		if grounded or not free then
			F.air = nil
		elseif not F.air then
			F.air = now
		end
		if grounded and seat == nil and now > (N.homeHold or 0) then record(root, hum, now, vel, pos) end
		if grounded or not free or S.Fly or S.Noclip or now <= selfMoveUntil then
			if F.soft or F.hold then
				F.soft, F.hold = false, nil
				hideMark()
			end
			return false
		end

		local g = workspace.Gravity
		local limitV = S.FallSpeed * (g > 196.2 and math.sqrt(g / 196.2) or 1)
		local mode = S.FallMode
		if mode ~= 2 and mode ~= 3 then mode = 1 end
		local snap = F.snaps[#F.snaps]
		local h = snap and pos.Y - snap.cf.Position.Y or 0
		local airT = F.air and now - F.air or 0
		local jv = hum.UseJumpPower == false and math.sqrt(2 * g * (hum.JumpHeight or 7.2)) or hum.JumpPower
		local lim = (tonumber(jv) or 50) ^ 2 / (2 * g) * 2.5 + 20
		if S.FallHeight > lim then lim = S.FallHeight end
		local high = snap ~= nil and not (S.JumpOn or S.InfJump) and airT > 0.8 and h > lim
		local fast = vel.Y < -limitV

		local hit = nil
		if F.soft or fast or high then
			hit = workspace:Raycast(pos, Vector3.new(0, -3000, 0), rp)
		end

		local act = nil
		if F.soft then
			act = hit and "soft" or "drop"
		elseif fast then
			act = (mode ~= 2 and hit) and "soft" or ((mode ~= 3 and snap and h > 60) and "back" or nil)
		elseif high then
			if mode == 2 then
				act = "back"
			elseif hit and vel.Y < -8 then
				act = "soft"
			elseif mode == 1 then
				F.hold = F.hold or now
				if now - F.hold > 1 then act = "back" end
			end
		end
		if not high then F.hold = nil end

		if act == "soft" then
			if not F.soft then
				F.soft, F.softAt, F.hold = true, now, nil
				defNote("fall", S.FallNotify, "Анти-падіння: м'яка посадка", ORANGE, 2)
			elseif now - F.softAt > 25 then
				F.soft = false
				hideMark()
				return false
			end
			local d = pos.Y - hit.Position.Y
			local cap = limitV > S.FallSoft and limitV or S.FallSoft
			local vmax = S.FallSoft + d * 1.2
			if vmax > cap then vmax = cap end
			if vel.Y < -vmax then
				root.AssemblyLinearVelocity = Vector3.new(vel.X, -vmax, vel.Z)
			end
			if S.FallMark then showMark(hit, d, now) else hideMark() end
			return false
		end

		if F.soft then
			F.soft = false
			hideMark()
		end
		if (act == "back" or (act == "drop" and mode == 1 and snap and h > 60)) and doReturn(char, root, now) then
			return true
		end
		return false
	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 ctBan, leashId = {}, 0
	local leashRp = RaycastParams.new()
	leashRp.FilterType = Enum.RaycastFilterType.Exclude
	leashRp.RespectCanCollide = true

	local function startLeash(origin, plr)
		leashId += 1
		local id = leashId
		local t0 = os.clock()
		N.homeHold = t0 + 3.2
		task.spawn(function()
			local airBad, last = 0, t0
			while id == leashId and gateOpen do
				task.wait()
				local now = os.clock()
				local dt = now - last
				last = now
				local char = player.Character
				local root, hum = getRoot(char), getHum(char)
				if now - t0 > 3 or not (root and hum and hum.Health > 0) then break end
				if now - t0 < 0.1 then continue end
				local pos, vel = root.Position, root.AssemblyLinearVelocity
				local bad = false
				if not (pos.Magnitude < 1e6 and vel.Magnitude < 250) then
					bad = true
				elseif hum.FloorMaterial == Enum.Material.Air and not hum.SeatPart then
					leashRp.FilterDescendantsInstances = { char }
					if workspace:Raycast(pos, Vector3.new(0, -600, 0), leashRp) then
						airBad = 0
					else
						airBad += dt
						bad = airBad >= 0.25
					end
				else
					airBad = 0
				end
				if not bad and pos.Y < origin.Position.Y - 160 then bad = true end
				if bad then
					markSelf(0.8)
					root.AssemblyLinearVelocity = Vector3.zero
					root.AssemblyAngularVelocity = Vector3.zero
					char:PivotTo(origin + Vector3.new(0, 2, 0))
					N.homeHold = os.clock() + 0.8
					ctBan[plr] = os.clock() + 10
					toast(tr("Контр-ТП: повернуто назад"), Color3.fromRGB(255, 160, 80), true)
					break
				end
			end
		end)
	end

	local function trigger(plr, char, seen)
		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
				local myRoot = getRoot(player.Character)
				local origin = myRoot and myRoot.CFrame
				local ok, why
				if S.CtSafe then
					ok, why = teleportNear(char, 1, { seen = seen, range = S.CtRadius + 45 })
				else
					ok = teleportNear(char, 1)
				end
				if ok then
					toast(string.format(tr("Контр-ТП: %s"), name), ACCENT, true)
					if S.CtSafe and origin then startLeash(origin, plr) end
				elseif why then
					toast(string.format(tr("Контр-ТП скасовано: %s поза безпечною зоною"), name), Color3.fromRGB(255, 160, 80), true)
					return
				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
		if (ctBan[plr] or 0) > os.clock() 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, pos)
	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
	awParams.RespectCanCollide = true
	awParams.IgnoreWater = true
	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
				awRec[plr] = nil
				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
			else
				awRec[plr] = nil
			end
		end
		return best
	end

	local function updateAimWarn()
		local on = S.AimWarn and gateOpen
		local best = on and scanAim() or nil
		if not on then table.clear(awRec) end
		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 flickPrev, flickRoot = nil, nil
	local lastUnsit = 0
	local fallUpdate: any, fallReset: any = N.fallUpdate, N.fallReset
	local fallWarned = false

	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
			flickPrev, flickRoot = nil, nil
			fallReset()
			return
		end
		if flickRoot ~= root then
			flickRoot, flickPrev = root, nil
			fallReset()
		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 okF, moved = pcall(fallUpdate, char, root, hum, now, seat)
		if not okF then
			if not fallWarned then
				fallWarned = true
				warn("[ZENITH] anti-fall: " .. tostring(moved))
			end
		elseif moved then
			flickPrev = nil
			return
		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
				if inst.Name ~= N.BLUR_NAME then changed = clampProp(inst, "Size", S.AbBlur, true) or changed end
			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("guard", function()
	local FORCE = {
		AlignPosition = true, AlignOrientation = true, LinearVelocity = true, VectorForce = true,
		AngularVelocity = true, Torque = true, BallSocketConstraint = true, RopeConstraint = true,
		SpringConstraint = true, RodConstraint = true, HingeConstraint = true, RocketPropulsion = false,
	}
	local SINGLE = { LinearVelocity = true, VectorForce = true, AngularVelocity = true, Torque = true }
	local JOINT = { Weld = true, WeldConstraint = true, Motor6D = true, ManualWeld = true, Snap = true }

	local function ownerOf(inst)
		local m = inst
		while m and m ~= workspace do
			if m:IsA("Model") then
				local plr = Players:GetPlayerFromCharacter(m)
				if plr then return plr end
			end
			m = m.Parent
		end
		return nil
	end

	local function isMine(p, myChar)
		return p ~= nil and myChar ~= nil and p:IsDescendantOf(myChar)
	end
	local function isForeign(p)
		if not p then return false end
		local o = ownerOf(p)
		return o ~= nil and o ~= player
	end

	local function linkBad(d, myChar)
		local cn = d.ClassName
		if FORCE[cn] then
			local a0, a1 = d.Attachment0, d.Attachment1
			local p0 = a0 and a0.Parent
			local p1 = a1 and a1.Parent
			if SINGLE[cn] then
				local o = ownerOf(d)
				return isMine(p0, myChar) and o ~= nil and o ~= player
			end
			return (isMine(p0, myChar) and isForeign(p1)) or (isMine(p1, myChar) and isForeign(p0))
		elseif JOINT[cn] then
			local p0, p1 = d.Part0, d.Part1
			return (isMine(p0, myChar) and isForeign(p1)) or (isMine(p1, myChar) and isForeign(p0))
		end
		return false
	end

	local function sweep(model, myChar)
		local n = 0
		for _, d in model:GetDescendants() do
			local cn = d.ClassName
			if (FORCE[cn] or JOINT[cn]) and linkBad(d, myChar) then
				pcall(function() d:Destroy() end)
				n += 1
			end
		end
		return n
	end

	local saved = {}
	local function release(part, secs)
		if not part.Parent then return end
		if part.CanCollide then
			part.CanCollide = false
			saved[part] = os.clock() + secs
		end
	end
	local function restoreDue(force)
		local now = os.clock()
		for part, due in saved do
			if force or now >= due or not part.Parent then
				if part.Parent then part.CanCollide = true end
				saved[part] = nil
			end
		end
	end

	local fresh = {}
	local bootAt = os.clock()
	workspace.DescendantAdded:Connect(function(d)
		if not S.GdCage or workspace.StreamingEnabled then return end
		if os.clock() - bootAt < 25 then return end
		if d:IsA("BasePart") and d.CanCollide and d.ClassName ~= "Terrain" then
			fresh[#fresh + 1] = { p = d, t = os.clock() }
			if #fresh > 300 then table.remove(fresh, 1) end
		end
	end)

	local rideT = {}
	local posHist = {}
	local acc1, acc2, acc3, acc4 = 0, 0, 0, 0
	local sounded = setmetatable({}, { __mode = "k" })

	RunService.Heartbeat:Connect(function(dt)
		if not gateOpen then return end
		local myChar = player.Character
		local myRoot = getRoot(myChar)
		if not (myRoot and isAlive(myChar)) then
			if next(saved) ~= nil then restoreDue(true) end
			return
		end
		local now = os.clock()
		restoreDue(false)

		acc1 += dt
		if acc1 >= 0.5 then
			acc1 = 0
			if S.GdLinks then
				local n = sweep(myChar, myChar)
				for _, plr in Players:GetPlayers() do
					local char = plr ~= player and plr.Character
					local r = char and getRoot(char)
					if r and (r.Position - myRoot.Position).Magnitude < 70 then
						n += sweep(char, myChar)
					end
				end
				if n > 0 then
					defNote("GdLinks", true, "Відчеплено чужі зв'язки з вашим персонажем", Color3.fromRGB(255, 190, 90), 4)
				end
			end

			if S.GdCage and not workspace.StreamingEnabled and #fresh > 0 then
				table.insert(posHist, { t = now, p = myRoot.Position })
				while #posHist > 0 and now - posHist[1].t > 1.6 do table.remove(posHist, 1) end
				local still = true
				for _, h in posHist do
					if (h.p - myRoot.Position).Magnitude > 3 then still = false end
				end
				local near = {}
				for i = #fresh, 1, -1 do
					local f = fresh[i]
					if not f.p.Parent or now - f.t > 4 then
						table.remove(fresh, i)
					elseif ownerOf(f.p) == nil and f.p.Anchored ~= nil then
						local pos = f.p.Position
						if (pos - myRoot.Position).Magnitude < 14 and pos.Y > myRoot.Position.Y - 1.5 then
							near[#near + 1] = f.p
						end
					end
				end
				if still and #posHist >= 3 and #near >= 4 then
					for _, p in near do release(p, 12) end
					defNote("GdCage", true, "Клітку навколо вас зроблено прохідною", Color3.fromRGB(255, 190, 90), 6)
				end
			end
		end

		acc2 += dt
		if acc2 >= 0.25 then
			local step = acc2
			acc2 = 0
			if S.GdRide then
				local seen = {}
				for _, plr in Players:GetPlayers() do
					if plr ~= player then
						local r = getRoot(plr.Character)
						if r then
							local d = r.Position - myRoot.Position
							local flat = Vector3.new(d.X, 0, d.Z).Magnitude
							if flat < 3.6 and d.Y > 1.2 and d.Y < 7 then
								seen[plr] = true
								rideT[plr] = (rideT[plr] or 0) + step
								if rideT[plr] > 1.4 then
									for _, part in plr.Character:GetDescendants() do
										if part:IsA("BasePart") then release(part, 3) end
									end
									defNote("GdRide", true, "Гравець на вас не штовхатиме", Color3.fromRGB(255, 190, 90), 6)
								end
							end
						end
					end
				end
				for plr in rideT do
					if not seen[plr] then rideT[plr] = nil end
				end
			end
		end

		acc4 += dt
		if acc4 >= 2 then
			acc4 = 0
			if S.GdPlrCol then
				for _, plr in Players:GetPlayers() do
					local char = plr ~= player and plr.Character
					if char then
						for _, d in char:GetDescendants() do
							if d:IsA("BasePart") and d.CanCollide then d.CanCollide = false end
						end
					end
				end
			end
		end

		acc3 += dt
		if acc3 >= 1.5 then
			acc3 = 0
			if S.GdSound then
				for _, plr in Players:GetPlayers() do
					local char = plr ~= player and plr.Character
					if char then
						for _, d in char:GetDescendants() do
							if d:IsA("Sound") and d.Playing and (d.Volume > 4 or d.PlaybackLoudness > 500) then
								d.Volume = math.min(d.Volume, 0.5)
								if not sounded[d] then
									sounded[d] = true
									defNote("GdSound", true, "Приглушено гучний звук від гравця", Color3.fromRGB(255, 190, 90), 8)
								end
							end
						end
					end
				end
			end
		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 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

	local function espStep()
		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 asz = overlay.AbsoluteSize
		if asz.X < 50 or asz.Y < 50 then asz = vp end
		local sx, sy = 1, 1
		local insX, insY = N.inset()
		local ox, oy = S.EspOffX + insX, S.EspOffY + insY
		local function W2V(pos)
			local v, on = cam:WorldToViewportPoint(pos)
			return Vector3.new(v.X * sx + ox, v.Y * sy + oy, v.Z), on
		end
		local center = asz / 2
		local myChar = player.Character
		rp.FilterDescendantsInstances = myChar and { myChar } or {}
		rp.RespectCanCollide = true
		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 nowT = os.clock()
						if nowT - (e.visT or 0) > 0.09 then
							e.visT = nowT
							local head = char:FindFirstChild("Head") or root
							local h = workspace:Raycast(camPos, head.Position - camPos, rp)
							local vis = h == nil or h.Instance:IsDescendantOf(char)
							if not vis and head ~= root then
								h = workspace:Raycast(camPos, root.Position - camPos, rp)
								vis = h == nil or h.Instance:IsDescendantOf(char)
							end
							e.vis = vis
							N.espVis[char] = vis
						end
						color3 = e.vis and Color3.fromRGB(60, 255, 90) or Color3.fromRGB(255, 60, 60)
					elseif S.EspTeamColor and plr and plr.Team then
						color3 = plr.TeamColor.Color
					elseif S.EspHealthColor then
						color3 = Color3.fromRGB(255, 60, 60):Lerp(Color3.fromRGB(60, 255, 90), math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1))
					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 = W2V(topPos)
					local bsp, bOn = W2V(botPos)
					local rootSp, rootOn = W2V(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 = math.max(S.EspBoxThick, isTouch and 2 or 1)
						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 - (isTouch and 9 or 6), minY)
							e.barBg.Size = UDim2.fromOffset(isTouch and 5 or 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(asz.X / 2, asz.Y)
						elseif S.EspTracerFrom == 2 then from = center
						else
							local ap = getAimPoint()
							from = Vector2.new(ap.X + ox, ap.Y + oy)
						end
						local to = Vector2.new((minX + maxX) / 2, maxY)
						local diff = to - from
						e.tracer.Visible = true
						e.tracer.Size = UDim2.fromOffset(diff.Magnitude, isTouch and 2 or 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 = W2V(headPart.Position)
						if hon and hsp.Z > 0 then
							local r = math.clamp(300 / math.max(hsp.Z, 1), isTouch and 4 or 3, isTouch and 12 or 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

	local espWarned = false
	RunService:BindToRenderStep("FunModeVisuals", Enum.RenderPriority.Last.Value, function()
		local okE, errE = pcall(espStep)
		if not okE and not espWarned then
			espWarned = true
			warn("[ZENITH] esp: " .. tostring(errE))
		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: any = {}
	local rp = RaycastParams.new()
	rp.FilterType = Enum.RaycastFilterType.Exclude

	local function newRec(): any
		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: any, rec: any, flag: string, now: number)
		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: any, flag: string): any
		return (rec.fc[flag] or 0) >= S.DtThreshold and S[FLAG_KEY[flag]]
	end

	local ghostRoot = Instance.new("Folder")
	ghostRoot.Name = "FunModeGhost"
	ghostRoot.Parent = workspace

	local GHOST_BODY = "|Head|Torso|Left Arm|Right Arm|Left Leg|Right Leg|UpperTorso|LowerTorso|LeftUpperArm|LeftLowerArm|LeftHand|RightUpperArm|RightLowerArm|RightHand|LeftUpperLeg|LeftLowerLeg|LeftFoot|RightUpperLeg|RightLowerLeg|RightFoot|"
	local GHOST_KEEP = "|SpecialMesh|BlockMesh|CylinderMesh|FileMesh|Decal|Texture|SurfaceAppearance|"

	local function ghostSources(char: any): any
		local body, direct, acc = {}, {}, {}
		for _, c in char:GetChildren() do
			if c:IsA("BasePart") then
				if c.Name ~= "HumanoidRootPart" and #direct < 40 then
					direct[#direct + 1] = c
					if string.find(GHOST_BODY, "|" .. c.Name .. "|", 1, true) then body[#body + 1] = c end
				end
			elseif c:IsA("Accessory") then
				for _, h in c:GetChildren() do
					if h:IsA("BasePart") and #acc < 16 then acc[#acc + 1] = h end
				end
			end
		end
		local list = #body > 0 and body or direct
		for _, h in acc do list[#list + 1] = h end
		return list
	end

	local function killGhost(rec: any)
		local g = rec.ghost
		rec.ghost = nil
		if g then g.model:Destroy() end
	end

	local function buildGhost(rec: any, char: any, srcs: any)
		local model = Instance.new("Model")
		model.Name = "ZenithGhost"
		local linked = {}
		for _, src in srcs do
			local okC, dst: any = pcall(src.Clone, src)
			if okC and dst then
				for _, ch in dst:GetChildren() do
					if not string.find(GHOST_KEEP, "|" .. ch.ClassName .. "|", 1, true) then
						ch:Destroy()
					elseif ch:IsA("Decal") then
						ch.Transparency = 0
					end
				end
			else
				dst = Instance.new("Part")
				dst.Size = src.Size
				dst.Color = src.Color
				dst.Material = src.Material
			end
			dst.Transparency = 0
			dst.Anchored = true
			dst.CanCollide = false
			dst.CanQuery = false
			dst.CanTouch = false
			dst.CastShadow = false
			dst.CFrame = src.CFrame
			dst.Parent = model
			linked[#linked + 1] = { src, dst }
		end
		local hl = Instance.new("Highlight")
		hl.Adornee = model
		hl.FillColor = RED
		hl.FillTransparency = 0.72
		hl.OutlineColor = RED
		hl.OutlineTransparency = 0.15
		hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
		hl.Parent = model
		model.Parent = ghostRoot
		rec.ghost = { model = model, char = char, links = linked }
	end

	local function syncGhost(rec: any, char: any, want: any)
		if not want then
			if rec.ghost then killGhost(rec) end
			return
		end
		local srcs = ghostSources(char)
		local g = rec.ghost
		if g then
			local same = g.char == char and g.model.Parent ~= nil and #g.links == #srcs
			if same then
				for i, p in g.links do
					if p[1] ~= srcs[i] then
						same = false
						break
					end
				end
			end
			if same then return end
			killGhost(rec)
		end
		if #srcs > 0 then
			local n = 0
			for _, r in recs do
				if r.ghost then n += 1 end
			end
			if n < 8 then pcall(buildGhost, rec, char, srcs) end
		end
	end

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

	local function stateIs(hum: any, ...: any): boolean
		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)

	RunService:BindToRenderStep("FunModeGhost", Enum.RenderPriority.Camera.Value + 6, function()
		local on = S.DtReveal and gateOpen
		for _, rec in recs do
			local g = rec.ghost
			if g then
				if not on then
					killGhost(rec)
				elseif g.char.Parent then
					for _, p in g.links do
						local s = p[1]
						if s.Parent then p[2].CFrame = s.CFrame end
					end
				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, rec.invisSeen = 0, 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 airborne then rec.airUntil = now + 0.6 end

						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 and now > (rec.airUntil or 0) 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

							local flyCand = S.DtFly and not seated and airborne and dist > 0.02
								and not stateIs(hum, Enum.HumanoidStateType.Climbing, Enum.HumanoidStateType.Swimming,
									Enum.HumanoidStateType.Seated, Enum.HumanoidStateType.Ragdoll, Enum.HumanoidStateType.Dead,
									Enum.HumanoidStateType.Jumping)
							if flyCand then
								local y0, y1 = rec.flyY0 or pos.Y, rec.flyY1 or pos.Y
								y0, y1 = math.min(y0, pos.Y), math.max(y1, pos.Y)
								if y1 - y0 > 3 then
									rec.flyT = 0
									y0, y1 = pos.Y, pos.Y
								else
									rec.flyT += pdt
								end
								rec.flyY0, rec.flyY1 = y0, y1
								if rec.flyT >= S.DtFlyTime then
									rec.flyT, rec.flyY0, rec.flyY1 = 0, nil, nil
									hit(plr, rec, "fly", now)
								end
							else
								rec.flyT, rec.flyY0, rec.flyY1 = 0, nil, nil
							end

							if S.DtNoclip and dist > 0.8 and dist < 40 and not airborne and now > (rec.airUntil or 0) and math.abs(delta.Y) < 1.5 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
								rec.invisSeen = now
								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
								rec.invisSeen = 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

					local seen = char ~= nil and char.Parent ~= nil and now - (rec.invisSeen or 0) < 2.5
					syncGhost(rec, char, seen and S.DtReveal and gateOpen and flagged(rec, "invis"))
				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(tr("%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(myChar)
		if not (isAlive(myChar) and myRoot) then return end
		local t = getTarget(true)
		local tRoot = t and getRoot(t.char)
		if not tRoot then
			toast(tr("Бліц: немає цілі в колі FOV"), Color3.fromRGB(215, 80, 85), true)
			return
		end
		local rel = myRoot.Position - tRoot.Position
		if rel.Magnitude > S.OrbitMaxStart then
			toast(tr("Бліц: ціль занадто далеко"), Color3.fromRGB(215, 80, 85), true)
			return
		end
		local dir = S.OrbitDir == 2 and -1 or 1
		orb = { char = t.char, startCF = myRoot.CFrame, t0 = os.clock(), flip = os.clock(), dir = dir, angle = math.atan2(rel.Z, rel.X) }
		RunService:BindToRenderStep("ZenithOrbitCam", Enum.RenderPriority.Camera.Value + 2, function()
			if not orb or not S.OrbitFace then return end
			local cam = getCamera()
			local part = getAimPart(orb.char)
			if cam and part then
				cam.CFrame = CFrame.lookAt(cam.CFrame.Position, part.Position)
			end
		end)
		toast(tr("Бліц: обертання навколо цілі"), ACCENT, true)
	end

	RunService.Heartbeat:Connect(function(dt)
		local o = orb
		if not o then return end
		local myChar = player.Character
		local myRoot = getRoot(myChar)
		local tRoot = getRoot(o.char)
		local now = os.clock()
		if not (gateOpen and isAlive(myChar) and myRoot and o.char.Parent and isAlive(o.char) and tRoot)
			or now - o.t0 >= S.OrbitTime then
			finish()
			return
		end
		if S.OrbitDir == 3 and now - o.flip > 1 then
			o.flip = now
			o.dir = -o.dir
		end
		o.angle += o.dir * math.rad(S.OrbitSpeed) * dt
		local center = tRoot.Position
		local desired = center + Vector3.new(math.cos(o.angle), 0, math.sin(o.angle)) * S.OrbitRadius + Vector3.new(0, S.OrbitHeight, 0)
		rp.FilterDescendantsInstances = { myChar, o.char }
		local hit = workspace:Raycast(center, desired - center, rp)
		if hit then desired = hit.Position + hit.Normal * 1.5 end
		local look = Vector3.new(center.X, desired.Y, center.Z)
		local cf = (look - desired).Magnitude > 0.1 and CFrame.lookAt(desired, look) or CFrame.new(desired)
		markSelf(0.5)
		myChar:PivotTo(cf)
		myRoot.AssemblyLinearVelocity = Vector3.zero
	end)
end)

safeRun("fps", function()
	local saved = {}
	local removed = {}
	local work, wi = {}, 1
	local undo, ui = {}, 1
	local active, curKey = false, nil
	local gSaved = nil
	local lastKeep = 0

	local function ours(inst)
		local n = inst.Name
		return string.sub(n, 1, 7) == "FunMode" or string.sub(n, 1, 6) == "Zenith"
	end

	local function inCharacter(inst)
		local cur = inst.Parent
		while cur and cur ~= workspace do
			if cur:IsA("Model") and cur:FindFirstChildOfClass("Humanoid") then return true end
			cur = cur.Parent
		end
		return false
	end

	local function save(inst, props)
		local rec = saved[inst]
		if not rec then
			rec = {}
			saved[inst] = rec
		end
		for k, v in props do
			if rec[k] == nil then rec[k] = v end
		end
	end

	local function apply(inst)
		if not inst.Parent or ours(inst) then return end
		local lv = S.FpsLevel
		if inst:IsA("BasePart") then
			if S.FpsKeepChars and inCharacter(inst) then return end
			local props = { CastShadow = inst.CastShadow }
			if lv >= 2 then
				props.Material = inst.Material
				props.Reflectance = inst.Reflectance
			end
			local mesh = lv >= 3 and inst:IsA("MeshPart")
			if mesh then
				props.RenderFidelity = inst.RenderFidelity
				props.TextureID = inst.TextureID
			end
			save(inst, props)
			inst.CastShadow = false
			if lv >= 2 then
				inst.Material = Enum.Material.SmoothPlastic
				inst.Reflectance = 0
			end
			if mesh then
				pcall(function()
					inst.RenderFidelity = Enum.RenderFidelity.Performance
					inst.TextureID = ""
				end)
			end
		elseif inst:IsA("Decal") or inst:IsA("Texture") then
			if lv >= 2 and not (S.FpsKeepChars and inCharacter(inst)) then
				save(inst, { Transparency = inst.Transparency })
				inst.Transparency = 1
			end
		elseif inst:IsA("SurfaceAppearance") then
			if lv >= 3 and not (S.FpsKeepChars and inCharacter(inst)) then
				removed[#removed + 1] = { inst = inst, parent = inst.Parent }
				inst.Parent = nil
			end
		elseif inst:IsA("ParticleEmitter") or inst:IsA("Trail") or inst:IsA("Beam") or inst:IsA("Fire")
			or inst:IsA("Smoke") or inst:IsA("Sparkles") then
			save(inst, { Enabled = inst.Enabled })
			inst.Enabled = false
		elseif inst:IsA("PostEffect") and not inst:IsA("ColorCorrectionEffect") and inst.Name ~= N.BLUR_NAME then
			save(inst, { Enabled = inst.Enabled })
			inst.Enabled = false
		elseif inst:IsA("Atmosphere") and lv >= 3 then
			save(inst, { Density = inst.Density, Haze = inst.Haze, Glare = inst.Glare })
			inst.Density = 0
			inst.Haze = 0
			inst.Glare = 0
		end
	end

	local function applyGlobals()
		local lv = S.FpsLevel
		gSaved = {
			GlobalShadows = Lighting.GlobalShadows,
			EnvironmentDiffuseScale = Lighting.EnvironmentDiffuseScale,
			EnvironmentSpecularScale = Lighting.EnvironmentSpecularScale,
		}
		N.fpsShadows = gSaved.GlobalShadows
		Lighting.GlobalShadows = false
		if lv >= 2 then
			Lighting.EnvironmentDiffuseScale = 0
			Lighting.EnvironmentSpecularScale = 0
		end
		local terrain = workspace:FindFirstChildOfClass("Terrain")
		if terrain then
			gSaved.terrain = {}
			for _, prop in { "Decoration", "WaterWaveSize", "WaterWaveSpeed", "WaterReflectance" } do
				local ok, v = pcall(function() return terrain[prop] end)
				if ok then gSaved.terrain[prop] = v end
			end
			pcall(function()
				terrain.Decoration = false
				terrain.WaterWaveSize = 0
				terrain.WaterWaveSpeed = 0
				terrain.WaterReflectance = 0
			end)
			gSaved.terrainRef = terrain
		end
		if lv >= 3 then
			pcall(function()
				local r = settings().Rendering
				gSaved.quality = r.QualityLevel
				r.QualityLevel = Enum.QualityLevel.Level01
			end)
		end
	end

	local function restoreGlobals()
		local g = gSaved
		gSaved = nil
		N.fpsShadows = nil
		if not g then return end
		if S.FullBright then
			Lighting.GlobalShadows = false
		else
			Lighting.GlobalShadows = g.GlobalShadows
		end
		Lighting.EnvironmentDiffuseScale = g.EnvironmentDiffuseScale
		Lighting.EnvironmentSpecularScale = g.EnvironmentSpecularScale
		if g.terrainRef and g.terrain then
			for prop, v in g.terrain do pcall(function() g.terrainRef[prop] = v end) end
		end
		if g.quality then
			pcall(function() settings().Rendering.QualityLevel = g.quality end)
		end
	end

	local function startWork()
		active = true
		applyGlobals()
		work = workspace:GetDescendants()
		for _, d in Lighting:GetDescendants() do work[#work + 1] = d end
		local cam = workspace.CurrentCamera
		if cam then
			for _, d in cam:GetChildren() do work[#work + 1] = d end
		end
		wi = 1
	end

	local function startUndo()
		active = false
		restoreGlobals()
		undo, ui = {}, 1
		for inst, rec in saved do undo[#undo + 1] = { inst = inst, rec = rec } end
		saved = {}
		work, wi = {}, 1
		for _, r in removed do
			if r.inst and r.parent and r.parent.Parent then pcall(function() r.inst.Parent = r.parent end) end
		end
		removed = {}
	end

	workspace.DescendantAdded:Connect(function(inst)
		if active then work[#work + 1] = inst end
	end)

	RunService.Heartbeat:Connect(function()
		local want = gateOpen and S.FpsBoost
		local key = tostring(S.FpsLevel) .. (S.FpsKeepChars and "k" or "a")

		if active and (not want or key ~= curKey) then
			startUndo()
		end

		if ui <= #undo then
			local last = math.min(ui + 599, #undo)
			for i = ui, last do
				local u = undo[i]
				if u.inst.Parent then
					for prop, v in u.rec do pcall(function() u.inst[prop] = v end) end
				end
			end
			ui = last + 1
			if ui > #undo then undo = {} ui = 1 end
			return
		end

		if want and not active then
			curKey = key
			startWork()
			return
		end

		if active then
			local last = math.min(wi + 399, #work)
			for i = wi, last do
				local inst = work[i]
				if inst then pcall(apply, inst) end
				work[i] = false
			end
			wi = last + 1
			if wi > #work and #work > 0 then work, wi = {}, 1 end

			local now = os.clock()
			if now - lastKeep > 0.5 then
				lastKeep = now
				if Lighting.GlobalShadows then Lighting.GlobalShadows = false end
			end
		end
	end)
end)

safeRun("sky", function()
	local C = Color3.fromRGB

	local PRESETS = {
		{ clock = 14, amb = C(110, 120, 140), out = C(140, 150, 170), atm = C(150, 190, 255), dec = C(106, 130, 170), dens = 0.3, haze = 0.8, tint = C(255, 255, 255), sat = 0.1, fog = C(190, 210, 240), fe = 100000, bri = 2.2, stars = 0 },
		{ clock = 18.1, amb = C(110, 80, 70), out = C(160, 100, 80), atm = C(255, 170, 110), dec = C(190, 80, 40), dens = 0.4, haze = 1.6, tint = C(255, 215, 190), sat = 0.2, fog = C(255, 160, 100), fe = 50000, bri = 2, stars = 0 },
		{ clock = 0, amb = C(35, 40, 70), out = C(45, 55, 95), atm = C(25, 35, 70), dec = C(10, 15, 40), dens = 0.25, haze = 0.3, tint = C(190, 205, 255), sat = 0, fog = C(15, 20, 40), fe = 100000, bri = 1, stars = 3000 },
		{ clock = 0, amb = C(25, 25, 45), out = C(30, 30, 60), atm = C(0, 0, 0), dec = C(0, 0, 0), dens = 0, haze = 0, tint = C(215, 215, 255), sat = 0.15, fog = C(0, 0, 0), fe = 1000000, bri = 1, stars = 6000 },
		{ clock = 17.5, amb = C(150, 100, 140), out = C(190, 120, 170), atm = C(255, 150, 210), dec = C(200, 90, 170), dens = 0.45, haze = 2, tint = C(255, 210, 240), sat = 0.3, fog = C(255, 170, 220), fe = 40000, bri = 2.2, stars = 0 },
		{ clock = 12, amb = C(70, 75, 85), out = C(90, 95, 105), atm = C(90, 100, 110), dec = C(60, 65, 75), dens = 0.6, haze = 3.5, tint = C(190, 200, 210), sat = -0.35, fog = C(100, 108, 118), fe = 600, bri = 1.3, stars = 0 },
		{ clock = 15, amb = C(60, 110, 50), out = C(90, 150, 70), atm = C(120, 255, 90), dec = C(60, 150, 40), dens = 0.5, haze = 2.5, tint = C(190, 255, 170), sat = 0.25, fog = C(110, 200, 80), fe = 1500, bri = 2, stars = 0 },
		{ clock = 0, amb = C(70, 40, 120), out = C(90, 50, 160), atm = C(150, 70, 255), dec = C(40, 200, 255), dens = 0.4, haze = 1.5, tint = C(210, 160, 255), sat = 0.4, fog = C(60, 20, 120), fe = 8000, bri = 1.5, stars = 2500 },
	}
	local lastPreset, lastOn
	local skyClock = 0
	local lastT = os.clock()

	local LP = { "ClockTime", "Ambient", "OutdoorAmbient", "Brightness", "FogColor", "FogEnd", "FogStart", "ExposureCompensation", "ColorShift_Top", "ColorShift_Bottom" }
	local saved = nil
	local atmSaved = nil
	local ownAtm, tintFx
	local skySaved = {}

	local function findAtm()
		for _, o in Lighting:GetChildren() do
			if o:IsA("Atmosphere") and o ~= ownAtm then return o end
		end
		return nil
	end

	local function engage()
		saved = {}
		for _, p in LP do saved[p] = Lighting[p] end
		local a = findAtm()
		if a then
			atmSaved = { inst = a }
			for _, p in { "Color", "Decay", "Density", "Haze", "Offset", "Glare" } do atmSaved[p] = a[p] end
		else
			ownAtm = Instance.new("Atmosphere")
			ownAtm.Name = "FunModeSkyAtm"
			ownAtm.Parent = Lighting
		end
		tintFx = Instance.new("ColorCorrectionEffect")
		tintFx.Name = "FunModeSkyTint"
		tintFx.Parent = Lighting
		for _, o in Lighting:GetChildren() do
			if o:IsA("Sky") then skySaved[o] = o.StarCount end
		end
	end

	local function disengage()
		if saved then
			for p, v in saved do pcall(function() Lighting[p] = v end) end
			saved = nil
		end
		if atmSaved and atmSaved.inst and atmSaved.inst.Parent then
			for p, v in atmSaved do
				if p ~= "inst" then pcall(function() atmSaved.inst[p] = v end) end
			end
		end
		atmSaved = nil
		if ownAtm then ownAtm:Destroy() ownAtm = nil end
		if tintFx then tintFx:Destroy() tintFx = nil end
		for sky, n in skySaved do
			if sky.Parent then pcall(function() sky.StarCount = n end) end
			skySaved[sky] = nil
		end
	end

	local function currentPreset(now)
		local idx = S.SkyPreset
		if idx == 9 then

			local h = (now * 0.05) % 1
			local col = Color3.fromHSV(h, 0.7, 1)
			return { clock = 17, amb = Color3.fromHSV(h, 0.4, 0.55), out = Color3.fromHSV(h, 0.4, 0.7), atm = col,
				dec = Color3.fromHSV((h + 0.5) % 1, 0.8, 0.6), dens = S.SkyDensity, haze = 2, tint = Color3.fromHSV(h, 0.25, 1),
				sat = 0.3, fog = col, fe = 40000, bri = 2, stars = 0 }
		elseif idx == 10 then
			local col = N.COLORS[S.SkyColor][2]
			return { clock = S.SkyTime, amb = col:Lerp(Color3.new(0.2, 0.2, 0.25), 0.7), out = col:Lerp(Color3.new(0.3, 0.3, 0.35), 0.6),
				atm = col, dec = col:Lerp(Color3.new(0, 0, 0), 0.5), dens = S.SkyDensity, haze = 1.5, tint = col:Lerp(Color3.new(1, 1, 1), 0.7),
				sat = 0.15, fog = col, fe = 60000, bri = 2, stars = 0 }
		end
		return PRESETS[idx]
	end

	local function apply(now, dt)
		local pr = currentPreset(now)
		if not pr then return end
		local clock = pr.clock
		if S.SkyCycle > 0 then
			skyClock = (skyClock + dt * S.SkyCycle * 0.4) % 24
			clock = (pr.clock + skyClock) % 24
		end
		Lighting.ClockTime = clock
		Lighting.Ambient = pr.amb
		Lighting.OutdoorAmbient = pr.out
		Lighting.Brightness = pr.bri
		Lighting.FogColor = pr.fog
		Lighting.FogStart = 0
		Lighting.FogEnd = pr.fe
		local atm = ownAtm or (atmSaved and atmSaved.inst)
		if atm and atm.Parent then
			atm.Color = pr.atm
			atm.Decay = pr.dec
			atm.Density = (S.SkyPreset == 9 or S.SkyPreset == 10) and S.SkyDensity or pr.dens
			atm.Haze = math.min(pr.haze, 4)
			atm.Offset = 0.25
			atm.Glare = 0.2
		end
		if tintFx then
			tintFx.TintColor = pr.tint
			tintFx.Saturation = pr.sat
		end
		for sky in skySaved do
			if sky.Parent then sky.StarCount = S.SkyStars and pr.stars or 0 end
		end
	end

	local acc = 0
	RunService.Heartbeat:Connect(function()
		local now = os.clock()
		local dt = now - lastT
		lastT = now
		local on = S.SkyOn and gateOpen and not splashActive
		if on then
			if not lastOn then engage() skyClock = 0 end
			if lastPreset ~= S.SkyPreset then skyClock = 0 lastPreset = S.SkyPreset end
			acc += dt
			if acc >= 0.05 then
				apply(now, acc)
				acc = 0
			end
		elseif lastOn then
			disengage()
		end
		lastOn = on
	end)
end)

safeRun("pull", function()
	local pulled, untilT, fixedCF

	local function release()
		if pulled then pulledChars[pulled] = os.clock() + 1.5 end
		pulled = nil
	end

	RunService:BindToRenderStep("FunModePull", Enum.RenderPriority.Camera.Value + 6, function()
		if not pulled then return end
		local cam, myRoot = getCamera(), getRoot(player.Character)
		if not (cam and myRoot and pulled.Parent and isAlive(pulled) and os.clock() < untilT and gateOpen) then
			release()
			return
		end
		pulledChars[pulled] = math.huge
		pcall(function() pulled:SetAttribute("ZenithLocalMove", os.clock() + 2) end)

		if fixedCF then pcall(function() pulled:PivotTo(fixedCF) end) end
	end)

	pullStop = function()
		if pulled then release() end
	end

	pullToggle = function()
		if pulled then
			release()
			toast(tr("Притяг вимкнено"), ACCENT, true)
			return
		end

		local oldTeam = S.IgnoreTeam
		if S.PullTeam then S.IgnoreTeam = false end
		local ok, t = pcall(getTarget, S.PullUseFov)
		S.IgnoreTeam = oldTeam
		if not (ok and t) then
			toast(tr("Немає цілі для притягу"), Color3.fromRGB(215, 80, 85), true)
			return
		end

		local cam, myRoot = getCamera(), getRoot(player.Character)
		local tRoot, tHum = getRoot(t.char), getHum(t.char)
		if not (cam and myRoot and tRoot and tHum) then return end
		local look = cam.CFrame.LookVector
		local flat = Vector3.new(look.X, 0, look.Z)
		if flat.Magnitude < 0.01 then flat = myRoot.CFrame.LookVector end
		flat = flat.Unit
		local pos = myRoot.Position + flat * S.PullDist
		local feet = tHum.RigType == Enum.HumanoidRigType.R6 and 3 or (tHum.HipHeight + tRoot.Size.Y / 2)
		local gp = RaycastParams.new()
		gp.FilterType = Enum.RaycastFilterType.Exclude
		gp.FilterDescendantsInstances = { player.Character, t.char }
		local hit = workspace:Raycast(pos + Vector3.new(0, 6, 0), Vector3.new(0, -40, 0), gp)
		local y = hit and (hit.Position.Y + feet) or pos.Y
		pos = Vector3.new(pos.X, y, pos.Z)
		fixedCF = CFrame.lookAt(pos, Vector3.new(myRoot.Position.X, pos.Y, myRoot.Position.Z))
		pulled, untilT = t.char, os.clock() + S.PullTime
		pulledChars[pulled] = math.huge
		toast(string.format(tr("Притяг: %s"), t.plr and t.plr.DisplayName or t.char.Name), ACCENT, true)
	end
end)

safeRun("recolor", function()
	local MATS = { nil, Enum.Material.SmoothPlastic, Enum.Material.Neon, Enum.Material.Metal, Enum.Material.Glass }
	local saved = {}
	local tracked = {}
	local lastRun = 0

	local function remember(inst, prop)
		local rec = saved[inst]
		if not rec then rec = {} saved[inst] = rec end
		if rec[prop] == nil then rec[prop] = inst[prop] end
	end

	local function setProp(inst, prop, value)
		local ok = pcall(function()
			remember(inst, prop)
			inst[prop] = value
		end)
		return ok
	end

	local function restoreAll(onlyChar)
		for inst, rec in saved do
			if not onlyChar or inst:IsDescendantOf(onlyChar) or not inst.Parent then
				for prop, v in rec do pcall(function() inst[prop] = v end) end
				saved[inst] = nil
			end
		end
		if onlyChar then tracked[onlyChar] = nil else tracked = {} end
	end

	local function scan(char)
		local info = tracked[char]
		if not info then info = { parts = {}, t = -10 } tracked[char] = info end
		if os.clock() - info.t < 0.6 then return info end
		info.t = os.clock()
		local parts = {}
		for _, d in char:GetDescendants() do
			if d:IsA("BasePart") then
				if d.Name ~= "HumanoidRootPart" then parts[#parts + 1] = d end
				if d:IsA("MeshPart") and d.TextureID ~= "" then setProp(d, "TextureID", "") end
			elseif d:IsA("SurfaceAppearance") then

				pcall(function()
					remember(d, "Parent")
					d.Parent = nil
				end)
			elseif d:IsA("Shirt") then setProp(d, "ShirtTemplate", "")
			elseif d:IsA("Pants") then setProp(d, "PantsTemplate", "")
			elseif d:IsA("ShirtGraphic") then setProp(d, "Graphic", "")
			end
		end
		info.parts = parts
		return info
	end

	local function wanted(plr)
		if plr == player then return S.ChrWho == 4 end
		if S.ChrWho == 1 or S.ChrWho == 3 then return true end
		if S.ChrWho == 2 then return not isTeammate(plr) end
		return false
	end

	RunService.Heartbeat:Connect(function()
		if not (S.Chr and gateOpen) or splashActive then
			if next(saved) ~= nil or next(tracked) ~= nil then restoreAll() end
			return
		end
		local now = os.clock()
		if now - lastRun < 1 / 30 then return end
		lastRun = now

		local c1, c2 = N.CHR_COLORS[S.ChrColor][2], N.CHR_COLORS[S.ChrColor2][2]
		local mat = MATS[S.ChrMat]
		local seen = {}
		for _, plr in Players:GetPlayers() do
			local char = plr.Character
			if char and char.Parent and wanted(plr) then
				seen[char] = true
				local info = scan(char)
				local n = #info.parts
				for i, part in info.parts do
					if part.Parent then
						local col
						if S.ChrStyle == 1 then
							col = c1
						elseif S.ChrStyle == 2 then
							col = Color3.fromHSV((now * 0.15 * S.ChrSpeed + i / math.max(n, 1) * 0.5) % 1, 0.9, 1)
						else
							local k = (math.sin(now * 2 * S.ChrSpeed + i * 0.35) + 1) / 2
							col = c1:Lerp(c2, k)
						end
						setProp(part, "Color", col)
						if mat then setProp(part, "Material", mat) end
						local rec = saved[part]
						if S.ChrAlpha > 0 then
							local orig = rec and rec.Transparency or part.Transparency
							setProp(part, "Transparency", math.max(orig, S.ChrAlpha))
						elseif rec and rec.Transparency ~= nil then
							part.Transparency = rec.Transparency
							rec.Transparency = nil
						end
					end
				end
			end
		end

		for char in tracked do
			if not seen[char] then restoreAll(char) end
		end
	end)
end)

safeRun("third-person", function()
	local saved = nil
	local lastDist, pendingUntil = nil, 0

	RunService.Heartbeat:Connect(function()
		if S.Tpv and gateOpen then
			if not saved then
				saved = {
					mode = player.CameraMode,
					min = player.CameraMinZoomDistance,
					max = player.CameraMaxZoomDistance,
				}
				lastDist = nil
			end
			player.CameraMode = Enum.CameraMode.Classic

			if lastDist ~= S.TpvDist then

				lastDist = S.TpvDist
				pendingUntil = os.clock() + 0.2
				player.CameraMinZoomDistance = S.TpvDist
				player.CameraMaxZoomDistance = S.TpvDist
			elseif os.clock() >= pendingUntil then
				if S.TpvFree then
					player.CameraMinZoomDistance = 4
					player.CameraMaxZoomDistance = 200
				else
					player.CameraMinZoomDistance = S.TpvDist
					player.CameraMaxZoomDistance = S.TpvDist
				end
			end
		elseif saved then
			player.CameraMode = saved.mode
			player.CameraMinZoomDistance = saved.min
			player.CameraMaxZoomDistance = saved.max
			saved = nil
			lastDist = nil
		end
	end)
end)

safeRun("theme", function()
	N.theme.init()
	N.save.start()
end)