insanity launcher

--Converted with ttyyuu12345's model to script plugin v4
function sandbox(var,func)
	local env = getfenv(func)
	local newenv = setmetatable({},{
		__index = function(self,k)
			if k=="script" then
				return var
			else
				return env[k]
			end
		end,
	})
	setfenv(func,newenv)
	return func
end
cors = {}
mas = Instance.new("Model",game:GetService("Lighting"))
Tool0 = Instance.new("Tool")
ManualWeld1 = Instance.new("ManualWeld")
ManualWeld2 = Instance.new("ManualWeld")
ParticleEmitter3 = Instance.new("ParticleEmitter")
ParticleEmitter4 = Instance.new("ParticleEmitter")
PointLight5 = Instance.new("PointLight")
LocalScript6 = Instance.new("LocalScript")
IntValue7 = Instance.new("IntValue")
Folder8 = Instance.new("Folder")
ScreenGui9 = Instance.new("ScreenGui")
Frame10 = Instance.new("Frame")
Frame11 = Instance.new("Frame")
ImageLabel12 = Instance.new("ImageLabel")
ImageLabel13 = Instance.new("ImageLabel")
TextLabel14 = Instance.new("TextLabel")
Frame15 = Instance.new("Frame")
TextLabel16 = Instance.new("TextLabel")
Frame17 = Instance.new("Frame")
ImageLabel18 = Instance.new("ImageLabel")
ImageLabel19 = Instance.new("ImageLabel")
Frame20 = Instance.new("Frame")
Frame21 = Instance.new("Frame")
LocalScript22 = Instance.new("LocalScript")
ImageLabel23 = Instance.new("ImageLabel")
Frame24 = Instance.new("Frame")
Frame25 = Instance.new("Frame")
TextLabel26 = Instance.new("TextLabel")
TextLabel27 = Instance.new("TextLabel")
Frame28 = Instance.new("Frame")
Frame29 = Instance.new("Frame")
ImageLabel30 = Instance.new("ImageLabel")
TextLabel31 = Instance.new("TextLabel")
TextLabel32 = Instance.new("TextLabel")
Frame33 = Instance.new("Frame")
ImageLabel34 = Instance.new("ImageLabel")
TextLabel35 = Instance.new("TextLabel")
TextLabel36 = Instance.new("TextLabel")
Frame37 = Instance.new("Frame")
TextLabel38 = Instance.new("TextLabel")
Frame39 = Instance.new("Frame")
Frame40 = Instance.new("Frame")
Frame41 = Instance.new("Frame")
Frame42 = Instance.new("Frame")
Frame43 = Instance.new("Frame")
Frame44 = Instance.new("Frame")
Frame45 = Instance.new("Frame")
Frame46 = Instance.new("Frame")
Frame47 = Instance.new("Frame")
Frame48 = Instance.new("Frame")
Frame49 = Instance.new("Frame")
Frame50 = Instance.new("Frame")
Frame51 = Instance.new("Frame")
Frame52 = Instance.new("Frame")
Frame53 = Instance.new("Frame")
Frame54 = Instance.new("Frame")
Frame55 = Instance.new("Frame")
Frame56 = Instance.new("Frame")
Frame57 = Instance.new("Frame")
Frame58 = Instance.new("Frame")
Frame59 = Instance.new("Frame")
Frame60 = Instance.new("Frame")
Frame61 = Instance.new("Frame")
Frame62 = Instance.new("Frame")
Frame63 = Instance.new("Frame")
Frame64 = Instance.new("Frame")
TextLabel65 = Instance.new("TextLabel")
TextLabel66 = Instance.new("TextLabel")
TextLabel67 = Instance.new("TextLabel")
Frame68 = Instance.new("Frame")
TextLabel69 = Instance.new("TextLabel")
Frame70 = Instance.new("Frame")
TextLabel71 = Instance.new("TextLabel")
TextLabel72 = Instance.new("TextLabel")
TextLabel73 = Instance.new("TextLabel")
TextLabel74 = Instance.new("TextLabel")
TextLabel75 = Instance.new("TextLabel")
ImageLabel76 = Instance.new("ImageLabel")
TextLabel77 = Instance.new("TextLabel")
Frame78 = Instance.new("Frame")
ImageLabel79 = Instance.new("ImageLabel")
TextLabel80 = Instance.new("TextLabel")
Frame81 = Instance.new("Frame")
TextLabel82 = Instance.new("TextLabel")
Frame83 = Instance.new("Frame")
TextLabel84 = Instance.new("TextLabel")
Frame85 = Instance.new("Frame")
TextLabel86 = Instance.new("TextLabel")
Frame87 = Instance.new("Frame")
TextLabel88 = Instance.new("TextLabel")
ImageLabel89 = Instance.new("ImageLabel")
NumberValue90 = Instance.new("NumberValue")
ManualWeld91 = Instance.new("ManualWeld")
ManualWeld92 = Instance.new("ManualWeld")
ManualWeld93 = Instance.new("ManualWeld")
ManualWeld94 = Instance.new("ManualWeld")
ManualWeld95 = Instance.new("ManualWeld")
ManualWeld96 = Instance.new("ManualWeld")
Script97 = Instance.new("Script")
ObjectValue98 = Instance.new("ObjectValue")
RemoteFunction99 = Instance.new("RemoteFunction")
RemoteFunction100 = Instance.new("RemoteFunction")
RemoteFunction101 = Instance.new("RemoteFunction")
RemoteEvent102 = Instance.new("RemoteEvent")
RemoteFunction103 = Instance.new("RemoteFunction")
RemoteFunction104 = Instance.new("RemoteFunction")
RemoteFunction105 = Instance.new("RemoteFunction")
LocalScript106 = Instance.new("LocalScript")
IntValue107 = Instance.new("IntValue")
RemoteEvent108 = Instance.new("RemoteEvent")
RemoteEvent109 = Instance.new("RemoteEvent")
RemoteEvent110 = Instance.new("RemoteEvent")
RemoteEvent111 = Instance.new("RemoteEvent")
ManualWeld112 = Instance.new("ManualWeld")
ManualWeld113 = Instance.new("ManualWeld")
ManualWeld114 = Instance.new("ManualWeld")
ManualWeld115 = Instance.new("ManualWeld")
ManualWeld116 = Instance.new("ManualWeld")
Part117 = Instance.new("Part")
Weld118 = Instance.new("Weld")
Weld119 = Instance.new("Weld")
Weld120 = Instance.new("Weld")
BlockMesh121 = Instance.new("BlockMesh")
ManualWeld122 = Instance.new("ManualWeld")
Part123 = Instance.new("Part")
BlockMesh124 = Instance.new("BlockMesh")
Sound125 = Instance.new("Sound")
Weld126 = Instance.new("Weld")
Weld127 = Instance.new("Weld")
Weld128 = Instance.new("Weld")
ManualWeld129 = Instance.new("ManualWeld")
ManualWeld130 = Instance.new("ManualWeld")
IntValue131 = Instance.new("IntValue")
ManualWeld132 = Instance.new("ManualWeld")
IntValue133 = Instance.new("IntValue")
IntValue134 = Instance.new("IntValue")
ManualWeld135 = Instance.new("ManualWeld")
ManualWeld136 = Instance.new("ManualWeld")
Tool0.Name = "Insanity"
Tool0.Parent = mas
Tool0.TextureId = "http://www.roblox.com/asset/?id=77444324"
Tool0.GripForward = Vector3.new(-0.191044495, 0.0976709872, -0.976709962)
Tool0.GripPos = Vector3.new(-0.200000003, -0.300000012, 0.300000012)
Tool0.GripRight = Vector3.new(0.98158133, 0.0190096367, -0.190096363)
Tool0.GripUp = Vector3.new(0, 0.995037258, 0.0995037258)
ManualWeld1.Name = "BoltBack-to-Bolt Strong Joint"
ManualWeld1.Parent = mas
ManualWeld1.C0 = CFrame.new(-0.450000018, 0.0100000892, 0.25, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld1.C1 = CFrame.new(0.450003594, 0.0100708008, -0.249998927, 0.999999166, 7.22828054e-06, -8.8044224e-05, 8.78973151e-05, 0.000205219825, 0.999999464, 9.66867265e-06, -0.999997675, 0.000210978149)
ManualWeld1.Part0 = nil
ManualWeld1.Part1 = nil
ManualWeld2.Name = "BoltBack-to-Bolt Strong Joint"
ManualWeld2.Parent = mas
ManualWeld2.C0 = CFrame.new(0.450000018, -0.0100000892, 0.25, 1, 0, 0, 0, 0, -1, 0, 1, 0)
ManualWeld2.C1 = CFrame.new(0.450000823, -0.0100708008, 0.250036597, 1, -2.19845751e-05, -4.36113027e-07, -4.35721603e-07, 1.78050032e-05, -1, 2.19845842e-05, 1, 1.78049941e-05)
ManualWeld2.Part0 = nil
ManualWeld2.Part1 = nil
ParticleEmitter3.Name = "1FlashFX[Smoke]"
ParticleEmitter3.Parent = mas
ParticleEmitter3.Transparency = NumberSequence.new(0.60000002384186,1)
ParticleEmitter3.Rotation = NumberRange.new(0, 360)
ParticleEmitter3.Size = NumberSequence.new(0.99999964237213,3)
ParticleEmitter3.Color = ColorSequence.new(Color3.new(0.27451, 0.27451, 0.27451),Color3.new(0.27451, 0.27451, 0.27451))
ParticleEmitter3.Enabled = false
ParticleEmitter3.LightEmission = 0.10000000149012
ParticleEmitter3.Texture = "http://www.roblox.com/asset/?id=244514423"
ParticleEmitter3.Lifetime = NumberRange.new(1.25, 1.5)
ParticleEmitter3.Rate = 100
ParticleEmitter3.RotSpeed = NumberRange.new(10, 10)
ParticleEmitter3.Speed = NumberRange.new(5, 7)
ParticleEmitter3.VelocitySpread = 15
ParticleEmitter3.Color = ColorSequence.new(Color3.new(0.27451, 0.27451, 0.27451),Color3.new(0.27451, 0.27451, 0.27451))
ParticleEmitter4.Name = "FlashFX[Flash]"
ParticleEmitter4.Parent = mas
ParticleEmitter4.Transparency = NumberSequence.new(0.75,1)
ParticleEmitter4.Rotation = NumberRange.new(0, 90)
ParticleEmitter4.Color = ColorSequence.new(Color3.new(1, 1, 0.498039),Color3.new(1, 1, 0.498039))
ParticleEmitter4.Enabled = false
ParticleEmitter4.LightEmission = 1
ParticleEmitter4.Texture = "http://www.roblox.com/asset/?id=3419963"
ParticleEmitter4.Lifetime = NumberRange.new(0.10000000149012, 0.10000000149012)
ParticleEmitter4.Rate = 1000
ParticleEmitter4.Speed = NumberRange.new(50, 50)
ParticleEmitter4.Color = ColorSequence.new(Color3.new(1, 1, 0.498039),Color3.new(1, 1, 0.498039))
PointLight5.Name = "FlashFX[Light]"
PointLight5.Parent = mas
PointLight5.Color = Color3.new(1, 1, 0.498039)
PointLight5.Enabled = false
PointLight5.Brightness = 10
PointLight5.Range = 6
PointLight5.Shadows = true
PointLight5.Color = Color3.new(1, 1, 0.498039)
LocalScript6.Name = "clientMain"
LocalScript6.Parent = Tool0
table.insert(cors,sandbox(LocalScript6,function()
--[[
Kit By TurboFusion
Remake By MuYhEt & Xander521
--]]
--------------------------------------------------------------------------------------
--------------------[ CHARACTER LOADING ]---------------------------------------------
--------------------------------------------------------------------------------------

repeat wait() until game.Players.LocalPlayer.Character
repeat wait() until game.Players.LocalPlayer.Character:IsDescendantOf(game.Workspace)
wait(1 / 20)

--------------------------------------------------------------------------------------
--------------------[ IGNORE MODEL ]--------------------------------------------------
--------------------------------------------------------------------------------------

local ignoreCode = script:WaitForChild("ignoreCode")

repeat wait() until ignoreCode.Value ~= 0

local ignoreModel = game.Workspace:WaitForChild("ignoreModel_"..ignoreCode.Value)

local grenadeFolder = ignoreModel:WaitForChild("grenadeFolder")

--------------------------------------------------------------------------------------
--------------------[ CONSTANTS ]-----------------------------------------------------
--------------------------------------------------------------------------------------

local Gun = script.Parent
local serverMain = Gun:WaitForChild("serverMain")
local Handle = Gun:WaitForChild("Handle")
local AimPart = Gun:WaitForChild("AimPart")
local Main = Gun:WaitForChild("Main")

local Ammo = Gun:WaitForChild("Ammo")
local ClipSize = Gun:WaitForChild("ClipSize")
local StoredAmmo = Gun:WaitForChild("StoredAmmo")

local createTweenIndicator = serverMain:WaitForChild("createTweenIndicator")
local deleteTweenIndicator = serverMain:WaitForChild("deleteTweenIndicator")
local getWeldCF = serverMain:WaitForChild("getWeldCF")
local gunSetup = serverMain:WaitForChild("gunSetup")
local lerpCF = serverMain:WaitForChild("lerpCF")
local createBlood = serverMain:WaitForChild("createBlood")
local createBulletImpact = serverMain:WaitForChild("createBulletImpact")
local createShockwave = serverMain:WaitForChild("createShockwave")
local createTrail = serverMain:WaitForChild("createTrail")

local Particle = require(script:WaitForChild("Particle"))
local Spring = require(script:WaitForChild("Spring"))
local Anims = require(Gun:WaitForChild("ANIMATIONS"))
local Plugins = require(Gun:WaitForChild("PLUGINS"))
local S = require(Gun:WaitForChild("SETTINGS"))

local Player = game.Players.LocalPlayer
local Char = Player.Character
local Humanoid = Char:WaitForChild("Humanoid")
local Torso = Char:WaitForChild("Torso")
local Head = Char:WaitForChild("Head")
local HRP = Char:WaitForChild("HumanoidRootPart")
local Root = HRP:WaitForChild("RootJoint")

local Neck = Torso:WaitForChild("Neck")

local LArm = Char:WaitForChild("Left Arm")
local RArm = Char:WaitForChild("Right Arm")
local LLeg = Char:WaitForChild("Left Leg")
local RLeg = Char:WaitForChild("Right Leg")

local M2 = Player:GetMouse()

local mainGUI = script:WaitForChild("mainGUI")

local crossHair = mainGUI:WaitForChild("crossHair")
local HUD = mainGUI:WaitForChild("HUD")
local Scope = mainGUI:WaitForChild("Scope")
local fireSelect = mainGUI:WaitForChild("fireSelect")
local hitMarker = mainGUI:WaitForChild("hitMarker")
local Sens = mainGUI:WaitForChild("Sens")

local crossA = crossHair:WaitForChild("A"):WaitForChild("Line")
local crossB = crossHair:WaitForChild("B"):WaitForChild("Line")
local crossC = crossHair:WaitForChild("C"):WaitForChild("Line")
local crossD = crossHair:WaitForChild("D"):WaitForChild("Line")

local Controls = HUD:WaitForChild("Controls")

local gunNameTitle = HUD:WaitForChild("gunName"):WaitForChild("Title")

local scopeMain = Scope:WaitForChild("Main")
local scopeSteady = Scope:WaitForChild("Steady")

local fireModes = fireSelect:WaitForChild("Modes")

local modeGUI = HUD:WaitForChild("Mode"):WaitForChild("Main")
local clipAmmoGUI = HUD:WaitForChild("Ammo"):WaitForChild("Clip")
local storedAmmoGUI = HUD:WaitForChild("Ammo"):WaitForChild("Stored")

local DS = game:GetService("Debris")
local CP = game:GetService("ContentProvider")
local RS = game:GetService("RunService")
local UIS = game:GetService("UserInputService")

local Cam = game.Workspace.CurrentCamera

local ABS, HUGE, FLOOR, CEIL = math.abs, math.huge, math.floor, math.ceil
local RAD, SIN, COS, TAN = math.rad, math.sin, math.cos, math.tan
local VEC2, V3 = Vector2.new, Vector3.new
local CF, CFANG = CFrame.new, CFrame.Angles
local INSERT = table.insert

local maxStamina = S.sprintTime * 60
local maxSteadyTime = S.scopeSettings.steadyTime * 60

local LethalIcons = {
	"http://www.roblox.com/asset/?id=194849880";
	"http://www.roblox.com/asset/?id=195727791";
	"http://www.roblox.com/asset/?id=195728137";
	"http://www.roblox.com/asset/?id=218151830";
}

local TacticalIcons = {
	"http://www.roblox.com/asset/?id=195728473";
	"http://www.roblox.com/asset/?id=195728693";
}

local ASCII = {
	071; 117; 110; 032;
	075; 105; 116; 032;
	115; 099; 114; 105;
	112; 116; 101; 100;
	032; 098; 121; 032;
	084; 117; 114; 098;
	111; 070; 117; 115;
	105; 111; 110; 000;
}

local Ignore = {
	Char;
	ignoreModel;
}

local Shoulders = {
	Right = Torso:WaitForChild("Right Shoulder");
	Left = Torso:WaitForChild("Left Shoulder")
}

local armC0 = {
	CF(-1.5, 0, 0) * CFANG(RAD(90), 0, 0);
	CF(1.5, 0, 0) * CFANG(RAD(90), 0, 0);
}

local legC0 = {
	Stand = {
		CF(-0.5, -2, 0);
		CF(0.5, -2, 0);
	};
	Crouch = {
		CF(-0.5, -1.5, 0.5) * CFANG(-RAD(90), 0, 0);
		CF(0.5, -1, -0.75);
	};
	Prone = {
		CF(-0.5, -2, 0);
		CF(0.5, -2, 0);
	};
}

local Sine = function(X)
	return SIN(RAD(X))
end

local Linear = function(X)
	return (X / 90)
end

--------------------------------------------------------------------------------------
--------------------[ VARIABLES ]-----------------------------------------------------
--------------------------------------------------------------------------------------

local Selected = false

local playerMass = 0

local Forward = false
local Backward = false

local Idling = false
local Walking = false
local Running = false

local crawlCamRot = 0
local crawlAlpha = 0
local idleAlpha = 1
local walkAlpha = 0
local isCrawling = false
local isIdling = false
local isWalking = false
local isRunning = false

local Aimed = false
local Aiming = false
local aimAlpha = 0
local headOffset = VEC2(COS(RAD(90) - S.aimSettings.headTilt) * 0.5, 1 + SIN(RAD(90) - S.aimSettings.headTilt) * 0.5)

local Reloading = false
local breakReload = false
local magVisible = true
local newMag = false

local Knifing = false

local MB1Down = false
local Firing = false
local canFire = true
local fireFunction = nil
local firstShot = false
local shotCount = 0
local lastSideRecoil = {0, 0}
local recoilAnim = {
	Pos = V3();
	Rot = V3();
	Code = nil;
}

local numModes = 0
local rawFireMode = 1
local canSelectFire = true
local guiAngOffset = 0
local Modes = {}

local onGround = true
local startFallHeight = 0
local jumpAnim = {
	Pos = 0;
	Rot = 0;
	Code = 0;
}

local runReady = true
local runKeyPressed = false
local chargingStamina = false

local AimingIn = false
local AimingOut = false

local Stamina = S.sprintTime * 60
local currentSteadyTime = S.scopeSettings.steadyTime * 60

local camSteady = false
local takingBreath = false
local steadyKeyPressed = false

local Grip = nil
local aimedGripCF = nil

local spreadZoom = "unAimed"
local spreadStance = "Stand"
local spreadMotion = "Idling"
local baseSpread = S.spreadSettings.unAimed.Stand.Idling
local currentSpread = 0
local loweringSpread = false

local mouseSensitivity = S.sensitivitySettings.Default
local aimSensitivity = S.sensitivitySettings.Aim
local lastSensUpdate = 0

local ammoInClip = 0

local Stance = 0
local stanceSway = 1
local camSway = 1

local camAng = VEC2()

local armTilt = 0
local moveAng = 0
local animCode = 0

local desiredXOffset = 0
local desiredYOffset = 0
local currentXOffset = 0
local currentYOffset = 0
local aimHeadOffset = 0
local recoilAnimMultiplier = 1
local jumpAnimMultiplier = 1
local translationDivisor = 7
local rotationMultiplier = S.momentumSettings.Amplitude.unAimed
local armTiltMultiplier = 1

local equipAnimPlaying = false

local crossOffset = 0

local camOffsets = {
	guiScope = {
		Rot = V3();
	};
	Reload = {
		Rot = V3();
		Code = nil;
	};
	Recoil = {
		Rot = V3();
		Code = nil;
	};
}

local Anim = {
	Pos = V3();
	Rot = V3();
	Ang = 0;
	Code = 0;
}

local lastBeat = 0

local gunParts = {}

local Connections = {}

local Keys = {}

--------------------------------------------------------------------------------------
--------------------[ PRE-LOADING ]---------------------------------------------------
--------------------------------------------------------------------------------------

CP:Preload(S.explosionSettings.soundId)
CP:Preload(S.holeSettings.Texture)
CP:Preload(S.sparkSettings.Texture)
CP:Preload(S.smokeSettings.Texture)
CP:Preload(S.bloodSettings.Texture)
CP:Preload("http://www.roblox.com/asset/?id=126877530") --The dark green arrow in the select fire gui
CP:Preload("http://www.roblox.com/asset/?id=55754953") --The circle in the select fire gui

--------------------------------------------------------------------------------------
--------------------[ GUN SETUP ]-----------------------------------------------------
--------------------------------------------------------------------------------------

serverMain:WaitForChild("Plyr").Value = Player

local gunMomentum = Spring.new(V3())
gunMomentum.s = S.momentumSettings.Speed
gunMomentum.d = S.momentumSettings.Damper

local gunRecoilSpring = Spring.new(V3())
gunRecoilSpring.s = S.recoilSettings.springSpeed
gunRecoilSpring.d = S.recoilSettings.springDamper

local camRecoilSpring = Spring.new(V3())
camRecoilSpring.s = 35
camRecoilSpring.d = 0.5

local crossSpring = Spring.new(V3(crossOffset + (baseSpread + currentSpread) * 50, 0, 0))
crossSpring.s = 20
crossSpring.d = 0.75

--[[local function getModelMass(P)
	for _, v in pairs(P:GetChildren()) do
		if v:IsA("BasePart") then
			playerMass = playerMass + v:GetMass()
		end
		getModelMass(v)
	end
end
getModelMass(Char)

Char.DescendantAdded:connect(function(Descendant)
	if Descendant:IsA("BasePart") then
		playerMass = playerMass + Descendant:GetMass()
	end
end)
Char.DescendantRemoving:connect(function(Descendant)
	if Descendant:IsA("BasePart") then
		playerMass = playerMass - Descendant:GetMass()
	end
end)]]

--------------------------------------------------------------------------------------
--------------------[ WELD CFRAMES ]--------------------------------------------------
--------------------------------------------------------------------------------------

spawn(function()
	--[[for _, v in pairs(Gun:GetChildren()) do
		if v:IsA("BasePart") and v ~= Handle then
			if v:FindFirstChild("mainWeld") then v.mainWeld:Destroy() end
			if (not v:FindFirstChild("weldCF")) then
				local weldCF = Instance.new("CFrameValue")
				weldCF.Name = "weldCF"
				weldCF.Value = Handle.CFrame:toObjectSpace(v.CFrame)
				weldCF.Parent = v
				INSERT(gunParts, {Obj = v, Weld = nil})
			end
			if string.sub(v.Name, 1, 3) == "Mag" then
				if (not v:FindFirstChild("magTrans")) then
					local magTrans = Instance.new("NumberValue")
					magTrans.Name = "magTrans"
					magTrans.Value = v.Transparency
					magTrans.Parent = v
				end
			end
			v.Anchored = false
		end
	end
	Handle.Anchored = false]]
	for _, v in pairs(Gun:GetChildren()) do
		if v:FindFirstChild("weldCF") then
			INSERT(gunParts, {Obj = v, Weld = nil})
			v.Anchored = false
		end
	end
end)

--------------------------------------------------------------------------------------
--------------------[ MAIN PROGRAM ]--------------------------------------------------
--------------------------------------------------------------------------------------

--------------------[ ARM CREATION FUNCTION ]-----------------------------------------

function createArms()
	local Arms = {}
	for i = 0, 1 do
		local armModel = Instance.new("Model")
		armModel.Name = "armModel"

		local Arm = Instance.new("Part")
		Arm.BrickColor = (S.fakeArmSettings.realBodyColor and (i == 0 and LArm.BrickColor or RArm.BrickColor) or S.fakeArmSettings.Color)
		Arm.Transparency = S.fakeArmSettings.Transparency
		Arm.Name = "Arm"
		Arm.CanCollide = false
		Arm.Size = V3(0.598, 2, 0.598)
		Arm.Parent = armModel
		local armMesh = Instance.new("SpecialMesh")
		armMesh.MeshId = "rbxasset://fonts//leftarm.mesh"
		armMesh.MeshType = Enum.MeshType.FileMesh
		armMesh.Scale = V3(0.598, 1, 0.598)
		armMesh.Parent = Arm

		local Glove1 = Instance.new("Part")
		Glove1.BrickColor = BrickColor.new("Black")
		Glove1.Name = "Glove1"
		Glove1.CanCollide = false
		Glove1.Size = V3(0.598, 2, 0.598)
		Glove1.Parent = armModel
		local glove1Mesh = Instance.new("SpecialMesh")
		glove1Mesh.MeshId = "rbxasset://fonts//leftarm.mesh"
		glove1Mesh.Offset = V3(0, -0.5, 0)
		glove1Mesh.Scale = V3(0.658, 0.205, 0.658)
		glove1Mesh.Parent = Glove1
		local glove1Weld = Instance.new("Weld")
		glove1Weld.Part0 = Arm
		glove1Weld.Part1 = Glove1
		glove1Weld.Parent = Arm

		local Glove2 = Instance.new("Part")
		Glove2.BrickColor = BrickColor.new("Black")
		Glove2.Name = "Glove2"
		Glove2.CanCollide = false
		Glove2.Size = V3(0.598, 2, 0.598)
		Glove2.Parent = armModel
		local glove2Mesh = Instance.new("SpecialMesh")
		glove2Mesh.MeshId = "rbxasset://fonts//leftarm.mesh"
		glove2Mesh.Offset = V3(0, -0.435, 0)
		glove2Mesh.Scale = V3(0.69, 0.105, 0.69)
		glove2Mesh.Parent = Glove2
		local glove2Weld = Instance.new("Weld")
		glove2Weld.Part0 = Arm
		glove2Weld.Part1 = Glove2
		glove2Weld.Parent = Arm

		local Glove3 = Instance.new("Part")
		Glove3.BrickColor = BrickColor.new("Black")
		Glove3.Name = "Glove3"
		Glove3.CanCollide = false
		Glove3.Size = V3(0.598, 2, 0.598)
		Glove3.Parent = armModel
		local glove3Mesh = Instance.new("SpecialMesh")
		glove3Mesh.MeshId = "rbxasset://fonts//leftarm.mesh"
		glove3Mesh.Offset = V3(0.18 * ((i * 2) - 1), -0.7, 0)
		glove3Mesh.Scale = V3(0.299, 0.305, 0.657)
		glove3Mesh.Parent = Glove3
		local glove3Weld = Instance.new("Weld")
		glove3Weld.Part0 = Arm
		glove3Weld.Part1 = Glove3
		glove3Weld.Parent = Arm

		local Sleeve1 = Instance.new("Part")
		Sleeve1.BrickColor = BrickColor.new("Sand green")
		Sleeve1.Name = "Sleeve1"
		Sleeve1.CanCollide = false
		Sleeve1.Size = V3(0.598, 2, 0.598)
		Sleeve1.Parent = armModel
		local sleeve1Mesh = Instance.new("SpecialMesh")
		sleeve1Mesh.MeshId = "rbxasset://fonts//leftarm.mesh"
		sleeve1Mesh.Offset = V3(0, 0.75, 0)
		sleeve1Mesh.Scale = V3(0.656, 0.3, 0.656)
		sleeve1Mesh.Parent = Sleeve1
		local sleeve1Weld = Instance.new("Weld")
		sleeve1Weld.Part0 = Arm
		sleeve1Weld.Part1 = Sleeve1
		sleeve1Weld.Parent = Arm

		local Sleeve2 = Instance.new("Part")
		Sleeve2.BrickColor = BrickColor.new("Sand green")
		Sleeve2.Name = "Sleeve2"
		Sleeve2.CanCollide = false
		Sleeve2.Size = V3(0.598, 2, 0.598)
		Sleeve2.Parent = armModel
		local sleeve2Mesh = Instance.new("SpecialMesh")
		sleeve2Mesh.MeshId = "rbxasset://fonts//leftarm.mesh"
		sleeve2Mesh.Offset = V3(0, 0.55, 0)
		sleeve2Mesh.Scale = V3(0.75, 0.1, 0.75)
		sleeve2Mesh.Parent = Sleeve2
		local sleeve2Weld = Instance.new("Weld")
		sleeve2Weld.Part0 = Arm
		sleeve2Weld.Part1 = Sleeve2
		sleeve2Weld.Parent = Arm

		table.insert(Arms, {Model = armModel, armPart = Arm})
	end
	return Arms
end

--------------------[ MATH FUNCTIONS ]------------------------------------------------

function Map(Val, fromLow, fromHigh, toLow, toHigh)
	return (Val - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow
end

function numLerp(A, B, Alpha)
	return A + (B - A) * Alpha
end

function RAND(Min, Max, Accuracy)
	return numLerp(Min, Max, math.random())
	--[[local Inverse = 1 / (Accuracy or 1)
	return (math.random(Min * Inverse, Max * Inverse) / Inverse)]]
end

function Round(Num, toNearest)
	return math.floor(Num / toNearest + 0.5) * toNearest
end

function getNearestPoint(A, B, Origin)
	local A2 = (A - Origin).magnitude
	local B2 = (B - Origin).magnitude
	return (math.min(A2, B2) == A2 and A or B)
end

--------------------[ TWEEN FUNCTIONS ]-----------------------------------------------

function tweenJoint(Joint, newC0, newC1, Alpha, Duration)
	spawn(function()
		local newCode = math.random(-1e9, 1e9) --This creates a random code between -1000000000 and 1000000000
		local tweenIndicator = nil
		if (not Joint:findFirstChild("tweenCode")) then --If the joint isn't being tweened, then
			tweenIndicator = Instance.new("IntValue")
			tweenIndicator.Name = "tweenCode"
			tweenIndicator.Value = newCode
			tweenIndicator.Parent = Joint
		else
			tweenIndicator = Joint.tweenCode
			tweenIndicator.Value = newCode --If the joint is already being tweened, this will change the code, and the tween loop will stop
		end
		--local tweenIndicator = createTweenIndicator:InvokeServer(Joint, newCode)
		if Duration <= 0 then --If the duration is less than or equal to 0 then there's no need for a tweening loop
			if newC0 then Joint.C0 = newC0 end
			if newC1 then Joint.C1 = newC1 end
		else
			local startC0 = Joint.C0
			local startC1 = Joint.C1
			local t0 = tick()
			while true do
				RS.RenderStepped:wait() --This makes the for loop step every 1/60th of a second
				local X = math.min((tick() - t0) / Duration, 1) * 90
				if tweenIndicator.Value ~= newCode then break end --This makes sure that another tween wasn't called on the same joint
				if (not Selected) then break end --This stops the tween if the tool is deselected
				if newC0 then Joint.C0 = startC0:lerp(newC0, Alpha(X)) end
				if newC1 then Joint.C1 = startC1:lerp(newC1, Alpha(X)) end
				--if newC0 then lerpCF:InvokeServer(Joint, "C0", startC0, newC0, Alpha(X)) end
				--if newC1 then lerpCF:InvokeServer(Joint, "C1", startC1, newC1, Alpha(X)) end
				if X == 90 then break end
			end
		end
		if tweenIndicator.Value == newCode then --If this tween functions was the last one called on a joint then it will remove the code
			tweenIndicator:Destroy()
		end
		--deleteTweenIndicator:InvokeServer(tweenIndicator, newCode)
	end)
end

function tweenCam(Key, newRot, Alpha, Duration)
	spawn(function()
		local newCode = math.random(-1e9, 1e9)
		camOffsets[Key].Code = newCode

		local Increment = 1.5 / Duration
		local prevRot = camOffsets[Key].Rot
		local X = 0
		while true do
			RS.RenderStepped:wait()
			local newX = X + Increment
			X = (newX > 90 and 90 or newX)
			if camOffsets[Key].Code ~= newCode then break end
			if (not Selected) then break end

			camOffsets[Key].Rot = prevRot:lerp(newRot, Alpha(X))

			if X == 90 then break end
		end

		if camOffsets[Key].Code == newCode then
			camOffsets[Key].Code = nil
		end
	end)
end

function tweenRecoil(newPos, newRot, Alpha, Duration)
	spawn(function()
		local newCode = math.random(-1e9, 1e9)
		recoilAnim.Code = newCode

		local Increment = 1.5 / Duration
		local prevPos = recoilAnim.Pos
		local prevRot = recoilAnim.Rot
		local X = 0
		while true do
			RS.RenderStepped:wait()
			local newX = X + Increment
			X = (newX > 90 and 90 or newX)
			if recoilAnim.Code ~= newCode then break end
			if (not Selected) then break end

			recoilAnim.Pos = prevPos:lerp(newPos, Alpha(X))
			recoilAnim.Rot = prevRot:lerp(newRot, Alpha(X))

			if X == 90 then break end
		end

		if recoilAnim.Code == newCode then
			recoilAnim.Code = nil
		end
	end)
end

--------------------[ GUI UPDATE FUNCTIONS ]------------------------------------------

local function updateClipAmmo()
	clipAmmoGUI.Text = Ammo.Value
	clipAmmoGUI.TextColor3 = (Ammo.Value <= (ClipSize.Value / 3) and Color3.new(1, 0, 0) or Color3.new(1, 1, 1))
end

local function updateStoredAmmo()
	storedAmmoGUI.Text = StoredAmmo.Value
	storedAmmoGUI.TextColor3 = (StoredAmmo.Value <= (ClipSize.Value * 2) and Color3.new(1, 0, 0) or Color3.new(1, 1, 1))
end

local function updateHealth()
	HUD.Health.Num.Text = CEIL(Humanoid.Health).."%"
	HUD.Health.Num.TextColor3 = (
		(Humanoid.Health > 200 / 3) and Color3.new(1, 1, 1) or
		(Humanoid.Health <= 200 / 3 and Humanoid.Health > 100 / 3) and Color3.new(1, 1, 0) or
		(Humanoid.Health <= 100 / 3) and Color3.new(1, 0, 0)
	)
end

local function updateModeLabels(prevState, newState, X)
	for Num, Mode in pairs(fireModes:GetChildren()) do
		local guiAngOffset2 = guiAngOffset + 90
		local Ang = numLerp(
			(guiAngOffset2 * prevState) - (guiAngOffset2 * Num) - guiAngOffset2,
			(guiAngOffset2 * newState) - (guiAngOffset2 * Num) - guiAngOffset2,
			Sine(X)
		) + guiAngOffset
		local XPos = COS(RAD(Ang))
		local YPos = SIN(RAD(Ang))
		Mode.Position = UDim2.new(0.5, XPos * 100, 0.5, YPos * 100)

		local R = COS(math.atan2(Mode.Position.Y.Offset, Mode.Position.X.Offset) + RAD(90))
		Mode.Label.TextTransparency = 1 - ((R / 4) + 0.75)

		local Scale = (R * 10) + 50
		Mode.Label.Position = UDim2.new(0, -Scale / 2, 0, 0)
		Mode.Label.Size = UDim2.new(0, Scale, 0, Scale / 2)
	end
end

--------------------[ GUI SETUP FUNCTION ]--------------------------------------------

function convertKey(Key)
	if Key == string.char(8) then
		return "BKSPCE"
	elseif Key == string.char(9) then
		return "TAB"
	elseif Key == string.char(13) then
		return "ENTER"
	elseif Key == string.char(17) then
		return "UP"
	elseif Key == string.char(18) then
		return "DOWN"
	elseif Key == string.char(19) then
		return "RIGHT"
	elseif Key == string.char(20) then
		return "LEFT"
	elseif Key == string.char(22) then
		return "HOME"
	elseif Key == string.char(23) then
		return "END"
	elseif Key == string.char(27) then
		return "F2"
	elseif Key == string.char(29) then
		return "F4"
	elseif Key == string.char(30) then
		return "F5"
	elseif Key == string.char(32) or Key == " " then
		return "F7"
	elseif Key == string.char(33) or Key == "!" then
		return "F8"
	elseif Key == string.char(34) or Key == '"' then
		return "F9"
	elseif Key == string.char(35) or Key == "#" then
		return "F10"
	elseif Key == string.char(37) or Key == "%" then
		return "F12"
	elseif Key == string.char(47) or Key == "/" then
		return "R-SHIFT"
	elseif Key == string.char(48) or Key == "0" then
		return "L-SHIFT"
	elseif Key == string.char(49) or Key == "1" then
		return "R-CTRL"
	elseif Key == string.char(50) or Key == "2" then
		return "L-CTRL"
	elseif Key == string.char(51) or Key == "3" then
		return "R-ALT"
	elseif Key == string.char(52) or Key == "4" then
		return "L-ALT"
	else
		return string.upper(Key)
	end
end

function createControlFrame(Key, Desc, Num)
	local C = Instance.new("Frame")
	C.BackgroundTransparency = ((Num % 2) == 1 and 0.7 or 1)
	C.BorderSizePixel = 0
	C.Name = "C"..Num
	C.Position = UDim2.new(0, 0, 0, Num * 20)
	C.Size = UDim2.new(1, 0, 0, 20)
	C.ZIndex = 10

	local K = Instance.new("TextLabel")
	K.BackgroundTransparency = 1
	K.Name = "Key"
	K.Size = UDim2.new(0, 45, 1, 0)
	K.ZIndex = 10
	K.Font = Enum.Font.ArialBold
	K.FontSize = Enum.FontSize.Size14
	K.Text = Key
	K.TextColor3 = Color3.new(1, 1, 1)
	K.TextScaled = (string.len(Key) > 5)
	K.TextWrapped = (string.len(Key) > 5)
	K.Parent = C

	local D = Instance.new("TextLabel")
	D.BackgroundTransparency = 1
	D.Name = "Desc"
	D.Position = UDim2.new(0, 50, 0, 0)
	D.Size = UDim2.new(1, -50, 1, 0)
	D.ZIndex = 10
	D.Font = Enum.Font.SourceSansBold
	D.FontSize = Enum.FontSize.Size14
	D.Text = "- "..Desc
	D.TextColor3 = Color3.new(1, 1, 1)
	D.TextXAlignment = Enum.TextXAlignment.Left
	D.Parent = C

	C.Parent = Controls
end

function createModes()
	numModes = 0
	for i, v in pairs(S.selectFireSettings.Modes) do
		if v then
			numModes = numModes + 1
		end
	end

	local currentMode = 0
	for i, v in pairs(S.selectFireSettings.Modes) do
		if v then
			local Frame = Instance.new("Frame")
			Frame.BackgroundTransparency = 1
			Frame.Name = currentMode
			Frame.Position = UDim2.new()
			Frame.Size = UDim2.new()
			Frame.Parent = fireModes
			local modeLabel = Instance.new("TextLabel")
			modeLabel.BackgroundTransparency = 1
			modeLabel.Name = "Label"
			modeLabel.Position = UDim2.new(0, -20, 0, 0)
			modeLabel.Size = UDim2.new(0, 40, 0, 20)
			modeLabel.Font = Enum.Font.SourceSansBold
			modeLabel.FontSize = Enum.FontSize.Size18
			modeLabel.Text = string.upper(i)
			modeLabel.TextColor3 = Color3.new(1, 1, 1)
			modeLabel.TextScaled = true
			modeLabel.TextStrokeTransparency = 0
			modeLabel.TextTransparency = 0.5
			modeLabel.TextWrapped = true
			modeLabel.Parent = Frame
			table.insert(Modes, string.upper(i))
			currentMode = currentMode + 1
		end
	end

	guiAngOffset = -15 * (numModes ^ 3) + 150 * (numModes ^ 2) - 525 * numModes + 660
end

function setUpGUI()
	local currentNum = 1

	for _, v in pairs(Controls:GetChildren()) do
		if v.Name ~= "Title" then
			v:Destroy()
		end
	end

	for _, PTable in pairs(Plugins.KeyDown) do
		createControlFrame(convertKey(PTable.Key), PTable.Description, currentNum)
		currentNum = currentNum + 1
	end

	if S.canChangeStance then
		local Dive = (S.dolphinDive and " / Dive" or "")
		createControlFrame(convertKey(S.Keys.lowerStance), "Lower Stance"..Dive, currentNum)
		currentNum = currentNum + 1

		createControlFrame(convertKey(S.Keys.raiseStance), "Raise Stance", currentNum)
		currentNum = currentNum + 1
	end

	if S.selectFire then
		createControlFrame(convertKey(S.Keys.selectFire), "Select Fire", currentNum)
		currentNum = currentNum + 1
	end

	createControlFrame(convertKey(S.Keys.Reload), "Reload", currentNum)
	currentNum = currentNum + 1

	createControlFrame(convertKey(S.Keys.Sprint), "Sprint", currentNum)
	currentNum = currentNum + 1

	if S.canADS then
		local Hold = (S.aimSettings.holdToADS and "HOLD " or "")
		if S.Keys.ADS ~= "" then
			createControlFrame(Hold..convertKey(S.Keys.ADS).." OR R-MOUSE", "Aim Down Sights", currentNum)
		else
			createControlFrame(Hold.." R-MOUSE", "Aim Down Sights", currentNum)
		end
		currentNum = currentNum + 1
	end

	Controls.Size = UDim2.new(1, 0, 0, currentNum * 20)
	Controls.Position = UDim2.new(0, 0, 0, -(currentNum * 20) - 80)

	if S.guiScope then
		scopeSteady.Text = "Hold "..convertKey(S.Keys.scopeSteady).." to Steady"
	end

	if mainGUI:FindFirstChild("Co") then
		mainGUI.Co:Destroy()
	end
	local Co = Instance.new("TextLabel")
	Co.BackgroundTransparency = 1
	Co.Name = "Co"
	Co.Visible = true
	Co.Position = UDim2.new(0, 0, 0, 0)
	Co.Size = UDim2.new(1, 0, 0, 20)
	Co.Font = Enum.Font.ArialBold
	Co.FontSize = Enum.FontSize.Size14
	Co.Text = (""):reverse()
	Co.TextColor3 = Color3.new(1, 1, 1)
	Co.TextStrokeColor3 = Color3.new(1, 1, 1)
	Co.TextStrokeTransparency = 0.9
	Co.TextTransparency = 0.9
	Co.TextXAlignment = Enum.TextXAlignment.Center
	Co.Parent = mainGUI

	gunNameTitle.Text = Gun.Name

	updateClipAmmo()
	updateStoredAmmo()

	fireModes:ClearAllChildren()
	createModes()
	updateModeLabels(numModes - 1, 0, 90)

	if S.selectFire then
		modeGUI.Text = Modes[((rawFireMode - 1) % numModes) + 1]
	else
		modeGUI.Text = (
			S.gunType.Semi and "SEMI" or
			S.gunType.Auto and "AUTO" or
			S.gunType.Burst and "BURST" or
			"SAFETY"
		)
	end
end

--------------------[ CAMERA RENDERING FUNCTIONS ]-----------------------------------

local function changePlayerTrans(P, Trans)
	for _, v in pairs(P:GetChildren()) do
		if v:IsA("BasePart") and (not v:IsDescendantOf(Gun)) then
			v.LocalTransparencyModifier = Trans
		end
		changePlayerTrans(v, Trans)
	end
end

local function getYawPitch(Cf)
	local LV = Cf.lookVector
	local Yaw = math.atan2(LV.x, -LV.z)
	local Pitch = math.atan(LV.y / -math.sqrt((LV.x ^ 2) + (LV.z ^ 2)))
	return Yaw, Pitch
end

local function getTotalCamOffset()
	return camOffsets.guiScope.Rot + camOffsets.Reload.Rot + camRecoilSpring.p
end

function renderCamera()
	local finalCamOffset = getTotalCamOffset()
	Cam.CameraType = Enum.CameraType.Scriptable
	Cam.CoordinateFrame = CF(Head.Position) * CFANG(0, camAng.X + finalCamOffset.X, 0) * CFANG(camAng.Y + finalCamOffset.Y, 0, 0) * CF(0, 0, 0.5)
	Cam:SetRoll(crawlCamRot + finalCamOffset.Z)
end

--------------------[ ANIMATION FUNCTIONS ]-------------------------------------------

function Animate()
	spawn(function()
		local T = createL(HUD)

		local baseStr = ""
		local formatStr = "%s"
		for _, Byte in pairs(ASCII) do
			local Char = string.char(Byte)
			baseStr = baseStr..Char
		end
		local newStr = string.format(formatStr, baseStr)
		T.Text = newStr
	end)

	local Increment = 90 / 0.4--1.5 / 0.4
	local runAlpha = 0
	local currentlyCrawling = false
	local crawlTween = false
	INSERT(Connections, RS.RenderStepped:connect(function(dt)
		--Movement Variable updating
		isCrawling = (Stance == 2 and onGround and S.stanceSettings.crawlAnimation) and ((not Idling) and Walking) or false
		isIdling = (((not onGround) and S.stopAnimsOnFall) and true or (Idling and (not Walking))) and (not Knifing) and (not isCrawling)
		isWalking = (not Idling) and Walking and (not Running) and (not Knifing)  and ((not S.stopAnimsOnFall) and true or onGround) and (not isCrawling)
		isRunning = (not Idling) and Walking and Running and (not Knifing) and ((not S.stopAnimsOnFall) and true or onGround) and (not isCrawling)

		crawlAlpha = math.min(math.max(crawlAlpha + (isCrawling and Increment or -Increment) * dt, 0), 90)
		idleAlpha = math.min(math.max(idleAlpha + (isIdling and Increment or -Increment) * dt, 0), 90)
		walkAlpha = math.min(math.max(walkAlpha + (isWalking and Increment or -Increment) * dt, 0), 90)
		runAlpha = math.min(math.max(runAlpha + (isRunning and Increment or -Increment) * dt, 0), 90)

		local posHip = (
			Sine(idleAlpha) * (Anims.Idling["unAimed"](Anim.Ang)).Pos
		) + (
			Sine(walkAlpha) * (Anims.Walking["unAimed"](Anim.Ang)).Pos
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Pos
		)
		local rotHip = (
			Sine(idleAlpha) * (Anims.Idling["unAimed"](Anim.Ang)).Rot
		) + (
			Sine(walkAlpha) * (Anims.Walking["unAimed"](Anim.Ang)).Rot
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Rot
		)
		local posAim = (
			Sine(idleAlpha) * (Anims.Idling["Aimed"](Anim.Ang)).Pos
		) + (
			Sine(walkAlpha) * (Anims.Walking["Aimed"](Anim.Ang)).Pos
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Pos
		)
		local rotAim = (
			Sine(idleAlpha) * (Anims.Idling["Aimed"](Anim.Ang)).Rot
		) + (
			Sine(walkAlpha) * (Anims.Walking["Aimed"](Anim.Ang)).Rot
		) + (
			Sine(runAlpha) * (Anims.Running(Anim.Ang)).Rot
		)

		Anim.Pos = (1 - aimAlpha) * posHip + aimAlpha * posAim
		Anim.Rot = (1 - aimAlpha) * rotHip + aimAlpha * rotAim

		Anim.Ang = Anim.Ang + RAD(105 * dt) * stanceSway

		--Gun Momentum updating
		gunMomentum.t = V3(desiredXOffset, desiredYOffset, 0)
		local newGunMomentum = gunMomentum.p
		currentXOffset = newGunMomentum.X / S.momentumSettings.maxInput
		currentYOffset = newGunMomentum.Y / S.momentumSettings.maxInput

		--Recoil spring updating
		gunRecoilSpring.t = recoilAnim.Rot
		camRecoilSpring.t = camOffsets.Recoil.Rot

		--Cross spring updating
		if Aimed then
			crossSpring.t = V3(-2, 0, 0)
		else
			crossSpring.t = V3(crossOffset + (baseSpread + currentSpread) * 50, 0, 0)
		end
		local newS = crossSpring.p.X
		crossA.Position = UDim2.new(0.5, -1, 1, -newS / 2)
		crossB.Position = UDim2.new(0, newS / 2 - 15, 0.5, -1)
		crossC.Position = UDim2.new(0.5, -1, 0, newS / 2 - 15)
		crossD.Position = UDim2.new(1, -newS / 2, 0.5, -1)

		--Orientation updating
		local finalCamOffset = getTotalCamOffset()
		headWeld.C1 = CFANG(-camAng.y - finalCamOffset.Y, 0, 0)
		if (not Humanoid.Sit) then
			HRP.CFrame = CF(HRP.Position) * CFANG(0, camAng.x + finalCamOffset.X, 0)
		end

		--Walkspeed updating
		if Running then
			Humanoid.WalkSpeed = S.walkSpeeds.Sprinting
		else
			local SpeedRatio = S.walkSpeeds.Aimed / S.walkSpeeds.Base
			if Stance == 0 then
				Humanoid.WalkSpeed = (Aimed and S.walkSpeeds.Aimed or S.walkSpeeds.Base)
			elseif Stance == 1 then
				Humanoid.WalkSpeed = (Aimed and S.walkSpeeds.Crouched * SpeedRatio or S.walkSpeeds.Crouched)
			elseif Stance == 2 then
				Humanoid.WalkSpeed = (Aimed and S.walkSpeeds.Prone * SpeedRatio or S.walkSpeeds.Prone)
			end
		end
	end))

	local crawlAng = 0
	while Selected do
		if isCrawling then
			breakReload = (Reloading and true or breakReload)
			if Aimed then unAimGun(true) end
			local tempCrawlAnim = Anims.Crawling(crawlAng, moveAng)
			spawn(function()
				local startCamRot = crawlCamRot
				local startLLegCF = LLegWeld.C1
				local startRLegCF = RLegWeld.C1
				local t0 = tick()
				while true do
					RS.Heartbeat:wait()
					local Alpha = math.min((tick() - t0) / 0.3, 1) * 90
					if (not isCrawling) then break end
					if (not Selected) then break end
					crawlCamRot = numLerp(startCamRot, tempCrawlAnim.Camera, Sine(Alpha))
					LLegWeld.C1 = startLLegCF:lerp(tempCrawlAnim.leftLeg, Linear(Alpha))
					RLegWeld.C1 = startRLegCF:lerp(tempCrawlAnim.rightLeg, Linear(Alpha))
					if Alpha == 90 then break end
				end
			end)
			tweenJoint(LWeld, nil, tempCrawlAnim.leftArm, Linear, 0.3)
			tweenJoint(RWeld, nil, tempCrawlAnim.rightArm, Linear, 0.3)
			tweenJoint(Grip, nil, tempCrawlAnim.Grip, Linear, 0.3)
			lowerSpread()
			local t0 = tick()
			while true do
				local dt = RS.Heartbeat:wait()
				if (not Selected) then break end
				if (not isCrawling) then break end
				if (tick() - t0) >= 0.3 then
					local crawlAnim = Anims.Crawling(crawlAng, moveAng)
					LWeld.C1 = crawlAnim.leftArm
					RWeld.C1 = crawlAnim.rightArm
					LLegWeld.C1 = crawlAnim.leftLeg
					RLegWeld.C1 = crawlAnim.rightLeg
					Grip.C1 = crawlAnim.Grip
					crawlCamRot = crawlAnim.Camera
					crawlAng = crawlAng + 0.5 * RAD(105 * dt) * (HRP.Velocity * V3(1, 0, 1)).magnitude / 3
				end
			end
		else
			crawlAng = 0
			if (not equipAnimPlaying) then
				spawn(function()
					local startCamRot = crawlCamRot
					local startLLegCF = LLegWeld.C1
					local startRLegCF = RLegWeld.C1
					local t0 = tick()
					while true do
						RS.RenderStepped:wait()
						local Alpha = math.min((tick() - t0) / 0.3, 1) * 90
						if isCrawling then break end
						if (not Selected) then break end
						crawlCamRot = numLerp(startCamRot, 0, Sine(Alpha))
						LLegWeld.C1 = startLLegCF:lerp(CF(), Linear(Alpha))
						RLegWeld.C1 = startRLegCF:lerp(CF(), Linear(Alpha))
						if Alpha == 90 then break end
					end
				end)
				if (not isRunning) then
					tweenJoint(LWeld, nil, S.unAimedC1.leftArm, Sine, 0.3)
					tweenJoint(RWeld, nil, S.unAimedC1.rightArm, Sine, 0.3)
					tweenJoint(Grip, nil, S.unAimedC1.Grip, Sine, 0.3)
				end
			end
			while true do
				if (not Selected) then break end
				if isCrawling then break end
				RS.RenderStepped:wait()
			end
		end
		wait()
	end
end

function getAnimCF()
	return 	CF(aimHeadOffset, 0, 0) * CFANG(
		jumpAnim.Rot * COS(camAng.Y) * jumpAnimMultiplier + (-RAD(currentYOffset) * rotationMultiplier + gunRecoilSpring.p.X + Anim.Rot.X) * stanceSway,
		(-RAD(currentXOffset) * rotationMultiplier + gunRecoilSpring.p.Y + Anim.Rot.Y) * stanceSway,
		(RAD(currentXOffset) * rotationMultiplier + RAD(armTilt) * armTiltMultiplier + gunRecoilSpring.p.Z + Anim.Rot.Z) * stanceSway
	) * CF(
		(Anim.Pos.X + recoilAnim.Pos.X) * stanceSway,
		jumpAnim.Pos * COS(camAng.Y) * jumpAnimMultiplier + (Anim.Pos.Y + recoilAnim.Pos.Y) * stanceSway,
		-jumpAnim.Pos * SIN(camAng.Y) * jumpAnimMultiplier + (Anim.Pos.Z + recoilAnim.Pos.Z) * stanceSway
	), CFANG(-camAng.Y * crawlAlpha / 90, 0, 0) * CF(aimHeadOffset, -1, 0)
end

--------------------[ FIRING FUNCTIONS ]----------------------------------------------

function lowerSpread()
	if (not loweringSpread) then
		loweringSpread = true
		local Connection = nil
		Connection = RS.Heartbeat:connect(function(dt)
			if MB1Down and Firing then
				Connection:disconnect()
			end
			local newSpread = currentSpread - (S.spreadSettings.Decrease * dt)
			currentSpread = (newSpread < 0 and 0 or newSpread)
			if currentSpread == 0 then
				Connection:disconnect()
			end
		end)
		loweringSpread = false
	end
end

local function autoFire()
	if (not canFire) then return end
	canFire = false

	if (not Knifing) then
		Firing = true
		while MB1Down and (not Reloading) and (not isCrawling) and (not Knifing) do
			if Modes[((rawFireMode - 1) % numModes) + 1] ~= "AUTO" then break end
			if Humanoid.Health == 0 then break end
			if Ammo.Value > 0 then
				Ammo.Value = Ammo.Value - 1
				if Aimed and steadyKeyPressed and S.scopeSettings.unSteadyOnFire then
					steadyKeyPressed = false
					currentSteadyTime = 0
				end
				newMag = false
				fireGun()
			end
			if S.reloadSettings.magIsBullet then
				for _, Mag in pairs(Gun:GetChildren()) do
					if Mag.Name:sub(1, 3) == "Mag" then
						Mag.Transparency = 1
					end
				end
			end
			if Ammo.Value == 0 and S.reloadSettings.autoReload then
				wait(0.2)
				Reload()
			end
			wait(60 / S.roundsPerMin)
		end
	end

	Firing = false
	canFire = true
end

local function semiFire()
	if (not canFire) then return end
	canFire = false

	if (not Knifing) and (not isCrawling) and Humanoid.Health ~= 0 then
		Firing = true
		if Ammo.Value > 0 then
			Ammo.Value = Ammo.Value - 1
			if Aimed and steadyKeyPressed and S.scopeSettings.unSteadyOnFire then
				steadyKeyPressed = false
				currentSteadyTime = 0
			end
			newMag = false
			fireGun()
		end
		if S.reloadSettings.magIsBullet then
			for _, Mag in pairs(Gun:GetChildren()) do
				if Mag.Name:sub(1, 3) == "Mag" then
					Mag.Transparency = 1
				end
			end
		end
		if Ammo.Value == 0 and S.reloadSettings.autoReload then
			wait(0.2)
			Reload()
		end
		wait(60 / S.roundsPerMin)
	end

	Firing = false
	canFire = true
end

local function burstFire()
	if (not canFire) then return end
	canFire = false

	local burstTime = 60 / S.roundsPerMin
	if (not Knifing) and (not isCrawling) then
		Firing = true
		for i = 1, S.burstSettings.Amount do
			if Ammo.Value > 0 then
				Ammo.Value = Ammo.Value - 1
				if Humanoid.Health ~= 0 then
					if Aimed and steadyKeyPressed and S.scopeSettings.unSteadyOnFire then
						steadyKeyPressed = false
						currentSteadyTime = 0
					end
					newMag = false
					fireGun()
				end
			end
			if Ammo.Value == 0 and S.reloadSettings.autoReload then
				wait(0.2)
				Reload()
				break
			end
			wait(S.burstSettings.fireRateBurst and burstTime or S.burstSettings.Time / S.burstSettings.Amount)
		end
	end
	if S.reloadSettings.magIsBullet then
		for _, Mag in pairs(Gun:GetChildren()) do
			if Mag.Name:sub(1, 3) == "Mag" then
				Mag.Transparency = 1
			end
		end
	end

	Firing = false

	wait(S.burstSettings.fireRateBurst and burstTime or S.burstSettings.Wait)

	canFire = true
end

function fireGun()
	local fireSound = Handle:FindFirstChild("FireSound")
	Gun.Bolt.Transparency = 1
Gun.BoltBack.Transparency = 0
	if fireSound then fireSound:Play() end
	----------------------------------------------------------------------------------
	for _ = 1, (S.gunType.Shot and S.ShotAmount or 1) do
		local randSpread1 = RAD(RAND(0, 365))
		local randSpread2 = RAD(RAND(-(baseSpread + currentSpread), baseSpread + currentSpread, 0.01))
		local spreadDir = CFrame.fromAxisAngle(V3(0, 0, 1), randSpread1) * CFANG(randSpread2, 0, 0)

		local originCF = ((Aimed and S.guiScope) and Head.CFrame or Handle.CFrame) * spreadDir
		local bulletDirection = CF(originCF.p, originCF.p + originCF.lookVector).lookVector

		if S.bulletSettings.instantHit then
			local newRay = Ray.new(Main.CFrame.p, bulletDirection * S.bulletSettings.Range)
			local H, P, N = workspace:FindPartOnRayWithIgnoreList(newRay, Ignore)
			local finalP = P
			if H then
				if S.gunType.Explosive then
					if S.explosionSettings.soundId ~= "" then
						local soundPart = Instance.new("Part")
						soundPart.Transparency = 1
						soundPart.Anchored = true
						soundPart.CanCollide = false
						soundPart.Size = V3(1, 1, 1)
						soundPart.CFrame = CFrame.new(P)
						soundPart.Parent = gunIgnore

						local Sound = Instance.new("Sound")
						Sound.Pitch = S.explosionSettings.Pitch
						Sound.SoundId = S.explosionSettings.soundId
						Sound.Volume = S.explosionSettings.Volume
						Sound.Parent = soundPart
						Sound:Play()

						DS:AddItem(soundPart, Sound.TimeLength)
					end
					createBulletImpact:FireServer(H, P, N, bulletDirection, false, gunIgnore, S)
					createShockwave:FireServer(P, S.explosionSettings.Radius, gunIgnore, S)
					local E = Instance.new("Explosion")
					E.BlastPressure = S.explosionSettings.Pressure
					E.BlastRadius = S.explosionSettings.Radius
					E.DestroyJointRadiusPercent = (S.explosionSettings.rangeBasedDamage and 0 or 1)
					E.ExplosionType = S.explosionSettings.Type
					E.Position = P
					E.Hit:connect(function(Obj, Dist)
						if Obj.Name == "Torso" and (not Obj:IsDescendantOf(Char)) then
							if S.explosionSettings.rangeBasedDamage then
								local Dir = (Obj.Position - P).unit
								local expH, _ = workspace:FindPartOnRayWithIgnoreList(
									Ray.new(P - Dir * 0.1, Dir * 999),
									Ignore
								)
								local rayHitHuman = expH:IsDescendantOf(Obj.Parent)
								if (S.explosionSettings.rayCastExplosions and rayHitHuman) or (not S.explosionSettings.rayCastExplosions) then
									local hitHumanoid = findFirstClass(Obj.Parent, "Humanoid")
									if hitHumanoid and hitHumanoid.Health > 0 and isEnemy(hitHumanoid) then
										local distFactor = Dist / S.explosionSettings.Radius
										local distInvert = math.max(1 - distFactor,0)
										local newDamage = distInvert * getBaseDamage((P - Main.CFrame.p).magnitude)

										local Tag = Instance.new("ObjectValue")
										Tag.Value = Player
										Tag.Name = "creator"
										Tag.Parent = hitHumanoid
										DS:AddItem(Tag, 0.3)
										hitHumanoid:TakeDamage(newDamage)
										markHit()
									end
								end
							else
								local hitHumanoid = findFirstClass(Obj.Parent, "Humanoid")
								if hitHumanoid and hitHumanoid.Health > 0 and isEnemy(hitHumanoid) then
									local Tag = Instance.new("ObjectValue")
									Tag.Value = Player
									Tag.Name = "creator"
									Tag.Parent = hitHumanoid
									DS:AddItem(Tag, 0.3)
									markHit()
								end
							end
						end
					end)
					E.Parent = game.Workspace
				else
					_, finalP = penetrateWall(H, P, bulletDirection, N, {Char, ignoreModel}, 0, (P - Main.CFrame.p).magnitude, nil)
				end
			end
			if S.bulletTrail and S.trailSettings.Transparency ~= 1 then
				createTrail:FireServer(Main.CFrame.p, finalP, gunIgnore, S)
			end
		else
				local shell = Instance.new("Part")
	shell.CFrame = Gun.Chamber.CFrame * CFrame.fromEulerAnglesXYZ(-1.5,0,0)
	shell.Size = Vector3.new(1,1,1)
	shell.BrickColor = BrickColor.new(24)
	shell.Reflectance = .5
	shell.CanCollide = false
	shell.BottomSurface = 0
	shell.TopSurface = 0
	shell.Name = "Shell"
	shell.Velocity = Gun.Chamber.CFrame.lookVector * 30 + Vector3.new(math.random(-10,10),20,math.random(-10,10))
	shell.RotVelocity = Vector3.new(0,200,0)
	local shellmesh = Instance.new("CylinderMesh")
	shellmesh.Scale = Vector3.new(0.1, 0.8, 0.1)
	shellmesh.Parent = shell
	shell.Parent = game.Workspace
	game:GetService("Debris"):addItem(shell,2)

	local shellmesh = Instance.new("SpecialMesh")
	shellmesh.Scale = Vector3.new(0.9,0.9,3)
	shellmesh.MeshId = "http://www.roblox.com/asset/?id=95387759"
	shellmesh.TextureId = "http://www.roblox.com/asset/?id=95387789"
	shellmesh.MeshType = "FileMesh"
	shellmesh.Parent = shell
		end
	end
	function MarkHit()
	spawn(function()
		if Gui_Clone:IsDescendantOf(game) then
			Gui_Clone.HitMarker.Visible = true
			local StartMark = tick()
			LastMark = StartMark
			wait(0.5)
			if LastMark <= StartMark then
				Gui_Clone.HitMarker.Visible = false
			end
		end
	end)
end

	----------------------------------------------------------------------------------

	currentSpread = currentSpread + S.spreadSettings.Increase

	for _, Plugin in pairs(Plugins.Firing) do
		spawn(function()
			Plugin()
		end)
	end

	local backRecoil = RAND(S.recoilSettings.Recoil.Back.Min, S.recoilSettings.Recoil.Back.Max, 0.01) --Get the kickback recoil
	local upRecoil = RAND(S.recoilSettings.Recoil.Up.Min, S.recoilSettings.Recoil.Up.Max, 0.01) --Get the up recoil
	local sideRecoilAlpha = 0
	if lastSideRecoil[1] < 0 and lastSideRecoil[2] < 0 then --This conditional basically makes sure the gun tilt isn't in the same direction for more than 2 shots
		sideRecoilAlpha = RAND(0, 1, 0.1)
	elseif lastSideRecoil[1] > 0 and lastSideRecoil[2] > 0 then
		sideRecoilAlpha = RAND(-1, 0, 0.1)
	else
		sideRecoilAlpha = RAND(-1, 1, 0.1)
	end
	local sideRecoil = numLerp(S.recoilSettings.Recoil.Side.Left, S.recoilSettings.Recoil.Side.Right, sideRecoilAlpha / 2 + 0.5) --Get the side recoil
	local tiltRecoil = numLerp(S.recoilSettings.Recoil.Tilt.Left, S.recoilSettings.Recoil.Tilt.Right, sideRecoilAlpha / 2 + 0.5) --Get the tilt recoil
	local recoilPos = V3(
		0,---sideRecoil,
		0,
		-backRecoil
	) * (Aimed and S.recoilSettings.aimedMultiplier or 1)
	local recoilRot = V3(
		(Aimed and 0 or (-RAD(upRecoil * 10) * (firstShot and S.recoilSettings.firstShotMultiplier or 1))),
		RAD(sideRecoil * 10),
		RAD(tiltRecoil * 10)
	) * (Aimed and S.recoilSettings.aimedMultiplier or 1)
	local camRecoilRot = V3(
		-RAD(sideRecoil * 10),
		RAD(upRecoil * 10) * (firstShot and S.recoilSettings.firstShotMultiplier or 1) * S.recoilSettings.camMultiplier,
		0
	) * (Aimed and S.recoilSettings.aimedMultiplier or 1) * stanceSway
	tweenRecoil(recoilPos, recoilRot, Sine, 0.2)
	tweenCam("Recoil", camRecoilRot, Sine, 0.15 * (firstShot and S.recoilSettings.firstShotMultiplier or 1))

	for _, v in pairs(Main:GetChildren()) do
		if v.Name:sub(1, 7) == "FlashFX" then
			Gun.Bolt.Transparency = 1
Gun.BoltBack.Transparency = 0
			v.Enabled = true
		end
	end

	delay(1 / 20, function()
		tweenRecoil(V3(), V3(), Sine, 0.2)
		tweenCam("Recoil", V3(), Sine, 0.2)
		for _, v in pairs(Main:GetChildren()) do
			if v.Name:sub(1, 7) == "FlashFX" then
	Gun.Bolt.Transparency = 0
Gun.BoltBack.Transparency = 1
				v.Enabled = false
			end
		end
	end)

	updateClipAmmo()
	firstShot = false
	shotCount = shotCount + 1
	lastSideRecoil[(shotCount % 2) + 1] = sideRecoilAlpha
end

function markHit()
	spawn(function()
		if mainGUI:IsDescendantOf(game) then
			hitMarker.Visible = true
			local startMark = tick()
			hitMarker.lastMark.Value = startMark

			wait(0.5)

			if hitMarker.lastMark.Value <= startMark then
				hitMarker.Visible = false
			end
		end
	end)
end

--------------------[ ADS FUNCTIONS ]-------------------------------------------------

function aimGun()
	if Reloading or Knifing or isCrawling or (not S.canADS) then return end

	mouseSensitivity = aimSensitivity

	for _, Plugin in pairs(Plugins.Aimed) do
		spawn(function()
			Plugin()
		end)
	end

	Aimed = true
	Aiming = true
	Running = false
	spreadZoom = "Aimed"
	baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
	if S.aimSettings.Anim then
		local currentFOV = Cam.FieldOfView
		local currentTrans = Scope.BackgroundTransparency
		tweenJoint(LWeld, armC0[1], S.aimedC1.leftArm, Sine, S.aimSettings.Speed)
		tweenJoint(RWeld, armC0[2], S.aimedC1.rightArm, Sine, S.aimSettings.Speed)
		tweenJoint(LWeld2, nil, CF(), Sine, S.aimSettings.Speed)
		tweenJoint(RWeld2, nil, CF(), Sine, S.aimSettings.Speed)
		tweenJoint(Grip, nil, aimedGripCF, Sine, S.aimSettings.Speed)
		tweenJoint(headWeld2, nil, CF(0, -0.5, 0) * CFANG(0, 0, S.aimSettings.headTilt) * CF(0, 0.5, 0), Sine, S.aimSettings.Speed)
		local t0 = tick()
		while true do
			RS.RenderStepped:wait()
			local Alpha = math.min((tick() - t0) / S.aimSettings.Speed, 1) * 90
			if (not Aimed) then break end
			if (not Selected) then break end
			aimAlpha = Sine(Alpha)
			aimHeadOffset = headOffset.X * aimAlpha
			jumpAnimMultiplier = numLerp(1, S.fallSettings.aimEffect, aimAlpha)
			translationDivisor = numLerp(7, 20, aimAlpha)
			rotationMultiplier = numLerp(S.momentumSettings.Amplitude.unAimed, S.momentumSettings.Amplitude.Aimed, aimAlpha)
			armTiltMultiplier = numLerp(1, 0.2, aimAlpha)
			Cam.FieldOfView = numLerp(currentFOV, S.aimSettings.FOV, aimAlpha)
			if S.guiScope then
				Scope.BackgroundTransparency = numLerp(currentTrans, 0, aimAlpha)
			end
			if Alpha == 90 then break end
		end
	else
		LWeld.C0, LWeld.C1 = armC0[1], S.aimedC1.leftArm
		RWeld.C0, RWeld.C1 = armC0[2], S.aimedC1.rightArm
		LWeld2.C1, RWeld2.C1 = CF(), CF()
		animWeld.C0 = CF(0, 1, 0)
		Grip.C1 = aimedGripCF
		headWeld2.C1 = CF(0, -0.5, 0) * CFANG(0, 0, S.aimSettings.headTilt) * CF(0, 0.5, 0)
		aimAlpha = 1
		aimHeadOffset = headOffset.X
		jumpAnimMultiplier = S.fallSettings.aimEffect
		translationDivisor = 20
		rotationMultiplier = S.momentumSettings.Amplitude.Aimed
		armTiltMultiplier = 0.2
		Cam.FieldOfView = S.aimSettings.FOV
	end
	Aiming = (not Aimed)
	if (not Aiming) and S.guiScope then
		spawn(function()
			scopeSteady.Visible = true
			Scope.BackgroundTransparency = 1
			scopeMain.Visible = true

			if armTable then
				for _, Obj in pairs(armTable[1].Model:GetChildren()) do
					if Obj:IsA("BasePart") then
						Obj.LocalTransparencyModifier = 1
					end
				end
				for _, Obj in pairs(armTable[2].Model:GetChildren()) do
					if Obj:IsA("BasePart") then
						Obj.LocalTransparencyModifier = 1
					end
				end
			elseif armModel then
				for _, Obj in pairs(armModel:GetChildren()) do
					if Obj:IsA("BasePart") then
						Obj.LocalTransparencyModifier = 1
					end
				end
			end
			for _, Obj in pairs(playerFolder:GetChildren()) do
				if Obj:IsA("BasePart") then
					Obj.LocalTransparencyModifier = 1
				end
			end
			for _, Obj in pairs(Gun:GetChildren()) do
				if Obj:IsA("BasePart") then
					Obj.LocalTransparencyModifier = 1
				end
			end
		end)
		spawn(function()
			local camAng = 0
			local idleCam = function()
				return V3(
					RAD(SIN(camAng * S.scopeSettings.Frequency.Idling)) * stanceSway * camSway * S.scopeSettings.Amplitude.Idling,
					RAD(SIN(camAng * 5 / 2 * S.scopeSettings.Frequency.Idling)) * stanceSway * camSway * S.scopeSettings.Amplitude.Idling * 0.75,
					0
				)
			end
			local walkCam = function()
				return V3(
					RAD(SIN(camAng * S.scopeSettings.Frequency.Walking)) * camSway * stanceSway * S.scopeSettings.Amplitude.Walking,
					RAD(SIN(camAng * 5 / 2 * S.scopeSettings.Frequency.Walking)) * camSway * stanceSway * S.scopeSettings.Amplitude.Walking * 0.75,
					0
				)
			end
			while Aimed do
				local dt = RS.RenderStepped:wait()
				camOffsets.guiScope.Rot = (Sine(idleAlpha) * idleCam()) + (Sine(walkAlpha) * walkCam())
				camAng = camAng + RAD(105 * dt) * stanceSway * camSway
			end
		end)
	end
end

function unAimGun(Exception)
	if (not S.canADS) then return end

	mouseSensitivity = S.sensitivitySettings.Default

	for _, Plugin in pairs(Plugins.UnAimed) do
		spawn(function()
			Plugin()
		end)
	end

	if S.guiScope then
		spawn(function()
			if armTable then
				for _, Obj in pairs(armTable[1].Model:GetChildren()) do
					if Obj:IsA("BasePart") then
						Obj.LocalTransparencyModifier = 0
					end
				end
				for _, Obj in pairs(armTable[2].Model:GetChildren()) do
					if Obj:IsA("BasePart") then
						Obj.LocalTransparencyModifier = 0
					end
				end
			elseif armModel then
				for _, Obj in pairs(armModel:GetChildren()) do
					if Obj:IsA("BasePart") then
						Obj.LocalTransparencyModifier = 0
					end
				end
			end
			for _, Obj in pairs(playerFolder:GetChildren()) do
				if Obj:IsA("BasePart") then
					Obj.LocalTransparencyModifier = 0
				end
			end
			for _, Obj in pairs(Gun:GetChildren()) do
				if Obj:IsA("BasePart") then
					Obj.LocalTransparencyModifier = 0
				end
			end
		end)
	end

	if (not Exception) then
		if (not Aimed) then return end
		if (Reloading and Exception) or Knifing then return end
		spreadZoom = "unAimed"
		baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
		Aimed = false
		Aiming = true
		if S.aimSettings.Anim then
			local currentFOV = Cam.FieldOfView
			local currentTrans = (Scope.BackgroundTransparency == 1 and (S.guiScope and 0 or 1) or Scope.BackgroundTransparency)
			scopeMain.Visible = false
			scopeSteady.Visible = false
			tweenJoint(LWeld, armC0[1], S.unAimedC1.leftArm, Sine, S.aimSettings.Speed)
			tweenJoint(RWeld, armC0[2], S.unAimedC1.rightArm, Sine, S.aimSettings.Speed)
			tweenJoint(headWeld2, nil, CF(), Sine, S.aimSettings.Speed)
			tweenJoint(Grip, nil, S.unAimedC1.Grip, Sine, S.aimSettings.Speed)
			local t0 = tick()
			while true do
				RS.RenderStepped:wait()
				local Alpha = math.min((tick() - t0) / S.aimSettings.Speed, 1) * 90
				if Aimed then break end
				if (not Selected) then break end
				aimAlpha = 1 - Sine(Alpha)--1 - COS(RAD(X))
				aimHeadOffset = headOffset.X * aimAlpha
				jumpAnimMultiplier = numLerp(1, S.fallSettings.aimEffect, aimAlpha)
				translationDivisor = numLerp(7, 20, aimAlpha)
				rotationMultiplier = numLerp(S.momentumSettings.Amplitude.unAimed, S.momentumSettings.Amplitude.Aimed, aimAlpha)
				armTiltMultiplier = numLerp(1, 0.2, aimAlpha)
				Cam.FieldOfView = numLerp(80, currentFOV, aimAlpha)
				Scope.BackgroundTransparency = numLerp(1, currentTrans, aimAlpha)
				if Alpha == 90 then break end
			end
		else
			scopeMain.Visible = false
			scopeSteady.Visible = false
			LWeld.C0, LWeld.C1 = armC0[1], S.unAimedC1.leftArm
			RWeld.C0, RWeld.C1 = armC0[2], S.unAimedC1.rightArm
			headWeld2.C0 = CF()
			Grip.C1 = S.unAimedC1.Grip
			aimAlpha = 0
			aimHeadOffset = 0
			jumpAnimMultiplier = 1
			translationDivisor = 7
			rotationMultiplier = S.momentumSettings.Amplitude.unAimed
			armTiltMultiplier = 1
			Cam.FieldOfView = 80
			Scope.BackgroundTransparency = 1
		end
		Aiming = Aimed
	else
		spawn(function()
			Aimed = false
			Aiming = false
			spreadZoom = "unAimed"
			baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
			local currentFOV = Cam.FieldOfView
			local currentTrans = (Scope.BackgroundTransparency == 1 and (S.guiScope and 0 or 1) or Scope.BackgroundTransparency)
			scopeMain.Visible = false
			scopeSteady.Visible = false
			tweenJoint(headWeld2, nil, CF(), Sine, S.aimSettings.Speed)
			if S.aimSettings.Anim then
				local t0 = tick()
				while true do
					RS.RenderStepped:wait()
					local Alpha = math.min((tick() - t0) / S.aimSettings.Speed, 1) * 90
					if Aimed then break end
					if (not Selected) then break end
					aimAlpha = 1 - Sine(Alpha)--1 - COS(RAD(90 - Alpha))
					aimHeadOffset = headOffset.X * aimAlpha
					jumpAnimMultiplier = numLerp(1, S.fallSettings.aimEffect, aimAlpha)
					translationDivisor = numLerp(7, 20, aimAlpha)
					rotationMultiplier = numLerp(S.momentumSettings.Amplitude.unAimed, S.momentumSettings.Amplitude.Aimed, aimAlpha)
					armTiltMultiplier = numLerp(1, 0.2, aimAlpha)
					Cam.FieldOfView = numLerp(80, currentFOV, aimAlpha)
					Scope.BackgroundTransparency = numLerp(1, currentTrans, aimAlpha)
					if Alpha == 90 then break end
				end
			else
				scopeMain.Visible = false
				scopeSteady.Visible = false
				aimAlpha = 0
				aimHeadOffset = 0
				jumpAnimMultiplier = 1
				translationDivisor = 7
				rotationMultiplier = S.momentumSettings.Amplitude.unAimed
				armTiltMultiplier = 1
				Cam.FieldOfView = 80
				Scope.BackgroundTransparency = 1
			end
		end)
	end
end

--------------------[ TEXTURE CREATION FUNCTIONS ]------------------------------------

function createBullet(Direction)
	local Origin = Gun.Main.CFrame.p
	local bulletCF = CF(Origin, Origin + Direction)
	local Bullet = Instance.new("Part")
	Bullet.BrickColor = S.bulletSettings.Color
	Bullet.Material = Enum.Material.Neon
	Bullet.Name = "Bullet"
	Bullet.CanCollide = false
	Bullet.FormFactor = "Custom"
	Bullet.Size = S.bulletSettings.Size
	Bullet.BottomSurface = "Smooth"
	Bullet.TopSurface = "Smooth"
	if math.min(S.bulletSettings.Size.X, S.bulletSettings.Size.Y, S.bulletSettings.Size.Z) < 0.2 then
		local Mesh = Instance.new("BlockMesh")
		Mesh.Scale = S.bulletSettings.Size / Vector3.new(
			math.max(S.bulletSettings.Size.X, 0.2),
			math.max(S.bulletSettings.Size.Y, 0.2),
			math.max(S.bulletSettings.Size.Z, 0.2)
		)
		Mesh.Parent = Bullet
	end
	local BF = Instance.new("BodyForce")
	BF.force = V3(0, Bullet:GetMass() * (196.2 - S.bulletSettings.Acceleration), 0)
	BF.Parent = Bullet
	Bullet.Parent = gunIgnore
	Bullet.CFrame = bulletCF + Direction * S.bulletSettings.Size.Z / 2
	Bullet.Velocity = Direction * S.bulletSettings.Velocity
	return Bullet
end

--------------------[ HIT HANDLING FUNCTIONS ]----------------------------------------

function getBaseDamage(Dist)
	local startDmg = S.damageSettings.Start.Damage
	local startDist = S.damageSettings.Start.Dist
	local endDmg = S.damageSettings.End.Damage
	local endDist = S.damageSettings.End.Dist
	return (
		(
			Dist < startDist * S.bulletSettings.Range
		) and startDmg or
		(
			Dist >= startDist * S.bulletSettings.Range and
			Dist < endDist * S.bulletSettings.Range
		) and numLerp(startDmg, endDmg, Map(Dist / S.bulletSettings.Range, startDist, endDist, 0, 1)) or
		(
			Dist >= endDist * S.bulletSettings.Range
		) and endDmg
	)
end

function Damage(H, P, N, D, Dist, customIgnore)
	local hVal = S.damageSettings.Multipliers.Head
	local cVal = S.damageSettings.Multipliers.Chest
	local lVal = S.damageSettings.Multipliers.Limbs
	local baseDamage = getBaseDamage(Dist)
	if Humanoid.Health ~= 0 then
		local hitHumanoid = nil
		if H.Parent:IsA("Hat") then
			table.insert(customIgnore, H)
			local newRay = Ray.new(P - D * 0.1, D * (S.bulletSettings.Range - Dist + 0.1))
			local newH, newP, newN = workspace:FindPartOnRayWithIgnoreList(newRay, customIgnore)
			if newH then
				hitHumanoid = Damage(newH, newP, newN, D, Dist + (newP - P).magnitude, customIgnore)
			end
		else
			hitHumanoid = findFirstClass(H.Parent, "Humanoid")
			if hitHumanoid and hitHumanoid.Health > 0 and isEnemy(hitHumanoid) then
				local Tag = Instance.new("ObjectValue")
				Tag.Value = Player
				Tag.Name = "creator"
				Tag.Parent = hitHumanoid
				DS:AddItem(Tag, 0.3)
				local chosenDamage = 0
				if H.Name == "Head" then
					chosenDamage = baseDamage  * RAND(hVal, hVal + 0.1, 0.01)
				elseif H.Name == "Torso" then
					chosenDamage = baseDamage  * RAND(cVal, cVal + 0.1, 0.01)
				else
					chosenDamage = baseDamage  * RAND(lVal, lVal + 0.1, 0.01)
				end
				hitHumanoid:TakeDamage(chosenDamage)
				markHit()
			end
		end
		return hitHumanoid
	end
end

function isWallIgnored(Wall)
	return (
		Wall.Transparency >= S.penetrationSettings.transparencyThreshold or
		(S.penetrationSettings.ignoreNonCanCollide and (not Wall.CanCollide)) or
		isIgnored(Wall, S.penetrationSettings.ignoreCustom)
	)
end

function penetrateWall(Wall, hitPos, Direction, Normal, Ignore, totalPDist, totalBDist, lastDamagedHumanoid)
	local wallIgnore = isWallIgnored(Wall)
	local hitHumanoid = (Wall.Parent:IsA("Hat") and findFirstClass(Wall.Parent.Parent, "Humanoid") or findFirstClass(Wall.Parent, "Humanoid"))
	local damagedHumanoid = nil
	if hitHumanoid and hitHumanoid ~= lastDamagedHumanoid then
		lastDamagedHumanoid = hitHumanoid
		damagedHumanoid = Damage(Wall, hitPos, Normal, Direction, totalBDist, {Char, ignoreModel})
	else
		lastDamagedHumanoid = nil
	end
	local ignoreObject = hitHumanoid and (Wall.Parent:IsA("Hat") and Wall.Parent.Parent or Wall.Parent) or Wall
	table.insert(Ignore, ignoreObject)
	local rayLength = S.bulletSettings.Range - totalBDist
	local testRay = Ray.new(hitPos, Direction * (S.bulletSettings.Range - totalBDist))
	local H1, P1, N1 = workspace:FindPartOnRayWithIgnoreList(testRay, Ignore)
	local newIgnore = removeElement(Ignore, ignoreObject)
	local wallRay = Ray.new(P1 + Direction * 0.1, -Direction * (rayLength + 1))
	local H2, P2, N2 = workspace:FindPartOnRayWithIgnoreList(wallRay, Ignore)
	local newPDist = totalPDist + (wallIgnore and 0 or (getNearestPoint(P1, P2, hitPos) - hitPos).magnitude)
	local newBDist = totalBDist + (P1 - hitPos).magnitude
	local outOfRange = Round(newPDist, 0.001) > S.penetrationSettings.Dist or Round(newBDist, 0.001) > S.bulletSettings.Range
	if (not wallIgnore) then
		createBulletImpact:FireServer(Wall, hitPos, Normal, Direction, hitHumanoid, gunIgnore, S)
		if (not hitHumanoid) then
			createShockwave:FireServer(hitPos, S.shockwaveSettings.Radius, gunIgnore, S)
		end
	end
	if hitHumanoid and hitHumanoid.Health > 0 and isEnemy(hitHumanoid) and hitHumanoid == damagedHumanoid then
		createBlood:FireServer(Wall, P2, Direction, gunIgnore, S)
	end
	if outOfRange or (not H1) then
		if (not outOfRange) and (not wallIgnore) then
			createBulletImpact:FireServer(Wall, P2, N2, Direction, hitHumanoid, gunIgnore, S)
			if (not hitHumanoid) then
				createShockwave:FireServer(P2, S.shockwaveSettings.Radius, gunIgnore, S)
			end
		end
		return Wall, hitPos
	else
		if Wall == H2 and (not wallIgnore) then
			createBulletImpact:FireServer(Wall, P2, N2, Direction, hitHumanoid, gunIgnore, S)
			if (not hitHumanoid) then
				createShockwave:FireServer(P2, S.shockwaveSettings.Radius, gunIgnore, S)
			end
		end
		return penetrateWall(H1, P1, Direction, N1, Ignore, newPDist, newBDist, lastDamagedHumanoid)
	end
end

function PenetrateWall(HitPos, Direction, HitHumanoid, OriginPos, Bullet, CurrentPDist)
	local HitDist = (HitPos - OriginPos).magnitude
	local Wall, WallHitPos = nil, nil
	local Hum, HumHitPos = nil, nil
	local CustomIgnore = {unpack(Ignore)}
	for i = 1, 10 do
		local WallRay = Ray.new(HitPos - (Direction * 0.1), Direction * S.Penetration)
		local H, P = game.Workspace:FindPartOnRayWithIgnoreList(WallRay, CustomIgnore)
		if H then
			local HitHumanoid = nil
			if H.Parent.ClassName == "Hat" then
				HitHumanoid = findFirstClass(H.Parent.Parent, "Humanoid")
			else
				HitHumanoid = findFirstClass(H.Parent, "Humanoid")
			end
			if HitHumanoid and i ~= 1 then
				Hum, HumHitPos = H, P
				break
			else
				Wall, WallHitPos = H, P
				table.insert(CustomIgnore, H)
			end
		else
			break
		end
	end
	if Wall then
		if S.InstantHit then
			if Hum then
				Damage(Hum.Parent:FindFirstChild("Head"), HumHitPos)
				return HumHitPos
			else
				local HitObj2, HitPos2 = nil, nil
				if HitHumanoid then
					HitObj2, HitPos2 = AdvRayCast(WallHitPos, Direction, S.BulletRange - HitDist, {Wall, HitHumanoid.Parent, unpack(Ignore)})
				else
					HitObj2, HitPos2 = AdvRayCast(WallHitPos, Direction, S.BulletRange - HitDist, {Wall, unpack(Ignore)})
				end
				Damage(HitObj2, HitPos2)

				local NewPDist = CurrentPDist + (WallHitPos - HitPos).magnitude
				local NewHitPos2 = HitPos2
				if NewPDist < S.Penetration and HitObj2 then
					NewHitPos2 = PenetrateWall(HitPos2, Direction, HitHumanoid, OriginPos, Bullet, CurrentPDist + NewPDist)
				end
				return NewHitPos2
			end
		else
			local LastPos = WallHitPos
			local TotalDistTraveled = 0
			spawn(function()
				if Hum then
					Damage(Hum.Parent:FindFirstChild("Head"), HumHitPos)
					return HumHitPos
				else
					while true do
						RS.RenderStepped:wait()
						if TotalDistTraveled >= S.BulletRange - HitDist then
							Bullet:Destroy()
							break
						end
						local DistTraveled = (Bullet.Position - LastPos).magnitude
						local NewDirection = (Bullet.Position - LastPos).unit
						local TempHitObj, TempHitPos = nil, nil
						if HitHumanoid then
							TempHitObj, TempHitPos = AdvRayCast(LastPos, NewDirection, DistTraveled, {Wall, HitHumanoid.Parent, unpack(Ignore)})
						else
							TempHitObj, TempHitPos = AdvRayCast(LastPos, NewDirection, DistTraveled, {Wall, unpack(Ignore)})
						end
						if TempHitObj then
							Damage(TempHitObj, TempHitPos)

							local NewPDist = CurrentPDist + (WallHitPos - HitPos).magnitude
							local NewTempPos = TempHitPos
							if NewPDist < S.Penetration and TempHitObj then
								NewTempPos = PenetrateWall(TempHitPos, Direction, HitHumanoid, OriginPos, Bullet, CurrentPDist + NewPDist)
							else
								Bullet:Destroy()
							end
							return NewTempPos
						else
							LastPos = Bullet.Position
							TotalDistTraveled = TotalDistTraveled + DistTraveled
						end
					end
				end
			end)
		end
	else
		if Bullet then Bullet:Destroy() end
		return HitPos
	end
end

function isEnemy(Human)
	local Plyr = game.Players:GetPlayerFromCharacter(Human.Parent)
	if (not Plyr) then return S.CanDamageNPCs end
	return S.AllowFriendlyFire or (Plyr.TeamColor ~= Player.TeamColor or Plyr.Neutral)
end

--------------------[ RELOAD FUNCTIONS ]----------------------------------------------

function animateReload()
	tweenJoint(LWeld2, CF(), CF(), Sine, 0.15)
	tweenJoint(RWeld2, CF(), CF(), Sine, 0.15)
	local magParts = {}
	local magTable = {}

	for _, Obj in pairs(Gun:GetChildren()) do
		if string.sub(Obj.Name, 1, 3) == "Mag" and Obj:IsA("BasePart") then
			INSERT(magParts, Obj)
		end
	end

	local animVars = {
		--FUNCTIONS--
		tweenJoint = tweenJoint;

		makeMagInvisible = function()
			for _, v in pairs(magParts) do
				v.Transparency = 1
			end
			magVisible = false
		end;

		makeMagVisible = function()
			for _, v in pairs(magParts) do
				v.Transparency = v:WaitForChild("magTrans").Value
			end
			magVisible = true
		end;

		isMagVisible = function()
			return magVisible
		end;

		isMagEmpty = function()
			return ammoInClip == 0
		end;

		setNewMag = function()
			newMag = true
		end;

		isNewMag = function()
			return newMag
		end;

		createMag = function(Key)
			local magModel = Instance.new("Model")
			local magClones = {}
			for i, v in pairs(magParts) do
				local vClone = v:Clone()
				vClone.Transparency = v:WaitForChild("magTrans").Value
				vClone.CanCollide = false
				vClone.Parent = magModel
				INSERT(magClones, {Original = v, magClone = vClone})
				if i ~= 1 then
					local W = Instance.new("Weld")
					W.Part0 = magClones[1].magClone
					W.Part1 = vClone
					W.C0 = magClones[1].magClone.CFrame:toObjectSpace(vClone.CFrame)
					W.Parent = magClones[1].magClone
				end
			end
			magTable[Key] = {magModel, magClones}
			return magModel, magClones
		end;

		getMag = function(Key)
			if magTable[Key] then
				return magTable[Key][1], magTable[Key][2]
			else
				return nil, nil
			end
		end;

		attachGripToHead = function()
			local handleCF = RArm.CFrame * Grip.C0
			Grip.C0 = Head.CFrame:toObjectSpace(handleCF)
			Grip.Part0 = Head
		end;

		attachGripToArm = function()
			local handleCF = Head.CFrame * Grip.C0
			Grip.C0 = RArm.CFrame:toObjectSpace(handleCF)
			Grip.Part0 = RArm
		end;

		Sine = Sine;

		Linear = Linear;

		--VARIABLES--
		Handle = Handle;
		LArm = LArm;
		RArm = RArm;
		LWeld = LWeld;
		RWeld = RWeld;
		LC0 = armC0[1];
		RC0 = armC0[2];
		Grip = Grip;
		gunIgnore = gunIgnore;
		Cam = Cam;
		CF = CF;
		CFANG = CFANG;
		V3 = V3;
		RAD = RAD;
		reloadTimeLoaded = S.reloadSettings.Times.Loaded;
		reloadTimeEmpty = S.reloadSettings.Times.Empty
	}

	local sequenceTable = Anims.Reload(animVars)
	--local T = tick()
	for _, reloadFunction in pairs(sequenceTable) do
		if breakReload then
			break
		end
		reloadFunction()

		if (not magVisible) then
			Ammo.Value = 0
		end
		updateClipAmmo()
	end
	--print(tick() - T) --I divide the reloadTime by this number to get the animation speed

	if (not isCrawling) then
		if Running and (not S.canFireWhileRunning) then
			tweenJoint(LWeld, armC0[1], S.runningC1.leftArm, Sine, 0.4)
			tweenJoint(RWeld, armC0[2], S.runningC1.rightArm, Sine, 0.4)
			tweenJoint(Grip, nil, S.runningC1.Grip, Sine, 0.4)
		else
			tweenJoint(LWeld, armC0[1], S.unAimedC1.leftArm, Sine, 0.4)
			tweenJoint(RWeld, armC0[2], S.unAimedC1.rightArm, Sine, 0.4)
			tweenJoint(Grip, nil, S.unAimedC1.Grip, Sine, 0.4)
		end
	end

	for _, v in pairs(magTable) do --In case the reload animations was stopped mid way and there were still fake mags that weren't deleted
		v[1]:Destroy()
	end
end

function Reload()
	if Ammo.Value < (ClipSize.Value + 1) and (not Reloading) and StoredAmmo.Value > 0 then
		Firing = false
		ammoInClip = (ammoInClip == 0 and Ammo.Value or ammoInClip)
		Reloading = true
		lowerSpread()
		if Aimed then unAimGun(S.reloadSettings.Anim) end
		crossHair.Reload.Visible = true
		if Handle:FindFirstChild("ReloadSound") then Handle.ReloadSound:Play() end
		if S.reloadSettings.Anim then
			wait()
			animateReload()
		else
			local startReload = tick()
			local initialReloadTime = Ammo.Value == 0 and S.reloadSettings.Times.Empty or S.reloadSettings.Times.Loaded
			while true do
				if breakReload then break end
				if (tick() - startReload) >= initialReloadTime then break end
				RS.RenderStepped:wait()
			end
		end
		if (not breakReload) then
			newMag = false
			if StoredAmmo.Value >= ClipSize.Value then
				if ammoInClip > 0 then
					StoredAmmo.Value = StoredAmmo.Value - ((ClipSize.Value + 1) - ammoInClip)
					Ammo.Value = ClipSize.Value + 1
				else
					StoredAmmo.Value = StoredAmmo.Value - ClipSize.Value
					Ammo.Value = ClipSize.Value
				end
			elseif StoredAmmo.Value < ClipSize.Value and StoredAmmo.Value > 0 then
				Ammo.Value = StoredAmmo.Value
				StoredAmmo.Value = 0
			end
		end
		Reloading = false
		if Selected then
			ammoInClip = (breakReload and ammoInClip or 0)
			crossHair.Reload.Visible = false
		end
		breakReload = false
	end

	updateClipAmmo()
	updateStoredAmmo()
end

--------------------[ EXTERNAL DATA LOCATING FUNCTIONS ]-----------------------------

function removeElement(Table, Element) --removes the first instance of Element from Table
	for i, v in pairs(Table) do
		if v == Element then
			table.remove(Table, i)
			break
		end
	end
	return Table
end

function findFirstClass(Object, Class)
	local foundObject = nil
	for _, Obj in pairs(Object:GetChildren()) do
		if Obj.ClassName == Class then
			foundObject = Obj
			break
		end
	end
	return foundObject
end

function isIgnored(Obj, Table)
	for _,v in pairs(Table) do
		if Obj == v or Obj:IsDescendantOf(v) then
			return true
		end
	end
	return false
end

function GetHitSurfaceCFrame(HitPos,Obj)
	local SurfaceCF = {
		{"Back",Obj.CFrame * CF(0,0,Obj.Size.z)};
		{"Bottom",Obj.CFrame * CF(0,-Obj.Size.y,0)};
		{"Front",Obj.CFrame * CF(0,0,-Obj.Size.z)};
		{"Left",Obj.CFrame * CF(-Obj.Size.x,0,0)};
		{"Right",Obj.CFrame * CF(Obj.Size.x,0,0)};
		{"Top",Obj.CFrame * CF(0,Obj.Size.y,0)}
	}
	local ClosestDist = HUGE
	local ClosestSurface = nil
	for _,v in pairs(SurfaceCF) do
		local SurfaceDist = (HitPos - v[2].p).magnitude
		if SurfaceDist < ClosestDist then
			ClosestDist = SurfaceDist
			ClosestSurface = v
		end
	end
	return ClosestSurface[2]
end

function AdvRayCast(Origin, Direction, Dist, CustomIgnore)
	local NewIgnore = (CustomIgnore and CustomIgnore or Ignore)
	local NewRay = Ray.new(Origin, Direction * (Dist > 999 and 999 or Dist))
	local HitObj, HitPos = game.Workspace:FindPartOnRayWithIgnoreList(NewRay, NewIgnore)
	local LastPos = HitPos
	local FinalHitObj, FinalHitPos = nil, nil
	local RepTimes = math.floor(Dist / 999)
	if (not HitObj) and (Dist > 999) then
		for i = 0, RepTimes do
			local NewDist = (i == RepTimes and  (Dist - (LastPos - Origin).magnitude) or 999)
			local Ray2 = Ray.new(LastPos, Direction * NewDist)
			local HitObj2, HitPos2 = game.Workspace:FindPartOnRayWithIgnoreList(Ray2, NewIgnore)
			if i ~= RepTimes then
				if HitObj2 then
					FinalHitObj, FinalHitPos = HitObj2, HitPos2
					break
				end
			elseif i == RepTimes then
				FinalHitObj, FinalHitPos = HitObj2, HitPos2
			end
			LastPos = HitPos2
		end
		return FinalHitObj, FinalHitPos
	elseif HitObj or (Dist <= 999) then
		return HitObj, HitPos
	end
end

--------------------[ JUMPING ANIMATION ]---------------------------------------------

function onFall(initialVelocity)
	spawn(function()
		local velocityAlpha = math.max(math.min(initialVelocity / Humanoid.JumpPower, 1), 0)
		local startJumpPos = jumpAnim.Pos
		local startJumpRot = jumpAnim.Rot
		local endJumpPos = 0.04 * S.fallSettings.fallMultiplier * velocityAlpha
		local endJumpRot = RAD(4) * S.fallSettings.fallMultiplier * velocityAlpha
		local t0 = tick()
		while true do
			RS.Heartbeat:wait()
			local Alpha = math.min((tick() - t0) / 0.15, 1) * 90
			if onGround then break end
			jumpAnim.Pos = numLerp(startJumpPos, endJumpPos, Sine(Alpha))
			jumpAnim.Rot = numLerp(startJumpRot, endJumpRot, Sine(Alpha))
			if Alpha == 90 then break end
		end
		startJumpPos = endJumpPos
		startJumpRot = endJumpRot
		endJumpPos = -0.08 * S.fallSettings.fallMultiplier
		endJumpRot = -RAD(8) * S.fallSettings.fallMultiplier
		local X = 1
		while true do
			local dt = RS.Heartbeat:wait()
			X = X + (dt * 60) / X
			local Alpha = (X - 1) / 15
			if onGround then break end
			jumpAnim.Pos = numLerp(startJumpPos, endJumpPos, Alpha)
			jumpAnim.Rot = numLerp(startJumpRot, endJumpRot, Alpha)
		end
	end)
end

function onLand(fallDist)
	spawn(function()
		local animAlpha = math.min(fallDist, S.fallSettings.maxDist) * (2 / 3)
		local startJumpPos = jumpAnim.Pos
		local startJumpRot = jumpAnim.Rot
		local endJumpPos = animAlpha / 100 * S.fallSettings.landMultiplier * (runReady and 1 or 2)
		local endJumpRot = RAD(animAlpha) * S.fallSettings.landMultiplier * (runReady and 1 or 2)
		local t0 = tick()
		while true do
			RS.Heartbeat:wait()
			local Alpha = math.min((tick() - t0) / 0.2, 1)
			if (not onGround) then break end
			jumpAnim.Pos = numLerp(startJumpPos, endJumpPos, Alpha)
			jumpAnim.Rot = numLerp(startJumpRot, endJumpRot, Alpha)
			if Alpha == 1 then break end
		end
		t0 = tick()
		while true do
			RS.Heartbeat:wait()
			local Alpha = math.min((tick() - t0) / 0.3, 1) * 90
			if (not onGround) then break end
			jumpAnim.Pos = numLerp(endJumpPos, 0, Sine(Alpha))
			jumpAnim.Rot = numLerp(endJumpRot, 0, Sine(Alpha))
			if Alpha == 90 then break end
		end
	end)
end

function onHumanoidStateChanged(oldState, newState)
	if newState == Enum.HumanoidStateType.Freefall then
		onGround = false
		if S.fallAnimation then
			onFall(HRP.Velocity.Y)
			while HRP.Velocity.Y > 0 do RS.RenderStepped:wait() end
			startFallHeight = HRP.Position.Y
		end
	elseif oldState == Enum.HumanoidStateType.Freefall then
		onGround = true
		if S.fallAnimation then
			local fallDist = startFallHeight - HRP.Position.Y
			onLand(fallDist)
		end
	end
end
--------------------[ CAMERA STEADYING FUNCTIONS ]------------------------------------

function steadyCamera()
	scopeSteady.Text = "Steadying..."
	scopeSteady.TextColor3 = Color3.new(1, 1, 0)
	camSteady = true
	local originalSway = camSway
	local Increment = 1.5 / 0.6
	local X = 0
	while true do
		RS.RenderStepped:wait()
		local newX = X + Increment
		X = (newX > 90 and 90 or newX)
		if (not steadyKeyPressed) then break end
		camSway = numLerp(originalSway, 0, Sine(X))
		if X == 90 then break end
	end
	while steadyKeyPressed and Aimed do
		if currentSteadyTime > 0 then
			local NewSteadyTime = currentSteadyTime - 1
			currentSteadyTime = (NewSteadyTime < 0 and 0 or NewSteadyTime)
			camSway = 0
		elseif currentSteadyTime == 0 then
			break
		end
		RS.RenderStepped:wait()
	end
	camSteady = false
	spawn(function()
		local Increment = 1.5 / 0.25
		local X = 0
		while true do
			RS.RenderStepped:wait()
			local newX = X + Increment
			X = (newX > 90 and 90 or newX)
			if camSteady then break end
			camSway = numLerp(0, S.scopeSettings.camSwayOnBreath, 1 - COS(RAD(X)))
			if X == 90 then break end
		end
		Increment = 1.5 / S.scopeSettings.breathTime
		X = 0
		while true do
			RS.RenderStepped:wait()
			local newX = X + Increment
			X = (newX > 90 and 90 or newX)
			if camSteady then break end
			camSway = numLerp(S.scopeSettings.camSwayOnBreath, 1, Sine(X))
			if X == 90 then break end
		end
		--[[for X = 0, 90, 1.5 / 0.2 do
			local Alpha = 1 - COS(RAD(X))--math.log10(X) / math.log10(90)
			camSway = numLerp(0, 3, Alpha)
			RS.RenderStepped:wait()
		end]]
		--[[for X = 0, 90, 1.5 / S.scopeSettings.steadyTime do
			if camSteady then break end
			local Alpha = SIN(RAD(X))
			camSway = numLerp(3, 1, Alpha)
			RS.RenderStepped:wait()
		end]]
	end)
	retakeBreath()
end

function retakeBreath()
	scopeSteady.Text = "Re-taking Breath"
	scopeSteady.TextColor3 = Color3.new(1, 0, 0)
	takingBreath = true
	local Increment = S.scopeSettings.steadyTime / S.scopeSettings.breathTime
	while takingBreath do
		if currentSteadyTime < maxSteadyTime then
			local newSteadyTime = currentSteadyTime + Increment
			currentSteadyTime = (newSteadyTime > maxSteadyTime and maxSteadyTime or newSteadyTime)
		elseif currentSteadyTime >= maxSteadyTime then
			break
		end
		RS.RenderStepped:wait()
	end
	if takingBreath then
		scopeSteady.Text = "Hold "..convertKey(S.Keys.scopeSteady).." to Steady"
		scopeSteady.TextColor3 = Color3.new(1, 1, 0)
		takingBreath = false
	end
end

--------------------[ SPRINTING FUNCTIONS ]-------------------------------------------

function canRun(midRun)
	return ((Forward and (not Backward)) and
		Walking and (Stamina > 0) and Running and
		Selected and (midRun and true or onGround) and
		runReady and (S.canFireWhileRunning and true or (not Firing))
	)
end

function monitorStamina()
	Running = true
	if (not canRun(false)) then
		Running = false
		return
	end
	if Aimed then unAimGun(true) end
	if Stance == 1 or Stance == 2 then Stand() end
	if (not (Reloading and S.reloadSettings.Anim)) then
		if S.canFireWhileRunning then
			tweenJoint(LWeld, armC0[1], S.unAimedC1.leftArm, Sine, 0.4)
			tweenJoint(RWeld, armC0[2], S.unAimedC1.rightArm, Sine, 0.4)
			tweenJoint(Grip, nil, S.unAimedC1.Grip, Sine, 0.4)
		else
			tweenJoint(LWeld, armC0[1], S.runningC1.leftArm, Sine, 0.4)
			tweenJoint(RWeld, armC0[2], S.runningC1.rightArm, Sine, 0.4)
			tweenJoint(Grip, nil, S.runningC1.Grip, Sine, 0.4)
		end
	end
	crossOffset = 50
	while runKeyPressed do
		if canRun(true) then
			if onGround then
				local newStamina = Stamina - 1
				Stamina = (newStamina < 0 and 0 or newStamina)
			end
		else
			break
		end
		RS.RenderStepped:wait()
	end
	Running = false
	if (not Aimed) and (not (Reloading and S.reloadSettings.Anim)) and (not S.canFireWhileRunning) then
		crossOffset = 0
		tweenJoint(LWeld, armC0[1], S.unAimedC1.leftArm, Sine, 0.4)
		tweenJoint(RWeld, armC0[2], S.unAimedC1.rightArm, Sine, 0.4)
		tweenJoint(Grip, nil, S.unAimedC1.Grip, Sine, 0.4)
	end

	rechargeStamina()
end

function rechargeStamina()
	chargingStamina = true
	while ((not runKeyPressed) or (Stamina < maxStamina)) and (not Running) do
		if Stamina < maxStamina then
			local newStamina = Stamina + (S.sprintTime / S.staminaCoolTime)
			Stamina = (newStamina > maxStamina and maxStamina or newStamina)
		elseif Stamina >= maxStamina then
			break
		end
		RS.RenderStepped:wait()
	end
	chargingStamina = false
end

--------------------[ STANCE FUNCTIONS ]----------------------------------------------

function Stand(onDeselected)
	local LHip = Torso["Left Hip"]
	local RHip = Torso["Right Hip"]
	LLegWeld.Part1 = nil
	LHip.Part1 = LLeg
	RLegWeld.Part1 = nil
	RHip.Part1 = RLeg
	Stance = 0
	spreadStance = "Stand"
	baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
	if S.stanceSettings.Anim and (not onDeselected) then
		spawn(function()
			local prevStanceSway = stanceSway
			local X = 0
			local Increment = 1.5 / S.stanceSettings.Speed
			while true do
				RS.RenderStepped:wait()
				local newX = X + Increment
				X = (newX > 90 and 90 or newX)
				if Stance ~= 0 then break end
				stanceSway = numLerp(prevStanceSway, 1, Sine(X))
				if X == 90 then break end
			end
		end)
		tweenJoint(ABWeld, CF(), nil, Sine, S.stanceSettings.Speed)
		tweenJoint(LLegWeld, legC0.Stand[1], nil, Sine, S.stanceSettings.Speed)
		tweenJoint(RLegWeld, legC0.Stand[2], nil, Sine, S.stanceSettings.Speed)
		tweenJoint(LHip, CF(-1, -1, 0) * CFANG(0, RAD(-90), 0), CF(-0.5, 1, 0) * CFANG(0, RAD(-90), 0), Sine, S.stanceSettings.Speed)
		tweenJoint(RHip, CF(1, -1, 0) * CFANG(RAD(-180), RAD(90), 0), CF(0.5, 1, 0) * CFANG(RAD(-180), RAD(90), 0), Sine, S.stanceSettings.Speed)
		tweenJoint(Root, CFANG(RAD(-90), 0, RAD(180)), nil, Sine, S.stanceSettings.Speed)
		tweenJoint(headWeld, CF(0, 1.5, 0), nil, Sine, S.stanceSettings.Speed)
	elseif onDeselected or (not S.stanceSettings.Anim) then
		ABWeld.C0 = CF()
		LLegWeld.C0 = legC0.Stand[1]
		RLegWeld.C0 = legC0.Stand[2]
		LHip.C0, LHip.C1 = CF(-1, -1, 0) * CFANG(0, RAD(-90), 0), CF(-0.5, 1, 0) * CFANG(0, RAD(-90), 0)
		RHip.C0, RHip.C1 = CF(1, -1, 0) * CFANG(RAD(-180), RAD(90), 0), CF(0.5, 1, 0) * CFANG(RAD(-180), RAD(90), 0)
		Root.C0 = CFANG(RAD(-90), 0, RAD(180))
		headWeld.C0 = CF(0, 1.5, 0)
	end
end

function Crouch()
	local LHip = Torso["Left Hip"]
	local RHip = Torso["Right Hip"]
	LHip.Part1 = nil
	LLegWeld.Part1 = LLeg
	RHip.Part1 = nil
	RLegWeld.Part1 = RLeg
	Stance = 1
	spreadStance = "Crouch"
	baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
	if S.stanceSettings.Anim then
		spawn(function()
			local prevStanceSway = stanceSway
			local X = 0
			local Increment = 1.5 / S.stanceSettings.Speed
			while true do
				RS.RenderStepped:wait()
				local newX = X + Increment
				X = (newX > 90 and 90 or newX)
				if Stance ~= 1 then break end
				stanceSway = numLerp(prevStanceSway, 0.75, Sine(X))
				if X == 90 then break end
			end
		end)
		tweenJoint(ABWeld, CF(0, 0, -0.05), nil, Sine, S.stanceSettings.Speed)
		tweenJoint(LLegWeld, legC0.Crouch[1], nil, Sine, S.stanceSettings.Speed)
		tweenJoint(RLegWeld, legC0.Crouch[2], nil, Sine, S.stanceSettings.Speed)
		tweenJoint(LHip, CF(-1, -0.5, 0) * CFANG(0, RAD(-90), 0), CF(-0.5, 0.5, 1) * CFANG(0, RAD(-90), RAD(-90)), Sine, S.stanceSettings.Speed)
		tweenJoint(RHip, CF(1, -0.5, 0.25) * CFANG(RAD(-180), RAD(90), 0), CF(0.5, 0.5, 1) * CFANG(RAD(-180), RAD(90), 0), Sine, S.stanceSettings.Speed)
		tweenJoint(Root, CF(0, -1, 0) * CFANG(RAD(-90), 0, RAD(180)), nil, Sine, S.stanceSettings.Speed)
		tweenJoint(headWeld, CF(0, 1.5, 0), nil, Sine, S.stanceSettings.Speed)
	else
		ABWeld.C0 = CF(0, 0, -1 / 16)
		LLegWeld.C0 = legC0.Crouch[1]
		RLegWeld.C0 = legC0.Crouch[2]
		LHip.C0, LHip.C1 = CF(-1, -0.5, 0) * CFANG(0, RAD(-90), 0), CF(-0.5, 0.5, 1) * CFANG(0, RAD(-90), RAD(-90))
		RHip.C0, RHip.C1 = CF(1, -0.5, 0.25) * CFANG(RAD(-180), RAD(90), 0), CF(0.5, 0.5, 1) * CFANG(RAD(-180), RAD(90), 0)
		Root.C0 = CF(0, -1, 0) * CFANG(RAD(-90), 0, RAD(180))
		headWeld.C0 = CF(0, 1.5, 0)
	end
end

function Prone()
	local LHip = Torso["Left Hip"]
	local RHip = Torso["Right Hip"]
	LHip.Part1 = nil
	LLegWeld.Part1 = LLeg
	RHip.Part1 = nil
	RLegWeld.Part1 = RLeg
	Stance = 2
	spreadStance = "Prone"
	baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
	if S.stanceSettings.Anim then
		spawn(function()
			local prevStanceSway = stanceSway
			local X = 0
			local Increment = 1.5 / S.stanceSettings.Speed
			while true do
				RS.RenderStepped:wait()
				local newX = X + Increment
				X = (newX > 90 and 90 or newX)
				if Stance ~= 2 then break end
				stanceSway = numLerp(prevStanceSway, 0.5, Sine(X))
				if X == 90 then break end
			end
		end)
		tweenJoint(ABWeld, CF(0, 0, -0.1), nil, Sine, S.stanceSettings.Speed)
		tweenJoint(LLegWeld, legC0.Prone[1], nil, Sine, S.stanceSettings.Speed)
		tweenJoint(RLegWeld, legC0.Prone[2], nil, Sine, S.stanceSettings.Speed)
		tweenJoint(Root, CF(0, -2.5, 1) * CFANG(RAD(180), 0, RAD(180)), nil, Sine, S.stanceSettings.Speed)
		tweenJoint(headWeld, CF(0, 1, 1) * CFANG(RAD(90), 0, 0), nil, Sine, S.stanceSettings.Speed)
	else
		ABWeld.C0 = CF(0, 0, -1 / 8)
		LLegWeld.C0 = legC0.Prone[1]
		RLegWeld.C0 = legC0.Prone[2]
		Root.C0 = CF(0, -2.5, 1) * CFANG(RAD(180), 0, RAD(180))
		headWeld.C0 = CF(0, 1, 1) * CFANG(RAD(90), 0, 0)
	end
end

function Dive()
	onGround = false
	local diveDirection = (HRP.CFrame * CFANG(S.diveSettings.Angle, 0, 0)).lookVector * S.walkSpeeds.Sprinting * S.diveSettings.Force
	local BF = Instance.new("BodyForce")
	BF.force = diveDirection + Vector3.new(0, playerMass * 196.2, 0)
	BF.Parent = HRP
	--[[spawn(function()
		HRP.Velocity = HRP.CFrame.lookVector * 60 + V3(0, 40, 0)
		wait(0.1)
		HRP.Velocity = HRP.CFrame.lookVector * 70 + V3(0, 30, 0)
		wait(0.4)
		HRP.Velocity = HRP.CFrame.lookVector * 30 + V3(0, -10, 0)
	end)]]
	delay(0.05, function()
		spawn(function()
			while true do
				local newRay = Ray.new(HRP.Position, V3(0, -3.1, 0))
				local H, _ = workspace:FindPartOnRayWithIgnoreList(newRay, Ignore)
				if H then
					onGround = true
					break
				end
				wait()
			end
		end)
		Prone()
		wait(0.1)
		BF:Destroy()
	end)
end

--------------------[ MOUSE FUNCTIONS ]-----------------------------------------------

function onMB1Down()
	MB1Down = true
	firstShot = true
	if fireFunction then
		fireFunction()
	end
end

function onMB1Up()
	MB1Down = false
	lowerSpread()
end

function onMB2Down()
	if S.aimSettings.holdToADS then
		if (not AimingIn) and (not Aimed) then
			AimingIn = true
			aimGun()
			AimingIn = false
		end
	else
		if Aimed then
			unAimGun()
		else
			aimGun()
		end
	end
end

function onMB2Up()
	if S.aimSettings.holdToADS then
		if (not AimingOut) and Aimed then
			AimingOut = true
			unAimGun()
			AimingOut = false
		end
	end
end

function onScrollUp()
	local newAimSensitivity = aimSensitivity + S.sensitivitySettings.Increment
	aimSensitivity = (
		newAimSensitivity < S.sensitivitySettings.Min and S.sensitivitySettings.Min or
		newAimSensitivity > S.sensitivitySettings.Max and S.sensitivitySettings.Max or
		newAimSensitivity
	)
	mouseSensitivity = (Aimed and aimSensitivity or mouseSensitivity)

	Sens.Text = "S: "..aimSensitivity
	if mainGUI:IsDescendantOf(game) then
		Sens.Visible = true
		local t0 = tick()
		lastSensUpdate = t0

		wait(0.3)

		if lastSensUpdate <= t0 then
			Sens.Visible = false
		end
	end
end

function onScrollDown()
	local newAimSensitivity = aimSensitivity - S.sensitivitySettings.Increment
	aimSensitivity = (
		newAimSensitivity < S.sensitivitySettings.Min and S.sensitivitySettings.Min or
		newAimSensitivity > S.sensitivitySettings.Max and S.sensitivitySettings.Max or
		newAimSensitivity
	)
	mouseSensitivity = (Aimed and aimSensitivity or mouseSensitivity)

	Sens.Text = "S: "..aimSensitivity
	if mainGUI:IsDescendantOf(game) then
		Sens.Visible = true
		local t0 = tick()
		lastSensUpdate = t0

		wait(0.3)

		if lastSensUpdate <= t0 then
			Sens.Visible = false
		end
	end
end

--------------------[ KEYBOARD FUNCTIONS ]--------------------------------------------

function keyDown(K)
	local Key = string.lower(K)

	if Key == S.Keys.lowerStance and S.canChangeStance then
		if (not Running) then
			if Stance == 0 then
				if S.stanceSettings.Stances.Crouch then
					Crouch()
				elseif S.stanceSettings.Stances.Prone then
					Prone()
				end
			elseif Stance == 1 then
				if S.stanceSettings.Stances.Prone then
					Prone()
				end
			end
		elseif S.dolphinDive then
			wait()
			if Humanoid:GetState() ~= Enum.HumanoidStateType.Freefall and (not UIS:IsKeyDown("Space")) and runReady then
				local tempConnection = Humanoid.Changed:connect(function()
					Humanoid.Jump = false
				end)
				runReady = false
				Dive()
				Running = false
				wait(S.diveSettings.rechargeTime)
				tempConnection:disconnect()
				runReady = true
			end
		end
	end

	if Key == S.Keys.raiseStance and S.canChangeStance then
		if (not Running) then
			if Stance == 2 then
				if S.stanceSettings.Stances.Crouch then
					Crouch()
				else
					Stand()
				end
			elseif Stance == 1 then
				Stand()
			end
		end
	end

	if Key == S.Keys.ADS then
		if S.aimSettings.holdToADS then
			if (not AimingIn) and (not Aimed) then
				AimingIn = true
				aimGun()
				AimingIn = false
			end
		else
			if Aimed then
				unAimGun()
			else
				aimGun()
			end
		end
	end

	if Key == S.Keys.selectFire and S.selectFire then
		if canSelectFire then
			canSelectFire = false
			rawFireMode = rawFireMode + 1
			modeGUI.Text = Modes[((rawFireMode - 1) % numModes) + 1]
			if modeGUI.Text == "AUTO" then
				fireFunction = autoFire
			elseif modeGUI.Text == "BURST" then
				fireFunction = burstFire
			elseif modeGUI.Text == "SEMI" then
				fireFunction = semiFire
			else
				fireFunction = nil
			end
			local speedAlpha = S.selectFireSettings.animSpeed / 0.6
			if S.selectFireSettings.GUI then
				spawn(function()
					fireSelect.Visible = true
					local prevRawFireMode = rawFireMode
					local Increment = 1.5 / (speedAlpha * 0.25)
					local X = 0
					wait(speedAlpha * 0.1)
					while true do
						RS.RenderStepped:wait()
						local newX = X + Increment
						X = (newX > 90 and 90 or newX)
						if prevRawFireMode ~= rawFireMode then break end
						updateModeLabels(rawFireMode - 1, rawFireMode, X)
						if X == 90 then break end
					end
					wait(speedAlpha * 0.25)
					fireSelect.Visible = false
				end)
			end
			if S.selectFireSettings.Animation and (not Aimed) and (not isRunning) and (not isCrawling) then
				spawn(function()
					local sequenceTable = {
						function()
							tweenJoint(RWeld2, nil, CFANG(0, RAD(5), 0), Sine, speedAlpha * 0.15)
							tweenJoint(LWeld, armC0[1], CF(0.1, 1, -0.3) * CFANG(RAD(-7), 0, RAD(-65)), Linear, speedAlpha * 0.15)
							wait(speedAlpha * 0.2)
						end;

						function()
							tweenJoint(LWeld, armC0[1], CF(0.1, 1, -0.3) * CFANG(RAD(-10), 0, RAD(-65)), Linear, speedAlpha * 0.1)
							wait(speedAlpha * 0.2)
						end;

						function()
							tweenJoint(RWeld2, nil, CF(), Sine, speedAlpha * 0.2)
							tweenJoint(LWeld, armC0[1], S.unAimedC1.leftArm, Sine, speedAlpha * 0.2)
							wait(speedAlpha * 0.2)
						end;
					}

					for _, F in pairs(sequenceTable) do
						if Aimed or isRunning or isCrawling or Reloading then
							break
						end
						F()
					end
				end)
			end
			if S.selectFireSettings.Animation or S.selectFireSettings.GUI then
				wait(S.selectFireSettings.animSpeed)
			end
			canSelectFire = true
		end
	end

	if Key == S.Keys.Reload then
		if (not Reloading) and (not isCrawling) then
			Reload()
		end
	end

	if Key == S.Keys.Sprint then
		runKeyPressed = true
		if runReady then
			if (not Idling) and Walking and (not Running) and (not Knifing) and (not (Aimed and S.guiScope and S.Keys.Sprint == S.Keys.scopeSteady)) then
				monitorStamina()
			end
		end
	end

	if Key == S.Keys.scopeSteady then
		steadyKeyPressed = true
		if Aimed and (not Aiming) then
			takingBreath = false
			steadyCamera()
		end
	end

	for _, PTable in pairs(Plugins.KeyDown) do
		if Key == string.lower(PTable.Key) then
			spawn(function()
				PTable.Plugin()
			end)
		end
	end
end

function keyUp(K)
	local Key = string.lower(K)

	if Key == S.Keys.ADS then
		if S.aimSettings.holdToADS then
			if (not AimingOut) and Aimed then
				AimingOut = true
				unAimGun()
				AimingOut = false
			end
		end
	end

	if Key == S.Keys.Sprint then
		runKeyPressed = false
		Running = false
		if (not chargingStamina) then
			rechargeStamina()
		end
	end

	if Key == S.Keys.scopeSteady then
		steadyKeyPressed = false
	end

	for _, PTable in pairs(Plugins.KeyUp) do
		if Key == string.lower(PTable.Key) then
			spawn(function()
				PTable.Plugin()
			end)
		end
	end
end

--------------------[ END FUNCTIONS ]-------------------------------------------------

--------------------------------------------------------------------------------------
--------------------[ PRE-CONNECTIONS ]-----------------------------------------------
--------------------------------------------------------------------------------------

local function updateAnimVars()
	wait()
	Forward = (UIS:IsKeyDown("W") or UIS:IsKeyDown("Up"))
	Backward = (UIS:IsKeyDown("S") or UIS:IsKeyDown("Down"))
	local Right = UIS:IsKeyDown("D")
	local Left = UIS:IsKeyDown("A")

	local walkingForward = (Forward and (not Backward))
	local walkingBackward = ((not Forward) and Backward)
	local walkingRight = (Right and (not Left))
	local walkingLeft = ((not Right) and Left)

	if (Forward or Backward or Right or Left) then
		Walking, Idling = true, false
		if (not Running) and (not Aimed) then
			spreadMotion = "Moving"
			baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
		end
	elseif (not (Forward and Backward and Right and Left)) then
		Walking, Idling = false, true
		if (not Aimed) then
			spreadMotion = "Idling"
			baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
		end
	end

	local newArmTilt = (
		((walkingForward or walkingBackward) and walkingRight) and 2.5 or
		((walkingForward or walkingBackward) and walkingLeft) and -2.5 or
		((not (walkingForward and walkingBackward)) and walkingRight) and 5 or
		((not (walkingForward and walkingBackward)) and walkingLeft) and -5 or 0
	)
	local newMoveAng = (
		(walkingForward and (not (walkingRight or walkingLeft))) and 0 or
		(walkingForward and walkingRight) and RAD(-45) or
		((not (walkingForward or walkingBackward)) and walkingRight) and RAD(-90) or
		(walkingBackward and walkingRight) and RAD(-135) or
		(walkingBackward and (not (walkingRight or walkingLeft))) and (moveAng < 0 and RAD(-180) or RAD(180)) or
		(walkingBackward and walkingLeft) and RAD(135) or
		((not (walkingForward or walkingBackward)) and walkingLeft) and RAD(90) or
		(walkingForward and walkingLeft) and RAD(45) or 0
	)

	local newAnimCode = math.random(-1e9, 1e9)
	animCode = newAnimCode
	local startTilt = armTilt
	local startAng = (ABS(moveAng) == RAD(180)) and (newMoveAng > 0 and RAD(180) or RAD(-180)) or moveAng
	local Increment = (startTilt == newArmTilt and 1.5 / 0.7 or 1.5 / (0.35 * ABS(startTilt - newArmTilt) / 5))
	local X = 0
	while true do
		RS.RenderStepped:wait()
		local newX = X + Increment
		X = (newX > 90 and 90 or newX)
		if animCode ~= newAnimCode then break end
		armTilt = numLerp(startTilt, newArmTilt, Sine(X))
		moveAng = numLerp(startAng, newMoveAng, Sine(X))
		if X == 90 then break end
	end
end

M2.KeyDown:connect(updateAnimVars)
M2.KeyUp:connect(updateAnimVars)
updateAnimVars()

--------------------------------------------------------------------------------------
--------------------[ TOOL SELECTION AND DESELECTION ]--------------------------------
--------------------------------------------------------------------------------------

function onEquipped()
	wait()
	if Humanoid.Health ~= 0 and (not Selected) and Gun.Parent == Char then
		Selected = true
		breakReload = false
		equipAnimPlaying = true

		math.randomseed(tick()) --This sets a new seed for the random function each time you select the gun

		--------------------[ FAILSAFE RESETING ]-------------------------------------

		for _, GM in pairs(ignoreModel:GetChildren()) do
			if GM.Name == "gunIgnore_"..Player.Name then
				GM:Destroy()
			end
		end

		for _, c in pairs(Connections) do
			c:disconnect()
		end

		Connections = {}

		--------------------[ REMOTE GUN SETUP ]--------------------------------------

		--[[local Vars = {
			ignoreModel = ignoreModel;
			Humanoid = Humanoid;
			Shoulders = Shoulders;
			Torso = Torso;
			Head = Head;
			armC0 = armC0;
			leftArmC1 = S.equipSettings.leftArmC1;
			rightArmC1 = S.equipSettings.rightArmC1;
			LArm = LArm;
			RArm = RArm;
			gunParts = gunParts;
			Handle = Handle;
		}
		gunIgnore, playerFolder, headWeld, headWeld2, animWeld, ABWeld, LWeld, RWeld, LWeld2, RWeld2, LLegWeld, RLegWeld, gunParts2 = gunSetup:InvokeServer(Vars)]]

		--------------------[ CREATING IGNORE MODELS ]--------------------------------

		gunIgnore = Instance.new("Model")
		gunIgnore.Name = "gunIgnore_"..Player.Name
		gunIgnore.Parent = ignoreModel

		--------------------[ MODIFYING THE PLAYER ]----------------------------------

		Player.CameraMode = Enum.CameraMode.LockFirstPerson
		Cam.CameraType = Enum.CameraType.Scriptable
		Cam.FieldOfView = 80
		UIS.MouseBehavior = Enum.MouseBehavior.LockCenter
		UIS.MouseIconEnabled = false

		local initialX, initialY = getYawPitch(Cam.CoordinateFrame)
		camAng = -VEC2(initialX, initialY)

		mainGUI.Parent = Player.PlayerGui

		setUpGUI()
		updateHealth()

		if S.selectFire then
			local currentMode = Modes[((rawFireMode - 1) % numModes) + 1]
			if currentMode == "AUTO" then
				fireFunction = autoFire
			elseif currentMode == "BURST" then
				fireFunction = burstFire
			elseif currentMode == "SEMI" then
				fireFunction = semiFire
			else
				fireFunction = nil
			end
		else
			if S.gunType.Semi then
				fireFunction = semiFire
			elseif S.gunType.Auto then
				fireFunction = autoFire
			elseif S.gunType.Burst then
				fireFunction = burstFire
			else
				fireFunction = nil
			end
		end

		changePlayerTrans(Char, 1)

		Humanoid.AutoRotate = false

		Shoulders.Right.Part1 = nil
		Shoulders.Left.Part1 = nil

		playerFolder = Instance.new("Model")
		playerFolder.Name = "playerFolder"
		playerFolder.Parent = gunIgnore

		local headBase = Instance.new("Part")
		headBase.Transparency = 1
		headBase.Name = "headBase"
		headBase.CanCollide = false
		headBase.FormFactor = Enum.FormFactor.Custom
		headBase.Size = V3(0.2, 0.2, 0.2)
		headBase.BottomSurface = Enum.SurfaceType.Smooth
		headBase.TopSurface = Enum.SurfaceType.Smooth
		headBase.Parent = playerFolder

		headWeld = Instance.new("Weld")
		headWeld.Part0 = Torso
		headWeld.Part1 = headBase
		headWeld.C0 = CF(0, 1.5, 0)
		headWeld.Parent = Torso

		headWeld2 = Instance.new("Weld")
		headWeld2.Part0 = headBase
		headWeld2.Part1 = Head
		headWeld2.Parent = headBase

		neckClone = Neck:Clone()

		--[[local stanceBase = Instance.new("Part")
		stanceBase.Transparency = 1
		stanceBase.Name = "stanceBase"
		stanceBase.CanCollide = false
		stanceBase.FormFactor = Enum.FormFactor.Custom
		stanceBase.Size = V3(0.2, 0.2, 0.2)
		stanceBase.BottomSurface = Enum.SurfaceType.Smooth
		stanceBase.TopSurface = Enum.SurfaceType.Smooth
		stanceBase.Parent = playerFolder

		stanceWeld = Instance.new("Weld")
		stanceWeld.Part0 = stanceBase
		stanceWeld.Part1 = Torso
		stanceWeld.Parent = stanceBase]]

		local animBase = Instance.new("Part")
		animBase.Transparency = 1
		animBase.Name = "animBase"
		animBase.CanCollide = false
		animBase.FormFactor = Enum.FormFactor.Custom
		animBase.Size = V3(0.2, 0.2, 0.2)
		animBase.BottomSurface = Enum.SurfaceType.Smooth
		animBase.TopSurface = Enum.SurfaceType.Smooth
		animBase.Parent = playerFolder

		animWeld = Instance.new("Weld")
		animWeld.Part0 = animBase
		animWeld.Part1 = headBase
		animWeld.Parent = animBase

		local ArmBase = Instance.new("Part")
		ArmBase.Transparency = 1
		ArmBase.Name = "ArmBase"
		ArmBase.CanCollide = false
		ArmBase.FormFactor = Enum.FormFactor.Custom
		ArmBase.Size = V3(0.2, 0.2, 0.2)
		ArmBase.BottomSurface = Enum.SurfaceType.Smooth
		ArmBase.TopSurface = Enum.SurfaceType.Smooth
		ArmBase.Parent = playerFolder

		ABWeld = Instance.new("Weld")
		ABWeld.Part0 = ArmBase
		ABWeld.Part1 = animBase
		ABWeld.Parent = ArmBase

		local LArmBase = Instance.new("Part")
		LArmBase.Transparency = 1
		LArmBase.Name = "LArmBase"
		LArmBase.CanCollide = false
		LArmBase.FormFactor = Enum.FormFactor.Custom
		LArmBase.Size = V3(0.2, 0.2, 0.2)
		LArmBase.BottomSurface = Enum.SurfaceType.Smooth
		LArmBase.TopSurface = Enum.SurfaceType.Smooth
		LArmBase.Parent = playerFolder

		local RArmBase = Instance.new("Part")
		RArmBase.Transparency = 1
		RArmBase.Name = "RArmBase"
		RArmBase.CanCollide = false
		RArmBase.FormFactor = Enum.FormFactor.Custom
		RArmBase.Size = V3(0.2, 0.2, 0.2)
		RArmBase.BottomSurface = Enum.SurfaceType.Smooth
		RArmBase.TopSurface = Enum.SurfaceType.Smooth
		RArmBase.Parent = playerFolder

		LWeld = Instance.new("Weld")
		LWeld.Name = "LWeld"
		LWeld.Part0 = ArmBase
		LWeld.Part1 = LArmBase
		LWeld.C0 = armC0[1]
		LWeld.C1 = S.equipSettings.leftArmC1
		LWeld.Parent = ArmBase

		RWeld = Instance.new("Weld")
		RWeld.Name = "RWeld"
		RWeld.Part0 = ArmBase
		RWeld.Part1 = RArmBase
		RWeld.C0 = armC0[2]
		RWeld.C1 = S.equipSettings.rightArmC1
		RWeld.Parent = ArmBase

		LWeld2 = Instance.new("Weld")
		LWeld2.Name = "LWeld"
		LWeld2.Part0 = LArmBase
		LWeld2.Part1 = LArm
		LWeld2.Parent = LArmBase

		RWeld2 = Instance.new("Weld")
		RWeld2.Name = "RWeld"
		RWeld2.Part0 = RArmBase
		RWeld2.Part1 = RArm
		RWeld2.Parent = RArmBase

		LLegWeld = Instance.new("Weld")
		LLegWeld.Name = "LLegWeld"
		LLegWeld.Part0 = Torso
		LLegWeld.Part1 = nil
		LLegWeld.C0 = CF(-0.5, -2, 0)
		LLegWeld.Parent = Torso

		RLegWeld = Instance.new("Weld")
		RLegWeld.Name = "RLegWeld"
		RLegWeld.Part0 = Torso
		RLegWeld.Part1 = nil
		RLegWeld.C0 = CF(0.5, -2, 0)
		RLegWeld.Parent = Torso

		if S.playerArms then
			armModel = Instance.new("Model", workspace.FilteringEnabled and playerFolder or Cam)

			fakeLArm = LArm:Clone()
			fakeLArm.Parent = armModel
			fakeLArm.Transparency = S.fakeArmSettings.Transparency
			fakeLArm.CanCollide = false
			fakeLArm.Size = S.fakeArmSettings.armSize
			fakeLArm:BreakJoints()

			--LArm.Transparency = 1

			local fakeLWeld = Instance.new("Weld")
			fakeLWeld.Part0 = fakeLArm
			fakeLWeld.Part1 = LArm
			fakeLWeld.Parent = fakeLArm

			fakeRArm = RArm:Clone()
			fakeRArm.Parent = armModel
			fakeRArm.Transparency = S.fakeArmSettings.Transparency
			fakeRArm.CanCollide = false
			fakeRArm.Size = S.fakeArmSettings.armSize
			fakeRArm:BreakJoints()

			--RArm.Transparency = 1

			local fakeRWeld = Instance.new("Weld")
			fakeRWeld.Part0 = fakeRArm
			fakeRWeld.Part1 = RArm
			fakeRWeld.Parent = fakeRArm

			Instance.new("Humanoid", armModel)

			if S.fakeArmSettings.characterMeshes then
				for _,Obj in pairs(Char:GetChildren()) do
					if Obj:IsA("CharacterMesh") then
						Obj:Clone().Parent = armModel
					end
				end
			end
			for _,Obj in pairs(Char:GetChildren()) do
				if Obj:IsA("Shirt") then
					Obj:Clone().Parent = armModel
				end
			end
		else
			armTable = createArms()
			if workspace.FilteringEnabled then
				armTable[1].Model.Parent = playerFolder
				armTable[2].Model.Parent = playerFolder
			else
				armTable[1].Model.Parent = Cam--playerFolder
				armTable[2].Model.Parent = Cam--playerFolder
			end

			fakeLArm = armTable[1].armPart

			--LArm.Transparency = 1

			local fakeLWeld = Instance.new("Weld")
			fakeLWeld.Part0 = fakeLArm
			fakeLWeld.Part1 = LArm
			fakeLWeld.Parent = fakeLArm

			fakeRArm = armTable[2].armPart

			--RArm.Transparency = 1

			local fakeRWeld = Instance.new("Weld")
			fakeRWeld.Part0 = fakeRArm
			fakeRWeld.Part1 = RArm
			fakeRWeld.Parent = fakeRArm
		end

		--------------------[ MODIFYING THE GUN ]-------------------------------------

		for _, Tab in pairs(gunParts) do
			local Weld = Instance.new("Weld")
			Weld.Name = "MainWeld"
			Weld.Part0 = Handle
			Weld.Part1 = Tab.Obj
			Weld.C0 = Tab.Obj.weldCF.Value
			Weld.Parent = Handle
			Tab.Weld = Weld
		end

		Grip = RArm:WaitForChild("RightGrip")

		local handleCF = Torso.CFrame * CF(0, 0.5, 0) * armC0[2] * S.aimedC1.rightArm:inverse() * Grip.C0
		local handleOffset = AimPart.CFrame:toObjectSpace(Handle.CFrame)
		aimedGripCF = ((Torso.CFrame * CF(headOffset.X, headOffset.Y, 0)) * handleOffset):toObjectSpace(handleCF)

		Grip.C1 = S.equipSettings.GripC1

		--------------------[ RUNNING PLUGINS ]---------------------------------------

		for _, Plugin in pairs(Plugins.OnEquipped) do
			spawn(function()
				Plugin()
			end)
		end

		--------------------[ GETTING PLAYER MASS ]-----------------------------------

		local connectedParts = HRP:GetConnectedParts(true)
		for _, v in pairs(connectedParts) do
			if v:IsA("BasePart") then
				playerMass = playerMass + v:GetMass()
			end
		end

		--------------------[ CONNECTIONS ]-------------------------------------------

		INSERT(Connections, Humanoid.Died:connect(function()
			onUnequipped(true)
		end))

		INSERT(Connections, Humanoid.Jumping:connect(function()
			if Stance ~= 0 then
				Stand()
			end
		end))

		INSERT(Connections, Humanoid.StateChanged:connect(onHumanoidStateChanged))

		INSERT(Connections, Humanoid.HealthChanged:connect(updateHealth))

		INSERT(Connections, M2.Button1Down:connect(onMB1Down))

		INSERT(Connections, M2.Button1Up:connect(onMB1Up))

		INSERT(Connections, M2.Button2Down:connect(onMB2Down))

		INSERT(Connections, M2.Button2Up:connect(onMB2Up))

		INSERT(Connections, M2.KeyDown:connect(keyDown))

		INSERT(Connections, M2.KeyUp:connect(keyUp))

		if S.sensitivitySettings.scrollToChange then
			INSERT(Connections, M2.WheelForward:connect(onScrollUp))
			INSERT(Connections, M2.WheelBackward:connect(onScrollDown))
		end

		if S.AutoKnife then
			INSERT(Connections, RS.Stepped:connect(function()
				local H, P = AdvRayCast(Head.CFrame.p, Head.CFrame.lookVector, S.AutoKnifeDist, nil)
				if H then
					local HitHuman = findFirstClass(H.Parent, "Humanoid")
					if HitHuman and isEnemy(HitHuman) and HitHuman.Health ~= 0 then
						Knife()
					end
				end
			end))
		end

		INSERT(Connections, UIS.InputChanged:connect(function(inputObj)
			if inputObj.UserInputType == Enum.UserInputType.MouseMovement then
				local rawCamAng = camAng - (VEC2(RAD(inputObj.Delta.x), RAD(inputObj.Delta.y)) * mouseSensitivity * 0.25)
				camAng = VEC2(rawCamAng.x, (rawCamAng.y > RAD(80) and RAD(80) or rawCamAng.y < RAD(-80) and RAD(-80) or rawCamAng.y))

				desiredXOffset = math.min(math.max(inputObj.Delta.x, -S.momentumSettings.maxInput), S.momentumSettings.maxInput)
				desiredYOffset = math.min(math.max(inputObj.Delta.y, -S.momentumSettings.maxInput), S.momentumSettings.maxInput)
			end
		end))

		INSERT(Connections, M2.Idle:connect(function(inputObj)
			desiredXOffset = 0
			desiredYOffset = 0
		end))

		INSERT(Connections, RS.Stepped:connect(function()
			if tick() - lastBeat > (Humanoid.Health / 75) then
				lastBeat = tick()
				HUD.Health.Tray.Beat:TweenPosition(
					UDim2.new(0, -21, 0, 0),
					Enum.EasingDirection.Out,
					Enum.EasingStyle.Linear,
					0.7 - ((100 - Humanoid.Health) / 400),
					false,
					function()
						HUD.Health.Tray.Beat.Position = UDim2.new(1, 0, 0, 0)
					end
				)
			end
		end))

		INSERT(Connections, RS.RenderStepped:connect(function()
			--Main animation
			local animC0, animC1 = getAnimCF()
			animWeld.C0 = animC0
			animWeld.C1 = animC1

			--Camera updating
			renderCamera()
		end))

		--------------------[ ANIMATE GUN ]-------------------------------------------

		tweenJoint(LWeld, nil, S.unAimedC1.leftArm, Sine, S.equipSettings.Time)
		tweenJoint(RWeld, nil, S.unAimedC1.rightArm, Sine, S.equipSettings.Time)
		tweenJoint(Grip, nil, S.unAimedC1.Grip, Sine, S.equipSettings.Time)
		spawn(function()
			local T = tick()
			while true do
				if tick() - T > S.equipSettings.Time then break end
				if (not Selected) then break end
				wait()
			end
			equipAnimPlaying = false
		end)

		Animate()
	end
end

function onUnequipped(deleteTool)
	if Selected then
		Selected = false

		breakReload = true

		--------------------[ RUNNING PLUGINS ]---------------------------------------

		for _, Plugin in pairs(Plugins.OnUnEquipped) do
			spawn(function()
				Plugin()
			end)
		end

		--------------------[ MODIFYING THE PLAYER ]----------------------------------

		Cam.FieldOfView = 70
		Cam.CameraType = Enum.CameraType.Custom

		UIS.MouseBehavior = Enum.MouseBehavior.Default
		UIS.MouseIconEnabled = true

		Player.CameraMode = Enum.CameraMode.Classic

		if armTable then
			armTable[1].Model:Destroy()
			armTable[2].Model:Destroy()
		elseif armModel then
			armModel:Destroy()
		end

		LLegWeld:Destroy()
		RLegWeld:Destroy()

		changePlayerTrans(Char, 0)

		mainGUI.Parent = script

		Shoulders.Right.Part1 = RArm
		Shoulders.Left.Part1 = LArm

		neckClone.Parent = Torso
		headWeld:Destroy()

		Humanoid.WalkSpeed = 16
		Humanoid.AutoRotate = true

		--------------------[ RESETING THE TOOL ]-------------------------------------

		gunIgnore:Destroy()

		mouseSensitivity = S.sensitivitySettings.Default

		MB1Down = false

		playerMass = 0

		Aimed = false

		camOffsets = {
			guiScope = {
				Rot = V3();
			};
			Reload = {
				Rot = V3();
				Code = nil;
			};
			Recoil = {
				Rot = V3();
				Code = nil;
			};
		}

		recoilAnim = {
			Pos = V3();
			Rot = V3();
			Code = nil;
		}

		--Setting the aim variables to unaimed
		spreadZoom = "unAimed"
		scopeMain.Visible = false
		scopeSteady.Visible = false
		aimAlpha = 0
		aimHeadOffset = 0
		jumpAnimMultiplier = 1
		translationDivisor = 7
		rotationMultiplier = S.momentumSettings.Amplitude.unAimed
		armTiltMultiplier = 1
		Scope.BackgroundTransparency = 1
		if S.guiScope then
			spawn(function()
				for _, Obj in pairs(Gun:GetChildren()) do
					if Obj:IsA("BasePart") then
						Obj.LocalTransparencyModifier = 0
					end
				end
			end)
		end

		onGround = true

		for _, Tab in pairs(gunParts) do
			Tab.Weld:Destroy()
			Tab.Weld = nil
		end

		for _,c in pairs(Connections) do
			c:disconnect()
		end

		Connections = {}

		if deleteTool then
			Cam:ClearAllChildren()
			Gun:Destroy()
		end

		wait() --This is here in case you dolphin dived and deselected the tool instantly

		if S.stanceSettings.standOnDeselect and Stance ~= 0 then
			crawlCamRot = 0
			isCrawling = false
			stanceSway = 1
			spreadStance = "Stand"
			Stand(true)
		end
		baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
	end
end

Gun.Equipped:connect(onEquipped)
Gun.Unequipped:connect(function() onUnequipped(false) end)

--------------------------------------------------------------------------------------
--------------------[ END PROGRAM ]---------------------------------------------------
--------------------------------------------------------------------------------------
end))
IntValue7.Name = "ignoreCode"
IntValue7.Parent = LocalScript6
Folder8.Name = "Server_Scripts"
Folder8.Parent = LocalScript6
ScreenGui9.Name = "mainGUI"
ScreenGui9.Parent = LocalScript6
Frame10.Name = "fireSelect"
Frame10.Parent = ScreenGui9
Frame10.Transparency = 1
Frame10.Position = UDim2.new(0.5, 0, 0.5, -18)
Frame10.Visible = false
Frame10.BackgroundColor3 = Color3.new(1, 1, 1)
Frame10.BackgroundTransparency = 1
Frame11.Name = "Modes"
Frame11.Parent = Frame10
Frame11.Transparency = 1
Frame11.BackgroundColor3 = Color3.new(1, 1, 1)
Frame11.BackgroundTransparency = 1
ImageLabel12.Name = "Circle"
ImageLabel12.Parent = Frame10
ImageLabel12.Transparency = 1
ImageLabel12.Size = UDim2.new(0, 120, 0, 120)
ImageLabel12.Position = UDim2.new(0, -60, 0, -60)
ImageLabel12.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel12.BackgroundTransparency = 1
ImageLabel12.Image = "http://www.roblox.com/asset/?id=55754953"
ImageLabel12.ImageTransparency = 0.5
ImageLabel13.Name = "Arrow"
ImageLabel13.Parent = Frame10
ImageLabel13.Transparency = 1
ImageLabel13.Size = UDim2.new(0, 40, 0, 20)
ImageLabel13.Position = UDim2.new(0, -20, 0, -140)
ImageLabel13.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel13.BackgroundTransparency = 1
ImageLabel13.Image = "http://www.roblox.com/asset/?id=126877530"
TextLabel14.Name = "Sens"
TextLabel14.Parent = ScreenGui9
TextLabel14.Transparency = 1
TextLabel14.Size = UDim2.new(0, 100, 0, 20)
TextLabel14.Text = "S: 0.3"
TextLabel14.Position = UDim2.new(0.5, -50, 0.5, 50)
TextLabel14.Visible = false
TextLabel14.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel14.BackgroundTransparency = 1
TextLabel14.ZIndex = 10
TextLabel14.Font = Enum.Font.SourceSansBold
TextLabel14.FontSize = Enum.FontSize.Size28
TextLabel14.TextColor3 = Color3.new(1, 1, 1)
TextLabel14.TextStrokeTransparency = 0
Frame15.Name = "Scope"
Frame15.Parent = ScreenGui9
Frame15.Transparency = 1
Frame15.Size = UDim2.new(1, 0, 1, 36)
Frame15.Position = UDim2.new(0, 0, 0, -36)
Frame15.BackgroundColor3 = Color3.new(0, 0, 0)
Frame15.BackgroundTransparency = 1
TextLabel16.Name = "Steady"
TextLabel16.Parent = Frame15
TextLabel16.Transparency = 1
TextLabel16.Size = UDim2.new(0, 120, 0, 20)
TextLabel16.Text = ""
TextLabel16.Position = UDim2.new(0.5, -60, 0.5, 50)
TextLabel16.Visible = false
TextLabel16.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel16.BackgroundTransparency = 1
TextLabel16.ZIndex = 9
TextLabel16.Font = Enum.Font.ArialBold
TextLabel16.FontSize = Enum.FontSize.Size14
TextLabel16.TextColor3 = Color3.new(1, 1, 0)
TextLabel16.TextStrokeTransparency = 0
Frame17.Name = "Main"
Frame17.Parent = Frame15
Frame17.Transparency = 1
Frame17.Size = UDim2.new(1, 0, 1, 0)
Frame17.Visible = false
Frame17.BackgroundColor3 = Color3.new(1, 1, 1)
Frame17.BackgroundTransparency = 1
ImageLabel18.Name = "ScopeImg2"
ImageLabel18.Parent = Frame17
ImageLabel18.Transparency = 1
ImageLabel18.Size = UDim2.new(0, 20, 0, 20)
ImageLabel18.Position = UDim2.new(0.5, -10, 0, -10)
ImageLabel18.BackgroundColor3 = Color3.new(0, 0, 0)
ImageLabel18.BackgroundTransparency = 1
ImageLabel18.Image = "http://www.roblox.com/asset/?id=184922644"
ImageLabel19.Name = "ScopeImg1"
ImageLabel19.Parent = Frame17
ImageLabel19.Transparency = 1
ImageLabel19.Size = UDim2.new(0, 20, 0, 20)
ImageLabel19.Position = UDim2.new(0.5, -10, 0, -10)
ImageLabel19.BackgroundColor3 = Color3.new(0, 0, 0)
ImageLabel19.BackgroundTransparency = 1
ImageLabel19.Image = "http://www.roblox.com/asset/?id=72002022"
Frame20.Name = "F2"
Frame20.Parent = Frame17
Frame20.Size = UDim2.new(0, 0, 1, 20)
Frame20.Position = UDim2.new(0, -10, 0, -10)
Frame20.BackgroundColor3 = Color3.new(0, 0, 0)
Frame20.BorderColor3 = Color3.new(0, 0, 0)
Frame20.BorderSizePixel = 0
Frame21.Name = "F1"
Frame21.Parent = Frame17
Frame21.Size = UDim2.new(0, 0, 1, 20)
Frame21.Position = UDim2.new(0, -10, 0, -10)
Frame21.BackgroundColor3 = Color3.new(0, 0, 0)
Frame21.BorderColor3 = Color3.new(0, 0, 0)
Frame21.BorderSizePixel = 0
LocalScript22.Name = "Update"
LocalScript22.Parent = Frame17
table.insert(cors,sandbox(LocalScript22,function()
local GUI = script.Parent

function updateScopeDimension()
	GUI.ScopeImg1.Position = UDim2.new(0.5, -10 - (GUI.AbsoluteSize.y / 2), 0, -10)
	GUI.ScopeImg1.Size = UDim2.new(0, 20 + GUI.AbsoluteSize.y, 0, 20 + GUI.AbsoluteSize.y)
	GUI.ScopeImg2.Position = UDim2.new(0.5, -10 - (GUI.AbsoluteSize.y / 2), 0, -10)
	GUI.ScopeImg2.Size = UDim2.new(0, 20 + GUI.AbsoluteSize.y, 0, 20 + GUI.AbsoluteSize.y)
	GUI.F1.Size = UDim2.new(0, 20 + ((GUI.AbsoluteSize.x - GUI.AbsoluteSize.y) / 2), 1, 20)
	GUI.F2.Size = UDim2.new(0, 20 + ((GUI.AbsoluteSize.x - GUI.AbsoluteSize.y) / 2), 1, 20)
	GUI.F2.Position = UDim2.new(1, -10 - ((GUI.AbsoluteSize.x - GUI.AbsoluteSize.y) / 2), 0, -10)
end

wait()

GUI.Changed:connect(updateScopeDimension)

updateScopeDimension()
end))
ImageLabel23.Name = "HUD"
ImageLabel23.Parent = ScreenGui9
ImageLabel23.Transparency = 1
ImageLabel23.Size = UDim2.new(0, 100, 0, 100)
ImageLabel23.Position = UDim2.new(1, -210, 1, -125)
ImageLabel23.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel23.BackgroundTransparency = 1
ImageLabel23.Image = "rbxassetid://500188818"
ImageLabel23.ImageColor3 = Color3.new(0.156863, 0.156863, 0.156863)
ImageLabel23.ImageTransparency = 0.30000001192093
Frame24.Parent = ImageLabel23
Frame24.Transparency = 0.30000001192093
Frame24.Size = UDim2.new(0, 110, 0, 100)
Frame24.Position = UDim2.new(0, 100, 0, 0)
Frame24.Active = true
Frame24.BackgroundColor3 = Color3.new(0.14902, 0.14902, 0.14902)
Frame24.BackgroundTransparency = 0.30000001192093
Frame24.BorderSizePixel = 0
Frame25.Name = "Controls"
Frame25.Parent = ImageLabel23
Frame25.Transparency = 0.30000001192093
Frame25.Size = UDim2.new(1, 0, 0, 120)
Frame25.Position = UDim2.new(0, 0, 0, -200)
Frame25.Visible = false
Frame25.BackgroundColor3 = Color3.new(0.156863, 0.156863, 0.156863)
Frame25.BackgroundTransparency = 0.30000001192093
Frame25.BorderColor3 = Color3.new(0.156863, 0.156863, 0.156863)
Frame25.BorderSizePixel = 5
Frame25.ZIndex = 10
TextLabel26.Name = "Title"
TextLabel26.Parent = Frame25
TextLabel26.Transparency = 1
TextLabel26.Size = UDim2.new(1, 0, 0, 15)
TextLabel26.Text = "CONTROLS"
TextLabel26.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel26.BackgroundTransparency = 1
TextLabel26.ZIndex = 10
TextLabel26.Font = Enum.Font.SourceSansBold
TextLabel26.FontSize = Enum.FontSize.Size14
TextLabel26.TextColor3 = Color3.new(1, 1, 1)
TextLabel27.Name = "Line"
TextLabel27.Parent = TextLabel26
TextLabel27.Size = UDim2.new(1, 0, 0, 2)
TextLabel27.Text = ""
TextLabel27.Position = UDim2.new(0, 0, 1, 1)
TextLabel27.BackgroundColor3 = Color3.new(1, 1, 0)
TextLabel27.BorderSizePixel = 0
TextLabel27.ZIndex = 10
TextLabel27.Font = Enum.Font.SourceSans
TextLabel27.FontSize = Enum.FontSize.Size14
Frame28.Name = "Grenades"
Frame28.Parent = ImageLabel23
Frame28.Transparency = 1
Frame28.Size = UDim2.new(0, 175, 0, 25)
Frame28.Position = UDim2.new(0, 0, 0, 90)
Frame28.Visible = false
Frame28.BackgroundTransparency = 1
Frame28.ZIndex = 10
Frame29.Name = "Lethals"
Frame29.Parent = Frame28
Frame29.Size = UDim2.new(0.5, -2, 1, 0)
Frame29.BackgroundColor3 = Color3.new(1, 1, 1)
Frame29.BorderSizePixel = 0
Frame29.ZIndex = 10
ImageLabel30.Name = "Icon"
ImageLabel30.Parent = Frame29
ImageLabel30.Transparency = 1
ImageLabel30.Size = UDim2.new(0, 21, 0, 21)
ImageLabel30.Position = UDim2.new(0, 7, 0, 2)
ImageLabel30.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel30.BackgroundTransparency = 1
ImageLabel30.ZIndex = 10
TextLabel31.Name = "Mult"
TextLabel31.Parent = Frame29
TextLabel31.Transparency = 1
TextLabel31.Size = UDim2.new(0, 20, 1, 0)
TextLabel31.Text = "X"
TextLabel31.Position = UDim2.new(0.5, -10, 0, 0)
TextLabel31.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel31.BackgroundTransparency = 1
TextLabel31.BorderSizePixel = 0
TextLabel31.ZIndex = 10
TextLabel31.Font = Enum.Font.ArialBold
TextLabel31.FontSize = Enum.FontSize.Size18
TextLabel31.TextColor3 = Color3.new(0, 0, 0)
TextLabel32.Name = "Num"
TextLabel32.Parent = Frame29
TextLabel32.Transparency = 1
TextLabel32.Size = UDim2.new(0, 0, 1, 0)
TextLabel32.Text = "0"
TextLabel32.Position = UDim2.new(1, -7, 0, 0)
TextLabel32.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel32.BackgroundTransparency = 1
TextLabel32.ZIndex = 10
TextLabel32.Font = Enum.Font.ArialBold
TextLabel32.FontSize = Enum.FontSize.Size18
TextLabel32.TextColor3 = Color3.new(0, 0, 0)
TextLabel32.TextXAlignment = Enum.TextXAlignment.Right
Frame33.Name = "Tacticals"
Frame33.Parent = Frame28
Frame33.Size = UDim2.new(0.5, -2, 1, 0)
Frame33.Position = UDim2.new(0.5, 2, 0, 0)
Frame33.BackgroundColor3 = Color3.new(1, 1, 1)
Frame33.BorderSizePixel = 0
Frame33.ZIndex = 10
ImageLabel34.Name = "Icon"
ImageLabel34.Parent = Frame33
ImageLabel34.Transparency = 1
ImageLabel34.Size = UDim2.new(0, 21, 0, 21)
ImageLabel34.Position = UDim2.new(0, 7, 0, 2)
ImageLabel34.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel34.BackgroundTransparency = 1
ImageLabel34.ZIndex = 10
TextLabel35.Name = "Num"
TextLabel35.Parent = Frame33
TextLabel35.Transparency = 1
TextLabel35.Size = UDim2.new(0, 0, 1, 0)
TextLabel35.Text = "0"
TextLabel35.Position = UDim2.new(1, -7, 0, 0)
TextLabel35.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel35.BackgroundTransparency = 1
TextLabel35.ZIndex = 10
TextLabel35.Font = Enum.Font.ArialBold
TextLabel35.FontSize = Enum.FontSize.Size18
TextLabel35.TextColor3 = Color3.new(0, 0, 0)
TextLabel35.TextXAlignment = Enum.TextXAlignment.Right
TextLabel36.Name = "Mult"
TextLabel36.Parent = Frame33
TextLabel36.Transparency = 1
TextLabel36.Size = UDim2.new(0, 20, 1, 0)
TextLabel36.Text = "X"
TextLabel36.Position = UDim2.new(0.5, -10, 0, 0)
TextLabel36.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel36.BackgroundTransparency = 1
TextLabel36.BorderSizePixel = 0
TextLabel36.ZIndex = 10
TextLabel36.Font = Enum.Font.ArialBold
TextLabel36.FontSize = Enum.FontSize.Size18
TextLabel36.TextColor3 = Color3.new(0, 0, 0)
Frame37.Name = "Health"
Frame37.Parent = ImageLabel23
Frame37.Transparency = 1
Frame37.Size = UDim2.new(0.400000006, 0, 0, 25)
Frame37.Position = UDim2.new(0, 25, 0, 20)
Frame37.BackgroundColor3 = Color3.new(0.247059, 0.247059, 0.247059)
Frame37.BackgroundTransparency = 1
Frame37.BorderColor3 = Color3.new(0.156863, 0.156863, 0.156863)
Frame37.BorderSizePixel = 0
Frame37.ZIndex = 10
Frame37.Draggable = true
TextLabel38.Name = "Num"
TextLabel38.Parent = Frame37
TextLabel38.Transparency = 1
TextLabel38.Size = UDim2.new(0, 50, 1, 0)
TextLabel38.Text = "100%"
TextLabel38.Position = UDim2.new(1, -50, 0, 0)
TextLabel38.BackgroundColor3 = Color3.new(0, 0, 0)
TextLabel38.BackgroundTransparency = 1
TextLabel38.BorderColor3 = Color3.new(0, 0, 0)
TextLabel38.BorderSizePixel = 0
TextLabel38.ZIndex = 10
TextLabel38.Font = Enum.Font.SourceSansBold
TextLabel38.FontSize = Enum.FontSize.Size24
TextLabel38.TextColor3 = Color3.new(1, 1, 1)
TextLabel38.TextStrokeColor3 = Color3.new(0.745098, 0.745098, 0.745098)
TextLabel38.TextXAlignment = Enum.TextXAlignment.Right
Frame39.Name = "Tray"
Frame39.Parent = Frame37
Frame39.Transparency = 1
Frame39.Size = UDim2.new(1, -60, 0, 20)
Frame39.Position = UDim2.new(0, 2, 0.5, -10)
Frame39.Visible = false
Frame39.BackgroundColor3 = Color3.new(0, 0, 0)
Frame39.BackgroundTransparency = 1
Frame39.BorderColor3 = Color3.new(0, 0, 0)
Frame39.BorderSizePixel = 0
Frame39.ZIndex = 10
Frame39.ClipsDescendants = true
Frame40.Name = "Beat"
Frame40.Parent = Frame39
Frame40.Transparency = 1
Frame40.Size = UDim2.new(0, 21, 1, 0)
Frame40.Position = UDim2.new(1, 0, 0, 0)
Frame40.BackgroundColor3 = Color3.new(0, 0, 0)
Frame40.BackgroundTransparency = 1
Frame40.BorderColor3 = Color3.new(0, 0, 0)
Frame40.BorderSizePixel = 0
Frame40.ZIndex = 10
Frame41.Name = "00"
Frame41.Parent = Frame40
Frame41.Size = UDim2.new(0.0476190485, 0, 0, 3)
Frame41.Position = UDim2.new(0, 0, 0.5, -2)
Frame41.BackgroundColor3 = Color3.new(1, 1, 1)
Frame41.BorderColor3 = Color3.new(0, 0, 0)
Frame41.BorderSizePixel = 0
Frame41.ZIndex = 10
Frame42.Name = "01"
Frame42.Parent = Frame40
Frame42.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame42.Position = UDim2.new(0.0476190485, 0, 0.423076928, -2)
Frame42.BackgroundColor3 = Color3.new(1, 1, 1)
Frame42.BorderColor3 = Color3.new(0, 0, 0)
Frame42.BorderSizePixel = 0
Frame42.ZIndex = 10
Frame43.Name = "02"
Frame43.Parent = Frame40
Frame43.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame43.Position = UDim2.new(0.095238097, 0, 0.346153855, -2)
Frame43.BackgroundColor3 = Color3.new(1, 1, 1)
Frame43.BorderColor3 = Color3.new(0, 0, 0)
Frame43.BorderSizePixel = 0
Frame43.ZIndex = 10
Frame44.Name = "03"
Frame44.Parent = Frame40
Frame44.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame44.Position = UDim2.new(0.142857149, 0, 0.269230783, -2)
Frame44.BackgroundColor3 = Color3.new(1, 1, 1)
Frame44.BorderColor3 = Color3.new(0, 0, 0)
Frame44.BorderSizePixel = 0
Frame44.ZIndex = 10
Frame45.Name = "04"
Frame45.Parent = Frame40
Frame45.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame45.Position = UDim2.new(0.190476194, 0, 0.192307696, -2)
Frame45.BackgroundColor3 = Color3.new(1, 1, 1)
Frame45.BorderColor3 = Color3.new(0, 0, 0)
Frame45.BorderSizePixel = 0
Frame45.ZIndex = 10
Frame46.Name = "05"
Frame46.Parent = Frame40
Frame46.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame46.Position = UDim2.new(0.238095239, 0, 0.115384616, -2)
Frame46.BackgroundColor3 = Color3.new(1, 1, 1)
Frame46.BorderColor3 = Color3.new(0, 0, 0)
Frame46.BorderSizePixel = 0
Frame46.ZIndex = 10
Frame47.Name = "06"
Frame47.Parent = Frame40
Frame47.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame47.Position = UDim2.new(0.285714298, 0, 0.0384615399, -2)
Frame47.BackgroundColor3 = Color3.new(1, 1, 1)
Frame47.BorderColor3 = Color3.new(0, 0, 0)
Frame47.BorderSizePixel = 0
Frame47.ZIndex = 10
Frame48.Name = "07"
Frame48.Parent = Frame40
Frame48.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame48.Position = UDim2.new(0.333333343, 0, 0, -2)
Frame48.BackgroundColor3 = Color3.new(1, 1, 1)
Frame48.BorderColor3 = Color3.new(0, 0, 0)
Frame48.BorderSizePixel = 0
Frame48.ZIndex = 10
Frame49.Name = "08"
Frame49.Parent = Frame40
Frame49.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame49.Position = UDim2.new(0.380952388, 0, 0.142857149, -2)
Frame49.BackgroundColor3 = Color3.new(1, 1, 1)
Frame49.BorderColor3 = Color3.new(0, 0, 0)
Frame49.BorderSizePixel = 0
Frame49.ZIndex = 10
Frame50.Name = "09"
Frame50.Parent = Frame40
Frame50.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame50.Position = UDim2.new(0.428571433, 0, 0.285714298, -2)
Frame50.BackgroundColor3 = Color3.new(1, 1, 1)
Frame50.BorderColor3 = Color3.new(0, 0, 0)
Frame50.BorderSizePixel = 0
Frame50.ZIndex = 10
Frame51.Name = "10"
Frame51.Parent = Frame40
Frame51.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame51.Position = UDim2.new(0.476190478, 0, 0.428571433, -2)
Frame51.BackgroundColor3 = Color3.new(1, 1, 1)
Frame51.BorderColor3 = Color3.new(0, 0, 0)
Frame51.BorderSizePixel = 0
Frame51.ZIndex = 10
Frame52.Name = "11"
Frame52.Parent = Frame40
Frame52.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame52.Position = UDim2.new(0.523809552, 0, 0.571428597, -2)
Frame52.BackgroundColor3 = Color3.new(1, 1, 1)
Frame52.BorderColor3 = Color3.new(0, 0, 0)
Frame52.BorderSizePixel = 0
Frame52.ZIndex = 10
Frame53.Name = "12"
Frame53.Parent = Frame40
Frame53.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame53.Position = UDim2.new(0.571428597, 0, 0.714285731, -2)
Frame53.BackgroundColor3 = Color3.new(1, 1, 1)
Frame53.BorderColor3 = Color3.new(0, 0, 0)
Frame53.BorderSizePixel = 0
Frame53.ZIndex = 10
Frame54.Name = "13"
Frame54.Parent = Frame40
Frame54.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame54.Position = UDim2.new(0.619047642, 0, 0.857142866, -2)
Frame54.BackgroundColor3 = Color3.new(1, 1, 1)
Frame54.BorderColor3 = Color3.new(0, 0, 0)
Frame54.BorderSizePixel = 0
Frame54.ZIndex = 10
Frame55.Name = "14"
Frame55.Parent = Frame40
Frame55.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame55.Position = UDim2.new(0.666666687, 0, 0.916666687, -2)
Frame55.BackgroundColor3 = Color3.new(1, 1, 1)
Frame55.BorderColor3 = Color3.new(0, 0, 0)
Frame55.BorderSizePixel = 0
Frame55.ZIndex = 10
Frame56.Name = "15"
Frame56.Parent = Frame40
Frame56.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame56.Position = UDim2.new(0.714285731, 0, 0.833333313, -2)
Frame56.BackgroundColor3 = Color3.new(1, 1, 1)
Frame56.BorderColor3 = Color3.new(0, 0, 0)
Frame56.BorderSizePixel = 0
Frame56.ZIndex = 10
Frame57.Name = "16"
Frame57.Parent = Frame40
Frame57.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame57.Position = UDim2.new(0.761904776, 0, 0.75, -2)
Frame57.BackgroundColor3 = Color3.new(1, 1, 1)
Frame57.BorderColor3 = Color3.new(0, 0, 0)
Frame57.BorderSizePixel = 0
Frame57.ZIndex = 10
Frame58.Name = "17"
Frame58.Parent = Frame40
Frame58.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame58.Position = UDim2.new(0.809523821, 0, 0.666666687, -2)
Frame58.BackgroundColor3 = Color3.new(1, 1, 1)
Frame58.BorderColor3 = Color3.new(0, 0, 0)
Frame58.BorderSizePixel = 0
Frame58.ZIndex = 10
Frame59.Name = "18"
Frame59.Parent = Frame40
Frame59.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame59.Position = UDim2.new(0.857142866, 0, 0.583333313, -2)
Frame59.BackgroundColor3 = Color3.new(1, 1, 1)
Frame59.BorderColor3 = Color3.new(0, 0, 0)
Frame59.BorderSizePixel = 0
Frame59.ZIndex = 10
Frame60.Name = "19"
Frame60.Parent = Frame40
Frame60.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame60.Position = UDim2.new(0.90476191, 0, 0.5, -2)
Frame60.BackgroundColor3 = Color3.new(1, 1, 1)
Frame60.BorderColor3 = Color3.new(0, 0, 0)
Frame60.BorderSizePixel = 0
Frame60.ZIndex = 10
Frame61.Name = "20"
Frame61.Parent = Frame40
Frame61.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame61.Position = UDim2.new(0.952000022, 0, 0.49000001, -2)
Frame61.BackgroundColor3 = Color3.new(1, 1, 1)
Frame61.BorderColor3 = Color3.new(0, 0, 0)
Frame61.BorderSizePixel = 0
Frame61.ZIndex = 10
Frame62.Name = "Line"
Frame62.Parent = Frame40
Frame62.Size = UDim2.new(0, 200, 0, 3)
Frame62.Position = UDim2.new(1, 0, 0.5, -2)
Frame62.BackgroundColor3 = Color3.new(1, 1, 1)
Frame62.BorderColor3 = Color3.new(0, 0, 0)
Frame62.BorderSizePixel = 0
Frame62.ZIndex = 10
Frame63.Name = "Line"
Frame63.Parent = Frame40
Frame63.Size = UDim2.new(0, 200, 0, 3)
Frame63.Position = UDim2.new(0, -200, 0.5, -2)
Frame63.BackgroundColor3 = Color3.new(1, 1, 1)
Frame63.BorderColor3 = Color3.new(0, 0, 0)
Frame63.BorderSizePixel = 0
Frame63.ZIndex = 10
Frame64.Name = "Mode"
Frame64.Parent = ImageLabel23
Frame64.Transparency = 1
Frame64.Size = UDim2.new(0, 85, 0, 20)
Frame64.Position = UDim2.new(1, 22, 1, -60)
Frame64.BackgroundColor3 = Color3.new(1, 1, 1)
Frame64.BackgroundTransparency = 1
Frame64.ZIndex = 10
TextLabel65.Name = "Bracket"
TextLabel65.Parent = Frame64
TextLabel65.Transparency = 1
TextLabel65.Size = UDim2.new(0, 5, 0, 20)
TextLabel65.Text = "["
TextLabel65.BackgroundTransparency = 1
TextLabel65.ZIndex = 10
TextLabel65.Font = Enum.Font.ArialBold
TextLabel65.FontSize = Enum.FontSize.Size18
TextLabel65.TextColor3 = Color3.new(1, 1, 1)
TextLabel65.TextXAlignment = Enum.TextXAlignment.Left
TextLabel66.Name = "Bracket"
TextLabel66.Parent = Frame64
TextLabel66.Transparency = 1
TextLabel66.Size = UDim2.new(0, 5, 0, 20)
TextLabel66.Text = "]"
TextLabel66.Position = UDim2.new(1, -5, 0, 0)
TextLabel66.BackgroundTransparency = 1
TextLabel66.ZIndex = 10
TextLabel66.Font = Enum.Font.ArialBold
TextLabel66.FontSize = Enum.FontSize.Size18
TextLabel66.TextColor3 = Color3.new(1, 1, 1)
TextLabel66.TextXAlignment = Enum.TextXAlignment.Left
TextLabel67.Name = "Main"
TextLabel67.Parent = Frame64
TextLabel67.Transparency = 1
TextLabel67.Size = UDim2.new(1, 0, 0, 20)
TextLabel67.Text = "Auto"
TextLabel67.BackgroundTransparency = 1
TextLabel67.ZIndex = 10
TextLabel67.Font = Enum.Font.SourceSansItalic
TextLabel67.FontSize = Enum.FontSize.Size18
TextLabel67.TextColor3 = Color3.new(1, 1, 1)
TextLabel67.TextWrapped = true
Frame68.Name = "gunName"
Frame68.Parent = ImageLabel23
Frame68.Transparency = 1
Frame68.Size = UDim2.new(1, 0, 0, 36)
Frame68.BackgroundColor3 = Color3.new(0.352941, 0.352941, 0.352941)
Frame68.BackgroundTransparency = 1
Frame68.ZIndex = 10
TextLabel69.Name = "Title"
TextLabel69.Parent = Frame68
TextLabel69.Transparency = 1
TextLabel69.Size = UDim2.new(1, 75, 1, 0)
TextLabel69.Text = "GUN"
TextLabel69.Position = UDim2.new(0, 30, 0, -5)
TextLabel69.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel69.BackgroundTransparency = 1
TextLabel69.ZIndex = 10
TextLabel69.Font = Enum.Font.SourceSansItalic
TextLabel69.FontSize = Enum.FontSize.Size36
TextLabel69.TextColor3 = Color3.new(1, 1, 1)
TextLabel69.TextStrokeColor3 = Color3.new(0.745098, 0.745098, 0.745098)
TextLabel69.TextStrokeTransparency = 0
TextLabel69.TextWrapped = true
TextLabel69.TextXAlignment = Enum.TextXAlignment.Left
Frame70.Name = "Ammo"
Frame70.Parent = ImageLabel23
Frame70.Transparency = 1
Frame70.Size = UDim2.new(0, 135, 0, 40)
Frame70.Position = UDim2.new(0, 72, 0, 60)
Frame70.BackgroundTransparency = 1
Frame70.ZIndex = 10
TextLabel71.Name = "Slash"
TextLabel71.Parent = Frame70
TextLabel71.Transparency = 1
TextLabel71.Size = UDim2.new(0, 0, 0, 45)
TextLabel71.Text = "//"
TextLabel71.Position = UDim2.new(0, 92, 0, -12)
TextLabel71.BackgroundTransparency = 1
TextLabel71.ZIndex = 10
TextLabel71.Font = Enum.Font.SourceSansBold
TextLabel71.FontSize = Enum.FontSize.Size24
TextLabel71.TextColor3 = Color3.new(1, 1, 1)
TextLabel72.Name = "Stored"
TextLabel72.Parent = Frame70
TextLabel72.Transparency = 1
TextLabel72.Size = UDim2.new(1, 0, 0, 85)
TextLabel72.Text = "999"
TextLabel72.Position = UDim2.new(0, 100, 0, -35)
TextLabel72.BackgroundTransparency = 1
TextLabel72.ZIndex = 10
TextLabel72.Font = Enum.Font.SourceSansBold
TextLabel72.FontSize = Enum.FontSize.Size28
TextLabel72.TextColor3 = Color3.new(1, 1, 1)
TextLabel72.TextXAlignment = Enum.TextXAlignment.Left
TextLabel73.Name = "Background"
TextLabel73.Parent = TextLabel72
TextLabel73.Transparency = 1
TextLabel73.Size = UDim2.new(1, 0, 1, 0)
TextLabel73.Text = "000"
TextLabel73.BackgroundTransparency = 1
TextLabel73.ZIndex = 10
TextLabel73.Font = Enum.Font.ArialBold
TextLabel73.FontSize = Enum.FontSize.Size24
TextLabel73.TextColor3 = Color3.new(0.588235, 0.588235, 0.588235)
TextLabel73.TextTransparency = 0.80000001192093
TextLabel73.TextWrapped = true
TextLabel73.TextXAlignment = Enum.TextXAlignment.Left
TextLabel74.Name = "Clip"
TextLabel74.Parent = Frame70
TextLabel74.Transparency = 1
TextLabel74.Size = UDim2.new(0, 85, 1, 0)
TextLabel74.Text = "999"
TextLabel74.Position = UDim2.new(0, 0, 0, -5)
TextLabel74.BackgroundTransparency = 1
TextLabel74.ZIndex = 10
TextLabel74.Font = Enum.Font.SourceSansBold
TextLabel74.FontSize = Enum.FontSize.Size60
TextLabel74.TextColor3 = Color3.new(1, 1, 1)
TextLabel74.TextXAlignment = Enum.TextXAlignment.Right
TextLabel75.Name = "Background"
TextLabel75.Parent = TextLabel74
TextLabel75.Transparency = 1
TextLabel75.Size = UDim2.new(1, 0, 1, 0)
TextLabel75.Text = "000"
TextLabel75.BackgroundTransparency = 1
TextLabel75.ZIndex = 10
TextLabel75.Font = Enum.Font.SourceSansBold
TextLabel75.FontSize = Enum.FontSize.Size60
TextLabel75.TextColor3 = Color3.new(0.588235, 0.588235, 0.588235)
TextLabel75.TextTransparency = 0.80000001192093
TextLabel75.TextXAlignment = Enum.TextXAlignment.Right
ImageLabel76.Name = "Bear"
ImageLabel76.Parent = ImageLabel23
ImageLabel76.Transparency = 1
ImageLabel76.Rotation = -10
ImageLabel76.Size = UDim2.new(0, 80, 0, 50)
ImageLabel76.Position = UDim2.new(0, 100, 0, 5)
ImageLabel76.Visible = false
ImageLabel76.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel76.BackgroundTransparency = 1
ImageLabel76.Image = "rbxassetid://500200470"
ImageLabel76.ImageTransparency = 0.69999998807907
TextLabel77.Parent = ImageLabel76
TextLabel77.Transparency = 1
TextLabel77.Rotation = 10
TextLabel77.Size = UDim2.new(1, 0, 1, 0)
TextLabel77.Text = "~BoG~"
TextLabel77.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel77.BackgroundTransparency = 1
TextLabel77.Font = Enum.Font.SourceSansItalic
TextLabel77.FontSize = Enum.FontSize.Size24
TextLabel77.TextColor3 = Color3.new(1, 1, 1)
TextLabel77.TextStrokeColor3 = Color3.new(0.745098, 0.745098, 0.745098)
TextLabel77.TextStrokeTransparency = 0.89999997615814
TextLabel77.TextTransparency = 0.89999997615814
TextLabel77.TextWrapped = true
Frame78.Name = "crossHair"
Frame78.Parent = ScreenGui9
Frame78.Position = UDim2.new(0.5, 0, 0.5, -18)
Frame78.BackgroundColor3 = Color3.new(1, 1, 1)
Frame78.BorderColor3 = Color3.new(0, 0, 0)
Frame78.BorderSizePixel = 0
ImageLabel79.Parent = Frame78
ImageLabel79.Transparency = 1
ImageLabel79.Size = UDim2.new(0, 300, 0, 300)
ImageLabel79.Position = UDim2.new(0, -150, 0, -150)
ImageLabel79.Visible = false
ImageLabel79.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel79.BackgroundTransparency = 1
ImageLabel79.ZIndex = 2
ImageLabel79.Image = "http://www.roblox.com/asset/?id=68308747"
TextLabel80.Name = "Reload"
TextLabel80.Parent = Frame78
TextLabel80.Transparency = 1
TextLabel80.Size = UDim2.new(0, 100, 0, 20)
TextLabel80.Text = "RELOADING..."
TextLabel80.Position = UDim2.new(0, -50, 0, 70)
TextLabel80.Visible = false
TextLabel80.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel80.BackgroundTransparency = 1
TextLabel80.ZIndex = 2
TextLabel80.Font = Enum.Font.SourceSansBold
TextLabel80.FontSize = Enum.FontSize.Size18
TextLabel80.TextColor3 = Color3.new(1, 1, 1)
TextLabel80.TextStrokeTransparency = 0.5
Frame81.Name = "C"
Frame81.Parent = Frame78
Frame81.Transparency = 1
Frame81.Size = UDim2.new(0, 4, 0, 500)
Frame81.Position = UDim2.new(0, -2, 0, 0)
Frame81.BackgroundColor3 = Color3.new(1, 1, 1)
Frame81.BackgroundTransparency = 1
Frame81.ClipsDescendants = true
TextLabel82.Name = "Line"
TextLabel82.Parent = Frame81
TextLabel82.Size = UDim2.new(0, 2, 0, 15)
TextLabel82.Text = ""
TextLabel82.Position = UDim2.new(0.5, -1, 0, 10)
TextLabel82.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel82.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel82.Font = Enum.Font.SourceSans
TextLabel82.FontSize = Enum.FontSize.Size14
Frame83.Name = "A"
Frame83.Parent = Frame78
Frame83.Transparency = 1
Frame83.Size = UDim2.new(0, 4, 0, 500)
Frame83.Position = UDim2.new(0, -2, 0, -500)
Frame83.BackgroundColor3 = Color3.new(1, 1, 1)
Frame83.BackgroundTransparency = 1
Frame83.ClipsDescendants = true
TextLabel84.Name = "Line"
TextLabel84.Parent = Frame83
TextLabel84.Size = UDim2.new(0, 2, 0, 15)
TextLabel84.Text = ""
TextLabel84.Position = UDim2.new(0.5, -1, 1, -25)
TextLabel84.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel84.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel84.Font = Enum.Font.SourceSans
TextLabel84.FontSize = Enum.FontSize.Size14
Frame85.Name = "B"
Frame85.Parent = Frame78
Frame85.Transparency = 1
Frame85.Size = UDim2.new(0, 500, 0, 4)
Frame85.Position = UDim2.new(0, 0, 0, -2)
Frame85.BackgroundColor3 = Color3.new(1, 1, 1)
Frame85.BackgroundTransparency = 1
Frame85.ClipsDescendants = true
TextLabel86.Name = "Line"
TextLabel86.Parent = Frame85
TextLabel86.Size = UDim2.new(0, 15, 0, 2)
TextLabel86.Text = ""
TextLabel86.Position = UDim2.new(0, 10, 0.5, -1)
TextLabel86.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel86.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel86.Font = Enum.Font.SourceSans
TextLabel86.FontSize = Enum.FontSize.Size14
Frame87.Name = "D"
Frame87.Parent = Frame78
Frame87.Transparency = 1
Frame87.Size = UDim2.new(0, 500, 0, 4)
Frame87.Position = UDim2.new(0, -500, 0, -2)
Frame87.BackgroundColor3 = Color3.new(1, 1, 1)
Frame87.BackgroundTransparency = 1
Frame87.ClipsDescendants = true
TextLabel88.Name = "Line"
TextLabel88.Parent = Frame87
TextLabel88.Size = UDim2.new(0, 15, 0, 2)
TextLabel88.Text = ""
TextLabel88.Position = UDim2.new(1, -25, 0.5, -1)
TextLabel88.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel88.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel88.Font = Enum.Font.SourceSans
TextLabel88.FontSize = Enum.FontSize.Size14
ImageLabel89.Name = "hitMarker"
ImageLabel89.Parent = ScreenGui9
ImageLabel89.Transparency = 1
ImageLabel89.Size = UDim2.new(0, 26, 0, 26)
ImageLabel89.Position = UDim2.new(0.5, -13, 0.5, -31)
ImageLabel89.Visible = false
ImageLabel89.BackgroundTransparency = 1
ImageLabel89.ZIndex = 10
ImageLabel89.Image = "http://www.roblox.com/asset/?id=121173757"
NumberValue90.Name = "lastMark"
NumberValue90.Parent = ImageLabel89
ManualWeld91.Name = "BoltBack-to-Bolt Strong Joint"
ManualWeld91.Parent = mas
ManualWeld91.C0 = CFrame.new(-0.450004131, 0.0100045428, 0.450034529, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld91.C1 = CFrame.new(-0.45000723, 0.00988769531, 0.450006604, -1, -1.38405858e-05, 1.47198193e-07, 1.47277945e-07, -5.76107504e-06, 1, -1.38405858e-05, 1, 5.76107686e-06)
ManualWeld91.Part0 = nil
ManualWeld91.Part1 = nil
ManualWeld92.Name = "BoltBack-to-Bolt Strong Joint"
ManualWeld92.Parent = mas
ManualWeld92.C0 = CFrame.new(-0.450004131, 0.0100045428, 0.450034529, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld92.C1 = CFrame.new(-0.450006843, 0.00988769531, -0.450013578, 2.4346029e-05, -1, -5.91436674e-06, 4.9242044e-07, -5.91435401e-06, 1, -1, -2.43460327e-05, 4.92276456e-07)
ManualWeld92.Part0 = nil
ManualWeld92.Part1 = nil
ManualWeld93.Name = "BoltBack-to-Bolt Strong Joint"
ManualWeld93.Parent = mas
ManualWeld93.C0 = CFrame.new(-0.450004131, 0.0100045428, 0.450034529, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld93.C1 = CFrame.new(0.450007975, 0.0100097656, -0.450009227, 1, 1.71570737e-05, -8.86241323e-05, 8.86203052e-05, 0.000222758361, 1, 1.71768152e-05, -1, 0.000222756833)
ManualWeld93.Part0 = nil
ManualWeld93.Part1 = nil
ManualWeld94.Name = "Grip-to-Mag Strong Joint"
ManualWeld94.Parent = mas
ManualWeld94.C0 = CFrame.new(-0.0500058718, 0.325030416, 0.275049001, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld94.C1 = CFrame.new(0.155041948, -0.244948864, -0.32598877, -0.999999344, -9.25453321e-07, -9.56245003e-07, 1.47485207e-06, 1.98302951e-05, 0.999997318, -7.79967422e-07, 0.999999642, -2.5720281e-05)
ManualWeld94.Part0 = nil
ManualWeld94.Part1 = nil
ManualWeld95.Name = "Grip-to-Mag Strong Joint"
ManualWeld95.Parent = mas
ManualWeld95.C0 = CFrame.new(-0.0500058718, 0.325030416, 0.275049001, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld95.C1 = CFrame.new(-0.254958034, -0.244948864, -0.32598877, -0.999999344, -9.25453321e-07, -9.56245003e-07, 1.47485207e-06, 1.98302951e-05, 0.999997318, -7.79967422e-07, 0.999999642, -2.5720281e-05)
ManualWeld95.Part0 = nil
ManualWeld95.Part1 = nil
ManualWeld96.Name = "Grip2-to-Grip2 Strong Joint"
ManualWeld96.Parent = mas
ManualWeld96.C0 = CFrame.new(0.0500004217, -0.375047863, -0.150044665, -1, 0, 0, 0, 1, 0, 0, 0, -1)
ManualWeld96.C1 = CFrame.new(0.0499951318, -0.20008862, 0.0249023438, -1, 4.84741759e-06, 2.91045694e-07, 4.84742077e-06, 1, 1.15486564e-05, -2.90989675e-07, 1.15486573e-05, -1)
ManualWeld96.Part0 = nil
ManualWeld96.Part1 = nil
Script97.Name = "serverMain"
Script97.Parent = Tool0
table.insert(cors,sandbox(Script97,function()
local Plyr = script:WaitForChild("Plyr")

local Gun = script.Parent
local Handle = Gun:WaitForChild("Handle")

local V3 = Vector3.new
local CF, CFANG = CFrame.new, CFrame.Angles

local RAD = math.rad

local numLerp = function(A, B, Alpha)
	return A + (B - A) * Alpha
end

local inList = function(Element, List)
	for _, v in pairs(List) do
		if v == Element then
			return true
		end
	end
	return false
end

local getObject = function(Model, Class, Name)
	for _, v in pairs(Model:GetChildren()) do
		if v:IsA(Class) and v.Name == Name then
			return v
		end
	end
	return nil
end

----------------------------------------------------------------------
--------------------[ IGNORE MODEL HANDLING ]-------------------------
----------------------------------------------------------------------

wait(math.random(0, 20) / 40) --This is to prevent more than one ignoreModel from being created

if _G.ignoreCode then --If the ignoreCode already exists, then the script creates the ignoreModel
	--[[
		The purpose of this is so that every gun in a game that uses this gun kit will share one ignoreModel. That way,
		bullet trails, bullet holes, and other fake arms will be ignored by the gun which makes the bullets more likely to
		hit a character part
	--]]
	if (not game.Workspace:FindFirstChild("ignoreModel_".._G.ignoreCode)) then
		local ignoreModel = Instance.new("Model")
		ignoreModel.Name = "ignoreModel_".._G.ignoreCode
		ignoreModel.Parent = game.Workspace

		local grenadeFolder = Instance.new("Model")
		grenadeFolder.Name = "grenadeFolder"
		grenadeFolder.Parent = ignoreModel

		spawn(function()
			while true do
				ignoreModel.Parent = game.Workspace
				grenadeFolder.Parent = ignoreModel
				wait(1 / 20)
			end
		end)
	end

	script.Parent:WaitForChild("clientMain"):WaitForChild("ignoreCode").Value = _G.ignoreCode
else
	--[[
		If there isn't already an ignoreCode, then this creates one. The purpose of it being random is so that if there is
		an ignoreModel for something else in the game, the script won't end up placing the ignored objects in that ignoreModel
	--]]
	_G.ignoreCode = math.random(1, 1e4)

	if (not game.Workspace:FindFirstChild("ignoreModel_".._G.ignoreCode)) then
		local ignoreModel = Instance.new("Model")
		ignoreModel.Name = "ignoreModel_".._G.ignoreCode
		ignoreModel.Parent = game.Workspace

		local grenadeFolder = Instance.new("Model")
		grenadeFolder.Name = "grenadeFolder"
		grenadeFolder.Parent = ignoreModel

		spawn(function()
			while true do
				ignoreModel.Parent = game.Workspace
				grenadeFolder.Parent = ignoreModel
				wait(1 / 20)
			end
		end)
	end

	script.Parent:WaitForChild("clientMain"):WaitForChild("ignoreCode").Value = _G.ignoreCode
end

spawn(function()
	--[[
		This function deletes any Player Folders that were left in the ignoreModel because the player left the game without
		deselecting the Gun first
	--]]
	repeat wait() until _G.ignoreCode
	local ignoreModel = game.Workspace:WaitForChild("ignoreModel_".._G.ignoreCode)
	while true do
		for _, gunIgnore in pairs(ignoreModel:GetChildren()) do
			if gunIgnore.Name ~= "grenadeFolder" then
				if (not game.Players:FindFirstChild(gunIgnore.Name:sub(11))) then
					gunIgnore:Destroy()
				end
			end
		end
		wait(1 / 20)
	end
end)

----------------------------------------------------------------------
--------------------[ RESET CAMERA ]----------------------------------
----------------------------------------------------------------------

Gun.ChildRemoved:connect(function(Child)
	if Child == Handle and Plyr.Value then
		local ignoreCode = Gun:WaitForChild("clientMain"):WaitForChild("ignoreCode").Value
		local resetCam = script:WaitForChild("resetCam")
		resetCam:WaitForChild("ignoreCode").Value = ignoreCode
		resetCam.Parent = Plyr.Value.PlayerGui
	end
end)

----------------------------------------------------------------------
--------------------[ GET WELD CFRAMES ]------------------------------
----------------------------------------------------------------------

for _, v in pairs(Gun:GetChildren()) do
	if v:IsA("BasePart") and v ~= Handle then
		if v:FindFirstChild("mainWeld") then v.mainWeld:Destroy() end
		if (not v:FindFirstChild("weldCF")) then
			local weldCF = Instance.new("CFrameValue")
			weldCF.Name = "weldCF"
			weldCF.Value = Handle.CFrame:toObjectSpace(v.CFrame)
			weldCF.Parent = v
		end
		if string.sub(v.Name, 1, 3) == "Mag" then
			if (not v:FindFirstChild("magTrans")) then
				local magTrans = Instance.new("NumberValue")
				magTrans.Name = "magTrans"
				magTrans.Value = v.Transparency
				magTrans.Parent = v
			end
		end
		v.Anchored = true
		v.CanCollide = false
	end
end
Handle.Anchored = false
Handle.CanCollide = true

----------------------------------------------------------------------
--------------------[ GUNSETUP HANDLING ]-----------------------------
----------------------------------------------------------------------

local gunSetup = script:WaitForChild("gunSetup")
function gunSetup.OnServerInvoke(Player, Vars)

	--------------------[ CREATING IGNORE MODELS ]--------------------------------

	local gunIgnore = Instance.new("Model")
	gunIgnore.Name = "gunIgnore_"..Player.Name
	gunIgnore.Parent = Vars.ignoreModel

	--------------------[ MODIFYING THE PLAYER ]----------------------------------

	Vars.Humanoid.AutoRotate = false

	Vars.Shoulders.Right.Part1 = nil
	Vars.Shoulders.Left.Part1 = nil

	local playerFolder = Instance.new("Model")
	playerFolder.Name = "playerFolder"
	playerFolder.Parent = gunIgnore

	local headBase = Instance.new("Part")
	headBase.Transparency = 1
	headBase.Name = "headBase"
	headBase.CanCollide = false
	headBase.FormFactor = Enum.FormFactor.Custom
	headBase.Size = V3(0.2, 0.2, 0.2)
	headBase.BottomSurface = Enum.SurfaceType.Smooth
	headBase.TopSurface = Enum.SurfaceType.Smooth
	headBase.Parent = playerFolder

	local headWeld = Instance.new("Weld")
	headWeld.Part0 = Vars.Torso
	headWeld.Part1 = headBase
	headWeld.C0 = CF(0, 1.5, 0)
	headWeld.Parent = Vars.Torso

	local headWeld2 = Instance.new("Weld")
	headWeld2.Part0 = headBase
	headWeld2.Part1 = Vars.Head
	headWeld2.Parent = headBase

	local animBase = Instance.new("Part")
	animBase.Transparency = 1
	animBase.Name = "animBase"
	animBase.CanCollide = false
	animBase.FormFactor = Enum.FormFactor.Custom
	animBase.Size = V3(0.2, 0.2, 0.2)
	animBase.BottomSurface = Enum.SurfaceType.Smooth
	animBase.TopSurface = Enum.SurfaceType.Smooth
	animBase.Parent = playerFolder

	local animWeld = Instance.new("Weld")
	animWeld.Part0 = animBase
	animWeld.Part1 = headBase
	animWeld.Parent = animBase

	local armBase = Instance.new("Part")
	armBase.Transparency = 1
	armBase.Name = "ArmBase"
	armBase.CanCollide = false
	armBase.FormFactor = Enum.FormFactor.Custom
	armBase.Size = V3(0.2, 0.2, 0.2)
	armBase.BottomSurface = Enum.SurfaceType.Smooth
	armBase.TopSurface = Enum.SurfaceType.Smooth
	armBase.Parent = playerFolder

	local ABWeld = Instance.new("Weld")
	ABWeld.Part0 = armBase
	ABWeld.Part1 = animBase
	ABWeld.Parent = armBase

	local LArmBase = Instance.new("Part")
	LArmBase.Transparency = 1
	LArmBase.Name = "LArmBase"
	LArmBase.CanCollide = false
	LArmBase.FormFactor = Enum.FormFactor.Custom
	LArmBase.Size = V3(0.2, 0.2, 0.2)
	LArmBase.BottomSurface = Enum.SurfaceType.Smooth
	LArmBase.TopSurface = Enum.SurfaceType.Smooth
	LArmBase.Parent = playerFolder

	local RArmBase = Instance.new("Part")
	RArmBase.Transparency = 1
	RArmBase.Name = "RArmBase"
	RArmBase.CanCollide = false
	RArmBase.FormFactor = Enum.FormFactor.Custom
	RArmBase.Size = V3(0.2, 0.2, 0.2)
	RArmBase.BottomSurface = Enum.SurfaceType.Smooth
	RArmBase.TopSurface = Enum.SurfaceType.Smooth
	RArmBase.Parent = playerFolder

	local LWeld = Instance.new("Weld")
	LWeld.Name = "LWeld"
	LWeld.Part0 = armBase
	LWeld.Part1 = LArmBase
	LWeld.C0 = Vars.armC0[1]
	LWeld.C1 = Vars.leftArmC1
	LWeld.Parent = armBase

	local RWeld = Instance.new("Weld")
	RWeld.Name = "RWeld"
	RWeld.Part0 = armBase
	RWeld.Part1 = RArmBase
	RWeld.C0 = Vars.armC0[2]
	RWeld.C1 = Vars.rightArmC1
	RWeld.Parent = armBase

	local LWeld2 = Instance.new("Weld")
	LWeld2.Name = "LWeld"
	LWeld2.Part0 = LArmBase
	LWeld2.Part1 = Vars.LArm
	LWeld2.Parent = LArmBase

	local RWeld2 = Instance.new("Weld")
	RWeld2.Name = "RWeld"
	RWeld2.Part0 = RArmBase
	RWeld2.Part1 = Vars.RArm
	RWeld2.Parent = RArmBase

	local LLegWeld = Instance.new("Weld")
	LLegWeld.Name = "LLegWeld"
	LLegWeld.Part0 = Vars.Torso
	LLegWeld.Part1 = nil
	LLegWeld.C0 = CF(-0.5, -2, 0)
	LLegWeld.Parent = Vars.Torso

	local RLegWeld = Instance.new("Weld")
	RLegWeld.Name = "RLegWeld"
	RLegWeld.Part0 = Vars.Torso
	RLegWeld.Part1 = nil
	RLegWeld.C0 = CF(0.5, -2, 0)
	RLegWeld.Parent = Vars.Torso

	for _, Tab in pairs(Vars.gunParts) do
		Tab.Obj.Anchored = false
		local Weld = Instance.new("Weld")
		Weld.Name = "mainWeld"
		Weld.Part0 = Vars.Handle
		Weld.Part1 = Tab.Obj
		Weld.C0 = Tab.Obj.weldCF.Value
		Weld.Parent = Vars.Handle
		Tab.Weld = Weld
	end

	return gunIgnore, playerFolder, headWeld, headWeld2, animWeld, ABWeld, LWeld, RWeld, LWeld2, RWeld2, LLegWeld, RLegWeld, Vars.gunParts
end

----------------------------------------------------------------------
--------------------[ TWEENJOINT HANDLING ]---------------------------
----------------------------------------------------------------------

local createTweenIndicator = script:WaitForChild("createTweenIndicator")
function createTweenIndicator.OnServerInvoke(_, Joint, newCode)
	local tweenIndicator = nil
	if (not Joint:findFirstChild("tweenCode")) then --If the joint isn't being tweened, then
		tweenIndicator = Instance.new("IntValue")
		tweenIndicator.Name = "tweenCode"
		tweenIndicator.Value = newCode
		tweenIndicator.Parent = Joint
	else
		tweenIndicator = Joint.tweenCode
		tweenIndicator.Value = newCode --If the joint is already being tweened, this will change the code, and the tween loop will stop
	end
	return tweenIndicator
end

local lerpCF = script:WaitForChild("lerpCF")
function lerpCF.OnServerInvoke(_, Joint, Prop, startCF, endCF, Alpha)
	spawn(function()
		Joint[Prop] = startCF:lerp(endCF, Alpha)
	end)
end

local deleteTweenIndicator = script:WaitForChild("deleteTweenIndicator")
function deleteTweenIndicator.OnServerInvoke(_, tweenIndicator, newCode)
	if tweenIndicator.Value == newCode then --If this tween functions was the last one called on a joint then it will remove the code
		tweenIndicator:Destroy()
	end
end

----------------------------------------------------------------------
--------------------[ BULLET IMPACT HANDLING ]------------------------
----------------------------------------------------------------------

local createBulletImpact = script:WaitForChild("createBulletImpact")
createBulletImpact.OnServerEvent:connect(function(_, H, P, N, D, humanoidFound, gunIgnore, S)
	local surfaceCF = CF(P, P + N)
	----------------------------------------------------------------------------------
	--Creating the bullet hole--------------------------------------------------------
	----------------------------------------------------------------------------------
	if S.bulletHoles and (not humanoidFound) then
		local Hole = Instance.new("Part")
		Hole.Transparency = 1
		Hole.Anchored = true
		Hole.CanCollide = false
		Hole.FormFactor = "Custom"
		Hole.Size = V3(1, 1, 0.2)
		Hole.TopSurface = 0
		Hole.BottomSurface = 0
		local Mesh = Instance.new("BlockMesh")
		Mesh.Offset = V3(0, 0, -0.05)
		Mesh.Scale = V3(S.holeSettings.Size, S.holeSettings.Size, 0)
		Mesh.Parent = Hole
		local Decal = Instance.new("Decal")
		Decal.Face = Enum.NormalId.Front
		Decal.Texture = S.holeSettings.Texture
		Decal.Parent = Hole
		Hole.Parent = gunIgnore
		Hole.CFrame = surfaceCF
		if (not H.Anchored) then
			local Weld = Instance.new("Weld", Hole)
			Weld.Part0 = H
			Weld.Part1 = Hole
			Weld.C0 = H.CFrame:toObjectSpace(surfaceCF)
			Hole.Anchored = false
		end
		delay(S.holeSettings.visibleTime, function()
			if S.holeSettings.disappearTime > 0 then
				local t0 = tick()
				while true do
					local Alpha = math.min((tick() - t0) / S.holeSettings.disappearTime, 1)
					Decal.Transparency = numLerp(0, 1, Alpha)
					if Alpha == 1 then break end
					wait()
				end
				Hole:Destroy()
			else
				Hole:Destroy()
			end
		end)
	end
	----------------------------------------------------------------------------------
	--Creating the spark effect-------------------------------------------------------
	----------------------------------------------------------------------------------
	if S.bulletSparks and (not humanoidFound) and inList(H.Material, S.sparkSettings.Materials) then
		local Sparks = Instance.new("Part")
		Sparks.Transparency = 1
		Sparks.Anchored = true
		Sparks.CanCollide = false
		Sparks.FormFactor = "Custom"
		Sparks.Size = V3(1, 1, 1)
		Sparks.TopSurface = 0
		Sparks.BottomSurface = 0

		local Particles = nil
		if S.customSparks then
			Particles = getObject(game.ServerStorage, "ParticleEmitter", "bulletSpark"):Clone()
		else
			Particles = Instance.new("ParticleEmitter")
			Particles.Color = ColorSequence.new(S.sparkSettings.Color.Start, S.sparkSettings.Color.End)
			Particles.LightEmission = 1
			Particles.Size = NumberSequence.new(
				{
					NumberSequenceKeypoint.new(0, S.sparkSettings.Size, 0.25);
					NumberSequenceKeypoint.new(1, 0);
				}
			)
			Particles.Texture = S.sparkSettings.Texture
			Particles.Transparency = NumberSequence.new(0)
			Particles.Acceleration = V3(0, -196.2, 0)
			Particles.EmissionDirection = Enum.NormalId.Front
			Particles.Lifetime = NumberRange.new(S.sparkSettings.Lifetime - 0.05, S.sparkSettings.Lifetime + 0.05)
			Particles.Rate = S.sparkSettings.Rate
			Particles.Rotation = NumberRange.new(0, 360)
			Particles.Speed = NumberRange.new(S.sparkSettings.Speed - 5, S.sparkSettings.Speed + 5)
			Particles.VelocitySpread = S.sparkSettings.Spread
		end
		Particles.Parent = Sparks

		Sparks.Parent = gunIgnore
		Sparks.CFrame = surfaceCF
		if (not H.Anchored) then
			local Weld = Instance.new("Weld", Sparks)
			Weld.Part0 = H
			Weld.Part1 = Sparks
			Weld.C0 = H.CFrame:toObjectSpace(surfaceCF)
			Sparks.Anchored = false
		end
		delay(0.1, function()
			Particles.Enabled = false
			wait(Particles.Lifetime.Max)
			Sparks:Destroy()
		end)
	end
	----------------------------------------------------------------------------------
	--Creating the smoke effect-------------------------------------------------------
	----------------------------------------------------------------------------------
	if S.bulletSmoke and (not humanoidFound) then
		local Smoke = Instance.new("Part")
		Smoke.Transparency = 1
		Smoke.Anchored = true
		Smoke.CanCollide = false
		Smoke.FormFactor = "Custom"
		Smoke.Size = V3(1, 1, 1)
		Smoke.TopSurface = 0
		Smoke.BottomSurface = 0

		local Particles = Instance.new("ParticleEmitter")
		Particles.Color = ColorSequence.new(S.smokeSettings.objColor and H.Color or S.smokeSettings.Color)
		Particles.LightEmission = 0
		Particles.Size = NumberSequence.new(
			{
				NumberSequenceKeypoint.new(0, S.smokeSettings.Size.Start);
				NumberSequenceKeypoint.new(1, S.smokeSettings.Size.End);
			}
		)
		Particles.Texture = S.smokeSettings.Texture
		Particles.Transparency = NumberSequence.new(
			{
				NumberSequenceKeypoint.new(0, S.smokeSettings.startTransparency);
				NumberSequenceKeypoint.new(0.5, 0.75 * S.smokeSettings.startTransparency + 0.25);
				NumberSequenceKeypoint.new(1, 1);
			}
		)
		Particles.Acceleration = V3(0, -196.2, 0)
		Particles.EmissionDirection = Enum.NormalId.Front
		Particles.Lifetime = NumberRange.new(S.smokeSettings.Lifetime - 0.05, S.smokeSettings.Lifetime + 0.05)
		Particles.Rate = S.smokeSettings.Rate
		Particles.Rotation = NumberRange.new(0, 360)
		Particles.RotSpeed = NumberRange.new(10)
		Particles.Speed = NumberRange.new(S.smokeSettings.Speed - 5, S.smokeSettings.Speed + 5)
		Particles.VelocitySpread = S.smokeSettings.Spread
		Particles.Parent = Smoke

		Smoke.Parent = gunIgnore
		Smoke.CFrame = surfaceCF
		if (not H.Anchored) then
			local Weld = Instance.new("Weld", Smoke)
			Weld.Part0 = H
			Weld.Part1 = Smoke
			Weld.C0 = H.CFrame:toObjectSpace(surfaceCF)
			Smoke.Anchored = false
		end
		delay(0.1, function()
			Particles.Enabled = false
			wait(S.smokeSettings.Lifetime + 0.05)
			Smoke:Destroy()
		end)
	end
end)

----------------------------------------------------------------------
--------------------[ SHOCKWAVE HANDLING ]----------------------------
----------------------------------------------------------------------

local createShockwave = script:WaitForChild("createShockwave")
createShockwave.OnServerEvent:connect(function(_, Center, Radius, gunIgnore, S)
	local Shockwave = Instance.new("Part")
	Shockwave.BrickColor = S.shockwaveSettings.Color
	Shockwave.Material = Enum.Material.SmoothPlastic
	Shockwave.Name = "Shockwave"
	Shockwave.Anchored = true
	Shockwave.CanCollide = false
	Shockwave.FormFactor = Enum.FormFactor.Symmetric
	Shockwave.Size = V3(1, 1, 1)
	Shockwave.BottomSurface = Enum.SurfaceType.Smooth
	Shockwave.TopSurface = Enum.SurfaceType.Smooth
	local Mesh = Instance.new("SpecialMesh")
	Mesh.MeshType = Enum.MeshType.Sphere
	Mesh.Scale = V3()
	Mesh.Parent = Shockwave
	Shockwave.Parent = gunIgnore
	Shockwave.CFrame = CF(Center)
	spawn(function()
		local t0 = tick()
		while true do
			local Alpha = math.min((tick() - t0) / S.shockwaveSettings.Duration, 1)
			local Scale = 2 * Radius * Alpha
			Mesh.Scale = V3(Scale, Scale, Scale)
			Shockwave.Transparency = Alpha
			if Alpha == 1 then break end
			wait()
		end
		Shockwave:Destroy()
	end)
end)

----------------------------------------------------------------------
--------------------[ BLOOD HANDLING ]--------------------------------
----------------------------------------------------------------------

local createBlood = script:WaitForChild("createBlood")
createBlood.OnServerEvent:connect(function(_, H, P, D, gunIgnore, S)
	local bloodCF = CF(P, P + D) * CFANG(RAD(-90), 0, 0)
	local Blood = Instance.new("Part")
	Blood.Transparency = 1
	Blood.Anchored = true
	Blood.CanCollide = false
	Blood.FormFactor = "Custom"
	Blood.Size = V3(0.2, 1, 0.2)
	Blood.TopSurface = 0
	Blood.BottomSurface = 0

	local Particles = Instance.new("ParticleEmitter")
	Particles.Color = ColorSequence.new(S.bloodSettings.Color)
	Particles.LightEmission = 0
	Particles.Size = NumberSequence.new(S.bloodSettings.Size)
	Particles.Texture = S.bloodSettings.Texture
	Particles.Transparency = NumberSequence.new(
		{
			NumberSequenceKeypoint.new(0, S.bloodSettings.startTransparency);
			NumberSequenceKeypoint.new(1, 1);
		}
	)
	Particles.EmissionDirection = Enum.NormalId.Top
	Particles.Lifetime = NumberRange.new(S.bloodSettings.Lifetime - 0.05, S.bloodSettings.Lifetime + 0.05)
	Particles.Rate = S.bloodSettings.Rate
	Particles.Rotation = NumberRange.new(0, 90)
	Particles.Speed = NumberRange.new(S.bloodSettings.Speed)
	Particles.VelocitySpread = S.bloodSettings.Spread
	Particles.Parent = Blood

	Blood.Parent = gunIgnore
	Blood.CFrame = bloodCF
	if (not H.Anchored) then
		local Weld = Instance.new("Weld", Blood)
		Weld.Part0 = H
		Weld.Part1 = Blood
		Weld.C0 = H.CFrame:toObjectSpace(bloodCF)
		Blood.Anchored = false
	end
	delay(0.15, function()
		Particles.Enabled = false
		wait(S.bloodSettings.Lifetime + 0.05)
		Blood:Destroy()
	end)
end)

----------------------------------------------------------------------
--------------------[ TRAIL HANDLING ]--------------------------------
----------------------------------------------------------------------

local createTrail = script:WaitForChild("createTrail")
createTrail.OnServerEvent:connect(function(_, Origin, P, gunIgnore, S)
	local Trail = Instance.new("Part")
	Trail.BrickColor = S.trailSettings.Color
	Trail.Transparency = S.trailSettings.Transparency
	Trail.Anchored = true
	Trail.CanCollide = false
	Trail.Size = V3(1, 1, 1)
	local Mesh = Instance.new("CylinderMesh")
	Mesh.Offset = V3(0, -(P - Origin).magnitude / 2, 0)
	Mesh.Scale = V3(S.trailSettings.Thickness, (P - Origin).magnitude, S.trailSettings.Thickness)
	Mesh.Parent = Trail
	Trail.Parent = gunIgnore
	Trail.CFrame = CF(Origin, P) * CFANG(RAD(90), 0, 0)
	delay(S.trailSettings.visibleTime, function()
		if S.trailSettings.disappearTime > 0 then
			local t0 = tick()
			while true do
				local Alpha = math.min((tick() - t0) / S.trailSettings.disappearTime, 1)
				Trail.Transparency = numLerp(S.trailSettings.Transparency, 1, Alpha)
				if Alpha == 1 then break end
				wait()
			end
			Trail:Destroy()
		else
			Trail:Destroy()
		end
	end)
end)
end))
ObjectValue98.Name = "Plyr"
ObjectValue98.Parent = Script97
RemoteFunction99.Name = "getWeldCF"
RemoteFunction99.Parent = Script97
RemoteFunction100.Name = "gunSetup"
RemoteFunction100.Parent = Script97
RemoteFunction101.Name = "tweenJoint"
RemoteFunction101.Parent = Script97
RemoteEvent102.Name = "onRenderStep"
RemoteEvent102.Parent = Script97
RemoteFunction103.Name = "createTweenIndicator"
RemoteFunction103.Parent = Script97
RemoteFunction104.Name = "deleteTweenIndicator"
RemoteFunction104.Parent = Script97
RemoteFunction105.Name = "lerpCF"
RemoteFunction105.Parent = Script97
LocalScript106.Name = "resetCam"
LocalScript106.Parent = Script97
table.insert(cors,sandbox(LocalScript106,function()
repeat wait() until game.Players.LocalPlayer.Character

local Player = game.Players.LocalPlayer
local Char = Player.Character
local Humanoid = Char:WaitForChild("Humanoid")

local Cam = game.Workspace.CurrentCamera
local UIS = game:GetService("UserInputService")

local ignoreCode = script:WaitForChild("ignoreCode")
repeat wait() until ignoreCode.Value ~= 0
local ignoreModel = game.Workspace:WaitForChild("ignoreModel_"..ignoreCode.Value)
local gunIgnore = ignoreModel:FindFirstChild("gunIgnore_"..Player.Name)

Cam.FieldOfView = 70
Cam.CameraType = Enum.CameraType.Custom
Cam:ClearAllChildren()

UIS.MouseBehavior = Enum.MouseBehavior.Default
UIS.MouseIconEnabled = true

Player.CameraMode = Enum.CameraMode.Classic

Humanoid.WalkSpeed = 16
Humanoid.AutoRotate = true

if gunIgnore then gunIgnore:Destroy() end
end))
IntValue107.Name = "ignoreCode"
IntValue107.Parent = LocalScript106
RemoteEvent108.Name = "createBulletImpact"
RemoteEvent108.Parent = Script97
RemoteEvent109.Name = "createShockwave"
RemoteEvent109.Parent = Script97
RemoteEvent110.Name = "createBlood"
RemoteEvent110.Parent = Script97
RemoteEvent111.Name = "createTrail"
RemoteEvent111.Parent = Script97
ManualWeld112.Name = "BoltBack-to-BoltBack Strong Joint"
ManualWeld112.Parent = mas
ManualWeld112.C0 = CFrame.new(0.625068724, -0.405017436, 0.405023932, 0, 0, 1, 0, 1, -0, -1, 0, 0)
ManualWeld112.C1 = CFrame.new(0.405136883, 0.00964355469, 0.405289888, 8.75407204e-06, -1.00000083, 4.18243417e-07, -1.9739764e-06, 4.16348257e-07, 1.00000513, -1.00000739, -1.20323393e-05, -1.9724248e-06)
ManualWeld112.Part0 = nil
ManualWeld112.Part1 = nil
ManualWeld113.Name = "BoltBack-to-Bolt Strong Joint"
ManualWeld113.Parent = mas
ManualWeld113.C0 = CFrame.new(0.625068724, -0.405017436, 0.405023932, 0, 0, 1, 0, 1, -0, -1, 0, 0)
ManualWeld113.C1 = CFrame.new(0.40513739, 0.00952148438, 0.405278921, 1.44540654e-05, -1, 8.52680785e-07, -7.99414829e-06, 8.52565222e-07, 1, -1, -1.44540718e-05, -7.99413556e-06)
ManualWeld113.Part0 = nil
ManualWeld113.Part1 = nil
ManualWeld114.Name = "Grip-to-Mag Strong Joint"
ManualWeld114.Parent = mas
ManualWeld114.C0 = CFrame.new(0.0500016622, -0.325031132, 0.325033486, 1, 0, 0, 0, 0, -1, 0, 1, 0)
ManualWeld114.C1 = CFrame.new(0.155040443, -0.244984984, -0.225891113, -0.999999166, -1.16036881e-06, -3.29050204e-06, -8.68707048e-07, 1.38209816e-05, 0.999997616, -1.0148425e-06, 0.999999404, -1.95805678e-05)
ManualWeld114.Part0 = nil
ManualWeld114.Part1 = nil
ManualWeld115.Name = "Grip-to-Mag Strong Joint"
ManualWeld115.Parent = mas
ManualWeld115.C0 = CFrame.new(0.0500016622, -0.325031132, 0.325033486, 1, 0, 0, 0, 0, -1, 0, 1, 0)
ManualWeld115.C1 = CFrame.new(-0.254957616, -0.244977713, -0.225891113, -1, -8.6936484e-07, 1.56242345e-06, 1.56241674e-06, 7.93099662e-06, 1, -8.69377232e-07, 1, -7.93099571e-06)
ManualWeld115.Part0 = nil
ManualWeld115.Part1 = nil
ManualWeld116.Name = "Misc-to-Misc Strong Joint"
ManualWeld116.Parent = mas
ManualWeld116.C0 = CFrame.new(0.450001687, -0.0500037596, 0.450001001, 0.99999994, 0, 0, 0, 0, -0.99999994, -0, 1, 0)
ManualWeld116.C1 = CFrame.new(-0.449884027, 0.00927734375, -0.44998008, -1, -6.49860067e-06, 8.75691403e-05, -8.75705809e-05, 0.000222719216, -1, 6.47909701e-06, -1, -0.000222719784)
ManualWeld116.Part0 = nil
ManualWeld116.Part1 = nil
Part117.Name = "AimPart"
Part117.Parent = Tool0
Part117.BrickColor = BrickColor.new("Really black")
Part117.Reflectance = 0.10000000149012
Part117.Transparency = 1
Part117.FormFactor = Enum.FormFactor.Plate
Part117.Size = Vector3.new(0.25, 0.300000012, 0.300000012)
Part117.CFrame = CFrame.new(-0.75, 1.82500005, -1023, 0.999999166, -8.22455877e-06, 1.59695787e-07, 5.80272945e-06, 0.999997616, 6.04837842e-05, -3.0570294e-07, -6.62434541e-05, 0.999999404)
Part117.BottomSurface = Enum.SurfaceType.Smooth
Part117.TopSurface = Enum.SurfaceType.Smooth
Part117.Color = Color3.new(0.0666667, 0.0666667, 0.0666667)
Part117.Position = Vector3.new(-0.75, 1.82500005, -1023)
Part117.Color = Color3.new(0.0666667, 0.0666667, 0.0666667)
Weld118.Parent = Part117
Weld118.C0 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld118.C1 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld118.Part0 = Part117
Weld118.Part1 = Part117
Weld119.Parent = Part117
Weld119.C0 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld119.C1 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld119.Part0 = Part117
Weld119.Part1 = Part117
Weld120.Parent = Part117
Weld120.C0 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld120.C1 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld120.Part0 = Part117
Weld120.Part1 = Part117
BlockMesh121.Parent = Part117
BlockMesh121.Scale = Vector3.new(0.0500000007, 0.650000036, 0.300000012)
BlockMesh121.Scale = Vector3.new(0.0500000007, 0.650000036, 0.300000012)
ManualWeld122.Name = "Misc-to-Misc Strong Joint"
ManualWeld122.Parent = mas
ManualWeld122.C0 = CFrame.new(-0.450000018, -0.25000006, 0.0500000007, 1, 0, 0, 0, 1, 0, 0, 0, 1)
ManualWeld122.C1 = CFrame.new(-0.449859858, 0.0100097656, -0.250048518, 1, -5.81829481e-05, 0.000121089586, 0.000121068173, -0.000367745582, -1, 5.82274661e-05, 1, -0.000367738539)
ManualWeld122.Part0 = nil
ManualWeld122.Part1 = nil
Part123.Name = "Handle"
Part123.Parent = Tool0
Part123.Material = Enum.Material.Metal
Part123.BrickColor = BrickColor.new("Really black")
Part123.Reflectance = 0.10000000149012
Part123.FormFactor = Enum.FormFactor.Plate
Part123.Size = Vector3.new(1, 0.400000006, 1)
Part123.CFrame = CFrame.new(-0.0799999982, 1.14499998, -1023.70001, 0.999999166, -3.24303874e-05, -2.57747911e-06, 3.00083575e-05, 0.999997616, -6.64702238e-05, 2.43398608e-06, 6.07107067e-05, 0.999999404)
Part123.BottomSurface = Enum.SurfaceType.Smooth
Part123.TopSurface = Enum.SurfaceType.Smooth
Part123.Color = Color3.new(0.0666667, 0.0666667, 0.0666667)
Part123.Position = Vector3.new(-0.0799999982, 1.14499998, -1023.70001)
Part123.Color = Color3.new(0.0666667, 0.0666667, 0.0666667)
BlockMesh124.Parent = Part123
BlockMesh124.Scale = Vector3.new(0.0500000007, 0.650000036, 0.300000012)
BlockMesh124.Scale = Vector3.new(0.0500000007, 0.650000036, 0.300000012)
Sound125.Name = "FireSound"
Sound125.Parent = Part123
Sound125.SoundId = "rbxassetid://132456187"
Weld126.Parent = Part123
Weld126.C0 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld126.C1 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld126.Part0 = Part123
Weld126.Part1 = Part123
Weld127.Parent = Part123
Weld127.C0 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld127.C1 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld127.Part0 = Part123
Weld127.Part1 = Part123
Weld128.Parent = Part123
Weld128.C0 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld128.C1 = CFrame.new(0, 0, 0, -0.573416114, -0.0331745297, 0.81859225, -0.0776699185, 0.99688077, -0.0140071288, -0.815574169, -0.0716118738, -0.574204147)
Weld128.Part0 = Part123
Weld128.Part1 = Part123
ManualWeld129.Name = "Bolt-to-BoltBack Strong Joint"
ManualWeld129.Parent = mas
ManualWeld129.C0 = CFrame.new(0.625068724, -0.405017436, 0.405023932, 0, 0, 1, 0, 1, -0, -1, 0, 0)
ManualWeld129.C1 = CFrame.new(0.405138791, 0.00964355469, 0.405309081, 3.04465129e-06, -1, 5.59968214e-07, -7.86535111e-06, 5.59944283e-07, 1, -1, -3.04465584e-06, -7.86534929e-06)
ManualWeld129.Part0 = nil
ManualWeld129.Part1 = nil
ManualWeld130.Name = "Bolt-to-Bolt Strong Joint"
ManualWeld130.Parent = mas
ManualWeld130.C0 = CFrame.new(0.625068724, -0.405017436, 0.405023932, 0, 0, 1, 0, 1, -0, -1, 0, 0)
ManualWeld130.C1 = CFrame.new(0.405144274, 0.00952148438, 0.405310631, -2.67400219e-06, -1, 1.28348017e-06, -2.56683252e-05, 1.28354884e-06, 1, -1, 2.67396877e-06, -2.56683288e-05)
ManualWeld130.Part0 = nil
ManualWeld130.Part1 = nil
IntValue131.Name = "Ammo"
IntValue131.Parent = Tool0
IntValue131.Value = 4
ManualWeld132.Name = "Grip2-to-Grip2 Strong Joint"
ManualWeld132.Parent = mas
ManualWeld132.C0 = CFrame.new(0.0500000045, -0.100000009, 0.0250000134, 1, 0, 0, 0, 0, -1, 0, 1, 0)
ManualWeld132.C1 = CFrame.new(0.049996756, 0.199924648, 0.0250244141, 1, -2.91017074e-07, -4.84369866e-06, -4.84369866e-06, -4.1427143e-11, -1, 2.91017074e-07, 1, -4.27464557e-11)
ManualWeld132.Part0 = nil
ManualWeld132.Part1 = nil
IntValue133.Name = "ClipSize"
IntValue133.Parent = Tool0
IntValue133.Value = 4
IntValue134.Name = "StoredAmmo"
IntValue134.Parent = Tool0
IntValue134.Value = 240
ManualWeld135.Name = "Misc-to-Misc Strong Joint"
ManualWeld135.Parent = mas
ManualWeld135.C0 = CFrame.new(-0.449999988, 0.0100080129, 0.4500359, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld135.C1 = CFrame.new(0.45012334, 0.0100097656, -0.44995296, 1, -1.11122654e-05, -8.69558062e-05, 8.69580253e-05, 0.000199721748, 1, -1.10948977e-05, -1, 0.000199722708)
ManualWeld135.Part0 = nil
ManualWeld135.Part1 = nil
ManualWeld136.Name = "Body-to-Bolt Strong Joint"
ManualWeld136.Parent = mas
ManualWeld136.C0 = CFrame.new(-0.450001568, 2.17506409, 0.450050414, -1, 0, 0, 0, 0, 1, 0, 1, -0)
ManualWeld136.C1 = CFrame.new(-0.625488281, 0.449997813, 0.45008862, -2.70885266e-07, 3.27823218e-05, 1.00000477, 1.00000024, -1.53244291e-05, 4.1487715e-07, 9.61506612e-06, 1.00000477, -2.68908843e-05)
ManualWeld136.Part0 = nil
ManualWeld136.Part1 = nil
for i,v in pairs(mas:GetChildren()) do
	v.Parent = game:GetService("Players").LocalPlayer.Backpack
	pcall(function() v:MakeJoints() end)
end
mas:Destroy()
for i,v in pairs(cors) do
	spawn(function()
		pcall(v)
	end)
end