Saturn HUBS Source Leaked By Hasty

  LPH_OBFUSCATED 
	LPH_JIT_MAX = (...) (...) ;
	LPH_NO_VIRTUALIZE = (...) (...) ;


 utility = {}
 UIS = :();
 RS = :();
 TS = :();
 mouse = :().LocalPlayer:()

 Library = {}
 mainKeybind = 
 canDrag = 

 utility:(color)  
	 color.R*,color.G*,color.B*


  (gui)
	 dragging
	 dragInput
	 dragStart
	 startPos

	  (input)
		 delta = input.Position - dragStart
		TS:(gui, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {Position = .(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)}):();
	

	 lastEnd = 
	 lastMoved = 
	 con
	gui.InputBegan:((input)
		 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
			  canDrag   
			dragging = 
			dragStart = input.Position
			startPos = gui.Position

		
	)

	UIS.InputEnded:((input)

		 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
			dragging = 
		
	)


	gui.InputChanged:((input)
		 input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch 
			dragInput = input
			lastMoved = .()
		
	)

	UIS.InputChanged:((input)
		 input == dragInput  dragging 
			(input)
		
	)


 tweenInfo = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.InOut)
 tweenInfo2 = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.InOut)
 Library:(object, goal, callback)
	 tween = TS:(object, tweenInfo, goal)
	tween.Completed:(callback  () )
	tween:()


 Library:(object, goal, callback)
	 tween = TS:(object, tweenInfo2, goal)
	tween.Completed:(callback  () )
	tween:()


 ScreenGui = .(, ())

 Library:(options)
	 GUI = {
		CurrentTab = 
	}
	

	 Main = .(, ScreenGui)
	 Title = .(, Main)
	 Divider = .(, Main)
	 TabBar = .(, Main)
	 TabLayout = .(, TabBar)
	 TabBarPad = .(, TabBar)
	 MainCorner = .(, Main)
	 MainGradient = .(, Main)
	 Divider2 = .(, Main)
	
	ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
	Main.Name = 
	Main.Position = .(,,,)
	Main.Size = .(,,,)
	Main.BackgroundColor3 = .(,,)
	Main.BorderSizePixel = 
	Main.BorderColor3 = .(,,)
	Main.ZIndex = 
	Title.Name = 
	Title.Position = .(,,,)
	Title.Size = .(,,,)
	Title.BackgroundColor3 = .(,,)
	Title.BackgroundTransparency = 
	Title.BorderSizePixel = 
	Title.BorderColor3 = .(,,)
	Title.Text = options.Title
	Title.TextColor3 = .(,,)
	Title.Font = .Font.Gotham
	Title.TextSize = 
	Title.ZIndex = 
	Title.TextXAlignment = .TextXAlignment.Left
	Divider.Name = 
	Divider.Position = .(,,,)
	Divider.Size = .(,,,)
	Divider.BackgroundColor3 = .(,,)
	Divider.BorderSizePixel = 
	Divider.BorderColor3 = .(,,)
	Divider.ZIndex = 
	TabBar.Name = 
	TabBar.Position = .(,,,)
	TabBar.Size = .(,,,)
	TabBar.BackgroundColor3 = .(,,)
	TabBar.BackgroundTransparency = 
	TabBar.BorderSizePixel = 
	TabBar.BorderColor3 = .(,,)
	TabBar.ZIndex = 
	TabBar.ScrollingEnabled = 
	TabBar.ScrollBarThickness = 
	TabBar.ScrollBarImageColor3 = .(,,)
	TabLayout.Name = 
	TabLayout.HorizontalAlignment = .HorizontalAlignment.Center
	TabLayout.SortOrder = .SortOrder.LayoutOrder
	TabBarPad.Name = 
	TabBarPad.PaddingTop = .(,)
	Divider2.Name = 
	Divider2.Position = .(,,,)
	Divider2.Size = .(,,,)
	Divider2.BackgroundColor3 = .(,,)
	Divider2.BackgroundTransparency = 
	Divider2.BorderSizePixel = 
	Divider2.BorderColor3 = .(,,)
	Divider2.ZIndex = 
	MainCorner.CornerRadius = .(,)
	MainGradient.Name = 
	MainGradient.Color = ColorSequence.{ColorSequenceKeypoint.(, .(, , )), ColorSequenceKeypoint.(,.(, , ))}

	 MC = .(, ())
	 MobileCard = .(, MC)
	 CardGradient = .(, MobileCard)
	 CardText = .(, MobileCard)
	 CardCorner = .(, MobileCard)

	MC.Name = 
	MC.ZIndexBehavior = .ZIndexBehavior.Sibling
	MobileCard.Name = 
	MobileCard.Position = .(, -, , );
	MobileCard.Size = .(,,,)
	MobileCard.BackgroundColor3 = .(,,)
	MobileCard.BorderSizePixel = 
	MobileCard.BorderColor3 = .(,,)
	MobileCard.AutoButtonColor = 
	CardGradient.Name = 
	CardGradient.Color = ColorSequence.{ColorSequenceKeypoint.(, .(, , )), ColorSequenceKeypoint.(,.(, , ))}
	CardGradient.Rotation = -
	CardText.Name = 
	CardText.Size = .(,,,)
	CardText.BackgroundColor3 = .(,,)
	CardText.BackgroundTransparency = 
	CardText.BorderSizePixel = 
	CardText.BorderColor3 = .(,,)
	CardText.Text = 
	CardText.TextColor3 = .(,,)
	CardText.Font = .Font.Gotham
	CardText.TextSize = 
	CardText.ZIndex = 

	MobileCard.MouseButton1Click:(()
		ScreenGui.Enabled =  ScreenGui.Enabled
	)
	
	(MobileCard)
	(Main)

	 Library:()
		ScreenGui.Enabled =  ScreenGui.Enabled
	

	UIS.InputBegan:((key, gp)
		 gp   ;

		 key.KeyCode == .KeyCode[mainKeybind] 
			Library:()
		
	)

	 GUI:(options)
		
		 tab = {
			Active = 
		}
		
		 Canvas = .(, Main)
		 UIListLayout = .(, Canvas)
		 UIPadding = .(, Canvas)
		 SelectedTab = .(, TabBar)
		 Highlight = .(, SelectedTab)
		 STCorner = .(, SelectedTab)
		 Tab = .(, SelectedTab)
		
		SelectedTab.Name = 
		SelectedTab.Position = .(,,,)
		SelectedTab.Size = .(,,,)
		SelectedTab.BackgroundColor3 = .(,,)
		SelectedTab.BackgroundTransparency = 
		SelectedTab.BorderSizePixel = 
		SelectedTab.BorderColor3 = .(,,)
		SelectedTab.ZIndex = 
		Highlight.Name = 
		Highlight.Position = .(,,,)
		Highlight.Size = .(,,,)
		Highlight.BackgroundColor3 = .(,,)
		Highlight.BorderSizePixel = 
		Highlight.Transparency = 
		Highlight.BorderColor3 = .(,,)
		Highlight.ZIndex = 
		STCorner.CornerRadius = .(,)
		Tab.Name = 
		Tab.Position = .(,,,)
		Tab.Size = .(,,,)
		Tab.BackgroundColor3 = .(,,)
		Tab.BackgroundTransparency = 
		Tab.BorderSizePixel = 
		Tab.BorderColor3 = .(,,)
		Tab.Text = options.Name
		Tab.TextColor3 = .(,,)
		Tab.Font = .Font.Gotham
		Tab.TextSize = 
		Tab.ZIndex = 
		Tab.AutoButtonColor = 		
		Canvas.Name = 
		Canvas.Position = .(,,,)
		Canvas.Size = .(,,,)
		Canvas.BackgroundColor3 = .(,,)
		Canvas.BackgroundTransparency = 
		Canvas.BorderSizePixel = 
		Canvas.BorderColor3 = .(,,)
		Canvas.ZIndex = 
		Canvas.Visible = 
		Canvas.AutomaticCanvasSize = .AutomaticSize.Y;
		Canvas.ScrollBarThickness = 
		Canvas.ScrollBarImageColor3 = .(,,)
		UIListLayout.HorizontalAlignment = .HorizontalAlignment.Center
		UIListLayout.SortOrder = .SortOrder.LayoutOrder
		UIListLayout.Padding = .(,)
		UIPadding.PaddingTop = .(,)
		
		 tab:()
			  tab.Active 
				 GUI.CurrentTab ~=  
					GUI.CurrentTab:()
				
				tab.Active = 
				Library:(Tab, {TextColor3 = .(,,)})
				Library:(SelectedTab, {BackgroundTransparency = })
				Library:(Highlight, {BackgroundTransparency = })
				Canvas.Visible = 
				GUI.CurrentTab = tab
			
		

		 tab:()
			 tab.Active 
				tab.Active = 
				Library:(Tab, {TextColor3 =.(,,)})
				Library:(SelectedTab, {BackgroundTransparency = })
				Library:(Highlight, {BackgroundTransparency = })
				Canvas.Visible = 
			
		

		Tab.MouseButton1Click:(()
			tab:()
		)

		 GUI.CurrentTab ==  
			tab.()	
		
		
		
		 tab:(options)
			
			 toggle = {
				State = 
			}
			
			 Toggle = .(, Canvas)
			 ToggleTitle = .(, Toggle)
			 CheckBox = .(, Toggle)
			 CheckBoxCorner = .(, CheckBox)
			 CheckMark = .(, CheckBox)
			 ToggleCorner = .(, Toggle)
			


			Toggle.Name = 
			Toggle.Position = .(,,,)
			Toggle.Size = .(,,,)
			Toggle.BackgroundColor3 = .(,,)
			Toggle.BackgroundTransparency = 
			Toggle.BorderSizePixel = 
			Toggle.BorderColor3 = .(,,)
			Toggle.ZIndex = 
			Toggle.AutoButtonColor = 		
			ToggleTitle.Name = 
			ToggleTitle.Position = .(,,,)
			ToggleTitle.Size = .(,,,)
			ToggleTitle.BackgroundColor3 = .(,,)
			ToggleTitle.BackgroundTransparency = 
			ToggleTitle.BorderSizePixel = 
			ToggleTitle.BorderColor3 = .(,,)
			ToggleTitle.Text = options.Name
			ToggleTitle.TextColor3 = .(,,)
			ToggleTitle.Font = .Font.Gotham
			ToggleTitle.TextSize = 
			ToggleTitle.ZIndex = 
			ToggleTitle.TextXAlignment = .TextXAlignment.Left
			CheckBox.Name = 
			CheckBox.Position = .(,,,)
			CheckBox.Size = .(,,,)
			CheckBox.BackgroundColor3 = .(,,)
			CheckBox.BorderSizePixel = 
			CheckBox.BorderColor3 = .(,,)
			CheckBox.ZIndex = 
			CheckBoxCorner.CornerRadius = .(,)
			CheckMark.Name = 
			CheckMark.Position = .(,,,)
			CheckMark.Size = .(,,,)
			CheckMark.BackgroundColor3 = .(,,)
			CheckMark.BackgroundTransparency = 
			CheckMark.BorderSizePixel = 
			CheckMark.BorderColor3 = .(,,)
			CheckMark.Image = 
			CheckMark.Visible = 
			CheckMark.AutoButtonColor = 
			CheckMark.ZIndex = 
			ToggleCorner.CornerRadius = .(,)
			
			toggle.State = options.default

			options.(toggle.State)

			 toggle.State 
				Library:(CheckMark, {ImageTransparency = })
			
				Library:(CheckMark, {ImageTransparency = })
			

			 toggle:(boolean)
				 boolean ==  
					toggle.State =  toggle.State
				
					toggle.State = boolean
				

				 toggle.State 
					()
					Library:(CheckMark, {ImageTransparency = })
				
					Library:(CheckMark, {ImageTransparency = })
				

				options.(toggle.State)
			

			Toggle.MouseButton1Down:(()
				toggle:()
			)
			
			 toggle
		
		
		 tab:(options)
			 slider = {
				hover = ,
				MouseDown = ,
				connections = {}
			}
			
			 Slider = .(, Canvas)
			 SliderTitle = .(, Slider)
			 SliderBack = .(, Slider)
			 SliderBackCorner = .(, SliderBack)
			 SliderMain = .(, SliderBack)
			 SliderMainCorner = .(, SliderMain)
			 SliderCorner = .(, Slider)
			 SliderAmt = .(, Slider)
			

			Slider.Name = 
			Slider.Position = .(,,,)
			Slider.Size = .(,,,)
			Slider.BackgroundColor3 = .(,,)
			Slider.BackgroundTransparency = 
			Slider.BorderSizePixel = 
			Slider.BorderColor3 = .(,,)
			Slider.ZIndex = 
			Slider.AutoButtonColor = 
			SliderTitle.Name = 
			SliderTitle.Position = .(,,,)
			SliderTitle.Size = .(,,,)
			SliderTitle.BackgroundColor3 = .(,,)
			SliderTitle.BackgroundTransparency = 
			SliderTitle.BorderSizePixel = 
			SliderTitle.BorderColor3 = .(,,)
			SliderTitle.Text = options.Name
			SliderTitle.TextColor3 = .(,,)
			SliderTitle.Font = .Font.Gotham
			SliderTitle.TextSize = 
			SliderTitle.ZIndex = 
			SliderTitle.TextXAlignment = .TextXAlignment.Left
			SliderBack.Name = 
			SliderBack.Position = .(,,,)
			SliderBack.Size = .(,,,)
			SliderBack.BackgroundColor3 = .(,,)
			SliderBack.BorderSizePixel = 
			SliderBack.BorderColor3 = .(,,)
			SliderBack.ZIndex = 
			SliderBackCorner.CornerRadius = .(,)
			SliderMain.Name = 
			SliderMain.Position = .(-,,,)
			SliderMain.Size = .(,,,)
			SliderMain.BackgroundColor3 = .(,,)
			SliderMain.BorderSizePixel = 
			SliderMain.BorderColor3 = .(,,)
			SliderMain.ZIndex = 
			SliderMainCorner.CornerRadius = .(,)
			SliderCorner.CornerRadius = .(,)
			SliderAmt.Name = 
			SliderAmt.Position = .(,,,)
			SliderAmt.Size = .(,,,)
			SliderAmt.BackgroundColor3 = .(,,)
			SliderAmt.BackgroundTransparency = 
			SliderAmt.BorderSizePixel = 
			SliderAmt.BorderColor3 = .(,,)
			SliderAmt.Text = 
			SliderAmt.TextColor3 = .(,,)
			SliderAmt.Font = .Font.Gotham
			SliderAmt.TextSize = 
			SliderAmt.ZIndex = 
			

			 slider:(v)
				 v ==  
					 percentage = .((mouse.X - SliderBack.AbsolutePosition.X) / (SliderBack.AbsoluteSize.X), , )
					 value = ((options.max - options.min) * percentage) + options.min
					 value %  ==  
						SliderAmt.Text = .(, value)
					
						SliderAmt.Text = .(, value)
					
					SliderMain.Size = .(percentage, )
				
					 v %  ==  
						SliderAmt.Text = .(, v)
					
						SliderAmt.Text = (v)
					
					SliderMain.Size = .(((v - options.min) / (options.max - options.min)), )
				
				options.(slider:())
			


			 slider:()
				 (SliderAmt.Text)
			

			slider:(options.default)

			SliderAmt.FocusLost:(()
				 toNum
				(()
					toNum = (SliderAmt.Text)
				)
				 toNum 
					toNum = .(toNum, options.min, options.max)
					slider:(toNum)
				
					SliderAmt.Text = 
				
			)

			 Connection;
			.(slider.connections, UIS.InputEnded:((input)
				 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
					(()
						Connection:();
						Connection = ;
					)
				
			))

			
			.(slider.connections, Slider.MouseButton1Down:(()
				(Connection) 
					Connection:();
				;

				Connection = RS.Heartbeat:(()
					

						slider:()

				)
			))
			

			 slider
		
		
		 tab:(options)
			 dropdown = {}
			
			 Dropdown = .(, Canvas)
			 DropdownTitle = .(, Dropdown)
			 DropdownSelected = .(, Dropdown)
			 SelectedOptionCorner = .(, DropdownSelected)
			 SelectedText = .(, DropdownSelected)
			 DropdownCorner = .(, Dropdown)
			
			Dropdown.Name = 
			Dropdown.Position = .(,,,)
			Dropdown.Size = .(,,,)
			Dropdown.BackgroundColor3 = .(,,)
			Dropdown.BackgroundTransparency = 
			Dropdown.BorderSizePixel = 
			Dropdown.BorderColor3 = .(,,)
			Dropdown.ZIndex = 
			DropdownTitle.Name = 
			DropdownTitle.Position = .(,,,)
			DropdownTitle.Size = .(,,,)
			DropdownTitle.BackgroundColor3 = .(,,)
			DropdownTitle.BackgroundTransparency = 
			DropdownTitle.BorderSizePixel = 
			DropdownTitle.BorderColor3 = .(,,)
			DropdownTitle.Text = options.Name
			DropdownTitle.TextColor3 = .(,,)
			DropdownTitle.Font = .Font.Gotham
			DropdownTitle.TextSize = 
			DropdownTitle.ZIndex = 
			DropdownTitle.TextXAlignment = .TextXAlignment.Left
			DropdownSelected.Name = 
			DropdownSelected.Position = .(,,,)
			DropdownSelected.Size = .(,,,)
			DropdownSelected.BackgroundColor3 = .(,,)
			DropdownSelected.BorderSizePixel = 
			DropdownSelected.BorderColor3 = .(,,)
			DropdownSelected.ZIndex = 
			SelectedOptionCorner.CornerRadius = .(,)
			SelectedText.Name = 
			SelectedText.Position = .(,,,)
			SelectedText.Size = .(,,,)
			SelectedText.BackgroundColor3 = .(,,)
			SelectedText.BackgroundTransparency = 
			SelectedText.BorderSizePixel = 
			SelectedText.BorderColor3 = .(,,)
			SelectedText.AutoButtonColor = 
			SelectedText.Text = options.default
			SelectedText.TextColor3 = .(,,)
			SelectedText.Font = .Font.Gotham
			SelectedText.TextSize = 
			SelectedText.ZIndex = 
			DropdownCorner.CornerRadius = .(,)
			

			 DropDownOptions = .(, Main)
			 Frame = .(, DropDownOptions)
			 UIListLayout = .(, Frame)

			

			DropDownOptions.Name = 
			DropDownOptions.Position = .(,,,)
			DropDownOptions.Size = .(,,,)
			DropDownOptions.BackgroundColor3 = .(,,)
			DropDownOptions.BackgroundTransparency = 
			DropDownOptions.BorderSizePixel = 
			DropDownOptions.BorderColor3 = .(,,)
			DropDownOptions.Visible = 
			DropDownOptions.AutomaticSize = .AutomaticSize.XY
			DropDownOptions.ZIndex = 
			Frame.Size = .(,,,)
			Frame.BackgroundColor3 = .(,,)
			Frame.BackgroundTransparency = 
			Frame.BorderSizePixel = 
			Frame.BorderColor3 = .(,,)
			Frame.AutomaticSize = .AutomaticSize.XY
			Frame.ZIndex = 
			UIListLayout.HorizontalAlignment = .HorizontalAlignment.Center
			UIListLayout.SortOrder = .SortOrder.LayoutOrder
			
			 i, v  (options.options) 
				 Option = .(, Frame)
				 Highlight = .(, Option)
				Option.Name = 
				Option.Position = .(,,,)
				Option.Size = .(,,,)
				Option.BackgroundColor3 = .(,,)
				Option.BackgroundTransparency = 
				Option.BorderSizePixel = 
				Option.Text = v
				Option.BorderColor3 = .(,,)
				Option.TextColor3 = .(,,)
				Option.Font = .Font.SourceSans
				Option.TextSize = 
				Option.ZIndex = 
				Highlight.Name = 
				Highlight.Position = .(-,,,)
				Highlight.Size = .(,,,)
				Highlight.BackgroundColor3 = .(,,)
				Highlight.BorderSizePixel = 
				Highlight.BorderColor3 = .(,,)
				Highlight.AutomaticSize = .AutomaticSize.Y
				Highlight.ZIndex = 
				
				Option.MouseButton1Down:(()
					SelectedText.Text = v
					DropDownOptions.Visible = 
					options.(v)
				)
			
			
			SelectedText.MouseButton1Down:(()
				DropDownOptions.Visible =  DropDownOptions.Visible
			)
			
			options.(options.default)
			
			 dropdown
		
		
		 tab:(options)
			 button = {}
			
			 Button = .(, Canvas)
			 ButtonTitle = .(, Button)
			 ButtonCorner = .(, Button)

			

			Button.Name = 
			Button.Position = .(,,,)
			Button.Size = .(,,,)
			Button.BackgroundColor3 = .(,,)
			Button.BackgroundTransparency = 
			Button.BorderSizePixel = 
			Button.BorderColor3 = .(,,)
			Button.ZIndex = 
			ButtonTitle.Name = 
			ButtonTitle.Size = .(,,,)
			ButtonTitle.BackgroundColor3 = .(,,)
			ButtonTitle.AutoButtonColor = 
			ButtonTitle.BackgroundTransparency = 
			ButtonTitle.BorderSizePixel = 
			ButtonTitle.BorderColor3 = .(,,)
			ButtonTitle.Text = options.Name
			ButtonTitle.TextColor3 = .(,,)
			ButtonTitle.Font = .Font.Gotham
			ButtonTitle.TextSize = 
			ButtonTitle.ZIndex = 
			ButtonCorner.CornerRadius = .(,)
			
			ButtonTitle.MouseButton1Down:(()
				Library:(Button, {BackgroundColor3 = .(, , )})
			)
			
			ButtonTitle.MouseButton1Up:(()
				Library:(Button, {BackgroundColor3 = .(, , )})
			)
			
			ButtonTitle.MouseButton1Click:(()
				options.()
			)
			
			 button
		
		
		 tab
	
	
	 GUI





 players = :()
 userInputService = :()
 replicatedStorage = :()



 pwr, at, natpwr = , .(, , ), 
 camera = .CurrentCamera
 player = :().LocalPlayer
 target = 
 silent = 
 silentkey = 
 typing = 
 locked = 
 attach0 = .()
 attach1 = .()
 beam = .()
 character = player.Character
 tf = .()
 mouse = player:()
 sphere = .()
 mode = 
 modes = {
	[] = ,
	[] = ,
	[] = ,
	[] = ,
	[] = 
	
}
 oldHighlight = 



 Finium = .()
 Main = .()
 Mode = .()
 UICorner = .()
 Value = .()
 Title = .()
 Power = .()
 UICorner_2 = .()
 Value_2 = .()
 Title_2 = .()
 PassDuration = .()
 UICorner_3 = .()
 Value_3 = .()
 Title_3 = .()
 Route = .()
 UICorner_4 = .()
 Value_4 = .()
 Title_4 = .()
 UIAspectRatioConstraint = .()

Finium.Name = 
Finium.Parent = ()
Finium.ZIndexBehavior = .ZIndexBehavior.Sibling

Main.Name = 
Main.Parent = Finium
Main.AnchorPoint = .(, )
Main.BackgroundColor3 = .(, , )
Main.BackgroundTransparency = 
Main.Position = .(, , , )
Main.Size = .(, , , )

Mode.Name = 
Mode.Parent = Main
Mode.BackgroundColor3 = .(, , )
Mode.Position = .(, , , )
Mode.Size = .(, , , )

UICorner.Parent = Mode

Value.Name = 
Value.Parent = Mode
Value.BackgroundColor3 = .(, , )
Value.BackgroundTransparency = 
Value.Position = .(, , , )
Value.Size = .(, , , )
Value.Font = .Font.SourceSansBold
Value.Text = 
Value.TextColor3 = .(, , )
Value.TextScaled = 
Value.TextSize = 
Value.TextWrapped = 

Title.Name = 
Title.Parent = Mode
Title.BackgroundColor3 = .(, , )
Title.BackgroundTransparency = 
Title.Position = .(, , , )
Title.Size = .(, , , )
Title.Font = .Font.SourceSans
Title.Text = 
Title.TextColor3 = .(, , )
Title.TextScaled = 
Title.TextSize = 
Title.TextStrokeTransparency = 
Title.TextWrapped = 

Power.Name = 
Power.Parent = Main
Power.BackgroundColor3 = .(, , )
Power.Position = .(, , , )
Power.Size = .(, , , )

UICorner_2.Parent = Power

Value_2.Name = 
Value_2.Parent = Power
Value_2.BackgroundColor3 = .(, , )
Value_2.BackgroundTransparency = 
Value_2.Position = .(, , , )
Value_2.Size = .(, , , )
Value_2.Font = .Font.SourceSansBold
Value_2.Text = 
Value_2.TextColor3 = .(, , )
Value_2.TextScaled = 
Value_2.TextSize = 
Value_2.TextWrapped = 

Title_2.Name = 
Title_2.Parent = Power
Title_2.BackgroundColor3 = .(, , )
Title_2.BackgroundTransparency = 
Title_2.Position = .(, , , )
Title_2.Size = .(, , , )
Title_2.Font = .Font.SourceSans
Title_2.Text = 
Title_2.TextColor3 = .(, , )
Title_2.TextScaled = 
Title_2.TextSize = 
Title_2.TextStrokeTransparency = 
Title_2.TextWrapped = 

PassDuration.Name = 
PassDuration.Parent = Main
PassDuration.BackgroundColor3 = .(, , )
PassDuration.Position = .(, , , )
PassDuration.Size = .(, , , )

UICorner_3.Parent = PassDuration

Value_3.Name = 
Value_3.Parent = PassDuration
Value_3.BackgroundColor3 = .(, , )
Value_3.BackgroundTransparency = 
Value_3.Position = .(, , , )
Value_3.Size = .(, , , )
Value_3.Font = .Font.SourceSansBold
Value_3.Text = 
Value_3.TextColor3 = .(, , )
Value_3.TextScaled = 
Value_3.TextSize = 
Value_3.TextWrapped = 

Title_3.Name = 
Title_3.Parent = PassDuration
Title_3.BackgroundColor3 = .(, , )
Title_3.BackgroundTransparency = 
Title_3.Position = .(, , , )
Title_3.Size = .(, , , )
Title_3.Font = .Font.SourceSans
Title_3.Text = 
Title_3.TextColor3 = .(, , )
Title_3.TextScaled = 
Title_3.TextSize = 
Title_3.TextStrokeTransparency = 
Title_3.TextWrapped = 





 qbon = 

  (power, direction)
	 origin = :().LocalPlayer.Character.Head.Position + direction * 
	 velocity = power * direction
	 peakvel = velocity * (velocity.Y / )
	 airtime = (velocity.Y / ) * 
	 origin + .(peakvel.X * , , peakvel.Z * ), airtime


  ()
	 zDiff = :().LocalPlayer.Character.HumanoidRootPart.Position.Z - at.Z
	 a = 
	 zDiff <  
		a = 
	
		a = -
	
	 a	


  (humanoid)
	 isPlayer = players:(humanoid.Parent)
	 isPlayer 
		 humanoid.MoveDirection
	
		 (humanoid.WalkToPoint - :().LocalPlayer.Character.Head.Position).Unit
	


  (char)
	 powerTable = {
		[] = ,
		[] = ,
		[] = ,
		[] = ,
		[] = ,
		[] = ,
		[] = ,
		[] = ,
		[] = ,
	}
	 distance = (character.Head.Position - char.Head.Position).Magnitude
	 lDiff = .huge
	 power = 
	 pdistance = 
	 reachedDis = 
	 nextDis = 
	 naturalPower = 
	 dis, pwr  (powerTable) 
		dis *= 
		 distance > dis  dis > reachedDis 
			power = pwr
			naturalPower = pwr
			pdistance = dis
			reachedDis = dis
			 dis ==   nextDis = dis +   nextDis = dis +  
		
	
	 diff = .(nextDis - distance, , .huge)
	 required = (nextDis - reachedDis)
	 nextPower = powerTable[nextDis / ]  
	 percentage = diff / required
	
	power += .((nextPower - power) - ((nextPower - power) * percentage), , )
	 power, naturalPower


  ()
	 .PlaceId == 


 () 
	 __namecall; __namecall = (, , (self, ...)
		 args = {...}
		  ()  qbon  args[] ==  
			 direction = (at - character.Head.Position).Unit
			 nwArgs = {, character.Head.CFrame.Position, character.Head.Position + direction * , pwr}
			 (self, (nwArgs))
		
		 (self, ...)
	)

	 __namecall; __namecall = (, , (self, ...)
		 args = {...}
		  ()  qbon  args[] ==  
			 direction = (at - character.Head.Position).Unit
			 nwArgs = {, character.Head.CFrame.Position, character.Head.Position + direction * , , .(pwr)}
			 (self, (nwArgs))
		
		 (self, ...)
	)


  (moveDirection, pos)
	
	moveDirection = .(moveDirection.X, , moveDirection.Z)
	 x = moveDirection.X
	 z = moveDirection.Z
	 .(x) >  
		 x ~= .(x) 
			x = -
		
			x = 
		
	
		x = 
	
	 .(z) >  
		 z ~= .(z) 
			z = -
		
			z = 
		
	
		z = 
	
	 md = .(x, , z)
	 md.Magnitude <=  
		md = .(, , (pos))
	
	 md


  ()
	 np = 
	 nm = .huge
	 s = {}
	 :() 
		.(s, .npcwr.a)
		.(s, .npcwr.b)
	
	 i, p  (s) 
		 i, c  (p:()) 
			 c:()  c:() 
				 plr = players:(c)
				 plr == player   
				 ( ()  .PlaceId ~= )   plr   
				 plr   ()  plr.Team ~= player.Team   
				 d = (c.HumanoidRootPart.Position - mouse.Hit.Position).Magnitude
				 d < nm 
					nm = d
					np = c
					
			
		
	
	 np

 
  (g, v0, x0, t1) 
	
	 c = **;
	 p3 = *g*t1*t1 + v0*t1 + x0;
	 p2 = p3 - (g*t1*t1 + v0*t1)/;
	 p1 = (c*g*t1*t1 + *v0*t1 + x0 - c*(x0+p3))/(*c) - p2;

	
	 curve0 = (p1 - x0).magnitude;
	 curve1 = (p2 - p3).magnitude;

	
	 b = (x0 - p3).unit;
	 r1 = (p1 - x0).unit;
	 u1 = r1:(b).unit;
	 r2 = (p2 - p3).unit;
	 u2 = r2:(b).unit;
	b = u1:(r1).unit;

	 cf1 = .(
		x0.x, x0.y, x0.z,
		r1.x, u1.x, b.x,
		r1.y, u1.y, b.y,
		r1.z, u1.z, b.z
	)

	 cf2 = .(
		p3.x, p3.y, p3.z,
		r2.x, u2.x, b.x,
		r2.y, u2.y, b.y,
		r2.z, u2.z, b.z
	)

	 curve0, -curve1, cf1, cf2;




attach0.Parent = .Terrain
attach1.Parent = .Terrain
beam.Parent = .Terrain
beam.Attachment0 = attach0
beam.Attachment1 = attach1
tf.Parent = 
mouse.TargetFilter = tf

  () 
	 :() 
		.ScrambleWall.Parent = tf
		.LineDownWall.Parent = tf
		mouse.TargetFilter = tf
	
 

sphere.Parent = tf
sphere.Material = .Material.Neon
sphere.Color = .(, , )
sphere.CanCollide = 
sphere.Anchored = 
sphere.Size = .(, , )
sphere.Shape = .PartType.Ball



userInputService.InputBegan:((input, gp)
	typing = gp
	 a = 
	(()
		a = .(input.KeyCode.Value)
	) 
	silentkey ..= a 
	 .(silentkey, ) 
		silentkey = 
		silent =  silent
		(silent)
	
	  typing 
		 input.KeyCode == .KeyCode.Q 
			locked =  locked
		 input.KeyCode == .KeyCode.Z 
			mode = modes[mode]
		
	
)

.(()
	  
		.()
		 userInputService:(.KeyCode.T)   typing  target 
			(pwr, at)
		
		
)

.(()
	  (power)
		 gui = player.PlayerGui.BallGui
		 i,v  (gui.Frame:()) 
			 v.Name~= 
				v.BackgroundTransparency=(v.Name)<=power    
			
		
		gui.Frame.Disp.Text=power
	 
	  
		.((/) * (.(, ) / ))
		 player.PlayerGui:()  silent 
			 natpwr ~= natpwr  natpwr <  
				natpwr = 
				
			 pwr > (natpwr + ) 
				(.(natpwr + , , ))
			
				(natpwr)
			
		
	
)

 lib = Library:({Title = })


 Tab = lib:({Name =})
 Tab1 = lib:({Name =})
 Tab6 = lib:({Name =})
 Tab2 = lib:({Name =})
 Tab3 = lib:({Name =})
 Tab4 = lib:({Name =})
 Tab5 = lib:({Name =})


Tab:({
	Name = ,
	default = ,
	callback = (v)
		qbon = v
		 v 
			Finium.Enabled = 
			beam.Enabled = 
		
			Finium.Enabled = 
			beam.Enabled = 
		
	,
})







 players = :()
 userInputService = :()
 replicatedStorage = :()
 remotes = replicatedStorage:()
 characterSoundEvent = remotes:()
 player = :().LocalPlayer
 runService = :()



 saturn = {

    Catching = {
        mags = ,
        range = 
    }
}

Tab1:({
    Name = ,
    default = ,
    callback = (v)
        saturn.Catching.mags = v
    
})

 magToggle = Tab1:({
    Name = ,
    min = ,
    max = ,
    default = ,
    callback = (v)
		saturn.Catching.range = v
    
})

Tab1:({
    Name = ,
    options = {
        ,
        ,
        ,
		
    },
	
    default = ,
    callback = (v)
         v ==  
            magToggle:()
         v ==  
            magToggle:()
         v ==  
            magToggle:()
		 v ==  
            magToggle:()
        
    ,
})

 autokick =  

.(()

().Variables = {}

	Variables.Players = :()
	Variables.ReplicatedStorage = :()
	Variables.UserInputService = :()
	Variables.Client = Variables.Players.LocalPlayer
	Variables.Character = Variables.Client.Character  Variables.Client.CharacterAdded:()

	Variables.Client.CharacterAdded:((Character)
		Variables.Character = Character 
	)

	 Aimbot = {}

	 Aimbot:(Arrows)
		 Y = 
		 Arrow1 = 

		 _, Arrow  (Arrows) 
			 Arrow.Position.Y.Scale > Y 
				Y = Arrow.Position.Y.Scale
				Arrow1 = Arrow 
			
		

		 Arrow1
	

	Variables.Client.PlayerGui.ChildAdded:((child)
		 child.Name ==   autokick ==  
			 KickerGui = child 
			 Meter = KickerGui:()
			 Cursor = Meter:()
			 Arrows = {}

			 i,v  (Meter:()) 
				 .(v.Name:(), ) 
					.(Arrows, v)
				
			 

			 .()  Cursor.Position.Y.Scale < 
			()
			 .()  Cursor.Position.Y.Scale >= Aimbot:(Arrows).Position.Y.Scale + ( / ( / ))
			()
		
	)
)

Tab3:({
	Name = ,
	default = ,
	callback = (v)
	autokick = v
})



 connection

Tab4:({
	Name = ,
	default = ,
	callback = (v)
	 v 
		connection = :().LocalPlayer:().Button1Down:(()
			 i, v  (.workspace:()) 
				 v.Name ==   v:() 
					 toolPosition = v.Parent.HumanoidRootPart.Position
					 playerPosition = :().LocalPlayer.Character.HumanoidRootPart.Position
					 (toolPosition - playerPosition).Magnitude <= tprange 
						:().LocalPlayer.Character.HumanoidRootPart.CFrame = v.Parent.HumanoidRootPart.CFrame + .(, , )
					
				
			
		)
	
		 connection 
			connection:() 
		
	
})

Tab4:({
	Name = ,
	min = ,
	max = ,
	default = ,
	callback = (v)
	tprange = v
})







 swatreachmain = 
 player = :().LocalPlayer
 swatDistance = .huge
 swatted = 
 userInputService = :()

  (fb)
	 fb  fb:()


  (checkFunc)
	 lowestDistance = .huge
	 lowestFB = 
	 index, part  (:()) 
		 (part)   part.Anchored 
			 checkFunc 
				  (part) 
					
				
			
			 distance = (player.Character.HumanoidRootPart.Position - part.Position).Magnitude
			 distance < lowestDistance 
				lowestFB = part
				lowestDistance = distance
			
		
	
	 lowestFB, lowestDistance


  (parts, part)
	 lowestMagnitude = .huge
	 lowestPart = 
	 index, p  (parts) 
		 dis = (part.Position - p.Position).Magnitude
		 dis < lowestMagnitude 
			lowestMagnitude = dis
			lowestPart = p
		
	
	 lowestPart


  (char)
	 swatreachmain 
		.()
		 ball = ()
		 ball  swatted 
			 distance = (player.Character.HumanoidRootPart.Position - ball.Position).Magnitude
			 distance < swatDistance 
				 catch = ({player.Character[], player.Character[]}, ball)
				(ball, catch, )
				(ball, catch, )
			
		
	


userInputService.InputBegan:((input, gp)
	  gp 
		 input.KeyCode == .KeyCode.R   swatted 
			swatted = 
			.()
			swatted = 
		
	
)

  (character)
	 swatreachmain 
		(character)
	


player.CharacterAdded:(updateCharacter)

Tab4:({
	Name = ,
	default = ,
	callback = (value)
	swatreachmain = value
	 value 
		(player.Character) 
	
})

 swatreachmain 
	(player.Character)




 autoswatv = 

 enabledd = 

  ()
	 enabledd 
         player = :().LocalPlayer
		 character = player.Character  player.CharacterAdded:()
		 humanoidRootPart = character:()
		 RunService = :()

		  (part)
			 distance = (part.Position - humanoidRootPart.Position).Magnitude
			 distance <= autoswatv 
				()
				()
				.()
			
		
		  ()
			 _, v  (.Workspace:()) 
				 v.Name ==   v:() 
					(v)
				
			
		
		connection = RunService.Heartbeat:(updateDistances)
	
		 connection 
			connection:()
			connection = 
		
	


Tab4:({
	Name = ,
	default = ,
	callback = (v)
	enabledd = v
	()
})

Tab4:({
	Name = ,
	min = ,
	max = ,
	default = ,
	callback = (v)
	autoswatv = v
})

Tab6:({
	Name = ,
	default = ,
	callback = (v)
	 v 
         player = :().LocalPlayer

		  (ball)
			 ball.Name ==   ball:() 
				 v0 = ball.Velocity
				 x0 = ball.Position
				 dt = /
				 grav = .(, -, )
				 points = {
					[] = x0
				}
				  (p, v0)
					 raycastParams = RaycastParams.()
					raycastParams.RespectCanCollide = 
					 ray = :(p, .(, -, ), raycastParams)
					 ray2 = :(p, .(, - * , ), raycastParams)
					 ray   ray2
				
				  
					  (points[#points], v0) 
						 v0.Y <  
							
						
					
					 currentPoint = points[#points]
					v0 += grav * dt
					points[#points + ] = currentPoint + (v0 * dt)
				
				 optimal = points[#points]
				 part = .()
				part.Anchored = 
				part.CanCollide = 
				part.Position = .(optimal.X, player.Character.HumanoidRootPart.Position.Y + , optimal.Z)
				part.Parent = 
				part.Material = .Material.Neon
				part.Size = .(, , )
				 .()  ball.Parent ~= 
				part:()
			
		

		  (ball)
			.()
			(ball)
		
		eventConnection = .ChildAdded:(handleChildAdded)
	
		 eventConnection 
			eventConnection:()
			eventConnection = 
		
	
})





Tab:({
	Name = ,
	default = ,
	callback = (v)
	 v   toggleActive 
		toggleActive = 
		eventConnection = .ChildAdded:((b)
			 b.Name ==   b:() 
				.()
				 vel = b.Velocity
				 pos = b.Position
				 c0, c1, cf1, cf2 = (.(, -, ), vel, pos, )
				 beam = .()
				 a0 = .()
				 a1 = .()
				beam.Color = ColorSequence.(predictioncolor)
				beam.Transparency = NumberSequence.(, )
				beam.CurveSize0 = c0
				beam.CurveSize1 = c1
				beam.Name = 
				beam.Parent = .Terrain
				beam.Transparency = NumberSequence.({
					NumberSequenceKeypoint.(, ),
					NumberSequenceKeypoint.(, ),
					NumberSequenceKeypoint.(, ),
					NumberSequenceKeypoint.(, ),
				})
				beam.Segments = 
				a0.Parent = .Terrain
				a1.Parent = .Terrain
				a0.CFrame = a0.Parent.CFrame:() * cf1
				a1.CFrame = a1.Parent.CFrame:() * cf2
				beam.Attachment0 = a0
				beam.Attachment1 = a1
				beam.Width0 = 
				beam.Width1 = 
				 .()  b.Parent ~= 
				a0:()
				a1:()
			
		)
	  Value  toggleActive 
		toggleActive = 
		 eventConnection 
			eventConnection:()
		
	
})


Tab:({
	Name = ,
	options = {
		,
		,
        ,
        ,
        
	},
	default = ,
	callback = (v)
	 v ==  
		predictioncolor = .(, , )
	 v ==  
		predictioncolor = .(, , )
	 v ==  
		predictioncolor = .(, , )
	 v ==  
		predictioncolor = .(, , )
	 v ==  
		predictioncolor = .(, , )
	
})


 isAntiJamEnabled = 

  ()
	  
		 isAntiJamEnabled 
			 :().LocalPlayer.Character  :().LocalPlayer.Character:()  :().LocalPlayer.Character.Head.CanCollide 
				 _, player  (:():()) 
					 player ~= :().LocalPlayer  player.Character  player.Character:() 
						(()
							player.Character.Torso.CanCollide = 
							player.Character.Head.CanCollide = 
						)
					
				
			
		
			 :().LocalPlayer.Character  :().LocalPlayer.Character:()   :().LocalPlayer.Character.Head.CanCollide 
				:().LocalPlayer.Character.Torso.CanCollide = 
				:().LocalPlayer.Character.Head.CanCollide = 
			
		
		.()
	




Tab:({
	Name = ,
	default = ,
	callback = (enabled)
        isAntiJamEnabled = enabled
    
})


(updateCollisionState)


 AutoFollowQb = 
 followCarrierTask

  ()
     AutoFollowQb 
         carrier = :().Values.Carrier.Value
         carrier  carrier:(:())  carrier.Team ~= :().LocalPlayer.Team 
             humanoid = :().LocalPlayer.Character  :().LocalPlayer.Character:()
             humanoid 
                humanoid:(carrier.Character.Torso.Position)
            
        
        ()
    


  (value)
    AutoFollowQb = value
     value 
        followCarrierTask = .(FollowCarrier)
    
         followCarrierTask 
            followCarrierTask:()
        
    


Tab4:({
	Name = ,
	default = ,
	callback = ToggleFollowCarrier,
})



Tab4:({
	Name = ,
	min = ,
	max = ,
	default = ,
	callback = (set)

,
})


 player = :().LocalPlayer
 userInputService = :()
 runService = :()

 jumpCooldown =   
 lastJumpTime = 
 antiAceEnabled =   

  ()
    
    


  ()
    
    


userInputService.InputBegan:((input, gameProcessedEvent)
      gameProcessedEvent  input.UserInputType == .UserInputType.Keyboard  input.KeyCode == .KeyCode.Space 
         antiAceEnabled 
             currentTime = ()
             currentTime - lastJumpTime > jumpCooldown 
                ()
                lastJumpTime = currentTime
            
                ()
            
        
            
        
    
)

runService.RenderStepped:(()
     antiAceEnabled 
        
        
        
    
)

Tab5:({
	Name = ,
	default = ,
	callback = (state)
        antiAceEnabled = state
    ,
})


UserInputService.InputBegan:((input, gameProcessedEvent)
      gameProcessedEvent  JumpToggleEnabled  input.KeyCode == .KeyCode.Space 
        ()
    
)

Tab5:({
	Name = ,
	callback = (state)
        
 decalsyeeted =  
 g = 
 w = g.Workspace
 l = g.Lighting
 t = w.Terrain
t.WaterWaveSize = 
t.WaterWaveSpeed = 
t.WaterReflectance = 
t.WaterTransparency = 
l.GlobalShadows = 
l.FogEnd = 
l.Brightness = 
().Rendering.QualityLevel = 
 i, v  (g:()) 
     v:()  v:()  v:()  v:() 
        v.Material = 
        v.Reflectance = 
     v:()  v:()  decalsyeeted 
        v.Transparency = 
     v:()  v:() 
        v.Lifetime = NumberRange.()
     v:() 
        v.BlastPressure = 
        v.BlastRadius = 
     v:()  v:()  v:() 
        v.Enabled = 
     v:() 
        v.Material = 
        v.Reflectance = 
        v.TextureID = 
    

 i, e  (l:()) 
     e:()  e:()  e:()  e:()  e:() 
        e.Enabled = 
    


    ,
})




 qbaimpred = 
Tab:({
	Name = ,
	default = ,
	callback = (v)
	qbaimpred = v 

	 qbaimpred 
		 beam = .()
		 a0 = .()
		 a1 = .()   
		 mouse = :().LocalPlayer:()
		beam.Color = ColorSequence.(.(, , ))
		beam.Transparency = NumberSequence.(, )
		beam.Segments =  * 
		beam.Name = 
		beam.Parent = .Terrain
		a0.Parent = .Terrain
		a1.Parent = .Terrain
		beam.Attachment0 = a0
		beam.Attachment1 = a1
		beam.Width0 = 
		beam.Width1 = 
		 qbaimpred 
			.()
			 :().LocalPlayer.Character:()  :().LocalPlayer.PlayerGui:()  :().LocalPlayer.Character:() 
				 power = (:().LocalPlayer.PlayerGui.BallGui.Frame.Disp.Text)
				 direction = (mouse.Hit.Position - .CurrentCamera.CFrame.Position).Unit
				 vel = power * direction
				 origin = :().LocalPlayer.Character.Head.Position + direction * 
				 c0, c1, cf1, cf2 = (.(, -, ), power * direction, :().LocalPlayer.Character.Head.Position + (direction * ), )
				a0.CFrame = a0.Parent.CFrame:() * cf1
				a1.CFrame = a1.Parent.CFrame:() * cf2
				beam.CurveSize0 = c0
				beam.CurveSize1 = c1
			
		
		beam:() 
	
		
		
	
})


 autoCatchDistance = 

  ()
      
        .()
         ball = ()
         ball 
             distance = (ball.Position - player.Character.HumanoidRootPart.Position).Magnitude
             distance < autoCatchDistance 
                () 
                () 
                .()
            
        
    


Tab6:({
	Name = ,
	default = ,
	callback = (value)
         value 

            ()
        
    ,
})

Tab6:({
	Name = ,
	min = ,
	max = ,
	default = ,
	callback = (value)
    
        autoCatchDistance = value
    ,
})








.(()
      
        .()

          saturn.Catching.mags 
            
        

         i, v  (:():()) 
             v.Name ==   v:() 
                 (:().LocalPlayer.Character.HumanoidRootPart.Position - v.Position).magnitude <= saturn.Catching.range 
                    (() 
                        (:().LocalPlayer.Character[], v, )
                        (:().LocalPlayer.Character[], v, )
                        (:().LocalPlayer.Character[], v, )
                        (:().LocalPlayer.Character[], v, )
                    )
                
            
        
    
)



 RunService = :()
 HitboxExpanderEnabled = 
 HitboxExpanderSize = 


Tab6:({
	Name = ,
	default = ,
	callback = (toggleValue)
 HitboxExpanderEnabled = toggleValue
    ,
})

Tab6:({
	Name = ,
	min = ,
	max = ,
	default = ,
	callback = (sliderValue)
    HitboxExpanderSize = sliderValue
    ,
})

(()
      
        ()
         HitboxExpanderEnabled 
             _, v  (:()) 
                 v.Name ==   v:() 
                     _, vp  ((v:())) 
                        vp:()
                    
                    v.CanCollide = 
                    v.Size = .(HitboxExpanderSize, HitboxExpanderSize, HitboxExpanderSize)
                
            
        
    
)




  (v)
     state = v
     transparency = state    
     model = :().Models.Field.Grass
    
     _, part  (model:()) 
         part:() 
            part.CanCollide =  state
            part.Transparency = transparency
        
    
    
     state 
         part = .()
        part.Size = .(, , )
        part.CFrame = .(.(, -, ))
        part.Anchored = 
        part.Parent = .Workspace
    
         Anim = .()
        Anim.AnimationId = 
         track = :().LocalPlayer.Character.Humanoid:(Anim)
        track:(, , )
    
         track ~=  
            track:()
        
    





 removeJumpCooldownConnection

Tab6:({
	Name = ,
	default = ,
	callback = (v)
         v 
            removeJumpCooldownConnection = userInputService.JumpRequest:(()
                 v 
                    player.Character.Humanoid:(.HumanoidStateType.Jumping, )
                
            )
        
             removeJumpCooldownConnection 
                removeJumpCooldownConnection:()
            
            
        
    ,
})


 infiniteJumpConnection

Tab5:({
	Name = ,
	default = ,
	callback = (v)
         v 
            infiniteJumpConnection = userInputService.JumpRequest:(()
                 v 
                    player.Character.Humanoid:(.HumanoidStateType.Jumping, )
                    player.Character.Humanoid:(.HumanoidStateType.Jumping)
                
            )
        
             infiniteJumpConnection 
                infiniteJumpConnection:()
            
            
        
    ,
})




  
	task.wait()
	if not qbon then 
		if oldHighlight then
			oldHighlight:Destroy()
			oldHighlight = nil
		end
		continue 
	end
	if not player.Character:FindFirstChild("Football") then
		if oldHighlight then
			oldHighlight:Destroy()
			oldHighlight = nil
		end
		Finium.Enabled = false
		sphere.Transparency = 1
	else
		Value.Text = mode
		if not silent then
			sphere.Transparency = 0
		else
			sphere.Transparency = 1
		end
		beam.Enabled = not silent
		Finium.Enabled = not silent
		if not locked then
			target = findtarget()
		end
		if not target then task.wait() continue end
		local highlight = Instance.new("Highlight")
		highlight.FillColor = Color3.fromRGB(0, 0, 0)
		highlight.Enabled = not silent
		highlight.Parent = target
		highlight.Adornee = target
		if oldHighlight then
			oldHighlight:Destroy()
			oldHighlight = nil
		end
		oldHighlight = highlight
		pwr, natpwr = findPower(target)
		local direction = Vector3.new(0, 0, 0)
		local moveDirection = getMoveDirection(target.Humanoid)
		local distance = (target.Head.Position - character.Head.Position).Magnitude
		if mode ~= "Bullet" then
			moveDirection = straightenMoveDirection(moveDirection)
			--local graph = visualization.new()
			local a = 0.985
			if mode == "Mag" then 
				a = 1.0009
			elseif mode == "Dime" then
				a = 1.0005	
			elseif mode == "Jump" then
				a = 0.98-- Same behavior as "Mag"
			elseif mode == "AngleDive" then
				a = 1.011	
			end
			if pwr > 80 then
				if character.Humanoid:GetState() ~= Enum.HumanoidStateType.Freefall then
					a += 0.013
				else
					a += 0.013
				end
			end
			pwr *= a
			pwr = math.clamp(pwr, 0, 100)
			at = target.Head.Position + (moveDirection * pwr + Vector3.new(0, (distance + (pwr / 2)), 0))
		else
			local estimated = distance / 95
			pwr = 95
			at = target.Head.Position + (moveDirection * 25 * estimated) + Vector3.new(0, (distance / 125 * 15), 0)
		end
		
		direction = (at - character.Head.Position).Unit
		--graph:Graph(pwr, direction)
		local lPosition, airtime = calculateLanding(pwr, direction)
		Value_2.Text = math.round(pwr)
		Value_3.Text = (math.round(airtime * 100) / 100).."s"
		sphere.Position = lPosition
		local curve0, curve1, cf1, cf2 = beamProjectile(Vector3.new(0, -28, 0), pwr * direction, character.Head.Position + (direction * 5),airtime * 1.75, 7)
		beam.Segments = 10 * 300
		beam.Color = ColorSequence.new(Color3.fromRGB(0, 0, 0))
		beam.CurveSize0 = curve0
		beam.CurveSize1 = curve1
		attach0.CFrame = attach0.Parent.CFrame:Inverse() * cf1
		attach1.CFrame = attach1.Parent.CFrame:Inverse() * cf2
		task.wait()	
	end
end