OP WIN EVERY GAME NO RAGDOLL AUTO FARM MOBILE READY SOURCE

 ().BlindShotOP 
    (() ().BlindShotOP.() )
    .()


 Players = :()
 RunService = :()
 Workspace = :()
 UserInputService = :()
 TweenService = :()

 LocalPlayer = Players.LocalPlayer
 Camera = Workspace.CurrentCamera

 Config = {
    espEnabled = ,
    espShowName = ,
    espShowDistance = ,
    espTracers = ,
    espBoxes = ,
    espLaserESP = ,
    
    aimbotEnabled = ,
    aimbotSmooth = ,
    
    winModeEnabled = ,
    winModeSafeRadius = ,
    
    punchAuraEnabled = ,
    punchAuraRange = ,
    punchAuraSpeed = ,
    
    autoFarmEnabled = ,
    autoFarmDelay = ,
    
    antiRagdollEnabled = ,
    speedHackEnabled = ,
    speedHackValue = ,
}

 Tuning = {
    BoxRatio = ,
    MaxESPDistance = ,
    LaserESPLength = ,
    SafeCheckRadius = ,
    FlyHeight = ,
    TrophyPosition = .(, , )
}

 Palette = {
    Enemy = .(, , ),
    Tracer = .(, , ),
    LaserActive = .(, , ),
    LaserInactive = .(, , ),
    Safe = .(, , )
}

 IsMobileDevice = UserInputService.TouchEnabled

 State = {
    Running = ,
    Unloaded = ,
    LastPunch = ,
    Farming = ,
    PunchEquipped = ,
    SafeSpotLocked = ,
    FinalLocked = ,
    LastSafeCheck = ,
    MobileAiming = ,
    WasFinalBattle = ,
    LastWinModeUpdate = ,
    LastESPUpdate = ,
    CachedArena = ,
    CachedArenaTime = ,
    CachedLasers = ,
    CachedLasersTime = 
}

 Cache = {
    Connections = {},
    LaserData = {}
}

 UpdateIntervals = {
    WinMode = IsMobileDevice    ,
    ESP = IsMobileDevice    ,
    ArenaCache = ,
    LaserCache = IsMobileDevice    
}

 ScreenGui = 

 ESP = { cache = {} }

   
    ()
    


 testDraw = .()
 (testDraw) ==  
    ()
    

 testDraw  testDraw.Remove 
    testDraw:()


 ESP.()
     {
        BoxTop = .(),
        BoxRight = .(),
        BoxBottom = .(),
        BoxLeft = .(),
        Name = .(),
        Distance = .(),
        Tracer = .(),
        Laser = .()
    }


 ESP.(obj)
    obj.BoxTop.Thickness = 
    obj.BoxTop.Visible = 
    obj.BoxRight.Thickness = 
    obj.BoxRight.Visible = 
    obj.BoxBottom.Thickness = 
    obj.BoxBottom.Visible = 
    obj.BoxLeft.Thickness = 
    obj.BoxLeft.Visible = 
    
    obj.Name.Size = 
    obj.Name.Font = .Fonts.Monospace
    obj.Name.Center = 
    obj.Name.Outline = 
    obj.Name.Visible = 
    
    obj.Distance.Size = 
    obj.Distance.Font = .Fonts.Monospace
    obj.Distance.Center = 
    obj.Distance.Outline = 
    obj.Distance.Visible = 
    
    obj.Tracer.Thickness = 
    obj.Tracer.Visible = 
    
    obj.Laser.Thickness = 
    obj.Laser.Visible = 


 ESP.(player)
      ESP.cache[player] 
        ESP.cache[player] = ESP.()
        ESP.(ESP.cache[player])
    
     ESP.cache[player]


 ESP.(obj)
      obj   
    obj.BoxTop.Visible = 
    obj.BoxRight.Visible = 
    obj.BoxBottom.Visible = 
    obj.BoxLeft.Visible = 
    obj.Name.Visible = 
    obj.Distance.Visible = 
    obj.Tracer.Visible = 
    obj.Laser.Visible = 


 ESP.(obj)
      obj   
    (() obj.BoxTop:() )
    (() obj.BoxRight:() )
    (() obj.BoxBottom:() )
    (() obj.BoxLeft:() )
    (() obj.Name:() )
    (() obj.Distance:() )
    (() obj.Tracer:() )
    (() obj.Laser:() )


 ESP.(player)
     ESP.cache[player] 
        ESP.(ESP.cache[player])
        ESP.cache[player] = 
    


 ESP.()
     player, obj  (ESP.cache) 
        ESP.(obj)
    
    ESP.cache = {}


  (character)
      character    
     character:()


  (character)
      character    
     character:()


  (player)
     player == LocalPlayer 
         char = LocalPlayer.Character
          char    
         hum = (char)
          hum  hum.Health <=     
         
    
    
     aliveFolder = Workspace:()
     aliveFolder 
         playerValue = aliveFolder:(player.Name)
         playerValue    
    
    
     char = player.Character
      char    
     hum = (char)
      hum  hum.Health <=     
    
     


 ESP.(player)
     obj = ESP.(player)
    
      Config.espEnabled 
        ESP.(obj)
        
    
    
     player == LocalPlayer 
        ESP.(obj)
        
    
    
      (player) 
        ESP.(obj)
        
    
    
     character = player.Character
      character 
        ESP.(obj)
        
    
    
     root = (character)
      root 
        ESP.(obj)
        
    
    
     rootPos = root.Position
     myChar = LocalPlayer.Character
     myRoot = myChar  (myChar)
     distance = myRoot  (rootPos - myRoot.Position).Magnitude  
    
     distance > Tuning.MaxESPDistance 
        ESP.(obj)
        
    
    
     screenPos, onScreen = Camera:(rootPos)
      onScreen  screenPos.Z <=  
        ESP.(obj)
        
    
    
     screenSize = Camera.ViewportSize
     boxHeight = .( / screenPos.Z, , screenSize.Y * )
     boxWidth = boxHeight * Tuning.BoxRatio
     x = screenPos.X - boxWidth / 
     y = screenPos.Y - boxHeight / 
     color = Palette.Enemy
    
     Config.espBoxes 
        obj.BoxTop.From = .(x, y)
        obj.BoxTop.To = .(x + boxWidth, y)
        obj.BoxTop.Color = color
        obj.BoxTop.Visible = 
        
        obj.BoxRight.From = .(x + boxWidth, y)
        obj.BoxRight.To = .(x + boxWidth, y + boxHeight)
        obj.BoxRight.Color = color
        obj.BoxRight.Visible = 
        
        obj.BoxBottom.From = .(x + boxWidth, y + boxHeight)
        obj.BoxBottom.To = .(x, y + boxHeight)
        obj.BoxBottom.Color = color
        obj.BoxBottom.Visible = 
        
        obj.BoxLeft.From = .(x, y + boxHeight)
        obj.BoxLeft.To = .(x, y)
        obj.BoxLeft.Color = color
        obj.BoxLeft.Visible = 
    
        obj.BoxTop.Visible = 
        obj.BoxRight.Visible = 
        obj.BoxBottom.Visible = 
        obj.BoxLeft.Visible = 
    
    
     Config.espShowName 
        obj.Name.Text = player.DisplayName
        obj.Name.Position = .(screenPos.X, y - )
        obj.Name.Color = color
        obj.Name.Visible = 
    
        obj.Name.Visible = 
    
    
     Config.espShowDistance 
        obj.Distance.Text = .(, .(distance))
        obj.Distance.Position = .(screenPos.X, y + boxHeight + )
        obj.Distance.Color = .(, , )
        obj.Distance.Visible = 
    
        obj.Distance.Visible = 
    
    
     Config.espTracers 
         tracerStart = .(screenSize.X / , screenSize.Y)
        obj.Tracer.From = tracerStart
        obj.Tracer.To = .(screenPos.X, y + boxHeight)
        obj.Tracer.Color = Palette.Tracer
        obj.Tracer.Visible = 
    
        obj.Tracer.Visible = 
    
    
     Config.espLaserESP 
         skinModel = character:()
         laserVisible = 
        
         skinModel 
             ponto = skinModel:()
             targetPart = skinModel:()
            
             ponto  targetPart 
                 pontoAttach = ponto:()
                 targetAttach = targetPart:()
                 beam = ponto:()
                
                 pontoAttach  targetAttach 
                     laserStart = pontoAttach.WorldPosition
                     laserEnd = targetAttach.WorldPosition
                    
                     startScreen = Camera:(laserStart)
                     endScreen = Camera:(laserEnd)
                    
                     startScreen.Z >  
                        obj.Laser.From = .(startScreen.X, startScreen.Y)
                        obj.Laser.To = .(endScreen.X, endScreen.Y)
                        
                         isActive = beam  beam.Enabled
                        obj.Laser.Color = isActive  Palette.LaserActive  Palette.LaserInactive
                        obj.Laser.Thickness = isActive    
                        obj.Laser.Visible = 
                        laserVisible = 
                        
                        Cache.LaserData[player] = {
                            startPos = laserStart,
                            endPos = laserEnd,
                            direction = (laserEnd - laserStart).Unit,
                            active = isActive
                        }
                    
                
            
        
        
          laserVisible 
            obj.Laser.Visible = 
            Cache.LaserData[player] = 
        
    
        obj.Laser.Visible = 
        Cache.LaserData[player] = 
    


  (character, partName)
      character    
     partName ==  
         hitbox = character:()
         hitbox   hitbox 
    
     part = character:(partName)
     part   part 
     (character)


 Aimbot = {}

 Aimbot.()
     closestPlayer = 
     closestDist = .huge
     screenCenter = Camera.ViewportSize / 
    
     _, player  (Players:()) 
         player == LocalPlayer   
          (player)   
        
         character = player.Character
          character   
        
         head = (character, )
          head   
        
         screenPos, onScreen = Camera:(head.Position)
          onScreen  screenPos.Z <=    
        
         dist = (.(screenPos.X, screenPos.Y) - .(screenCenter.X, screenCenter.Y)).Magnitude
         dist < closestDist 
            closestDist = dist
            closestPlayer = player
        
    
    
     closestPlayer


 Aimbot.()
      Config.aimbotEnabled   Config.winModeEnabled   
    
     isMobileAiming = State.MobileAiming == 
     isRMBPressed = UserInputService:(.UserInputType.MouseButton2)
    
      Config.winModeEnabled   isRMBPressed   isMobileAiming   
    
     target = Aimbot.()
      target   
    
     character = target.Character
      character   
    
     head = (character, )
      head   
    
     targetPos = head.Position
     camPos = Camera.CFrame.Position
     targetCF = .(camPos, targetPos)
    
    Camera.CFrame = Camera.CFrame:(targetCF, Config.aimbotSmooth)


 WinMode = {}
 PunchAura = {}
 VirtualInputManager = :()

  (keyCode)
    (()
        VirtualInputManager:(, keyCode, , )
        .()
        VirtualInputManager:(, keyCode, , )
    )
    
    (()
         keypress 
            (keyCode.Value)
            .()
            (keyCode.Value)
        
    )


  ()
    (()
        VirtualInputManager:(, , , , , )
        .()
        VirtualInputManager:(, , , , , )
    )
    
    (()
         mouse1click 
            ()
        
    )


 WinMode.()
    (.KeyCode.One)
    
     backpack = LocalPlayer:()
     backpack 
         _, tool  (backpack:()) 
             tool:() 
                 char = LocalPlayer.Character
                 char 
                    (()
                        tool.Parent = char
                    )
                
                
            
        
    


 WinMode.()
     char = LocalPlayer.Character
      char   
    
     _, item  (char:()) 
         item:() 
            (()
                item:()
            )
            
        
    
    
    ()


 WinMode.()
     state = {
        finalBattle = ,
        matchRunning = ,
        timerText = ,
        alivePlayers = 
    }
    
     finalBattle = Workspace:()
     finalBattle  state.finalBattle = finalBattle.Value 
    
     partidaRolando = Workspace:()
     partidaRolando  state.matchRunning = partidaRolando.Value 
    
     jogadoresVivos = Workspace:()
     jogadoresVivos  state.alivePlayers = #jogadoresVivos:() 
    
    (()
         playerGui = LocalPlayer:()
         playerGui 
             timerGui = playerGui:()
             timerGui 
                 timerLabel = timerGui:(, )
                 timerLabel 
                    state.timerText = timerLabel.Text
                
            
        
    )
    
     state


 HITBOX_HALF_WIDTH = 
 HITBOX_HALF_DEPTH = 
 HITBOX_BUFFER = 
 MIN_SAFE_DISTANCE = HITBOX_HALF_WIDTH + HITBOX_BUFFER

  ()
     now = ()
     State.CachedArena  now - State.CachedArenaTime < UpdateIntervals.ArenaCache 
         State.CachedArena
    
    
     arenaFloor = Workspace:()
     result
     arenaFloor 
         pos = arenaFloor.Position
         size = arenaFloor.Size
         radius = .(size.X, size.Z) /  - 
        result = {
            centerX = pos.X,
            centerZ = pos.Z,
            radius = .(radius, ),
            floorY = pos.Y + size.Y / 
        }
    
        result = {
            centerX = ,
            centerZ = -,
            radius = ,
            floorY = -
        }
    
    
    State.CachedArena = result
    State.CachedArenaTime = now
     result


  (pos)
     arena = ()
     dx = pos.X - arena.centerX
     dz = pos.Z - arena.centerZ
     dist = .(dx * dx + dz * dz)
    
     dist > arena.radius 
         scale = (arena.radius - ) / dist
         .(
            arena.centerX + dx * scale,
            pos.Y,
            arena.centerZ + dz * scale
        )
    
    
     pos


  (pos)
     arena = ()
     dx = pos.X - arena.centerX
     dz = pos.Z - arena.centerZ
     dist = .(dx * dx + dz * dz)
     dist <= arena.radius


  (point, rayStart, rayDir)
     toPoint = point - rayStart
     projection = toPoint:(rayDir)
     closestPoint = rayStart + rayDir * .(, projection)
     (point - closestPoint).Magnitude


  ()
     now = ()
     State.CachedLasers  now - State.CachedLasersTime < UpdateIntervals.LaserCache 
         State.CachedLasers
    
    
     lasers = {}
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = player.Character
          character   
        
         skinModel = character:()
          skinModel   
        
         ponto = skinModel:()
         targetPart = skinModel:()
        
         ponto  targetPart 
             pontoAttach = ponto:()
             targetAttach = targetPart:()
            
             pontoAttach  targetAttach 
                 laserStart = pontoAttach.WorldPosition
                 laserEnd = targetAttach.WorldPosition
                 direction = (laserEnd - laserStart).Unit
                
                lasers[player] = {
                    startPos = laserStart,
                    endPos = laserEnd,
                    direction = direction
                }
            
        
    
    
    State.CachedLasers = lasers
    State.CachedLasersTime = now
     lasers


  (hitboxCenter, laserStart, laserDir)
     toHitbox = hitboxCenter - laserStart
     projection = toHitbox:(laserDir)
    
     projection <    ,  
    
     closestPointOnRay = laserStart + laserDir * projection
    
     dx = .(closestPointOnRay.X - hitboxCenter.X)
     dz = .(closestPointOnRay.Z - hitboxCenter.Z)
    
     isHit = dx < HITBOX_HALF_WIDTH  dz < HITBOX_HALF_DEPTH
     clearance = .(HITBOX_HALF_WIDTH - dx, HITBOX_HALF_DEPTH - dz)
    
     isHit, -clearance


 WinMode.(pos, radius)
     lasers = ()
     player, laserData  (lasers) 
         laserData  laserData.direction 
             isHit, clearance = (pos, laserData.startPos, laserData.direction)
             isHit 
                 
            
             dist = (pos, laserData.startPos, laserData.direction)
             dist < MIN_SAFE_DISTANCE 
                 
            
        
    
     


 WinMode.(pos)
     lasers = ()
     minDist = 
    
     player, laserData  (lasers) 
         laserData  laserData.direction  laserData.startPos 
             isHit, clearance = (pos, laserData.startPos, laserData.direction)
             isHit 
                 
            
             dist = (pos, laserData.startPos, laserData.direction)
             dist < minDist 
                minDist = dist
            
        
    
    
     minDist


 WinMode.()
     arena = ()
     char = LocalPlayer.Character
     arenaY = char  char:()  char.HumanoidRootPart.Position.Y  -
     arenaCenter = .(arena.centerX, arenaY, arena.centerZ)
     arenaRadius = arena.radius
    
     bestPos = arenaCenter
     bestSafety = WinMode.(arenaCenter)
    
     angle = , ,  
         dist = , arenaRadius,  
             rad = .(angle)
             testPos = arenaCenter + .(.(rad) * dist, , .(rad) * dist)
            
             minLaserDist = WinMode.(testPos)
            
             minLaserDist > bestSafety 
                bestSafety = minLaserDist
                bestPos = testPos
            
        
    
    
     bestPos


 WinMode.()
     char = LocalPlayer.Character
      char    
     root = (char)
      root    
    
     closestPos = 
     closestDist = .huge
    
     _, player  (Players:()) 
         player == LocalPlayer   
          (player)   
        
         enemyChar = player.Character
          enemyChar   
         enemyRoot = (enemyChar)
          enemyRoot   
        
         hitbox = enemyChar:()
         head = enemyChar:()
        
         targetPos
         hitbox 
            targetPos = hitbox.Position
         head 
            targetPos = head.Position
        
            targetPos = enemyRoot.Position
        
        
         dist = (enemyRoot.Position - root.Position).Magnitude
         dist < closestDist 
            closestDist = dist
            closestPos = targetPos
        
    
    
     closestPos


 WinMode.()
     char = LocalPlayer.Character
      char    
     root = (char)
      root    
    
     closestPlayer = 
     closestDist = .huge
    
     _, player  (Players:()) 
         player == LocalPlayer   
          (player)   
        
         enemyChar = player.Character
          enemyChar   
         enemyRoot = (enemyChar)
          enemyRoot   
        
         dist = (enemyRoot.Position - root.Position).Magnitude
         dist < closestDist 
            closestDist = dist
            closestPlayer = player
        
    
    
     closestPlayer


 WinMode.()
     char = LocalPlayer.Character
      char    
     root = (char)
      root    
    
     arena = ()
     arenaY = root.Position.Y
    
     lasers = ()
     laserCount = 
     _  (lasers)  laserCount = laserCount +  
    
     laserCount ==     
    
     bestPos = 
     bestSafety = 
     checked = 
     maxChecks = IsMobileDevice    
    
     _, player  (Players:()) 
         checked >= maxChecks   
         player == LocalPlayer   
          (player)   
        
         enemyChar = player.Character
          enemyChar   
         enemyRoot = (enemyChar)
          enemyRoot   
        
        checked = checked + 
         enemyPos = enemyRoot.Position
        
         laserPlayer, laserData  (lasers) 
             laserPlayer == player   
              laserData   laserData.direction   
            
             laserDir = .(laserData.direction.X, , laserData.direction.Z).Unit
            
             behindOffset = -laserDir * 
             behindPos = .(
                enemyPos.X + behindOffset.X,
                arenaY,
                enemyPos.Z + behindOffset.Z
            )
            
            behindPos = (behindPos)
            
              (behindPos)   
            
             isSafe = 
             minClearance = 
            
             checkPlayer, checkLaser  (lasers) 
                  checkLaser   checkLaser.direction   
                
                 isHit = (behindPos, checkLaser.startPos, checkLaser.direction)
                 isHit 
                    isSafe = 
                    
                
                
                 dist = (behindPos, checkLaser.startPos, checkLaser.direction)
                 dist < minClearance 
                    minClearance = dist
                
            
            
             isSafe  minClearance >   minClearance > bestSafety 
                bestSafety = minClearance
                bestPos = behindPos
            
        
    
    
     bestPos


 WinMode.()
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
    
     closestEnemy = 
     closestDist = .huge
    
     _, player  (Players:()) 
         player == LocalPlayer   
          (player)   
        
         enemyChar = player.Character
          enemyChar   
         enemyRoot = (enemyChar)
          enemyRoot   
        
         dist = (enemyRoot.Position - root.Position).Magnitude
         dist < closestDist 
            closestDist = dist
            closestEnemy = enemyRoot
        
    
    
     closestEnemy 
         lookAt = .(root.Position, .(closestEnemy.Position.X, root.Position.Y, closestEnemy.Position.Z))
        root.CFrame = lookAt
    


 WinMode.()
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
     humanoid = (char)
    
    root.CFrame = root.CFrame + .(, Tuning.FlyHeight, )
    
     humanoid 
        humanoid.PlatformStand = 
    
    
     bv = root:()
      bv 
        bv = .()
        bv.Name = 
        bv.MaxForce = .(.huge, .huge, .huge)
        bv.Velocity = .(, , )
        bv.Parent = root
    
    
    State.Flying = 


 WinMode.()
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
     humanoid = (char)
    
     bv = root:()
     bv  bv:() 
    
     humanoid 
        humanoid.PlatformStand = 
    
    
    State.Flying = 


 WinMode.(enemy)
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
     myHitbox = char:()
    
     enemyChar = enemy.Character
      enemyChar   
     enemyRoot = (enemyChar)
      enemyRoot   
     enemyHitbox = enemyChar:()
    
     lookAt = .(root.Position, .(enemyRoot.Position.X, root.Position.Y, enemyRoot.Position.Z))
    root.CFrame = lookAt
    
    root.CFrame = .(enemyRoot.Position + .(, , )) * .(, lookAt:())
    
    WinMode.()
    
     myHitbox  enemyHitbox   
         i = ,  
            (()
                (myHitbox, enemyHitbox, )
                (myHitbox, enemyHitbox, )
            )
        
    
    
     _, part  (enemyChar:()) 
         part:()  myHitbox 
            (()
                (myHitbox, part, )
                (myHitbox, part, )
            )
        
    


 WinMode.()
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
    
     bv = root:()
     bv  bv:() 
    
     arena = ()
    root.CFrame = .(arena.centerX, root.Position.Y, arena.centerZ)


 WinMode.()
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
    
     bv = root:()
      bv 
        bv = .()
        bv.Name = 
        bv.MaxForce = .(.huge, .huge, .huge)
        bv.Velocity = .(, , )
        bv.Parent = root
    
    
     humanoid = (char)
     humanoid 
        humanoid.PlatformStand = 
    


 WinMode.()
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
    
     bv = root:()
     bv  bv:() 


 WinMode.()
      Config.winModeEnabled 
        State.PunchEquipped = 
        State.SafeSpotLocked = 
        State.FinalLocked = 
        WinMode.()
        
    
    
     char = LocalPlayer.Character
      char   
     root = (char)
      root   
    
     gameState = WinMode.()
    
      gameState.matchRunning   gameState.finalBattle 
         State.WasFinalBattle 
            State.WasFinalBattle = 
            WinMode.()
        
        State.SafeSpotLocked = 
        State.FinalLocked = 
        State.PunchEquipped = 
        
    
    
     gameState.finalBattle 
        State.WasFinalBattle = 
    
    
     arena = ()
     arenaY = root.Position.Y
     arenaCenter = .(arena.centerX, arenaY, arena.centerZ)
     arenaRadius = arena.radius
    
     timerLower = gameState.timerText:()
     isShootout = timerLower:()
    
     isCritical = gameState.timerText:()  
                       gameState.timerText:() 
                       gameState.timerText:()  
                       gameState.timerText:() 
                       gameState.timerText:() 
                       gameState.timerText:() 
                       gameState.timerText:() 
                       gameState.timerText:()
    
     isShootout 
        State.FinalLocked = 
        
    
    
    State.FinalLocked = 
    
     now = ()
     now - State.LastWinModeUpdate < UpdateIntervals.WinMode 
         State.SafeSpotLocked 
             safePos = (.(State.SafeSpotLocked.X, arenaY, State.SafeSpotLocked.Z))
             closestEnemy = WinMode.()
             closestEnemy 
                root.CFrame = .(safePos, closestEnemy)
            
                root.CFrame = .(safePos)
            
        
        
    
    State.LastWinModeUpdate = now
    
     lasers = ()
    
     bestPos = 
     bestSafety = 
    
     stepAngle = IsMobileDevice  (isCritical    )  (isCritical    )
     stepDist = IsMobileDevice  (isCritical    )  (isCritical    )
    
     angle = , , stepAngle 
         dist = , arenaRadius, stepDist 
             rad = .(angle)
             spot = .(
                arena.centerX + .(rad) * dist,
                arenaY,
                arena.centerZ + .(rad) * dist
            )
            
             isSafe = 
             minClearance = 
            
             player, laserData  (lasers) 
                 laserData  laserData.direction 
                     isHit = (spot, laserData.startPos, laserData.direction)
                     isHit 
                        isSafe = 
                        minClearance = 
                        
                    
                     dist2 = (spot, laserData.startPos, laserData.direction)
                     dist2 < minClearance 
                        minClearance = dist2
                    
                
            
            
             isSafe  minClearance > MIN_SAFE_DISTANCE  minClearance > bestSafety 
                bestSafety = minClearance
                bestPos = spot
            
        
    
    
     bestPos  bestSafety > MIN_SAFE_DISTANCE 
        State.SafeSpotLocked = (bestPos)
    
         behindPos = WinMode.()
         behindPos  (behindPos) 
            State.SafeSpotLocked = (behindPos)
         bestPos 
            State.SafeSpotLocked = (bestPos)
          State.SafeSpotLocked 
            State.SafeSpotLocked = arenaCenter
        
    
    
      State.SafeSpotLocked   
    
    State.SafeSpotLocked = (State.SafeSpotLocked)
     safePos = (.(State.SafeSpotLocked.X, arenaY, State.SafeSpotLocked.Z))
    
     closestEnemy = WinMode.()
     targetCFrame
     closestEnemy 
        targetCFrame = .(safePos, closestEnemy)
    
        targetCFrame = .(safePos)
    
    
    root.CFrame = targetCFrame
    
     gameState.finalBattle 
        WinMode.()
        
         State.SafeSpotLocked 
             clamped = (State.SafeSpotLocked)
             safePos = .(clamped.X, root.Position.Y, clamped.Z)
            
             closestEnemy = WinMode.()
             closestEnemy 
                root.CFrame = .(safePos, closestEnemy)
            
                root.CFrame = .(safePos)
            
        
        
          State.PunchEquipped 
            WinMode.()
            State.PunchEquipped = 
        
        
         _, player  (Players:()) 
             player == LocalPlayer   
              (player)   
            
             enemyChar = player.Character
              enemyChar   
             enemyRoot = (enemyChar)
              enemyRoot   
            
             dist = (root.Position - enemyRoot.Position).Magnitude
             dist < Config.punchAuraRange 
                 myHitbox = char:()
                 targetHitbox = enemyChar:()
                
                 myHitbox  targetHitbox   
                    (() (myHitbox, targetHitbox, ) )
                    (() (myHitbox, targetHitbox, ) )
                
                
                (()
                     mouse1click 
                        ()
                     mouse1press  mouse1release 
                        ()
                        ()
                    
                )
            
        
    
        WinMode.()
    


 PunchAura.()
     char = LocalPlayer.Character
      char    
    
     root = (char)
      root    
    
     myPos = root.Position
     closestEnemy = 
     closestDist = Config.punchAuraRange
    
     _, player  (Players:()) 
         player == LocalPlayer   
          (player)   
        
         enemyChar = player.Character
          enemyChar   
        
         enemyRoot = (enemyChar)
          enemyRoot   
        
         dist = (enemyRoot.Position - myPos).Magnitude
         dist < closestDist 
            closestDist = dist
            closestEnemy = player
        
    
    
     closestEnemy


 PunchAura.(targetPlayer)
     char = LocalPlayer.Character
      char   
    
     root = (char)
      root   
    
     targetChar = targetPlayer.Character
      targetChar   
    
     targetRoot = (targetChar)
      targetRoot   
    
     myHitbox = char:()
     targetHitbox = targetChar:()
    
     lookAtTarget = .(root.Position, .(targetRoot.Position.X, root.Position.Y, targetRoot.Position.Z))
    root.CFrame = lookAtTarget
    
     myHitbox  targetHitbox   
        (() (myHitbox, targetHitbox, ) )
        (() (myHitbox, targetHitbox, ) )
        
         _, part  (targetChar:()) 
             part:()  part.Name ~=  
                (()
                    (myHitbox, part, )
                    (myHitbox, part, )
                )
            
        
    
    
    (()
         mouse1click 
            ()
         mouse1press  mouse1release 
            ()
            ()
        
    )


 PunchAura.()
      Config.punchAuraEnabled   
    
     now = ()
     now - State.LastPunch < Config.punchAuraSpeed   
    
     nearbyEnemy = PunchAura.()
      nearbyEnemy   
    
    State.LastPunch = now
    PunchAura.(nearbyEnemy)


  ()
      Config.antiRagdollEnabled   
    (()
         char = LocalPlayer.Character
         char 
             ragdollScript = char:()
             ragdollScript  ragdollScript:() 
        
    )


  ()
      Config.speedHackEnabled   
    (()
         char = LocalPlayer.Character
         char 
             hum = (char)
             hum  hum.WalkSpeed = Config.speedHackValue 
        
    )



  (target)
     char = LocalPlayer.Character
      char    
     root = (char)
      root    
    
     targetPart = 
     (target) ==  
         target:() 
            targetPart = target
         target:() 
            targetPart = target.PrimaryPart  target:()
        
    
    
      targetPart    
    
    root.CFrame = targetPart.CFrame + .(, , )
     


  ()
     char = LocalPlayer.Character
      char   
    
     hum = (char)
     root = (char)
    
     root 
        root.CFrame = .(, -, )
    
    
     hum 
        (() hum.Health =  )
    


  ()
     startTime = ()
     timeout = 
    
     () - startTime < timeout 
         char = LocalPlayer.Character
         char 
             hum = (char)
             root = (char)
             hum  hum.Health >   root  root.Position.Y > - 
                .()
                 
            
        
        .()
    
    
     


  ()
     state = {
        matchRunning = ,
        finalBattle = 
    }
    
     partidaRolando = Workspace:()
     partidaRolando  state.matchRunning = partidaRolando.Value 
    
     finalBattle = Workspace:()
     finalBattle  state.finalBattle = finalBattle.Value 
    
     state


  ()
     timeout = 
     startTime = ()
    
     () - startTime < timeout 
          Config.autoFarmEnabled    
        
         gameState = ()
          gameState.matchRunning 
             
        
        
        .()
    
    
     


  ()
     trophyPos = Tuning.TrophyPosition
    
     Config.autoFarmEnabled  State.Running 
         char = LocalPlayer.Character
          char  
            .()
             
        
        
         root = (char)
          root  
            .()
             
        
        
         trophy = Workspace:()
          trophy  
            .()
             
        
        
        root.CFrame = .(trophyPos)
        
          
            (()
                (root, trophy, )
                (root, trophy, )
            )
        
        
        .(Config.autoFarmDelay)
    
    State.Farming = 


  ()
     State.Farming   
    State.Farming = 
    Threads[] = .(AutoFarmLoop)


  ()
    Config.autoFarmEnabled = 
     Threads[] 
        (() .(Threads[]) )
        Threads[] = 
    
    State.Farming = 


  (name)
     Threads[name] 
        (() .(Threads[name]) )
        Threads[name] = 
    


  ()
     name, conn  (Cache.Connections) 
        (() conn:() )
        Cache.Connections[name] = 
    


  ()
    State.Running = 
    State.Unloaded = 
    Config.autoFarmEnabled = 
    Config.winModeEnabled = 
    
    (() WinMode.() )
    
    .()
    ()
    
     name  (Threads) 
        (name)
    
    
    ESP.()
    Cache.LaserData = {}
    
     ScreenGui 
        (() ScreenGui:() )
        ScreenGui = 
    
    
    ().BlindShotOP = 


  ()
     isMobile = UserInputService.TouchEnabled
    
    ScreenGui = .()
    ScreenGui.Name = 
    ScreenGui.ResetOnSpawn = 
    ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
    ScreenGui.IgnoreGuiInset = 
    
    (()
          
            .(ScreenGui)
         gethui 
            ScreenGui.Parent = ()
            
        
    )
    
    ScreenGui.Parent = LocalPlayer:()
    
     Accent = .(, , )
     GlassBg = .(, , )
     GlassCard = .(, , )
     TextPrimary = .(, , )
     TextSecondary = .(, , )
    
     MainContainer = .()
    MainContainer.Name = 
    MainContainer.AnchorPoint = .(, )
    MainContainer.Position = .(, , , )
    MainContainer.Size = isMobile  .(, , , )  .(, , , )
    MainContainer.BackgroundColor3 = GlassBg
    MainContainer.BackgroundTransparency = 
    MainContainer.BorderSizePixel = 
    MainContainer.ClipsDescendants = 
    MainContainer.Parent = ScreenGui
    
     MainCorner = .()
    MainCorner.CornerRadius = .(, )
    MainCorner.Parent = MainContainer
    
     TopBar = .()
    TopBar.Size = .(, , , )
    TopBar.BackgroundColor3 = .(, , )
    TopBar.BackgroundTransparency = 
    TopBar.BorderSizePixel = 
    TopBar.Parent = MainContainer
    
     TopCorner = .()
    TopCorner.CornerRadius = .(, )
    TopCorner.Parent = TopBar
    
     TitleLabel = .()
    TitleLabel.Size = .(, , , )
    TitleLabel.Position = .(, , , -)
    TitleLabel.BackgroundTransparency = 
    TitleLabel.Text = 
    TitleLabel.TextSize = 
    TitleLabel.Font = .Font.GothamBold
    TitleLabel.TextColor3 = Accent
    TitleLabel.TextXAlignment = .TextXAlignment.Left
    TitleLabel.Parent = TopBar
    
     PowerBtn = .()
    PowerBtn.Size = .(, , , )
    PowerBtn.Position = .(, -, , -)
    PowerBtn.BackgroundColor3 = .(, , )
    PowerBtn.BackgroundTransparency = 
    PowerBtn.BorderSizePixel = 
    PowerBtn.Image = 
    PowerBtn.ImageColor3 = TextPrimary
    PowerBtn.Parent = TopBar
    
     PowerCorner = .()
    PowerCorner.CornerRadius = .(, )
    PowerCorner.Parent = PowerBtn
    
    PowerBtn.MouseButton1Click:(Unload)
    
     ContentFrame = .()
    ContentFrame.Size = .(, -, , -)
    ContentFrame.Position = .(, , , )
    ContentFrame.BackgroundTransparency = 
    ContentFrame.ScrollBarThickness = isMobile    
    ContentFrame.ScrollBarImageColor3 = Accent
    ContentFrame.CanvasSize = .(, , , isMobile    )
    ContentFrame.Parent = MainContainer
    
     ContentLayout = .()
    ContentLayout.CellSize = isMobile  .(, -, , )  .(, -, , )
    ContentLayout.CellPadding = .(, , , )
    ContentLayout.SortOrder = .SortOrder.LayoutOrder
    ContentLayout.Parent = ContentFrame
    
      (label, default, callback, order)
         Frame = .()
        Frame.BackgroundColor3 = GlassCard
        Frame.BackgroundTransparency = 
        Frame.BorderSizePixel = 
        Frame.LayoutOrder = order  
        Frame.Parent = ContentFrame
        
         Corner = .()
        Corner.CornerRadius = .(, )
        Corner.Parent = Frame
        
         Label = .()
        Label.Size = .(, -, , )
        Label.Position = .(, , , )
        Label.BackgroundTransparency = 
        Label.Text = label
        Label.TextSize = isMobile    
        Label.Font = .Font.GothamMedium
        Label.TextColor3 = TextPrimary
        Label.TextXAlignment = .TextXAlignment.Left
        Label.TextTruncate = .TextTruncate.AtEnd
        Label.Parent = Frame
        
         toggleSize = isMobile    
         toggleHeight = isMobile    
        
         ToggleBg = .()
        ToggleBg.Size = .(, toggleSize, , toggleHeight)
        ToggleBg.Position = .(, -toggleSize - , , -toggleHeight/)
        ToggleBg.BackgroundColor3 = default  Accent  .(, , )
        ToggleBg.BorderSizePixel = 
        ToggleBg.Parent = Frame
        
         BgCorner = .()
        BgCorner.CornerRadius = .(, )
        BgCorner.Parent = ToggleBg
        
         circleSize = isMobile    
        
         Circle = .()
        Circle.Size = .(, circleSize, , circleSize)
        Circle.Position = default  .(, -circleSize - , , -circleSize/)  .(, , , -circleSize/)
        Circle.BackgroundColor3 = TextPrimary
        Circle.BorderSizePixel = 
        Circle.Parent = ToggleBg
        
         CircleCorner = .()
        CircleCorner.CornerRadius = .(, )
        CircleCorner.Parent = Circle
        
         enabled = default
         Btn = .()
        Btn.Size = .(, , , )
        Btn.BackgroundTransparency = 
        Btn.Text = 
        Btn.Parent = Frame
        
        Btn.MouseButton1Click:(()
            enabled =  enabled
            TweenService:(ToggleBg, TweenInfo.(), {
                BackgroundColor3 = enabled  Accent  .(, , )
            }):()
            TweenService:(Circle, TweenInfo.(, .EasingStyle.Back), {
                Position = enabled  .(, -circleSize - , , -circleSize/)  .(, , , -circleSize/)
            }):()
            (enabled)
        )
        
         Frame
    
    
      (label, min, max, default, callback, order)
        min = .(min, max)
        default = .(default, min, max)
        
         Frame = .()
        Frame.BackgroundColor3 = GlassCard
        Frame.BackgroundTransparency = 
        Frame.BorderSizePixel = 
        Frame.LayoutOrder = order  
        Frame.Parent = ContentFrame
        
         Corner = .()
        Corner.CornerRadius = .(, )
        Corner.Parent = Frame
        
         Label = .()
        Label.Size = .(, , , )
        Label.Position = .(, , , )
        Label.BackgroundTransparency = 
        Label.Text = label
        Label.TextSize = 
        Label.Font = .Font.GothamMedium
        Label.TextColor3 = TextPrimary
        Label.TextXAlignment = .TextXAlignment.Left
        Label.Parent = Frame
        
         Value = .()
        Value.Size = .(, , , )
        Value.Position = .(, -, , )
        Value.BackgroundTransparency = 
        Value.Text = (default)
        Value.TextSize = 
        Value.Font = .Font.GothamBold
        Value.TextColor3 = Accent
        Value.TextXAlignment = .TextXAlignment.Right
        Value.Parent = Frame
        
         sliderHeight = isMobile    
         sliderY = isMobile    
        
         SliderBg = .()
        SliderBg.Size = .(, -, , sliderHeight)
        SliderBg.Position = .(, , , sliderY)
        SliderBg.BackgroundColor3 = .(, , )
        SliderBg.BorderSizePixel = 
        SliderBg.Parent = Frame
        
         BgCorner = .()
        BgCorner.CornerRadius = .(, )
        BgCorner.Parent = SliderBg
        
         Fill = .()
        Fill.Size = .((default - min) / (max - min), , , )
        Fill.BackgroundColor3 = Accent
        Fill.BorderSizePixel = 
        Fill.Parent = SliderBg
        
         FillCorner = .()
        FillCorner.CornerRadius = .(, )
        FillCorner.Parent = Fill
        
         currentValue = default
         dragging = 
        
         hitAreaHeight = isMobile    
        
         SliderBtn = .()
        SliderBtn.Size = .(, , , hitAreaHeight)
        SliderBtn.Position = .(, , , isMobile    )
        SliderBtn.BackgroundTransparency = 
        SliderBtn.Text = 
        SliderBtn.Parent = Frame
        
          (inputPos)
             pct = .((inputPos - SliderBg.AbsolutePosition.X) / SliderBg.AbsoluteSize.X, , )
            currentValue = .((min + (max - min) * pct) * ) / 
            Fill.Size = .(pct, , , )
            Value.Text = (currentValue)
            (currentValue)
        
        
        SliderBtn.InputBegan:((input)
             input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
                dragging = 
                (input.Position.X)
            
        )
        
        SliderBtn.InputEnded:((input)
             input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
                dragging = 
            
        )
        
        Cache.Connections[ .. label] = UserInputService.InputChanged:((input)
             dragging  State.Running  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
                (input.Position.X)
            
        )
        
         Frame
    
    
    (, , (v) Config.espEnabled = v , )
    (, , (v) Config.espShowName = v , )
    (, , (v) Config.espShowDistance = v , )
    (, , (v) Config.espLaserESP = v , )
    (, , (v) Config.espBoxes = v , )
    (, , (v) Config.espTracers = v , )
    
    (, , (v) Config.winModeEnabled = v , )
    (, , , , (v) Config.winModeSafeRadius = v , )
    
    (, , (v) Config.aimbotEnabled = v , )
    (, , , , (v) Config.aimbotSmooth = v , )
    
    (, , (v) Config.punchAuraEnabled = v , )
    (, , , , (v) Config.punchAuraRange = v , )
    
    (, , (v)
        Config.autoFarmEnabled = v
         v  ()  () 
    , )
    (, , , , (v) Config.autoFarmDelay = v , )
    
    (, , (v) Config.antiRagdollEnabled = v , )
    (, , (v) Config.speedHackEnabled = v , )
    (, , , , (v) Config.speedHackValue = v , )
    
     dragging = 
     dragStart, startPos
    
      (input)
         input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
            dragging = 
            dragStart = input.Position
            startPos = MainContainer.Position
        
    
    
      (input)
         input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
            dragging = 
        
    
    
    TopBar.InputBegan:(StartDrag)
    TopBar.InputEnded:(StopDrag)
    MainContainer.InputBegan:(StartDrag)
    MainContainer.InputEnded:(StopDrag)
    
    Cache.Connections[] = UserInputService.InputChanged:((input)
         dragging  State.Running  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
             delta = input.Position - dragStart
            MainContainer.Position = .(
                startPos.X.Scale, startPos.X.Offset + delta.X,
                startPos.Y.Scale, startPos.Y.Offset + delta.Y
            )
        
    )
    
     isMobile 
         MobileToggle = .()
        MobileToggle.Name = 
        MobileToggle.Size = .(, , , )
        MobileToggle.Position = .(, -, , )
        MobileToggle.BackgroundColor3 = GlassBg
        MobileToggle.BackgroundTransparency = 
        MobileToggle.BorderSizePixel = 
        MobileToggle.Text = 
        MobileToggle.TextSize = 
        MobileToggle.Font = .Font.GothamBold
        MobileToggle.TextColor3 = TextPrimary
        MobileToggle.ZIndex = 
        MobileToggle.Parent = ScreenGui
        
         MobileCorner = .()
        MobileCorner.CornerRadius = .(, 0)
        MobileCorner.Parent = MobileToggle
        
        local MobileStroke = Instance.new("UIStroke")
        MobileStroke.Color = Accent
        MobileStroke.Thickness = 2
        MobileStroke.Parent = MobileToggle
        
        local visible = true
        local mobileDragging = false
        local mobileDragStart, mobileStartPos
        
        MobileToggle.MouseButton1Click:Connect(function()
            if not mobileDragging then
                visible = not visible
                MainContainer.Visible = visible
            end
        end)
        
        MobileToggle.InputBegan:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.Touch then
                mobileDragging = false
                mobileDragStart = input.Position
                mobileStartPos = MobileToggle.Position
            end
        end)
        
        MobileToggle.InputChanged:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.Touch then
                local delta = input.Position - mobileDragStart
                if delta.Magnitude > 10 then
                    mobileDragging = true
                    local screenSize = ScreenGui.AbsoluteSize
                    local btnSize = MobileToggle.AbsoluteSize
                    local newX = math.clamp(mobileStartPos.X.Offset + delta.X, 10, screenSize.X - btnSize.X - 10)
                    local newY = math.clamp(mobileStartPos.Y.Offset + delta.Y, 50, screenSize.Y - btnSize.Y - 10)
                    MobileToggle.Position = UDim2.new(0, newX, 0, newY)
                end
            end
        end)
        
        MobileToggle.InputEnded:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.Touch then
                task.wait(0.1)
                mobileDragging = false
            end
        end)
        
        local AimToggle = Instance.new("TextButton")
        AimToggle.Name = "AimToggle"
        AimToggle.Size = UDim2.new(0, 42, 0, 42)
        AimToggle.Position = UDim2.new(1, -52, 0, 60)
        AimToggle.BackgroundColor3 = Color3.fromRGB(60, 65, 75)
        AimToggle.BackgroundTransparency = 0.1
        AimToggle.BorderSizePixel = 0
        AimToggle.Text = "AIM"
        AimToggle.TextSize = 11
        AimToggle.Font = Enum.Font.GothamBold
        AimToggle.TextColor3 = TextSecondary
        AimToggle.Visible = false
        AimToggle.ZIndex = 100
        AimToggle.Parent = ScreenGui
        
        local AimCorner = Instance.new("UICorner")
        AimCorner.CornerRadius = UDim.new(1, 0)
        AimCorner.Parent = AimToggle
        
        local AimStroke = Instance.new("UIStroke")
        AimStroke.Color = Color3.fromRGB(60, 65, 75)
        AimStroke.Thickness = 2
        AimStroke.Parent = AimToggle
        
        local aimActive = false
        
        AimToggle.MouseButton1Click:Connect(function()
            aimActive = not aimActive
            State.MobileAiming = aimActive
            AimToggle.BackgroundColor3 = aimActive and Accent or Color3.fromRGB(60, 65, 75)
            AimToggle.TextColor3 = aimActive and TextPrimary or TextSecondary
            AimStroke.Color = aimActive and Accent or Color3.fromRGB(60, 65, 75)
        end)
        
        task.spawn(function()
            while State.Running and not State.Unloaded do
                task.wait(0.1)
                pcall(function()
                    AimToggle.Visible = Config.aimbotEnabled
                    if not Config.aimbotEnabled and aimActive then
                        aimActive = false
                        State.MobileAiming = false
                        AimToggle.BackgroundColor3 = Color3.fromRGB(60, 65, 75)
                        AimToggle.TextColor3 = TextSecondary
                        AimStroke.Color = Color3.fromRGB(60, 65, 75)
                    end
                end)
            end
        end)
    end
end

local function MainLoop()
    if State.Unloaded then return end
    
    Camera = Workspace.CurrentCamera
    if not Camera then return end
    
    local now = tick()
    
    local shouldThrottleESP = Config.winModeEnabled and IsMobileDevice
    if shouldThrottleESP then
        if now - State.LastESPUpdate >= UpdateIntervals.ESP then
            State.LastESPUpdate = now
            for _, player in ipairs(Players:GetPlayers()) do
                pcall(function() ESP.Render(player) end)
            end
        end
    else
        for _, player in ipairs(Players:GetPlayers()) do
            pcall(function() ESP.Render(player) end)
        end
    end
    
    pcall(function() Aimbot.Update() end)
    pcall(function() WinMode.Update() end)
    pcall(function() PunchAura.Update() end)
    
    AntiRagdoll()
    SpeedHack()
end

Cache.Connections.RenderStepped = RunService.RenderStepped:Connect(MainLoop)

Cache.Connections.PlayerRemoving = Players.PlayerRemoving:Connect(function(player)
    ESP.Remove(player)
    Cache.LaserData[player] = nil
end)

Cache.Connections.CharacterAdded = LocalPlayer.CharacterAdded:Connect(function()
    task.wait(0.5)
    AntiRagdoll()
end)

CreateGUI()

getgenv().BlindShotOP = {
    Config = Config,
    State = State,
    Unload = Unload,
    TeleportTo = TeleportTo
}