UNNAMED ESP | UNIVERSAL DRAWING ESP [UNBANNABLE]

(, )

     PROTOSMASHER_LOADED   

 UserInputService	= :;
 HttpService	= :;
 GUIService	= :;
 TweenService	= :;
 RunService	= :;
 Players		= :;
 LocalPlayer	= Players.LocalPlayer;
 Camera		= .CurrentCamera;
 Mouse		= LocalPlayer:();
 V2New		= .new;
 V3New		= .new;
 WTVP		= Camera.WorldToViewportPoint;
 WorldToViewport	= (...)  (Camera, ...) ;
 Menu		= {};
 MouseHeld		= ;
 LastRefresh	= ;
 OptionsFile	= ;
 Binding		= ;
 BindedKey		= ;
 OIndex		= ;
 LineBox		= {};
 UIButtons		= {};
 Sliders		= {};
 ColorPicker	= { Loading = ; LastGenerated =  };
 Dragging		= ;
 DraggingUI	= ;
 Rainbow		= ;
 DragOffset	= ();
 DraggingWhat	= ;
 OldData		= {};
 IgnoreList	= {};
 EnemyColor	= .(, , );
 TeamColor		= .(, , );
 MenuLoaded	= ;
 ErrorLogging	= ;
 TracerPosition	= (Camera.ViewportSize.X / , Camera.ViewportSize.Y - );
 DragTracerPosition= ;
 SubMenu 		= {};
 IsSynapse 	=    PROTOSMASHER_LOADED;
 Connections 	= { Active = {} };
 Signal 		= {}; Signal.__index = Signal;
 GetCharacter;
 CurrentColorPicker;
 Spectating;

 Executor = (identifyexecutor  (()   ))()
 SupportedExploits = { , , , ,  }
 QUAD_SUPPORTED_EXPLOIT = .(SupportedExploits, Executor) ~= 



.MenuDrawingData	= .MenuDrawingData  { Instances = {} };
.InstanceData	= .InstanceData  {};
.RSName		= .RSName  ( .. HttpService:());

 GetDataName	= .RSName .. ;
 UpdateName	= .RSName .. ;

 Debounce		= ({}, {
	__index = (t, i)
		 (t, i)  
	;
});

 .UESP_InputChangedCon  .UESP_InputChangedCon:() 
 .UESP_InputBeganCon  .UESP_InputBeganCon:() 
 .UESP_InputEndedCon  .UESP_InputEndedCon:() 
 .CurrentColorPicker  .CurrentColorPicker:() 

 RealPrint, LastPrintTick = , ;
 LatestPrints = ({}, { __index = (t, i)  (t, i)    });

  (...)
	 Content = {...};
	  = RealPrint;

	 () - LatestPrints[Content] >  
		LatestPrints[Content] = ();
		(Content);
	


  (HEX)
	HEX = HEX:(, );
	
	 .(( .. HEX:(, )), ( .. HEX:(, )), ( .. HEX:(, )));


  (String)
	 (String) ==  
		 String: ~=   #String ==   String ==   ;
	
	
	 ;


  (t, i, v)
	t[i] = v;


 Teams = {};
 CustomTeams = { 
	[] = {
		Initialize = ()
			Teams.Sheriffs = {}; 
			Teams.Bandits = {}; 
			 Func = ::(, );
			 Event = ::(, );
			 S, B = Func:;

			Teams.Sheriffs = S;
			Teams.Bandits = B;

			Event.OnClientEvent:((id, PlayerName, Team, Remove) 
				 id ==  
					 TeamTable, NotTeamTable
					 Team ==  
						TeamTable = TDM.Bandits
						NotTeamTable = TDM.Sheriffs
					
						TeamTable = TDM.Sheriffs
						NotTeamTable = TDM.Bandits
					
					 Remove 
						TeamTable[PlayerName] = 
					
						TeamTable[PlayerName] = 
						NotTeamTable[PlayerName] = 
					
					 PlayerName == LocalPlayer.Name 
						TDM.Friendlys = TeamTable
						TDM.Enemies = NotTeamTable
					
				
			)
		;
		CheckTeam = (Player)
			 LocalTeam = Teams.Sheriffs[LocalPlayer.Name]  Teams.Sheriffs  Teams.Bandits;
			
			 LocalTeam[Player.Name]    ;
		;
	};
	[] = {
		CheckTeam = (Player)
			 LocalLastName = LocalPlayer:   LocalLastName  (LocalLastName)    
			 PlayerLastName = Player:   PlayerLastName    

			 PlayerLastName == LocalLastName
		
	};
	[] = {
		CheckTeam = (Player)
			 LocalStats = LocalPlayer:;
			 LocalLastName = LocalStats  LocalStats:;   LocalLastName  (LocalLastName.Value)   ; 
			 PlayerStats = Player:;
			 PlayerLastName = PlayerStats  PlayerStats:;   PlayerLastName   ; 

			 PlayerLastName.Value == LocalLastName.Value;
		;
	};
    [] = {
		CheckTeam = (Player)
			 LocalStats = LocalPlayer:;
			 LocalGuildName = LocalStats  LocalStats:;   LocalGuildName  (LocalGuildName.Value)   ; 
			 PlayerStats = Player:;
			 PlayerGuildName = PlayerStats  PlayerStats:;   PlayerGuildName   ; 

			 PlayerGuildName.Value == LocalGuildName.Value;
		;
	};
    [] = {
		CheckTeam = (Player)
			 LocalStats = LocalPlayer:;
			 LocalGuildName = LocalStats  LocalStats:;   LocalGuildName  (LocalGuildName.Value)   ; 
			 PlayerStats = Player:;
			 PlayerGuildName = PlayerStats  PlayerStats:;   PlayerGuildName   ; 

			 PlayerGuildName.Value == LocalGuildName.Value;
		;
	};
};

 RenderList = {Instances = {}};

 RenderList:(, Obj2Draw, Text, Color)
	RenderList.Instances[] = { ParentInstance = ;  = Obj2Draw; Text = Text; Color = Color };
	 RenderList.Instances[];


 CustomPlayerTag;
 CustomESP;
 CustomCharacter;
 GetHealth;
 GetAliveState;
 CustomRootPartName;

 Modules = {
	[] = {
		CustomESP = ()
			 (.PF_Replication) ~=  
				 lastScan = .pfReplicationScan

				 (() - (lastScan  )) >  
					.pfReplicationScan = ()

					 gc = ()
					 i = , #gc 
						 gcObject = gc[i];
						 (gcObject) ==   ((gcObject, )) ==  
							.PF_Replication = gcObject;
							
						
					
				

				
			

			 Index, Player  (Players:()) 
				 Player == LocalPlayer   

				 Body = .PF_Replication.(Player);

				 (Body) ==   ((Body, )) ==  
					Player.Character = Body.torso.Parent
					
				

				Player.Character = ;
			
		,

		GetHealth = (Player)
			 (.pfHud) ~=  
				 
			

			 .pfHud:(Player)
		,

		GetAliveState = (Player)
			 (.pfHud) ~=  
				 lastScan = .pfHudScan

				 (() - (lastScan  )) >  
					.pfHudScan = ()

					 gc = ()
					 i = , #gc 
						 gcObject = gc[i];
						 (gcObject) ==   ((gcObject, )) ==  
							.pfHud = gcObject;
							
						
					
				

				
			

			 .pfHud:(Player)
		,

		CustomRootPartName = ,
	};
	[] = {
		CustomCharacter = (Player)
			 : 
				 .Players:(Player.Name);
			
		
	};
	[] = {
		CustomPlayerTag = (Player)
			 Player:  ( .. Player.Job.Value .. )  ;
		;
		CustomESP = ()
			 : 
				 i, v  (.MoneyPrinters:()) 
					 Main	= v:;
					 Owner	= v:;
					 Money	= v:  v.Int:  ;
					 Main  Owner  Money 
						 O = (Owner.Value);
						 M = (Money.Value);

						(RenderList.AddOrUpdateInstance, RenderList, v, Main, .(, O, M), .(, , ));
					
				
			
		;
	};
	
	
	
	
	

	
	
	
	
					
	
	
	

	
	
	
	
	
	
	[] = {
		CustomESP = ()
			 :  .Mobs: 
				 i, v  (.Mobs.Forest1:()) 
					 Main	= v:;
					 Hum	= v:;

					 Main  Hum 
						(RenderList.AddOrUpdateInstance, RenderList, v, Main, .(, v.Name, Hum.Health, Hum.MaxHealth), .(, , ));
					
				
			
		;
	};
	[] = {
		CustomESP = ()
			 : 
				 i, v  (:()) 
					 v.Name ==  
						 Main = v:;

						 Main 
							(RenderList.AddOrUpdateInstance, RenderList, v, Main, , .(, , ));
						
					
				
			
		;
	};
	[] = {
		CustomESP = ()
			
			
			
			

			
			
			
			
			
			
		;
		CustomPlayerTag = (Player)
			 .PlaceVersion <     

			 Name = ;
			 FirstName = Player:

			 (FirstName) ==   #FirstName >  
				 Prefix = ;
				 Extra = {};
				Name = Name .. ;

				 Player: >  
					Name = Name ..  .. (Player:) .. ;
				
				  (Player:) 
					Prefix = Player: ==   (Player: ==     )  ;
				
				  (FirstName) 
					Name = Name ..  .. Prefix .. FirstName;
				
				  (Player:) 
					Name = Name ..  .. Player:;
				

				  (Name)  Name = Name .. ; 

				 Character = (Player);

				 Character 
					 Character  Character:  .(Extra, ); 
					 Character:  Character.ManaAbilities:  .(Extra, ); 

					 Character:	 		 .(Extra,  .. .(Character.Mana.Value)); 
					 Character: 		 .(Extra, ); 
					 Character:		 .(Extra, ); 
					 Character:			 .(Extra, ); 
					 Character:  .(Extra, ); 
					 Character:		 	 .(Extra, ); 
					 Character:  Character.Head: 
						 FM = Character.Head:;
						 FM.Texture ==  
							.(Extra, );
						 FM.Texture ==  
							.(Extra, );
						 FM.Texture ==  
							.(Extra, );
						 FM.Texture ==  
							.(Extra, );
						
					
				
				 Player: 
					 Player.Backpack: 			 .(Extra, );  
					 Player.Backpack:			 .(Extra, );  
					 Player.Backpack: 	 .(Extra, ); 
					 Player.Backpack:		 	 .(Extra, ); 
				

				 #Extra >   Name = Name ..  .. .(Extra, ) .. ; 
			

			 Name;
		;
	};
	[] = {
		CustomPlayerTag = (Player)
			 Name = ;

			 Player: 
				Name = Name .. ;
				 Prefix = ;
				 Extra = {};
				 Player.leaderstats:  Player.leaderstats.Prestige.ClassName ==   Player.leaderstats.Prestige.Value >  
					Name = Name ..  .. (Player.leaderstats.Prestige.Value) .. ;
				
				 Player.leaderstats:  Player.leaderstats:  Player.leaderstats.HouseRank.ClassName ==    (Player.leaderstats.HouseRank.Value) 
					Prefix = Player.leaderstats.HouseRank.Value ==   (Player.leaderstats.Gender.Value ==     )  ;
				
				 Player.leaderstats:  Player.leaderstats.FirstName.ClassName ==    (Player.leaderstats.FirstName.Value) 
					Name = Name ..  .. Prefix .. Player.leaderstats.FirstName.Value;
				
				 Player.leaderstats:  Player.leaderstats.LastName.ClassName ==    (Player.leaderstats.LastName.Value) 
					Name = Name ..  .. Player.leaderstats.LastName.Value;
				
				 Player.leaderstats:  Player.leaderstats.UberTitle.ClassName ==    (Player.leaderstats.UberTitle.Value) 
					Name = Name ..  .. Player.leaderstats.UberTitle.Value;
				

				  (Name)  Name = Name .. ; 

				 Character = (Player);

				 Character 
					 Character  Character:  .(Extra, ); 
					 Character:  Character.ManaAbilities:  .(Extra, ); 

					 Character:	 		 .(Extra,  .. .(Character.Mana.Value)); 
					 Character: 		 .(Extra, );    
					 Character:			 .(Extra, );  
					 Character:			 .(Extra, );  
					
					 Character: 	 .(Extra, ); 
					 Character:  Character.Head: 
						 FM = Character.Head:;
						 FM.Texture ==  
							.(Extra, );
						 FM.Texture ==  
							.(Extra, );
						 FM.Texture ==  
							.(Extra, );
						
					
				
				 Player: 
					 Player.Backpack: 			 .(Extra, );  
					 Player.Backpack:			 .(Extra, );  
					 Player.Backpack: 	 .(Extra, ); 
				

				 #Extra >   Name = Name ..  .. .(Extra, ) .. ; 
			

			 Name;
		;
	};

	[] = { 
		CustomCharacter = (Player)
			 : 
				 .Players:(Player.Name);
			
		
	};

    [] = { 
		CustomPlayerTag = (Player)
			 Name = ;
            CharacterName = Player:; 

              (CharacterName) 
                Name = ():(CharacterName);
                 Character = (Player);
                 Extra = {};

                 Character 
                     Blood, Armor = Character:(), Character:();

                     Blood  Blood.ClassName ==  
                        .(Extra, ():(Blood.Value));
                    

                     Armor  Armor.ClassName ==  
                        .(Extra, ():(.(Armor.Value / )));
                    
                

                 BackpackChildren = Player.Backpack:()

                 index = , #BackpackChildren 
                     Oath = BackpackChildren[index]
                     Oath.ClassName ==   Oath.Name:() 
                         OathName = Oath.Name:(, )
                        .(Extra, OathName);
                    
                

                 #Extra >   Name = Name ..  .. .(Extra, ) .. ; 
            

			 Name;
		;
	};

    [] = { 
    CustomPlayerTag = (Player)
         Name = ;
        CharacterName = Player:; 

          (CharacterName) 
            Name = ():(CharacterName);
             Character = (Player);
             Extra = {};

             Character 
                 Blood, Armor = Character:(), Character:();

                 Blood  Blood.ClassName ==  
                    .(Extra, ():(Blood.Value));
                

                 Armor  Armor.ClassName ==  
                    .(Extra, ():(.(Armor.Value / )));
                
            

             BackpackChildren = Player.Backpack:()

             index = , #BackpackChildren 
                 Oath = BackpackChildren[index]
                 Oath.ClassName ==   Oath.Name:() 
                     OathName = Oath.Name:(, )
                    .(Extra, OathName);
                
            

             #Extra >   Name = Name ..  .. .(Extra, ) .. ; 
        

         Name;
    ;
};
};

 Modules[.PlaceId] ~=  
	 Module = Modules[.PlaceId];
	CustomPlayerTag = Module.CustomPlayerTag  ;
	CustomESP = Module.CustomESP  ;
	CustomCharacter = Module.CustomCharacter  ;
	GetHealth = Module.GetHealth  ;
	GetAliveState = Module.GetAliveState  ;
	CustomRootPartName = Module.CustomRootPartName  ;


 (Player)
	 Player.Character  (CustomCharacter  (Player));


 ()
	 UserInputService:();


 (Values)
	 X1, Y1, X2, Y2 = Values[], Values[], Values[], Values[]
	 MLocation = ();
	 (MLocation.x >= X1  MLocation.x <= (X1 + (X2 - X1)))  (MLocation.y >= Y1  MLocation.y <= (Y1 + (Y2 - Y1)));


 (t) 
	 (t) ~=    

	 (t, {
		__call = (t, func)
			 (func) ~=    ;
			 i, v  (t) 
				(func, i, v);
			
		;
	});

  (format, ...)
	 .(format, ...);

 (Min, Max, Percent)
	 Min + .(((Max - Min) * Percent) + );


 (InstanceName)
	  = .(InstanceName);
	
	 ((Properties)
		 i, v  (Properties) 
			(Set, , i, v);
		
		 ;
	)


 Menu:(Name, DrawingType, Properties)
	 ;

	 .MenuDrawingData.Instances[Name] ~=  
		 = .MenuDrawingData.Instances[Name];
		 i, v  (Properties) 
			(Set, , i, v);
		
	
		 = (DrawingType)(Properties);
	

	.MenuDrawingData.Instances[Name] = ;

	 ;

 Menu:(Name)
	  = .MenuDrawingData.Instances[Name];
	  ~=  
		 ((Properties)
			 i, v  (Properties) 
				(Set, , i, v);
			
			 ;
		)
	

 Menu:(Name)
	 .MenuDrawingData.Instances[Name];


 Options = ({}, {
	__call = (t, ...)
		 Arguments = {...};
		 Name = Arguments[];
		OIndex = OIndex + ;
		(t, Name, ({
			Name			= Arguments[];
			Text			= Arguments[];
			Value			= Arguments[];
			DefaultValue	= Arguments[];
			AllArgs			= Arguments;
			Index			= OIndex;
		}, {
			__call = (t, v, force)
				 self = t;

				 (t.Value) ==  
					t.();
				 (t.Value) ==  
					 BT = Menu:((, t.Name));
					  force 
						Binding = ;
						 Val = 
						 Binding 
							();
							Val = (Val + ) % ;
							BT.Text = Val <=     ;
						
					
					t.Value = force  v  BindedKey;
					 BT  t.BasePosition  t.BaseSize 
						BT.Text = (t.Value):;
						BT.Position = t.BasePosition + (t.BaseSize.X - BT.TextBounds.X - , -);
					
				
					 NewValue = v;
					 NewValue ==   NewValue =  t.Value; 
					(t, , NewValue);

					 Arguments[] ~=   Menu:.Visible 
						 (Arguments[]) ==  
							 AMT = Menu:((, t.Name));
							 AMT 
								AMT.Text = (t.Value);
							
						
							 Inner = Menu:((, t.Name));
							 Inner  Inner.Visible = t.Value; 
						
					
				
			;
		}));
	;
})

 ()
	 _, Result = (readfile, OptionsFile);
	
	 _  
		 _, Table = (HttpService.JSONDecode, HttpService, Result);
		 _  (Table) ==  
			 i, v  (Table) 
				 (Options[i]) ==   Options[i].Value ~=   ((Options[i].Value) ==   (Options[i].Value) == ) 
					Options[i].Value = v.Value;
					(Options[i], v.Value);
				
			

			 Table.TeamColor  TeamColor = .(Table.TeamColor.R, Table.TeamColor.G, Table.TeamColor.B) 
			 Table.EnemyColor  EnemyColor = .(Table.EnemyColor.R, Table.EnemyColor.G, Table.EnemyColor.B) 

			 (Table.MenuKey) ==   Options.(.KeyCode[Table.MenuKey], ) 
			 (Table.ToggleKey) ==   Options.(.KeyCode[Table.ToggleKey], ) 
		
	


(, , );
(, , );
(, , );
(, , );
(, , );
(, , );
(, , );
(, , );
(, , );
(, , );
(, , );
(, , );

(, ,     , , ); 
(, , , , );
(, , , , );
(, , , -, );
(, , .KeyCode.F4, );
(, , .KeyCode.F3, );
(, SENTINEL_LOADED    , ()
	 SENTINEL_LOADED   

	SubMenu:((), , {
		{
			Type = ; Text = ; Color = TeamColor;

			Function = (Circ, Position)
				 () - ColorPicker.LastGenerated <   ; 

				 .CurrentColorPicker  .CurrentColorPicker:() 
				 ColorPicker = ColorPicker.(Position - (-, ));
				CurrentColorPicker = ColorPicker;
				.CurrentColorPicker = CurrentColorPicker;
				ColorPicker.ColorChanged:((Color) Circ.Color = Color TeamColor = Color Options.TeamColor = Color );
			
		};
		{
			Type = ; Text = ; Color = EnemyColor;

			Function = (Circ, Position)
				 () - ColorPicker.LastGenerated <   ; 

				 .CurrentColorPicker  .CurrentColorPicker:() 
				 ColorPicker = ColorPicker.(Position - (-, ));
				CurrentColorPicker = ColorPicker;
				.CurrentColorPicker = CurrentColorPicker;
				ColorPicker.ColorChanged:((Color) Circ.Color = Color EnemyColor = Color Options.EnemyColor = Color );
			
		};
		{
			Type = ; Text = ;

			Function = ()
				EnemyColor = .(, , );
				TeamColor = .(, , );

				 C1 = Menu:;  C1  C1.Color = TeamColor 
				 C2 = Menu:;  C2  C2.Color = EnemyColor 
			
		};
		{
			Type = ; Text = ;

			Function = ()
				Rainbow =  Rainbow;
			
		};
	});
, );
(, , ()
	 i, v  (Options) 
		 Options[i] ~=   Options[i].Value ~=   Options[i].Text ~=   ((Options[i].Value) ==   (Options[i].Value) ==   (Options[i].Value) == ) 
			Options[i](Options[i].DefaultValue, );
		
	
, );
(, , Load, );
(, , ()
	 COptions = {};

	 i, v  (Options) 
		COptions[i] = v;
	
	
	 (TeamColor) ==   COptions.TeamColor = { R = TeamColor.R; G = TeamColor.G; B = TeamColor.B } 
	 (EnemyColor) ==   COptions.EnemyColor = { R = EnemyColor.R; G = EnemyColor.G; B = EnemyColor.B } 
	
	 (COptions.MenuKey.Value) ==   COptions.MenuKey = COptions.MenuKey.Value.Name 
	 (COptions.ToggleKey.Value) ==   COptions.ToggleKey = COptions.ToggleKey.Value.Name 

	(OptionsFile, HttpService:(COptions));
, );

();

(, , );

  (...)
	 Output = {};
	 i, v  {...} 
		 (v) ==  
			.(v, (i, v)
				Output[i] = v;
			)
		
	
	 Output


 LineBox:(Properties)
	 Box = { Visible =  }; 

	 Properties = ({
		Transparency	= ;
		Thickness		= ;
		Visible			= ;
	}, Properties);

	 .am_ic3  
		Box[]= NewDrawing(Properties);
		Box[] 		= NewDrawing(Properties);
	 QUAD_SUPPORTED_EXPLOIT 
		Box[]			= NewDrawing(Properties);
	
		Box[]		= NewDrawing(Properties);
		Box[]		= NewDrawing(Properties);
		Box[]	= NewDrawing(Properties);
		Box[]	= NewDrawing(Properties);
	

	 Box:(CF, Size, Color, Properties, Parts)
		  CF   Size   

		 .am_ic3  (Parts) ==  
			 AllCorners = {};
			
			 i, v  (Parts) 
				
				
				 CF, Size = v.CFrame, v.Size;
				

				 Corners = {
					.(CF.X + Size.X / , CF.Y + Size.Y / , CF.Z + Size.Z / );
					.(CF.X - Size.X / , CF.Y + Size.Y / , CF.Z + Size.Z / );
					.(CF.X - Size.X / , CF.Y - Size.Y / , CF.Z - Size.Z / );
					.(CF.X + Size.X / , CF.Y - Size.Y / , CF.Z - Size.Z / );
					.(CF.X - Size.X / , CF.Y + Size.Y / , CF.Z - Size.Z / );
					.(CF.X + Size.X / , CF.Y + Size.Y / , CF.Z - Size.Z / );
					.(CF.X - Size.X / , CF.Y - Size.Y / , CF.Z + Size.Z / );
					.(CF.X + Size.X / , CF.Y - Size.Y / , CF.Z + Size.Z / );
				};

				 i, v  (Corners) 
					.(AllCorners, v);
				

				
			

			 xMin, yMin = Camera.ViewportSize.X, Camera.ViewportSize.Y;
			 xMax, yMax = , ;
			 Vs = ;

			 i, v  (AllCorners) 				
				 Position, V = (v);

				 VS   V  Vs =   

				 Position.X > xMax 
					xMax = Position.X;
				
				 Position.X < xMin 
					xMin = Position.X;
				
				 Position.Y > yMax 
					yMax = Position.Y;
				
				 Position.Y < yMin 
					yMin = Position.Y;
				
			

			 xSize, ySize = xMax - xMin, yMax - yMin;

			 Outline = Box[];
			 Square = Box[];
			Outline.Visible = Vs;
			Square.Visible = Vs;
			Square.Position = (xMin, yMin);
			Square.Color	= Color;
			Square.Thickness = .(Outline.Thickness * );
			
			Square.Size = (xSize, ySize);
			Outline.Position = Square.Position;
			Outline.Size = Square.Size;
			Outline.Color = .(, , );
			Outline.Transparency = ;

			
		
		
		 TLPos, Visible1	= ((CF * .( Size.X,  Size.Y, )).Position);
		 TRPos, Visible2	= ((CF * .(-Size.X,  Size.Y, )).Position);
		 BLPos, Visible3	= ((CF * .( Size.X, -Size.Y, )).Position);
		 BRPos, Visible4	= ((CF * .(-Size.X, -Size.Y, )).Position);

		 Quad = Box[];

		 QUAD_SUPPORTED_EXPLOIT 
			 Visible1  Visible2  Visible3  Visible4 
				Quad.Visible = ;
				Quad.Color	= Color;
				Quad.PointA = (TLPos.X, TLPos.Y);
				Quad.PointB = (TRPos.X, TRPos.Y);
				Quad.PointC = (BRPos.X, BRPos.Y);
				Quad.PointD = (BLPos.X, BLPos.Y);
			
				Box[].Visible = ;
			
		
			Visible1 = TLPos.Z >  
			Visible2 = TRPos.Z >  
			Visible3 = BLPos.Z >  
			Visible4 = BRPos.Z >  

			
			 Visible1 
				Box[].Visible		= ;
				Box[].Color		= Color;
				Box[].From			= (TLPos.X, TLPos.Y);
				Box[].To			= (TRPos.X, TRPos.Y);
			
				Box[].Visible		= ;
			
			 Visible2 
				Box[].Visible		= ;
				Box[].Color		= Color;
				Box[].From		= (TRPos.X, TRPos.Y);
				Box[].To			= (BRPos.X, BRPos.Y);
			
				Box[].Visible		= ;
			
			 Visible3 
				Box[].Visible	= ;
				Box[].Color		= Color;
				Box[].From		= (BLPos.X, BLPos.Y);
				Box[].To		= (TLPos.X, TLPos.Y);
			
				Box[].Visible	= ;
			
			 Visible4 
				Box[].Visible	= ;
				Box[].Color	= Color;
				Box[].From		= (BRPos.X, BRPos.Y);
				Box[].To		= (BLPos.X, BLPos.Y);
			
				Box[].Visible	= ;
			
			
			 Properties  (Properties) ==  
				(Properties)((i, v)
					(Set, Box[],		i, v);
					(Set, Box[],		i, v);
					(Set, Box[],	i, v);
					(Set, Box[],	i, v);
				)
			
		
	
	 Box:(bool)
		 .am_ic3 
			Box[].Visible = bool;
			Box[].Visible = bool;
		
			(Set, Box[],				, bool);
		
		
		
		
		
	
	 Box:()
		self:();
		 .am_ic3 
			Box[]:();
			Box[]:();
		
			Box[]:();
		
		
		
		
		
	

	 Box;


 Colors = {
	White = FromHex;
	Primary = {
		Main	= FromHex;
		Light	= FromHex;
		Dark	= FromHex;
	};
	Secondary = {
		Main	= FromHex;
		Light	= FromHex;
		Dark	= FromHex;
	};
};

 Connections:(Connection, Function)
     NewConnection = Connection:(Function);
    .(self.Active, NewConnection);
     NewConnection;


 Connections:()
     Index, Connection  (self.Active) 
         Connection.Connected 
            Connection:();
        
    
    
    self.Active = {};


 Signal.()
	 self = ({ _BindableEvent = .new }, Signal);
    
	 self;


 Signal:(Callback)
    ((Callback) == ,  .. (Callback));

	 self._BindableEvent.Event:((...) (...) );


 Signal:(...)
    self._BindableEvent:(...);


 Signal:()
     Arguments = self._BindableEvent:();

     Arguments;


 Signal:()
     self._BindableEvent 
        self._BindableEvent:();
    


  ()
	 UserInputService:();


  (, MousePosition)
	 TopLeft = .Position;
	 BottomRight = .Position + .Size;
     MousePosition = MousePosition  ();
    
     MousePosition.X > TopLeft.X  MousePosition.Y > TopLeft.Y  MousePosition.X < BottomRight.X  MousePosition.Y < BottomRight.Y;


 ImageCache = {};

  (, Url)
	 Data = IsSynapse  :(Url)  Url;

	(, IsSynapse)

	[IsSynapse    ] = ImageCache[Url]  Data;
	ImageCache[Url] = Data;
    
      IsSynapse   ()  .Loaded; 





  ()
     Drawings = { __Objects = {} };
     Metatable = {};

     Metatable.(self, Index)
         Object = (self.__Objects, Index);
        
          Object  (IsSynapse   Object.__SELF.__OBJECT_EXISTS) 
             Type = Index:(, Index: - );

            Success, Object = (.new, Type);

              Object   Success   () ; 

            self.__Objects[Index] = ({ __SELF = Object; Type = Type }, {
                __call = (self, Properties)
                     Object = (self, );  IsSynapse   Object.__OBJECT_EXISTS   , ; 

                     Properties ==  
                        Object.Visible = ;
                        Object.Transparency = ;
                        Object:();
                        
                         ;
                    
                    
                     (Properties) ==  
                         Property, Value  (Properties) 
                             CanSet = ;

                             self.Type ==    IsSynapse  Property ==   (Value) ==  
                                CanSet = ;

                                (()
                                     ()  Object.Loaded;
                                      self.DefaultSize  (self, , Object.Size) 

                                    Property = ;
                                    Value = Value.X / self.DefaultSize.X;

                                    Object[Property] = Value
                                )
                            
                            
                             CanSet  Object[Property] = Value 
                        
                    

                     Object;
                
            });

            Object.Visible = ;
            Object.Transparency = ; 
            
             Type ==  
                 .Fonts  Object.Font = .Fonts.Monospace 
                Object.Size = ;
                Object.Color = .(, , );
                Object.Center = ;
				Object.Outline = ;
				OutlineOpacity = ;
             Type ==   Type ==  
                Object.Thickness = ;
                Object.Filled = ;
            

             self.__Objects[Index];
        

         Object;
    

     Metatable.(self, Delete, ...)
         Arguments = {Delete, ...};
        
         Delete ==  
             Index,   ((self, )) 
                ();
            
        
    

     (Drawings, Metatable);


 Images = {};

(()
	Images.Ring = ;
	Images.Overlay = ;
)

 ColorPicker.(Position, Size, Color)
	ColorPicker.LastGenerated = ();
	ColorPicker.Loading = ;

     Picker = { Color = Color  .(, , ); HSV = { H = , S = , V =  } };
     Drawings = ();
     Position = Position  ();
     Size = Size  ;
     Padding = { , , ,  };
    
    Picker.ColorChanged = Signal.();

     Background = Drawings[] {
        Color = .(, , );
		Filled = ;
		Visible = ;
        Position = Position - (Padding[], Padding[]);
        Size = (Size, Size) + (Padding[] + Padding[], Padding[] + Padding[]);
    };
     ColorPreview = Drawings[] {
        Position = Position + ((Size, Size) / );
        Radius = Size /  - ;
        Filled = ;
        Thickness = ;
        NumSides = ;
        Color = .(, , );
    };
     Main = Drawings[] {
        Position = Position;
        Size = (Size, Size);
    }; (Main, Images.Ring);
     Preview = Drawings[] {
        Position = Main.Position + (Main.Size / );
        Size = Main.Size / ;
        Color = .(, , );
        Filled = ;
        Thickness = ;
    };
     Overlay = Drawings[] {
        Position = Preview.Position;
        Size = Preview.Size;
        Transparency = ;
    }; (Overlay, Images.Overlay);
     CursorOutline = Drawings[] {
        Radius = ;
        Thickness = ;
        Filled = ;
        Color = .(, , );
        Position = (Main.Position.X + Main.Size.X - , Main.Position.Y + (Main.Size.Y / ));
    };
     Cursor = Drawings[] {
        Radius = ;
        Transparency = ;
        Filled = ;
        Color = .(, , );
        Position = CursorOutline.Position;
    };
     CursorOutline = Drawings[] {
        Radius = ;
        Thickness = ;
        Filled = ;
        Color = .(, , );
        Position = (Preview.Position.X + Preview.Size.X - , Preview.Position.Y + );
    };
    Drawings[] {
        Radius = ;
        Transparency = ;
        Filled = ;
        Color = .(, , );
        Position = CursorOutline.Position;
    };
    
     Picker:(Input)
         MousePosition = (Input.Position.X, Input.Position.Y + );

         self.MouseHeld 
             self.Item ==  
                 Main = self.Drawings[] ();
                 Preview = self.Drawings[] ();
                 Bounds = Main.Size / ;
                 Center = Main.Position + Bounds;
                 Relative = MousePosition - Center;
                 Direction = Relative.unit;
                 Position = Center + Direction * Main.Size.X / ;
                 H = (.(Position.Y - Center.Y, Position.X - Center.X)) * ;
                 H <   H =  + H; 
                H = H / ;
                self.HSV.H = H;
                 EndColor = .(H, self.HSV.S, self.HSV.V);  EndColor ~= self.Color  self.ColorChanged:(self.Color); 
                 Pointer = self.Drawings[] { Position = Position };
                self.Drawings[] { Position = Pointer.Position };
                Bounds = Bounds * ;
                Preview.Color = .(H, , );
                self.Color = EndColor;
                self.Drawings[] { Color = EndColor };
             self.Item ==  
                 Preview = self.Drawings[] ();
                 HSV = self.HSV;
                 Position = (.(MousePosition.X, Preview.Position.X, Preview.Position.X + Preview.Size.X), .(MousePosition.Y, Preview.Position.Y, Preview.Position.Y + Preview.Size.Y));
                HSV.S = (Position.X - Preview.Position.X) / Preview.Size.X;
                HSV.V =  - (Position.Y - Preview.Position.Y) / Preview.Size.Y;
                 EndColor = .(HSV.H, HSV.S, HSV.V);  EndColor ~= self.Color  self.ColorChanged:(self.Color); 
                self.Color = EndColor;
                self.Drawings[] { Color = EndColor };
                 Pointer = self.Drawings[] { Position = Position };
                self.Drawings[] { Position = Pointer.Position };
            
        
    

     Picker:(Input, P, Type)
         Type ==  
             Input.UserInputType.Name ==  
                 Main = self.Drawings[] ();
                 SquareSV = self.Drawings[] ();
                 MousePosition = (Input.Position.X, Input.Position.Y + );
                self.MouseHeld = ;
                 Bounds = Main.Size / ;
                 Center = Main.Position + Bounds;
                 R = (MousePosition - Center);
        
                 R.Magnitude < Bounds.X  R.Magnitude > Bounds.X -  
                    self.Item = ;
                
                
                 MousePosition.X > SquareSV.Position.X  MousePosition.Y > SquareSV.Position.Y  MousePosition.X < SquareSV.Position.X + SquareSV.Size.X  MousePosition.Y < SquareSV.Position.Y + SquareSV.Size.Y 
                    self.Item = ;
                

                self:(Input, P);
            
         Type ==  
             Input.UserInputType.Name ==  
                self:(Input, P);
            
         Type ==   Input.UserInputType.Name ==  
            self.Item = ;
        
	
	
	 Picker:()
		self.();
		self.UpdatePosition = ;
		self.HandleInput = ;
		Connections:(); 
	

	Connections:(UserInputService.InputBegan, (Input, Process)
		Picker:(Input, Process, );
	);
	Connections:(UserInputService.InputChanged, (Input, Process)
		 Input.UserInputType.Name ==  
			 MousePosition = (Input.Position.X, Input.Position.Y + );
			 Cursor = Picker.Drawings[] {
				Filled = ;
				Color = .(, , );
				PointA = MousePosition + (, );
				PointB = MousePosition + (, );
				PointC = MousePosition + (, );
				Thickness = ;
			};
		
		Picker:(Input, Process, );
	);
	Connections:(UserInputService.InputEnded, (Input, Process)
		Picker:(Input, Process, );
		
		 Input.UserInputType.Name ==  
			Picker.MouseHeld = ;
		
	);

	ColorPicker.Loading = ;

    Picker.Drawings = Drawings;
     Picker;


 SubMenu:(Position, Title, Options)
	self.Open = ;

	 Visible = ;
	 BasePosition = Position;
	 BaseSize = (, );
	 End = BasePosition + BaseSize;

	self.Bounds = { BasePosition.X, BasePosition.Y, End.X, End.Y };

	(, ()
		  self.Open  ; 

		Menu:(, , {
			Size		= BaseSize;
			Position	= BasePosition;
			Filled		= ;
			Color		= Colors.Primary.Main;
			Thickness	= ;
			Visible		= Visible;
		});
	);
	Menu:(, , {
		Position	= BasePosition;
		Size		= (BaseSize.X, );
		Color		= Colors.Primary.Dark;
		Filled		= ;
		Visible		= Visible;
	});
	Menu:(, , {
		Position 	= BasePosition + (, );
		Size		= (BaseSize.X, );
		Color		= Colors.Primary.Main;
		Filled		= ;
		Visible		= Visible;
	});
	Menu:(, , {
		Size 		= ;
		Position	= .MenuDrawingData.Instances[].Position + (, -);
		Text		= Title  ;
		Color		= Colors.Secondary.Light;
		Visible		= Visible;
	});
	Menu:(, , {
		Size		= BaseSize - (, );
		Position	= BasePosition + (, );
		Filled		= ;
		Color		= Colors.Secondary.Main;
		Transparency= ;
		Visible		= Visible;
	});

	 Options 
		 Index, Option  (Options)  
			  (Name)  ():(Name, Index) 
			 Position = .MenuDrawingData.Instances[].Position + (, Index *  - );
			

			 Option.Type ==  
				 ColorPreview = Menu:(GetName, , {
					Position = Position;
					Color = Option.Color;
					Radius = IsSynapse    ;
					NumSides = ;
					Filled = ;
					Visible = ;
				});
				 Text = Menu:(GetName, , {
					Text = Option.Text;
					Position = ColorPreview.Position + (, -);
					Size = ;
					Color = Colors.Primary.Dark;
					Visible = ;
				});
				UIButtons[#UIButtons + ] = {
					FromSubMenu = ;
					Option = ()  Option.(ColorPreview, BasePosition + (BaseSize.X, )) ;
					 = Menu:((, GetName), , {
						Position	= Position - (, );
						Size		= (BaseSize.X, );
						Visible		= ;
					});
				};
			 Option.Type ==  
				UIButtons[#UIButtons + ] = {
					FromSubMenu = ;
					Option = Option.Function;
					 = Menu:((, GetName), , {
						Size		= (BaseSize.X, ) - (, );
						Visible		= ;
						Transparency= ;
						Position	= Position - (, );
						Color		= Colors.Secondary.Light;
						Filled		= ;
					});
				};
				 Text		= Menu:((, GetName), , {
					Text		= Option.Text;
					Size		= ;
					Position	= Position + (, -);
					Visible		= ;
					Color		= Colors.Primary.Dark;
				});
			
		
	


 SubMenu:()
	self.Open = ;

	 i, v  (.MenuDrawingData.Instances) 
		 i:(, ) ==  
			v.Visible = ;

			 i:(, ) ==   
				v:();
				.MenuDrawingData.Instance[i] = ;
			
		
	

	 i, Button  (UIButtons) 
		 Button.FromSubMenu 
			UIButtons[i] = ;
		
	

	(() 
		 i = ,  
			 .CurrentColorPicker  
				.CurrentColorPicker:();
			
			();
		
	)

	CurrentColorPicker = ;


 (NewPosition) 
	MenuLoaded = ;
	UIButtons  = {};
	Sliders	   = {};

	 BaseSize = (, );
	 BasePosition = NewPosition  (Camera.ViewportSize.X /  - (BaseSize.X / ), Camera.ViewportSize.Y /  - (BaseSize.Y / ));

	BasePosition = (.(BasePosition.X, , Camera.ViewportSize.X), .(BasePosition.Y, , Camera.ViewportSize.Y));

	Menu:(, , {
		Visible			= ;
		Color			= .(, , );
		Transparency	= ;
		Thickness		= ;
	});
	Menu:(, , {
		Visible			= ;
		Color			= .(, , );
		Transparency	= ;
		Thickness		= ;
	});

	(, () 
		Menu:(, , {
			Size		= BaseSize;
			Position	= BasePosition;
			Filled		= ;
			Color		= Colors.Primary.Main;
			Thickness	= ;
			Visible		= ;
		});
	);
	Menu:(, , {
		Position	= BasePosition;
		Size		= (BaseSize.X, );
		Color		= Colors.Primary.Dark;
		Filled		= ;
		Visible		= ;
	});
	Menu:(, , {
		Position 	= BasePosition + (, );
		Size		= (BaseSize.X, );
		Color		= Colors.Primary.Main;
		Filled		= ;
		Visible		= ;
	});
	Menu:(, , {
		Size 		= ;
		Position	= .MenuDrawingData.Instances.TopBarTwo.Position + (, );
		Text		= ;
		Color		= Colors.Secondary.Light;
		Visible		= ;
		Transparency= ; 
		Outline 	= ;
		OutlineOpacity = ;
	});
	Menu:(, , {
		Size 		= ;
		Position	= .MenuDrawingData.Instances.TopBarTwo.Position + (BaseSize.X - , );
		Text		= ;
		Color		= Colors.Secondary.Light;
		Visible		= ;
		Transparency= ;
		Outline 	= ;
		OutlineOpacity = ;
	});
	Menu:(, , {
		Size		= BaseSize - (, );
		Position	= BasePosition + (, );
		Filled		= ;
		Color		= Colors.Secondary.Main;
		Transparency= ;
		Visible		= ;
	});

	 CPos = ;

	(Options)((i, v)
		 (v.Value) ==    (v.Text)  v.Text ~=  
			CPos 				= CPos + ;
			 BaseSize		= (BaseSize.X, );
			 BasePosition	= .MenuDrawingData.Instances.Filling.Position + (, v.Index *  - );
			UIButtons[#UIButtons + ] = {
				Option = v;
				 = Menu:((, v.Name), , {
					Position	= BasePosition - (, );
					Size		= BaseSize;
					Visible		= ;
				});
			};
			Menu:((, v.Name), , {
				Radius		= ;
				Position	= BasePosition;
				Color		= Colors.Secondary.Light;
				Filled		= ;
				Visible		= ;
			});
			Menu:((, v.Name), , {
				Radius		= ;
				Position	= BasePosition;
				Color		= Colors.Secondary.Dark;
				Filled		= ;
				Visible		= v.Value;
			});
			Menu:((, v.Name), , {
				Text		= v.Text;
				Size		= ;
				Position	= BasePosition + (, -);
				Visible		= ;
				Color		= Colors.Secondary.Light;
				Transparency= ;
				Outline		= ;
				OutlineOpacity = ;
			});
		
	)
	(Options)((i, v) 
		 (v.Value) ==  
			CPos 				= CPos + ;

			 BaseSize		= (BaseSize.X, );
			 BasePosition	= .MenuDrawingData.Instances.Filling.Position + (, CPos - );

			 Line			= Menu:((, v.Name), , {
				Transparency	= ;
				Color			= Colors.Secondary.Light;
				
				Filled			= ;
				Visible			= ;
				Position 		= BasePosition + (, -);
				Size 			= BaseSize - (, );
				Transparency	= ;
			});
			 Slider		= Menu:((, v.Name), , {
				Visible			= ;
				Filled			= ;
				Color			= Colors.Primary.Dark;
				Size			= (, Line.Size.Y);
				Transparency	= ;
			});
			 Text			= Menu:((, v.Name), , {
				Text			= v.Text;
				Size			= ;
				Center			= ;
				Transparency	= ;
				Outline			= ;
				OutlineOpacity  = ;
				Visible			= ;
				Color			= Colors.White;
			}); Text.Position	= Line.Position + (Line.Size / ) - (, Text.TextBounds.Y / );
			 AMT			= Menu:((, v.Name), , {
				Text			= (v.Value);
				Size			= ;
				Center			= ;
				Transparency	= ;
				Outline			= ;
				OutlineOpacity  = ;
				Visible			= ;
				Color			= Colors.White;
				Position		= Text.Position;
			});

			 CSlider = {Slider = Slider; Line = Line; Min = v.AllArgs[]; Max = v.AllArgs[]; Option = v};
			 Dummy = .new;

			Dummy::(()
				Text.Transparency = Dummy.Value;
				
				AMT.Transparency =  - Dummy.Value;
			);

			Dummy.Value = ;

			 CSlider:(Bool)
				self.ShowingValue = Bool;

				TweenService:(Dummy, TweenInfo.(, .EasingStyle.Quart, .EasingDirection.Out), { Value = Bool     }):();
			

			Sliders[#Sliders + ] = CSlider;

			
			
			

			Slider.Position = Line.Position + (, );
			
			v.BaseSize = BaseSize;
			v.BasePosition = BasePosition;
			
		
	)
	 FirstItem = ;
	(Options)((i, v) 
		 (v.Value) ==  
			CPos 				= CPos + ( FirstItem    );
			FirstItem			= ;

			 BaseSize		= (BaseSize.X, FirstItem    );
			 BasePosition	= .MenuDrawingData.Instances.Filling.Position + (, CPos - );

			UIButtons[#UIButtons + ] = {
				Option = v;
				 = Menu:((, v.Name), , {
					Size		= (BaseSize.X, ) - (, );
					Visible		= ;
					Transparency= ;
					Position	= BasePosition + (, -);
					Color		= Colors.Secondary.Light;
					Filled		= ;
				});
			};
			 Text		= Menu:((, v.Name), 'Text', {
				Text		= v.Text;
				Size		= 20;
				Position	= BasePosition + V2New(20, -10);
				Visible		= true;
				Color		= Colors.Secondary.Light;
				Transparency= 1;
				Outline		= true;
				OutlineOpacity = 0.5;
			});
			local BindText	= Menu:AddMenuInstance(Format('%s_BindText', v.Name), 'Text', {
				Text		= tostring(v.Value):match'%w+%.%w+%.(.+)';
				Size		= 20;
				Position	= BasePosition;
				Visible		= true;
				Color		= Colors.Secondary.Light;
				Transparency= 1;
				Outline		= true;
				OutlineOpacity = 0.5;
			});

			Options[i].BaseSize = BaseSize;
			Options[i].BasePosition = BasePosition;
			BindText.Position = BasePosition + V2New(BaseSize.X - BindText.TextBounds.X - 20, -10);
		end
	end)
	GetTableData(Options)(function(i, v) -- just to make sure certain things are drawn before or after others, too lazy to actually sort table
		if typeof(v.Value) == 'function' then
			local BaseSize		= V2New(BaseSize.X, 30);
			local BasePosition	= shared.MenuDrawingData.Instances.Filling.Position + V2New(0, CPos + (25 * v.AllArgs[4]) - 35);

			UIButtons[#UIButtons + 1] = {
				Option = v;
				Instance = Menu:AddMenuInstance(Format('%s_Hitbox', v.Name), 'Square', {
					Size		= V2New(BaseSize.X, 20) - V2New(30, 0);
					Visible		= true;
					Transparency= .5;
					Position	= BasePosition + V2New(15, -10);
					Color		= Colors.Secondary.Light;
					Filled		= true;
				});
			};
			local Text		= Menu:AddMenuInstance(Format('%s_Text', v.Name), 'Text', {
				Text		= v.Text;
				Size		= 20;
				Position	= BasePosition + V2New(20, -10);
				Visible		= true;
				Color		= Colors.Secondary.Light;
				Transparency= 1;
				Outline		= true;
				OutlineOpacity = 0.5;
			});

			-- BindText.Position = BasePosition + V2New(BaseSize.X - BindText.TextBounds.X - 10, -10);
		end
	end)

	delay(.1, function()
		MenuLoaded = true;
	end);

	-- this has to be at the bottom cuz proto drawing api doesnt have zindex :triumph:	
	Menu:AddMenuInstance('Cursor1', 'Line', {
		Visible			= false;
		Color			= Color3.new(1, 0, 0);
		Transparency	= 1;
		Thickness		= 2;
	});
	Menu:AddMenuInstance('Cursor2', 'Line', {
		Visible			= false;
		Color			= Color3.new(1, 0, 0);
		Transparency	= 1;
		Thickness		= 2;
	});
	Menu:AddMenuInstance('Cursor3', 'Line', {
		Visible			= false;
		Color			= Color3.new(1, 0, 0);
		Transparency	= 1;
		Thickness		= 2;
	});
end

CreateMenu();
delay(0.1, function()
	SubMenu:Show(V2New()); -- Create the submenu
	SubMenu:Hide();
end);

shared.UESP_InputChangedCon = UserInputService.InputChanged:Connect(function(input)
	if input.UserInputType.Name == 'MouseMovement' and Options.MenuOpen.Value then
		for i, v in pairs(Sliders) do
			local Values = {
				v.Line.Position.X;
				v.Line.Position.Y;
				v.Line.Position.X + v.Line.Size.X;
				v.Line.Position.Y + v.Line.Size.Y;
			};
			if MouseHoveringOver(Values) then
				v:ShowValue(true);
			else
				if not MouseHeld then v:ShowValue(false); end
			end
		end
	end
end)
shared.UESP_InputBeganCon = UserInputService.InputBegan:Connect(function(input)
	if input.UserInputType.Name == 'MouseButton1' and Options.MenuOpen.Value then
		MouseHeld = true;
		local Bar = Menu:GetInstance'TopBar';
		local Values = {
			Bar.Position.X;
			Bar.Position.Y;
			Bar.Position.X + Bar.Size.X;
			Bar.Position.Y + Bar.Size.Y;
		}
		if MouseHoveringOver(Values) then
			DraggingUI = true;
			DragOffset = Menu:GetInstance'Main'.Position - GetMouseLocation();
		else
			for i, v in pairs(Sliders) do
				local Values = {
					v.Line.Position.X;
					v.Line.Position.Y;
					v.Line.Position.X + v.Line.Size.X;
					v.Line.Position.Y + v.Line.Size.Y;
					-- v.Line.From.X	- (v.Slider.Radius);
					-- v.Line.From.Y	- (v.Slider.Radius);
					-- v.Line.To.X		+ (v.Slider.Radius);
					-- v.Line.To.Y		+ (v.Slider.Radius);
				};
				if MouseHoveringOver(Values) then
					DraggingWhat = v;
					Dragging = true;
					break
				end
			end

			if not Dragging then
				local Values = {
					TracerPosition.X - 10;
					TracerPosition.Y - 10;
					TracerPosition.X + 10;
					TracerPosition.Y + 10;
				};
				if MouseHoveringOver(Values) then
					DragTracerPosition = true;
				end
			end
		end
	end
end)
shared.UESP_InputEndedCon = UserInputService.InputEnded:Connect(function(input)
	if input.UserInputType.Name == 'MouseButton1' and Options.MenuOpen.Value then
		MouseHeld = false;
		DragTracerPosition = false;
		local IgnoreOtherInput = false;

		if SubMenu.Open and not MouseHoveringOver(SubMenu.Bounds) then
			if CurrentColorPicker and IsMouseOverDrawing(CurrentColorPicker.Drawings['Square-Background']()) then IgnoreOtherInput = true; end
			if not IgnoreOtherInput then SubMenu:Hide() end
		end

		if not IgnoreOtherInput then
			for i, v in pairs(UIButtons) do
				if SubMenu.Open and MouseHoveringOver(SubMenu.Bounds) and not v.FromSubMenu then continue end

				local Values = {
					v.Instance.Position.X;
					v.Instance.Position.Y;
					v.Instance.Position.X + v.Instance.Size.X;
					v.Instance.Position.Y + v.Instance.Size.Y;
				};
				if MouseHoveringOver(Values) then
					v.Option();
					IgnoreOtherInput = true;
					break -- prevent clicking 2 options
				end
			end
			for i, v in pairs(Sliders) do
				if IgnoreOtherInput then break end

				local Values = {
					v.Line.Position.X;
					v.Line.Position.Y;
					v.Line.Position.X + v.Line.Size.X;
					v.Line.Position.Y + v.Line.Size.Y;
				};
				if not MouseHoveringOver(Values) then
					v:ShowValue(false);
				end
			end
		end
	elseif input.UserInputType.Name == 'MouseButton2' and Options.MenuOpen.Value and not DragTracerPosition then
		local Values = {
			TracerPosition.X - 10;
			TracerPosition.Y - 10;
			TracerPosition.X + 10;
			TracerPosition.Y + 10;
		}
		if MouseHoveringOver(Values) then
			DragTracerPosition = false;
			TracerPosition = V2New(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y - 135);
		end
	elseif input.UserInputType.Name == 'Keyboard' then
		if Binding then
			BindedKey = input.KeyCode;
			Binding = false;
		elseif input.KeyCode == Options.MenuKey.Value or (input.KeyCode == Enum.KeyCode.Home and UserInputService:IsKeyDown(Enum.KeyCode.LeftControl)) then
			Options.MenuOpen();
		elseif input.KeyCode == Options.ToggleKey.Value then
			Options.Enabled();
		elseif input.KeyCode.Name == 'F1' and UserInputService:IsMouseButtonPressed(1) and shared.am_ic3 then -- hehe hiden spectate feature cuz why not
			local HD, LPlayer, LCharacter = 0.95;

			for i, Player in pairs(Players:GetPlayers()) do
				local Character = GetCharacter(Player);

				if Player ~= LocalPlayer and Player ~= Spectating and Character and Character:FindFirstChild'HumanoidRootPart' then
					local Head = Character:FindFirstChild'Head';
					local Humanoid = Character:FindFirstChildOfClass'Humanoid';
					
					if Head then
						local Distance  = (Camera.CFrame.Position - Head.Position).Magnitude;
						
						if Distance > Options.MaxDistance.Value then continue; end

						local Direction = -(Camera.CFrame.Position - Mouse.Hit.Position).unit;
						local Relative  = Character.Head.Position - Camera.CFrame.Position;
						local Unit      = Relative.unit;

						local DP = Direction:Dot(Unit);

						if DP > HD then
							HD = DP;
							LPlayer = Player;
							LCharacter = Character;
						end
					end
				end
			end
			
			if LPlayer and LPlayer ~= Spectating and LCharacter then
				Camera.CameraSubject = LCharacter.Head;
				Spectating = LPlayer;
			else
				if LocalPlayer.Character and LocalPlayer.Character:FindFirstChildOfClass'Humanoid' then
					Camera.CameraSubject = LocalPlayer.Character:FindFirstChildOfClass'Humanoid';
					Spectating = nil;
				end
			end
		end
	end
end)

local function CameraCon() -- unnamed esp v1 sucks
	workspace.CurrentCamera:GetPropertyChangedSignal'ViewportSize':Connect(function()
		TracerPosition = V2New(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y - 135);
	end);
end

CameraCon();

local function ToggleMenu()
	if Options.MenuOpen.Value then
		-- GUIService:SetMenuIsOpen(true);
		GetTableData(shared.MenuDrawingData.Instances)(function(i, v)
			if OldData[v] then
				pcall(Set, v, 'Visible', true);
			end
		end)
	else
		-- GUIService:SetMenuIsOpen(false);
		GetTableData(shared.MenuDrawingData.Instances)(function(i, v)
			OldData[v] = v.Visible;
			if v.Visible then
				pcall(Set, v, 'Visible', false);
			end
		end)
	end
end

local function CheckRay(Instance, Distance, Position, Unit)
	local Pass = true;
	local Model = Instance;

	if Distance > 999 then return false; end

	if Instance.ClassName == 'Player' then
		Model = GetCharacter(Instance);
	end

	if not Model then
		Model = Instance.Parent;

		if Model.Parent == workspace then
			Model = Instance;
		end
	end

	if not Model then return false end

	local _Ray = Ray.new(Position, Unit * Distance);
	
	local List = {LocalPlayer.Character, Camera, Mouse.TargetFilter};

	for i,v in pairs(IgnoreList) do table.insert(List, v); end;

	local Hit = workspace:FindPartOnRayWithIgnoreList(_Ray, List);

	if Hit and not Hit:IsDescendantOf(Model) then
		Pass = false;
		if Hit.Transparency >= .3 or not Hit.CanCollide and Hit.ClassName ~= Terrain then -- Detect invisible walls
			IgnoreList[#IgnoreList + 1] = Hit;
		end
	end

	return Pass;
end

local function CheckTeam(Player)
	if Player.Neutral and LocalPlayer.Neutral then return true; end
	return Player.TeamColor == LocalPlayer.TeamColor;
end

local CustomTeam = CustomTeams[game.PlaceId];

if CustomTeam ~= nil then
	if CustomTeam.Initialize then ypcall(CustomTeam.Initialize) end

	CheckTeam = CustomTeam.CheckTeam;
end

local function CheckPlayer(Player, Character)
	if not Options.Enabled.Value then return false end

	local Pass = true;
	local Distance = 0;

	if Player ~= LocalPlayer and Character then
		if not Options.ShowTeam.Value and CheckTeam(Player) then
			Pass = false;
		end

		local Head = Character:FindFirstChild'Head';

		if Pass and Character and Head then
			Distance = (Camera.CFrame.Position - Head.Position).Magnitude;
			if Options.VisCheck.Value then
				Pass = CheckRay(Player, Distance, Camera.CFrame.Position, (Head.Position - Camera.CFrame.Position).unit);
			end
			if Distance > Options.MaxDistance.Value then
				Pass = false;
			end
		end
	else
		Pass = false;
	end

	return Pass, Distance;
end

local function CheckDistance(Instance)
	if not Options.Enabled.Value then return false end

	local Pass = true;
	local Distance = 0;

	if Instance ~= nil then
		Distance = (Camera.CFrame.Position - Instance.Position).Magnitude;
		if Options.VisCheck.Value then
			Pass = CheckRay(Instance, Distance, Camera.CFrame.Position, (Instance.Position - Camera.CFrame.Position).unit);
		end
		if Distance > Options.MaxDistance.Value then
			Pass = false;
		end
	else
		Pass = false;
	end

	return Pass, Distance;
end

local function UpdatePlayerData()
	if (tick() - LastRefresh) > (Options.RefreshRate.Value / 1000) then
		LastRefresh = tick();
		if CustomESP and Options.Enabled.Value then
			local a, b = pcall(CustomESP);
		end
		for i, v in pairs(RenderList.Instances) do
			if v.Instance ~= nil and v.Instance.Parent ~= nil and v.Instance:IsA'BasePart' then
				local Data = shared.InstanceData[v.Instance:GetDebugId()] or { Instances = {}; DontDelete = true };

				Data.Instance = v.Instance;

				Data.Instances['OutlineTracer'] = Data.Instances['OutlineTracer'] or NewDrawing'Line'{
					Transparency	= 0.75;
					Thickness		= 5;
					Color 			= Color3.new(0.1, 0.1, 0.1);
				}
				Data.Instances['Tracer'] = Data.Instances['Tracer'] or NewDrawing'Line'{
					Transparency	= 1;
					Thickness		= 2;
				}
				Data.Instances['NameTag'] = Data.Instances['NameTag'] or NewDrawing'Text'{
					Size			= Options.TextSize.Value;
					Center			= true;
					Outline			= Options.TextOutline.Value;
					Visible			= true;
				};
				Data.Instances['DistanceTag'] = Data.Instances['DistanceTag'] or NewDrawing'Text'{
					Size			= Options.TextSize.Value - 1;
					Center			= true;
					Outline			= Options.TextOutline.Value;
					Visible			= true;
				};

				local NameTag		= Data.Instances['NameTag'];
				local DistanceTag	= Data.Instances['DistanceTag'];
				local Tracer		= Data.Instances['Tracer'];
				local OutlineTracer	= Data.Instances['OutlineTracer'];

				local Pass, Distance = CheckDistance(v.Instance);

				if Pass then
					local ScreenPosition, Vis = WorldToViewport(v.Instance.Position);
					local Color = v.Color;
					local OPos = Camera.CFrame:pointToObjectSpace(v.Instance.Position);
					
					if ScreenPosition.Z < 0 then
						local AT = math.atan2(OPos.Y, OPos.X) + math.pi;
						OPos = CFrame.Angles(0, 0, AT):vectorToWorldSpace((CFrame.Angles(0, math.rad(89.9), 0):vectorToWorldSpace(V3New(0, 0, -1))));
					end
					
					local Position = WorldToViewport(Camera.CFrame:pointToWorldSpace(OPos));

					if Options.ShowTracers.Value then
						Tracer.Transparency = math.clamp(Distance / 200, 0.45, 0.8);
						Tracer.Visible	= true;
						Tracer.From		= TracerPosition;
						Tracer.To		= V2New(Position.X, Position.Y);
						Tracer.Color	= Color;
						OutlineTracer.Visible = true;
						OutlineTracer.Transparency = Tracer.Transparency - 0.1;
						OutlineTracer.From = Tracer.From;
						OutlineTracer.To = Tracer.To;
						OutlineTracer.Color	= Color3.new(0.1, 0.1, 0.1);
					else
						Tracer.Visible = false;
						OutlineTracer.Visible = false;
					end

					if ScreenPosition.Z > 0 then
						local ScreenPositionUpper = ScreenPosition;
						
						if Options.ShowName.Value then
							LocalPlayer.NameDisplayDistance = 0;
							NameTag.Visible		= true;
							NameTag.Text		= v.Text;
							NameTag.Size		= Options.TextSize.Value;
							NameTag.Outline		= Options.TextOutline.Value;
							NameTag.Position	= V2New(ScreenPositionUpper.X, ScreenPositionUpper.Y);
							NameTag.Color		= Color;
							if Drawing.Fonts and shared.am_ic3 then -- CURRENTLY SYNAPSE ONLY :MEGAHOLY:
								NameTag.Font	= Drawing.Fonts.Monospace;
							end
						else
							LocalPlayer.NameDisplayDistance = 100;
							NameTag.Visible = false;
						end
						if Options.ShowDistance.Value or Options.ShowHealth.Value then
							DistanceTag.Visible		= true;
							DistanceTag.Size		= Options.TextSize.Value - 1;
							DistanceTag.Outline		= Options.TextOutline.Value;
							DistanceTag.Color		= Color3.new(1, 1, 1);
							if Drawing.Fonts and shared.am_ic3 then -- CURRENTLY SYNAPSE ONLY :MEGAHOLY:
								NameTag.Font	= Drawing.Fonts.Monospace;
							end

							local Str = '';

							if Options.ShowDistance.Value then
								Str = Str .. Format('[%d] ', Distance);
							end

							DistanceTag.Text = Str;
							DistanceTag.Position = V2New(ScreenPositionUpper.X, ScreenPositionUpper.Y) + V2New(0, NameTag.TextBounds.Y);
						else
							DistanceTag.Visible = false;
						end
					else
						NameTag.Visible			= false;
						DistanceTag.Visible		= false;
					end
				else
					NameTag.Visible			= false;
					DistanceTag.Visible		= false;
					Tracer.Visible			= false;
					OutlineTracer.Visible	= false;
				end

				Data.Instances['NameTag'] 		= NameTag;
				Data.Instances['DistanceTag']	= DistanceTag;
				Data.Instances['Tracer']		= Tracer;
				Data.Instances['OutlineTracer']	= OutlineTracer;

				shared.InstanceData[v.Instance:GetDebugId()] = Data;
			end
		end
		for i, v in pairs(Players:GetPlayers()) do
			local Data = shared.InstanceData[v.Name] or { Instances = {}; };

			Data.Instances['Box'] = Data.Instances['Box'] or LineBox:Create{Thickness = 4};
			Data.Instances['OutlineTracer'] = Data.Instances['OutlineTracer'] or NewDrawing'Line'{
				Transparency	= 1;
				Thickness		= 3;
				Color			= Color3.new(0.1, 0.1, 0.1);
			}
			Data.Instances['Tracer'] = Data.Instances['Tracer'] or NewDrawing'Line'{
				Transparency	= 1;
				Thickness		= 1;
			}
			Data.Instances['HeadDot'] = Data.Instances['HeadDot'] or NewDrawing'Circle'{
				Filled			= true;
				NumSides		= 30;
			}
			Data.Instances['NameTag'] = Data.Instances['NameTag'] or NewDrawing'Text'{
				Size			= Options.TextSize.Value;
				Center			= true;
				Outline			= Options.TextOutline.Value;
				OutlineOpacity	= 1;
				Visible			= true;
			};
			Data.Instances['DistanceHealthTag'] = Data.Instances['DistanceHealthTag'] or NewDrawing'Text'{
				Size			= Options.TextSize.Value - 1;
				Center			= true;
				Outline			= Options.TextOutline.Value;
				OutlineOpacity	= 1;
				Visible			= true;
			};

			local NameTag		= Data.Instances['NameTag'];
			local DistanceTag	= Data.Instances['DistanceHealthTag'];
			local Tracer		= Data.Instances['Tracer'];
			local OutlineTracer	= Data.Instances['OutlineTracer'];
			local HeadDot		= Data.Instances['HeadDot'];
			local Box			= Data.Instances['Box'];

			local Character = GetCharacter(v);
			local Pass, Distance = CheckPlayer(v, Character);

			if Pass and Character then
				local Humanoid = Character:FindFirstChildOfClass'Humanoid';
				local Head = Character:FindFirstChild'Head';
				local HumanoidRootPart = Character:FindFirstChild(CustomRootPartName or 'HumanoidRootPart')

				local Dead = (Humanoid and Humanoid:GetState().Name == 'Dead')
				if type(GetAliveState) == 'function' then
					Dead = (not GetAliveState(v, Character))
				end

				if Character ~= nil and Head and HumanoidRootPart and not Dead then
					local ScreenPosition, Vis = WorldToViewport(Head.Position);
					local Color = Rainbow and Color3.fromHSV(tick() * 128 % 255/255, 1, 1) or (CheckTeam(v) and TeamColor or EnemyColor); Color = Options.ShowTeamColor.Value and v.TeamColor.Color or Color;
					local OPos = Camera.CFrame:pointToObjectSpace(Head.Position);
					
					if ScreenPosition.Z < 0 then
						local AT = math.atan2(OPos.Y, OPos.X) + math.pi;
						OPos = CFrame.Angles(0, 0, AT):vectorToWorldSpace((CFrame.Angles(0, math.rad(89.9), 0):vectorToWorldSpace(V3New(0, 0, -1))));
					end
					
					local Position = WorldToViewport(Camera.CFrame:pointToWorldSpace(OPos));

					if Options.ShowTracers.Value then
						if TracerPosition.X >= Camera.ViewportSize.X or TracerPosition.Y >= Camera.ViewportSize.Y or TracerPosition.X < 0 or TracerPosition.Y < 0 then
							TracerPosition = V2New(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y - 135);
						end

						Tracer.Visible	= true;
						Tracer.Transparency = math.clamp(1 - (Distance / 200), 0.25, 0.75);
						Tracer.From		= TracerPosition;
						Tracer.To		= V2New(Position.X, Position.Y);
						Tracer.Color	= Color;
						OutlineTracer.From = Tracer.From;
						OutlineTracer.To = Tracer.To;
						OutlineTracer.Transparency = Tracer.Transparency - 0.15;
						OutlineTracer.Visible = true;
					else
						Tracer.Visible = false;
						OutlineTracer.Visible = false;
					end
					
					if ScreenPosition.Z > 0 then
						local ScreenPositionUpper	= WorldToViewport((HumanoidRootPart:GetRenderCFrame() * CFrame.new(0, Head.Size.Y + HumanoidRootPart.Size.Y + (Options.YOffset.Value / 25), 0)).Position);
						local Scale					= Head.Size.Y / 2;

						if Options.ShowName.Value then
							NameTag.Visible		= true;
							NameTag.Text		= v.Name .. (CustomPlayerTag and CustomPlayerTag(v) or '');
							NameTag.Size		= Options.TextSize.Value;
							NameTag.Outline		= Options.TextOutline.Value;
							NameTag.Position	= V2New(ScreenPositionUpper.X, ScreenPositionUpper.Y) - V2New(0, NameTag.TextBounds.Y);
							NameTag.Color		= Color;
							NameTag.Color		= Color;
							NameTag.OutlineColor= Color3.new(0.05, 0.05, 0.05);
							NameTag.Transparency= 0.85;
							if Drawing.Fonts and shared.am_ic3 then -- CURRENTLY SYNAPSE ONLY :MEGAHOLY:
								NameTag.Font	= Drawing.Fonts.Monospace;
							end
						else
							NameTag.Visible = false;
						end
						if Options.ShowDistance.Value or Options.ShowHealth.Value then
							DistanceTag.Visible		= true;
							DistanceTag.Size		= Options.TextSize.Value - 1;
							DistanceTag.Outline		= Options.TextOutline.Value;
							DistanceTag.Color		= Color3.new(1, 1, 1);
							DistanceTag.Transparency= 0.85;
							if Drawing.Fonts and shared.am_ic3 then -- CURRENTLY SYNAPSE ONLY :MEGAHOLY:
								NameTag.Font	= Drawing.Fonts.Monospace;
							end

							local Str = '';

							if Options.ShowDistance.Value then
								Str = Str .. Format('[%d] ', Distance);
							end
							if Options.ShowHealth.Value then								
								if typeof(Humanoid) == 'Instance' then
									Str = Str .. Format('[%d/%d] [%s%%]', Humanoid.Health, Humanoid.MaxHealth, math.floor(Humanoid.Health / Humanoid.MaxHealth * 100));
								elseif type(GetHealth) == 'function' then
									local health, maxHealth = GetHealth(v)
									
									if type(health) == 'number' and type(maxHealth) == 'number' then
										Str = Str .. Format('[%d/%d] [%s%%]', health, maxHealth, math.floor(health / maxHealth * 100))
									end
								end
							end

							DistanceTag.Text = Str;
							DistanceTag.OutlineColor = Color3.new(0.05, 0.05, 0.05);
							DistanceTag.Position = (NameTag.Visible and NameTag.Position + V2New(0, NameTag.TextBounds.Y) or V2New(ScreenPositionUpper.X, ScreenPositionUpper.Y));
						else
							DistanceTag.Visible = false;
						end
						if Options.ShowDot.Value and Vis then
							local Top			= WorldToViewport((Head.CFrame * CFrame.new(0, Scale, 0)).Position);
							local Bottom		= WorldToViewport((Head.CFrame * CFrame.new(0, -Scale, 0)).Position);
							local Radius		= (Top - Bottom).y;

							HeadDot.Visible		= true;
							HeadDot.Color		= Color;
							HeadDot.Position	= V2New(ScreenPosition.X, ScreenPosition.Y);
							HeadDot.Radius		= Radius;
						else
							HeadDot.Visible = false;
						end
						if Options.ShowBoxes.Value and Vis and HumanoidRootPart then
							local Body = {
								Head;
								Character:FindFirstChild'Left Leg' or Character:FindFirstChild'LeftLowerLeg';
								Character:FindFirstChild'Right Leg' or Character:FindFirstChild'RightLowerLeg';
								Character:FindFirstChild'Left Arm' or Character:FindFirstChild'LeftLowerArm';
								Character:FindFirstChild'Right Arm' or Character:FindFirstChild'RightLowerArm';
							}
							Box:Update(HumanoidRootPart.CFrame, V3New(2, 3, 1) * (Scale * 2), Color, nil, shared.am_ic3 and Body);
						else
							Box:SetVisible(false);
						end
					else
						NameTag.Visible			= false;
						DistanceTag.Visible		= false;
						HeadDot.Visible			= false;
						
						Box:SetVisible(false);
					end
				else
					NameTag.Visible			= false;
					DistanceTag.Visible		= false;
					HeadDot.Visible			= false;
					Tracer.Visible			= false;
					OutlineTracer.Visible 	= false;
					
					Box:SetVisible(false);
				end
			else
				NameTag.Visible			= false;
				DistanceTag.Visible		= false;
				HeadDot.Visible			= false;
				Tracer.Visible			= false;
				OutlineTracer.Visible 	= false;

				Box:SetVisible(false);
			end

			shared.InstanceData[v.Name] = Data;
		end
	end
end

local LastInvalidCheck = 0;

local function Update()
	if tick() - LastInvalidCheck > 0.3 then
		LastInvalidCheck = tick();

		if Camera.Parent ~= workspace then
			Camera = workspace.CurrentCamera;
			CameraCon();
			WTVP = Camera.WorldToViewportPoint;
		end

		for i, v in pairs(shared.InstanceData) do
			if not Players:FindFirstChild(tostring(i)) then
				if not shared.InstanceData[i].DontDelete then
					GetTableData(v.Instances)(function(i, obj)
						obj.Visible = false;
						obj:Remove();
						v.Instances[i] = nil;
					end)
					shared.InstanceData[i] = nil;
				else
					if shared.InstanceData[i].Instance == nil or shared.InstanceData[i].Instance.Parent == nil then
						GetTableData(v.Instances)(function(i, obj)
							obj.Visible = false;
							obj:Remove();
							v.Instances[i] = nil;
						end)
						shared.InstanceData[i] = nil;
					end
				end
			end
		end
	end

	local CX = Menu:GetInstance'CrosshairX';
	local CY = Menu:GetInstance'CrosshairY';
	
	if Options.Crosshair.Value then
		CX.Visible = true;
		CY.Visible = true;

		CX.To = V2New((Camera.ViewportSize.X / 2) - 8, (Camera.ViewportSize.Y / 2));
		CX.From = V2New((Camera.ViewportSize.X / 2) + 8, (Camera.ViewportSize.Y / 2));
		CY.To = V2New((Camera.ViewportSize.X / 2), (Camera.ViewportSize.Y / 2) - 8);
		CY.From = V2New((Camera.ViewportSize.X / 2), (Camera.ViewportSize.Y / 2) + 8);
	else
		CX.Visible = false;
		CY.Visible = false;
	end

	if Options.MenuOpen.Value and MenuLoaded then
		local MLocation = GetMouseLocation();
		shared.MenuDrawingData.Instances.Main.Color = Color3.fromHSV(tick() * 24 % 255/255, 1, 1);
		local MainInstance = Menu:GetInstance'Main';
		
		local Values = {
			MainInstance.Position.X;
			MainInstance.Position.Y;
			MainInstance.Position.X + MainInstance.Size.X;
			MainInstance.Position.Y + MainInstance.Size.Y;
		};
		
		if MainInstance and (MouseHoveringOver(Values) or (SubMenu.Open and MouseHoveringOver(SubMenu.Bounds))) then
			Debounce.CursorVis = true;
			
			Menu:UpdateMenuInstance'Cursor1'{
				Visible	= true;
				From	= V2New(MLocation.x, MLocation.y);
				To		= V2New(MLocation.x + 5, MLocation.y + 6);
			}
			Menu:UpdateMenuInstance'Cursor2'{
				Visible	= true;
				From	= V2New(MLocation.x, MLocation.y);
				To		= V2New(MLocation.x, MLocation.y + 8);
			}
			Menu:UpdateMenuInstance'Cursor3'{
				Visible	= true;
				From	= V2New(MLocation.x, MLocation.y + 6);
				To		= V2New(MLocation.x + 5, MLocation.y + 5);
			}
		else
			if Debounce.CursorVis then
				Debounce.CursorVis = false;
				
				Menu:UpdateMenuInstance'Cursor1'{Visible = false};
				Menu:UpdateMenuInstance'Cursor2'{Visible = false};
				Menu:UpdateMenuInstance'Cursor3'{Visible = false};
			end
		end
		if MouseHeld then
			local MousePos = GetMouseLocation();

			if Dragging then
				DraggingWhat.Slider.Position = V2New(math.clamp(MLocation.X - DraggingWhat.Slider.Size.X / 2, DraggingWhat.Line.Position.X, DraggingWhat.Line.Position.X + DraggingWhat.Line.Size.X - DraggingWhat.Slider.Size.X), DraggingWhat.Slider.Position.Y);
				local Percent	= (DraggingWhat.Slider.Position.X - DraggingWhat.Line.Position.X) / ((DraggingWhat.Line.Position.X + DraggingWhat.Line.Size.X - DraggingWhat.Line.Position.X) - DraggingWhat.Slider.Size.X);
				local Value		= CalculateValue(DraggingWhat.Min, DraggingWhat.Max, Percent);
				DraggingWhat.Option(Value);
			elseif DraggingUI then
				Debounce.UIDrag = true;
				local Main = Menu:GetInstance'Main';
				Main.Position = MousePos + DragOffset;
			elseif DragTracerPosition then
				TracerPosition = MousePos;
			end
		else
			Dragging = false;
			DragTracerPosition = false;
			if DraggingUI and Debounce.UIDrag then
				Debounce.UIDrag = false;
				DraggingUI = false;
				CreateMenu(Menu:GetInstance'Main'.Position);
			end
		end
		if not Debounce.Menu then
			Debounce.Menu = true;
			ToggleMenu();
		end
	elseif Debounce.Menu and not Options.MenuOpen.Value then
		Debounce.Menu = false;
		ToggleMenu();
	end
end

RunService:UnbindFromRenderStep(GetDataName);
RunService:UnbindFromRenderStep(UpdateName);

RunService:BindToRenderStep(GetDataName, 300, UpdatePlayerData);
RunService:BindToRenderStep(UpdateName, 199, Update);