PIRNO CCX Source

 repo = 
 Library = (:(repo .. ))()
 ThemeManager = (:(repo .. ))()
 SaveManager = (:(repo .. ))()

 HttpService = :()
 RunService = :()
 UserInputService = :()
 Players = :()
 Lighting = :()
 TweenService = :()
 ReplicatedFirst = :()
 ReplicatedStorage = :()
 ScriptContext = :()
 Stats = :()
 VirtualUser = :()

 Camera = .CurrentCamera
 LP = Players.LocalPlayer


 sound_ids = {
    [] = ,
    [] = ,
    [] = ,
    [] = 
}

 current_sky = Lighting:()
 default_sky = {
    SkyboxBk = current_sky  current_sky.SkyboxBk  , SkyboxDn = current_sky  current_sky.SkyboxDn  ,
    SkyboxFt = current_sky  current_sky.SkyboxFt  , SkyboxLf = current_sky  current_sky.SkyboxLf  ,
    SkyboxRt = current_sky  current_sky.SkyboxRt  , SkyboxUp = current_sky  current_sky.SkyboxUp  
}

 SkyBoxes = {
    [] = default_sky,
    [] = { [] = , [] = , [] = , [] = , [] = , [] =  },
    [] = { []=, []=, []=, []=, []=, []= },
    [] = { []=, []=, []=, []=, []=, []= },
    [] = { []=, []=, []=, []=, []=, []= },
    [] = { []=, []=, []=, []=, []=, []= }
}


 OriginalLighting = {
    Ambient = Lighting.Ambient,
    OutdoorAmbient = Lighting.OutdoorAmbient,
    ColorShift_Bottom = Lighting.ColorShift_Bottom,
    ColorShift_Top = Lighting.ColorShift_Top,
    GlobalShadows = Lighting.GlobalShadows,
    ClockTime = Lighting.ClockTime,
    FogEnd = Lighting.FogEnd,
    FogStart = Lighting.FogStart
}

 game_atmosphere = Lighting:()
 original_atmosphere_density = game_atmosphere  game_atmosphere.Density  


 Framework, Classes, Libraries, Bullets, OldFire, Entities, Network
(()
    Framework = (ReplicatedFirst:())
     Framework.WaitForLoaded  (() Framework:() ) 
    Classes = Framework.Classes
    Libraries = Framework.Libraries
    Bullets = Libraries  Libraries.Bullets
    Entities = Libraries  Libraries.Entities
    Network = Libraries  Libraries.Network
)


 CHAR_FOLDER = :(, )
 ZOMBIES = :()
 CORPSES = :()
 VEHICLES = :()


 HitmarkerSound = .()
HitmarkerSound.Volume = 
HitmarkerSound.Parent = 


 SilentFovCircle = .()
SilentFovCircle.Thickness = ; SilentFovCircle.NumSides = ; SilentFovCircle.Filled = ; SilentFovCircle.Visible = 

 AimLockFovCircle = .()
AimLockFovCircle.Thickness = ; AimLockFovCircle.NumSides = ; AimLockFovCircle.Filled = ; AimLockFovCircle.Visible = 

 AimTracer = .()
AimTracer.Thickness = ; AimTracer.Color = .(, , ); AimTracer.Visible = 

 TargetDot = .()
TargetDot.Thickness = ; TargetDot.Radius = ; TargetDot.Filled = ; TargetDot.Color = .(, , ); TargetDot.Visible = 

 CustomCrosshair = { Top = .(), Bottom = .(), Left = .(), Right = .() }
 _, line  (CustomCrosshair)  line.Thickness = ; line.Color = .(, , ); line.Visible =  

 ESP_Table = {}
 Corpse_Objects = {}
 Vehicle_Data = {}
 ItemESP_Cache = { Texts = {}, Nodes = {}, LastRefresh =  }
 LootBoxESP_Cache = { Texts = {}, Entries = {}, LastRefresh =  }

 CurrentSilentTarget, CurrentSilentRoot, SilentAimPoint = , , 
 CurrentAimLockTarget, CurrentAimLockRoot, AimLockPoint = , , 


 KnownPlayers = {}
  ()  _, p  (Players:())  KnownPlayers[p.Name] =   
Players.PlayerAdded:((p) KnownPlayers[p.Name] =  )
()


.(()
    (()
         getconnections   _, Connection  ((ScriptContext.Error))  Connection:()  
    )
)


 originalHeadProps = {}
 oldIndex
oldIndex = (, , (self, key)
      ()  key ==   originalHeadProps[self] 
         originalHeadProps[self].Size
    
     (self, key)
)

 oldNewIndex
oldNewIndex = (, , (self, key, value)
      ()  key ==   originalHeadProps[self] 
        originalHeadProps[self].Size = value
        
    
     (self, key, value)
)


  (character)
     player = Players:(character)
     player  (player.DisplayName  player.Name)  character.Name


  (character)
     tool = character:()
     tool   tool.Name 
     equipFolder = character:()  character:()
     equipFolder 
         _, child  (equipFolder:()) 
             child:()  child:()   child.Name 
        
    
     


  (targetPos, targetCharacter, wallbangEnabled)
     wallbangEnabled    
     rayParams = RaycastParams.()
    rayParams.FilterType = .RaycastFilterType.Exclude
    rayParams.FilterDescendantsInstances = {LP.Character, targetCharacter, Camera}
    rayParams.IgnoreWater = 
     result = :(Camera.CFrame.Position, targetPos - Camera.CFrame.Position, rayParams)
     result == 



  (fovRadius, wallbangEnabled)
     target, root, aimPoint = , , 
     shortest = fovRadius
     mouseLoc = UserInputService:()

      CHAR_FOLDER   , ,  

     _, char  (CHAR_FOLDER:()) 
         char:()  char ~= LP.Character 
             head = char:()
             rootPart = char:()
             hum = char:()

             head  rootPart  hum  hum.Health >  
                 pos, onScreen = Camera:(head.Position)
                 onScreen 
                     magToCenter = (.(pos.X, pos.Y) - mouseLoc).Magnitude

                     magToCenter < (fovRadius + ) 
                         cf = head.CFrame

                        
                         currentSize = 
                         Toggles.HitboxEnabled  Toggles.HitboxEnabled.Value  Options.HitboxSize 
                            currentSize = Options.HitboxSize.Value
                        

                        
                        
                         offset = (currentSize / ) - 
                         offset <   offset =   

                         points = {
                            head.Position, 
                            head.Position + (cf.UpVector * offset), 
                            head.Position - (cf.UpVector * offset), 
                            head.Position + (cf.RightVector * offset), 
                            head.Position - (cf.RightVector * offset), 
                            head.Position + (cf.UpVector * offset) + (cf.RightVector * offset), 
                            head.Position + (cf.UpVector * offset) - (cf.RightVector * offset), 
                            head.Position - (cf.UpVector * offset) + (cf.RightVector * offset), 
                            head.Position - (cf.UpVector * offset) - (cf.RightVector * offset)  
                        }

                         validPoint = 
                         _, pt  (points) 
                             (pt, char, wallbangEnabled) 
                                validPoint = pt; 
                            
                        

                         validPoint 
                             exactPos, _ = Camera:(validPoint)
                             exactMag = (.(exactPos.X, exactPos.Y) - mouseLoc).Magnitude

                             exactMag < shortest 
                                shortest = exactMag; target = head; root = rootPart; aimPoint = validPoint
                            
                        
                    
                
            
        
    
     target, root, aimPoint


  ()
     success, ping = (()  Stats.Network.ServerStatsItem[]:() )
     success  ping   (ping / ) +  
     


  (origin, targetPos)
    .(()
         (origin) ~=   (targetPos) ~=    
         distance = (origin - targetPos).Magnitude
         distance <    

         tracer = .()
        tracer.Anchored = ; tracer.CanCollide = ; tracer.CanTouch = ; tracer.CanQuery = 
        tracer.Massless = ; tracer.CastShadow = ; tracer.Material = .Material.ForceField
        tracer.Color = Options.TracerColor  Options.TracerColor.Value  .(, , )
        tracer.Size = .(, , distance)
        tracer.CFrame = .(origin, targetPos) * .(, , -distance / )
        tracer.Parent = Camera

         tween = TweenService:(tracer, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {Transparency = , Size = .(, , distance)})
        tween:(); .(); tracer:()
    )


  ()
     chunking = ReplicatedStorage:()  ReplicatedStorage:()
     chunking   chunking:()  chunking:() 
     


  (instance)
      (instance  instance.Parent)    
     instance:()   instance.Position 
     instance:()   instance.WorldPosition 
     instance:()   instance.Value.Position 
     instance:() 
         primary = instance.PrimaryPart  instance:(, )
         primary   primary.Position 
         ok, pivot = (()  instance:() )
         ok  (pivot) ==    pivot.Position 
    
     


 GrabAllRuntime = { Running = , LastRunAt = , MinInterval =  }
  ()
     now = ()
     GrabAllRuntime.Running  (now - GrabAllRuntime.LastRunAt) < GrabAllRuntime.MinInterval   
    GrabAllRuntime.Running = ; GrabAllRuntime.LastRunAt = now
    .(()
        (()
              (Entities  Network)   
             (Entities.Search) ~=   (Network.Send) ~=    
             map = :()
             elements = map  map:()
              elements   
             sentIds = {}
             _, element  (elements:()) 
                 detail = element:(, )
                 detail 
                     _, instance  (detail:()) 
                         okSearch, entity = (()  Entities:(instance) )
                         okSearch  entity  entity.Type ==   entity.Id   sentIds[entity.Id] 
                            sentIds[entity.Id] = 
                            (() Network:(, entity.Id) )
                        
                    
                
            
        )
        GrabAllRuntime.Running = 
    )



 Bullets 
    OldFire = (Bullets.Fire, (self, ...)
         Args = {...}
         Toggles.SilentAimEnabled  Toggles.SilentAimEnabled.Value  SilentAimPoint  CurrentSilentRoot 
             origin = Args[]
             finalOrigin = (origin) ==   origin
              finalOrigin 
                 tool = LP.Character  LP.Character:()
                 handle = tool  (tool:()  tool:()  tool:()  tool:())
                finalOrigin = handle  handle.Position  Camera.CFrame.Position
            

             predictionTime = ()
             targetVelocity = CurrentSilentRoot.AssemblyLinearVelocity
             predictedPosition = SilentAimPoint + (targetVelocity * predictionTime)

            Args[] = (predictedPosition - finalOrigin).Unit

             Toggles.HitSound.Value 
                (()
                    HitmarkerSound.SoundId = sound_ids[Options.HitSoundType.Value]  sound_ids[]
                    HitmarkerSound:()
                )
            
             Toggles.BulletTracer.Value  (finalOrigin, predictedPosition) 
        
         (self, (Args))
    )



  (obj)
     ESP_Table[obj]   
     data = { BoxOutline = .(), Box = .(), Name = .(), Distance = .(), Weapon = .(), HealthBarBG = .(), HealthBar = .() }

    data.BoxOutline.Thickness = ; data.BoxOutline.Color = .(,,); data.BoxOutline.Filled = 
    data.Box.Thickness = ; data.Box.Color = .(,,); data.Box.Filled = 

    data.Name.Size = ; data.Name.Center = ; data.Name.Outline = ; data.Name.Color = .(,,); data.Name.Font = 
    data.Distance.Size = ; data.Distance.Center = ; data.Distance.Outline = ; data.Distance.Color = .(, , ); data.Distance.Font = 
    data.Weapon.Size = ; data.Weapon.Center = ; data.Weapon.Outline = ; data.Weapon.Color = .(, , ); data.Weapon.Font = 

    data.HealthBarBG.Filled = ; data.HealthBarBG.Color = .(,,); data.HealthBarBG.Thickness = 
    data.HealthBar.Filled = ; data.HealthBar.Thickness = 

    ESP_Table[obj] = data


  (dict, obj, color, icon)
     dict[obj]   
     data = { Name = .(), Dist = .(), Highlight = .() }
    data.Name.Size = ; data.Name.Center = ; data.Name.Outline = ; data.Name.Color = color; data.Name.Font = 
    data.Dist.Size = ; data.Dist.Center = ; data.Dist.Outline = ; data.Dist.Color = .(, , ); data.Dist.Font = 
    data.Highlight.Parent = obj; data.Highlight.FillColor = color; data.Highlight.FillTransparency = ; data.Highlight.OutlineColor = .(, , ); data.Highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    dict[obj] = {Drawings = data, Icon = icon}


  (color)
     t = .()
    t.Size = ; t.Font = ; t.Outline = ; t.Center = ; t.Color = color; t.Visible = 
     t



 AutoShootTick = 
RunService.RenderStepped:(()
     mouseLoc = UserInputService:()
     current_atmosphere = Lighting:()

    
     Toggles.FullBright  Toggles.FullBright.Value 
        Lighting.Ambient = .(, , )
        Lighting.OutdoorAmbient = .(, , )
        Lighting.ColorShift_Bottom = .(, , )
        Lighting.ColorShift_Top = .(, , )
        Lighting.GlobalShadows = 
        Lighting.ClockTime = 
    
         Toggles.EveningMode  Toggles.EveningMode.Value 
            Lighting.ClockTime = 
            Lighting.Ambient = .(, , )
            Lighting.OutdoorAmbient = .(, , )
            Lighting.GlobalShadows = OriginalLighting.GlobalShadows
        
            Lighting.Ambient = OriginalLighting.Ambient
            Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
            Lighting.ColorShift_Bottom = OriginalLighting.ColorShift_Bottom
            Lighting.ColorShift_Top = OriginalLighting.ColorShift_Top
            Lighting.GlobalShadows = OriginalLighting.GlobalShadows
            Lighting.ClockTime = OriginalLighting.ClockTime
        
    

     Toggles.NoFog  Toggles.NoFog.Value 
        Lighting.FogEnd = 
        Lighting.FogStart = 
         current_atmosphere  current_atmosphere.Density =  
    
        Lighting.FogEnd = OriginalLighting.FogEnd
        Lighting.FogStart = OriginalLighting.FogStart
         current_atmosphere  current_atmosphere.Density = original_atmosphere_density 
    

     Toggles.FOV_Active  Toggles.FOV_Active.Value  Camera.FieldOfView = Options.FOV_Value.Value 

    
     Toggles.ShowCrosshair  Toggles.ShowCrosshair.Value 
         gap = Options.CrosshairGap.Value;  len = Options.CrosshairLength.Value
        CustomCrosshair.Top.From = .(mouseLoc.X, mouseLoc.Y - gap); CustomCrosshair.Top.To = .(mouseLoc.X, mouseLoc.Y - gap - len); CustomCrosshair.Top.Visible = 
        CustomCrosshair.Bottom.From = .(mouseLoc.X, mouseLoc.Y + gap); CustomCrosshair.Bottom.To = .(mouseLoc.X, mouseLoc.Y + gap + len); CustomCrosshair.Bottom.Visible = 
        CustomCrosshair.Left.From = .(mouseLoc.X - gap, mouseLoc.Y); CustomCrosshair.Left.To = .(mouseLoc.X - gap - len, mouseLoc.Y); CustomCrosshair.Left.Visible = 
        CustomCrosshair.Right.From = .(mouseLoc.X + gap, mouseLoc.Y); CustomCrosshair.Right.To = .(mouseLoc.X + gap + len, mouseLoc.Y); CustomCrosshair.Right.Visible = 
    
         _, line  (CustomCrosshair)  line.Visible =  
    

    
    AimLockFovCircle.Position = mouseLoc; AimLockFovCircle.Radius = Options.AimLockFov  Options.AimLockFov.Value  
    AimLockFovCircle.Color = Options.AimLockFovColor  Options.AimLockFovColor.Value  .(, , )
    AimLockFovCircle.Visible = Toggles.AimLockEnabled  Toggles.AimLockEnabled.Value  Toggles.ShowAimLockFov.Value

    CurrentAimLockTarget, CurrentAimLockRoot, AimLockPoint = (Options.AimLockFov.Value, Toggles.AimLockWallHack.Value)

     Toggles.AimLockEnabled  Toggles.AimLockEnabled.Value  Options.AimLockKey:()  AimLockPoint 
         targetPos = AimLockPoint
         predictionTime = ()
         CurrentAimLockRoot  targetPos = targetPos + (CurrentAimLockRoot.AssemblyLinearVelocity * predictionTime) 

         screenPos, onScreen = Camera:(targetPos)
         onScreen  mousemoverel 
             smooth = Options.AimLockSmoothness.Value
             smooth <   smooth =  
            ((screenPos.X - mouseLoc.X) / smooth, (screenPos.Y - mouseLoc.Y) / smooth)
        
    

    
    SilentFovCircle.Position = mouseLoc; SilentFovCircle.Radius = Options.SilentAimFov  Options.SilentAimFov.Value  
    SilentFovCircle.Color = Options.SilentFovColor  Options.SilentFovColor.Value  .(, , )
    SilentFovCircle.Visible = Toggles.SilentAimEnabled  Toggles.SilentAimEnabled.Value  Toggles.ShowSilentFov.Value

    CurrentSilentTarget, CurrentSilentRoot, SilentAimPoint = (Options.SilentAimFov.Value, Toggles.SilentWallHack.Value)

     Toggles.SilentAimEnabled  Toggles.SilentAimEnabled.Value  SilentAimPoint 
         screenPos, onScreen = Camera:(SilentAimPoint)

         onScreen 
            TargetDot.Position = .(screenPos.X, screenPos.Y)
            TargetDot.Visible = 

             Toggles.ShowAimTracer.Value 
                AimTracer.From = mouseLoc; AimTracer.To = .(screenPos.X, screenPos.Y); AimTracer.Visible = 
             AimTracer.Visible =  
        
            TargetDot.Visible = 
            AimTracer.Visible = 
        

         Toggles.AutoShootEnabled  Toggles.AutoShootEnabled.Value  Options.AutoShootKey:() 
             () - AutoShootTick >  
                AutoShootTick = ()
                 mouse1click 
                    ()
                
                    VirtualUser:(.(mouseLoc.X, mouseLoc.Y))
                
            
        
    
        TargetDot.Visible = 
        AimTracer.Visible = 
    

    
     activePlayers = {}
     Toggles.ESP_Enabled  Toggles.ESP_Enabled.Value  CHAR_FOLDER 
         _, char  (CHAR_FOLDER:()) 
             char:()  char ~= LP.Character 
                 hrp = char:();  hum = char:()
                 hrp  hum  hum.Health >  
                    activePlayers[char] = 
                      ESP_Table[char]  (char) 
                     data = ESP_Table[char]
                     pos, onScreen = Camera:(hrp.Position)
                     dist = (Camera.CFrame.Position - hrp.Position).Magnitude

                     onScreen  dist <= Options.ESP_MaxDistance.Value 
                         headPos = char:()  char.Head.Position  (hrp.Position + .(, , ))
                         legPos = hrp.Position - .(, , )
                         top, _ = Camera:(headPos + .(, , ))
                         bottom, _ = Camera:(legPos)

                         sizeY = .(top.Y - bottom.Y)
                         sizeX = sizeY * 
                         topY = top.Y

                        data.BoxOutline.Visible = Toggles.ESP_Box.Value
                        data.BoxOutline.Size = .(sizeX, sizeY)
                        data.BoxOutline.Position = .(pos.X - sizeX / , topY)

                        data.Box.Visible = Toggles.ESP_Box.Value
                        data.Box.Size = .(sizeX, sizeY)
                        data.Box.Position = .(pos.X - sizeX / , topY)
                        data.Box.Color = Options.ESP_Color  Options.ESP_Color.Value  .(,,)

                        data.Name.Visible = Toggles.ESP_Name.Value
                        data.Name.Text = (char)
                        data.Name.Position = .(pos.X, topY - )

                        data.Distance.Visible = Toggles.ESP_Distance.Value
                        data.Distance.Text =  .. .(dist) .. 
                        data.Distance.Position = .(pos.X, topY + sizeY + )

                         Toggles.ESP_Weapon.Value 
                             weaponName = (char)
                             weaponName 
                                data.Weapon.Visible = 
                                data.Weapon.Text = weaponName
                                data.Weapon.Position = .(pos.X, topY + sizeY + (Toggles.ESP_Distance.Value    ))
                             data.Weapon.Visible =  
                         data.Weapon.Visible =  

                         Toggles.ESP_HealthBar.Value 
                             healthPercent = .(hum.Health / hum.MaxHealth, , )
                             barHeight = .(sizeY * healthPercent)

                            data.HealthBarBG.Visible = 
                            data.HealthBarBG.Size = .(, sizeY + )
                            data.HealthBarBG.Position = .(pos.X - (sizeX / ) - , topY - )

                            data.HealthBar.Visible = 
                            data.HealthBar.Size = .(, barHeight)
                            data.HealthBar.Position = .(pos.X - (sizeX / ) - , topY + (sizeY - barHeight))
                            data.HealthBar.Color = .( - (healthPercent * ), healthPercent * , )
                        
                            data.HealthBarBG.Visible = ; data.HealthBar.Visible = 
                        
                    
                         _, v  (data)  v.Visible =  
                    
                
            
        
    

     char, data  (ESP_Table) 
          activePlayers[char] 
             _, v  (data)  (() v.Visible =  ) 
             (char) ~=    char.Parent 
                 _, v  (data)  (() v:() ) 
                ESP_Table[char] = 
            
        
    

     activeCorpses = {}
     Toggles.Corpse_Enabled  Toggles.Corpse_Enabled.Value  CORPSES 
         _, obj  (CORPSES:()) 
             obj:()  KnownPlayers[obj.Name] 
                 hrp = obj:()  obj:()
                 hrp 
                    activeCorpses[obj] = 
                      Corpse_Objects[obj]  (Corpse_Objects, obj, .(, , ), ) 
                     data = Corpse_Objects[obj]
                     pos, onScreen = Camera:(hrp.Position)
                     dist = (Camera.CFrame.Position - hrp.Position).Magnitude
                     onScreen  dist <  
                        data.Drawings.Name.Visible = Toggles.Corpse_Name.Value; data.Drawings.Name.Text = data.Icon ..  .. obj.Name; data.Drawings.Name.Position = .(pos.X, pos.Y - )
                        data.Drawings.Dist.Visible = Toggles.Corpse_Distance.Value; data.Drawings.Dist.Text = .(dist) .. ; data.Drawings.Dist.Position = .(pos.X, pos.Y - )
                        data.Drawings.Highlight.Enabled = Toggles.Corpse_Chams.Value
                     data.Drawings.Name.Visible = ; data.Drawings.Dist.Visible = ; data.Drawings.Highlight.Enabled =  
                
            
        
    

     obj, data  (Corpse_Objects) 
          activeCorpses[obj] 
            (() data.Drawings.Name.Visible = ; data.Drawings.Dist.Visible = ; data.Drawings.Highlight.Enabled =  )
             (obj) ~=    obj.Parent 
                (() data.Drawings.Name:() ); (() data.Drawings.Dist:() ); (() data.Drawings.Highlight:() )
                Corpse_Objects[obj] = 
            
        
    

     activeVehicles = {}
     Toggles.Vehicle_Enabled  Toggles.Vehicle_Enabled.Value  VEHICLES 
         _, v  (VEHICLES:()) 
             primary = v:()  v:(, )
             primary 
                activeVehicles[v] = 
                  Vehicle_Data[v]  (Vehicle_Data, v, .(, , ), ) 
                 data = Vehicle_Data[v]
                 pos, onScreen = Camera:(primary.Position)
                 dist = (Camera.CFrame.Position - primary.Position).Magnitude
                 onScreen  dist <  
                    data.Drawings.Name.Visible = Toggles.Vehicle_Name.Value; data.Drawings.Name.Text = data.Icon ..  .. v.Name; data.Drawings.Name.Position = .(pos.X, pos.Y - )
                    data.Drawings.Dist.Visible = Toggles.Vehicle_Distance.Value; data.Drawings.Dist.Text =  .. .(dist) .. ; data.Drawings.Dist.Position = .(pos.X, pos.Y)
                    data.Drawings.Highlight.Enabled = Toggles.Vehicle_Chams.Value
                 data.Drawings.Name.Visible = ; data.Drawings.Dist.Visible = ; data.Drawings.Highlight.Enabled =  
            
        
    

     obj, data  (Vehicle_Data) 
          activeVehicles[obj] 
            (() data.Drawings.Name.Visible = ; data.Drawings.Dist.Visible = ; data.Drawings.Highlight.Enabled =  )
             (obj) ~=    obj.Parent 
                (() data.Drawings.Name:() ); (() data.Drawings.Dist:() ); (() data.Drawings.Highlight:() )
                Vehicle_Data[obj] = 
            
        
    

     activeItems = {}
     Toggles.ItemEspEnabled  Toggles.ItemEspEnabled.Value 
         () - ItemESP_Cache.LastRefresh >  
            ItemESP_Cache.LastRefresh = ()
             chunkData = ()
             nodes = {}
             chunkData 
                 _, obj  (chunkData:())   obj.Name ==   obj:()  nodes[obj] =   
            
             map = :()
             map  map:() 
                 _, el  (map.Elements:()) 
                     d = el:(, )
                     d   _, i  (d:())   i:()  i.Name ==   nodes[i] =    
                
            
            ItemESP_Cache.Nodes = nodes
        

         node, _  (ItemESP_Cache.Nodes) 
             wPos = (node)
             wPos 
                 dist = (Camera.CFrame.Position - wPos).Magnitude
                 dist <= Options.ItemEspDistance.Value 
                     vp, on = Camera:(wPos)
                     on  vp.Z >  
                          ItemESP_Cache.Texts[node]  ItemESP_Cache.Texts[node] = (.(, , )) 
                         txt = ItemESP_Cache.Texts[node]
                        txt.Text =  .. .(dist) .. ; txt.Position = .(vp.X, vp.Y); txt.Visible = 
                        activeItems[node] = 
                    
                         ItemESP_Cache.Texts[node]  ItemESP_Cache.Texts[node].Visible =  
                    
                
                     ItemESP_Cache.Texts[node]  ItemESP_Cache.Texts[node].Visible =  
                
            
        
    

     node, txt  (ItemESP_Cache.Texts) 
          activeItems[node] 
            (() txt.Visible =  )
             (node) ~=    node.Parent 
                (() txt:() ); ItemESP_Cache.Texts[node] = 
            
        
    

     activeLoot = {}
     Toggles.LootBoxEspEnabled  Toggles.LootBoxEspEnabled.Value 
         () - LootBoxESP_Cache.LastRefresh >  
            LootBoxESP_Cache.LastRefresh = ()
             entries = {}
             Entities  Entities.Search 
                 map = :()
                 map  map:() 
                     _, el  (map.Elements:()) 
                         d = el:(, )
                         d 
                             _, inst  (d:()) 
                                (()
                                     e = Entities:(inst)
                                     e  e.Type ==   entries[inst] =  
                                )
                            
                        
                    
                
            
            LootBoxESP_Cache.Entries = entries
        

         inst, _  (LootBoxESP_Cache.Entries) 
             wPos = (inst)
             wPos 
                 dist = (Camera.CFrame.Position - wPos).Magnitude
                 dist <= Options.LootBoxEspDistance.Value 
                     vp, on = Camera:(wPos)
                     on  vp.Z >  
                          LootBoxESP_Cache.Texts[inst]  LootBoxESP_Cache.Texts[inst] = (.(, , )) 
                         txt = LootBoxESP_Cache.Texts[inst]
                        txt.Text =  .. .(dist) .. ; txt.Position = .(vp.X, vp.Y); txt.Visible = 
                        activeLoot[inst] = 
                    
                         LootBoxESP_Cache.Texts[inst]  LootBoxESP_Cache.Texts[inst].Visible =  
                    
                
                     LootBoxESP_Cache.Texts[inst]  LootBoxESP_Cache.Texts[inst].Visible =  
                
            
        
    

     inst, txt  (LootBoxESP_Cache.Texts) 
          activeLoot[inst] 
            (() txt.Visible =  )
             (inst) ~=    inst.Parent 
                (() txt:() ); LootBoxESP_Cache.Texts[inst] = 
            
        
    
)


RunService.Heartbeat:(()
    (()
         character = LP.Character
         humanoid = character  character:()
         hrp = character  character:()
         humanoid  hrp 
             Toggles.InfJump  Toggles.InfJump.Value  UserInputService:(.KeyCode.Space)  humanoid:(.HumanoidStateType.Jumping) 
             Toggles.AntiFallDamage  Toggles.AntiFallDamage.Value  hrp.Velocity.Y < - 
                hrp.Velocity = .(hrp.Velocity.X, -, hrp.Velocity.Z); humanoid:(.HumanoidStateType.Landed)
            
        
    )

     Toggles.ZOMBIE_ANCHOR  ZOMBIES 
         freeze = Toggles.ZOMBIE_ANCHOR.Value
         _, z  (ZOMBIES:()) 
             z:() 
                 root = z:();  hum = z:()
                 root  root.Anchored = freeze ;  hum  freeze  hum.WalkSpeed =  
            
        
    

     Toggles.AutoGrabLoot  Toggles.AutoGrabLoot.Value  () 

    
     Toggles.HitboxEnabled  Toggles.HitboxEnabled.Value  CHAR_FOLDER 
         sizeVal = Options.HitboxSize.Value
         transVal = Options.HitboxTrans.Value

         _, char  (CHAR_FOLDER:()) 
             char:()  char ~= LP.Character 
                 head = char:()
                 head  head:() 
                      originalHeadProps[head] 
                        originalHeadProps[head] = { Size = head.Size, Transparency = head.Transparency }
                    
                     head.Size.X ~= sizeVal  head.Transparency ~= transVal 
                        head.Size = .(sizeVal, sizeVal, sizeVal)
                        head.Transparency = transVal
                        head.CanCollide = 
                        head.Massless = 
                    
                
            
        
    
         head, props  (originalHeadProps) 
             head  head.Parent 
                 head.Size ~= props.Size 
                    head.Size = props.Size
                    head.Transparency = props.Transparency
                
            
        
    
)


 NoclipConnection
  ()
     Toggles.NoclipEnabled.Value 
          NoclipConnection 
            NoclipConnection = RunService.Stepped:(()
                 LP.Character 
                     _, part  (LP.Character:()) 
                         part:()  part.CanCollide 
                            part.CanCollide = 
                        
                    
                
            )
        
    
         NoclipConnection 
            NoclipConnection:()
            NoclipConnection = 
        
    



 Window = Library:({ Title = , Center = , AutoShow = , TabPadding = , MenuFadeTime =  })

 Tabs = {
    Combat = Window:(),
    Visuals = Window:(),
    World = Window:(),
    Local = Window:(),
    [] = Window:()
}


 AimLockBox = Tabs.Combat:()
 HitboxUIBox = Tabs.Combat:()
 SilentAimBox = Tabs.Combat:()
 EffectsBox = Tabs.Combat:()

AimLockBox:(, { Text = , Default =  }):(, { Default = , SyncToggleState = , Mode = , Text =  })
AimLockBox:(, { Text = , Default =  })
AimLockBox:(, { Text = , Default =  }):(, { Default = .(, , ), Title =  })
AimLockBox:(, { Text = , Default = , Min = , Max = , Rounding =  })
AimLockBox:(, { Text = , Default = , Min = , Max = , Rounding =  })

HitboxUIBox:(, { Text = , Default =  })
HitboxUIBox:(, { Text = , Default = , Min = , Max = , Rounding =  })
HitboxUIBox:(, { Text = , Default = , Min = , Max = , Rounding =  })

SilentAimBox:(, { Text = , Default =  })
SilentAimBox:(, { Text = , Default =  })
SilentAimBox:(, { Text = , Default =  }):(, { Default = .(, , ), Title =  })
SilentAimBox:(, { Text = , Default = , Min = , Max = , Rounding =  })
SilentAimBox:()
SilentAimBox:(, { Text = , Default =  }):(, { Default = , SyncToggleState = , Mode = , Text =  })

EffectsBox:(, { Text = , Default =  })
EffectsBox:(, { Text = , Default =  }):(, { Default = .(, , ), Title =  })
EffectsBox:(, { Text = , Default =  })
EffectsBox:(, { Text = , Default = , Min = , Max = , Rounding =  })
EffectsBox:(, { Text = , Default = , Min = , Max = , Rounding =  })
EffectsBox:()
EffectsBox:(, { Text = , Default =  })
EffectsBox:(, { Values = { , , ,  }, Default = , Multi = , Text =  })


 EspBox = Tabs.Visuals:()
EspBox:(, { Text = , Default =  })
EspBox:(, { Text = , Default =  })
EspBox:(, { Text = , Default =  }):(, { Default = .(, , ), Title =  })
EspBox:(, { Text = , Default =  })
EspBox:(, { Text = , Default =  })
EspBox:(, { Text = , Default =  })
EspBox:(, { Text = , Default = , Min = , Max = , Rounding =  })

 WorldVisualsBox = Tabs.Visuals:()
WorldVisualsBox:(, { Values = { , , , , ,  }, Default = , Multi = , Text =  })
Options.SkyboxSelection:(()
     selected = Options.SkyboxSelection.Value
     skyData = SkyBoxes[selected]
      skyData   

     sky = Lighting:()
      sky 
        sky = .()
        sky.Parent = Lighting
    

    sky.SkyboxBk = skyData.SkyboxBk; sky.SkyboxDn = skyData.SkyboxDn; sky.SkyboxFt = skyData.SkyboxFt
    sky.SkyboxLf = skyData.SkyboxLf; sky.SkyboxRt = skyData.SkyboxRt; sky.SkyboxUp = skyData.SkyboxUp
)

WorldVisualsBox:(, { Text = , Default =  })
WorldVisualsBox:(, { Text = , Default =  })
WorldVisualsBox:(, { Text = , Default =  })


 LootBoxUI = Tabs.World:()
 CorpseBox = Tabs.World:()
 VehicleBox = Tabs.World:()

LootBoxUI:(, { Text = , Default =  }):(, { Default = , SyncToggleState = , Mode = , Text =  })
LootBoxUI:()
LootBoxUI:()
LootBoxUI:(, { Text = , Default =  })
LootBoxUI:(, { Text = , Default = , Min = , Max = , Rounding =  })
LootBoxUI:(, { Text = , Default =  })
LootBoxUI:(, { Text = , Default = , Min = , Max = , Rounding =  })

CorpseBox:(, { Text = , Default =  })
CorpseBox:(, { Text = , Default =  })
CorpseBox:(, { Text = , Default =  })
CorpseBox:(, { Text = , Default =  })

VehicleBox:(, { Text = , Default =  })
VehicleBox:(, { Text = , Default =  })
VehicleBox:(, { Text = , Default =  })
VehicleBox:(, { Text = , Default =  })


 MovementBox = Tabs.Local:()
MovementBox:(, { Text = , Default =  }):(, { Default = , SyncToggleState = , Mode = , Text =  })
Toggles.NoclipEnabled:(handleNoclip)

MovementBox:(, { Text = , Default =  })
MovementBox:(, { Text = , Default =  })
MovementBox:(, { Text = , Default =  })
MovementBox:(, { Text = , Default =  })
MovementBox:(, { Text = , Default = , Min = , Max = , Rounding =  })


Library:()
 FrameTimer = ();  FrameCounter = ;  FPS = 
RunService.RenderStepped:(()
    FrameCounter += ;  (() - FrameTimer) >=   FPS = FrameCounter; FrameTimer = (); FrameCounter =  
     ping = ; (() ping = .(Stats.Network.ServerStatsItem[]:()) )
    Library:(():(.(FPS), ping))
)

Library.KeybindFrame.Visible = 
 MenuGroup = Tabs[]:()
MenuGroup:(, () Library:() )
MenuGroup:():(, { Default = , NoUI = , Text =  })
Library.ToggleKeybind = Options.MenuKeybind

ThemeManager:(Library); SaveManager:(Library); SaveManager:(); SaveManager:({  })
ThemeManager:(); SaveManager:()
SaveManager:(Tabs[]); ThemeManager:(Tabs[])
SaveManager:()