trash skidded script open src

 Rayfield = (:())()

 Window = Rayfield:({
   Name = ,
   Icon = , 
   LoadingTitle = ,
   LoadingSubtitle = ,
   ShowText = , 
   Theme = , 

   ToggleUIKeybind = , 

   DisableRayfieldPrompts = ,
   DisableBuildWarnings = , 

   ConfigurationSaving = {
      Enabled = ,
      FolderName = ud, 
      FileName = 
   },

   Discord = {
      Enabled = , 
      Invite = , 
      RememberJoins =  
   },

   KeySystem = , 
   KeySettings = {
      Title = ,
      Subtitle = ,
      Note = , 
      FileName = , 
      SaveKey = , 
      GrabKeyFromSite = , 
      Key = {} 
   }
})


 MiscTab = Window:(, )
 LocalTab = Window:(, )
 EspTab = Window:(, )
 DummyTab = Window:(, )
 TechTab = Window:(, )
 AutoTab = Window:(, )
 ServerTab = Window:(, )
 AutoBlockTab = Window:(, )
 AdminTab = Window:(, )


MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

MiscTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})


 player = .Players.LocalPlayer
 char = player.Character  player.CharacterAdded:()
 humanoid = char:()

 auraOn = 
 auraHighlight = 
 auraParticles = {}
 auraColorTime = 
 auraLoop = 

  ()
   
    anim = .()
   anim.AnimationId = 
    track = humanoid:(anim)
   track:()

   
   auraHighlight = .()
   auraHighlight.Adornee = char
   auraHighlight.FillTransparency = 
   auraHighlight.OutlineTransparency = 
   auraHighlight.OutlineColor = .(, , )
   auraHighlight.Parent = char

   
    _, partName  ({, , }) 
       part = char:(partName)
       part 
          att = .(, part)
          particle = .(, att)
         particle.Name = 
         particle.Rate = 
         particle.Lifetime = NumberRange.(, )
         particle.Speed = NumberRange.(, )
         particle.Size = NumberSequence.({ NumberSequenceKeypoint.(, ), NumberSequenceKeypoint.(, ) })
         particle.Transparency = NumberSequence.({ NumberSequenceKeypoint.(, ), NumberSequenceKeypoint.(, ) })
         particle.Color = ColorSequence.(.(, , ))
         particle.Rotation = NumberRange.(, )
         particle.RotSpeed = NumberRange.(-, )
         particle.SpreadAngle = .(, )
         particle.ZOffset = -
         .(auraParticles, particle)
      
   

   
   auraLoop = :().RenderStepped:((dt)
       auraOn  auraHighlight 
         auraColorTime += dt * 
          r = .(auraColorTime) *  + 
          g = .(auraColorTime + ) *  + 
          b = .(auraColorTime + ) *  + 
         auraHighlight.OutlineColor = .(r, g, b)
      
   )


  ()
    auraHighlight 
      auraHighlight:()
      auraHighlight = 
   
    _, p  (auraParticles) 
       p  p:() 
   
   auraParticles = {}

    auraLoop 
      auraLoop:()
      auraLoop = 
   


LocalTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      auraOn = Value
       Value 
         ()
      
         ()
      
   ,
})


 blockEnabled = 
 targetAnimationId = 
 blockConnection = 
 blockLoop = 

  (humanoid)
    _, track  (humanoid:()) 
       track.Animation  track.Animation.AnimationId == targetAnimationId 
         track:()
         track:()
      
   


  ()
    char = player.Character  player.CharacterAdded:()
    humanoid = char:()

   blockLoop = .(()
       blockEnabled  humanoid  humanoid.Parent 
         (humanoid)
         .()
      
   )

   blockConnection = humanoid.AnimationPlayed:((track)
       track.Animation  track.Animation.AnimationId == targetAnimationId 
         track:()
         track:()
      
   )


  ()
    blockConnection 
      blockConnection:()
      blockConnection = 
   
    blockLoop 
      .(blockLoop)
      blockLoop = 
   


LocalTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      blockEnabled = Value
       Value 
         ()
         player.CharacterAdded:(()
             blockEnabled 
               .()
               ()
            
         )
      
         ()
      
   ,
})


  ()
   .StunBypass = :().RenderStepped:(()
       char = .Players.LocalPlayer.Character
       char 
          char:() 
            char.Stunned:()
         
          hum = char:()
          hum 
            hum.PlatformStand = 
             hum.WalkSpeed ==  
               hum.WalkSpeed = 
            
         
      
   )


  ()
    .StunBypass 
      .StunBypass:()
      .StunBypass = 
   


LocalTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Value 
         ()
      
         ()
      
   ,
})


  ()
   .NoSlowLoop = :().RenderStepped:(()
       char = .Players.LocalPlayer.Character
       char 
          hum = char:()
          hum 
             hum.WalkSpeed <  
               hum.WalkSpeed = 
            
            hum.PlatformStand = 
         
      
   )


  ()
    .NoSlowLoop 
      .NoSlowLoop:()
      .NoSlowLoop = 
   


LocalTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Value 
         ()
      
         ()
      
   ,
})


 espEnabled = 
 espConnections = {}
 espLabels = {}

  (target)
    target == player   
    espLabels[target]   

    head = target:()
     head   

    billboard = .()
   billboard.Name = 
   billboard.Size = .(, , , )
   billboard.StudsOffset = .(, , )
   billboard.AlwaysOnTop = 
   billboard.Adornee = head
   billboard.Parent = head

    nameLabel = .()
   nameLabel.Size = .(, , , )
   nameLabel.BackgroundTransparency = 
   nameLabel.Text = target.Name
   nameLabel.TextColor3 = .(, , )
   nameLabel.TextStrokeTransparency = 
   nameLabel.TextScaled = 
   nameLabel.Font = .Font.GothamBold
   nameLabel.Parent = billboard

   espLabels[target] = billboard


  ()
    _, p  (.Players:()) 
       p.Character 
         (p.Character)
      
   

   .(espConnections, .Players.PlayerAdded:((p)
      p.CharacterAdded:((char)
          .()  char:()
         (char)
      )
   ))

    _, p  (.Players:()) 
       p ~= player 
         .(espConnections, p.CharacterAdded:((char)
             .()  char:()
            (char)
         ))
      
   


  ()
    _, gui  (espLabels) 
       gui  gui:() 
   
   espLabels = {}

    _, conn  (espConnections) 
       conn  conn:() 
   
   espConnections = {}


EspTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      espEnabled = Value
       Value 
         ()
      
         ()
      
   ,
})


 highlightEnabled = 
 highlightConnections = {}
 highlightList = {}

  (char, plr)
    plr == player   
    highlightList[plr]   

    highlight = .()
   highlight.Name = 
   highlight.Adornee = char
   highlight.FillTransparency = 
   highlight.OutlineTransparency = 
   highlight.OutlineColor = .(, , )
   highlight.Parent = char

   highlightList[plr] = highlight


  ()
    _, plr  (.Players:()) 
       plr.Character 
         (plr.Character, plr)
      
   

   .(highlightConnections, .Players.PlayerAdded:((p)
      .(highlightConnections, p.CharacterAdded:((char)
          .()  char:()
         (char, p)
      ))
   ))

    _, p  (.Players:()) 
       p ~= player 
         .(highlightConnections, p.CharacterAdded:((char)
             .()  char:()
            (char, p)
         ))
      
   


  ()
    _, hl  (highlightList) 
       hl  hl:() 
   
   highlightList = {}

    _, conn  (highlightConnections) 
       conn  conn:() 
   
   highlightConnections = {}


EspTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      highlightEnabled = Value
       Value 
         ()
      
         ()
      
   ,
})


 boxEnabled = 
 boxList = {}
 boxConnections = {}

  (plr)
    plr == player   
    boxList[plr]   
     plr.Character   

    hrp = plr.Character:()
     hrp   

    box = .()
   box.Name = 
   box.Adornee = hrp
   box.AlwaysOnTop = 
   box.ZIndex = 
   box.Size = .(, , )
   box.Color3 = .(, , )
   box.Transparency = 
   box.Parent = hrp

   boxList[plr] = box


  ()
    _, p  (.Players:()) 
       p.Character 
         (p)
      
   

   .(boxConnections, .Players.PlayerAdded:((p)
      .(boxConnections, p.CharacterAdded:((char)
          .()  char:()
         (p)
      ))
   ))

    _, p  (.Players:()) 
       p ~= player 
         .(boxConnections, p.CharacterAdded:((char)
             .()  char:()
            (p)
         ))
      
   


  ()
    _, box  (boxList) 
       box  box:() 
   
   boxList = {}

    _, conn  (boxConnections) 
       conn  conn:() 
   
   boxConnections = {}


EspTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      boxEnabled = Value
       Value 
         ()
      
         ()
      
   ,
})


 guiConnection
 playerCountLabel

  ()
    screenGui = .()
   screenGui.Name = 
   screenGui.ResetOnSpawn = 
   screenGui.IgnoreGuiInset = 
   screenGui.Parent = player:()

   playerCountLabel = .()
   playerCountLabel.Size = .(, , , )
   playerCountLabel.Position = .(, -, , )
   playerCountLabel.BackgroundTransparency = 
   playerCountLabel.TextColor3 = .(, , )
   playerCountLabel.TextStrokeTransparency = 
   playerCountLabel.TextStrokeColor3 = .(, , )
   playerCountLabel.TextScaled = 
   playerCountLabel.Font = .Font.GothamBlack
   playerCountLabel.TextTransparency = 
   playerCountLabel.Text =  .. #.Players:()
   playerCountLabel.Parent = screenGui

    tween = TweenService:(playerCountLabel, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {
      TextTransparency = 
   })
   tween:()

   guiConnection = RunService.RenderStepped:(()
       playerCountLabel 
         playerCountLabel.Text =  .. #.Players:()
      
   )


  ()
    guiConnection 
      guiConnection:()
      guiConnection = 
   
    playerCountLabel 
      playerCountLabel:()
      playerCountLabel = 
   
    gui = player:():()
    gui 
      gui:()
   


EspTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Value 
         ()
      
         ()
      
   ,
})


 npcHighlights = {}
 npcConnections = {}
 highlightEnabled = 

  (model)
    npcHighlights[model]   
    highlight = .()
   highlight.Adornee = model
   highlight.FillTransparency = 
   highlight.OutlineTransparency = 
   highlight.OutlineColor = .(, , )
   highlight.Parent = model
   npcHighlights[model] = highlight


  ()
    liveFolder = :()
     liveFolder   

    _, model  (liveFolder:()) 
       model:()  model.Name ==  
         (model)
      
   

   .(npcConnections, liveFolder.ChildAdded:((child)
       child:()  child.Name ==  
         .()
         (child)
      
   ))


  ()
    _, h  (npcHighlights) 
       h  h:() 
   
   npcHighlights = {}

    _, conn  (npcConnections) 
       conn  conn:() 
   
   npcConnections = {}


DummyTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      highlightEnabled = Value
       Value 
         ()
      
         ()
      
   ,
})


 npcNameTags = {}
 npcNameConnections = {}
 showNames = 

  (npc)
    npcNameTags[npc]   

    hrp = npc:()
     hrp   

    billboard = .()
   billboard.Name = 
   billboard.Size = .(, , , )
   billboard.Adornee = hrp
   billboard.AlwaysOnTop = 
   billboard.StudsOffset = .(, , )
   billboard.Parent = npc

    textLabel = .()
   textLabel.Size = .(, , , )
   textLabel.BackgroundTransparency = 
   textLabel.Text = npc.Name
   textLabel.TextColor3 = .(, , )
   textLabel.TextStrokeTransparency = 
   textLabel.TextScaled = 
   textLabel.Font = .Font.GothamBold
   textLabel.Parent = billboard

   npcNameTags[npc] = billboard


  ()
    live = :()
     live   

    _, npc  (live:()) 
       npc:()  npc.Name ==  
         (npc)
      
   

   .(npcNameConnections, live.ChildAdded:((npc)
       npc:()  npc.Name ==  
         .()
         (npc)
      
   ))


  ()
    _, tag  (npcNameTags) 
       tag  tag:() 
   
   npcNameTags = {}

    _, conn  (npcNameConnections) 
       conn  conn:() 
   
   npcNameConnections = {}


DummyTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      showNames = Value
       Value 
         ()
      
         ()
      
   ,
})


 orbitConnection
 orbitOn = 
 orbitRadius = 
 orbitSpeed = 
 angle = 

  ()
    live = :()
     live    

    myChar = player.Character
     myChar   myChar:()    
    myPos = myChar.HumanoidRootPart.Position

    closest
    shortest = .huge

    _, npc  (live:()) 
       npc:()  npc.Name ==   npc:() 
          dist = (npc.HumanoidRootPart.Position - myPos).Magnitude
          dist < shortest 
            shortest = dist
            closest = npc
         
      
   

    closest


  ()
   angle = 
   orbitConnection = :().RenderStepped:((dt)
       myChar = player.Character
        myChar   myChar:()   
       myHRP = myChar.HumanoidRootPart

       npc = ()
        npc   npc:()   

       center = npc.HumanoidRootPart.Position
      angle += dt * orbitSpeed

       offset = .(
         .(angle) * orbitRadius,
         ,
         .(angle) * orbitRadius
      )

       goalPos = center + offset
       currentRot = myHRP.CFrame - myHRP.Position
      myHRP.CFrame = .(goalPos) * currentRot
   )


  ()
    orbitConnection 
      orbitConnection:()
      orbitConnection = 
   


DummyTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      orbitOn = Value
       Value 
         ()
      
         ()
      
   ,
})


DummyTab:({
   Name = ,
   Callback = ()
       myChar = player.Character
        myChar   myChar:()   
       myHRP = myChar.HumanoidRootPart

       npc = ()
       npc  npc:() 
          targetPos = npc.HumanoidRootPart.Position
          finalPos = .(targetPos.X, myHRP.Position.Y, targetPos.Z)

          currentRot = myHRP.CFrame - myHRP.Position
          goalCFrame = .(finalPos) * currentRot

          tween = :():(myHRP, TweenInfo.(, .EasingStyle.Sine), {
             = goalCFrame
         })
         tween:()
      
   ,
})


DummyTab:({
   Name = ,
   Callback = ()
       myChar = player.Character
        myChar   myChar:()   
       myHRP = myChar.HumanoidRootPart

       npc = ()
       npc  npc:() 
          targetPos = npc.HumanoidRootPart.Position
          newPos = .(targetPos.X, myHRP.Position.Y, targetPos.Z)

          currentRot = myHRP.CFrame - myHRP.Position
         myHRP.CFrame = .(newPos) * currentRot
      
   ,
})


TechTab:({
   Name = ,
   Callback = ()
      ().keybinds = {
         m1reset = .KeyCode.R,
         emotedash = .KeyCode.T,
         rotation = .KeyCode.H
      }
      (:())()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      ()()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

TechTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})


AdminTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

AdminTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})


 cooldown = 
 animationConnection
 animationId = 
 delayBeforeRemote = 

  ()
    args = {
      [] = {
         [] = .KeyCode.W,
         [] = .KeyCode.Q,
         [] = 
      }
   }
    char = player.Character
    char  char:() 
      char.Communicate:((args))
   


  ()
    hrp = player.Character  player.Character:()
    hrp 
      hrp.CFrame = hrp.CFrame * .(, , )
   


  ()
    char = player.Character  player.CharacterAdded:()
    humanoid = char:()

   animationConnection = humanoid.AnimationPlayed:((track)
       track.Animation  track.Animation.AnimationId == animationId   cooldown 
         cooldown = 
         .(delayBeforeRemote, ()
            ()
            ()
         )
         .(, ()
            cooldown = 
         )
      
   )


AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Value 
         ()
         player.CharacterAdded:(()
            .()
            ()
         )
      
          animationConnection 
            animationConnection:()
            animationConnection = 
         
      
   ,
})


 TweenService = :()
 cam = .CurrentCamera
 debounce = 
 animConnection
 charConnection

  ()
   ()

    args = {
      [] = {
         [] = .KeyCode.W,
         [] = .KeyCode.Q,
         [] = 
      }
   }
    char = player.Character
    char  char:() 
      char.Communicate:((args))
   

    startCFrame = cam.CFrame
    leftCFrame = startCFrame * .(, .(-), )

   cam.CameraType = .CameraType.Scriptable
    tween1 = TweenService:(cam, TweenInfo.(, .EasingStyle.Sine), { = leftCFrame})
   tween1:()
   tween1.Completed:()

   ()
    tween2 = TweenService:(cam, TweenInfo.(, .EasingStyle.Sine), { = startCFrame})
   tween2:()
   tween2.Completed:()

   ()
    angledCFrame = startCFrame * .(.(-), .(), )
    tween3 = TweenService:(cam, TweenInfo.(, .EasingStyle.Sine), { = angledCFrame})
   tween3:()
   tween3.Completed:()

   cam.CameraType = .CameraType.Custom


  (animator)
   animConnection = animator.AnimationPlayed:((track)
       track.Animation  track.Animation.AnimationId == animationId   debounce 
         debounce = 
         (, animationId)

          char = player.Character
          hrp = char  char:()
          hrp 
             back = hrp.CFrame.LookVector * -
            hrp.CFrame = hrp.CFrame + back
         

         .(, ()
            ()
            ()
            debounce = 
         )
      
   )


  ()
    char = player.Character  player.CharacterAdded:()
    humanoid = char:()
    animator = humanoid:()

    animator 
      (animator)
   
      humanoid.ChildAdded:((child)
          child:() 
            (child)
         
      )
   


AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Value 
         ()
         charConnection = player.CharacterAdded:(monitorCharacter)
      
          animConnection 
            animConnection:()
            animConnection = 
         
          charConnection 
            charConnection:()
            charConnection = 
         
      
   ,
})


 targetAnimationId = 
 rotating = 
 animConnection = 
 charConnection = 

  ()
    char = player.Character
    humanoid = char  char:()
    humanoid 
      humanoid.Jump = 
   


  ()
    char = player.Character
    humanoid = char  char:()
    humanoid 
      humanoid.Jump = 
   


  ()
    char = player.Character
    root = char  char:()
     root   

    currentCFrame = root.CFrame
    lookVector = -currentCFrame.LookVector
    newLook = .(currentCFrame.Position, currentCFrame.Position + lookVector)

   root.CFrame = newLook
   cam.CFrame = .(cam.CFrame.Position, cam.CFrame.Position + lookVector)


  ()
    char = player.Character
    remote = char  char:()
    remote 
       args = {
         [] = {
            [] = .KeyCode.W,
            [] = .KeyCode.Q,
            [] = 
         }
      }
      remote:((args))
   


  (humanoid)
   animConnection = humanoid.AnimationPlayed:((track)
       track.Animation  track.Animation.AnimationId == targetAnimationId   rotating 
         rotating = 
         ()

         .(, ()
            ()
            .(, ()
               ()
               ()
               rotating = 
            )
         )
      
   )


  ()
    char = player.Character  player.CharacterAdded:()
    humanoid = char:()
   (humanoid)


AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Value 
         ()
         charConnection = player.CharacterAdded:(setupMonitor)
      
          animConnection  animConnection:() animConnection =  
          charConnection  charConnection:() charConnection =  
      
   ,
})


 animationId = 
 toggleConnection = 
 systemEnabled = 

AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      systemEnabled = Value

       toggleConnection 
         toggleConnection:()
         toggleConnection = 
      

        systemEnabled   

       isTweening = 
       lastPlaying = 

      toggleConnection = :().RenderStepped:(()
          char = player.Character
           char   

          humanoid = char:()
          hrp = char:()
           humanoid   hrp   

          isPlaying = 
          _, track  (humanoid:()) 
             track.Animation  track.Animation.AnimationId == animationId 
               isPlaying = 
               
            
         

          isPlaying   isTweening   lastPlaying 
            isTweening = 
            lastPlaying = 

            .(, ()
                forwardCFrame = hrp.CFrame + hrp.CFrame.LookVector * 
                tweenInfo = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)
                tween = TweenService:(hrp, tweenInfo, { = forwardCFrame})
               tween:()
               tween.Completed:()

                tool = player.Backpack:()
                remote = char:()
                tool  remote 
                   args = {
                     [] = {
                        [] = tool,
                        [] = 
                     }
                  }
                  remote:((args))
               

               isTweening = 
            )
           isPlaying 
            lastPlaying = 
         
      )
   ,
})


 animationId = 
 TWEEN_HEIGHT_OFFSET = .(, , )
 systemEnabled = 
 toggleConnection = 

AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
      systemEnabled = Value

       toggleConnection 
         toggleConnection:()
         toggleConnection = 
      

        systemEnabled   

       isTweening = 
       lastPlaying = 
       cooldown = 

      toggleConnection = :().RenderStepped:(()
          character = player.Character
          hrp = character  character:()
          humanoid = character  character:()
           character   hrp   humanoid   

          isPlaying = 
          _, track  (humanoid:()) 
             track.Animation  track.Animation.AnimationId == animationId 
               isPlaying = 
               
            
         

          isPlaying   isTweening   lastPlaying   cooldown 
            isTweening = 
            lastPlaying = 
            cooldown = 

            .(, ()
                target = 
                shortestDist = 
                live = :()
                live 
                   _, model  (live:()) 
                      model:()  model ~= character 
                         torso = model:()  model:()
                         torso 
                            dist = (hrp.Position - torso.Position).Magnitude
                            dist <= shortestDist 
                              shortestDist = dist
                              target = torso
                           
                        
                     
                  
               

                target 
                   targetPos = target.Position + TWEEN_HEIGHT_OFFSET
                   tween = TweenService:(hrp, TweenInfo.(, .EasingStyle.Linear), { = .(targetPos)})
                  tween:()
                  tween.Completed:()
               

                tool = player.Backpack:()
                remote = character:()
                tool  remote 
                   args = {
                     [] = {
                        [] = tool,
                        [] = 
                     }
                  }
                  remote:((args))
               

               isTweening = 

               .(, ()
                  cooldown = 
               )
            )
           isPlaying 
            lastPlaying = 
         
      )
   ,
})


ServerTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})

ServerTab:({
   Name = ,
   Callback = ()
       TeleportService = :()
       player = .Players.LocalPlayer

       screenGui = .()
      screenGui.Name = 
      screenGui.Parent = player:()

       label = .()
      label.Size = .(, , , )
      label.Position = .(, , , )
      label.TextScaled = 
      label.BackgroundTransparency = 
      label.TextColor3 = .(, , )
      label.Font = .Font.GothamBold
      label.Text = 
      label.Parent = screenGui

       i = , , - 
         label.Text =  .. i .. 
         .()
      

      screenGui:()
      TeleportService:(.PlaceId, .JobId, player)
   ,
})

ServerTab:({
   Name = ,
   Callback = ()
       TeleportService = :()
       HttpService = :()
       player = .Players.LocalPlayer
       placeId = .PlaceId

       screenGui = .()
      screenGui.Name = 
      screenGui.Parent = player:()

       label = .()
      label.Size = .(, , , )
      label.Position = .(, , , )
      label.TextScaled = 
      label.BackgroundTransparency = 
      label.TextColor3 = .(, , )
      label.Font = .Font.GothamBold
      label.Text = 
      label.Parent = screenGui

       i = , , - 
         label.Text =  .. i .. 
         .()
      

      screenGui:()

        ()
          servers = {}
          success, response = (()
             HttpService:(:(..placeId..))
         )

          success  response  response.data 
             _, server  (response.data) 
                server.playing < server.maxPlayers  server.id ~= .JobId 
                  .(servers, server.id)
               
            
         

          #servers >   servers[.(, #servers)]  
      

       target = ()
       target 
         TeleportService:(placeId, target, player)
      
         ()
      
   ,
})

ServerTab:({
   Name = ,
   Callback = ()
       TeleportService = :()
       HttpService = :()
       player = .Players.LocalPlayer
       placeId = .PlaceId

       screenGui = .()
      screenGui.Name = 
      screenGui.Parent = player:()

       label = .()
      label.Size = .(, , , )
      label.Position = .(, , , )
      label.TextScaled = 
      label.BackgroundTransparency = 
      label.TextColor3 = .(, , )
      label.Font = .Font.GothamBold
      label.Text = 
      label.Parent = screenGui

       i = , , - 
         label.Text =  .. i .. 
         .()
      

      screenGui:()

        ()
          servers = {}
          cursor = 

          i = ,  
             url = ..placeId..
             cursor ~=  
               url = url ..  .. cursor
            

             success, response = (()
                HttpService:(:(url))
            )

             success  response  response.data 
                _, server  (response.data) 
                   server.playing <   server.id ~= .JobId 
                     .(servers, server.id)
                  
               

                response.nextPageCursor 
                  cursor = response.nextPageCursor
               
                  
               
            
               
            
         

          #servers >   servers[.(, #servers)]  
      

       target = ()
       target 
         TeleportService:(placeId, target, player)
      
         ()
      
   ,
})

ServerTab:({
   Name = ,
   Callback = ()
       player = .Players.LocalPlayer

       gui = .(, player:())
      gui.ResetOnSpawn = 
      gui.Name = 

       frame = .(, gui)
      frame.Size = .(, , , )
      frame.Position = .(, , , )
      frame.BackgroundColor3 = .(, , )
      frame.BorderSizePixel = 
      frame.BackgroundTransparency = 

       title = .(, frame)
      title.Size = .(, , , )
      title.Text = 
      title.TextColor3 = .(, , )
      title.BackgroundTransparency = 
      title.TextScaled = 
      title.Font = .Font.GothamBold

       yesBtn = .(, frame)
      yesBtn.Size = .(, , , )
      yesBtn.Position = .(, , , )
      yesBtn.Text = 
      yesBtn.BackgroundColor3 = .(, , )
      yesBtn.TextColor3 = .(, , )
      yesBtn.TextScaled = 
      yesBtn.Font = .Font.GothamBold

       noBtn = .(, frame)
      noBtn.Size = .(, , , )
      noBtn.Position = .(, , , )
      noBtn.Text = 
      noBtn.BackgroundColor3 = .(, , )
      noBtn.TextColor3 = .(, , )
      noBtn.TextScaled = 
      noBtn.Font = .Font.GothamBold

      yesBtn.MouseButton1Click:(()
         player:()
      )

      noBtn.MouseButton1Click:(()
         gui:()
      )
   ,
})

ServerTab:({
   Name = ,
   Callback = ()
       player = :().LocalPlayer
       screenGui = .()
      screenGui.Name = 
      screenGui.ResetOnSpawn = 
      screenGui.Parent = player:()

       pingLabel = .()
      pingLabel.Size = .(, , , )
      pingLabel.Position = .(, -, , )
      pingLabel.BackgroundTransparency = 
      pingLabel.BackgroundColor3 = .(, , )
      pingLabel.TextColor3 = .(, , )
      pingLabel.Font = .Font.GothamBold
      pingLabel.TextSize = 
      pingLabel.Text = 
      pingLabel.Parent = screenGui

        
          ping = .(player:() * )
         pingLabel.Text =  .. ping .. 

          ping <=  
            pingLabel.TextColor3 = .(, , )
          ping <=  
            pingLabel.TextColor3 = .(, , )
         
            pingLabel.TextColor3 = .(, , )
         

         ()
      
   ,
})

ServerTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Players = :()
       StarterGui = :()
       LocalPlayer = Players.LocalPlayer
       connections = {}
      
        ()
          mt = ()
          oldNamecall = mt.__namecall
         (mt, )

         mt.__namecall = ((self, ...)
             () ==   self == LocalPlayer 
               ()
                
            
             (self, ...)
         )

         LocalPlayer.Kick = ()
            ()
             
         

         (mt, )
      

        ()
          con = StarterGui.MessageBoxPrompted:(()
            ()
         )
         .(connections, con)
      

        ()
          _, v  (()) 
             (v) ==   (v) 
                info = debug.(v)
                info.name  .(info.name):() 
                  (v, (...)
                     ()
                      
                  )
               
            
         
      

        ()
         ()
         ()
         ()
      

        ()
          _, con  (connections) 
             (con) ==  
               (() con:() )
            
         
         .(connections)
      

       Value 
         ()
      
         ()
      
   ,
})


AutoBlockTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})



LocalTab:({
   Name = ,
   Callback = ()
      (:())()
   ,
})


LocalTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Players = :()
       RunService = :()

       lp = Players.LocalPlayer
       character = lp.Character  lp.CharacterAdded:()
       blockAnimEnabled = Value

       blockedIds = {
         ,
         ,
         
      }

        (animationId)
          _, id  (blockedIds) 
             animationId:(id) 
                
            
         
          
      

       .BlockAnimConnection 
         .BlockAnimConnection:()
         .BlockAnimConnection = 
      

       Value 
         .BlockAnimConnection = RunService.Stepped:(()
              blockAnimEnabled   
             char = lp.Character
              char   
             humanoid = char:()
             humanoid 
                animator = humanoid:()
                animator 
                   _, track  (animator:()) 
                      anim = track.Animation
                      anim  (anim.AnimationId) 
                        track:()
                        (() track:() )
                        ( .. anim.AnimationId)
                     
                  
               
            
         )
      
   ,
})


LocalTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Players = :()
       RunService = :()
       Workspace = :()

       lp = Players.LocalPlayer
       cam = Workspace.CurrentCamera

       .FaceCamConnection 
         .FaceCamConnection:()
         .FaceCamConnection = 
      

       Value 
         .FaceCamConnection = RunService.RenderStepped:(()
             char = lp.Character
              char   

             hrp = char:()
              hrp   

             camLook = cam.CFrame.LookVector
             lookDir = .(camLook.X, , camLook.Z).Unit

            hrp.CFrame = .(hrp.Position, hrp.Position + lookDir)
         )
      
   ,
})


AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Players = :()
       LocalPlayer = Players.LocalPlayer

       targetIDs = {
         [] = ,
         [] = ,
      }

       .SlideM1Connection 
         .SlideM1Connection:()
         .SlideM1Connection = 
      

        Value 
          .SlideM1AnimConnection  .SlideM1AnimConnection:() .SlideM1AnimConnection =  
          .SlideM1CharConnection  .SlideM1CharConnection:() .SlideM1CharConnection =  
         
      

        (char)
          humanoid = char:(, )
          animator = humanoid  humanoid:()
          remote = char:()

           humanoid   animator   remote   

          cooldown = 

          .SlideM1AnimConnection  .SlideM1AnimConnection:() 

         .SlideM1AnimConnection = animator.AnimationPlayed:((track)
              Value   
             id = track.Animation.AnimationId:()
             id  targetIDs[id]   cooldown 
               cooldown = 

               remote:({
                  [] = ,
                  [] = 
               })

               remote:({
                  [] = ,
                  [] = 
               })

               .(, ()
                  cooldown = 
               )
            
         )
      

       LocalPlayer.Character 
         (LocalPlayer.Character)
      

       .SlideM1CharConnection  .SlideM1CharConnection:() 
      .SlideM1CharConnection = LocalPlayer.CharacterAdded:((char)
         .()
          Value 
            (char)
         
      )
   ,
})


AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Players = :()
       TweenService = :()
       RunService = :()
       LocalPlayer = Players.LocalPlayer

       TARGET_ANIM_ID = 
       active = Value
       isTweening = 
       animConnection, charConnection

        active 
         isTweening = 
          charConnection  charConnection:() charConnection =  
          animConnection  animConnection:() animConnection =  
         
      

        ()
          LocalPlayer.Character  LocalPlayer.CharacterAdded:()
      

        ()
          char = ()
          humanoid = char:()
           humanoid    

          _, track  (humanoid:()) 
             track.Animation  track.Animation.AnimationId == TARGET_ANIM_ID 
                
            
         
          
      

        ()
          char = ()
          root = char:()
           root   

         root.Anchored = 
          forward = root.CFrame.LookVector.Unit
          targetCFrame = root.CFrame + (forward * )

          tweenInfo = TweenInfo.(, .EasingStyle.Linear)
          tween = TweenService:(root, tweenInfo, { = targetCFrame})
         tween:()
         tween.Completed:()
      

      RunService.RenderStepped:(()
           active   
          isTweening   
          () 
            isTweening = 
            .()
            ()
            .()
            isTweening = 
         
      )

       LocalPlayer.Character 
         ()
      
       charConnection  charConnection:() 
      charConnection = LocalPlayer.CharacterAdded:(()
         .()
          active 
            ()
         
      )
   ,
})


AutoTab:({
   Name = ,
   CurrentValue = ,
   Flag = ,
   Callback = (Value)
       Players = :()
       RunService = :()
       Workspace = :()

       LocalPlayer = Players.LocalPlayer
       Camera = Workspace.CurrentCamera

       LIFT_IDS = {
         [] = ,
         [] = ,
         [] = ,
         [] = ,
         [] = ,
         [] = ,
         [] = ,
      }

       JUMP_IDS = {
         [] = ,
         [] = ,
         [] = ,
         [] = ,
         [] = ,
         [] = ,
         [] = ,
      }

       isEnabled = Value
       lastUsed = {}

        ()
          char = LocalPlayer.Character  LocalPlayer.CharacterAdded:()
          humanoid = char:()
          hrp = char:()
         char.PrimaryPart = hrp
          char, humanoid
      

       Character, Humanoid = ()

        ()
           Character   Character.PrimaryPart then return end
         local originalSubject = Camera.CameraSubject
         Camera.CameraSubject = nil

         local startCFrame = Character:GetPivot()
         local targetCFrame = startCFrame + Vector3.new(0, 7, 0)
         local steps, duration = 10, 0.1
         for i = 1, steps do
            local alpha = i / steps
            Character:PivotTo(startCFrame:Lerp(targetCFrame, alpha))
            task.wait(duration / steps)
         end

         Camera.CameraSubject = originalSubject
      end

      RunService.RenderStepped:Connect(function()
         if not isEnabled then return end

         if LocalPlayer.Character ~= Character then
            Character, Humanoid = waitForCharacter()
         end

         for _, track in pairs(Humanoid:GetPlayingAnimationTracks()) do
            local animId = tostring(track.Animation.AnimationId)
            local now = tick()

            if LIFT_IDS[animId] and (not lastUsed[animId] or now - lastUsed[animId] > 0.5) then
               lastUsed[animId] = now
               task.delay(0.15, liftCharacter)

            elseif JUMP_IDS[animId] and (not lastUsed[animId] or now - lastUsed[animId] > 0.5) then
               lastUsed[animId] = now
               task.delay(0.15, function()
                  Humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
               end)
            end
         end
      end)
   end,
})

-- Whirlwind Dunk
AutoTab:CreateToggle({
   Name = "Whirlwind Dunk",
   CurrentValue = false,
   Flag = "WhirlwindDunkToggle",
   Callback = function(Value)
      local Players = game:GetService("Players")
      local RunService = game:GetService("RunService")
      local lp = Players.LocalPlayer

      local TARGET_ANIM_ID = "rbxassetid://12296113986"
      local isTeleporting = false
      local lastTrack = nil

      if _G.TeleportAnimConnection then
         _G.TeleportAnimConnection:Disconnect()
         _G.TeleportAnimConnection = nil
      end

      if Value then
         _G.TeleportAnimConnection = RunService.RenderStepped:Connect(function()
            local character = lp.Character
            if not character or isTeleporting then return end

            local humanoid = character:FindFirstChildWhichIsA("Humanoid")
            local root = character:FindFirstChild("HumanoidRootPart")
            if not humanoid or not root then return end

            for _, track in ipairs(humanoid:GetPlayingAnimationTracks()) do
               if track.Animation and track.Animation.AnimationId == TARGET_ANIM_ID then
                  if lastTrack == track then return end
                  lastTrack = track

                  isTeleporting = true
                  task.delay(1.3, function()
                     if root and root.Parent then
                        root.CFrame = root.CFrame + Vector3.new(0, 5, 0)
                     end
                     isTeleporting = false
                  end)
                  break
               end
            end

            if lastTrack and not lastTrack.IsPlaying then
               lastTrack = nil
            end
         end)
      end
   end,
})

-- Esp Character
local toolEspMap = {
   ["Flowing Water"] = {"Garou", Color3.fromRGB(0, 170, 255)},
   ["Crushed Rock"] = {"Garou", Color3.fromRGB(0, 170, 255)},
   ["Normal Punch"] = {"Saitama", Color3.fromRGB(139, 69, 19)},
   ["Serious Punch"] = {"Saitama", Color3.fromRGB(139, 69, 19)},
   ["Binding Cloth"] = {"Monster Form", Color3.fromRGB(255, 0, 0)},
   ["Beatdown"] = {"Brutal Demon", Color3.fromRGB(255, 255, 255)},
   ["Death Blow"] = {"Brutal Demon", Color3.fromRGB(255, 255, 255)},
   ["Blitz Shot"] = {"Cyborg", Color3.fromRGB(255, 140, 0)},
   ["Flamewave Cannon"] = {"Cyborg", Color3.fromRGB(255, 140, 0)},
   ["Explosive Shuriken"] = {"Sonic", Color3.fromRGB(255, 105, 180)},
   ["Carnage"] = {"Sonic", Color3.fromRGB(255, 105, 180)},
   ["Atmos Cleave"] = {"Blade Master", Color3.fromRGB(255, 255, 0)},
   ["Atomic Slash"] = {"Blade Master", Color3.fromRGB(255, 255, 0)},
   ["Crushing Pull"] = {"Tatsumaki", Color3.fromRGB(0, 255, 0)},
   ["Psychic Ricochet"] = {"Tatsumaki", Color3.fromRGB(0, 255, 0)},
   ["Bullet Barrage"] = {"Martial Artist", Color3.fromRGB(128, 0, 128)},
   ["Earth Splitting Strike"] = {"Martial Artist", Color3.fromRGB(128, 0, 128)},
}

local espFolder = Instance.new("Folder", workspace)
espFolder.Name = "DynamicESP"

local espEnabled = false

local function getEspData(player)
   local backpack = player:FindFirstChildOfClass("Backpack")
   if not backpack then return "Tech Prodigy", Color3.fromRGB(200, 200, 200) end

   for toolName, data in pairs(toolEspMap) do
      if backpack:FindFirstChild(toolName) then
         return data[1], data[2]
      end
   end
   return "Tech Prodigy", Color3.fromRGB(200, 200, 200)
end

local function createESP(player, labelText, color)
   local char = player.Character
   if not char or not char:FindFirstChild("Head") then return end
   if espFolder:FindFirstChild(player.Name) then return end

   local billboard = Instance.new("BillboardGui")
   billboard.Name = player.Name
   billboard.Adornee = char.Head
   billboard.Size = UDim2.new(0, 100, 0, 20)
   billboard.StudsOffset = Vector3.new(3.5, 0.5, 0)
   billboard.AlwaysOnTop = true
   billboard.Parent = espFolder

   local label = Instance.new("TextLabel", billboard)
   label.Size = UDim2.new(1, 0, 1, 0)
   label.BackgroundTransparency = 1
   label.Text = labelText
   label.TextColor3 = color
   label.Font = Enum.Font.GothamBold
   label.TextScaled = false
   label.TextSize = 12
   label.TextStrokeTransparency = 0.6
   label.TextTransparency = 1

   TweenService:Create(label, TweenInfo.new(0.3), {
      TextTransparency = 0,
      TextStrokeTransparency = 0.3
   }):Play()
end

local function clearAllESP()
   for _, v in ipairs(espFolder:GetChildren()) do
      v:Destroy()
   end
end

local function updateESPForPlayer(player)
   if player == game.Players.LocalPlayer then return end
   if not player.Character or not player.Character:FindFirstChild("Head") then return end
   local labelText, color = getEspData(player)
   createESP(player, labelText, color)
end

local function refreshAll()
   clearAllESP()
   for _, p in ipairs(game.Players:GetPlayers()) do
      updateESPForPlayer(p)
   end
end

EspTab:CreateToggle({
   Name = "Esp Character",
   CurrentValue = false,
   Flag = "EspCharacterToggle",
   Callback = function(Value)
      espEnabled = Value

      if espEnabled then
         refreshAll()

         for _, player in pairs(game.Players:GetPlayers()) do
            player.CharacterAdded:Connect(function()
               if espEnabled then
                  task.wait(1)
                  updateESPForPlayer(player)
               end
            end)
         end

         game.Players.PlayerAdded:Connect(function(player)
            player.CharacterAdded:Connect(function()
               if espEnabled then
                  task.wait(1)
                  updateESPForPlayer(player)
               end
            end)
         end)

         task.spawn(function()
            while espEnabled do
               refreshAll()
               task.wait(2)
            end
         end)
      else
         clearAllESP()
      end
   end,
})

-- No Anim Ult
local teleportEnabled = false
local teleporting = false
local oldPos = nil
local oldSubject = nil

LocalTab:CreateToggle({
   Name = "No Anim Ult",
   CurrentValue = false,
   Flag = "NoAnimUltToggle",
   Callback = function(Value)
      local Players = game:GetService("Players")
      local RunService = game:GetService("RunService")

      local lp = Players.LocalPlayer
      local character = lp.Character or lp.CharacterAdded:Wait()
      local blockAnimEnabled = Value

      local blockedIds = {
         "12447707844",
         "12342141464",
         "12772543293"
      }

      local function isBlocked(animationId)
         for _, id in pairs(blockedIds) do
            if animationId:find(id) then
               return true
            end
         end
         return false
      end

      if _G.BlockAnimConnection then
         _G.BlockAnimConnection:Disconnect()
         _G.BlockAnimConnection = nil
      end

      if Value then
         _G.BlockAnimConnection = RunService.Stepped:Connect(function()
            if not blockAnimEnabled then return end
            local char = lp.Character
            if not char then return end
            local humanoid = char:FindFirstChildOfClass("Humanoid")
            if humanoid then
               local animator = humanoid:FindFirstChildOfClass("Animator")
               if animator then
                  for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
                     local anim = track.Animation
                     if anim and isBlocked(anim.AnimationId) then
                        track:Stop(0)
                        pcall(function() track:Destroy() end)
                        print("🚫 Dừng animation bị chặn: " .. anim.AnimationId)
                     end
                  end
               end
            end
         end)
      end
   end,
})

-- Face Camera Y
LocalTab:CreateToggle({
   Name = "Face Camera Y",
   CurrentValue = false,
   Flag = "FaceCameraYToggle",
   Callback = function(Value)
      local Players = game:GetService("Players")
      local RunService = game:GetService("RunService")
      local Workspace = game:GetService("Workspace")

      local lp = Players.LocalPlayer
      local cam = Workspace.CurrentCamera

      if _G.FaceCamConnection then
         _G.FaceCamConnection:Disconnect()
         _G.FaceCamConnection = nil
      end

      if Value then
         _G.FaceCamConnection = RunService.RenderStepped:Connect(function()
            local char = lp.Character
            if not char then return end

            local hrp = char:FindFirstChild("HumanoidRootPart")
            if not hrp then return end

            local camLook = cam.CFrame.LookVector
            local lookDir = Vector3.new(camLook.X, 0, camLook.Z).Unit

            hrp.CFrame = CFrame.new(hrp.Position, hrp.Position + lookDir)
         end)
      end
   end,
})

Window:Show()