artic silent aim

().Arctic = {
    SilentAim = {
        Enabled = ,
        KeybindEnabled = ,
        Keybind = ,
        Predict = ,
        Prediction = ,
        AimPart = ,
        LegitMode = , 
    },
    AimAssist = {
        Enabled = ,
        Keybind = ,
        Predict = ,
        Prediction = ,
        Smoothness = ,
        Aimpart = ,
        LegitMode = ,
        DisableOnEnemyDeath = ,
        DisableOnOwnDeath = ,
        Shake = {
            Enabled = ,
            Strength = 
        },
    },
    FOV = {
        SilentAim = {
            ShowFOV = ,
            KeybindEnabled = ,
            Keybind = ,
            Filled = ,
            FOV = ,
            NumSides = ,
            Color = .(, , ),
            Thickness = ,
            Transparency = 
        },
        AimAssist = {
            Enabled = ,
            ShowFOV = ,
            KeybindEnabled = ,
            Keybind = ,
            Filled = ,
            FOV = ,
            NumSides = ,
            Color = .(, , ),
            Thickness = ,
            Transparency = 
        }
    },
    Checks = {
        KOCheck = ,
        WallCheck = ,
        CrewCheck = ,
        FriendCheck = ,
        VelocityCheck = 
    },
    GunFOV = {
        Enabled = ,
        DoubleBarrel = ,
        Revolver = ,
        Shotgun = ,
        TacticalShotgun = ,
        Smg = ,
        Rifle = ,
        Silencer = ,
        SilencerAR = ,
        Glock = ,
        AK47 = ,
        AR = 
    },
    Customize = {
        HitChance = {
            Enabled = ,
            GroundHitChance = ,
            AirHitChance = 
        },
        Prediction = {
            Enabled = ,
            GroundPrediction = ,
            AirPrediction = 
        },
        Smoothness = {
            Enabled = ,
            GroundSmoothness = ,
            AirSmoothness = 
        },
        Shake = {
            Enabled = ,
            GroundShake = ,
            AirShake = 
        }
    },
    RangeManagement = {
        Enabled = ,
        Type = , 
        Close = {
            CloseDetection = ,
            CloseFOV = ,
            ClosePrediction = 
        },
        Mid = {
            MidDetection = ,
            MidFOV = ,
            MidPrediction = 
        },
        Far = {
            FarDetection = ,
            FarFOV = ,
            FarPrediction = 
        },
        ReallyFar = {
            ReallyFarDetection = .huge,
            ReallyFarFOV = ,
            ReallyFarPrediction = 
        }
    },
    Resolver = {
        Enabled = ,
        KeybindEnabled = ,
        Keybind = 
    },
    Chat = {
        Enabled = , 
        FOV = ,
        Prediction = ,
        HitChance = ,
    },
    AutoPrediction = {
        ComingSoon = ,


    },
    HitSound = {
        ComingSoon = , 


    }
}



 Players = :()
 Client = :().LocalPlayer
 Mouse = :().LocalPlayer:()
 RunService = :()
 Camera = :().CurrentCamera
 Ping = :().Network.ServerStatsItem[]:()
 SilentAimFOV = .()
 AimAssistFOV = .()
 SilentAimTarget
 AimAssistTarget

SilentAimFOV.Color = ().Arctic.FOV.SilentAim.Color
SilentAimFOV.Thickness = ().Arctic.FOV.SilentAim.Thickness
SilentAimFOV.Filled = ().Arctic.FOV.SilentAim.Filled
SilentAimFOV.Transparency = ().Arctic.FOV.SilentAim.Transparency
SilentAimFOV.NumSides = ().Arctic.FOV.SilentAim.NumSides

AimAssistFOV.Color = ().Arctic.FOV.AimAssist.Color
AimAssistFOV.Thickness = ().Arctic.FOV.AimAssist.Thickness
AimAssistFOV.Filled = ().Arctic.FOV.AimAssist.Filled
AimAssistFOV.Transparency = ().Arctic.FOV.AimAssist.Transparency
AimAssistFOV.NumSides = ().Arctic.FOV.AimAssist.NumSides

 UpdateFOV = ()
      SilentAimFOV  AimAssistFOV 
         SilentAimFOV  AimAssistFOV
    
    SilentAimFOV.Visible = ().Arctic.FOV.SilentAim.ShowFOV
    SilentAimFOV.Radius = ().Arctic.FOV.SilentAim.FOV * 
    SilentAimFOV.Position = .(Mouse.X, Mouse.Y + (:():().Y))

    AimAssistFOV.Visible = ().Arctic.FOV.AimAssist.ShowFOV
    AimAssistFOV.Radius = ().Arctic.FOV.AimAssist.FOV * 
    AimAssistFOV.Position = .(Mouse.X, Mouse.Y + (:():().Y))
     SilentAimFOV  AimAssistFOV

RunService.Heartbeat:(UpdateFOV)

 grmt = ()
 backupindex = grmt.__index
(grmt, )
grmt.__index = ((self, v)
     (().Arctic.SilentAim.Enabled  Mouse  (v) == ) 
         SilentAimTarget  SilentAimTarget.Character 
             ().Arctic.SilentAim.Predict 
                 endpoint = .Players[(SilentAimTarget)].Character[().Arctic.SilentAim.AimPart]
                                     .CFrame +
                                     (.Players[(SilentAimTarget)].Character[().Arctic.SilentAim.AimPart]
                                         .Velocity * ().Arctic.SilentAim.Prediction)
                 ((v) ==   endpoint)
            
                 endpoint = .Players[(SilentAimTarget)].Character[().Arctic.SilentAim.AimPart]
                                     .CFrame
                 ((v) ==   endpoint)
            
        
    
     (self, v)
)

 WorldToScreenPoint = (Object)
     ObjectVector = Camera:(Object.Position)
     .(ObjectVector.X, ObjectVector.Y)

 IsOnScreen = (Object)
     IsOnScreen = Camera:(Object.Position)
     IsOnScreen

 NoMeshPart = (Object)
     .(Object.Name, ) 
        
    
     .({, , }, Object.ClassName) 
         
    

 WallCheck = (destination, ignore)
     Origin = Camera.CFrame.p
     CheckRay = Ray.(Origin, destination - Origin)
     Hit = .workspace:(CheckRay, ignore)
     Hit == 

 PlayerMouseFunction = ()
     Target, Closest = ,  / 
     _, v  (Players:()) 
         ().Arctic.Checks.WallCheck 
             (v.Character  v ~= Client  v.Character:()) 
                 Position, OnScreen = Camera:(v.Character.HumanoidRootPart.Position)
                 Distance = (.(Position.X, Position.Y) - .(Mouse.X, Mouse.Y)).Magnitude

                 (SilentAimFOV.Radius > Distance  Distance < Closest  OnScreen) 
                    (v.Character.HumanoidRootPart.Position, {Client, v.Character}) 
                    Closest = Distance
                    Target = v
                
            
        
             (v.Character  v ~= Client  v.Character:()) 
                 Position, OnScreen = Camera:(v.Character.HumanoidRootPart.Position)
                 Distance = (.(Position.X, Position.Y) - .(Mouse.X, Mouse.Y)).Magnitude

                 (SilentAimFOV.Radius > Distance  Distance < Closest  OnScreen) 
                    Closest = Distance
                    Target = v
                
            
        
    
     Target

 PlayerMouseFunction2 = ()
     Target, Closest = , AimAssistFOV.Radius * 
     _, v  (Players:()) 
         (v.Character  v ~= Client  v.Character:()) 
             ().Arctic.Checks.WallCheck 
                 Position, OnScreen = Camera:(v.Character.HumanoidRootPart.Position)
                 Distance = (.(Position.X, Position.Y) - .(Mouse.X, Mouse.Y)).Magnitude
                 (Distance < Closest  OnScreen) 
                    (v.Character.HumanoidRootPart.Position, {Client, v.Character}) 
                    Closest = Distance
                    Target = v
                
            
                 Position, OnScreen = Camera:(v.Character.HumanoidRootPart.Position)
                 Distance = (.(Position.X, Position.Y) - .(Mouse.X, Mouse.Y)).Magnitude
                 (Distance < Closest  OnScreen) 
                    Closest = Distance
                    Target = v
                
            
        
    
     Target

 BodyPartFunction = (character)
     ClosestDistance =  / 
     BodyPart = 
     (character  character:()) 
         _, x  , character:() 
             (x)  (x) 
                 Distance = ((x) - .(Mouse.X, Mouse.Y)).Magnitude
                 (SilentAimFOV.Radius > Distance  Distance < ClosestDistance) 
                    ClosestDistance = Distance
                    BodyPart = x
                
            
        
    
     BodyPart

 BodyPartFunction2 = (character)
     ClosestDistance =  / 
     BodyPart = 

     (character  character:()) 
         _, x  , character:() 
             (x)  (x) 
                 Distance = ((x) - .(Mouse.X, Mouse.Y)).Magnitude
                 (Distance < ClosestDistance) 
                    ClosestDistance = Distance
                    BodyPart = x
                
            
        
    
     BodyPart

.(()
     .() 
         ().Arctic.SilentAim.Enabled 
            SilentAimTarget = ()
        
         AimAssistTarget 
             ().Arctic.AimAssist.Enabled  (AimAssistTarget.Character) 
                ().Arctic.AimAssist.LegitMode 
                ().Arctic.AimAssist.Aimpart = ((AimAssistTarget.Character))
            
        
         SilentAimTarget 
             ().Arctic.SilentAim.Enabled  (SilentAimTarget.Character) 
                ().Arctic.SilentAim.LegitMode 
                ().Arctic.SilentAim.AimPart = ((SilentAimTarget.Character))
            
        
    
)
Mouse.KeyDown:((Key)
     ().Arctic.FOV.SilentAim.KeybindEnabled 
         (Key == ().Arctic.FOV.SilentAim.Keybind:()) 
             ().Arctic.FOV.SilentAim.ShowFOV ==  
                ().Arctic.FOV.SilentAim.ShowFOV = 
            
                ().Arctic.FOV.SilentAim.ShowFOV = 
            
             ().Arctic.FOV.AimAssist.KeybindEnabled 
                 (Key == ().Arctic.FOV.AimAssist.Keybind:()) 
                     ().Arctic.FOV.AimAssist.ShowFOV ==  
                        ().Arctic.FOV.AimAssist.ShowFOV = 
                    
                        ().Arctic.FOV.AimAssist.ShowFOV = 
                    
                
                 ().Arctic.SilentAim.KeybindEnabled 
                     (Key == ().Arctic.SilentAim.Keybind:()) 
                         ().Arctic.SilentAim.Enabled ==  
                            ().Arctic.SilentAim.Enabled = 
                        
                            ().Arctic.SilentAim.Enabled = 
                        
                    
                
            
        
         (Key == ().Arctic.AimAssist.Keybind:()) 
             ().Arctic.AimAssist.Enabled ==  
                IsTargetting =  IsTargetting
                 IsTargetting 
                    AimAssistTarget = ()
                
                     AimAssistTarget ~=  
                        AimAssistTarget = 
                        IsTargetting = 
                    
                
            
        
    
     ().Arctic.Resolver.KeybindEnabled 
         (Key == ().Arctic.Resolver.Keybind:()) 
             ().Arctic.Resolver.Enabled ==  
                ().Arctic.Resolver.Enabled = 
            
                ().Arctic.Resolver.Enabled = 
            
        
    
)
 ().Arctic.Checks.CrewCheck 
      
         newPlayer = .Players.PlayerAdded:()
         player:(newPlayer.Group) 
            .(Ignored.Players, newPlayer)
        
    

 ().Arctic.Checks.FriendCheck 
    .Players.PlayerAdded:((SilentAimTarget)
         Client:(SilentAimTarget) 
             newPlayer = .Players.PlayerAdded:()
            .(Ignored.Players, newPlayer)
        
    )


RunService.Heartbeat:(()
     ().Arctic.SilentAim.Enabled 
         SilentAimTarget  SilentAimTarget.Character  SilentAimTarget.Character:(().Arctic.SilentAim.AimPart) 
             ().Arctic.Resolver.Enabled ==  
            SilentAimTarget.Character:().Velocity.magnitude >  
                (()
                     TargetVel = SilentAimTarget.Character[().Arctic.SilentAim.AimPart]
                    TargetVel.Velocity = .(, , )
                    TargetVel.AssemblyLinearVelocity = .(, , )
                )
            
             ().Arctic.Checks.VelocityCheck ==   SilentAimTarget.Character:() ==
                .HumanoidStateType.Freefall 
                (()
                     TargetVelv5 = SilentAimTarget.Character[().Arctic.SilentAim.AimPart]
                    TargetVelv5.Velocity = .(TargetVelv5.Velocity.X, (TargetVelv5.Velocity.Y * ),
                        TargetVelv5.Velocity.Z)
                    TargetVelv5.AssemblyLinearVelocity = .(TargetVelv5.Velocity.X,
                        (TargetVelv5.Velocity.Y * ), TargetVelv5.Velocity.Z)
                )
            
             ().Arctic.Resolver.Enabled ==  
                (()
                     TargetVelv2 = SilentAimTarget.Character[().Arctic.SilentAim.AimPart]
                    TargetVelv2.Velocity = .(TargetVelv2.Velocity.X, , TargetVelv2.Velocity.Z)
                    TargetVelv2.AssemblyLinearVelocity = .(TargetVelv2.Velocity.X, , TargetVelv2.Velocity.Z)
                )
            
        
    
)
().Extra = {
    [] = (().Arctic.GunFOV.Enabled),
    [] = {
        [] = (().Arctic.GunFOV.DoubleBarrel)
    },
    [] = {
        [] = (().Arctic.GunFOV.DoubleBarrel)
    },
    [] = {
        [] = (().Arctic.GunFOV.Revolver)
    },
    [] = {
        [] = (().Arctic.GunFOV.Smg)
    },
    [] = {
        [] = (().Arctic.GunFOV.Shotgun)
    },
    [] = {
        [] = (().Arctic.GunFOV.TacticalShotgun)
    },
    [] = {
        [] = (().Arctic.GunFOV.Rifle)
    },
    [] = {
        [] = (().Arctic.GunFOV.Silencer)
    },
    [] = {
        [] = (().Arctic.GunFOV.SilencerAR)
    },
    [] = {
        [] = (().Arctic.GunFOV.Glock)
    },
    [] = {
        [] = (().Arctic.GunFOV.AK47)
    },
    [] = {
        [] = (().Arctic.GunFOV.AR)
    }
}

 Script = {
    Functions = {}
}
Script.Functions.getToolName = (name)
     split = .(.(name, )[], )[]
     split

Script.Functions.getEquippedWeaponName = ()
     (Client.Character)  Client.Character:() 
         Tool = Client.Character:()
         .(Tool.Name, )  .(Tool.Name, )   .(Tool.Name, ) 
             .(Tool.Name, ) 
             Script.Functions.(Tool.Name)
        
    
     

RunService.RenderStepped:(()
     ().Arctic.SilentAim.Enabled 
         ().Arctic.Checks.KOCheck ==   SilentAimTarget  SilentAimTarget.Character 
             KOd = SilentAimTarget.Character:()[].Value
             Grabbed = SilentAimTarget.Character:() ~= 
             KOd  Grabbed 
                SilentAimTarget = 
            
        
    
     ().Arctic.AimAssist.Enabled ==  
         ().Arctic.Checks.KOCheck ==   AimAssistTarget  AimAssistTarget.Character 
             KOd = AimAssistTarget.Character:()[].Value
             Grabbed = AimAssistTarget.Character:() ~= 
             KOd  Grabbed 
                AimAssistTarget = 
                IsTargetting = 
            
        
    
     ().Arctic.AimAssist.DisableOnEnemyDeath ==   AimAssistTarget 
    AimAssistTarget.Character:() 
         AimAssistTarget.Character.Humanoid.health <  
            AimAssistTarget = 
            IsTargetting = 
        
    
     ().Arctic.AimAssist.DisableOnOwnDeath ==   AimAssistTarget 
    AimAssistTarget.Character:() 
         Client.Character.Humanoid.health <  
            AimAssistTarget = 
            IsTargetting = 
        
    
     ().Arctic.FOV.AimAssist.Enabled ==   AimAssistTarget  AimAssistTarget.Character 
    AimAssistTarget.Character:() 
         AimAssistFOV.Radius < (.(Camera:(AimAssistTarget.Character.HumanoidRootPart.Position).X,
            Camera:(AimAssistTarget.Character.HumanoidRootPart.Position).Y) - .(Mouse.X, Mouse.Y)).Magnitude 
                AimAssistTarget = 
            IsTargetting = 
        
    
     ().Arctic.AimAssist.Predict  AimAssistTarget  AimAssistTarget.Character 
    AimAssistTarget.Character:(().Arctic.AimAssist.Aimpart) 
         ().Arctic.AimAssist.Shake.Enabled 
             Main = .(Camera.CFrame.p,
            AimAssistTarget.Character[().Arctic.AimAssist.Aimpart].Position +
                AimAssistTarget.Character[().Arctic.AimAssist.Aimpart].Velocity *
                    ().Arctic.AimAssist.Prediction +
                    .(.(-().Arctic.AimAssist.Shake.Strength,
                        ().Arctic.AimAssist.Shake.Strength), .(
                        -().Arctic.AimAssist.Shake.Strength,
                        ().Arctic.AimAssist.Shake.Strength), .(
                        -().Arctic.AimAssist.Shake.Strength,
                        ().Arctic.AimAssist.Shake.Strength)) * )
            Camera.CFrame = Camera.CFrame:(Main, ().Arctic.AimAssist.Smoothness / ,
                .EasingStyle.Elastic, .EasingDirection.InOut, .EasingStyle.Sine, .EasingDirection.Out)
        
             Main = .(Camera.CFrame.p,
            AimAssistTarget.Character[().Arctic.AimAssist.Aimpart].Position +
                AimAssistTarget.Character[().Arctic.AimAssist.Aimpart].Velocity *
                    ().Arctic.AimAssist.Prediction)
            Camera.CFrame = Camera.CFrame:(Main, ().Arctic.AimAssist.Smoothness / ,
                .EasingStyle.Elastic, .EasingDirection.InOut, .EasingStyle.Sine, .EasingDirection.Out)
        
     ().Arctic.AimAssist.Predict ==   AimAssistTarget  AimAssistTarget.Character 
    AimAssistTarget.Character:(().Arctic.AimAssist.Aimpart) 
         ().Arctic.AimAssist.Shake.Enabled 
             Main = .(Camera.CFrame.p,
            AimAssistTarget.Character[().Arctic.AimAssist.Aimpart].Position +
                    .(.(-().Arctic.AimAssist.Shake.Strength,
                        ().Arctic.AimAssist.Shake.Strength), .(
                        -().Arctic.AimAssist.Shake.Strength,
                        ().Arctic.AimAssist.Shake.Strength), .(
                        -().Arctic.AimAssist.Shake.Strength,
                        ().Arctic.AimAssist.Shake.Strength)) * )
            Camera.CFrame = Camera.CFrame:(Main, ().Arctic.AimAssist.Smoothness / ,
                .EasingStyle.Elastic, .EasingDirection.InOut, .EasingStyle.Sine, .EasingDirection.Out)
        
             Main =
                .(Camera.CFrame.p, AimAssistTarget.Character[().Arctic.AimAssist.Aimpart].Position)
            Camera.CFrame = Camera.CFrame:(Main, ().Arctic.AimAssist.Smoothness / ,
                .EasingStyle.Elastic, .EasingDirection.InOut, .EasingStyle.Sine, .EasingDirection.Out)
        
    
     Script.Functions.() ~=  
         WeaponSettings = ().Extra[Script.Functions.()]
         WeaponSettings ~=   ().Arctic.GunFOV.Enabled ==  
            ().Arctic.FOV.SilentAim.FOV = WeaponSettings.FOV
        
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.FOV.SilentAim.FOV
        
    
      ().Arctic.RangeManagement.Enabled  ().Arctic.RangeManagement.Type ==   Client ~=  
        (Client.Character)  SilentAimTarget  SilentAimTarget.Character 
         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Close.CloseDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.Close.CloseFOV
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.Close.ClosePrediction

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Mid.MidDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.Mid.MidFOV
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.Mid.MidPrediction

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Far.FarDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.Far.FarFOV
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.Far.FarPrediction

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.ReallyFar.ReallyFarDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.ReallyFar.ReallyFarFOV
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.ReallyFar.ReallyFarPrediction

        
    
     ().Arctic.RangeManagement.Enabled  ().Arctic.RangeManagement.Type ==   Client ~=  
        (Client.Character)  SilentAimTarget  SilentAimTarget.Character 
         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Close.CloseDetection 
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.Close.ClosePrediction

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Mid.MidDetection 
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.Mid.MidPrediction

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Far.FarDetection 
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.Far.FarPrediction

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.ReallyFar.ReallyFarDetection 
            ().Arctic.SilentAim.Prediction = ().Arctic.RangeManagement.ReallyFar.ReallyFarPrediction

        
    
     ().Arctic.RangeManagement.Enabled  ().Arctic.RangeManagement.Type ==   Client ~=  
        (Client.Character)  SilentAimTarget  SilentAimTarget.Character 
         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Close.CloseDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.Close.CloseFOV

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Mid.MidDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.Mid.MidFOV

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.Far.FarDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.Far.FarFOV

         (Client.Character.HumanoidRootPart.Position - SilentAimTarget.Character.HumanoidRootPart.Position).Magnitude <
            ().Arctic.RangeManagement.ReallyFar.ReallyFarDetection 
            ().Arctic.FOV.SilentAim.FOV = ().Arctic.RangeManagement.ReallyFar.ReallyFarFOV

        
    
)
 ().Arctic.Customize.HitChance.Enabled 
     SilentAimTarget.Character.Humanoid.FloorMaterial == .Material.Air 
        ().Arctic.SilentAim.HitChance = ().Arctic.Customize.HitChance.AirHitChance
    
        ().Arctic.SilentAim.HitChance = ().Arctic.Customize.HitChance.GroundHitChance
    

 ().Arctic.Customize.Prediction.Enabled 
     SilentAimTarget.Character.Humanoid.FloorMaterial == .Material.Air 
        ().Arctic.SilentAim.Prediction = ().Arctic.Customize.Prediction.AirPrediction
    
        ().Arctic.SilentAim.Prediction = ().Arctic.Customize.Prediction.GroundPrediction
    

 ().Arctic.Customize.Smoothness.Enabled 
     AimAssistTarget.Character.Humanoid.FloorMaterial == .Material.Air 
        ().Arctic.AimAssist.Smoothness = ().Arctic.Customize.Smoothness.AirSmoothness
    
        ().Arctic.AimAssist.Smoothness = ().Arctic.Customize.Smoothness.GroundSmoothness
    

 ().Arctic.Customize.Shake.Enabled 
     AimAssistTarget.Character.Humanoid.FloorMaterial == .Material.Air 
        ().Arctic.AimAssist.Shake.Strength = ().Arctic.Customize.Shake.AirShake
    
        ().Arctic.AimAssist.Shake.Strength = ().Arctic.Customize.Shake.GroundShake
    

Client.Chatted:((message)
     ().Arctic.Chat.Enabled 
         args = .(message, )
         args[] == ().Arctic.Chat.FOV  args[] ~=  
            ().Arctic.FOV.SilentAim.FOV = (args[])
        
    
     ().Arctic.Chat.Enabled 
         args = .(message, )
         args[] == ().Arctic.Chat.Prediction  args[] ~=  
            ().Arctic.SilentAim.Prediction = (args[])
        
    
     ().Arctic.Chat.Enabled 
         args = .(message, )
         args[] == ().Arctic.Chat.HitChance  args[] ~=  
            ().Arctic.SilentAim.HitChance = (args[])
        
    
)