Nova Script No Key

 Players = :()
 UIS = :()
 RunService = :()
 TweenService = :()
 Lighting = :()
 CAS = :()
 TeleportService = :()
 HttpService = :()
 ReplicatedStorage = :()


 BANNER_IMAGE = 

 player = Players.LocalPlayer
 camera = .CurrentCamera
 mouse = player:()

 conns = {}
  (signal, fn)
	 c = signal:(fn)
	.(conns, c)
	 c


 BLACK, WHITE = .(, , ), .(, , )

 THEME_NAMES = { , , , , ,  }
 THEMES = {
	Orange = .(, , ),
	Blue = .(, , ),
	Purple = .(, , ),
	Green = .(, , ),
	Red = .(, , ),
	Pink = .(, , ),
}

 ESP_COLOR_NAMES = { , , , , , ,  }
 ESP_COLORS = {
	Red = .(, , ),
	Green = .(, , ),
	Blue = .(, , ),
	White = .(, , ),
	Orange = .(, , ),
	Purple = .(, , ),
}




 origGravity = .Gravity
 origFov = camera.FieldOfView
 origZoom = player.CameraMaxZoomDistance

 S = {
	
	fly = , flySpeed = , noclip = ,
	customSpeed = , walkSpeed = , customJump = , jumpPower = ,
	infJump = , clickTP = , spin = , spinSpeed = ,
	
	esp = , espBox = , espSkeleton = , espName = , espDistance = ,
	espHealth = , espTracer = , espChams = , espTeamCheck = ,
	espTeamColors = , espColor = , espMaxDist = ,
	fov = .(origFov + ), crosshair = , crossSize = ,
	customFov = , zoomOn = , zoomFov = ,
	freecam = , freecamSpeed = , freecamSens = , freecamFreeze = ,
	
	aim = , aimKey = , aimPart = , aimFov = , aimShowFov = ,
	aimStrength = , aimWall = , aimTeam = , aimMaxDist = ,
	
	target = , spectate = ,
	
	fullbright = , noFog = , gravity = .(origGravity + ),
	clock = .(Lighting.ClockTime), zoom = ,
	
	antiAfk = , showFps = , theme = , scale = ,
	cfgSlot = , cfgAuto = ,
}

 menuOpen = 
 unloaded = 
 render 

  (class, props, parent)
	 o = .(class)
	 k, v  (props) 
		o[k] = v
	
	o.Parent = parent
	 o


  ()
	 c = player.Character
	 c, c  c:(), c  c:()





 pg = player:()
 _, n  ({ ,  }) 
	 old = pg:(n)
	 old  old:() 


 espGui = (, { Name = , ResetOnSpawn = , IgnoreGuiInset = , DisplayOrder =  }, pg)
 gui = (, { Name = , ResetOnSpawn = , IgnoreGuiInset = , DisplayOrder =  }, pg)




 flyBV, flyBG, flyConn

  ()
	 flyConn  flyConn:() flyConn =  
	 flyBV  flyBV:() flyBV =  
	 flyBG  flyBG:() flyBG =  
	 _, _, hum = ()
	 hum  hum.PlatformStand =  


  ()
	()
	 _, root, hum = ()
	  (root  hum) 
		S.fly = 
		
	
	hum.PlatformStand = 

	flyBV = (, { MaxForce = .one * , Velocity = .zero }, root)
	flyBG = (, { MaxTorque = .one * , P = ,  = root.CFrame }, root)

	flyConn = RunService.RenderStepped:(()
		 dir, cf = .zero, camera.CFrame
		 UIS:(.KeyCode.W)  dir += cf.LookVector 
		 UIS:(.KeyCode.S)  dir -= cf.LookVector 
		 UIS:(.KeyCode.D)  dir += cf.RightVector 
		 UIS:(.KeyCode.A)  dir -= cf.RightVector 
		 UIS:(.KeyCode.Space)  dir += .yAxis 
		 UIS:(.KeyCode.LeftShift)  dir -= .yAxis 
		 S.freecam  dir = .zero 
		 dir.Magnitude >   dir = dir.Unit 
		flyBV.Velocity = dir * S.flySpeed
		flyBG.CFrame = cf
	)


  (v)
	S.fly = v
	 v  ()  () 
	 render  () 





(RunService.Stepped, ()
	 S.noclip 
		 c = player.Character
		 c 
			 _, p  (c:()) 
				 p:()  p.CanCollide =  
			
		
	
)

(RunService.Heartbeat, ()
	 _, root, hum = ()
	  hum   
	 S.customSpeed  hum.WalkSpeed = S.walkSpeed 
	 S.customJump 
		hum.UseJumpPower = 
		hum.JumpPower = S.jumpPower
	
	 S.spin  root   S.fly 
		root.CFrame *= .(, .(S.spinSpeed), )
	
)

(UIS.JumpRequest, ()
	 S.infJump 
		 _, _, hum = ()
		 hum  hum:(.HumanoidStateType.Jumping) 
	
)

(player.Idled, ()
	 S.antiAfk 
		(()
			 vu = :()
			vu:()
			vu:(.())
		)
	
)




 espData = {}

 BONES_R15 = {
	{ ,  }, { ,  },
	{ ,  }, { ,  }, { ,  },
	{ ,  }, { ,  }, { ,  },
	{ ,  }, { ,  }, { ,  },
	{ ,  }, { ,  }, { ,  },
}
 BONES_R6 = {
	{ ,  }, { ,  }, { ,  },
	{ ,  }, { ,  },
}

  ()
	 S.espColor ==  
		 .((.() * ) % , , )
	
	 ESP_COLORS[S.espColor]


  (parent)
	 (, {
		AnchorPoint = .(, ), BorderSizePixel = ,
		BackgroundColor3 = WHITE, Visible = ,
	}, parent)


  (f, a, b, thick, col)
	 d = b - a
	f.Visible = 
	f.BackgroundColor3 = col
	f.Size = .(d.Magnitude, thick)
	f.Position = .((a.X + b.X) / , (a.Y + b.Y) / )
	f.Rotation = .(.(d.Y, d.X))


  (plr)
	 folder = (, { Name = plr.Name }, espGui)
	 d = { folder = folder }
	d.box = (, { BackgroundTransparency = , BorderSizePixel = , Visible =  }, folder)
	d.boxStroke = (, { Thickness =  }, d.box)
	d.name = (, {
		BackgroundTransparency = , AnchorPoint = .(, ), Size = .(, ),
		Font = .Font.GothamBold, TextSize = , TextStrokeTransparency = , Visible = ,
	}, folder)
	d.dist = (, {
		BackgroundTransparency = , AnchorPoint = .(, ), Size = .(, ),
		Font = .Font.GothamMedium, TextSize = , TextStrokeTransparency = , Visible = ,
	}, folder)
	d.hpBack = (, {
		BackgroundColor3 = BLACK, BackgroundTransparency = , BorderSizePixel = , Visible = ,
	}, folder)
	d.hpFill = (, { AnchorPoint = .(, ), BorderSizePixel = , Visible =  }, folder)
	d.tracer = (folder)
	d.bones = {}
	 i = ,   d.bones[i] = (folder) 
	espData[plr] = d
	 d


  (d)
	d.box.Visible = 
	d.name.Visible = 
	d.dist.Visible = 
	d.hpBack.Visible = 
	d.hpFill.Visible = 
	d.tracer.Visible = 
	 _, b  (d.bones)  b.Visible =  
	 d.hl  d.hl.Enabled =  


  (plr)
	 d = espData[plr]
	 d 
		 d.hl  d.hl:() 
		d.folder:()
		espData[plr] = 
	


  ()
	 camPos = camera.CFrame.Position
	 vp = camera.ViewportSize

	 _, plr  (Players:()) 
		 plr ~= player 
			 d = espData[plr]  (plr)
			 char = plr.Character
			 hum = char  char:()
			 root = char  char:()

			 show = S.esp  hum ~=   root ~=   hum.Health > 
			 show  S.espTeamCheck  plr.Team ~=   plr.Team == player.Team  show =  

			 dist = 
			 show 
				dist = (root.Position - camPos).Magnitude
				 dist > S.espMaxDist  show =  
			

			 top, bot
			 show 
				 t = camera:(root.Position + .(, , ))
				 b = camera:(root.Position - .(, , ))
				 t.Z >   b.Z >  
					top, bot = .(t.X, t.Y), .(b.X, b.Y)
				
					show = 
				
			

			  show 
				(d)
			
				 col = ()
				 S.espTeamColors  plr.Team  col = plr.TeamColor.Color 

				 h = .(bot.Y - top.Y, )
				 w = h * 
				 cx = (top.X + bot.X) / 

				
				d.box.Visible = S.espBox
				 S.espBox 
					d.box.Position = .(cx - w / , top.Y)
					d.box.Size = .(w, h)
					d.boxStroke.Color = col
				

				
				d.name.Visible = S.espName
				 S.espName 
					d.name.Text = plr.DisplayName
					d.name.TextColor3 = col
					d.name.Position = .(cx, top.Y - )
				

				
				d.dist.Visible = S.espDistance
				 S.espDistance 
					d.dist.Text = .(dist) .. 
					d.dist.TextColor3 = WHITE
					d.dist.Position = .(cx, bot.Y + )
				

				
				d.hpBack.Visible = S.espHealth
				d.hpFill.Visible = S.espHealth
				 S.espHealth 
					 frac = .(hum.Health / .(hum.MaxHealth, ), , )
					 x = cx - w /  - 
					d.hpBack.Position = .(x - , top.Y - )
					d.hpBack.Size = .(, h + )
					d.hpFill.Position = .(x, bot.Y)
					d.hpFill.Size = .(, h * frac)
					d.hpFill.BackgroundColor3 = .(frac * , , )
				

				
				 S.espTracer 
					(d.tracer, .(vp.X / , vp.Y), .(cx, bot.Y), , col)
				
					d.tracer.Visible = 
				

				
				 bones = hum.RigType == .HumanoidRigType.R15  BONES_R15  BONES_R6
				 i = , #d.bones 
					 line = d.bones[i]
					 pair = S.espSkeleton  bones[i]
					 drawn = 
					 pair 
						 a, b = char:(pair[]), char:(pair[])
						 a  b 
							 pa = camera:(a.Position)
							 pb = camera:(b.Position)
							 pa.Z >   pb.Z >  
								(line, .(pa.X, pa.Y), .(pb.X, pb.Y), , col)
								drawn = 
							
						
					
					  drawn  line.Visible =  
				

				
				 S.espChams 
					  d.hl  d.hl.Parent ~= char 
						 d.hl  d.hl:() 
						d.hl = (, {
							Adornee = char, FillTransparency = , OutlineColor = WHITE,
							DepthMode = .HighlightDepthMode.AlwaysOnTop,
						}, char)
					
					d.hl.FillColor = col
					d.hl.Enabled = 
				 d.hl 
					d.hl.Enabled = 
				
			
		
	


(Players.PlayerRemoving, (plr)
	(plr)
	 render  () 
)
(Players.PlayerAdded, ()
	 render  () 
)




 fovCircle = (, {
	AnchorPoint = .(, ), BackgroundTransparency = , Visible = ,
}, espGui)
(, { CornerRadius = .(, ) }, fovCircle)
(, { Color = WHITE, Thickness = , Transparency =  }, fovCircle)

  ()
	 k = S.aimKey
	 k ==    UIS:(.UserInputType.MouseButton2)
	 k ==    UIS:(.UserInputType.MouseButton1)
	 k ==    UIS:(.KeyCode.LeftAlt) 
	 


  (part, char)
	 params = RaycastParams.()
	params.FilterType = .RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { player.Character }
	 origin = camera.CFrame.Position
	 result = :(origin, part.Position - origin, params)
	 result ==   result.Instance:(char)


  ()
	 m = UIS:()
	 camPos = camera.CFrame.Position
	 best, bestD = , S.aimFov
	 _, plr  (Players:()) 
		 char = plr ~= player  plr.Character
		 char   (S.aimTeam  plr.Team ~=   plr.Team == player.Team) 
			 hum = char:()
			 part = char:(S.aimPart ==     )
			 hum  part  hum.Health >   (part.Position - camPos).Magnitude <= S.aimMaxDist 
				 p, onScreen = camera:(part.Position)
				 onScreen 
					 d = (.(p.X, p.Y) - m).Magnitude
					 d < bestD  ( S.aimWall  (part, char)) 
						best, bestD = part, d
					
				
			
		
	
	 best


  ()
	fovCircle.Visible = S.aim  S.aimShowFov
	  S.aim  S.freecam   
	 m = UIS:()
	fovCircle.Position = .(m.X, m.Y)
	fovCircle.Size = .(S.aimFov * , S.aimFov * )
	 () 
		 target = ()
		 target 
			 cf = camera.CFrame
			camera.CFrame = cf:(.(cf.Position, target.Position), S.aimStrength)
		
	





 fovTouched = 
  ()
	 zoom = S.zoomOn  UIS:() ==   UIS:(.KeyCode.C)
	 goal = 
	 zoom 
		goal = S.zoomFov
	 S.customFov 
		goal = S.fov
	
	 goal 
		fovTouched = 
	 fovTouched 
		goal = origFov
	
		
	
	 cur = camera.FieldOfView
	 nxt = cur + (goal - cur) * 
	 .(goal - nxt) <  
		nxt = goal
		  (zoom  S.customFov)  fovTouched =  
	
	camera.FieldOfView = nxt





 fcPos, fcPitch, fcYaw = .zero, , 
 fcAnchored = 

  (dt)
	 UIS:(.UserInputType.MouseButton2) 
		UIS.MouseBehavior = .MouseBehavior.LockCurrentPosition
		 d = UIS:()
		fcYaw -= d.X *  * S.freecamSens
		fcPitch = .(fcPitch - d.Y *  * S.freecamSens, -, )
	
		UIS.MouseBehavior = .MouseBehavior.Default
	
	 rot = .(fcPitch, fcYaw, )
	 move = .zero
	 UIS:() ==  
		 UIS:(.KeyCode.W)  move += rot.LookVector 
		 UIS:(.KeyCode.S)  move -= rot.LookVector 
		 UIS:(.KeyCode.D)  move += rot.RightVector 
		 UIS:(.KeyCode.A)  move -= rot.RightVector 
		 UIS:(.KeyCode.Space)  move += .yAxis 
		 UIS:(.KeyCode.LeftShift)  move -= .yAxis 
	
	 move.Magnitude >  
		 speed = S.freecamSpeed * (UIS:(.KeyCode.LeftControl)    )
		fcPos += move.Unit * speed * dt
	
	camera.CFrame = .(fcPos) * rot


  ()
	(() RunService:() )
	UIS.MouseBehavior = .MouseBehavior.Default
	 _, root, hum = ()
	 root  fcAnchored  root.Anchored =  
	fcAnchored = 
	camera.CameraType = .CameraType.Custom
	 hum  camera.CameraSubject = hum 


  ()
	()
	 cf = camera.CFrame
	fcPos = cf.Position
	fcPitch, fcYaw = cf:()
	 S.freecamFreeze 
		 _, root = ()
		 root 
			root.Anchored = 
			fcAnchored = 
		
	
	camera.CameraType = .CameraType.Scriptable
	RunService:(, .RenderPriority.Camera.Value + , stepFreecam)


  (v)
	S.freecam = v
	 v  ()  () 
	 render  () 


RunService:(, .RenderPriority.Camera.Value + , ()
	()
	()
	()
)




 chH = (, {
	AnchorPoint = .(, ), Position = .(, ),
	BorderSizePixel = , BackgroundColor3 = WHITE, Visible = ,
}, espGui)
 chV = (, {
	AnchorPoint = .(, ), Position = .(, ),
	BorderSizePixel = , BackgroundColor3 = WHITE, Visible = ,
}, espGui)
  ()
	chH.Visible, chV.Visible = S.crosshair, S.crosshair
	chH.Size = .(S.crossSize * , )
	chV.Size = .(, S.crossSize * )


 origLight = {
	Brightness = Lighting.Brightness, Ambient = Lighting.Ambient,
	OutdoorAmbient = Lighting.OutdoorAmbient, GlobalShadows = Lighting.GlobalShadows,
	FogEnd = Lighting.FogEnd, FogStart = Lighting.FogStart,
}
  ()
	 S.fullbright 
		Lighting.Brightness = 
		Lighting.Ambient = .(, , )
		Lighting.OutdoorAmbient = .(, , )
		Lighting.GlobalShadows = 
	
		Lighting.Brightness = origLight.Brightness
		Lighting.Ambient = origLight.Ambient
		Lighting.OutdoorAmbient = origLight.OutdoorAmbient
		Lighting.GlobalShadows = origLight.GlobalShadows
	
	 S.noFog 
		Lighting.FogEnd = 
	
		Lighting.FogEnd = origLight.FogEnd
		Lighting.FogStart = origLight.FogStart
	


  ()
	 names = {}
	 _, p  (Players:()) 
		 p ~= player  .(names, p.Name) 
	
	 names


  (v)
	 v 
		 p = S.target  Players:(S.target)
		 h = p  p.Character  p.Character:()
		 h  camera.CameraSubject = h  S.spectate =  
	
		 _, _, h = ()
		 h  camera.CameraSubject = h 
	


(player.CharacterAdded, ()
	S.spectate = 
	 S.freecam 
		S.freecam = 
		()
	
	 S.fly 
		S.fly = 
		()
	
	 render  () 
)




 W, BANNER_H, TITLE_H, TAB_H, ROW_H, VISIBLE, FOOT_H = , , , , , , 
 TITLE_Y = BANNER_H + 
 TAB_Y = TITLE_Y + TITLE_H
 LIST_Y = TAB_Y + TAB_H
 LIST_H = ROW_H * VISIBLE
 FOOT_Y = LIST_Y + LIST_H
 H = FOOT_Y + FOOT_H
 ROW_W = W - 

 main = (, {
	Name = , Size = .(W, H), AnchorPoint = .(, ),
	Position = .(, , , ), BackgroundColor3 = .(, , ),
	BorderSizePixel = , ClipsDescendants = , Active = , Draggable = ,
}, gui)
(, { CornerRadius = .(, ) }, main)
 mainStroke = (, { Thickness =  }, main)
 uiScale = (, { Scale =  }, main)


 banner = (, { Size = .(, , , BANNER_H), BackgroundColor3 = WHITE, BorderSizePixel =  }, main)
 bannerGrad = (, { Offset = .(-, ) }, banner)
 BANNER_IMAGE ~=  
	(, {
		Size = .(, ), BackgroundTransparency = ,
		Image = BANNER_IMAGE, ScaleType = .ScaleType.Crop,
	}, banner)

 bannerTitle = (, {
	BackgroundTransparency = , Size = .(, , , ), Position = .(, ),
	Font = .Font.GothamBlack, TextSize = , Text = , TextColor3 = WHITE,
}, banner)
 bannerStroke = (, { Thickness =  }, bannerTitle)
(, {
	BackgroundTransparency = , Size = .(, , , ), Position = .(, ),
	Font = .Font.GothamMedium, TextSize = , Text = , TextColor3 = WHITE, TextTransparency = ,
}, banner)
TweenService:(bannerGrad, TweenInfo.(, .EasingStyle.Sine, .EasingDirection.InOut, -, ),
	{ Offset = .(, ) }):()

 accentLine = (, { Size = .(, , , ), Position = .(, BANNER_H), BorderSizePixel =  }, main)


 titleLabel = (, {
	Size = .(, , , TITLE_H), Position = .(, TITLE_Y),
	BackgroundColor3 = BLACK, BorderSizePixel = , Font = .Font.GothamBold, TextSize = ,
	TextColor3 = WHITE, Text = ,
}, main)


 TAB_NAMES = { , ,  }
 tabButtons = {}
 i, name  (TAB_NAMES) 
	 btn = (, {
		Size = .( / , , , TAB_H), Position = .((i - ) / , , , TAB_Y),
		BorderSizePixel = , AutoButtonColor = , Font = .Font.GothamBold, TextSize = , Text = name,
	}, main)
	 line = (, { Size = .(, , , ), Position = .(, , , -), BorderSizePixel =  }, btn)
	tabButtons[i] = { btn = btn, line = line }

  (text, x)
	 f = (, {
		Size = .(, ), Position = .(x, TAB_Y + ),
		BackgroundColor3 = .(, , ), BorderSizePixel = , ZIndex = ,
	}, main)
	(, { CornerRadius = .(, ) }, f)
	(, {
		Size = .(, ), BackgroundTransparency = , Text = text, Font = .Font.GothamBold,
		TextSize = , TextColor3 = .(, , ), ZIndex = ,
	}, f)

(, )
(, W - )


 listFrame = (, {
	Size = .(W, LIST_H), Position = .(, LIST_Y),
	BackgroundColor3 = BLACK, BorderSizePixel = , ClipsDescendants = ,
}, main)
 track = (, {
	Size = .(, LIST_H - ), Position = .(, ),
	BackgroundColor3 = .(, , ), BorderSizePixel = ,
}, listFrame)
(, { CornerRadius = .(, ) }, track)
 thumb = (, { Size = .(, ), BorderSizePixel =  }, track)
(, { CornerRadius = .(, ) }, thumb)

 rows = {}
 rowHandlers = {}
 i = , VISIBLE 
	 r = {}
	r.frame = (, {
		Size = .(ROW_W, ROW_H), Position = .(, (i - ) * ROW_H),
		BorderSizePixel = , AutoButtonColor = , Text = ,
	}, listFrame)
	r.icon = (, {
		Size = .(, ROW_H), Position = .(, ), BackgroundTransparency = ,
		Font = .Font.Gotham, TextSize = , Text = ,
	}, r.frame)
	r.name = (, {
		Size = .(, ROW_H), Position = .(, ), BackgroundTransparency = ,
		Font = .Font.GothamMedium, TextSize = , TextXAlignment = .TextXAlignment.Left, Text = ,
	}, r.frame)
	r.value = (, {
		Size = .(, ROW_H), Position = .(, ), BackgroundTransparency = ,
		Font = .Font.GothamBold, TextSize = , TextColor3 = .(, , ),
		TextXAlignment = .TextXAlignment.Right, Text = ,
	}, r.frame)
	r.pill = (, {
		Size = .(, ), Position = .(ROW_W -  - , ROW_H /  - ),
		BorderSizePixel = ,
	}, r.frame)
	(, { CornerRadius = .(, ) }, r.pill)
	r.pillText = (, {
		Size = .(, ), BackgroundTransparency = , Font = .Font.GothamBold,
		TextSize = , TextColor3 = WHITE, Text = ,
	}, r.pill)
	r.track = (, {
		Size = .(, ), Position = .(ROW_W -  - , ROW_H /  - ),
		BackgroundColor3 = .(, , ), BorderSizePixel = ,
	}, r.frame)
	(, { CornerRadius = .(, ) }, r.track)
	r.fill = (, { Size = .(, ), BorderSizePixel =  }, r.track)
	(, { CornerRadius = .(, ) }, r.fill)
	r.arrow = (, {
		Size = .(, ROW_H), Position = .(ROW_W -  - , ), BackgroundTransparency = ,
		Font = .Font.GothamBold, TextSize = , TextColor3 = WHITE, Text = ,
	}, r.frame)
	rows[i] = r



 foot = (, {
	Size = .(W, FOOT_H), Position = .(, FOOT_Y),
	BackgroundColor3 = .(, , ), BorderSizePixel = ,
}, main)
 footLine = (, { Size = .(, , , ), BorderSizePixel =  }, foot)
 footLogo = (, {
	Size = .(, FOOT_H), Position = .(, ), BackgroundTransparency = ,
	Font = .Font.GothamBold, TextSize = , Text = ,
}, foot)
(, {
	Size = .(, FOOT_H), Position = .(, ), BackgroundTransparency = ,
	Font = .Font.GothamBold, TextSize = , TextColor3 = WHITE, TextXAlignment = .TextXAlignment.Left, Text = ,
}, foot)
 fpsLabel = (, {
	Size = .(, FOOT_H), Position = .(, -, , ), BackgroundTransparency = ,
	Font = .Font.Gotham, TextSize = , TextColor3 = .(, , ), Text = ,
}, foot)
 indexLabel = (, {
	Size = .(, FOOT_H), Position = .(, -, , ), BackgroundTransparency = ,
	Font = .Font.GothamBold, TextSize = , TextColor3 = WHITE, TextXAlignment = .TextXAlignment.Right, Text = ,
}, foot)




 registry = {} 
 applyingConfig = 
  (key, it) registry[key] = it  it 

  (name, icon, key, cb)
	 (key, {
		 = , name = name, icon = icon,
		get = ()  S[key] ,
		set = (v) S[key] = v  cb  (v)  ,
	})

  (name, icon, key, min, max, step, cb, fmt)
	 (key, {
		 = , name = name, icon = icon, min = min, max = max, step = step, fmt = fmt  ,
		get = ()  S[key] ,
		set = (v) S[key] = v  cb  (v)  ,
	})

  (name, icon, key, options, cb)
	 (key, {
		 = , name = name, icon = icon, options = options,
		get = ()  S[key] ,
		set = (v) S[key] = v  cb  (v)  ,
	})

  (name, icon, fn)  {  = , name = name, icon = icon, run = fn } 
  (name, icon, title, items)  {  = , name = name, icon = icon, menu = { title = title, items = items } } 
  (name, icon, textfn)  {  = , name = name, icon = icon, text = textfn } 

  ()
	S.customSpeed, S.customJump = , 
	 _, _, h = ()
	 h 
		h.WalkSpeed = 
		h.UseJumpPower = 
		h.JumpPower = 
	


 selfMenu = (, , , {
	(, , , (v)  v  ()  ()  ),
	(, , , , , ),
	(, , ),
	(, , , (v)
		  v   _, _, h = ()  h  h.WalkSpeed =   
	),
	(, , , , , ),
	(, , , (v)
		  v   _, _, h = ()  h  h.UseJumpPower =  h.JumpPower =   
	),
	(, , , , , ),
	(, , ),
	(, , ),
	(, , ),
	(, , , , , ),
})

 visualMenu = (, , , {
	(, , , {
		(, , ),
		(, , ),
		(, , ),
		(, , ),
		(, , ),
		(, , ),
		(, , ),
		(, , ),
		(, , ),
		(, , ),
		(, , , ESP_COLOR_NAMES),
		(, , , , , ),
	}),
	(, , , {
		(, , , updateCrosshair),
		(, , , , , , updateCrosshair),
	}),
})

 onlineMenu = (, , , {
	(, , ()  #Players:() ..  .. Players.MaxPlayers ),
	(, , , otherPlayerNames),
	(, , ()
		 p = S.target  Players:(S.target)
		 tr = p  p.Character  p.Character:()
		 _, root = ()
		 tr  root  root.CFrame = tr.CFrame * .(, , ) 
	),
	(, , , setSpectate),
})

 combatMenu = (, , , {
	(, , ),
	(, , , { , , ,  }),
	(, , , { ,  }),
	(, , , , , ),
	(, , ),
	(, , , , , , , ),
	(, , ),
	(, , ),
	(, , , , , ),
})

 worldMenu = (, , , {
	(, , , applyLighting),
	(, , , applyLighting),
	(, , , , , , (v) Lighting.ClockTime = v ),
	(, , , , , , (v) .Gravity = v ),
	(, , , (v) player.CameraMaxZoomDistance = v    origZoom ),
})


 itemNames, itemStatus = {}, 
  ()
	 rf = ReplicatedStorage:()
	  rf 
		itemNames, itemStatus = {}, 
		
	
	 ok, res = (()  rf:() )
	 ok  (res) ==  
		itemNames = res
		itemStatus = #res .. 
		  S.item   .(res, S.item)  S.item = res[] 
	
		itemStatus = 
	

  (action, name)
	 ev = ReplicatedStorage:()
	 ev  ev:(action, name)  itemStatus =  


 toolsMenu = (, , , {
	(, , ()  itemStatus ),
	(, , , ()  itemNames ),
	(, , ()  S.item  (, S.item)  ),
	(, , () () ),
	(, , () () ),
	(, , () .(() () () ) ),
	(, , ()
		 _, _, h = ()
		 bp = player:()
		 t = bp  bp:()
		 h  t  h:(t) 
	),
	(, , ()
		 _, _, h = ()
		 h  h:() 
	),
})

 cameraMenu = (, , , {
	(, , , (v)  v  ()  ()  ),
	(, , , , , ),
	(, , , , , , , ),
	(, , ),
	(, , ),
	(, , , , , , ()
		  applyingConfig  S.customFov =  
	),
	(, , ),
	(, , , , , ),
	(, , ()
		S.customFov = 
		S.fov = .(origFov + )
	),
})

 mainRoot = { title = , items = { selfMenu, visualMenu, cameraMenu, onlineMenu, combatMenu, worldMenu, toolsMenu } }

 miscRoot = { title = , items = {
	(, , ()  c = player.Character  c  c:()  ),
	(, , ()  _, _, h = ()  h  h.Sit =   ),
	(, , resetMovement),
	(, , ),
	(, , ()
		(() TeleportService:(.PlaceId, player) )
	),
} }




 SLOT_NAMES = { , , , ,  }
 EXCLUDED = { fly = , freecam = , spectate = , target = , item = , cfgSlot = , cfgAuto =  }
 sessionSlots, defaults = {}, {}
 cfgStatus = 

  ()
	 data = {}
	 k  (registry) 
		  EXCLUDED[k]  data[k] = S[k] 
	
	 data


  (data)
	applyingConfig = 
	 k, v  (data) 
		 item = registry[k]
		 item   EXCLUDED[k]  (v) == (S[k]) 
			 okValue = 
			 item.type ==  
				v = .(v, item.min, item.max)
			 item.type ==   (item.options) ==    .(item.options, v) 
				okValue = 
			
			 okValue  (item.set, v) 
		
	
	applyingConfig = 
	()


  (action, slot, data)
	 rf = ReplicatedStorage:()
	  rf    
	 ok, res = (()  rf:(action, slot, data) )
	 ok  res


  ()
	 slot, data = S.cfgSlot, ()
	sessionSlots[slot] = data
	cfgStatus = 
	()
	.(()
		 (, slot, data) ==   cfgStatus =  
		()
	)


  ()
	.(()
		 slot = S.cfgSlot
		 data = sessionSlots[slot]
		  data 
			 prof = ()
			 (prof) ==   (prof.slots) ==   data = prof.slots[slot] 
		
		 (data) ==  
			(data)
			cfgStatus = 
		
			cfgStatus = 
		
		()
	)


  ()
	 slot = S.cfgSlot
	sessionSlots[slot] = 
	cfgStatus = 
	()
	.(() (, slot) )


  ()
	(defaults)
	cfgStatus = 
	()



 panelOpen = 
 panel = (, {
	Size = .(, ), Position = .(,  + W + , , -),
	BackgroundColor3 = .(, , ), BorderSizePixel = , Visible = , Active = , Draggable = ,
}, gui)
(, { CornerRadius = .(, ) }, panel)
 panelStroke = (, { Thickness =  }, panel)
 panelTitle = (, {
	Size = .(, -, , ), Position = .(, ), BackgroundTransparency = ,
	Font = .Font.GothamBold, TextSize = , TextColor3 = WHITE, TextXAlignment = .TextXAlignment.Left, Text = ,
}, panel)
 panelBox = (, {
	Size = .(, -, , -), Position = .(, ), BackgroundColor3 = .(, , ),
	BorderSizePixel = , ClearTextOnFocus = , MultiLine = , TextWrapped = , TextEditable = ,
	TextXAlignment = .TextXAlignment.Left, TextYAlignment = .TextYAlignment.Top,
	Font = .Font.Code, TextSize = , TextColor3 = WHITE, PlaceholderText = , Text = ,
}, panel)
(, { CornerRadius = .(, ) }, panelBox)

  ()
	panel.Visible = panelOpen  menuOpen
	panelStroke.Color = THEMES[S.theme]


  (text)
	 ok, data = (()  HttpService:(text) )
	 ok  (data) ==  
		(data)
		cfgStatus = 
	
		cfgStatus = 
	
	()


 lastCode = 
 panelMode = 
 loadByCode 

  (text, x, w, fn)
	 b = (, {
		Size = .(w, ), Position = .(, x, , -), BackgroundColor3 = .(, , ),
		BorderSizePixel = , Font = .Font.GothamBold, TextSize = , TextColor3 = WHITE, Text = text,
	}, panel)
	(, { CornerRadius = .(, ) }, b)
	b.Activated:(fn)
	 b

 applyBtn = (, , , ()
	 panelMode ==  
		(panelBox.Text)
	 panelMode ==  
		(panelBox.Text)
	
)
(, , , ()
	panelOpen = 
	()
)

  (mode)
	panelOpen = 
	panelMode = mode
	applyBtn.Visible = (mode ==   mode == )
	applyBtn.Text = mode ==     
	 mode ==  
		panelTitle.Text = 
		panelBox.Text = HttpService:(())
	 mode ==  
		panelTitle.Text = 
		panelBox.Text = lastCode  
	 mode ==  
		panelTitle.Text = 
		panelBox.Text = 
	
		panelTitle.Text = 
		panelBox.Text = 
	
	()



  ()
	cfgStatus = 
	()
	.(()
		 res = (, , ())
		 (res) ==  
			lastCode = res
			cfgStatus = 
			()
		
			cfgStatus = 
		
		()
	)


loadByCode = (text)
	cfgStatus = 
	()
	.(()
		 res = (, text)
		 (res) ==  
			(res)
			cfgStatus = 
			panelOpen = 
			()
		 res ==  
			cfgStatus = 
		
			cfgStatus = 
		
		()
	)


 unload 
 settingsRoot = { title = , items = {
	(, , , THEME_NAMES),
	(, , , , , , , ),
	(, , ),
	(, , , {
		(, , ()  cfgStatus ),
		(, , saveCode),
		(, , () () ),
		(, , ()  lastCode   ),
		(, , , SLOT_NAMES),
		(, , saveConfig),
		(, , loadConfig),
		(, , deleteConfig),
		(, , , (v)
			 slot = S.cfgSlot
			.(() (, v  slot  ) )
		),
		(, , () () ),
		(, , () () ),
		(, , resetDefaults),
	}),
	(, , , {
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
		(, , ()   ),
	}),
	(, , () () ),
} }




 tabRoots = { mainRoot, miscRoot, settingsRoot }
 tabStacks = {}
 i, root  (tabRoots) 
	tabStacks[i] = { { menu = root, index = , scroll =  } }

 currentTab = 

  ()
	 st = tabStacks[currentTab]
	 st[#st]


  (menu)
	 (menu.items) ==    menu.() 
	 menu.items


  (item, dir)
	 opts = (item.options) ==   item.()  item.options
	 #opts ==    
	 idx = .(opts, item.())  
	idx = ((idx -  + dir) % #opts) + 
	item.(opts[idx])


  (item, dir)
	 item.type ==  
		 v = item.() + dir * item.step
		v = .(v / item.step + ) * item.step
		v = .(v, item.min, item.max)
		item.((.(, v)))
	 item.type ==  
		(item, dir)
	 item.type ==  
		item.( item.())
	


  ()
	 cur = ()
	 (cur.menu)[cur.index]


  ()
	 item = ()
	  item   
	 t = item.type
	 t ==  
		item.( item.())
	 t ==  
		.(tabStacks[currentTab], { menu = item.menu, index = , scroll =  })
	 t ==  
		item.()
	 t ==  
		(item, )
	
	()


  ()
	 st = tabStacks[currentTab]
	 #st >   .(st) 
	()


  (dir)
	 cur = ()
	 total = #(cur.menu)
	 total ==    
	 idx = cur.index + dir
	 idx <   idx = total  idx > total  idx =  
	cur.index = idx
	()


  (dir)
	 item = ()
	  item   
	 item.type ==  
		 dir >   ()  () 
		
	
	(item, dir)
	()


  (dir)
	currentTab = ((currentTab -  + dir) % #TAB_NAMES) + 
	()





render = ()
	 acc = THEMES[S.theme]
	mainStroke.Color = acc
	bannerStroke.Color = acc
	bannerGrad.Color = ColorSequence.({
		ColorSequenceKeypoint.(, .(, , )),
		ColorSequenceKeypoint.(, acc),
	})
	accentLine.BackgroundColor3 = acc
	footLine.BackgroundColor3 = acc
	thumb.BackgroundColor3 = acc
	footLogo.TextColor3 = acc
	uiScale.Scale = S.scale

	 i, tb  (tabButtons) 
		 active = i == currentTab
		tb.btn.BackgroundColor3 = active  acc:(BLACK, )  BLACK
		tb.btn.TextColor3 = active  WHITE  .(, , )
		tb.line.Visible = active
		tb.line.BackgroundColor3 = acc
	

	 cur = ()
	 items = (cur.menu)
	 total = #items
	cur.index = .(cur.index, , .(total, ))
	 cur.index <= cur.scroll  cur.scroll = cur.index -  
	 cur.index > cur.scroll + VISIBLE  cur.scroll = cur.index - VISIBLE 
	cur.scroll = .(cur.scroll, , .(total - VISIBLE, ))

	titleLabel.Text = .(cur.menu.title)
	indexLabel.Text = cur.index ..  .. total

	 i = , VISIBLE 
		 r = rows[i]
		 item = items[cur.scroll + i]
		  item 
			r.frame.Visible = 
		
			 sel = (cur.scroll + i) == cur.index
			r.frame.Visible = 
			r.frame.BackgroundColor3 = acc:(BLACK, )
			r.frame.BackgroundTransparency = sel    
			r.icon.Text = item.icon  
			r.name.Text = item.name
			r.name.TextColor3 = sel  WHITE  .(, , )

			r.value.Visible, r.pill.Visible, r.track.Visible, r.arrow.Visible = , , , 
			r.name.Size = .(, ROW_H)
			r.value.Position = .(, )
			r.value.Size = .(, ROW_H)

			 t = item.type
			 t ==  
				 on = item.()
				r.pill.Visible = 
				r.pill.BackgroundColor3 = on  acc  .(, , )
				r.pillText.Text = on    
			 t ==  
				 v = item.()
				r.name.Size = .(, ROW_H)
				r.value.Visible = 
				r.value.Text = .(item.fmt, v)
				r.track.Visible = 
				r.fill.BackgroundColor3 = acc
				r.fill.Size = .(.((v - item.min) / (item.max - item.min), , ), )
			 t ==  
				r.name.Size = .(, ROW_H)
				r.value.Visible = 
				r.value.Position = .(, )
				r.value.Size = .(, ROW_H)
				r.value.Text =  .. (item.()  ) .. 
			 t ==  
				r.arrow.Visible = 
				r.arrow.Text = 
			 t ==  
				r.arrow.Visible = 
				r.arrow.Text = 
			 t ==  
				r.name.Size = .(, ROW_H)
				r.value.Visible = 
				r.value.Position = .(, )
				r.value.Size = .(, ROW_H)
				r.value.Text = item.()
			
		
	

	 frac = total > VISIBLE  (VISIBLE / total)  
	thumb.Size = .(, frac)
	thumb.Position = .(, total >   cur.scroll / total  )



 i = , VISIBLE 
	rows[i].frame.Activated:(()
		 cur = ()
		cur.index = cur.scroll + i
		()
	)

 i, tb  (tabButtons) 
	tb.btn.Activated:(()
		currentTab = i
		()
	)





 actions = {
	[.KeyCode.Up] = () (-) ,
	[.KeyCode.Down] = () () ,
	[.KeyCode.Left] = () (-) ,
	[.KeyCode.Right] = () () ,
	[.KeyCode.Return] = activate,
	[.KeyCode.KeypadEnter] = activate,
	[.KeyCode.Backspace] = back,
	[.KeyCode.Q] = () (-) ,
	[.KeyCode.E] = () () ,
}
 repeatable = {
	[.KeyCode.Up] = , [.KeyCode.Down] = ,
	[.KeyCode.Left] = , [.KeyCode.Right] = ,
}

 heldToken = 
  (fn)
	heldToken += 
	 token = heldToken
	.(()
		.()
		 heldToken == token  menuOpen   unloaded 
			()
			.()
		
	)


  (_, state, input)
	  menuOpen   .ContextActionResult.Pass 
	 state == .UserInputState.Begin 
		 fn = actions[input.KeyCode]
		 fn 
			()
			 repeatable[input.KeyCode]  (fn) 
		
	
		heldToken += 
	
	 .ContextActionResult.Sink


 navKeys = {}
 key  (actions)  .(navKeys, key) 
CAS:(, onNav, , .ContextActionPriority.High.Value, .(navKeys))

  ()
	menuOpen =  menuOpen
	main.Visible = menuOpen
	()
	heldToken += 


(UIS.InputBegan, (input, processed)
	 processed   
	 input.UserInputType == .UserInputType.MouseButton1 
		 S.clickTP  UIS:(.KeyCode.LeftControl) 
			 _, root = ()
			 root  mouse.Hit 
				root.CFrame = .(mouse.Hit.Position + .(, , ))
			
		
	 input.KeyCode == .KeyCode.F 
		( S.fly)
	 input.KeyCode == .KeyCode.G 
		( S.freecam)
	 input.KeyCode == .KeyCode.Insert  input.KeyCode == .KeyCode.M 
		()
	
)




 fpsAcc, fpsFrames = , 
(RunService.RenderStepped, (dt)
	fpsAcc += dt
	fpsFrames += 
	 fpsAcc >=  
		fpsLabel.Text = S.showFps  (.(fpsFrames / fpsAcc + ) .. )  
		fpsAcc, fpsFrames = , 
	
)




unload = ()
	unloaded = 
	 S.freecam 
		S.freecam = 
		()
	
	()
	S.noclip, S.spin, S.esp, S.aim, S.fullbright, S.noFog = , , , , , 
	 S.spectate  () 
	()
	()
	.Gravity = origGravity
	camera.FieldOfView = origFov
	player.CameraMaxZoomDistance = origZoom
	 plr  (espData)  (plr) 
	RunService:()
	CAS:()
	 _, c  (conns)  c:() 
	gui:()
	espGui:()





 k  (registry) 
	  EXCLUDED[k]  defaults[k] = S[k] 

()
()

.(()
	.()
	 unloaded   
	()
	 prof = ()
	 (prof) ==   prof.autoload  (prof.slots) ==  
		 data = prof.slots[prof.autoload]
		 (data) ==  
			S.cfgSlot = prof.autoload
			S.cfgAuto = 
			(data)
			cfgStatus = 
		
	
	()
)