1suvi7

 Players = :()
 RunService = :()
 UserInputService = :()
 TweenService = :()
 plr = Players.LocalPlayer
 pg = plr:(, )
  pg   
 old = pg:()
 old  old:() 

 Theme = {
	bg = .(,,), sidebar = .(,,),
	panel = .(,,), panel2 = .(,,),
	accent = .(,,), text = .(,,),
	muted = .(,,), off = .(,,),
}
 themed, accentRefreshers = {}, {}
  (o, prop, key) .(themed, {o, prop, key}) 
  ()  _, t  (themed)  t[][t[]] = Theme[t[]]  
  ()  _, f  (accentRefreshers)  ()  
  (f) .(accentRefreshers, f) 

  (p, r)  c = .(); c.CornerRadius = .(, r  ); c.Parent = p;  c 
  (p, col, th)  s = .(); s.Color = col  .(,,); s.Thickness = th  ; s.Parent = p;  s 
  (cls, props, parent)
	 i = .(cls)
	 k, v  (props)  i[k] = v 
	 parent  i.Parent = parent 
	 i

  (t, v)  NumberSequenceKeypoint.(t, v) 
  (frame, handle)
	handle = handle  frame
	 dragging, dragInput, dragStart, startPos
	handle.InputBegan:((input)
		 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
			dragging = ; dragStart = input.Position; startPos = frame.Position
			input.Changed:(()  input.UserInputState == .UserInputState.End  dragging =   )
		
	)
	handle.InputChanged:((input)
		 input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch  dragInput = input 
	)
	UserInputService.InputChanged:((input)
		 input == dragInput  dragging 
			 d = input.Position - dragStart
			frame.Position = .(startPos.X.Scale, startPos.X.Offset + d.X, startPos.Y.Scale, startPos.Y.Offset + d.Y)
		
	)


 HEADSHOT = ():(plr.UserId)


  (sw)
	 sel = .()
	sel.Name = 
	sel.BackgroundTransparency = 
	sel.Size = .(,,,)
	sel.AnchorPoint = .(,)
	sel.Position = .(,,,)
	sel.Visible = 
	sel.ZIndex = 
	sel.Parent = sw
	 _, c  ({{,},{,},{,},{,}}) 
		 cx, cy = c[], c[]
		 h = .()
		h.Size = .(,,,)
		h.BackgroundColor3 = .(,,)
		h.BorderSizePixel = 
		h.Position = .(cx,,cy,)
		h.AnchorPoint = .(cx,cy)
		h.ZIndex = 
		h.Parent = sel
		 v = .()
		v.Size = .(,,,)
		v.BackgroundColor3 = .(,,)
		v.BorderSizePixel = 
		v.Position = .(cx,,cy,)
		v.AnchorPoint = .(cx,cy)
		v.ZIndex = 
		v.Parent = sel
	
	 hovering = 
	sw.MouseEnter:(()
		 hovering   
		hovering = 
		sel.Visible = 
		.(()
			 hovering 
				 t1 = TweenService:(sel, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {Size = .(,,,)})
				t1:(); t1.Completed:()
				  hovering   
				 t2 = TweenService:(sel, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.In), {Size = .(,,,)})
				t2:(); t2.Completed:()
			
			sel.Size = .(,,,)
			  sel:()  sel.Visible =  
		)
	)
	sw.MouseLeave:(()
		hovering = 
	)
	 sel


 addonState = {
	step  = {enabled=, color=.(,,)},
	glass = {enabled=, color=.(,,)},
	wings = {enabled=, color=.(,,)},
	crown = {enabled=, color=.(,,)},
	aura  = {enabled=, color=.(,,)},
}
 glassParts = {}
 modelAttachments = {}
 auraEmitters = {}
 auraBaseHue = 
 crownParts = {}
 crownSpring = {pos = .(), vel = .(), tilt = , tiltVel = }
 emitters = {}
 effectsFolder
 stepSide = 
 stepDistance = 
 STEP_DIST = 
 FOOT_OFFSET = 

  (props)
	 p = .()
	 k, v  (props)  p[k] = v 
	 p

  ()
	 effectsFolder  effectsFolder:(); effectsFolder =  
	emitters = {}
	glassParts = {}
	 _, m  (modelAttachments)   m.Parent  m:()  
	modelAttachments = {}
	crownParts = {}
	crownSpring = {pos = .(), vel = .(), tilt = , tiltVel = }
	auraEmitters = {}

 applyGlass
 applyModel
 antiFlingOn = 
 partCheckerOn = 
 partVelLimit = 
 partRestoreTime = 
  (on)
	antiFlingOn = on
	 _, p  (Players:()) 
		 p ~= plr  p.Character 
			 _, d  (p.Character:()) 
				 d:()  d.CanCollide =  on 
			
		
	

  (char)
	()
	 hrp = char:(, )
	  hrp   
	 folder = .(); folder.Name = ; folder.Parent = char
	effectsFolder = folder

	 addonState.glass.enabled  (, addonState.glass.color) 
	 addonState.wings.enabled  (, , addonState.wings.color) 
	 addonState.crown.enabled  (, , addonState.crown.color) 
	 addonState.aura.enabled  (, , addonState.aura.color) 

  (key, on)
	addonState[key].enabled = on
	 key ==   (on, addonState.glass.color);  
	 key ==   key ==   key ==   (key, on, addonState[key].color);  
	 _, em  (emitters[key]  {})  em.Enabled = on 

  (char, on)
	 _, d  (char:()) 
		 d:() 
			(() d.Enabled = on )
		 d:()  d:() 
			 on 
				 d:() ~=   (() d.Transparency = d:() ) 
			
				 d:() ==   d:(, d.Transparency) 
				(() d.Transparency =  )
			
		 d:() 
			 on 
				 d:() ~=   (() d.ShirtTemplate = d:() ) 
			
				 d:() ==   d:(, d.ShirtTemplate) 
				(() d.ShirtTemplate =  )
			
		 d:() 
			 on 
				 d:() ~=   (() d.PantsTemplate = d:() ) 
			
				 d:() ==   d:(, d.PantsTemplate) 
				(() d.PantsTemplate =  )
			
		 d:() 
			 on 
				 d:() ~=   (() d.Graphic = d:() ) 
			
				 d:() ==   d:(, d.Graphic) 
				(() d.Graphic =  )
			
		
	

applyGlass = (on, col)
	 char = plr.Character
	  char   
	 _, d  (char:()) 
		 d:()  d.Name ~=   d.Transparency <    d:() 
			 store = .(); store.Name = ; store.Parent = d
			store:(, d.Material.Name)
			store:(, d.Color)
			store:(, d.Transparency)
			store:(, d.Reflectance)
			 d:()  store:(, d.TextureID) 
			.(glassParts, d)
		
	
	(char,  on)
	 _, d  (glassParts) 
		 d.Parent 
			 store = d:()
			 on 
				d.Material = .Material.Glass
				d.Color = col
				d.Transparency = 
				d.Reflectance = 
				 d:()  (() d.TextureID =  ) 
			 store 
				d.Material = .Material[store:()]  .Material.Plastic
				d.Color = store:()  d.Color
				d.Transparency = store:()  
				d.Reflectance = store:()  
				 d:()  (() d.TextureID = store:()   ) 
			
		
	

applyModel = (key, on, col)
	 modelAttachments[key]  modelAttachments[key]:(); modelAttachments[key] =  
	  on   
	 char = plr.Character
	  char   
	 tmplFolder = :():()
	 tmplName = (key ==   )  (key ==   )  (key ==   )
	 tmpl = tmplFolder  tmplName  tmplFolder:(tmplName)
	  tmpl   
	 anchor
	 key ==  
		anchor = char:()  char:()
	 key ==  
		anchor = char:()  char:()
	
		anchor = char:()
	
	  anchor   
	 model = tmpl:()
	 folder = .()
	folder.Name =  .. key
	folder.Parent = char
	modelAttachments[key] = folder
	 parts = {}
	 model:()  .(parts, model) 
	 _, d  (model:()) 
		 d:()  .(parts, d) 
	
	 _, d  (parts) 
		d.Anchored = 
		d.CanCollide = 
		d.Massless = 
		d.CastShadow = 
		d.Color = col
		d.Material = .Material.Neon
		d.Transparency = 
		d.LocalTransparencyModifier = 
		 d:()  (() d.TextureID =  ) 
		 tex = d:()
		 tex  tex.Texture =  
	
	model.Parent = folder
	 key ==  
		 map = {
			[] = {, },
			[] = {},
			[] = {, },
			[] = {, },
			[] = {, },
			[] = {, },
		}
		 _, d  (parts) 
			d.Transparency = 
			 names = map[d.Name]  {d.Name}
			 target
			 _, n  (names) 
				 t = char:(n)
				 t  t:()  target = t  
			
			 target 
				d.CFrame = target.CFrame
				 w = .()
				w.Part0 = target
				w.Part1 = d
				w.Parent = d
			
		
		 _, d  (model:()) 
			 d:() 
				 kps = {}
				 _, k  (d.Color.Keypoints)  .(kps, {t = k.Time, v = k.Value}) 
				.(auraEmitters, {em = d, kps = kps})
			
		
		(addonState.aura.color)
		
	
	 key ==  
		 mp = parts[]
		 mp 
			mp.Anchored = 
			 topY = anchor.Position.Y + anchor.Size.Y/
			 _, d  (char:()) 
				 d:() 
					 h = d:()
					 h   t = h.Position.Y + h.Size.Y/;  t > topY  topY = t  
				
			
			 baseY = (topY - anchor.Position.Y) + mp.Size.Y/ + 
			mp.CFrame = anchor.CFrame * .(, baseY, )
			.(crownParts, {part = mp, anchor = anchor, baseY = baseY})
		
		
	
	 offsets = {
		wings = .(, , ),
	}
	 off = offsets[key]  .()
	 _, d  (parts) 
		d.CFrame = anchor.CFrame * off
		 w = .()
		w.Part0 = anchor
		w.Part1 = d
		w.Parent = d
	

  (key, col)
	addonState[key].color = col
	 key ==  
		 addonState.glass.enabled  (, col) 
		
	
	 key ==   key ==   key ==  
		 addonState[key].enabled  (key, , col) 
		
	
	 _, em  (emitters[key]  {})  em.Color = ColorSequence.(col) 

setAuraHue = (col)
	 _, e  (auraEmitters) 
		 e.em.Parent 
			e.em.Color = ColorSequence.(col)
		
	

  (origin, dir, side, col)
	 rp = RaycastParams.()
	rp.FilterType = .RaycastFilterType.Exclude
	rp.FilterDescendantsInstances = {plr.Character}
	 hit = :(origin + .(,,), .(,-,), rp)
	 groundPos, normal
	 hit 
		groundPos = hit.Position
		normal = hit.Normal
	
		groundPos = origin - .(,,)
		normal = .(,,)
	
	 part = .()
	part.Anchored = 
	part.CanCollide = 
	part.CanQuery = 
	part.CanTouch = 
	part.Massless = 
	part.CastShadow = 
	part.Size = .(, , )
	part.Color = col
	part.Material = .Material.Neon
	part.Transparency = 
	 look = dir.Magnitude >   dir.Unit  .(,,)
	part.CFrame = .(groundPos + normal*, groundPos + normal* + .(look.X,,look.Z))
	part.Parent = 
	.(()
		 t = 
		 t <  
			t = t + 
			  part.Parent   
			part.Transparency = .(, t)
			.()
		
		 part.Parent  part:() 
	)

plr.CharacterAdded:((char) .(); (char) )
 plr.Character  (plr.Character) 


RunService.Heartbeat:(()
	  antiFlingOn   
	 _, p  (Players:()) 
		 p ~= plr  p.Character 
			 _, d  (p.Character:()) 
				 d:()  d.CanCollide  d.CanCollide =  
			
		
	
)


 disabledByChecker = {}
RunService.Heartbeat:(()
	  partCheckerOn   
	 now = ()
	 _, d  (:()) 
		 d:()   d.Anchored   d:(plr.Character) 
			 v = d.AssemblyLinearVelocity
			 v.Magnitude > partVelLimit 
				 d.CanCollide 
					d.CanCollide = 
					d:(, )
				
				d:(, now)
			
		
	
	 partRestoreTime >  
		 _, d  (:()) 
			 d:()  d:() 
				 t = d:()  
				 now - t > partRestoreTime 
					d.CanCollide = 
					d:(, )
					d:(, )
				
			
		
	
)

 sg = (, {Name=, ResetOnSpawn=, IgnoreGuiInset=, ZIndexBehavior=.ZIndexBehavior.Sibling}, pg)

 main = (, {Name=, Size=.(,,,), Position=.(,-,,-), BackgroundColor3=Theme.bg, BorderSizePixel=, Active=}, sg)
(main,); (main); (main,,)
 menuScale = (, {Scale=}, main)
 dragBar = (, {Name=, Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Active=}, main)
(main, dragBar)
TweenService:(menuScale, TweenInfo.(, .EasingStyle.Back, .EasingDirection.Out), {Scale=}):()

 side = (, {Name=, Size=.(,,,), BackgroundColor3=Theme.sidebar, BorderSizePixel=}, main)
(side,); (side,,)

 iconF = (, {Name=, Size=.(,,,), Position=.(,,,), BackgroundColor3=Theme.panel2, BorderSizePixel=}, side)
(iconF,); (iconF,,)
 iconImg = (, {Size=.(,,,), BackgroundTransparency=, Image=HEADSHOT}, iconF)
(iconImg,)
(, {Size=.(,,,), Position=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Left}, side)

 nav = (, {Name=, Size=.(,,,-), Position=.(,,,), BackgroundTransparency=, ScrollBarThickness=, CanvasSize=.(,,,), AutomaticCanvasSize=.AutomaticSize.Y}, side)
(, {Padding=.(,), SortOrder=.SortOrder.LayoutOrder}, nav)
(, {PaddingLeft=.(,), PaddingRight=.(,), PaddingTop=.(,), PaddingBottom=.(,)}, nav)

 content = (, {Name=, Size=.(,-,,), Position=.(,,,), BackgroundTransparency=}, main)

 preview = (, {Name=, Size=.(,,,), Position=.(,,,-), BackgroundColor3=Theme.panel, BorderSizePixel=}, sg)
(preview,); (preview); (preview,,)
(preview)
(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.muted, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Left}, preview)

 vp = (, {Name=, Size=.(,-,,-), Position=.(,,,), BackgroundColor3=Theme.panel2, BorderSizePixel=, Ambient=.(,,), LightColor=.(,,)}, preview)
(vp,); (vp,,)
 cam = .(); cam.Parent = vp; vp.CurrentCamera = cam
cam.CFrame = .(.(,,), .(,-,))
 clone
(()
	 char = plr.Character  plr.CharacterAdded:()
	 prev = char.Archivable; char.Archivable = 
	 c = char:(); char.Archivable = prev
	 _, d  (c:())   d:()  d:()  
	c.Parent = vp; clone = c
)
 clone 
	 spin = 
	RunService.RenderStepped:((dt)
		  clone.Parent   
		spin = spin + dt * 
		clone:(.(,,) * .(, spin, ))
	)


 winBtns = (, {Name=, Size=.(,,,), Position=.(,-,,), BackgroundTransparency=}, main)
(, {FillDirection=.FillDirection.Horizontal, Padding=.(,), HorizontalAlignment=.HorizontalAlignment.Right, SortOrder=.SortOrder.LayoutOrder}, winBtns)
 minBtn = (, {Name=, Size=.(,,,), BackgroundColor3=Theme.panel2, Text=, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, BorderSizePixel=, AutoButtonColor=, LayoutOrder=}, winBtns)
(minBtn,); (minBtn,,)
 closeBtn = (, {Name=, Size=.(,,,), BackgroundColor3=Theme.panel2, Text=, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, BorderSizePixel=, AutoButtonColor=, LayoutOrder=}, winBtns)
(closeBtn,); (closeBtn,,)

 mb = (, {Name=, Size=.(,,,), Position=.(,-,,-), BackgroundColor3=Theme.panel, BorderSizePixel=, Visible=}, sg)
(mb,); (mb, Theme.accent, ); (mb,,)
 mbImg = (, {Size=.(,-,,-), Position=.(,,,), BackgroundTransparency=, Image=HEADSHOT}, mb)
(mbImg,)
(()  st = mb:();  st  st.Color = Theme.accent  )

 mbdrag, mbmoved, mbdragStart, mbStartPos
mb.InputBegan:((i)
	 i.UserInputType == .UserInputType.MouseButton1  i.UserInputType == .UserInputType.Touch 
		mbdrag = ; mbmoved = ; mbdragStart = i.Position; mbStartPos = mb.Position
		i.Changed:(()  i.UserInputState == .UserInputState.End  mbdrag =   )
	
)
mb.InputChanged:((i)
	 mbdrag  (i.UserInputType == .UserInputType.MouseMovement  i.UserInputType == .UserInputType.Touch) 
		 d = i.Position - mbdragStart
		 .(d.X) + .(d.Y) >   mbmoved =  
		mb.Position = .(mbStartPos.X.Scale, mbStartPos.X.Offset + d.X, mbStartPos.Y.Scale, mbStartPos.Y.Offset + d.Y)
	
)
mb.InputEnded:((i)
	 i.UserInputType == .UserInputType.MouseButton1  i.UserInputType == .UserInputType.Touch 
		  mbmoved  main.Visible = ; preview.Visible = ; mb.Visible =  
		mbdrag = 
	
)
minBtn.MouseButton1Click:(() mb.Position = main.Position; main.Visible = ; preview.Visible = ; mb.Visible =  )
closeBtn.MouseButton1Click:(() sg:() )

 stats = (, {Name=, Size=.(,,,), AutomaticSize=.AutomaticSize.X, AnchorPoint=.(,), Position=.(,,,), BackgroundColor3=Theme.panel, BackgroundTransparency=, BorderSizePixel=}, sg)
(stats,); (stats); (stats,,)
(, {PaddingLeft=.(,), PaddingRight=.(,)}, stats)
 statLbl = (, {Size=.(,,,), AutomaticSize=.AutomaticSize.X, BackgroundTransparency=, Text=, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Center, TextYAlignment=.TextYAlignment.Center}, stats)
(statLbl,,)
(stats)

 xyz = (, {Name=, Size=.(,,,), Position=.(,,,-), BackgroundColor3=Theme.panel, BackgroundTransparency=, BorderSizePixel=}, sg)
(xyz,); (xyz); (xyz,,)
(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.muted, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Left}, xyz)
 xyzLbl = (, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Left}, xyz)
(xyzLbl,,)
(xyz)

 spd = (, {Name=, Size=.(,,,), Position=.(,,,-), BackgroundColor3=Theme.panel, BackgroundTransparency=, BorderSizePixel=}, sg)
(spd,); (spd); (spd,,)
 spdLbl = (, {Size=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=}, spd)
(spdLbl,,)
(spd)

 wm = (, {Name=, Size=.(,,,), Position=.(,,,-), BackgroundColor3=Theme.panel, BackgroundTransparency=, BorderSizePixel=}, sg)
(wm,); (wm); (wm,,)
 wmImg = (, {Size=.(,,,), Position=.(,,,-), BackgroundTransparency=, Image=HEADSHOT}, wm)
(wmImg,)
(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=plr.DisplayName, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Left}, wm)
(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=..plr.Name, TextColor3=Theme.muted, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, wm)
(wm)

 fontEls = {}
  (parent, on, cb)
	 b = (, {Size=.(,,,), Position=.(,-,,-), BackgroundColor3=on  Theme.accent  Theme.off, Text=, BorderSizePixel=, AutoButtonColor=, ClipsDescendants=}, parent)
	(b,); (b, .(,,), )
	 knob = (, {Size=.(,,,), Position=on  .(,-,,-)  .(,,,-), BackgroundColor3=.(,,), BorderSizePixel=}, b)
	(knob,)
	 state = on
	  ()
		TweenService:(b, TweenInfo.(, .EasingStyle.Quad), {BackgroundColor3 = state  Theme.accent  Theme.off}):()
		TweenService:(knob, TweenInfo.(, .EasingStyle.Quad), {Position = state  .(,-,,-)  .(,,,-)}):()
	
	(); (refresh)
	b.MouseButton1Click:(() state =  state; ();  cb  (state)  )
	 b


 pagesHolder = (, {Name=, Size=.(,-,,-), Position=.(,,,), BackgroundTransparency=}, content)

 tabs = {,,,,,,,,}
 pages = {}
 _, t  (tabs) 
	pages[t] = (, {Name=t.., Size=.(,,,), BackgroundTransparency=, Visible=}, pagesHolder)


 menuPage = pages[]
  (xScale, xOff, widthOff)
	 col = (, {Size=.(,widthOff,,), Position=.(xScale,xOff,,), BackgroundTransparency=, ScrollBarThickness=, CanvasSize=.(,,,), AutomaticCanvasSize=.AutomaticSize.Y}, menuPage)
	(, {Padding=.(,), SortOrder=.SortOrder.LayoutOrder}, col)
	(, {PaddingTop=.(,), PaddingBottom=.(,)}, col)
	 col

 colA = (, , -)
 colB = (, , -)

 groupCounter = 
  (body)
	 n = (body:()  ) + 
	body:(, n)
	 n

  (parent, title)
	groupCounter = groupCounter + 
	 g = (, {Name=..groupCounter, Size=.(,,,), BackgroundColor3=Theme.panel, BorderSizePixel=, LayoutOrder=groupCounter, ClipsDescendants=}, parent)
	(g,); (g); (g,,)
	 head = (, {Name=, Size=.(,,,), BackgroundTransparency=, Text=, AutoButtonColor=}, g)
	 chev = (, {Name=, Size=.(,,,), Position=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.muted, Font=.Font.GothamBold, TextSize=}, g)
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=title, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Left}, g)
	 body = (, {Name=, Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, AutomaticSize=.AutomaticSize.Y}, g)
	(, {Padding=.(,), SortOrder=.SortOrder.LayoutOrder}, body)
	 open = 
	 lastH = 
	  ()
		 open  g.Size = .(,,,  + lastH)  g.Size = .(,,,) 
	
	body:():(()
		 body.AbsoluteSize.Y >   lastH = body.AbsoluteSize.Y 
		()
	)
	head.MouseButton1Click:(()
		open =  open
		body.Visible = open
		chev.Text = open    
		()
	)
	 body

  (body, h)
	 f = (, {Size=.(,,,h), BackgroundColor3=Theme.panel2, BorderSizePixel=, LayoutOrder=(body)}, body)
	(f,); (f,,)
	 f

  (body, label, on, cb)
	 f = (body, )
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=label, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, f)
	(f, on, cb)
	 f

  (body, label, default)
	 f = (body, )
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=label, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, f)
	 kb = (, {Size=.(,,,), Position=.(,-,,-), BackgroundColor3=Theme.panel, Text=default, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, BorderSizePixel=, AutoButtonColor=}, f)
	(kb,); (kb); (kb,,)
	 f

  (body, label, min, max, init, cb, fmt)
	 f = (, {Size=.(,,,), BackgroundColor3=Theme.panel2, BorderSizePixel=, LayoutOrder=(body)}, body)
	(f,); (f,,)
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=label, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, f)
	 valBox = (, {Size=.(,,,), Position=.(,-,,), BackgroundColor3=Theme.panel, BorderSizePixel=}, f)
	(valBox,); (valBox)
	 val = (, {Size=.(,,,), BackgroundTransparency=, Text=fmt  (init)  (init), TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=}, valBox)
	 track = (, {Size=.(,-,,), Position=.(,,,), BackgroundColor3=.(,,), BorderSizePixel=}, f)
	(track,)
	 frac = (init-min)/(max-min)
	 fill = (, {Size=.(frac,,,), BackgroundColor3=Theme.accent, BorderSizePixel=}, track)
	(fill,)
	 handle = (, {Size=.(,,,), AnchorPoint=.(,), Position=.(frac,,,), BackgroundColor3=.(,,), BorderSizePixel=, ZIndex=}, track)
	(handle,); (handle, Theme.accent, )
	(() fill.BackgroundColor3 = Theme.accent;  st = handle:();  st  st.Color = Theme.accent  )
	 dragging = 
	  (x)
		 rel = .((x - track.AbsolutePosition.X) / .(track.AbsoluteSize.X, ), , )
		 v = min + (max-min)*rel
		fill.Size = .(rel,,,)
		handle.Position = .(rel,,,)
		val.Text = fmt  (v)  .(, v)
		(v)
	
	track.InputBegan:((i)
		 i.UserInputType == .UserInputType.MouseButton1  i.UserInputType == .UserInputType.Touch  dragging = ; (i.Position.X) 
	)
	track.InputChanged:((i)
		 dragging  (i.UserInputType == .UserInputType.MouseMovement  i.UserInputType == .UserInputType.Touch)  (i.Position.X) 
	)
	UserInputService.InputEnded:((i)
		 i.UserInputType == .UserInputType.MouseButton1  i.UserInputType == .UserInputType.Touch  dragging =  
	)
	 f

  (body, label, colors, getCurrent, onPick)
	 f = (, {Size=.(,,,), BackgroundColor3=Theme.panel2, BorderSizePixel=, LayoutOrder=(body)}, body)
	(f,); (f,,)
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=label, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, f)
	 row = (, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=}, f)
	(, {FillDirection=.FillDirection.Horizontal, Padding=.(,)}, row)
	 swatches = {}
	 i, col  (colors) 
		 sw = (, {Size=.(,,,), BackgroundColor3=col, Text=, BorderSizePixel=, AutoButtonColor=, LayoutOrder=i}, row)
		(sw,)
		swatches[i] = (sw)
		sw.MouseButton1Click:(()
			(i, col)
			 j, s  (swatches) 
				s.Visible = (j == i)
				s:(, j == i)
			
		)
	
	 j, s  (swatches) 
		 on = (j == ())
		s.Visible = on
		s:(, on)
	
	 f

  (body, label, col, txtcol, cb)
	 b = (, {Size=.(,,,), BackgroundColor3=col, Text=label, TextColor3=txtcol, Font=.Font.GothamMedium, TextSize=, BorderSizePixel=, AutoButtonColor=, LayoutOrder=(body)}, body)
	(b,)
	b.MouseButton1Click:(cb)
	 b

  (body, label, default, cb)
	 f = (, {Size=.(,,,), BackgroundColor3=Theme.panel2, BorderSizePixel=, LayoutOrder=(body)}, body)
	(f,); (f,,)
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=label, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, f)
	 box = (, {Size=.(,,,), Position=.(,-,,), BackgroundColor3=Theme.panel, Text=default, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, BorderSizePixel=, ClearTextOnFocus=, PlaceholderText=}, f)
	(box,); (box); (box,,)
	 hint = (, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.muted, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, f)
	  ()
		 n = (box.Text)
		 n 
			hint.Text = 
			(n)
		
			hint.Text = 
		
	
	box.FocusLost:(commit)
	((default)  )
	 f


 themeList = {
	{name=, bg=.(,,), sidebar=.(,,), panel=.(,,), panel2=.(,,)},
	{name=, bg=.(,,), sidebar=.(,,), panel=.(,,), panel2=.(,,)},
	{name=, bg=.(,,), sidebar=.(,,), panel=.(,,), panel2=.(,,)},
	{name=, bg=.(,,), sidebar=.(,,), panel=.(,,), panel2=.(,,)},
}
 curTheme = 
 accentList = {.(,,), .(,,), .(,,), .(,,), .(,,)}
 curAccent = 

 gMenu = (colA, )
(gMenu, , )
(gMenu, , , , , (v) menuScale.Scale = v , (v)  .(, .(v*+)) )
(gMenu, , , , , (v)  _, e  (fontEls)  e[].TextSize = .(, .(e[]*v + ))  , (v)  .(, .(v*+)) )

 gOverlay = (colA, )
(gOverlay, , , (on) wm.Visible = on )
(gOverlay, , , (on) stats.Visible = on )
(gOverlay, , , (on) spd.Visible = on )
(gOverlay, , , (on) xyz.Visible = on )
(gOverlay, , , )

 gAppear = (colB, )
(gAppear, , {themeList[].panel, themeList[].panel, themeList[].panel, themeList[].panel}, ()  curTheme , (i)
	curTheme = i
	 t = themeList[i]
	Theme.bg = t.bg; Theme.sidebar = t.sidebar; Theme.panel = t.panel; Theme.panel2 = t.panel2
	()
)
(gAppear, , accentList, ()  curAccent , (i, col)
	curAccent = i; Theme.accent = col; ()
)
(gAppear, , .(,,), .(,,), () sg:() )

 configs = (colB, )
 folderRow = (, {Size=.(,,,), BackgroundTransparency=, LayoutOrder=(configs)}, configs)
(, {FillDirection=.FillDirection.Horizontal, Padding=.(,)}, folderRow)
 folderBtns = {}
 i, fn  ({, }) 
	 b = (, {Size=.(,,-,,), BackgroundColor3=Theme.panel2, Text=fn, TextColor3=(i==)  Theme.text  Theme.muted, Font=.Font.GothamMedium, TextSize=, BorderSizePixel=, AutoButtonColor=, LayoutOrder=i}, folderRow)
	(b,); (b,,)
	folderBtns[i] = b
	b.MouseButton1Click:(()  j, fb  (folderBtns)  fb.TextColor3 = (j == i)  Theme.text  Theme.muted  )

 _, n  ({, , }) 
	 b = (, {Size=.(,,,), BackgroundColor3=Theme.panel2, Text=..n, TextColor3=Theme.text, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left, BorderSizePixel=, LayoutOrder=(configs)}, configs)
	(b,); (b,,)


 addonsPage = pages[]
 aScroll = (, {Name=, Size=.(,,,), BackgroundTransparency=, ScrollBarThickness=, CanvasSize=.(,,,), AutomaticCanvasSize=.AutomaticSize.Y}, addonsPage)
(, {Padding=.(,), SortOrder=.SortOrder.LayoutOrder}, aScroll)
(, {PaddingRight=.(,), PaddingTop=.(,), PaddingBottom=.(,)}, aScroll)
 palette = {.(,,), .(,,), .(,,), .(,,), .(,,), .(,,)}
 addonDefs = {
	{key=,  label=},
	{key=, label=},
	{key=, label=},
	{key=,  label=},
	{key=, label=},
}
 _, def  (addonDefs) 
	 card = (, {Size=.(,,,), BackgroundColor3=Theme.panel, BorderSizePixel=}, aScroll)
	(card,); (card); (card,,)
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=def.label, TextColor3=Theme.text, Font=.Font.GothamBold, TextSize=, TextXAlignment=.TextXAlignment.Left}, card)
	 cb = (card, addonState[def.key].enabled, (on) (def.key, on) )
	cb.Position = .(,-,,)
	(, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=, Text=, TextColor3=Theme.muted, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left}, card)
	 row = (, {Size=.(,-,,), Position=.(,,,), BackgroundTransparency=}, card)
	(, {FillDirection=.FillDirection.Horizontal, Padding=.(,)}, row)
	 swatches = {}
	 i, col  (palette) 
		 sw = (, {Size=.(,,,), BackgroundColor3=col, Text=, BorderSizePixel=, AutoButtonColor=, LayoutOrder=i}, row)
		(sw,)
		 sel = (sw)
		 i ==   sel.Visible = ; sel:(, ) 
		swatches[i] = sel
		sw.MouseButton1Click:(()
			(def.key, col)
			 j, s  (swatches) 
				s.Visible = (j == i)
				s:(, j == i)
			
		)
	


 startBhop, stopBhop

 miscPage = pages[]
 mScroll = (, {Name=, Size=.(,,,), BackgroundTransparency=, ScrollBarThickness=, CanvasSize=.(,,,), AutomaticCanvasSize=.AutomaticSize.Y}, miscPage)
(, {Padding=.(,), SortOrder=.SortOrder.LayoutOrder}, mScroll)
(, {PaddingRight=.(,), PaddingTop=.(,), PaddingBottom=.(,)}, mScroll)
 bhopGroup = (mScroll, )
(bhopGroup, , , (on)
  on 
  ()
 
  ()
 
)

 helpersPage = pages[]
 hScroll = (, {Name=, Size=.(,,,), BackgroundTransparency=, ScrollBarThickness=, CanvasSize=.(,,,), AutomaticCanvasSize=.AutomaticSize.Y}, helpersPage)
(, {Padding=.(,), SortOrder=.SortOrder.LayoutOrder}, hScroll)
(, {PaddingRight=.(,), PaddingTop=.(,), PaddingBottom=.(,)}, hScroll)
 hGroup = (hScroll, )

(hGroup, , , (on)
	(on)
)

(hGroup, , , (on)
	partCheckerOn = on
)
(hGroup, , , (n)
	partVelLimit = n
)
(hGroup, , , (n)
	partRestoreTime = n
)

 swordLockOn = 
 swordLockHeartbeat = 
 swordLockHumanoid = 
 swordTargetRange = 
 swordLockShake = 
 swordLockSpeed = 
 swordAutoLunge = 
 swordJumpTarget = 
 swordTargetWasJumping = 
 swordAutoWalk = 
 swordAutoWalkHeartbeat = 
 swordNearestOpponent

 bhopOn = 
 bhopHeartbeat = 
 bhopCharacter = 
 bhopOriginalWalkSpeed = 
 BHOP_WALK_SPEED = 
 BHOP_HANDOFF_DISTANCE = 

  ()
 swordAutoWalk = 
 RunService:()
 swordAutoWalkHeartbeat = 
  char = plr.Character
  hum = char  char:()
  hum  hum:(.zero, ) 


  ()
 RunService:()
 swordAutoWalk = 
 swordAutoWalkHeartbeat = 
 RunService:(, .RenderPriority.Character.Value + , ()
    swordAutoWalk   
   char = plr.Character
   root = char  char:()
   hum = char  char:()
    root   hum  hum.Health <=  
   ()
   
  
   target = (root.Position)
    target   target.Parent 
   
  

  
   targetCF = target.CFrame
   behindLeft = target.Position - targetCF.LookVector *  - targetCF.RightVector * 
   flatGoal = .(behindLeft.X, root.Position.Y, behindLeft.Z)
   offset = flatGoal - root.Position
   offset.Magnitude >  
   hum:(.(offset.X, , offset.Z).Unit, )
  
   hum:(.zero, )
  
 )

 swordNextLunge = 
 swordLungeBusy = 
 swordRigsFolder = :()

 (rootPos)
  best, bestDist = , swordTargetRange
  checked = {}
   (character)
    character  character == plr.Character  checked[character]   
  checked[character] = 
   hum = character:()
   hrp = character:()
   hum  hrp  hum.Health >  
    d = (hrp.Position - rootPos).Magnitude
    d < bestDist 
    bestDist = d
    best = hrp
   
  
 
  _, otherPlayer  (Players:()) 
   otherPlayer ~= plr 
   (otherPlayer.Character)
  
 
  _, d  (:()) 
   d:()  d ~= plr.Character   Players:(d) 
    d:()  d:() 
    (d)
   
  
 
  best


 ()
 bhopOn = 
  bhopHeartbeat 
  bhopHeartbeat:()
  bhopHeartbeat = 
 
  char = plr.Character
  hum = char  char:()
  hum 
   char == bhopCharacter  bhopOriginalWalkSpeed ~=  
   hum.WalkSpeed = bhopOriginalWalkSpeed
  
  hum.Jump = 
 
 bhopCharacter = 
 bhopOriginalWalkSpeed = 


 ()
  bhopHeartbeat 
  bhopHeartbeat:()
  bhopHeartbeat = 
 
 bhopOn = 
 bhopCharacter = 
 bhopOriginalWalkSpeed = 
 bhopHeartbeat = RunService.Heartbeat:(()
    bhopOn   
   char = plr.Character
   hum = char  char:()
   root = char  char:()
    char   hum   root  hum.Health <=    

   char ~= bhopCharacter 
   bhopCharacter = char
   bhopOriginalWalkSpeed = hum.WalkSpeed
  
  hum.WalkSpeed = BHOP_WALK_SPEED

   handoff = 
   swordJumpTarget  swordNearestOpponent 
    target = (root.Position)
    target  target.Parent 
     delta = target.Position - root.Position
     flatDistance = .(delta.X, , delta.Z).Magnitude
    handoff = flatDistance <= BHOP_HANDOFF_DISTANCE
   
  

    handoff  hum.FloorMaterial ~= .Material.Air 
   hum.Jump = 
   hum:(.HumanoidStateType.Jumping)
  
 )


  (character)
  fallback = 
  _, child  (character:()) 
   child:() 
    child.Name:():()   child 
   fallback = fallback  child
  
 
  fallback


  (character)
  swordLungeBusy   swordAutoLunge   
  tool = (character)
   tool   
 swordLungeBusy = 
 .(()
  tool:()
  .()
   swordAutoLunge  tool.Parent == character 
   tool:()
  
  .()
  swordLungeBusy = 
 )


  ()
 swordLockOn = 
 swordTargetWasJumping = 
  swordLockHeartbeat 
  swordLockHeartbeat:()
  swordLockHeartbeat = 
 
  swordLockHumanoid 
  swordLockHumanoid.AutoRotate = 
  swordLockHumanoid = 
 


  ()
  swordLockHeartbeat 
  swordLockHeartbeat:()
  swordLockHeartbeat = 
 
 swordLockOn = 
 swordTargetWasJumping = 
  char = plr.Character
   char  ()  
 swordLockHumanoid = char:()
  root = char:()
   swordLockHumanoid   root  swordLockHumanoid.Health <=  
  ()
  
 
 swordLockHumanoid.AutoRotate = 
 swordLockHeartbeat = RunService.Heartbeat:(()
   c = plr.Character
   r = c  c:()
   h = c  c:()
    r   h  h.Health <=  
   ()
   
  
   target = (r.Position)
    target   target.Parent 
   h.AutoRotate = 
   swordTargetWasJumping = 
   
  
  h.AutoRotate = 

   targetHumanoid = target.Parent:()
   swordJumpTarget  targetHumanoid 
    targetState = targetHumanoid:()
    jumping = targetState == .HumanoidStateType.Jumping  targetState == .HumanoidStateType.Freefall
    jumping   swordTargetWasJumping  h.FloorMaterial ~= .Material.Air 
    h.Jump = 
   
   swordTargetWasJumping = jumping
  
   swordTargetWasJumping = 
  

   dir = target.Position - r.Position
   flat = .(dir.X, , dir.Z)
   distance = flat.Magnitude
   distance >  
    theta = .(.( / distance, -, ))
    directGoal = .(r.Position, r.Position + flat)
    correctedGoal = directGoal * .(, theta, )
    swordLockShake >  
     t = .() * 
     shake = .(swordLockShake)
    
    correctedGoal = correctedGoal * .(, .(t, , ) * shake, )
   
   r.CFrame = r.CFrame:(correctedGoal, swordLockSpeed)
  

   swordAutoLunge  distance <=   .() >= swordNextLunge 
   swordNextLunge = .() + 
   (c)
  
 )


 swordGroup = (hScroll, )
(swordGroup, , , (on)
  on 
  ()
 
  ()
 
)

(swordGroup, , , (n)
 swordTargetRange = .(, n)
)

(swordGroup, , , , , (v)
 swordLockShake = v
, (v)
  .(, v)
)

(swordGroup, , , , , (v)
 swordLockSpeed = v
, (v)
  .(, v)
)

(swordGroup, , , (on)
 swordAutoLunge = on
)

(swordGroup, , , (on)
 swordJumpTarget = on
 swordTargetWasJumping = 
)

(swordGroup, , , (on)
  on 
  ()
 
  ()
 
)

 swordOrbitOn = 
 swordOrbitToken = 

  (rootPos)
  target = (rootPos)
  target  target.Parent 
   hum = target.Parent:()
   hum  hum.Health >    target, hum 
 
  , 


  ()
 swordOrbitOn = 
 swordOrbitToken = swordOrbitToken + 


  ()
 swordOrbitOn = 
 swordOrbitToken = swordOrbitToken + 
  myToken = swordOrbitToken
 .(()
   teleports = 
   swordOrbitOn  myToken == swordOrbitToken 
    char = plr.Character
    root = char  char:()
    hum = char  char:()
     root   hum  hum.Health <=  
    ()
    
   

   swordRigsFolder = swordRigsFolder  :()
    target, targetHum = (root.Position)
     target   targetHum 
    .()
    
   

    angle = .() * .pi * 
    offset = .(.(angle) * , , .(angle) * )
    destination = target.Position + offset
   root.CFrame = .(destination, target.Position)
   teleports = teleports + 
   .()

     swordOrbitOn  myToken ~= swordOrbitToken   
    targetHum.Health <=    target.Parent 
    ()
    
   

    teleports %  ==  
     outAngle = .() * .pi * 
     outOffset = .(.(outAngle) * , , .(outAngle) * )
     outDestination = target.Position + outOffset
    root.CFrame = .(outDestination, target.Position)
    .()
      swordOrbitOn  myToken ~= swordOrbitToken   
     targetHum.Health <=    target.Parent 
     ()
     
    
    root.CFrame = .(target.Position + offset, target.Position)
   

   .()
  
 )


(swordGroup, , , (on)
  on 
  ()
 
  ()
 
)

 name, p  (pages) 
	 name ~=   name ~=   name ~=  
		(, {Size=.(,,,), BackgroundTransparency=, Text=name, TextColor3=Theme.muted, Font=.Font.GothamBold, TextSize=}, p)
	


 btns = {}
  (name)
	 n, p  (pages)  p.Visible = (n == name) 
	 n, b  (btns)  b.TextColor3 = (n == name)  Theme.text  Theme.muted 

 _, t  (tabs) 
	 b = (, {Name=t.., Size=.(,,,), BackgroundTransparency=, Text=t, TextColor3=Theme.muted, Font=.Font.GothamMedium, TextSize=, TextXAlignment=.TextXAlignment.Left, AutoButtonColor=}, nav)
	btns[t] = b
	b.MouseButton1Click:(() (t) )

()

 _, d  (sg:()) 
	 d:()  d:()  d:() 
		.(fontEls, {d, d.TextSize})
	


 frames, accum, spdAccum, sessionTime = , , , 
RunService.RenderStepped:((dt)
	frames = frames + ; accum = accum + dt; sessionTime = sessionTime + dt
	 accum >=  
		 mins = .(sessionTime / )
		 secs = .(sessionTime % )
		statLbl.Text =  .. .(frames/accum + ) ..  .. .(, mins, secs) ..  .. #Players:()
		frames = ; accum = 
	
	spdAccum = spdAccum + dt
	 spdAccum >=  
		spdAccum = 
		 char = plr.Character
		 hrp = char  char:()
		 v = hrp  hrp.AssemblyLinearVelocity  .zero
		spdLbl.Text =  .. .(.(v.X*v.X + v.Z*v.Z) + )
		 pos = hrp  hrp.Position  .zero
		xyzLbl.Text = .(, .(pos.X), .(pos.Y), .(pos.Z))
	
	 #crownParts >  
		 k, damp = , 
		 _, cp  (crownParts) 
			 head, part = cp.anchor, cp.part
			 head  part  head.Parent  part.Parent 
				 hrp = plr.Character  plr.Character:()
				 worldVel = hrp  hrp.AssemblyLinearVelocity  .zero
				 localVel = head.CFrame:(worldVel)
				 desired = .(, cp.baseY  , .(-localVel.Z * , , ))
				 targetTilt = .(-localVel.Z * , , )
				 pos = cp.pos  desired
				 vel = cp.vel  .zero
				 a = (desired - pos) * k - vel * damp
				vel = vel + a * dt
				pos = pos + vel * dt
				cp.pos = pos
				cp.vel = vel
				 t = cp.tilt  
				 tv = cp.tiltVel  
				 ta = (targetTilt - t) * k - tv * damp
				tv = tv + ta * dt
				t = t + tv * dt
				cp.tilt = t
				cp.tiltVel = tv
				part.CFrame = head.CFrame * .(pos) * .(t, , )
			
		
	
	 addonState.step.enabled 
		 char = plr.Character
		 hrp = char  char:()
		 hrp 
			 v = hrp.AssemblyLinearVelocity
			 flat = .(v.X, , v.Z)
			 hspeed = flat.Magnitude
			 hspeed >  
				stepDistance = stepDistance + hspeed * dt
				 stepDistance >= STEP_DIST 
					stepDistance = 
					stepSide = -stepSide
					 right = flat.Unit:(.(,,))
					 origin = hrp.Position + right * (FOOT_OFFSET * stepSide)
					(origin, flat, stepSide, addonState.step.color)
				
			
				stepDistance = 
			
		
	
)