free open source Auto parry

 success, err = (()

 _, name  ({, , , }) 
	 old = :():(name)
	 old  old:() 


 Players = :()
 RunService = :()
 UIS = :()
 VIM = :()
 TweenService = :()
 Player = Players.LocalPlayer
 Camera = .CurrentCamera

  ().BWS  ().BWS = {} 

 defaults = {
	Enabled = ,
	PingComp = ,
	ExtraMs = ,
	FireDebounce = ,
	MaxParryDistance = ,
	FastBallDistance = ,
	FastBallSpeed = ,
	ClashEnabled = ,
	ClashSpeedMult = ,
	ClashMinRate = ,
	ClashMaxRate = ,
	AutoCurve = ,
	CurveDir = ,
	CurvePower = ,
	ShowRing = ,
	BallESP = ,
	OnlyTargetedAtMe = ,

	TriggerBot = ,
	TriggerMode = ,
	TriggerFOV = ,
	TriggerRange = ,
	TriggerDelay = ,
	TriggerHoldKey = ,
	TriggerShowFOV = ,
	TriggerESP = ,
	TriggerOnlyAlive = ,

	AutoClicker = ,
	AutoClickerCPS = ,
}

 k, v  (defaults) 
	 ().BWS[k] ==   ().BWS[k] = v 

 CFG = ().BWS

 State = {
	parriedBalls = {},
	lastParry = ,
	lastFireTime = ,
	ballCache = {},
	prevBallVel = {},
	prevBallPos = {},
	velHistory = {},
	clashCount = {},
	inClash = ,
	clashUntil = ,
	clashRate = ,
	frame = ,
	globalLock = ,
	ping = ,
	playerVel = .zero,
	prevPlayerPos = .zero,
	blockConns = {},
	lastClashFire = ,
	triggerHeld = ,
	lastTriggerFire = ,
	triggerTarget = ,
	triggerHighlight = ,
	autoClickerEnabled = ,
	lastAutoClick = ,
}

 ESPFolder = .()
ESPFolder.Name = 
ESPFolder.Parent = :()

 RingFolder = .()
RingFolder.Name = 
RingFolder.Parent = 

 ActiveESP = {}

.(()
	  
		.()
		(()
			 stats = :()
			 pms = stats.Network.ServerStatsItem[]:()
			State.ping = .(pms / , , )
		)
	
)

  ()
	State.blockConns = {}
	 gui = Player:()
	  gui   
	 hotbar = gui:()
	  hotbar   
	 btn = hotbar:()
	  btn   
	  getconnections   
	(()
		 _, sig  ({, , }) 
			 _, conn  ((btn[sig])) 
				.(State.blockConns, conn)
			
		
	)


.(, CacheBlock)
Player.ChildAdded:((c)
	 c.Name ==   .(, CacheBlock) 
)

  ()
	 now = ()
	 now - State.lastFireTime < CFG.FireDebounce    
	 now < State.globalLock    

	State.lastFireTime = now
	State.globalLock = now + 

	 #State.blockConns >  
		 _, conn  (State.blockConns) 
			(() conn:() )
		
		 
	

	()
	 #State.blockConns >  
		 _, conn  (State.blockConns) 
			(() conn:() )
		
		 
	

	(()
		VIM:(, , , , , )
		VIM:(, , , , , )
	)
	 


  ()
	(()
		VIM:(, , , , , )
		VIM:(, , , , , )
	)


UIS.InputBegan:((input, gpe)
	 gpe   
	 input.KeyCode == .KeyCode.Four 
		State.autoClickerEnabled =  State.autoClickerEnabled
		(State.autoClickerEnabled    )
	
)

RunService.Heartbeat:(()
	  CFG.AutoClicker   State.autoClickerEnabled   
	 now = ()
	 interval =  / .(CFG.AutoClickerCPS, , )
	 now - State.lastAutoClick >= interval 
		State.lastAutoClick = now
		()
	
)

  ()
	 char = Player.Character
	 HRP = char  char:()
	  HRP    

	 mode = CFG.TriggerMode
	 mousePos = UIS:()
	 camPos = Camera.CFrame.Position
	 look = Camera.CFrame.LookVector
	 best, bestScore = , .huge

	 _, p  (Players:()) 
		 p ~= Player  p.Character 
			 h = p.Character:()
			 hum = p.Character:()
			 h  hum  ( CFG.TriggerOnlyAlive  hum.Health > ) 
				 dist = (HRP.Position - h.Position).Magnitude
				 sp, onScreen = Camera:(h.Position)

				 mode ==  
					 onScreen 
						 d = (.(sp.X, sp.Y) - mousePos).Magnitude
						 d <   d < bestScore 
							best, bestScore = p, d
						
					
				 mode ==  
					 onScreen 
						 d = (.(sp.X, sp.Y) - mousePos).Magnitude
						 d <= CFG.TriggerFOV  d < bestScore 
							best, bestScore = p, d
						
					
				 mode ==  
					 dist <= CFG.TriggerRange 
						 toEnemy = (h.Position - camPos)
						 dir = toEnemy.Magnitude >   toEnemy.Unit  .zero
						 dot = look:(dir)
						 dot >   dist < bestScore 
							best, bestScore = p, dist
						
					
				
			
		
	
	 best


  ()
	 now = ()
	 now - State.lastTriggerFire < CFG.TriggerDelay    
	 () 
		State.lastTriggerFire = now
		State.lastParry = now
		 
	
	 


 TriggerSG = .()
TriggerSG.Name = 
TriggerSG.ResetOnSpawn = 
TriggerSG.IgnoreGuiInset = 
TriggerSG.Parent = :()

 FOVCircle = .()
FOVCircle.Size = .(, CFG.TriggerFOV * , , CFG.TriggerFOV * )
FOVCircle.AnchorPoint = .(, )
FOVCircle.Position = .(, , , )
FOVCircle.BackgroundTransparency = 
FOVCircle.BorderSizePixel = 
FOVCircle.Visible = 
FOVCircle.Parent = TriggerSG
.(, FOVCircle).CornerRadius = .(, )
 fovStroke = .(, FOVCircle)
fovStroke.Color = .(, , )
fovStroke.Thickness = 
fovStroke.Transparency = 

  ()
	 show = CFG.TriggerBot  CFG.TriggerShowFOV  (CFG.TriggerMode ==   CFG.TriggerMode == )
	FOVCircle.Visible = show
	 show 
		 r = (CFG.TriggerMode == )    CFG.TriggerFOV
		FOVCircle.Size = .(, r * , , r * )
		 mp = UIS:()
		FOVCircle.Position = .(, mp.X, , mp.Y)
		fovStroke.Color = State.triggerTarget  .(, , )  .(, , )
	


  (target)
	 State.triggerHighlight 
		(() State.triggerHighlight:() )
		State.triggerHighlight = 
	
	  CFG.TriggerESP   target   target.Character   
	 h = target.Character:()
	  h   
	 box = .()
	box.Adornee = h
	box.Size = .(, , )
	box.Color3 = .(, , )
	box.Transparency = 
	box.ZIndex = 
	box.Parent = h
	State.triggerHighlight = box


UIS.InputBegan:((input, gpe)
	 gpe   
	 CFG.TriggerHoldKey ~=  
		 ok, code = (()  .KeyCode[CFG.TriggerHoldKey] )
		 ok  input.KeyCode == code  State.triggerHeld =  
	
)

UIS.InputEnded:((input)
	 CFG.TriggerHoldKey ~=  
		 ok, code = (()  .KeyCode[CFG.TriggerHoldKey] )
		 ok  input.KeyCode == code  State.triggerHeld =  
	
)

  (ball)
	 z = ball:()
	 z 
		 vv = z:()
		 vv 
			 ok, val = (()
				 vv:()   vv.Value 
				 (vv.VectorVelocity) ==    vv.VectorVelocity 
			)
			 ok  val  (val) ==    val 
		
	
	 ball.AssemblyLinearVelocity


  (ball, vel)
	  State.velHistory[ball]  State.velHistory[ball] = {} 
	 hist = State.velHistory[ball]
	.(hist, , vel)
	 #hist >   .(hist) 


  (ball)
	 hist = State.velHistory[ball]
	  hist  #hist <     
	 a, b = hist[], hist[]
	 a.Magnitude <   b.Magnitude <     
	 a.Unit:(b.Unit) < 


  (obj)
	  obj:()    
	 obj:()    
	 n = obj.Name:()
	 n:() 
		 (obj:()  obj.Shape == .PartType.Ball)  obj:() 
			 
		
	
	 


  (obj)
	State.ballCache[obj] = 
	State.parriedBalls[obj] = 
	State.prevBallPos[obj] = 
	State.prevBallVel[obj] = 
	State.velHistory[obj] = 
	State.clashCount[obj] = 
	 ActiveESP[obj] 
		ActiveESP[obj]:()
		ActiveESP[obj] = 
	


  (obj)
	 State.ballCache[obj]   
	  (obj)   
	State.ballCache[obj] = 
	obj.AncestryChanged:(()
		  obj:()  (obj) 
	)


.(()
	 _, d  (:())  (TrackObj, d) 
)
.DescendantAdded:((obj) (TrackObj, obj) )

  (ball)
	 ballPos = ball.Position
	 ballVel = (ball)
	 ballVel.Magnitude <     
	 fwd = ballVel.Unit
	 HRP = Player.Character  Player.Character:()
	 dir = CFG.CurveDir
	 pwr = CFG.CurvePower

	 dir ==   HRP 
		 best, bestD = , .huge
		 _, p  (Players:()) 
			 p ~= Player  p.Character 
				 h = p.Character:()
				 hum = p.Character:()
				 h  hum  hum.Health >  
					 d = (HRP.Position - h.Position).Magnitude
					 d < bestD  bestD = d; best = h 
				
			
		
		 best   best.Position + .(, , ) 
		dir = 
	

	 dir ==  
		dir = ({, , })[.()]
	

	 dir ==    ballPos + fwd *  + .(, pwr, )
	 dir ==    ballPos + fwd *  + .(, -pwr, )
	 dir ==  
		 left = .(, , ):(fwd)
		 left.Magnitude >   left = left.Unit  left = .(, , ) 
		 ballPos + fwd *  + left * pwr
	 dir ==  
		 right = fwd:(.(, , ))
		 right.Magnitude >   right = right.Unit  right = .(, , ) 
		 ballPos + fwd *  + right * pwr
	
	 ballPos + fwd *  + .(, pwr, )


  (worldPos)
	 sp, onScreen = Camera:(worldPos)
	 onScreen   sp.X, sp.Y 
	 vp = Camera.ViewportSize
	 center = .(vp.X/, vp.Y/)
	 d = .(sp.X, sp.Y) - center
	 d.Magnitude >  
		 edge = center + d.Unit * .(vp.X, vp.Y) * 
		 edge.X, edge.Y
	
	 , 


  (ball, useCurve)
	 now = ()
	 now < State.globalLock    
	 cd = State.parriedBalls[ball]  
	 now < cd    

	 useCurve  CFG.AutoCurve 
		 target = (ball)
		 target 
			 cx, cy = (target)
			 mp = UIS:()
			 cx  mousemoveabs 
				(() (cx, cy) )
				()
				(() (mp.X, mp.Y) )
			
				()
			
		
			()
		
	
		()
	

	State.lastParry = now
	State.parriedBalls[ball] = now + (State.inClash    )
	 


  (ball, speed, flipped)
	 cd = State.clashCount[ball]
	  cd 
		cd = {hits = , lastFlip = }
		State.clashCount[ball] = cd
	
	 flipped 
		cd.hits = cd.hits + 
		cd.lastFlip = ()
	

	 now = ()
	 clash = (cd.hits >=   (now - cd.lastFlip) < )  speed > 

	 clash 
		State.inClash = 
		State.clashUntil = now + 
		 normalized = .((speed - ) / , , )
		 rate = CFG.ClashMaxRate - (CFG.ClashMaxRate - CFG.ClashMinRate) * normalized
		State.clashRate = .(rate / CFG.ClashSpeedMult, CFG.ClashMinRate, CFG.ClashMaxRate)
	
	 clash


  (ball, pPos)
	 CFG.OnlyTargetedAtMe 
		 target = ball:()
		 target ~= Player.Name    
	

	 bPos = ball.Position
	 bVel = (ball)
	 speed = bVel.Magnitude
	 speed <     

	 toPlayer = pPos - bPos
	 dist = toPlayer.Magnitude
	 dist <    , dist, speed, bVel,  

	 toPlayerDir = toPlayer / dist
	 dot = bVel.Unit:(toPlayerDir)
	 curve = (ball)
	 minDot = curve    

	 dot < minDot    

	 maxDist = (speed > CFG.FastBallSpeed)  CFG.FastBallDistance  CFG.MaxParryDistance
	 dist > maxDist    

	 , dist, speed, bVel, dot


  (ball, pPos, pVel)
	 bPos = ball.Position
	 bVel = (ball)
	 relVel = bVel - pVel
	 toP = pPos - bPos
	 dist = toP.Magnitude
	 dist <     
	 closing = relVel:(toP.Unit)
	 closing <=     
	 dist / closing


.(()
	  
		.()
		 State.inClash  CFG.Enabled  CFG.ClashEnabled 
			 now = ()
			 now > State.clashUntil 
				State.inClash = 
			
				 HRP = Player.Character  Player.Character:()
				 HRP 
					 pPos = HRP.Position
					 hasThreat = 
					 ball  (State.ballCache) 
						 ball  ball.Parent  (ball, pPos) 
							hasThreat = 
							
						
					
					 hasThreat  (now - State.lastClashFire) >= State.clashRate 
						State.lastClashFire = now
						()
						State.lastParry = now
					  hasThreat 
						State.inClash = 
					
				
			
		
	
)

  (ball)
	 ActiveESP[ball]   
	 bg = .()
	bg.Adornee = ball
	bg.Size = .(, , , )
	bg.StudsOffset = .(, , )
	bg.AlwaysOnTop = 
	bg.Parent = ESPFolder
	 tl = .(, bg)
	tl.Name = 
	tl.Size = .(, , , )
	tl.BackgroundTransparency = 
	tl.TextColor3 = .(, , )
	tl.Font = .Font.GothamBold
	tl.TextSize = 
	tl.TextStrokeTransparency = 
	ActiveESP[ball] = bg


  (ball, pPos)
	 bg = ActiveESP[ball]
	  bg   
	 tl = bg:()
	  tl   
	 target = ball:()
	 dist = .((pPos - ball.Position).Magnitude)
	 spd = .((ball).Magnitude)
	 target == Player.Name 
		tl.Text =  .. dist ..  .. spd
		tl.TextColor3 = .(, , )
	
		tl.Text = (target  ) ..  .. dist
		tl.TextColor3 = .(, , )
	


 RING_SEG = 
 RingParts = {}
 ringRadius = 
 ringColor = .(, , )
 cachedFloorY, lastFloorT = , 
 rayP = RaycastParams.()
rayP.FilterType = .RaycastFilterType.Exclude

  ()
	 _, p  (RingParts)  (() p:() ) 
	RingParts = {}
	 i = , RING_SEG 
		 s = .()
		s.Anchored = 
		s.CanCollide = 
		s.CanTouch = 
		s.CanQuery = 
		s.CastShadow = 
		s.Size = .(, , )
		s.Material = .Material.Neon
		s.Color = .(, , )
		s.Transparency = 
		s.Parent = RingFolder
		RingParts[i] = s
	

()

  (pos)
	 now = ()
	 now - lastFloorT <    cachedFloorY 
	lastFloorT = now
	 filterList = {Player.Character}
	 _, p  (RingParts)  filterList[#filterList+] = p 
	rayP.FilterDescendantsInstances = filterList
	 r = :(pos + .(, , ), .(, -, ), rayP)
	cachedFloorY = r  (r.Position.Y + )  (pos.Y - )
	 cachedFloorY


  (hrp, closeDist, state)
	  CFG.ShowRing   CFG.Enabled 
		 i = , RING_SEG   RingParts[i]  RingParts[i].Transparency =   
		
	
	 targetR =  +  * .(closeDist / , , )
	ringRadius = ringRadius + (targetR - ringRadius) * 
	 tc = state ==   .(, , )
		 state ==   .(, , )
		 state ==   .(, , )
		 .(, , )
	ringColor = ringColor:(tc, )
	 fy = (hrp)
	 segLen = .(( * .pi * ringRadius) / RING_SEG, )
	 tr = state ==     state ==     state ==     
	 i = , RING_SEG 
		 a = (i / RING_SEG) * .pi * 
		 s = RingParts[i]
		 s 
			s.Size = .(segLen, , )
			s.CFrame = .(hrp.X + .(a)*ringRadius, fy, hrp.Z + .(a)*ringRadius) * .(, -a + .pi/, )
			s.Color = ringColor
			s.Transparency = tr
		
	



 ACCENT = .(, , )
 ACCENT2 = .(, , )
 BG = .(, , )
 BG2 = .(, , )
 BG3 = .(, , )
 TXT = .(, , )
 DIM = .(, , )

 SG = .()
SG.Name = 
SG.ResetOnSpawn = 
SG.ZIndexBehavior = .ZIndexBehavior.Sibling
SG.IgnoreGuiInset = 
SG.Parent = :()

 Pill = .()
Pill.Size = .(, , , )
Pill.Position = .(, , , -)
Pill.BackgroundColor3 = BG
Pill.Text = 
Pill.TextColor3 = .(,,)
Pill.TextSize = 
Pill.Font = .Font.GothamBold
Pill.BorderSizePixel = 
Pill.Active = 
Pill.Draggable = 
Pill.Parent = SG
.(, Pill).CornerRadius = .(, )
.(, Pill).Color = ACCENT

 Panel = .()
Panel.Size = .(, , , )
Panel.Position = .(, , , -)
Panel.BackgroundColor3 = BG
Panel.BorderSizePixel = 
Panel.ClipsDescendants = 
Panel.Active = 
Panel.Draggable = 
Panel.Visible = 
Panel.Parent = SG
.(, Panel).CornerRadius = .(, )
 pStroke = .(, Panel)
pStroke.Color = ACCENT
pStroke.Thickness = 

 Header = .(, Panel)
Header.Size = .(, , , )
Header.BackgroundColor3 = BG2
Header.BorderSizePixel = 
.(, Header).CornerRadius = .(, )

 TitleLbl = .(, Header)
TitleLbl.Size = .(, -, , )
TitleLbl.Position = .(, , , )
TitleLbl.BackgroundTransparency = 
TitleLbl.Text = 
TitleLbl.TextColor3 = .(,,)
TitleLbl.Font = .Font.GothamBold
TitleLbl.TextSize = 
TitleLbl.TextXAlignment = .TextXAlignment.Left

 Dot = .(, Header)
Dot.Size = .(, , , )
Dot.Position = .(, -, , -)
Dot.BackgroundColor3 = .(, , )
Dot.BorderSizePixel = 
.(, Dot).CornerRadius = .(, )

 TabBar = .(, Panel)
TabBar.Size = .(, -, , )
TabBar.Position = .(, , , )
TabBar.BackgroundTransparency = 

 TabContent = .(, Panel)
TabContent.Size = .(, -, , -)
TabContent.Position = .(, , , )
TabContent.BackgroundTransparency = 
TabContent.ClipsDescendants = 

 tabs = {, , , , }
 tabFrames, tabButtons = {}, {}

 _, name  (tabs) 
	 page = .(, TabContent)
	page.Size = .(, , , )
	page.BackgroundTransparency = 
	page.BorderSizePixel = 
	page.ScrollBarThickness = 
	page.ScrollBarImageColor3 = ACCENT
	page.AutomaticCanvasSize = .AutomaticSize.Y
	page.Visible = (name == )
	.(, page).Padding = .(, )
	 pad = .(, page)
	pad.PaddingLeft = .(, )
	pad.PaddingRight = .(, )
	pad.PaddingTop = .(, )
	tabFrames[name] = page


 tabLay = .(, TabBar)
tabLay.FillDirection = .FillDirection.Horizontal
tabLay.Padding = .(, )

 _, name  (tabs) 
	 tb = .(, TabBar)
	tb.Size = .(, , , )
	tb.BackgroundColor3 = (name == )  ACCENT  BG3
	tb.Text = name
	tb.TextColor3 = TXT
	tb.Font = .Font.GothamBold
	tb.TextSize = 
	tb.BorderSizePixel = 
	tb.AutoButtonColor = 
	.(, tb).CornerRadius = .(, )
	tabButtons[name] = tb
	tb.MouseButton1Click:(()
		 n, f  (tabFrames) 
			f.Visible = (n == name)
			tabButtons[n].BackgroundColor3 = (n == name)  ACCENT  BG3
		
	)


  (parent, text, key, order)
	 btn = .(, parent)
	btn.Size = .(, , , )
	btn.BackgroundColor3 = BG3
	btn.BorderSizePixel = 
	btn.Text = 
	btn.AutoButtonColor = 
	btn.LayoutOrder = order  
	.(, btn).CornerRadius = .(, )

	 lbl = .(, btn)
	lbl.Size = .(, -, , )
	lbl.Position = .(, , , )
	lbl.BackgroundTransparency = 
	lbl.Text = text
	lbl.TextColor3 = TXT
	lbl.Font = .Font.Gotham
	lbl.TextSize = 
	lbl.TextXAlignment = .TextXAlignment.Left

	 track = .(, btn)
	track.Size = .(, , , )
	track.Position = .(, -, , -)
	track.BackgroundColor3 = CFG[key]  ACCENT  DIM
	track.BorderSizePixel = 
	.(, track).CornerRadius = .(, )

	 knob = .(, track)
	knob.Size = .(, , , )
	knob.Position = CFG[key]  .(, -, , -)  .(, , , -)
	knob.BackgroundColor3 = .(,,)
	knob.BorderSizePixel = 
	.(, knob).CornerRadius = .(, )

	btn.MouseButton1Click:(()
		CFG[key] =  CFG[key]
		TweenService:(track, TweenInfo.(), {BackgroundColor3 = CFG[key]  ACCENT  DIM}):()
		TweenService:(knob, TweenInfo.(, .EasingStyle.Back), {
			Position = CFG[key]  .(, -, , -)  .(, , , -)
		}):()
	)


  (parent, text, key, mn, mx, stp, order)
	 f = .(, parent)
	f.Size = .(, , , )
	f.BackgroundColor3 = BG3
	f.BorderSizePixel = 
	f.LayoutOrder = order  
	.(, f).CornerRadius = .(, )

	 lbl = .(, f)
	lbl.Size = .(, -, , )
	lbl.Position = .(, , , )
	lbl.BackgroundTransparency = 
	lbl.Text = text
	lbl.TextColor3 = TXT
	lbl.Font = .Font.Gotham
	lbl.TextSize = 
	lbl.TextXAlignment = .TextXAlignment.Left

	 val = .(, f)
	val.Size = .(, , , )
	val.Position = .(, -, , )
	val.BackgroundTransparency = 
	val.Text = (CFG[key])
	val.TextColor3 = ACCENT2
	val.Font = .Font.GothamBold
	val.TextSize = 

	 bar = .(, f)
	bar.Size = .(, -, , )
	bar.Position = .(, , , )
	bar.BackgroundColor3 = .(, , )
	bar.BorderSizePixel = 
	bar.Text = 
	bar.AutoButtonColor = 
	.(, bar).CornerRadius = .(, )

	 fill = .(, bar)
	fill.Size = .(.((CFG[key]-mn)/(mx-mn), , ), , , )
	fill.BackgroundColor3 = ACCENT
	fill.BorderSizePixel = 
	.(, fill).CornerRadius = .(, )

	 dragging = 
	  (i)
		  dragging   
		 r = .((i.Position.X - bar.AbsolutePosition.X) / bar.AbsoluteSize.X, , )
		 v = .((mn + (mx-mn)*r)/stp + )*stp
		v = .(v, mn, mx)
		CFG[key] = v
		fill.Size = .(r, , , )
		val.Text = .(stp <     , v)
	
	bar.InputBegan:((i)
		 i.UserInputType == .UserInputType.MouseButton1  i.UserInputType == .UserInputType.Touch 
			dragging = ; (i)
		
	)
	UIS.InputEnded:((i)
		 i.UserInputType == .UserInputType.MouseButton1  i.UserInputType == .UserInputType.Touch  dragging =  
	)
	UIS.InputChanged:((i)
		 i.UserInputType == .UserInputType.MouseMovement  i.UserInputType == .UserInputType.Touch  (i) 
	)


  (parent, text, key, options, order)
	 f = .(, parent)
	f.Size = .(, , , )
	f.BackgroundColor3 = BG3
	f.BorderSizePixel = 
	f.LayoutOrder = order  
	f.ClipsDescendants = 
	.(, f).CornerRadius = .(, )

	 lbl = .(, f)
	lbl.Size = .(, , , )
	lbl.Position = .(, , , )
	lbl.BackgroundTransparency = 
	lbl.Text = text
	lbl.TextColor3 = TXT
	lbl.Font = .Font.Gotham
	lbl.TextSize = 
	lbl.TextXAlignment = .TextXAlignment.Left

	 sel = .(, f)
	sel.Size = .(, -, , )
	sel.Position = .(, , , )
	sel.BackgroundColor3 = .(, , )
	sel.BorderSizePixel = 
	sel.Text = CFG[key] .. 
	sel.TextColor3 = ACCENT2
	sel.Font = .Font.GothamBold
	sel.TextSize = 
	sel.AutoButtonColor = 
	.(, sel).CornerRadius = .(, )

	 open = 
	sel.MouseButton1Click:(()
		open =  open
		 open 
			f.Size = .(, , ,  + #options* + )
			 idx, opt  (options) 
				 ob = .(, f)
				ob.Name =  .. opt
				ob.Size = .(, -, , )
				ob.Position = .(, , ,  + (idx-)*)
				ob.BackgroundColor3 = .(, , )
				ob.BorderSizePixel = 
				ob.Text = opt
				ob.TextColor3 = (opt == CFG[key])  ACCENT2  TXT
				ob.Font = .Font.Gotham
				ob.TextSize = 
				ob.AutoButtonColor = 
				.(, ob).CornerRadius = .(, )
				ob.MouseButton1Click:(()
					CFG[key] = opt
					sel.Text = opt .. 
					open = 
					f.Size = .(, , , )
					 _, c  (f:()) 
						 c.Name:(,) ==   c:() 
					
				)
			
		
			f.Size = .(, , , )
			 _, c  (f:()) 
				 c.Name:(,) ==   c:() 
			
		
	)


(tabFrames.Main, , , )
(tabFrames.Main, , , )
(tabFrames.Main, , , )
(tabFrames.Main, , , )
(tabFrames.Main, , , , , , )
(tabFrames.Main, , , , , , )
(tabFrames.Main, , , , , , )
(tabFrames.Main, , , , , , )
(tabFrames.Main, , , , , , )
(tabFrames.Main, , , , , , )

(tabFrames.Clash, , , )
(tabFrames.Clash, , , , , , )
(tabFrames.Clash, , , , , , )
(tabFrames.Clash, , , , , , )

(tabFrames.Curve, , , )
(tabFrames.Curve, , , {, , , , , }, )
(tabFrames.Curve, , , , , , )

(tabFrames.Trigger, , , )
(tabFrames.Trigger, , , {, , }, )
(tabFrames.Trigger, , , , , , )
(tabFrames.Trigger, , , , , , )
(tabFrames.Trigger, , , , , , )
(tabFrames.Trigger, , , )
(tabFrames.Trigger, , , )
(tabFrames.Trigger, , , )

(tabFrames.Visual, , , )
(tabFrames.Visual, , , )

 menuOpen = 
 PANEL_HEIGHT = 

  ()
	menuOpen =  menuOpen
	 menuOpen 
		Panel.Visible = 
		TweenService:(Panel, TweenInfo.(, .EasingStyle.Back), {Size = .(, , , PANEL_HEIGHT)}):()
	
		TweenService:(Panel, TweenInfo.(), {Size = .(, , , )}):()
		.(, ()   menuOpen  Panel.Visible =   )
	


Pill.MouseButton1Click:(ToggleMenu)
UIS.InputBegan:((input, gpe)
	 gpe   
	 input.KeyCode == .KeyCode.Insert  () 
)

RunService.RenderStepped:((dt)
	State.frame = State.frame + 
	 f = State.frame

	 f %  ==  
		Dot.BackgroundColor3 = State.inClash  .(, , )
			 (State.triggerTarget  .(, , ))
			 (State.autoClickerEnabled  .(, , ))
			 (CFG.Enabled  .(, , )  .(, , ))
	

	 char = Player.Character
	 HRP = char  char:()
	  CFG.Enabled   HRP 
		  CFG.Enabled 
			 i = , RING_SEG   RingParts[i]  RingParts[i].Transparency =   
		
		
	

	 pPos = HRP.Position
	 now = ()

	 dt >   State.prevPlayerPos ~= .zero 
		State.playerVel = (pPos - State.prevPlayerPos) / dt
	
	State.prevPlayerPos = pPos

	 f %  ==  
		 b, expiry  (State.parriedBalls) 
			 now > expiry  State.parriedBalls[b] =  
		
	

	 ringState = 
	 closeDist = 

	 ball  (State.ballCache) 
		 ball  ball.Parent 
			 bPos = ball.Position
			 dist = (pPos - bPos).Magnitude

			 CFG.BallESP  f %  ==  
				 dist <  
					  ActiveESP[ball]  (ball) 
					(ball, pPos)
				 ActiveESP[ball] 
					ActiveESP[ball]:()
					ActiveESP[ball] = 
				
			

			 dist >  
				State.prevBallVel[ball] = 
				State.prevBallPos[ball] = 
				State.velHistory[ball] = 
			
				 bVel = (ball)
				 speed = bVel.Magnitude
				 speed <   State.prevBallPos[ball]  dt >  
					bVel = (bPos - State.prevBallPos[ball]) / dt
					speed = bVel.Magnitude
				
				(ball, bVel)

				 flipped = 
				 prevVel = State.prevBallVel[ball]
				 prevVel  prevVel.Magnitude >   speed >  
					 bVel:(prevVel) / (speed * prevVel.Magnitude) < -  flipped =  
				
				State.prevBallPos[ball] = bPos
				State.prevBallVel[ball] = bVel

				 threat, tDist, tSpeed = (ball, pPos)
				 threat 
					closeDist = .(closeDist, tDist)
					ringState = 
					 isClash = (ball, tSpeed, flipped)
					 eta = (ball, pPos, State.playerVel)
					 curving = (ball)

					 pingSec = CFG.PingComp  State.ping  
					 safety = (CFG.ExtraMs  ) / 
					 triggerWindow = pingSec + safety + 
					 tSpeed >   triggerWindow = triggerWindow +  
					 tSpeed >   triggerWindow = triggerWindow +  
					 curving  triggerWindow = triggerWindow +  

					 shouldParry = eta <= triggerWindow
						 tDist < 
						 (tSpeed >   tDist < )
						 (tSpeed >   tDist < )
						 (curving  tDist < )

					 isClash 
						ringState = 
					 shouldParry 
						 (ball, )  ringState =  
					
				
			
		
	

	 CFG.TriggerBot 
		 holdOk = (CFG.TriggerHoldKey == )  State.triggerHeld
		 holdOk 
			 target = ()
			 target ~= State.triggerTarget 
				State.triggerTarget = target
				(target)
			
			 target 
				()
				ringState = 
			
		
			 State.triggerTarget 
				State.triggerTarget = 
				()
			
		
		 f %  ==   () 
	
		FOVCircle.Visible = 
	

	 State.inClash  ringState =  
	 (now - State.lastParry) <   ringState ==   ringState =  
	 f %  ==   (pPos, closeDist, ringState) 
)

RunService.Heartbeat:(()
	  CFG.Enabled  State.inClash   
	 now = ()
	 now < State.globalLock   
	 HRP = Player.Character  Player.Character:()
	  HRP   
	 pPos = HRP.Position

	 ball  (State.ballCache) 
		 ball  ball.Parent   State.parriedBalls[ball] 
			 ball:() == Player.Name 
				 dist = (pPos - ball.Position).Magnitude
				 dist <  
					 bVel = (ball)
					 bVel.Magnitude >  
						 toP = pPos - ball.Position
						 toP.Magnitude >   bVel.Unit:(toP.Unit) >  
							(ball, )
							
						
					
				
			
		
	
)

Player.CharacterRemoving:(()
	State.parriedBalls = {}
	State.prevBallPos = {}
	State.prevBallVel = {}
	State.velHistory = {}
	State.clashCount = {}
	State.playerVel = .zero
	State.prevPlayerPos = .zero
	State.globalLock = 
	State.inClash = 
	State.lastFireTime = 
	State.autoClickerEnabled = 
	()
	 i = , RING_SEG   RingParts[i]  RingParts[i].Transparency =   
	 _, bg  (ActiveESP)  bg:() 
	ActiveESP = {}
)

 notif = .(, SG)
notif.Size = .(, , , )
notif.Position = .(, -, , -)
notif.BackgroundColor3 = BG
notif.TextColor3 = .(,,)
notif.Font = .Font.GothamBold
notif.TextSize = 
notif.Text = 
notif.BorderSizePixel = 
.(, notif).CornerRadius = .(, )
.(, notif).Color = ACCENT

TweenService:(notif, TweenInfo.(, .EasingStyle.Back), {Position = .(, -, , )}):()
.(, ()
	TweenService:(notif, TweenInfo.(), {Position = .(, -, , -)}):()
	.()
	notif:()
)

()
()
()
()
()
()
()
)

  success 
	( .. (err))