optimized swimhub free

 type_custom = 
  LPH_OBFUSCATED 
	LPH_JIT = (...)
		 ...;
	;
	LPH_JIT_MAX = (...)
		 ...;
	;
	LPH_NO_VIRTUALIZE = (...)
		 ...;
	;
	LPH_NO_UPVALUES = (f)
		 ((...)
			 (...);
		);
	;
	LPH_ENCSTR = (...)
		 ...;
	;
	LPH_ENCNUM = (...)
		 ...;
	;
	LPH_ENCFUNC = (func, key1, key2)
		 key1 ~= key2   () 
		 func
	
	LPH_CRASH = ()
		 (debug.());
	;
    SWG_DiscordUser = 
    SWG_DiscordID = 
    SWG_Private = 
    SWG_Dev = 
    SWG_Version = 
    SWG_Title = 
    SWG_ShortName = 
    SWG_FullName = 
    SWG_FFA = 
;


  = (:())
 Players = (:())
 RunService = (:())
 Lighting = (:())
 UserInputService = (:())
 HttpService = (:())
 GuiInset = (:()):()
 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()
 Camera = .CurrentCamera

  (name)
     repo = 
     success, content = (.HttpGet, , repo..name)
     success   content   (..content..) 

  (file)
     (..file)

  (file)
      (file)    
     success, returns = (readfile, ..file)
     success   returns   (returns) 

  (file)
      (file)    
     success, returns = (, (file))
     success   returns   (returns) 

  (file)
     (file)    
     success, returns = (getcustomasset, ..file)
     success   returns   (returns) 


      ()  () 
      ()  () 
      ()  () 
      (force, list)
         _, file  list 
             (force   force   (file)) 
                (..file, (file))
            
        
    
     gotassets = ()
     assets = HttpService:(gotassets)
     localassets = ()
     localassets 
        localassets = HttpService:(localassets)
         localassets.version ~= assets.version 
            (, gotassets)
            (, assets.list)
        
    
        (, gotassets)
    
    (, assets.list)




 cheat = {
    Library = ,
    Toggles = ,
    Options = ,
    ThemeManager = ,
    SaveManager = ,
    connections = {
        heartbeats = {},
        renderstepped = {}
    },
    drawings = {},
    hooks = {}
}
cheat.utility = {} 
    cheat.utility.new_heartbeat = (func)
         obj = {}
        cheat.connections.heartbeats[func] = func
         obj:()
             func 
                cheat.connections.heartbeats[func] = 
                func = 
            
        
         obj
    
    cheat.utility.new_renderstepped = (func)
         obj = {}
        cheat.connections.renderstepped[func] = func
         obj:()
             func 
                cheat.connections.renderstepped[func] = 
                func = 
            
        
         obj
    
    cheat.utility.new_drawing = (drawobj, args)
         obj = .(drawobj)
         i, v  (args) 
            obj[i] = v
        
        cheat.drawings[obj] = obj
         obj
    
    cheat.utility.new_hook = (f, newf, usecclosure) (()
         usecclosure 
             old; old = (f, ((...)
                 (old, ...)
            ))
            cheat.hooks[f] = old
             old
        
             old; old = (f, (...)
                 (old, ...)
            )
            cheat.hooks[f] = old
             old
        
    )() 
     connection; connection = RunService.Heartbeat:(((delta)
         _, func  (cheat.connections.heartbeats) 
            (delta)
        
    ))
     connection1; connection1 = RunService.RenderStepped:(((delta)
         _, func  (cheat.connections.renderstepped) 
            (delta)
        
    ))
    cheat.utility.unload = ()
        connection:()
        connection1:()
         key, _  (cheat.connections.heartbeats) 
            cheat.connections.heartbeats[key] = 
        
         key, _  (cheat.connections.renderstepped) 
            cheat.connections.heartbeats[key] = 
        
         _, drawing  (cheat.drawings) 
            drawing:()
            cheat.drawings[_] = 
        
         hooked, original  (cheat.hooks) 
             (original) ==  
                (hooked, (original))
            
                (original[], original[], (original[]))
            
        
    


cheat.Library, cheat.Toggles, cheat.Options = ()()
cheat.ThemeManager = ()()
cheat.SaveManager = ()()
 ui = {
    window = cheat.Library:({
        Title=.(
            SWG_Title,
            SWG_Version,
            SWG_FullName
        ),
    Center=,AutoShow=,TabPadding=})
}

 _CFramenew = .new
 _Vector2new = .new
 _Vector3new = .new
 _IsDescendantOf = .IsDescendantOf
 _FindFirstChild = .FindFirstChild
 _FindFirstChildOfClass = .FindFirstChildOfClass
 _Raycast = .Raycast
 _IsKeyDown = UserInputService.IsKeyDown
 _WorldToViewportPoint = Camera.WorldToViewportPoint
 _Vector3zeromin = .zero.Min
 _Vector2zeromin = .zero.Min
 _Vector3zeromax = .zero.Max
 _Vector2zeromax = .zero.Max
 _IsA = .IsA
 tablecreate = .create
 mathfloor = .floor
 mathround = .round
 mathclamp = .clamp
  = 
  = 
 getupvalues = debug.getupvalues
 getupvalue = debug.getupvalue
 setupvalue = debug.setupvalue
 getconstants = debug.getconstants
 getconstant = debug.getconstant
 setconstant = debug.setconstant
 getstack = debug.getstack
 setstack = debug.setstack
 getinfo = debug.getinfo
  = 

ui.tabs = {
    combat = ui.window:(),
    visuals = ui.window:(),
    misc = ui.window:(),
    config = ui.window:(),
}
ui.box = {
    aimbot = ui.tabs.combat:(),
    esp = ui.tabs.visuals:(),
    cheatvis = ui.tabs.visuals:(),
    world = ui.tabs.visuals:(),
    move = ui.tabs.misc:(),
    atvfly = ui.tabs.misc:(),
    misc = ui.tabs.misc:(),
    themeconfig = ui.tabs.config:(),
}

 trident = {
    loaded = ,
    lastpos = ,
    middlepart = ,
    tcp = ,
    original_model = 
}

   (()
    trident.middlepart = .Const.Ignore.LocalCharacter.Middle
    trident.original_model = :().Shared.entities.Player.Model
    trident.tcp = LocalPlayer.TCP
)  .()   trident.middlepart  trident.original_model  trident.tcp

cheat.EspLibrary = {}; (()
     esp_table = {}
      = (:())
     rservice = (:())
     plrs = (:())
     lplr = plrs.LocalPlayer
     container = .(, :().RobloxGui)
    esp_table = {
        __loaded = ,
        main_settings = {
            textSize = ,
            textFont = .Fonts.Monospace,
            distancelimit = ,
            maxdistance = ,
            useteamcolor = ,
            teamcheck = ,
            sleepcheck = ,
            simplecalc = 
        },
        main_object_settings = {
            textSize = ,
            textFont = .Fonts.Monospace,
            distancelimit = ,
            maxdistance = ,
            useteamcolor = ,
            teamcheck = ,
            sleepcheck = ,
            allowed = {}
        },
        settings = {
            enemy = {
                enabled = ,
    
                box = ,
                box_fill = ,
                realname = ,
                dist = ,
                weapon = ,
                skeleton = ,
    
                box_outline = ,
                realname_outline = ,
                dist_outline = ,
                weapon_outline = ,
    
                box_color = { .(, , ),  },
                box_fill_color = { .(, , ),  },
                realname_color = { .(, , ),  },
                dist_color = { .(, , ),  },
                weapon_color = { .(, , ),  },
                skeleton_color = { .(, , ),  },
    
                box_outline_color = { .(),  },
                realname_outline_color = .(),
                dist_outline_color = .(),
                weapon_outline_color = .(),
    
                chams = ,
                chams_visible_only = ,
                chams_fill_color = { .(, , ),  },
                chamsoutline_color = { .(, , ),  }
            },
            object = {
                enabled = ,

                realname = ,
                realname_outline = ,

                realname_color = { .(, , ),  },
                realname_outline_color = .(),

                chams = ,
                chams_visible_only = ,
                chams_fill_color = { .(, , ),  },
                chamsoutline_color = { .(, , ),  }
            }
        }
    }
     loaded_plrs = {}
    
     camera = .CurrentCamera

    
     VERTICES = {
        (-, -, -),
        (-, , -),
        (-, , ),
        (-, -, ),
        (, -, -),
        (, , -),
        (, , ),
        (, -, )
    }
     skeleton_order = {
        [] = ,
        [] = ,
        [] = ,
    
        [] = ,
        [] = ,
        [] = ,
    
        [] = ,
        [] = ,
        [] = ,
    
        [] = ,
        [] = ,
        [] = ,
    
        [] = ,
        [] = 
    }
    
     esp = {}
    esp.create_obj = (, args)
         obj = .()
         i, v  args 
            obj[i] = v
        
         obj
    
      (name)
         name ==   name:()  name:()  name:()
    
      (parts)
         min, max
         i = , #parts 
             part = parts[i]
             cframe, size = part.CFrame, part.Size
    
            min = (min  cframe.Position, (cframe - size * ).Position)
            max = (max  cframe.Position, (cframe + size * ).Position)
        
    
         center = (min + max) * 
         front = (center.X, center.Y, max.Z)
         (center, front), max - min
    
      (world)
         screen, inBounds = (camera, world)
         (screen.X, screen.Y), inBounds, screen.Z
    
    
      (cframe, size)
         corners = (#VERTICES)
         i = , #VERTICES 
            corners[i] = ((cframe + size *  * VERTICES[i]).Position)
        
    
         min = (camera.ViewportSize, (corners))
         max = (.zero, (corners))
         {
            corners = corners,
            topLeft = ((min.X), (min.Y)),
            topRight = ((max.X), (min.Y)),
            bottomLeft = ((min.X), (max.Y)),
            bottomRight = ((max.X), (max.Y))
        }
    

      (head, hrp)
        
         head_position = (head.Position - .yAxis * )
         leg_position = (hrp.Position - .yAxis * )
         headx, heady = head_position.X, head_position.Y
         legx, legy = leg_position.X, leg_position.Y
         height = legy - heady;
         width = height / 
         {
            topLeft = (headx - width, heady),
            topRight = (headx - width, legy),
            bottomLeft = (headx + width, heady),
            bottomRight =(headx + width, legy)
        }
    

     enttiyidentification = {}
     i, v  :().Shared.entities:() 
         model = (v, )
         model  model.PrimaryPart 
            enttiyidentification[v.Name] = {
                CollisionGroup = model.PrimaryPart.CollisionGroup,
                Material = model.PrimaryPart.Material,
                Color = model.PrimaryPart.Color
            }
        
    
      (model)
         model.ClassName ~=    ,  
         (model, )  (model, ).MeshId ==  
             #model:() ==  
                 , model:()[]
            
                 _, part  model:() 
                     part.Color == .(, , ) 
                         , part
                     part.Color == .(, , ) 
                         , part
                    
                
            
        
          model.PrimaryPart   
         primpart = model.PrimaryPart
         name, entity  enttiyidentification 
             entity.Color == primpart.Color  entity.Material == primpart.Material  entity.CollisionGroup == primpart.CollisionGroup 
                 name, primpart
            
        
         , 
    

      (original)	
         copy = {}
         key, value  original 
            copy[key] = (value) ==   (value)  value
        
         copy
    

    
      (model)
         model  (model, )  (model, ) 
             settings = esp_table.settings.enemy
            loaded_plrs[model] = {
                obj = {
                    box_fill = esp.(, { Filled = , Visible =  }),
                    box_outline = esp.(, { Filled = , Thickness = , Visible = , ZIndex = -}),
                    box = esp.(, { Filled = , Thickness = , Visible =  }),
                    realname = esp.(, { Center = , Visible =  }),
                    dist = esp.(, { Center = , Visible =  }),
                    weapon = esp.(, { Center = , Visible =  }),
                },
                esp = {
                    current_gun = ,
                    corners = ,
                    head = ,
                    character = 
                },
                chams_object = .(, container),
            }
             required, _  , skeleton_order 
                loaded_plrs[model].obj[ .. required] = esp.(, { Visible =  })
            

             character = model
             head = (character, )
             lowertorso = (character, )


             plr = loaded_plrs[model]
             obj = plr.obj

             cham = plr.chams_object
             box = obj.box
             box_outline = obj.box_outline
             box_fill = obj.box_fill
             realname = obj.realname
             dist = obj.dist
             weapon = obj.weapon

             main_settings = (esp_table.main_settings)
             settings = (esp_table.settings.enemy)

             setvis_cache = 

             plr:()
                main_settings = (esp_table.main_settings)
                settings = (esp_table.settings.enemy)

                cham.DepthMode = settings.chams_visible_only  .HighlightDepthMode.Occluded   settings.chams_visible_only  .HighlightDepthMode.AlwaysOnTop 
                cham.FillColor = settings.chams_fill_color[]
                cham.FillTransparency = settings.chams_fill_color[]
                cham.OutlineColor = settings.chamsoutline_color[]
                cham.OutlineTransparency = settings.chamsoutline_color[]

                box.Transparency = settings.box_color[]
                box.Color = settings.box_color[]
                box_outline.Transparency = settings.box_outline_color[]
                box_outline.Color = settings.box_outline_color[]
                box_fill.Color = settings.box_fill_color[]
                box_fill.Transparency = settings.box_fill_color[]

                realname.Size = main_settings.textSize
                realname.Font = main_settings.textFont
                realname.Color = settings.realname_color[]
                realname.Outline = settings.realname_outline
                realname.OutlineColor = settings.realname_outline_color
                realname.Transparency = settings.realname_color[]

                dist.Size = main_settings.textSize
                dist.Font = main_settings.textFont
                dist.Color = settings.dist_color[]
                dist.Outline = settings.dist_outline
                dist.OutlineColor = settings.dist_outline_color
                dist.Transparency = settings.dist_color[]

                weapon.Size = main_settings.textSize
                weapon.Font = main_settings.textFont
                weapon.Color = settings.weapon_color[]
                weapon.Outline = settings.weapon_outline
                weapon.OutlineColor = settings.weapon_outline_color
                weapon.Transparency = settings.weapon_color[]

                cham.Enabled = setvis_cache
                box.Visible = setvis_cache
                box_outline.Visible = setvis_cache
                box_fill.Visible = setvis_cache
                realname.Visible = setvis_cache
                dist.Visible = setvis_cache
                weapon.Visible = setvis_cache

                 required, _  , skeleton_order 
                     skeletonobj = obj[ .. required]
                     (skeletonobj) 
                        skeletonobj.Color = settings.skeleton_color[]
                        skeletonobj.Transparency = settings.skeleton_color[]
                        skeletonobj.Visible = setvis_cache
                    
                
            

             plr:(bool)
                 setvis_cache ~= bool 
                    setvis_cache = bool
                      bool 
                         _, v  obj  v.Visible =  
                    
                        cham.Enabled = settings.chams
                        box.Visible = settings.box
                        box_outline.Visible = settings.box_outline
                        box_fill.Visible = settings.box_fill
                        realname.Visible = settings.realname
                        dist.Visible = settings.dist
                        weapon.Visible = settings.weapon
                         required, _  , skeleton_order 
                             skeletonobj = obj[ .. required]
                             (skeletonobj) 
                                skeletonobj.Visible = settings.skeleton
                            
                        
                    
                
            

     plr.connection = cheat.utility.((delta)
      (
        settings.enabled 
        head 
        character
    ) 
         plr:()
    
    
     distance = (camera.CFrame.p - head.Position).Magnitude
     distance >  
         plr:()
    
    
     _, onScreen = (head.Position)
      onScreen 
         plr:()
    

                 distance = (camera.CFrame.p - head.Position).Magnitude

                 corners  main_settings.simplecalc 
                    corners = (head, lowertorso)
                
                     cache = {}
                     children = character:()
                     i = , #children 
                         part = children[i]
                         (part, )  (part.Name) 
                            cache[#cache + ] = part
                        
                    
                    corners = ((cache))
                

                  corners 
                     plr:()
                

                plr:()

                cham.Adornee = character
                
                     pos = corners.topLeft
                     size = corners.bottomRight - corners.topLeft
                    box.Position = pos
                    box.Size = size
                    box_outline.Position = pos + .one
                    box_outline.Size = size - .one
                    box_fill.Position = pos
                    box_fill.Size = size
                

                
                    realname.Text = 
                    realname.Position = (corners.topLeft + corners.topRight) *  -
                        .yAxis * realname.TextBounds.Y - (, )
                

                
                     bottom = (corners.bottomLeft + corners.bottomRight) * 
                    dist.Text = ((distance)) .. 
                    dist.Position = bottom
                    weapon.Text = 
                    weapon.Position = bottom + (dist.Visible  .yAxis * dist.TextBounds.Y - (, )  .zero)
                

                 settings.skeleton 
                     _, part  , character:() 
                         skeletonobj = obj[ .. part.Name]
                         parent_part = skeleton_order[part.Name]  (character, skeleton_order[part.Name])
                         skeletonobj  parent_part 
                             part_position, _ = (camera, part.Position)
                             parent_part_position, _ = (
                                camera, parent_part.CFrame.p
                            )
                            skeletonobj.From = (part_position.X, part_position.Y)
                            skeletonobj.To = (parent_part_position.X, parent_part_position.Y)
                        
                    
                
            )

            plr:()
        
             espname, mainpart = (model)
              (espname  mainpart)   
            loaded_plrs[model] = {
                obj = {
                    name = esp.(, { Center = , Visible = , Text = espname }),
                }
            }
             plr = loaded_plrs[model]
             obj = plr.obj

             realname = obj.name

             main_settings = (esp_table.main_object_settings)
             settings = (esp_table.settings.object)
             allowedobjs = (main_settings.allowed)

             setvis_cache = 

             plr:()
                main_settings = (esp_table.main_object_settings)
                settings = (esp_table.settings.object)
                allowedobjs = (main_settings.allowed)
                realname.Size = main_settings.textSize
                realname.Font = main_settings.textFont
                realname.Color = settings.realname_color[]
                realname.Outline = settings.realname_outline
                realname.OutlineColor = settings.realname_outline_color
                realname.Transparency = settings.realname_color[]
            

             plr:(bool)
                 setvis_cache ~= bool 
                     _, v  obj  v.Visible = bool 
                    setvis_cache = bool
                
            

      plr.connection = cheat.utility.((delta)
     plr = loaded_plrs[model]
      (settings.enabled  mainpart  allowedobjs[espname]) 
         plr:()
    
    
     distance = (camera.CFrame.p - mainpart.Position).Magnitude
     distance >  
         plr:()
    
    
     position, onscreen = (mainpart.Position)
      onscreen 
         plr:()
    
                plr:()
                realname.Position = position
            )

            plr:()
        
    
      (model)
         plr_object = loaded_plrs[model]
          plr_object   
        plr_object.connection:()
         i, v  plr_object.obj 
            v:()
        
         plr_object.chams_object 
            plr_object.chams_object:()
        
        loaded_plrs[model] = 
    
    
     esp_table.()
        ( esp_table.__loaded, );
    
         i, v  , :() 
           (v)
        
    
        esp_table.playerAdded = .ChildAdded:(create_esp);
        esp_table.playerRemoving = .ChildRemoved:(destroy_esp);
        esp_table.__loaded = ;
    
    
     esp_table.()
        (esp_table.__loaded, );
    
         i, v  , :() 
            (v)
        
    
        esp_table.playerAdded:();
        esp_table.playerRemoving:();
        esp_table.__loaded = ;
    
    
     esp_table.()
         _, v  loaded_plrs 
            .(() v:() )
        
    

    cheat.EspLibrary = esp_table
)();

 aimbot = {
    enabled = ,
    camera = ,
    silent = , 
    sleep_check = ,
    team_check = ,
    part = ,
    manipulation = ,
    manipulation_range = ,
    fov = ,
    fov_show = ,
    fov_color = .(, , ),
    fov_outline = ,
    fov_outline_color = .(, , ),
    fov_size = ,
    indicator = ,
    indicator_text = ,
    jumpshoot = ,
    noslowdown = ,
    nospread = ,
    forcehead = ,
    invis = ,
    mathhuge = ,
    hitboxes = ,
    hbbypass = ,
    instant = ,
    fly = ,
    silentwalk = 
}


     validcharacters = {}
     hbc, original_size, hbsize = , trident.original_model.Head.Size, (, , )
     dynamic, alwayshead = , 
     hitboxheadsizex, hitboxheadsizey, hitboxheadtransparency, cancollide = , , , 
      (obj)
          obj   
          obj:()   obj:()   
        validcharacters[obj] = obj
    

      (obj)
          validcharacters[obj]   
        validcharacters[obj] = 
    

     i, v  , :()  (v) 
    .ChildAdded:(addtovc);
    .ChildRemoved:(removefromvc);

     hbb = ui.box.aimbot:()
    hbb:(, {
        Text = ,
        Default = ,
        Callback = (value)
            aimbot.hitboxes = value
             hbc  hbc:() 
             value 
                hbc = cheat.utility.(()
                     trans = hitboxheadtransparency
                     i, v  validcharacters 
                         primpart = v  (v, )
                         primpart 
                            primpart.Size = hbsize
                            primpart.Transparency = trans
                            primpart.CanCollide = cancollide
                        
                    
                )
            
                 hbc  hbc:() 
                 i, v  validcharacters 
                     primpart = v  (v, )
                     primpart 
                        primpart.Size = original_size
                        primpart.Transparency = 
                        primpart.CanCollide = 
                    
                
            
        
    })
    hbb:(,{Text = ,Default = ,Callback = (v)
        cancollide = v
    })
    hbb:(, { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((State)
        hitboxheadtransparency = State
    )
    hbb:(, { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((State)
        hitboxheadsizex = State
        hbsize = (hitboxheadsizex, hitboxheadsizey, hitboxheadsizex)
    )
    hbb:(, { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((State)
        hitboxheadsizey = State
        hbsize = (hitboxheadsizex, hitboxheadsizey, hitboxheadsizex)
    )


     espb = ui.box.esp:()
     es = cheat.EspLibrary.settings.enemy
    espb:(, {Values = { , , ,  },Default = ,Multi = ,Text = ,Tooltip = ,Callback = (Value)
        cheat.EspLibrary.main_settings.textFont = .Fonts[Value]
        cheat.EspLibrary.()
    })
    espb:(, { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((State)
        cheat.EspLibrary.main_settings.textSize = State
        cheat.EspLibrary.()
    )
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            cheat.EspLibrary.main_settings.simplecalc = first
            cheat.EspLibrary.()
        
    })
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.enabled = first
            cheat.EspLibrary.()
        
    })
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            cheat.EspLibrary.main_settings.teamcheck = first
            cheat.EspLibrary.()
        
    })
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            cheat.EspLibrary.main_settings.sleepcheck = first
            cheat.EspLibrary.()
        
    })
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.box = first
            cheat.EspLibrary.()
        
    }):(, {
        Default = .(, , ),
        Title = ,
        Transparency = ,
        Callback = (Value)
            es.box_color[] = Value
            cheat.EspLibrary.()
        
    })
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.box_fill = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(, , ),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.box_fill_color[] = Value
                cheat.EspLibrary.()
            
        })
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.box_outline = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.box_outline_color[] = Value
                cheat.EspLibrary.()
            
        })
    
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.box_color[] = -State
        cheat.EspLibrary.()
    )
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.box_outline_color[] = State
        cheat.EspLibrary.()
    )
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.box_fill_color[] = -State
        cheat.EspLibrary.()
    )
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.realname = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(, , ),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.realname_color[] = Value
                cheat.EspLibrary.()
            
        })
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.realname_color[] = -State
        cheat.EspLibrary.()
    )
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.realname_outline = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.realname_outline_color = Value
                cheat.EspLibrary.()
            
        })

    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.dist = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(, , ),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.dist_color[] = Value
                cheat.EspLibrary.()
            
        })
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.dist_color[] = -State
        cheat.EspLibrary.()
    )
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.dist_outline = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.dist_outline_color = Value
                cheat.EspLibrary.()
            
        })
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.weapon = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(, , ),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.weapon_color[] = Value
                cheat.EspLibrary.()
            
        })
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.weapon_color[] = -State
        cheat.EspLibrary.()
    )
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.weapon_outline = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.weapon_outline_color = Value
                cheat.EspLibrary.()
            
        })
    
    espb:(, {Text = ,Default = ,Callback = (first)
        es.skeleton = first
        cheat.EspLibrary.()
    }):(, {Default = .(, , ),Title = ,Transparency = ,Callback = (Value)
        es.skeleton_color[] = Value
        cheat.EspLibrary.()
    })
    espb:(, { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((State)
        es.skeleton_color[] = -State
        cheat.EspLibrary.()
    )
    
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.chams = first
            cheat.EspLibrary.()
        
    })
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.chams_visible_only = first
            cheat.EspLibrary.()
        
    })
    
    espb:():(,
        {
            Default = .(),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.chams_fill_color[] = Value
                cheat.EspLibrary.()
            
        })
    espb:():(,
        {
            Default = .(),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.chamsoutline_color[] = Value
                cheat.EspLibrary.()
            
        })
    
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.chams_fill_color[] = State
        cheat.EspLibrary.()
    )
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.chamsoutline_color[] = State
        cheat.EspLibrary.()
    )
    


     espb = ui.box.esp:()
     es = cheat.EspLibrary.settings.object
    espb:(, {Values = { , , ,  },Default = ,Multi = ,Text = ,Tooltip = ,Callback = (Value)
        cheat.EspLibrary.main_object_settings.textFont = .Fonts[Value]
        cheat.EspLibrary.()
    })
    espb:(, { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((State)
        cheat.EspLibrary.main_object_settings.textSize = State
        cheat.EspLibrary.()
    )
    espb:(, {Values = {
        , , , , ,
        , , , ,
        , , 
    },Default = ,Multi = ,Text = ,Tooltip = ,Callback = (Value)
        cheat.EspLibrary.main_object_settings.allowed = Value
        cheat.EspLibrary.()
    })
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.enabled = first
            cheat.EspLibrary.()
        
    })
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.realname = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(, , ),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.realname_color[] = Value
                cheat.EspLibrary.()
            
        })
    espb:(,
        { Text = , Default = , Min = , Max = , Rounding = , Compact =  }):((
        State)
        es.realname_color[] = -State
        cheat.EspLibrary.()
    )
    espb:(, {
        Text = ,
        Default = ,
        Callback = (first)
            es.realname_outline = first
            cheat.EspLibrary.()
        
    }):(,
        {
            Default = .(),
            Title = ,
            Transparency = ,
            Callback = (Value)
                es.realname_outline_color = Value
                cheat.EspLibrary.()
            
        })

 canuseimages = (()
    cheat.utility.(, {}):()
)  (()
     a = cheat.utility.(, {})
    (a, ).Image = 
    a:()
)

     enabled, dynamic = , ;
     color1, color2 = .(,,), .();
     watermarktab = ui.box.cheatvis:()
     watermarktoggle = watermarktab:(, {Text = ,Default = ,Callback = (first)
        enabled = first
    })
    watermarktoggle:(,{Default = .(),Title = canuseimages    ,Transparency = ,Callback = (Value)
        color1 = Value
          canuseimages  color2 = Value 
    })
     canuseimages  watermarktoggle:(,{Default = .(),Title = ,Transparency = ,Callback = (Value)
        color2 = Value
    }); 
    watermarktab:(, {Text = ,Default = ,Callback = (first)
        dynamic = first
    })
     leftcolor, rightcolor, watertext = 
    .(, , ), 
    .(, , ),
    ;
     waterpos = .(, );
     text = cheat.utility.(, {
        ZIndex = ,
        Visible = ,
        Transparency = ,
        Position = waterpos + .(, ),
        Color = .(, , ),
        Outline = ,
        OutlineColor = .(),
        Font = ,
        Size = ,
        Text = watertext
    });
     gradr, gradl = cheat.utility.(canuseimages    , {
        ZIndex = ,
        Visible = ,
        Transparency = ,
        Position = waterpos,
        Size = .(text.TextBounds.X + , text.TextBounds.Y + ),
        Color = rightcolor
    }), cheat.utility.(canuseimages    , {
        ZIndex = ,
        Visible = ,
        Transparency = ,
        Position = waterpos,
        Size = .(text.TextBounds.X + , text.TextBounds.Y + ),
        Color = leftcolor
    });
     gradbackground = cheat.utility.(, {
        ZIndex = ,
        Visible = ,
        Transparency = ,
        Position = waterpos,
        Size = .(text.TextBounds.X + , text.TextBounds.Y + ),
        Color = leftcolor:(rightcolor, ),
        Filled = 
    });
     textbackground = cheat.utility.(, {
        ZIndex = ,
        Visible = ,
        Transparency = ,
        Position = waterpos + .(, ),
        Size = .(text.TextBounds.X + , text.TextBounds.Y + ),
        Color = .(,,),
        Filled = ,
        Thickness = ,
    });
     canuseimages  (gradr, ).Image = (); 
     canuseimages  (gradl, ).Image = (); 
     hue1, hue2, fpstimer, fps, finalfps = , , (), , ;
    cheat.utility.(((delta)
        fps = fps + ;
         fpstimer +  <= () 
            fpstimer = ();
            finalfps = fps;
            fps = ;
        ;
        hue1, hue2 = () % , () %  + ;
         hue1 >=   hue1 =    hue2 >=   hue2 =  
        rightcolor = dynamic  .(hue1, , )  color2;
        leftcolor = dynamic  .(hue2, , )  color1;
        watertext = ():(SWG_Version, SWG_ShortName, .(), (finalfps));
        gradr.Color = rightcolor;
        gradl.Color = leftcolor;
        gradbackground.Color = gradr.Color:(gradl.Color, );
        textbackground.Size = .(text.TextBounds.X + , text.TextBounds.Y + );
        textbackground.Position = waterpos + .(, );
        gradbackground.Size = .(text.TextBounds.X + , text.TextBounds.Y + );
        gradbackground.Position = waterpos;
        gradl.Position = waterpos;
        gradl.Size = .(text.TextBounds.X + , text.TextBounds.Y + );
        gradr.Position = waterpos;
        gradr.Size = .(text.TextBounds.X + , text.TextBounds.Y + );
        text.Position = waterpos + .(, );
        text.Text = watertext;

        text.Visible = enabled;
        gradl.Visible = enabled;
        gradr.Visible = enabled;
        gradbackground.Visible = enabled;
        textbackground.Visible = enabled;
    ))



     WorldTab = ui.box.world:()
     time = 
     timechanger = 
    WorldTab:(, {Text = ,Default = ,Callback = (first)
        timechanger = first
    })
    WorldTab:(,{ Text = , Default = (Lighting.ClockTime), Min = , Max = , Rounding = , Compact =  }):((State)
        time = State
    )
    cheat.utility.(()
         timechanger 
            Lighting.ClockTime = time
        
    )



     cursor = {
        Enabled = ,
        CustomPos = ,
        Position = (, ),
        Speed = ,
        Radius = ,
        Color = .(, , ),
        Thickness = ,
        Outline = ,
        Resize = ,
        Dot = ,
        Gap = ,
        TheGap = ,
        Font = .Fonts.Monospace,
        Text = {
            Logo = ,
            LogoColor = .(, , ),
            Name = ,
            NameColor = .(, , ),
            LogoFadingOffset = ,
        }
    }
     CrosshairTab = ui.box.world:()
    cursor.rainbow = 
    cursor.sussy = 
    CrosshairTab:(, {Values = { , , ,  },Default = ,Multi = ,Text = ,Tooltip = ,Callback = (Value)
        cursor.Font = .Fonts[Value]
    })
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.Enabled = first
    }):(, {Default = .(, , ),Title = ,Transparency = ,Callback = (Value)
        cursor.Color = Value
    })
    CrosshairTab:(, {Text = ,Default = ,Min = ,Max = ,Rounding = ,Compact = }):((State)
        cursor.Speed = State / 
    )
    CrosshairTab:(, {Text = ,Default = ,Min = ,Max = ,Rounding = ,Compact = ,}):((State)
        cursor.Radius = State
    )
    CrosshairTab:(, {Text = ,Default = ,Min = ,Max = ,Rounding = ,Compact = ,}):((State)
        cursor.Thickness = State
    )
    CrosshairTab:(, {Text = ,Default = ,Min = ,Max = ,Rounding = ,Compact = ,}):((State)
        cursor.Gap = State
    )
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.TheGap = first
    })
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.Outline = first
    })
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.Resize = first
    })
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.Dot = first
    })
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.sussy = first
        })
        CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.rainbow = first
    })
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.Text.Logo = first
    }):(, {Default = .(, , ),Title = ,Transparency = ,Callback = (Value)
        cursor.Text.LogoColor = Value
    })
    CrosshairTab:(, {Text = ,Default = ,Callback = (first)
        cursor.Text.Name = first
    }):(, {Default = .(, , ),Title = ,Transparency = ,Callback = (Value)
        cursor.Text.NameColor = Value
    })
    CrosshairTab:(, {Text = ,Default = ,Min = ,Max = ,Rounding = ,Compact = }):((State)
        cursor.Text.LogoFadingOffset = State
    )

    
     lines = {}
    
     outline = cheat.utility.(, {
        Visible = ,
        Size = (, ),
        Color = .(, , ),
        Filled = ,
        ZIndex = ,
        Transparency = 
    })
    
     dot = cheat.utility.(, {
        Visible = ,
        Size = (, ),
        Color = cursor.Color,
        Filled = ,
        ZIndex = ,
        Transparency = 
    })
    
     logotext = cheat.utility.(, {
        Visible = ,
        Font = cursor.Font,
        Size = ,
        Color = .(, , ),
        ZIndex = ,
        Transparency = ,
        Text = ,
        Center = ,
        Outline = ,
    })
     i = ,  
         line_outline = cheat.utility.(, {
            Visible = ,
            From = (, ),
            To = (, ),
            Color = .(, , ),
            Thickness = cursor.Thickness + ,
            ZIndex = ,
            Transparency = 
        })
         line = cheat.utility.(, {
            Visible = ,
            From = (, ),
            To = (, ),
            Color = cursor.Color,
            Thickness = cursor.Thickness,
            ZIndex = ,
            Transparency = 
        })
         naziline = cheat.utility.(, {
            Visible = ,
            From = (, ),
            To = (, ),
            Color = cursor.Color,
            Thickness = cursor.Thickness,
            ZIndex = ,
            Transparency = 
        })
        lines[i] = { line, line_outline, naziline }
    
     angle = 
     transp = 
     reverse = 
      (value)
         reverse ~= value 
            reverse = value
        
    
    
     pos, rainbow, rotationdegree, color = .zero, , , .()
     math_cos, math_atan, math_pi, math_sin = .cos, .atan, .pi, .sin
      (x)  x * math_pi /  
      (x)  x *  / math_pi 
    cheat.utility.(((delta)
         cursor.Enabled 
            rainbow = rainbow + (delta * )
             rainbow >   rainbow =  
            color = .fromHSV(rainbow, 1, 1)
            if cursor.CustomPos then pos = cursor.Position else pos = _Vector2new(
                Mouse.X,
                Mouse.Y + GuiInset.Y) end
            if cursor.rainbow then color = Color3.fromHSV(rainbow, 1, 1) else color = cursor.Color end
            if transp <= 1.5 + cursor.Text.LogoFadingOffset and not reverse then
                transp = transp + (((cursor.Speed == 0 and 1 or cursor.Speed) * 10) * delta)
                if transp >= 1.5 + cursor.Text.LogoFadingOffset then setreverse(true) end
            elseif reverse then
                transp = transp - (((cursor.Speed == 0 and 1 or cursor.Speed) * 10) * delta)
                if transp <= 0 - cursor.Text.LogoFadingOffset then setreverse(false) end
            end
            logotext.Position = _Vector2new(pos.X, (pos + _Vector2new(0, cursor.Radius + 5)).Y)
            logotext.Transparency = transp
            logotext.Visible = cursor.Text.Logo
            logotext.Color = cursor.Text.LogoColor
            logotext.Font = cursor.Font

            if cursor.sussy then
                local frametime = delta
                local a = cursor.Radius - 10
                local gamma = math_atan(a / a)

                if rotationdegree >= 90 then rotationdegree = 0 end

                for i = 1, 4 do
                    local p_0 = (a * math_sin(DEG2RAD(rotationdegree + (i * 90))))
                    local p_1 = (a * math_cos(DEG2RAD(rotationdegree + (i * 90))))
                    local p_2 = ((a / math_cos(gamma)) * math_sin(DEG2RAD(rotationdegree + (i * 90) + RAD2DEG(gamma))))
                    local p_3 = ((a / math_cos(gamma)) * math_cos(DEG2RAD(rotationdegree + (i * 90) + RAD2DEG(gamma))))


                    lines[i][1].From = _Vector2new(pos.X, pos.Y)
                    lines[i][1].To = _Vector2new(pos.X + p_0, pos.Y - p_1)
                    lines[i][1].Color = color
                    lines[i][1].Thickness = cursor.Thickness
                    lines[i][1].Visible = true
                    lines[i][3].From = _Vector2new(pos.X + p_0, pos.Y - p_1)
                    lines[i][3].To = _Vector2new(pos.X + p_2, pos.Y - p_3)
                    lines[i][3].Color = color
                    lines[i][3].Thickness = cursor.Thickness
                    lines[i][3].Visible = true
                end
                rotationdegree = rotationdegree + ((cursor.Speed * frametime) * 1000)
            else
                angle = (cursor.Speed == 0 and 0 or angle + ((cursor.Speed * 10) * delta))

                if angle >= 90 then
                    angle = 0
                end

                --
                dot.Visible = cursor.Dot
                dot.Color = color
                dot.Position = _Vector2new(pos.X - 1, pos.Y - 1)
                --
                outline.Visible = cursor.Outline and cursor.Dot
                outline.Position = _Vector2new(pos.X - 2, pos.Y - 2)
                --

                --
                for index, line in pairs(lines) do
                    index = index
                    local x, y = {}, {}
                    local x1, y1 = {}, {}
                    if cursor.Resize then
                        x = { pos.X +
                        (math.cos(angle + (index * (math.pi / 2))) * (cursor.Radius + ((cursor.Radius * math.sin(angle)) / 9))),
                            pos.X +
                            (math.cos(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20) - (cursor.TheGap and (((cursor.Radius - 20) * math.cos(angle)) / 4) or (((cursor.Radius - 20) * math.cos(angle)) - 4)))) }
                        y = { pos.Y +
                        (math.sin(angle + (index * (math.pi / 2))) * (cursor.Radius + ((cursor.Radius * math.sin(angle)) / 9))),
                            pos.Y +
                            (math.sin(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20) - (cursor.TheGap and (((cursor.Radius - 20) * math.cos(angle)) / 4) or (((cursor.Radius - 20) * math.cos(angle)) - 4)))) }
                        x1 = { pos.X + (math.cos(angle + (index * (math.pi / 2))) * (cursor.Radius + 1)), pos
                        .X +
                        (math.cos(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20 + 1) - (cursor.TheGap and ((cursor.Radius - 20 + 1) / cursor.Gap) or ((cursor.Radius - 20 + 1) - cursor.Gap)))) }
                        y1 = { pos.Y + (math.sin(angle + (index * (math.pi / 2))) * (cursor.Radius + 1)), pos
                        .Y +
                        (math.sin(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20 + 1) - (cursor.TheGap and ((cursor.Radius - 20 + 1) / cursor.Gap) or ((cursor.Radius - 20 + 1) - cursor.Gap)))) }
                    else
                        x = { pos.X + (math.cos(angle + (index * (math.pi / 2))) * (cursor.Radius)), pos.X +
                        (math.cos(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20) - (cursor.TheGap and ((cursor.Radius - 20) / cursor.Gap) or ((cursor.Radius - 20) - cursor.Gap)))) }
                        y = { pos.Y + (math.sin(angle + (index * (math.pi / 2))) * (cursor.Radius)), pos.Y +
                        (math.sin(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20) - (cursor.TheGap and ((cursor.Radius - 20) / cursor.Gap) or ((cursor.Radius - 20) - cursor.Gap)))) }
                        x1 = { pos.X + (math.cos(angle + (index * (math.pi / 2))) * (cursor.Radius + 1)), pos
                        .X +
                        (math.cos(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20 + 1) - (cursor.TheGap and ((cursor.Radius - 20 + 1) / cursor.Gap) or ((cursor.Radius - 20 + 1) - cursor.Gap)))) }
                        y1 = { pos.Y + (math.sin(angle + (index * (math.pi / 2))) * (cursor.Radius + 1)), pos
                        .Y +
                        (math.sin(angle + (index * (math.pi / 2))) * ((cursor.Radius - 20 + 1) - (cursor.TheGap and ((cursor.Radius - 20 + 1) / cursor.Gap) or ((cursor.Radius - 20 + 1) - cursor.Gap)))) }
                    end
                    --
                    line[1].Visible = true
                    line[1].Color = color
                    line[1].From = _Vector2new(x[2], y[2])
                    line[1].To = _Vector2new(x[1], y[1])
                    line[1].Thickness = cursor.Thickness
                    --
                    line[2].Visible = cursor.Outline
                    line[2].From = _Vector2new(x1[2], y1[2])
                    line[2].To = _Vector2new(x1[1], y1[1])
                    line[2].Thickness = cursor.Thickness + 2.5

                    line[3].Visible = false
                end
            end
        else
            dot.Visible = false
            outline.Visible = false
            logotext.Visible = false
            --
            for index, line in pairs(lines) do
                line[1].Visible = false
                line[2].Visible = false
                line[3].Visible = false
            end
        end
    end))
end

do
    local mvb = ui.box.move:AddTab('speedhack')
    local bhop_enabled, speed = false, 55
    local forcesprint = false
    mvb:AddToggle('speedhack_forcesprint', {Text = 'forcesprint',Default = false,Callback = function(first)
        forcesprint = first
    end})
    mvb:AddToggle('speedhack_enabled', {Text = 'speedhack enabled',Default = false,Callback = function(first)
        bhop_enabled = first
    end})
    mvb:AddSlider('speedhack_speed',{ Text = 'speed', Default = 55, Min = 55, Max = 70, Rounding = 0, Suffix = "sps", Compact = false }):OnChanged(function(State)
        speed = State
    end)
    local niga, wtf = speed, 0
    local middle = trident.middlepart
    cheat.utility.new_renderstepped(LPH_JIT_MAX(function(delta)
        if bhop_enabled and middle and _IsKeyDown(UserInputService, Enum.KeyCode.C) and _IsKeyDown(UserInputService, Enum.KeyCode.LeftShift) then
            local cameralook = Camera.CFrame.LookVector
            cameralook = _Vector3new(cameralook.X, 0, cameralook.Z)
            local direction = Vector3.zero
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.W) and direction + cameralook or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.S) and direction - cameralook or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.D) and direction + _Vector3new(- cameralook.Z, 0, cameralook.X) or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.A) and direction + _Vector3new(cameralook.Z, 0, - cameralook.X) or direction;
            if not (direction == Vector3.zero) then
                direction = direction.Unit
            end
            niga = math.clamp(niga-delta*20, 17, speed)
            if wtf == 0 then
                middle.CFrame = middle.CFrame + _Vector3new(0, 6.5, 0)
            end
            middle.AssemblyLinearVelocity = _Vector3new(
                direction.X * niga,
                wtf < 0.85 and 0 or -7,
                direction.Z * niga
            )
            wtf = wtf + delta
        else
            if forcesprint and middle then
                local cameralook = Camera.CFrame.LookVector
                cameralook = _Vector3new(cameralook.X, 0, cameralook.Z)
                local direction = Vector3.zero
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.W) and direction + cameralook or direction;
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.S) and direction - cameralook or direction;
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.D) and direction + _Vector3new(- cameralook.Z, 0, cameralook.X) or direction;
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.A) and direction + _Vector3new(cameralook.Z, 0, - cameralook.X) or direction;
                if not (direction == Vector3.zero) then
                    direction = direction.Unit
                end
                middle.AssemblyLinearVelocity = _Vector3new(
                    direction.X * 18,
                    middle.AssemblyLinearVelocity.Y,
                    direction.Z * 18
                )
            end
            niga = speed
            wtf = 0
        end
    end))
end

do
    local mvb = ui.box.move:AddTab('exploits')
    local enabled, speed = false, 55
    local fakecrouch_timer = tick()
    mvb:AddToggle('fakecrouch', {Text = 'fake crouch',Default = false,Callback = function(first)
        aimbot.silentwalk = first
    end}):AddKeyPicker('silentwalk_bind', {Default = 'None',SyncToggleState = true,Mode = 'Toggle',Text = 'fake crouch',NoUI = false})
    local freecamoffset = Vector3.zero
    local middle = workspace.Const.Ignore.LocalCharacter.Middle
    local bottom = workspace.Const.Ignore.LocalCharacter.Bottom
    local top = workspace.Const.Ignore.LocalCharacter.Top
    local originalprismcframe = top.Prism1.CFrame
    local pos = middle.CFrame
    mvb:AddToggle('longneck', {Text = 'long neck',Default = false,Callback = function(first)
        top.Prism1.CFrame = first and originalprismcframe - Vector3.yAxis * 5 or originalprismcframe
    end}):AddKeyPicker('longneck_bind', {Default = 'None',SyncToggleState = true,Mode = 'Toggle',Text = 'long neck',NoUI = false})
    mvb:AddToggle('freecam_enabled', {Text = 'freecam enabled',Default = false,Callback = function(first)
        enabled = first
        middle.CanCollide = not first
        bottom.CanCollide = not first
        top.CanCollide = not first
    end}):AddKeyPicker('freecam_bind', {Default = 'None',SyncToggleState = true,Mode = 'Toggle',Text = 'freecam',NoUI = false})
    mvb:AddSlider('freecam_speed',{ Text = 'speed', Default = 10, Min = 1, Max = 300, Rounding = 0, Suffix = "sps", Compact = false }):OnChanged(function(State)
        speed = State
    end)
    cheat.utility.new_heartbeat(LPH_JIT_MAX(function(delta)
        if tick() - fakecrouch_timer >= 0.15 then
            trident.tcp:FireServer(2, true)
            fakecrouch_timer = tick()
        end
        if enabled and middle then
            middle.CFrame = pos
            RunService.RenderStepped:Wait()
            if middle then
                local cameralook = Camera.CFrame.LookVector
                local direction = Vector3.zero
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.W) and direction + cameralook or direction;
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.S) and direction - cameralook or direction;
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.D) and direction + _Vector3new(- cameralook.Z, 0, cameralook.X) or direction;
                direction = _IsKeyDown(UserInputService, Enum.KeyCode.A) and direction + _Vector3new(cameralook.Z, 0, - cameralook.X) or direction;
                if not direction == Vector3.zero then
                    direction = direction.Unit
                end
                freecamoffset = freecamoffset + (direction * delta * speed)
                middle.CFrame = pos + freecamoffset
                middle.AssemblyLinearVelocity = Vector3.zero
            end
        elseif middle then
            freecamoffset = Vector3.zero
            pos = middle.CFrame
        end
    end))
end

do
    local mvb = ui.box.atvfly:AddTab('atv fly')
    local carfly_enabled, speed, accel, upspeed = false, 55, 100, 15
    mvb:AddToggle('carfly_enabled', {Text = 'car fly enabled',Default = false,Callback = function(first)
        carfly_enabled = first
    end}):AddKeyPicker('carfly_bind', {Default = 'None',SyncToggleState = true,Mode = 'Toggle',Text = 'car fly',NoUI = false})
    mvb:AddSlider('carfly_speed',{ Text = 'speed', Default = 150, Min = 50, Max = 300, Rounding = 0, Suffix = "sps", Compact = false }):OnChanged(function(State)
        speed = State
    end)
    mvb:AddSlider('carfly_upspeed',{ Text = 'up speed', Default = 15, Min = 5, Max = 100, Rounding = 0, Suffix = "sps", Compact = false }):OnChanged(function(State)
        upspeed = State
    end)
    mvb:AddSlider('carfly_accel',{ Text = 'acceleration', Default = 100, Min = 10, Max = 300, Rounding = 0, Suffix = "sps", Compact = false }):OnChanged(function(State)
        accel = State
    end)
    mvb:AddLabel("hold V to go up")
    mvb:AddLabel("hold B to go down")
    local car, dist = nil, 50
    local findcar = function()
        car, dist = nil, 50
        for i,v in pairs(workspace:GetChildren()) do
            if v:FindFirstChild("Seat") and v:FindFirstChild("Frame") then
                if (v.Frame.Position - trident.middlepart.Position).Magnitude < dist then
                    car = v
                    dist = (v.Frame.Position - trident.middlepart.Position).Magnitude
                end
            end
        end
    end
    findcar()
    local buildup = 0
    local lastdir = _Vector3new(1,0,0)
    cheat.utility.new_renderstepped(LPH_JIT_MAX(function(delta)
        if carfly_enabled and car and car:FindFirstChild("Frame") and (car.Frame.CFrame.p - Camera.CFrame.p).Magnitude <= 50 then
            local cameralook = Camera.CFrame.LookVector
            cameralook = _Vector3new(cameralook.X, 0, cameralook.Z)
            local direction = Vector3.zero
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.W) and direction + cameralook or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.S) and direction - cameralook or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.D) and direction + _Vector3new(- cameralook.Z, 0, cameralook.X) or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.A) and direction + _Vector3new(cameralook.Z, 0, - cameralook.X) or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.V) and direction + Vector3.yAxis or direction;
            direction = _IsKeyDown(UserInputService, Enum.KeyCode.B) and direction - Vector3.yAxis or direction;
            if direction ~= Vector3.zero then
                direction = direction.Unit
                if direction ~= Vector3.yAxis and -direction ~= Vector3.yAxis then
                    buildup = math.clamp(buildup + delta * accel, 0, speed)
                    lastdir = direction
                end
            else
                direction = lastdir
                buildup = math.clamp(buildup - delta * 150, 0, speed)
            end
            for i,v in pairs(car:GetChildren()) do
                v.AssemblyLinearVelocity = _Vector3new(direction.X * buildup, direction.Y * upspeed, direction.Z * buildup)
                --v.AssemblyLinearVelocity = direction * SPEED + _Vector3new(0, 0.05, 0)
                --v.CFrame = _CFramenew(v.CFrame.Position) * CFrame.Angles(0, y+(math.pi/2), 0)
            end
        elseif not car or car and car:FindFirstChild("Frame") and (car.Frame.CFrame.p - Camera.CFrame.p).Magnitude > 50 then
            findcar()
            buildup = 0
        else
            buildup = 0
        end
    end))
end
loadswimhubfile("chat_spam.lua")(cheat.Library, ui.box.misc:AddTab("chat spam"), function(word)
    trident.tcp:FireServer(23, word, "Global")
end, 25, 100)

ui.box.themeconfig:AddToggle('keybindshoww', {Text = 'show keybinds',Default = false,Callback = function(first)cheat.Library.KeybindFrame.Visible = first end})
cheat.ThemeManager:SetOptionsTEMP(cheat.Options, cheat.Toggles)
cheat.SaveManager:SetOptionsTEMP(cheat.Options, cheat.Toggles)
cheat.ThemeManager:SetLibrary(cheat.Library)
cheat.SaveManager:SetLibrary(cheat.Library)
cheat.SaveManager:IgnoreThemeSettings()
cheat.ThemeManager:SetFolder('swimhub')
cheat.SaveManager:SetFolder('swimhub')
cheat.SaveManager:BuildConfigSection(ui.tabs.config)
cheat.ThemeManager:ApplyToGroupbox(ui.box.themeconfig)

cheat.EspLibrary.load()