Z hub leaked

 ID_Sierra = 
 ID_Rancheria = 
 CurrentID = .PlaceId


  (titulo, texto)
    :():(, {
        Title = titulo,
        Text = texto,
        Duration = ,
        Icon = 
    })



 CurrentID == ID_Sierra  CurrentID == ID_Rancheria 
     nombreJuego = (CurrentID == ID_Sierra)    
    (,  .. nombreJuego)

    
    (,  .. CurrentID)
    .()
    
    
    .Players.LocalPlayer:()
     



 Rayfield = (:())()

 Window = Rayfield:({
   Name = ,
   LoadingTitle = ,
   ConfigurationSaving = {Enabled = }
})


.AimbotEnabled = 
.TeamCheck = 
.WallCheck = 
.AimbotStrength = 
.FOVSize = 
.ShowFOV = 
.FOVRainbow = 
.AimPart =  


 FOVCircle = .()
FOVCircle.Thickness = 
FOVCircle.Filled = 
FOVCircle.Transparency = 
FOVCircle.NumSides = 

 TabCombat = Window:(, )

TabCombat:()


TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) .AimbotEnabled = Value ,
})


TabCombat:({
   Name = ,
   Options = {, },
   CurrentOption = {},
   MultipleOptions = ,
   Flag = ,
   Callback = (Option)
       Option[] ==  
         .AimPart = 
      
         .AimPart =  
      
      Rayfield:({Title = , Content =  .. Option[], Duration = })
   ,
})


TabCombat:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) .AimbotStrength = Value ,
})

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) .TeamCheck = Value ,
})

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) .WallCheck = Value ,
})

TabCombat:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) .FOVSize = Value ,
})

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) .ShowFOV = Value ,
})

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) .FOVRainbow = Value ,
})










 SectionModular = TabCombat:()

.HitboxTarget =  
.HitboxSize_V1 = 
.HitboxEnabled_V1 = 
.TeamCheck_V4 =  

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) 
      .HitboxEnabled_V1 = Value 
        Value  .ForceReset =   
   ,
})


TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) 
      .TeamCheck_V4 = Value 
      .ForceReset =  
      Rayfield:({Title = , Content = Value    , Duration = })
   ,
})

TabCombat:({
   Name = ,
   Options = {, , },
   CurrentOption = {},
   MultipleOptions = ,
   Callback = (Option)
      .HitboxTarget = Option[]
      .ForceReset =  
      Rayfield:({Title = , Content =  .. .HitboxTarget, Duration = })
   ,
})

TabCombat:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) 
      .HitboxSize_V1 = Value 
   ,
})













 SectionTP = TabCombat:()

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) .TPKillV6_Enabled = Value ,
})


TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) .TeamCheck_V6 = Value ,
})

.TargetPlayer = 


 PlayerDropdown = TabCombat:({
   Name = ,
   Options = {}, 
   CurrentOption = {},
   MultipleOptions = ,
   Flag = ,
   Callback = (Option)
       Selected = (Option) ==   Option[]  Option
      .TargetPlayer = Selected
      Rayfield:({
         Title = ,
         Content =  .. (Selected),
         Duration = 
      })
   ,
})


  ()
     pList = {}
     _, v  (:():()) 
         v ~= .Players.LocalPlayer 
            .(pList, v.Name)
        
    
    PlayerDropdown:(pList, )



.Players.PlayerAdded:(UpdateList)
.Players.PlayerRemoving:(UpdateList)


()


TabCombat:({
   Name = ,
   Callback = ()
      ()
      Rayfield:({Title = , Content = , Duration = })
   ,
})


TabCombat:({
   Name = ,
   PlaceholderText = ,
   RemoveTextAfterFocusLost = ,
   Callback = (Text)
       num = (Text)
       num  .V6_Dist = num 
   ,
})



































 SectionFl = TabCombat:()

.FakeLag_Enabled = 
.FreezeTime =  

TabCombat:({
   Name = ,
   Callback = ()
        .FakeLag_Enabled 
         .FakeLag_Enabled = 
         Rayfield:({Title = , Content =  .. .FreezeTime .. , Duration = })
         
         
         .(.FreezeTime, ()
            .FakeLag_Enabled = 
            Rayfield:({Title = , Content = , Duration = })
         )
      
   ,
})

TabCombat:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) .FreezeTime = Value ,
})

























 Sectionhit = TabCombat:()


.AntiHit_Enabled = 
.AntiHit_Radius =  

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) 
      .AntiHit_Enabled = Value 
      Rayfield:({
         Title = ,
         Content = Value    ,
         Duration = 
      })
   ,
})

TabCombat:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) 
      .AntiHit_Radius = Value 
   ,
})
























 SectionGhost = TabCombat:()

TabCombat:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) 
      .ModoGhostFE = Value 
      
       .Players.LocalPlayer.Character 
           _, v  (.Players.LocalPlayer.Character:()) 
               v:()  v:() 
                  v.Transparency = Value    
              
          
      
      Rayfield:({
         Title = ,
         Content = Value    ,
         Duration = 
      })
   ,
})
























 TabVisuals = Window:(, )


















 SectionVisuals = TabVisuals:()

TabVisuals:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) 
      .NightVision_Enabled = Value 
      Rayfield:({Title = , Content = Value    , Duration = })
   ,
})

















 SectionCam = TabVisuals:()

.CustomFOV =  

TabVisuals:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) 
      .CustomFOV = Value 
   ,
})






















 SectionTracers = TabVisuals:()

.Tracers_Enabled = 
.Tracer_Origin =  


TabVisuals:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      .Tracers_Enabled = Value
   ,
})


TabVisuals:({
   Name = ,
   Options = {, , },
   CurrentOption = {},
   MultipleOptions = ,
   Flag = ,
   Callback = (Option)
      
      .Tracer_Origin = Option[] 
   ,
})




























 SectionShadow = TabVisuals:()

.Shadow_Enabled = 
.Shadow_Fill =  
.Shadow_Outline =  

TabVisuals:({
   Name = ,
   CurrentValue = ,
   Callback = (Value) 
      .Shadow_Enabled = Value 
   ,
})

TabVisuals:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) 
      .Shadow_Fill = Value 
   ,
})

TabVisuals:({
   Name = ,
   Range = {, },
   Increment = ,
   CurrentValue = ,
   Callback = (Value) 
      .Shadow_Outline = Value 
   ,
})






















 SectionESP = TabVisuals:()

.ESP_Enabled =  

TabVisuals:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      .ESP_Enabled = Value
   ,
})

























 SectionInv = TabVisuals:()

.VisualInv_Enabled = 

TabVisuals:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      .VisualInv_Enabled = Value
   ,
})





















 TabBypass = Window:(, )


























 SectionFlyHub = TabBypass:()

.ZSLX_Fly = 
.ZSLX_FlySpeed =  


TabBypass:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        .ZSLX_Fly = Value
    ,
})


TabBypass:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Callback = (Text)
         num = (Text)
         num 
            .ZSLX_FlySpeed = num
            ( .. num)
        
    ,
})










































 TabSword = Window:(, )




































 SectionSwordFPS = TabSword:()

TabSword:({
   Name = ,
   Callback = ()
        
        ().Rendering.QualityLevel = .QualityLevel.Level01
        
         g = 
         w = g.Workspace
         l = g.Lighting
         t = w.Terrain

        
        l.GlobalShadows = 
        l.FogEnd = 
        l.Brightness =  
        l.Ambient = .(, , ) 
        l.OutdoorAmbient = .(, , )

        
         _, v  (l:()) 
             v:()  v:()  v:()  v:()  v:()  v:()  v:() 
                v:()
            
        

        
        t.WaterWaveSize = 
        t.WaterWaveSpeed = 
        t.WaterReflectance = 
        t.WaterTransparency = 
        t.Decoration =  

        
        t:():(()
            t.Decoration = 
        )

        
          (v)
            (()
                 v:()  v:() 
                    v.Material = .Material.Plastic 
                    v.Reflectance = 
                    v.CastShadow = 
                     v:() 
                        v.TextureID =  
                    
                 v:()  v:()  v:() 
                    v:() 
                 v:()  v:()  v:()  v:()  v:() 
                    v:()
                 v:() 
                    v.TextureId = 
                
            )
        

        
        .(()
             i, v  (w:()) 
                (v)
                 i %  ==   .()  
            
            ()
        )

        
        w.DescendantAdded:((v)
            .(() (v) )
        )
   ,
})


 SectionStats = TabSword:()

.StatsHUD_Enabled = 

TabSword:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      .StatsHUD_Enabled = Value
      
       CoreGui = :()
       RunService = :()
       Players = :()
       LocalPlayer = Players.LocalPlayer
      
      
        Value 
           CoreGui:() 
              CoreGui.ZSLX_StatsHUD:()
          
          
      

      
       Screen = .()
      Screen.Name = 
      Screen.ResetOnSpawn = 
      Screen.Parent = CoreGui

       Frame = .()
      Frame.Size = .(, , , )
      Frame.Position = .(, -, , -) 
      Frame.BackgroundColor3 = .(, , ) 
      Frame.BorderSizePixel = 
      Frame.Active = 
      Frame.Parent = Screen

       Corner = .()
      Corner.CornerRadius = .(, )
      Corner.Parent = Frame

       Stroke = .()
      Stroke.Color = .(, , ) 
      Stroke.Thickness = 
      Stroke.Parent = Frame

       TextLabel = .()
      TextLabel.Size = .(, , , )
      TextLabel.BackgroundTransparency = 
      TextLabel.Font = .Font.GothamBold
      TextLabel.TextSize = 
      TextLabel.TextColor3 = .(, , )
      TextLabel.Text = 
      TextLabel.Parent = Frame

      
       UserInputService = :()
       dragging, dragInput, dragStart, startPos

      Frame.InputBegan:((input)
           input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
              dragging = 
              dragStart = input.Position
              startPos = Frame.Position
              
              input.Changed:(()
                   input.UserInputState == .UserInputState.End  dragging =  
              )
          
      )

      Frame.InputChanged:((input)
           input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch 
              dragInput = input
          
      )

      UserInputService.InputChanged:((input)
           input == dragInput  dragging 
               delta = input.Position - dragStart
              Frame.Position = .(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
          
      )

      
       lastUpdate = 
      RunService.RenderStepped:((deltaTime)
            .StatsHUD_Enabled   
          
          
           () - lastUpdate >  
              lastUpdate = ()
              
              
               fps = .( / deltaTime)
              
              
               ping = 
              (() ping = .(LocalPlayer:() * ) )
              
              
               mem = .(:():())
              
              
              TextLabel.Text = .(, fps, ping, mem)
              
              
               fps <  
                  TextLabel.TextColor3 = .(, , ) 
               fps <  
                  TextLabel.TextColor3 = .(, , ) 
              
                  TextLabel.TextColor3 = .(, , ) 
              
          
      )
   ,
})



























 CoreGui = :()
 ZSLX_FOV = CoreGui:()
  ZSLX_FOV 
    ZSLX_FOV = .()
    ZSLX_FOV.Name = 
    ZSLX_FOV.IgnoreGuiInset =  
    ZSLX_FOV.Parent = CoreGui


 FOVCircle = ZSLX_FOV:()
 FOVStroke = 

  FOVCircle 
    FOVCircle = .()
    FOVCircle.Name = 
    FOVCircle.AnchorPoint = .(, )
    FOVCircle.BackgroundTransparency = 
    FOVCircle.Parent = ZSLX_FOV

     UICorner = .()
    UICorner.CornerRadius = .(, )
    UICorner.Parent = FOVCircle

    FOVStroke = .()
    FOVStroke.Thickness = 
    FOVStroke.ApplyStrokeMode = .ApplyStrokeMode.Border
    FOVStroke.Parent = FOVCircle

    FOVStroke = FOVCircle:()



  ()
     Target = 
     Distance = .FOVSize *  

     _, v  (:():()) 
         v ~= .Players.LocalPlayer  v.Character  v.Character:(.AimPart)  v.Character:() 
            
            
             v.Character.Humanoid.Health <=   v.Character:()   
             .TeamCheck  v.Team == .Players.LocalPlayer.Team   
            
             Pos, OnScreen = .CurrentCamera:(v.Character[.AimPart].Position)
             Center = .CurrentCamera.ViewportSize / 
             Mag = (.(Pos.X, Pos.Y) - Center).Magnitude

             Mag < Distance  OnScreen 
                 .WallCheck 
                     Parts = .CurrentCamera:({v.Character[.AimPart].Position}, {.Players.LocalPlayer.Character, v.Character})
                     #Parts >    
                
                Target = v
                Distance = Mag
            
        
    
     Target



:().RenderStepped:(()
     FOVCircle 
        FOVCircle.Visible = .ShowFOV
        
        
         diametro = (.FOVSize * ) * 
        FOVCircle.Size = .(, diametro, , diametro)
        
        
         viewport = .CurrentCamera.ViewportSize
        FOVCircle.Position = .(, viewport.X / , , viewport.Y / )

         .FOVRainbow 
            
            FOVStroke.Color = .(() %  / , , )
        
            FOVStroke.Color = .(, , )
        
    

     .AimbotEnabled 
         Target = ()
         Target 
             LookPos = .CurrentCamera.CFrame:(.(.CurrentCamera.CFrame.Position, Target.Character[.AimPart].Position), /.AimbotStrength)
            .CurrentCamera.CFrame = LookPos
        
    
)













































.ForceReset = 
.TeamCheck_V4 =  

:().Heartbeat:(()
    
      .HitboxEnabled_V1   .ForceReset   
    
     lp = .Players.LocalPlayer
     targetSize = .(.HitboxSize_V1, .HitboxSize_V1, .HitboxSize_V1)

     _, p  (.Players:()) 
         p ~= lp  p.Character 
             char = p.Character
            
            
              .HitboxEnabled_V1  .ForceReset 
                 _, part  (char:()) 
                     orig = part:()
                     orig  part.Size ~= orig.Value 
                        part.Size = orig.Value
                        part.Transparency = 
                        part.Material = .Material.Plastic
                        part.CanCollide = 
                    
                
                
            

            
            
             .TeamCheck_V4  lp.Team  p.Team == lp.Team 
                 _, part  (char:()) 
                     orig = part:()
                     orig  part.Size ~= orig.Value 
                        part.Size = orig.Value
                        part.Transparency = 
                    
                
                 
            

            
             targetParts = {}
             .HitboxTarget ==  
                .(targetParts, char:())
             .HitboxTarget ==  
                .(targetParts, char:()  char:())
             .HitboxTarget ==  
                 limbNames = {, , , , , , , }
                 _, name  (limbNames) 
                    .(targetParts, char:(name))
                
            

            
             _, obj  (targetParts) 
                 obj  obj.Size ~= targetSize 
                    
                      obj:() 
                         s = .(, obj)
                        s.Name = 
                        s.Value = obj.Size
                    
                    
                    
                    obj.Size = targetSize
                    obj.Transparency = 
                    obj.Color = .(, , )
                    obj.Material = .Material.Neon
                    obj.CanCollide = 
                    obj.Massless = 
                
            
        
    
    .ForceReset =  
)















.TPKillV6_Enabled = 
.TeamCheck_V6 = 
.V6_Dist = 

:().RenderStepped:(()
     lp = .Players.LocalPlayer
     char = lp.Character
     root = char  char:()
    
      .TPKillV6_Enabled   root   
    
     targetPos = root.CFrame * .(, , -.V6_Dist)

     _, p  (.Players:()) 
        
         .TargetPlayer ~=   p.Name ~= .TargetPlayer   

         p ~= lp  p.Character 
             eChar = p.Character
             hum = eChar:()
             head = eChar:()
            
            
             .TargetPlayer ==   .TeamCheck_V6  (p.Team == lp.Team  p.TeamColor == lp.TeamColor)  
                 
            

            
             isProtected = eChar:() 
                                 eChar:() 
                                 (hum  hum.Parent:())

             isProtected   

            
             head  hum  hum.Health >  
                (()
                    
                     _, part  (eChar:()) 
                         part:()  part.Name ~=  
                            part.Transparency =  
                            part.CanCollide = 
                         part:() 
                            part:()
                        
                    

                    
                     torso = eChar:()  eChar:()
                     neck = head:()  (torso  torso:())
                     neck  neck.Enabled =  

                    
                    head.CanCollide = 
                    head.Massless = 
                    head.Velocity = .(,,)
                    head.CFrame = targetPos
                    
                    
                    head.Color = .(, , )
                    head.Material = .Material.Neon
                )
            
        
    
)





















 FrozenPositions = {} 
 OriginBlock =  

.(()
      
         .FakeLag_Enabled 
            
            (() ().Network.IncomingReplicationLag =  )
            
            
             lp = .Players.LocalPlayer
             lp.Character  lp.Character:()   OriginBlock 
                OriginBlock = .()
                OriginBlock.Name = 
                OriginBlock.Size = .(, , ) 
                OriginBlock.CFrame = lp.Character.HumanoidRootPart.CFrame
                OriginBlock.Anchored = 
                OriginBlock.CanCollide = 
                OriginBlock.Color = .(, , ) 
                OriginBlock.Material = .Material.Neon
                OriginBlock.Transparency =  
                OriginBlock.Parent = 
                
                
                 box = .()
                box.Adornee = OriginBlock
                box.Color3 = .(, , )
                box.Parent = OriginBlock
            

            
             _, p  (:():()) 
                 p ~= lp  
                     p.Character  p.Character:() 
                         hrp = p.Character.HumanoidRootPart
                        
                          FrozenPositions[p.Name] 
                            FrozenPositions[p.Name] = hrp.CFrame
                        
                        
                        hrp.CFrame = FrozenPositions[p.Name]
                        hrp.Velocity = .(, , )
                        hrp.AssemblyLinearVelocity = .(, , )
                    
                
            
        
            
             (FrozenPositions) ~=   OriginBlock 
                (() ().Network.IncomingReplicationLag =  )
                FrozenPositions = {}
                
                
                 OriginBlock 
                    OriginBlock:()
                    OriginBlock = 
                
            
        
        :().Heartbeat:() 
    
)





























 RunService = :()
 Players = :()
 lp = Players.LocalPlayer


 Ring = .()
Ring.Name = 
Ring.Color3 = .(, , )
Ring.Transparency = 
Ring.Adornee = .Terrain 
Ring.AlwaysOnTop =  
Ring.ZIndex = 
Ring.Height =  
Ring.Parent = .Terrain


  ()
     lp.Character  lp.Character:() 
         hrp = lp.Character.HumanoidRootPart
        
         randomDir = .(.(-, ), , .(-, )).Unit
         randomDir.Magnitude ==   randomDir = .(,,) 
        
        hrp.CFrame = hrp.CFrame + (randomDir * ) 
    


.(()
      
         .AntiHit_Enabled  lp.Character  lp.Character:() 
             myHrp = lp.Character.HumanoidRootPart
             radius = .AntiHit_Radius
            
            
            Ring.Visible = 
            Ring.InnerRadius = radius -  
            Ring.Radius = radius
            Ring.CFrame = .(myHrp.Position - .(, , )) * .(.(), , )
            
            
             _, p  (Players:()) 
                 p ~= lp  p.Character  p.Character:() 
                    
                    
                     p.Team == lp.Team  p.TeamColor == lp.TeamColor  
                         
                    
                    
                     enemyHrp = p.Character.HumanoidRootPart
                     distance = (myHrp.Position - enemyHrp.Position).Magnitude
                    
                    
                     distance <= radius 
                        ()
                        Rayfield:({
                            Title = , 
                            Content = , 
                            Duration = 
                        })
                        .() 
                    
                
            
        
            Ring.Visible =  
        
        RunService.Heartbeat:()
    
)































.ModoGhostFE = 

:().Heartbeat:(()
     lp = .Players.LocalPlayer
     char = lp.Character
     root = char  char:()
     hum = char  char:()

     .ModoGhostFE  root  hum  hum.Health >  
         oldPos = root.CFrame
        
        root.CFrame = oldPos * .(, -, )
        
        
        hum.CameraOffset = .(, , )
        
        
        :().RenderStepped:()
        root.CFrame = oldPos
     hum 
        
        hum.CameraOffset = .(, , )
    
)



















































 Lighting = :()
 ReplicatedStorage = :()
 Atmosphere = Lighting:()


 NVG_Effect = Lighting:()  .(, Lighting)
NVG_Effect.Name = 


.(()
     .()  
         .NightVision_Enabled 
            
             Atmosphere  Atmosphere.Parent == Lighting 
                Atmosphere.Parent = ReplicatedStorage
            
            
            
            Lighting.ExposureCompensation =  
            NVG_Effect.Enabled = 
            NVG_Effect.Brightness = 
            NVG_Effect.Contrast = 
            NVG_Effect.Saturation = - 
            NVG_Effect.TintColor = .(, , ) 
        
            
             Atmosphere  Atmosphere.Parent == ReplicatedStorage 
                Atmosphere.Parent = Lighting
            
            
            Lighting.ExposureCompensation = 
            NVG_Effect.Enabled = 
            NVG_Effect.TintColor = .(, , )
            NVG_Effect.Saturation = 
            NVG_Effect.Contrast = 
        
    
)




























:().RenderStepped:(()
     cam = .CurrentCamera
     cam  cam.FieldOfView ~= .CustomFOV 
        
        cam.FieldOfView = .CustomFOV
    
)





































 RunService = :()
 Players = :()
 LocalPlayer = Players.LocalPlayer
 Camera = .CurrentCamera


 .Tracers_Enabled ==   .Tracers_Enabled =  
 .Tracer_Origin ==   .Tracer_Origin =  

  ()
     gui = LocalPlayer.PlayerGui:()
      gui 
        gui = .()
        gui.Name = 
        gui.IgnoreGuiInset = 
        gui.ResetOnSpawn =  
        gui.DisplayOrder = 
        gui.Parent = LocalPlayer.PlayerGui
    
     gui


  (player)
     folder = ()
     name =  .. player.Name
     line = folder:(name)
      line 
        line = .()
        line.Name = name
        line.BorderSizePixel = 
        
        
        line.AnchorPoint = .(, ) 
        line.Visible = 
        line.Parent = folder
    
     line


RunService.RenderStepped:(()
    
      .Tracers_Enabled 
         gui = LocalPlayer.PlayerGui:()
         gui 
             _, child  (gui:())  child.Visible =  
        
        
    

     cam = .CurrentCamera
      cam   

    
     StartPos = .(cam.ViewportSize.X / , cam.ViewportSize.Y) 

     .Tracer_Origin ==  
        StartPos = .(cam.ViewportSize.X / , cam.ViewportSize.Y / )
     .Tracer_Origin ==  
        StartPos = .(cam.ViewportSize.X / , )
    

     _, player  (Players:()) 
         player ~= LocalPlayer 
             line = (player)
             char = player.Character
             hrp = char  char:()
             hum = char  char:()

             hrp  hum  hum.Health >  
                
                
                 ScreenPoint, OnScreen = cam:(hrp.Position)
                 EndPos = .(ScreenPoint.X, ScreenPoint.Y)

                
                 ScreenPoint.Z <  
                    InvPos = (EndPos - .(cam.ViewportSize.X/, cam.ViewportSize.Y/)).Unit * 
                   EndPos = .(cam.ViewportSize.X/, cam.ViewportSize.Y/) - InvPos
                

                
                
                 Center = (StartPos + EndPos) / 
                
                 Distance = (StartPos - EndPos).Magnitude
                
                 Angle = .(EndPos.Y - StartPos.Y, EndPos.X - StartPos.X)

                
                line.Visible = 
                line.Size = .(, Distance, , ) 
                line.Position = .(, Center.X, , Center.Y) 
                line.Rotation = .(Angle)

                
                 player.TeamColor 
                    line.BackgroundColor3 = player.TeamColor.Color
                
                    line.BackgroundColor3 = .(, , )
                
            
                 line  line.Visible =  
            
        
    
)


Players.PlayerRemoving:((player)
     folder = LocalPlayer.PlayerGui:()
     folder 
         line = folder:( .. player.Name)
         line  line:() 
    
)

































 Players = :()
 RunService = :()
 LocalPlayer = Players.LocalPlayer


 HIGHLIGHT_NAME = 


  ()
     _, p  (Players:()) 
         p.Character 
             hl = p.Character:(HIGHLIGHT_NAME)
             hl  hl:() 
        
    


RunService.RenderStepped:(()
    
      .Shadow_Enabled 
        
        
         _, p  (Players:()) 
             p.Character  p.Character:(HIGHLIGHT_NAME) 
                ()
                
            
        
        
    

    
     _, p  (Players:()) 
         p ~= LocalPlayer  p.Character 
             Char = p.Character
            
            
             Hum = Char:()
             Hum  Hum.Health >  
                
                
                 HL = Char:(HIGHLIGHT_NAME)
                
                  HL 
                    HL = .()
                    HL.Name = HIGHLIGHT_NAME
                    HL.Adornee = Char
                    HL.Parent = Char
                    HL.DepthMode = .HighlightDepthMode.AlwaysOnTop 
                

                
                
                 TeamColor = .(, , ) 
                 p.TeamColor 
                    TeamColor = p.TeamColor.Color
                

                HL.FillColor = TeamColor
                HL.OutlineColor = .(, , ) 
                
                
                HL.FillTransparency = .Shadow_Fill  
                HL.OutlineTransparency = .Shadow_Outline  
                
            
                
                 hl = Char:(HIGHLIGHT_NAME)
                 hl  hl:() 
            
        
    
)


Players.PlayerRemoving:((p)
     p.Character 
         hl = p.Character:(HIGHLIGHT_NAME)
         hl  hl:() 
    
)





































 RunService = :()
 Players = :()
 Camera = .CurrentCamera
 LocalPlayer = Players.LocalPlayer


  ()
     folder = LocalPlayer.PlayerGui:()
      folder 
        folder = .()
        folder.Name = 
        folder.IgnoreGuiInset =  
        folder.ResetOnSpawn = 
        folder.Parent = LocalPlayer.PlayerGui
    
     folder



 ESPGuis = {}

  (plr)
     ESPGuis[plr] 
         ESPGuis[plr].Box 
            ESPGuis[plr].Box:()
        
        ESPGuis[plr] = 
    


RunService.RenderStepped:(()
    
      .ESP_Enabled 
         _, set  (ESPGuis) 
             set.Box  set.Box.Visible =  
        
        
    

     Folder = ()

     _, plr  (Players:()) 
         plr ~= LocalPlayer 
            
              ESPGuis[plr] 
                 Box = .()
                Box.Name =  .. plr.Name
                Box.BackgroundTransparency =  
                Box.BorderSizePixel = 
                Box.Visible = 
                Box.Parent = Folder

                
                 Stroke = .()
                Stroke.Thickness = 
                Stroke.ApplyStrokeMode = .ApplyStrokeMode.Border
                Stroke.Parent = Box

                ESPGuis[plr] = {
                    Box = Box,
                    Stroke = Stroke
                }
            

             D = ESPGuis[plr]
             Char = plr.Character
            
            
             Char  Char:()  Char:()  Char.Humanoid.Health >  
                 Hum = Char.Humanoid
                 HRP = Char.HumanoidRootPart
                 Pos, OnScreen = Camera:(HRP.Position)

                 OnScreen 
                    
                     Size = (Hum.RigType == .HumanoidRigType.R6    )
                     Top = Camera:(HRP.Position + .(, Size, ))
                     Bottom = Camera:(HRP.Position - .(, Size + , ))
                     Height = .(Top.Y - Bottom.Y)
                     Width = Height / 
                     BoxPos = .(Pos.X - Width / , Pos.Y - Height / )

                    
                    D.Box.Size = .(, Width, , Height)
                    D.Box.Position = .(, BoxPos.X, , BoxPos.Y)
                    D.Box.Visible = 
                    
                    
                     plr.TeamColor 
                        D.Stroke.Color = plr.TeamColor.Color
                    
                        D.Stroke.Color = .(, , ) 
                    

                
                    
                    D.Box.Visible = 
                
            
                
                D.Box.Visible = 
            
        
            
             ESPGuis[plr]  (plr) 
        
    
)

Players.PlayerRemoving:(RemoveESP)















































 RunService = :()
 Players = :()
 LocalPlayer = Players.LocalPlayer


  ()
     folder = LocalPlayer.PlayerGui:()
      folder 
        folder = .()
        folder.Name = 
        folder.ResetOnSpawn =  
        folder.Parent = LocalPlayer.PlayerGui
    
     folder


 InvGuis = {}

  (plr)
     InvGuis[plr] 
         InvGuis[plr].Bill  InvGuis[plr].Bill:() 
        InvGuis[plr] = 
    



  (tool, parent, isEquipped, teamColor)
     Slot = .()
    Slot.Size = .(, , , ) 
    Slot.BackgroundColor3 = .(, , )
    Slot.BorderSizePixel = 
    Slot.Parent = parent

     Corner = .()
    Corner.CornerRadius = .(, )
    Corner.Parent = Slot

     Stroke = .()
    Stroke.Parent = Slot
    
     isEquipped 
        Stroke.Color = teamColor
        Stroke.Thickness = 
    
        Stroke.Color = .(, , )
        Stroke.Thickness = 
    

     tool.TextureId ~=  
         Icon = .()
        Icon.Size = .(, , , )
        Icon.Position = .(, , , )
        Icon.BackgroundTransparency = 
        Icon.Image = tool.TextureId
        Icon.Parent = Slot
    
         Name = .()
        Name.Size = .(, , , )
        Name.BackgroundTransparency = 
        
        Name.Text = .(tool.Name, , ) 
        Name.TextColor3 = .(, , )
        Name.TextScaled = 
        Name.Font = .Font.GothamBold
        Name.Parent = Slot
    
    
     Slot



RunService.RenderStepped:(()
    
      .VisualInv_Enabled 
         _, data  (InvGuis) 
             data.Bill  data.Bill.Enabled =  
        
        
    

     _, plr  (Players:()) 
         plr ~= LocalPlayer 
             Char = plr.Character
            
             isAlive = Char  Char:()  Char:()  Char:()  Char.Humanoid.Health > 
            
             isAlive 
                
                  InvGuis[plr] 
                     Bill = .()
                    Bill.Name =  .. plr.Name
                    Bill.AlwaysOnTop = 
                    Bill.Size = .(, , , )
                    Bill.StudsOffset = .(, , ) 
                    Bill.MaxDistance =  
                    
                    
                    Bill.Parent = ()
                    
                     Container = .()
                    Container.Size = .(, , , )
                    Container.BackgroundTransparency = 
                    Container.Parent = Bill
                    
                     Layout = .()
                    Layout.FillDirection = .FillDirection.Horizontal
                    Layout.HorizontalAlignment = .HorizontalAlignment.Center
                    Layout.VerticalAlignment = .VerticalAlignment.Center
                    Layout.Padding = .(, )
                    Layout.Parent = Container

                    InvGuis[plr] = {Bill = Bill, Container = Container, LastUpdate = }
                

                 GUI = InvGuis[plr]
                
                
                GUI.Bill.Adornee = Char.Head
                GUI.Bill.Enabled = 

                
                 () - GUI.LastUpdate >  
                    GUI.LastUpdate = ()
                    
                    
                     _, child  (GUI.Container:()) 
                         child:()  child:() 
                    

                     TColor = plr.TeamColor  plr.TeamColor.Color  .(, , ) 

                    
                     Equipped = Char:()
                     Equipped 
                        (Equipped, GUI.Container, , TColor)
                    

                    
                     Backpack = plr:()
                     Backpack 
                         Count = 
                         _, Item  (Backpack:()) 
                             Item:() 
                                (Item, GUI.Container, , TColor)
                                Count = Count + 
                                 Count >=     
                            
                        
                    
                
            
                
                 InvGuis[plr]  
                    InvGuis[plr].Bill.Enabled =  
                    InvGuis[plr].Bill.Adornee = 
                
            
        
    
)


Players.PlayerRemoving:(RemoveGUI)














































.(()
     p = .Players.LocalPlayer
     runService = :()
     staticY = 
     active = 
    
    
     PlayerControl
    (()
        PlayerControl = (p.PlayerScripts:()):()
    )

    runService.Stepped:(()
         char = p.Character
         hrp = char  char:()
         hum = char  char:()

        
         .ZSLX_Fly  hrp  hum  hum.Health >  
              active 
                staticY = hrp.Position.Y
                active = 
            

            hum:(.HumanoidStateType.Physics)
            hum.PlatformStand = 
            
            
             canCollideState =  (.Noclip_Enabled  )
             _, part  (char:()) 
                 part:()  part.CanCollide = canCollideState 
            
            
             cam = .CurrentCamera
            
             speed = (.ZSLX_FlySpeed  ) 
            
            
             moveVector = PlayerControl:()
            
             moveVector.Magnitude >  
                 camCF = cam.CFrame
                 look = camCF.LookVector
                 right = camCF.RightVector
                
                
                 direction = (look * -moveVector.Z) + (right * moveVector.X)
                
                hrp.AssemblyLinearVelocity = direction * speed
                staticY = hrp.Position.Y 
            
                
                hrp.AssemblyLinearVelocity = .(, , )
                hrp.CFrame = .(hrp.Position.X, staticY, hrp.Position.Z) * hrp.CFrame.Rotation
            
            
            
            hrp.CFrame = .(hrp.Position, hrp.Position + cam.CFrame.LookVector)
            hrp.RotVelocity = .(, , )
        
             active 
                active = 
                 hum then
                    hum.PlatformStand = false
                    hum:ChangeState(Enum.HumanoidStateType.GettingUp)
                end
                if char then
                    for _, part in pairs(char:GetChildren()) do
                        if part:IsA("BasePart") then part.CanCollide = true end
                    end
                end
            end
        end
    end)
end)