Feather Lite | Silent Aim, Kill Aura (OPEN SOURCE)

 .GameId ~=    

 FeatherLite = (:())()

 Players = :()
 RS = :()
 RunService = :()
 UIS = :()
 Lighting = :()
 CS = :()
 LP = Players.LocalPlayer

 G = ()
 G.FeatherLongFlight  G.FeatherLongFlight.stop  (G.FeatherLongFlight.stop) 
 alive = 
 conns = {}
G.FeatherLongFlight = {}

  (m)   m      ok, r = (, m)  ok  r   

  (group, notifyFn)
    group:({ Name = , Description = , Callback = ()
         setclipboard 
            (setclipboard, )
            ()
        
     })



 RS:()  RS:() 
     W = FeatherLite:({ Title = , Folder = , Key = .KeyCode.RightShift })
      (text) W:({ Title = , Text = text, Duration =  }) 
     tab = W:({ Name = , Icon =  })
     start = tab:()
    start:({ Title = , Text =  })
    (tab:(), say)
    ()
    G.FeatherLongFlight.stop = () (W.Unload, W) 
    


 IS = RS:(, )
  IS   
 Remotes = IS:()
 WorldFolder = RS:()
 Weapons = RS:()

 Begin = Remotes:()
 EndRemote = Remotes:()
 UpdateRemote = Remotes:()
 UseItem = Remotes:()
 SprintState = Remotes:()
 GunFire = Weapons.Remotes:()
 GunReload = Weapons.Remotes:()
 RPGFire = Weapons.Remotes:()
 Punch = Weapons.Remotes:()
 WeaponAction = RS:():():()

 ItemConfig = (WorldFolder:())
 GunConfig = (Weapons:())
 PunchConfig = (Weapons:())  { Cooldown = , Range =  }
 AircraftUtil = (IS:())

 STUDS_PER_M = 

 Window
 F = ({}, { __index = (_, k)
     el = Window  Window.Flags[k]
     el   el:() 
 })
  (sig, fn)  c = sig:(fn) conns[#conns + ] = c  c 
  (text)  Window  Window:({ Title = , Text = text, Duration =  })  

  ()  c = LP.Character  c  c:() 
  ()  c = LP.Character  c  c:() 
  (v)  .(v.X, , v.Z) 
  (studs)  .(studs / STUDS_PER_M) 
  (x)
     x:()   x.Position 
     x:()   x:().Position 

  (list, v)
     (list) ~=     
     _, x  (list)   x == v     
     



 espRoot = .()
espRoot.Name = 
  (() espRoot.Parent = (gethui  ())  :() ) 
    espRoot.Parent = LP:()


  (adornee, color)
     bb = .()
    bb.AlwaysOnTop = 
    bb.Size = .(, )
    bb.StudsOffset = .(, , )
    bb.LightInfluence = 
    bb.Adornee = adornee
     tl = .()
    tl.BackgroundTransparency = 
    tl.Size = .(, )
    tl.Font = .Font.GothamBold
    tl.TextSize = 
    tl.TextColor3 = color
    tl.TextStrokeTransparency = 
    tl.TextWrapped = 
    tl.Parent = bb
    bb.Parent = espRoot
     { bb = bb, tl = tl }

  (t)  t  (t.bb.Destroy, t.bb)  t.hl  (t.hl.Destroy, t.hl)   


  (store, list, highlight)
     seen = {}
     _, e  (list) 
        seen[e.key] = 
         t = store[e.key]
          t 
            t = (e.part, e.color)
             e.offset  t.bb.StudsOffset = e.offset 
            store[e.key] = t
        
        t.bb.Adornee = e.part
        t.tl.Text = e.text
        t.tl.TextColor3 = e.color
         highlight  e.model 
              t.hl 
                t.hl = .()
                t.hl.FillColor = e.color
                t.hl.FillTransparency = 
                t.hl.OutlineColor = .(, , )
                t.hl.DepthMode = .HighlightDepthMode.AlwaysOnTop
                t.hl.Parent = espRoot
            
            t.hl.Adornee = e.model
         t.hl 
            t.hl:()
            t.hl = 
        
    
     k, t  (store) 
          seen[k]  (t) store[k] =  
    





 lastPlane
  ()
     h = ()
     seat = h  h.SeatPart
     seat  AircraftUtil 
         p = AircraftUtil.(seat)
         p  lastPlane = p  p, seat 
    
     lastPlane  lastPlane.Parent   lastPlane,  
     _, m  (:()) 
         m:()  m.Name:(, ) ==   m:() == LP.UserId   m,  
    
     :(), 

  (p)  p  (p:()  p.PrimaryPart) 


  ()
     mine = ()
     out = {}
     _, m  (:()) 
         m:()  m ~= mine  m.Name:(, ) ==   m:() 
            out[#out + ] = m
        
    
     out

  (m)
     n = m.Name:(, ):(, ):(, )
     n ~=   n  




  ()
     out = {}
     _, z  (CS:()) 
         h = z:()
         h  h.Health >   z:()  out[#out + ] = z 
    
     out

  ()
     out, seen = {}, {}
      (m)
         m:()   seen[m]  m:()  (m) 
            seen[m] = 
            out[#out + ] = m
        
    
     _, m  (CS:())  (m) 
     folder = :()
     folder   _, m  (folder:())  (m)  
     out


  (z, head)
     (head  z:())  z:()  z:()



  (includeBandits)
     out = {}
     _, z  (()) 
         p = (z, F.AimHead ~= )
         p  out[#out + ] = { model = z, part = p, kind =  } 
    
     includeBandits 
         _, b  (())  out[#out + ] = { model = b, part = (b), kind =  } 
    
     out


 rayParams = RaycastParams.()
rayParams.FilterType = .RaycastFilterType.Exclude
  (from, to, targetModel)
     skip = { LP.Character, targetModel }
     items = :()
     items  skip[#skip + ] = items 
     plane = ()
     plane  skip[#skip + ] = plane 
    rayParams.FilterDescendantsInstances = skip
     :(from, to - from, rayParams) == 



  (origin, range)
     cam = .CurrentCamera
     center = cam.ViewportSize / 
     best, bestD
     _, t  ((F.AimBandits)) 
         pos = t.part.Position
         (pos - origin).Magnitude <= range 
             sp, onScreen = cam:(pos)
             onScreen 
                 d = (.(sp.X, sp.Y) - center).Magnitude
                 d <= (F.AimFov  )  ( bestD  d < bestD)  ( F.WallCheck  (origin, pos, t.model)) 
                    best, bestD = t, d
                
            
        
    
     best


  (from, range)
     best, bd
     _, b  (()) 
         r = (b)
         d = (r.Position - from).Magnitude
         d <= range  ( bd  d < bd)  best, bd = b, d 
    
     best



  (from, part, speed)
     pos, vel = part.Position, part.AssemblyLinearVelocity
     t = (pos - from).Magnitude / speed
     _ = ,   t = ((pos + vel * t) - from).Magnitude / speed 
     pos + vel * t



 fovGui = .()
fovGui.Name = 
fovGui.IgnoreGuiInset = 
fovGui.DisplayOrder = 
fovGui.ResetOnSpawn = 
fovGui.Parent = espRoot.Parent
 fov = .()
fov.AnchorPoint = .(, )
fov.Position = .(, )
fov.BackgroundTransparency = 
fov.Visible = 
fov.Parent = fovGui
.(, fov).CornerRadius = .(, )
 fovStroke = .(, fov)
fovStroke.Color = .(, , )
fovStroke.Transparency = 
fovStroke.Thickness = 
(RunService.RenderStepped, ()
     show = F.SilentAim  F.ShowFov
    fov.Visible = show == 
     show 
         r = F.AimFov  
        fov.Size = .(r * , r * )
    
)




 hooks = {}

  ()
     c = LP.Character
     t = c  c:()
     t  t:()   t 

  (tool)
     tool  GunConfig  GunConfig.Guns[tool:()  ]


hooks[GunFire] = (tool, origin, dir)
      F.SilentAim  (origin) ~=    
     cfg = (tool)
     t = (origin, cfg  cfg.Range  )
      t   
     aim = t.kind ==   (origin, t.part, (cfg  cfg.TracerSpeed)  )  t.part.Position
     .(tool, origin, (aim - origin).Unit)



hooks[WeaponAction] = (action, point, ...)
     action ~=    F.MountAim   
     plane = ()
     r = (plane)
      r   
     b = (r.Position, F.MountRange  )
      b   
     .(action, (r.Position, (b), ), ...)



hooks[RPGFire] = (lockTarget, look, point)
      F.RPGLock  lockTarget ~=    
     c = LP.Character
     from = c  c:().Position  .CurrentCamera.CFrame.Position
     b = (from, )
      b   
     .(b, (look) ==   look  ((b).Position - from).Unit)



hooks[SprintState] = (state)
     F.InfStamina  state ==    .() 


 oldNamecall
   getnamecallmethod  checkcaller 
    oldNamecall = (, , ((self, ...)
         h = hooks[self]
         h  alive   ()  () ==  
             ok, a = (h, ...)
             ok  a 
                 (self, .(a, , a.n))
            
        
         (self, ...)
    ))





 gunOrig = {}
  ()
      GunConfig   GunConfig.Guns   
     id, g  (GunConfig.Guns) 
         o = gunOrig[id]
          o 
            o = {
                SpreadHip = g.SpreadHip, SpreadAim = g.SpreadAim, SpreadMove = g.SpreadMove,
                FireInterval = g.FireInterval, Automatic = g.Automatic, InfiniteAmmo = g.InfiniteAmmo,
                ReloadTime = g.ReloadTime, ReloadEmptyTime = g.ReloadEmptyTime,
                Recoil = (g.Recoil) ==   .(g.Recoil)  ,
            }
            gunOrig[id] = o
        
         nospread = F.NoSpread == 
        g.SpreadHip = nospread    o.SpreadHip
        g.SpreadAim = nospread    o.SpreadAim
        g.SpreadMove = nospread    o.SpreadMove
         o.Recoil  (g.Recoil) ==  
             k, v  (o.Recoil) 
                 (v) ==   g.Recoil[k] = F.NoRecoil    v 
            
        
         o.FireInterval 
            g.FireInterval = F.RapidFire  o.FireInterval / (F.FireRateMult  )  o.FireInterval
        
        g.Automatic = (F.FullAuto  )  o.Automatic
        g.InfiniteAmmo = (F.InfAmmo  )  o.InfiniteAmmo
         o.ReloadTime  g.ReloadTime = F.FastReload  o.ReloadTime *   o.ReloadTime 
         o.ReloadEmptyTime  g.ReloadEmptyTime = F.FastReload  o.ReloadEmptyTime *   o.ReloadEmptyTime 
    

  ()
      GunConfig   GunConfig.Guns   
     id, o  (gunOrig) 
         g = GunConfig.Guns[id]
         g 
             k, v  (o) 
                 k ==  
                     rk, rv  (v)  g.Recoil[rk] = rv 
                
                    g[k] = v
                
            
        
    



 auraLast, reloadUntil = , 
  ()
      F.KillAura   
     tool = ()
     cfg = (tool)
     c = LP.Character
     head = c  c:()
      tool   cfg   head   
     now = .()
     now < reloadUntil  now - auraLast < .(cfg.FireInterval  , )   
     ammo = tool:()  
     ammo <=  
         (tool:()  ) >  
            GunReload:(tool)
            reloadUntil = now + (cfg.ReloadEmptyTime  ) + 
        
        
    
     origin = .CurrentCamera.CFrame.Position
     (origin - head.Position).Magnitude >   origin = head.Position 
     best, bd
     _, t  ((F.AimBandits)) 
         d = (t.part.Position - origin).Magnitude
         d <= .(F.AuraRange  , cfg.Range  )  ( bd  d < bd)  (origin, t.part.Position, t.model) 
            best, bd = t, d
        
    
      best   
    auraLast = now
     aim = best.kind ==   (origin, best.part, cfg.TracerSpeed  )  best.part.Position
    GunFire:(tool, origin, (aim - origin).Unit)



 punchLast = 
  ()
      F.PunchAura   
     c = LP.Character
     h, r = (), ()
      c   h   r  h.SeatPart  c:()   
     .() - punchLast < (PunchConfig.Cooldown  ) +    
     reach = (PunchConfig.Range  ) - 
     _, z  (()) 
         p = (z, )
         p  (p.Position - r.Position).Magnitude <= reach 
            punchLast = .()
            Punch:((p.Position - .CurrentCamera.CFrame.Position).Unit)
            
        
    

(RunService.Heartbeat, ()
    (auraTick)
    (punchTick)
)



 CATS = { , , , , ,  }
 CAT_COLOR = {
    [] = .(, , ),
    [] = .(, , ),
    [] = .(, , ),
    [] = .(, , ),
    [] = .(, , ),
    [] = .(, , ),
}

 items = {}
  (m)  m:()  m:()  items[m] =   
 _, tag  ({ ,  }) 
     _, m  (CS:(tag))  (m) 
    (CS:(tag), addItem)


  (m)
     id = m:()
     id  ItemConfig  ItemConfig.Items[id]  {}

  (m)  (m).Use  m:() 
  (m)
     m:()    
     use = (m)
     m:()  m:() ==   use ==     
     use ==   use ==   use ==     
     use ==     
     use ==   use ==   m:()  m:()    
     

  (m)  (m).Name  m:()  m.Name 
  (m)
     m:()   m 
     m.PrimaryPart  m:(, )

  (m)
     m.Parent ~=   m:()  m:() ==    m:()


  (m)
     parts = {}
     k, v  (m:()) 
         k:(, ) ==   (v) ==   v >  
            parts[#parts + ] = .(, v, k:())
        
    
     #parts >   .(parts, )  


 itemTags = {}
  ()
     list = {}
     r = ()
     cats = F.ItemCats
     F.ItemESP  r  (cats) ==   #cats >  
         range = F.EspRange  
         found = {}
         m  (items) 
              m.Parent 
                items[m] = 
             (m) 
                 cat = (m)
                 (cats, cat) 
                     p = (m)
                     d = p  (p - r.Position).Magnitude
                     d  d <= range  found[#found + ] = { m = m, cat = cat, d = d } 
                
            
        
        .(found, (a, b)  a.d < b.d )
         i = , .(#found, ) 
             it = found[i]
             part = (it.m)
             part 
                 name = (it.m)
                 it.cat ==   name = name ..  .. (it.m) ..  
                list[#list + ] = {
                    key = it.m, part = part, color = CAT_COLOR[it.cat], offset = .(, , ),
                    text = .(, name, (it.d)),
                }
            
        
    
    (itemTags, list, )



  (m)
     p = (m)
      p    
     ok, granted = (Begin.InvokeServer, Begin, m, p.Position)
     ok    granted

  (m) (EndRemote.FireServer, EndRemote, m) 
  (m, cf)
     p = (m)
      p   
     m:() 
        m:(cf * p.CFrame:(m:()))
    
        p.CFrame = cf
    
    p.AssemblyLinearVelocity = .zero
    p.AssemblyAngularVelocity = .zero



 bringing = 
 taken = ({}, { __mode =  }) 
  (i)
     plane = ()
     floor = plane  plane:(, )
      floor   floor:()    
     col, row = (i - ) % , .((i - ) / ) % 
     floor.CFrame * .((col - ) * , floor.Size.Y /  + , (row - ) * ), floor


  ()
     bringing   
     r, h = (), ()
      r   h   
     h.SeatPart  ()  
     cats = F.BringCats
     (cats) ~=   #cats ==   ()  
     toCargo = F.BringTo == 
     toCargo   ()  ()  
    bringing = 
     start = r.CFrame
     list = {}
     m  (items) 
         m.Parent   taken[m]  (m)  (cats, (m)) 
             p = (m)
             d = p  (p.Position - start.Position).Magnitude
             plane = ()
             inPlane = plane  m:(plane)
             d  d >   d <= (F.BringRange  )   inPlane  list[#list + ] = { m = m, d = d } 
        
    
    .(list, (a, b)  a.d < b.d )
     got = 
     i = , .(#list, F.BringMax  ) 
         m = list[i].m
          alive   r.Parent   
         p = (m)
         p  (m) 
            taken[m] = 
            r.CFrame = .(p.Position + .(, , ))
            .()
             (m) 
                .()
                 dest, stand
                 toCargo 
                     spot, floor = (got + )
                    dest = spot
                    stand = .(floor.Position + floor.CFrame.ZVector *  + .(, , ))
                
                    stand = start
                    dest = start * .((got %  - ) * , -, -)
                
                 _ = ,  
                    r.CFrame = stand
                    (m, dest)
                    RunService.Heartbeat:()
                
                (m)
                got += 
            
            .()
        
    
     r.Parent  r.CFrame = start 
    bringing = 
    (got >   ( .. got .. )  )



 using = 
  (m, kind)
     use = (m).Use
     kind ==   use ==  
        
          m:()  (m:()  ) > 
    
     use == ({ eat = , drink = , heal =  })[kind]

  (kind)
     r, h = (), ()
      r   h    
     reach = h.SeatPart    (F.UseRange  )
     best, bd
     m  (items) 
         m.Parent  (m)   taken[m]  (m, kind) 
             p = (m)
             d = p  (p.Position - r.Position).Magnitude
             d  d <= reach  ( bd  d < bd)  best, bd = m, d 
        
    
      best    
     start = r.CFrame
     hop = bd >    h.SeatPart
     hop  r.CFrame = .((best).Position + .(, , )) .() 
     ok = (best)
     ok 
        .()
        (UseItem.InvokeServer, UseItem, best, {})
        .()
         best.Parent  best:() == LP.UserId 
             hop  r.Parent 
                 _ = ,   r.CFrame = start (best, start * .(, -, -)) RunService.Heartbeat:() 
            
            (best)
        
    
        taken[best] = 
    
     hop  r.Parent  r.CFrame = start 
     ok

 lastUse = 
  ()
     using  .() - lastUse <    
     h = ()
      h  h.Health <=    
     todo
     F.AutoHeal  h.Health / .(h.MaxHealth, ) *  < (F.HealAt  ) 
        todo = 
     F.AutoEat  (LP:()  ) < (F.EatAt  ) 
        todo = 
     F.AutoDrink  (LP:()  ) < (F.DrinkAt  ) 
        todo = 
    
      todo   
    using, lastUse = , .()
    (useNearest, todo)
    using = 


.(()
     alive 
        (survivalTick)
        .()
    
)



 zombieTags, banditTags, placeTags, planeTags, playerTags = {}, {}, {}, {}, {}
  ()
     r = ()
     cam = .CurrentCamera
     from = r  r.Position  cam.CFrame.Position
     range = F.EspRange  

     zl = {}
     F.ZombieESP 
         _, z  (()) 
             p = (z, )
             h = z:()
             d = p  (p.Position - from).Magnitude
             d  d <= range 
                zl[#zl + ] = { key = z, part = p, model = z, color = .(, , ),
                    text = .(, .(h.Health), .(h.MaxHealth), (d)) }
            
        
        .(zl, (a, b)  (a.part.Position - from).Magnitude < (b.part.Position - from).Magnitude )
         i = #zl, , -  zl[i] =  
    
    (zombieTags, zl, F.ZombieHighlight)

     bl = {}
     F.BanditESP 
         _, b  (()) 
             p = (b)
            bl[#bl + ] = { key = b, part = p, model = b, color = .(, , ), offset = .(, , ),
                text = .(, ((p.Position - from).Magnitude)) }
        
    
    (banditTags, bl, F.BanditESP)

     pl = {}
     F.PlaneESP 
         _, m  (()) 
             p = (m)
             fuel = m:()
            pl[#pl + ] = { key = m, part = p, color = .(, , ), offset = .(, , ),
                text = .(, (m), fuel  .(, .(fuel))  , ((p.Position - from).Magnitude)) }
        
    
    (planeTags, pl, )

     ll = {}
     locs = :()  .World:()
     F.PlaceESP  locs 
         _, l  (locs:()) 
             part = l:()  (l.PrimaryPart  l:(, ))  (l:()  l)
             part 
                ll[#ll + ] = { key = l, part = part, color = .(, , ), offset = .(, , ),
                    text = .(, l:()  l.Name, ((l:().Position - from).Magnitude)) }
            
        
    
    (placeTags, ll, )

     pp = {}
     F.PlayerESP 
         _, p  (Players:()) 
             hrp = p ~= LP  p.Character  p.Character:()
             hrp 
                pp[#pp + ] = { key = p, part = hrp, color = .(, , ),
                    text = .(, p.DisplayName, ((hrp.Position - from).Magnitude)) }
            
        
    
    (playerTags, pp, )


.(()
     alive 
        (updateEsp)
        (updateItemEsp)
        .()
    
)




 flying = 
(RunService.Heartbeat, (dt)
     r, h = (), ()
     F.SpeedBoost  r  h   h.SeatPart   flying  h.MoveDirection.Magnitude >  
        r.CFrame += h.MoveDirection * (F.SpeedAmount  ) * dt
    
     F.InfStamina 
         LP:() ~=   LP:(, ) 
        LP:(, )
    
)

(UIS.JumpRequest, ()
     h = ()
     F.InfJump  h   h.SeatPart  h:(.HumanoidStateType.Jumping) 
)


 flyVel, flyGyro
  ()
    flying = 
     flyVel  flyVel:() flyVel =  
     flyGyro  flyGyro:() flyGyro =  

(RunService.RenderStepped, ()
     r, h = (), ()
      F.Fly   r   h  h.SeatPart   flying  ()   
    flying = 
      flyVel  flyVel.Parent ~= r 
         flyVel  flyVel:() 
         flyGyro  flyGyro:() 
        flyVel = .()
        flyVel.MaxForce = .(, , )
        flyVel.Parent = r
        flyGyro = .()
        flyGyro.MaxTorque = .(, , )
        flyGyro.P = 
        flyGyro.Parent = r
    
     look = .CurrentCamera.CFrame.LookVector
     move = h.MoveDirection
     dir = move
     move.Magnitude >  
         fwd = (look)
         along = fwd.Magnitude >   move:(fwd.Unit)  
        dir = move + .(, look.Y * along, )
    
     UIS:(.KeyCode.Space)  dir += .yAxis 
     UIS:(.KeyCode.LeftControl)  dir -= .yAxis 
    flyVel.Velocity = dir.Magnitude >   dir.Unit * (F.FlySpeed  )  .zero
    flyGyro.CFrame = .(r.Position, r.Position + (look) + .(, , ))
)

 noclipped = {}
(RunService.Stepped, ()
     c = LP.Character
     F.Noclip  c 
         _, p  (c:()) 
             p:()  p.CanCollide 
                noclipped[p] = 
                p.CanCollide = 
            
        
     (noclipped) 
         p  (noclipped)   p.Parent  p.CanCollide =   
        noclipped = {}
    
)


 savedLight, savedFog
  ()
     atm = Lighting:()
     F.Fullbright 
        savedLight = savedLight  { Ambient = Lighting.Ambient, OutdoorAmbient = Lighting.OutdoorAmbient, Brightness = Lighting.Brightness, GlobalShadows = Lighting.GlobalShadows, ClockTime = Lighting.ClockTime }
        Lighting.Ambient = .(, , )
        Lighting.OutdoorAmbient = .(, , )
        Lighting.Brightness = 
        Lighting.GlobalShadows = 
     savedLight 
         k, v  (savedLight)   k ~=   (() Lighting[k] = v )  
        savedLight = 
    
     F.NoFog 
        savedFog = savedFog  { FogEnd = Lighting.FogEnd, FogStart = Lighting.FogStart, Density = atm  atm.Density, Haze = atm  atm.Haze }
        Lighting.FogEnd = 
        Lighting.FogStart = 
         atm  atm.Density =  atm.Haze =  
     savedFog 
        Lighting.FogEnd = savedFog.FogEnd
        Lighting.FogStart = savedFog.FogStart
         atm  savedFog.Density  atm.Density = savedFog.Density atm.Haze = savedFog.Haze 
        savedFog = 
    

 LIGHT_BIND = 
RunService:(LIGHT_BIND, .RenderPriority.Last.Value + , ()
     F.Fullbright  F.NoFog  savedLight  savedFog  (lightTick) 
)


 hiddenFx = {}
  ()
     F.NoWeather 
         gui = LP.PlayerGui:()
         gui  gui.Enabled  hiddenFx[gui] =  gui.Enabled =  
         _, name  ({ ,  }) 
             f = :(name)
             f 
                 _, d  (f:()) 
                     (d:()  d:()  d:())  d.Enabled 
                        hiddenFx[d] = 
                        d.Enabled = 
                    
                
            
        
     (hiddenFx) 
         d  (hiddenFx)  (() d.Enabled =  ) 
        hiddenFx = {}
    

.(()
     alive 
        (weatherTick)
        .()
    
)

(LP.Idled, ()
     F.AntiAfk 
         VU = :()
        VU:()
        VU:(.())
    
)



  ()
     out = {}
     locs = :()  .World:()
     r = ()
     locs 
         _, l  (locs:()) 
             name = l:()  l.Name
             d = r  (l:().Position - r.Position).Magnitude  
            out[#out + ] = { name = .(, name, (d)), inst = l, d = d }
        
    
    .(out, (a, b)  a.d < b.d )
     out

  ()
     t = {}
     _, p  (())  t[#t + ] = p.name 
     #t ==   t[] =  
     t

  ()
     r, h = (), ()
     h  h.SeatPart  ()  
     h  r

  (name)
     r = ()
      r   
     _, p  (()) 
         p.name == name 
            r.CFrame = .(p.inst:().Position + .(, , ))
            
        
    
    ()

  (m)
     r = ()
     pr = (m)
      r   
      pr  ()  
    r.CFrame = .(pr.Position + pr.CFrame.ZVector *  + .(, , ))




  (plane, grip)
     target = plane
     plane:() ~=  
         _, d  (plane:()) 
             d:() ==   target = d  
        
    
     ok, granted, info = (Begin.InvokeServer, Begin, target, grip)
      ok   granted   
     rel = (info) ==   (info.gripRel) ==   info.gripRel
     target, rel  (plane).CFrame:(grip)



  ()
     r = ()
     plane = ()
     pr = (plane)
      r   pr   
     pr.CFrame.YVector.Y >   ()  
     grip = pr.Position + .(, , )
    r.CFrame = .(grip + (-pr.CFrame.ZVector).Unit *  + .(, , ))
    .()
     target, rel = (plane, grip)
      target  ()  
     t0 = .()
     alive  .() - t0 <   pr.CFrame.YVector.Y <  
         up = pr.CFrame.YVector
         axis = up:(.yAxis)
         axis.Magnitude <   axis = -pr.CFrame.XVector  
        UpdateRemote:(target, { Hold = pr.CFrame:(rel) + .(, , ), Spin = axis.Unit *  })
        .()
    
    (target)




Window = FeatherLite:({ Title = , Folder = , Key = .KeyCode.RightShift })
 gates = {}
  (test, els) gates[#gates + ] = { test = test, els = els } 


     tab = Window:({ Name = , Icon =  })
     plane = tab:()
    plane:({ Name = , Callback = () ((()))  })
    plane:({ Name = , Description = , Callback = () .(unflip)  })



     tab = Window:({ Name = , Icon =  })
     aim = tab:()
    aim:({ Name = , Flag = , Default = ,
        Description =  })
    (, {
        aim:({ Name = , Flag = , Default =  }),
        aim:({ Name = , Flag = , Default =  }),
        aim:({ Name = , Flag = , Default =  }),
        aim:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  }),
    })
    aim:({ Name = , Flag = , Default = ,
        Description =  })

     aura = tab:({ Name = , Description =  })
    aura:({ Name = , Flag = , Default = ,
        Description =  })
    (, {
        aura:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  }),
    })
    aura:({ Name = , Flag = , Default = ,
        Description =  })

     guns = tab:()
    guns:({ Name = , Flag = , Default =  })
    guns:({ Name = , Flag = , Default =  })
    guns:({ Name = , Flag = , Default = , Description =  })
    guns:({ Name = , Flag = , Default =  })
    guns:({ Name = , Flag = , Default =  })
    guns:({ Name = , Flag = , Default =  })
    (, {
        guns:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  }),
    })

     planeGuns = tab:()
    planeGuns:({ Name = , Flag = , Default = ,
        Description =  })
    (, {
        planeGuns:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  }),
    })
    planeGuns:({ Name = , Flag = , Default = ,
        Description =  })



     tab = Window:({ Name = , Icon =  })
     enemies = tab:()
    enemies:({ Name = , Flag = , Default =  })
    (, {
        enemies:({ Name = , Flag = , Default =  }),
    })
    enemies:({ Name = , Flag = , Default =  })
    enemies:({ Name = , Flag = , Default =  })

     world = tab:()
    world:({ Name = , Flag = , Default = , Description =  })
    world:({ Name = , Flag = , Default = , Description =  })
    world:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  })

     look = tab:()
    look:({ Name = , Flag = , Default = , Description =  })
    look:({ Name = , Flag = , Default =  })
    look:({ Name = , Flag = , Default = , Description =  })



     tab = Window:({ Name = , Icon =  })
     esp = tab:()
    esp:({ Name = , Flag = , Default =  })
    (, {
        esp:({ Name = , Flag = , Options = CATS, Multi = ,
            Default = { , , ,  } }),
    })

     bring = tab:({ Name = , Description =  })
    bring:({ Name = , Flag = , Options = CATS, Multi = , Default = { ,  } })
    bring:({ Name = , Flag = , Options = { ,  }, Default =  })
    bring:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  })
    bring:({ Name = , Flag = , Min = , Max = , Step = , Default =  })
    bring:({ Name = , Callback = () .(bringItems)  })

     survive = tab:({ Name = , Description =  })
    survive:({ Name = , Flag = , Default =  })
    (, { survive:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  }) })
    survive:({ Name = , Flag = , Default = , Description =  })
    (, { survive:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  }) })
    survive:({ Name = , Flag = , Default =  })
    (, { survive:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  }) })
    survive:({ Name = , Flag = , Min = , Max = , Step = , Default = , Suffix =  })



     tab = Window:({ Name = , Icon =  })
     move = tab:()
    move:({ Name = , Flag = , Default =  })
    move:({ Name = , Flag = , Default =  })
    (, {
        move:({ Name = , Flag = , Min = , Max = , Step = , Default =  }),
    })
    move:({ Name = , Flag = , Default =  })
    move:({ Name = , Flag = , Default = ,
        Description =  })
    (, {
        move:({ Name = , Flag = , Min = , Max = , Step = , Default =  }),
    })
    move:({ Name = , Flag = , Default =  })



     tab = Window:({ Name = , Icon =  })
     places = tab:({ Name = , Description =  })
     list = places:({ Name = , Flag = , Options = (), Default = ()[] })
    places:({ Name = , Callback = ()
         names = ()
        list:(names)
        list:(names[])
     })
    places:({ Name = , Callback = () (F.Place)  })

     planes = tab:({ Name = , Description =  })
      ()
         t = {}
         _, m  (())  t[#t + ] = m.Name 
         #t ==   t[] =  
         t
    
     pList = planes:({ Name = , Flag = , Options = (), Default = ()[] })
    planes:({ Name = , Callback = ()
         names = ()
        pList:(names)
        pList:(names[])
     })
    planes:({ Name = , Callback = () (:(F.OtherPlane  ))  })



     tab = Window:({ Name = , Icon =  })
     misc = tab:()
    misc:({ Name = , Flag = , Default = , Description =  })
     community = tab:()
    community:({ Title = , Text =  })
    (community, notify)


.(()
     alive 
         _, g  (gates) 
             onNow = F[g.test] == 
             _, el  (g.els) 
                 el  el.SetLocked  (el.Locked == ) == onNow  (el.SetLocked, el,  onNow) 
            
        
        (applyGunMods)
        .()
    
)

  oldNamecall  () 


  ()
      alive   
    alive = 
     _, c  (conns)  (c.Disconnect, c) 
    (RunService.UnbindFromRenderStep, RunService, LIGHT_BIND)
    hooks = {}
     oldNamecall  (, , , oldNamecall) 
    ()
    ()
     p  (noclipped)   p.Parent  p.CanCollide =   
     d  (hiddenFx)  (() d.Enabled =  ) 
     savedLight   k, v  (savedLight)   k ~=   (() Lighting[k] = v )   
     atm = Lighting:()
     savedFog 
        Lighting.FogEnd = savedFog.FogEnd
        Lighting.FogStart = savedFog.FogStart
         atm  savedFog.Density  atm.Density = savedFog.Density atm.Haze = savedFog.Haze 
    
    (espRoot.Destroy, espRoot)
    (fovGui.Destroy, fovGui)

G.FeatherLongFlight.stop = () () (Window.Unload, Window) 
Window:(stop)