Halo Assault Rifle

--Made by 1ndrew legit experience lol
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")
Part1 = Instance.new("Part")
SpecialMesh2 = Instance.new("SpecialMesh")
Part3 = Instance.new("Part")
SpecialMesh4 = Instance.new("SpecialMesh")
ParticleEmitter5 = Instance.new("ParticleEmitter")
ParticleEmitter6 = Instance.new("ParticleEmitter")
PointLight7 = Instance.new("PointLight")
Part8 = Instance.new("Part")
SpecialMesh9 = Instance.new("SpecialMesh")
Sound10 = Instance.new("Sound")
Sound11 = Instance.new("Sound")
Sound12 = Instance.new("Sound")
Part13 = Instance.new("Part")
CylinderMesh14 = Instance.new("CylinderMesh")
IntValue15 = Instance.new("IntValue")
IntValue16 = Instance.new("IntValue")
Script17 = Instance.new("Script")
NumberValue18 = Instance.new("NumberValue")
Script19 = Instance.new("Script")
ObjectValue20 = Instance.new("ObjectValue")
RemoteFunction21 = Instance.new("RemoteFunction")
RemoteFunction22 = Instance.new("RemoteFunction")
RemoteFunction23 = Instance.new("RemoteFunction")
RemoteEvent24 = Instance.new("RemoteEvent")
RemoteFunction25 = Instance.new("RemoteFunction")
RemoteFunction26 = Instance.new("RemoteFunction")
RemoteFunction27 = Instance.new("RemoteFunction")
LocalScript28 = Instance.new("LocalScript")
IntValue29 = Instance.new("IntValue")
RemoteEvent30 = Instance.new("RemoteEvent")
RemoteEvent31 = Instance.new("RemoteEvent")
RemoteEvent32 = Instance.new("RemoteEvent")
RemoteEvent33 = Instance.new("RemoteEvent")
LocalScript34 = Instance.new("LocalScript")
IntValue35 = Instance.new("IntValue")
Folder36 = Instance.new("Folder")
ScreenGui37 = Instance.new("ScreenGui")
Frame38 = Instance.new("Frame")
Frame39 = Instance.new("Frame")
TextLabel40 = Instance.new("TextLabel")
TextLabel41 = Instance.new("TextLabel")
TextLabel42 = Instance.new("TextLabel")
Frame43 = Instance.new("Frame")
TextLabel44 = Instance.new("TextLabel")
TextLabel45 = Instance.new("TextLabel")
Frame46 = Instance.new("Frame")
Frame47 = Instance.new("Frame")
ImageLabel48 = Instance.new("ImageLabel")
TextLabel49 = Instance.new("TextLabel")
TextLabel50 = Instance.new("TextLabel")
Frame51 = Instance.new("Frame")
ImageLabel52 = Instance.new("ImageLabel")
TextLabel53 = Instance.new("TextLabel")
TextLabel54 = Instance.new("TextLabel")
Frame55 = Instance.new("Frame")
TextLabel56 = Instance.new("TextLabel")
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")
Frame65 = Instance.new("Frame")
Frame66 = Instance.new("Frame")
Frame67 = Instance.new("Frame")
Frame68 = Instance.new("Frame")
Frame69 = Instance.new("Frame")
Frame70 = Instance.new("Frame")
Frame71 = Instance.new("Frame")
Frame72 = Instance.new("Frame")
Frame73 = Instance.new("Frame")
Frame74 = Instance.new("Frame")
Frame75 = Instance.new("Frame")
Frame76 = Instance.new("Frame")
Frame77 = Instance.new("Frame")
Frame78 = Instance.new("Frame")
Frame79 = Instance.new("Frame")
Frame80 = Instance.new("Frame")
Frame81 = Instance.new("Frame")
Frame82 = Instance.new("Frame")
TextLabel83 = Instance.new("TextLabel")
TextLabel84 = Instance.new("TextLabel")
TextLabel85 = Instance.new("TextLabel")
Frame86 = Instance.new("Frame")
TextLabel87 = Instance.new("TextLabel")
TextLabel88 = Instance.new("TextLabel")
ImageLabel89 = Instance.new("ImageLabel")
NumberValue90 = Instance.new("NumberValue")
TextLabel91 = Instance.new("TextLabel")
Frame92 = Instance.new("Frame")
TextLabel93 = Instance.new("TextLabel")
Frame94 = Instance.new("Frame")
ImageLabel95 = Instance.new("ImageLabel")
ImageLabel96 = Instance.new("ImageLabel")
Frame97 = Instance.new("Frame")
Frame98 = Instance.new("Frame")
LocalScript99 = Instance.new("LocalScript")
Frame100 = Instance.new("Frame")
Frame101 = Instance.new("Frame")
ImageLabel102 = Instance.new("ImageLabel")
ImageLabel103 = Instance.new("ImageLabel")
TextLabel104 = Instance.new("TextLabel")
Frame105 = Instance.new("Frame")
ImageLabel106 = Instance.new("ImageLabel")
TextLabel107 = Instance.new("TextLabel")
Frame108 = Instance.new("Frame")
TextLabel109 = Instance.new("TextLabel")
Frame110 = Instance.new("Frame")
TextLabel111 = Instance.new("TextLabel")
Frame112 = Instance.new("Frame")
TextLabel113 = Instance.new("TextLabel")
Frame114 = Instance.new("Frame")
TextLabel115 = Instance.new("TextLabel")
Part116 = Instance.new("Part")
SpecialMesh117 = Instance.new("SpecialMesh")
Part118 = Instance.new("Part")
SpecialMesh119 = Instance.new("SpecialMesh")
Part120 = Instance.new("Part")
SpecialMesh121 = Instance.new("SpecialMesh")
Part122 = Instance.new("Part")
SpecialMesh123 = Instance.new("SpecialMesh")
Part124 = Instance.new("Part")
SpecialMesh125 = Instance.new("SpecialMesh")
Part126 = Instance.new("Part")
SpecialMesh127 = Instance.new("SpecialMesh")
Part128 = Instance.new("Part")
SpecialMesh129 = Instance.new("SpecialMesh")
Tool0.Name = "MA5D"
Tool0.Parent = mas
Tool0.GripForward = Vector3.new(-0.971995592, 0, 0.234998941)
Tool0.GripPos = Vector3.new(0.100000001, -0.699999988, 0)
Tool0.GripRight = Vector3.new(-0.234998971, 0, -0.971995711)
Tool0.ToolTip = "Auto"
Part1.Name = "SightMark"
Part1.Parent = Tool0
Part1.Material = Enum.Material.Metal
Part1.BrickColor = BrickColor.new("Black")
Part1.Transparency = 1
Part1.Rotation = Vector3.new(0, 0, -1)
Part1.Anchored = true
Part1.CanCollide = false
Part1.FormFactor = Enum.FormFactor.Custom
Part1.Size = Vector3.new(0.200000003, 0.200000003, 0.200000003)
Part1.CFrame = CFrame.new(6.22700024, 1, 45.8950005, 0.99984777, 0.017451996, 0, -0.017451996, 0.99984777, 0, 0, 0, 1)
Part1.BackSurface = Enum.SurfaceType.SmoothNoOutlines
Part1.BottomSurface = Enum.SurfaceType.SmoothNoOutlines
Part1.FrontSurface = Enum.SurfaceType.SmoothNoOutlines
Part1.LeftSurface = Enum.SurfaceType.SmoothNoOutlines
Part1.RightSurface = Enum.SurfaceType.SmoothNoOutlines
Part1.TopSurface = Enum.SurfaceType.SmoothNoOutlines
Part1.Color = Color3.new(0.105882, 0.164706, 0.207843)
Part1.Position = Vector3.new(6.22700024, 1, 45.8950005)
Part1.Orientation = Vector3.new(0, 0, -1)
Part1.Color = Color3.new(0.105882, 0.164706, 0.207843)
SpecialMesh2.Parent = Part1
SpecialMesh2.MeshId = "http://www.roblox.com/asset/?id=11645468"
SpecialMesh2.Scale = Vector3.new(0, 0, 0)
SpecialMesh2.MeshType = Enum.MeshType.FileMesh
SpecialMesh2.Scale = Vector3.new(0, 0, 0)
Part3.Name = "Flame"
Part3.Parent = Tool0
Part3.Material = Enum.Material.Metal
Part3.BrickColor = BrickColor.new("Really black")
Part3.Rotation = Vector3.new(-90, 0, -180)
Part3.Anchored = true
Part3.CanCollide = false
Part3.FormFactor = Enum.FormFactor.Custom
Part3.Size = Vector3.new(0.200000003, 0.200000003, 0.200000003)
Part3.CFrame = CFrame.new(3.52699995, 0.890999973, 45.5390015, -1, 0, 0, 0, 0, 1, 0, 1, 0)
Part3.BottomSurface = Enum.SurfaceType.Smooth
Part3.TopSurface = Enum.SurfaceType.Smooth
Part3.Color = Color3.new(0.0666667, 0.0666667, 0.0666667)
Part3.Position = Vector3.new(3.52699995, 0.890999973, 45.5390015)
Part3.Orientation = Vector3.new(-90, -180, 0)
Part3.Color = Color3.new(0.0666667, 0.0666667, 0.0666667)
SpecialMesh4.Parent = Part3
SpecialMesh4.Scale = Vector3.new(0, 0, 0)
SpecialMesh4.MeshType = Enum.MeshType.Sphere
SpecialMesh4.Scale = Vector3.new(0, 0, 0)
ParticleEmitter5.Name = "1FlashFX[Smoke]"
ParticleEmitter5.Parent = Part3
ParticleEmitter5.Transparency = NumberSequence.new(0.60000002384186,1)
ParticleEmitter5.Rotation = NumberRange.new(0, 360)
ParticleEmitter5.Size = NumberSequence.new(0,0)
ParticleEmitter5.Color = ColorSequence.new(Color3.new(0.27451, 0.27451, 0.27451),Color3.new(0.27451, 0.27451, 0.27451))
ParticleEmitter5.Enabled = false
ParticleEmitter5.LightEmission = 0.10000000149012
ParticleEmitter5.Texture = "http://www.roblox.com/asset/?id=244514423"
ParticleEmitter5.Lifetime = NumberRange.new(1.25, 1.5)
ParticleEmitter5.Rate = 100
ParticleEmitter5.RotSpeed = NumberRange.new(10, 10)
ParticleEmitter5.Speed = NumberRange.new(5, 7)
ParticleEmitter5.VelocitySpread = 15
ParticleEmitter5.Color = ColorSequence.new(Color3.new(0.27451, 0.27451, 0.27451),Color3.new(0.27451, 0.27451, 0.27451))
ParticleEmitter6.Name = "FlashFX[Flash]"
ParticleEmitter6.Parent = Part3
ParticleEmitter6.Transparency = NumberSequence.new(1,0.89999997615814,0.88749998807907,1)
ParticleEmitter6.Size = NumberSequence.new(0,0)
ParticleEmitter6.Color = ColorSequence.new(Color3.new(1, 1, 0.498039),Color3.new(1, 1, 0.498039))
ParticleEmitter6.Enabled = false
ParticleEmitter6.LightEmission = 1
ParticleEmitter6.Texture = "http://www.roblox.com/asset/?id=242102147"
ParticleEmitter6.Lifetime = NumberRange.new(0.050000000745058, 0.075000002980232)
ParticleEmitter6.Rate = 1000
ParticleEmitter6.RotSpeed = NumberRange.new(22, 22)
ParticleEmitter6.Color = ColorSequence.new(Color3.new(1, 1, 0.498039),Color3.new(1, 1, 0.498039))
PointLight7.Name = "FlashFX[Light]"
PointLight7.Parent = Part3
PointLight7.Color = Color3.new(1, 1, 0.498039)
PointLight7.Enabled = false
PointLight7.Brightness = 10
PointLight7.Range = 6
PointLight7.Shadows = true
PointLight7.Color = Color3.new(1, 1, 0.498039)
Part8.Name = "Handle"
Part8.Parent = Tool0
Part8.Material = Enum.Material.Metal
Part8.BrickColor = BrickColor.new("Black")
Part8.Transparency = 1
Part8.Rotation = Vector3.new(89.9799957, 89.0099945, -89.9799957)
Part8.Anchored = true
Part8.CanCollide = false
Part8.FormFactor = Enum.FormFactor.Custom
Part8.Size = Vector3.new(0.200000003, 0.200000003, 0.200000003)
Part8.CFrame = CFrame.new(5.62200022, 0.25, 45.4970016, 6.10947609e-06, 0.0174520668, 0.99985081, -1.06869265e-07, 0.999852538, -0.0174520481, -1.00000095, -2.34570896e-09, 5.54323196e-06)
Part8.BackSurface = Enum.SurfaceType.SmoothNoOutlines
Part8.BottomSurface = Enum.SurfaceType.SmoothNoOutlines
Part8.FrontSurface = Enum.SurfaceType.SmoothNoOutlines
Part8.LeftSurface = Enum.SurfaceType.SmoothNoOutlines
Part8.RightSurface = Enum.SurfaceType.SmoothNoOutlines
Part8.TopSurface = Enum.SurfaceType.SmoothNoOutlines
Part8.Color = Color3.new(0.105882, 0.164706, 0.207843)
Part8.Position = Vector3.new(5.62200022, 0.25, 45.4970016)
Part8.Orientation = Vector3.new(1, 90, 0)
Part8.Color = Color3.new(0.105882, 0.164706, 0.207843)
SpecialMesh9.Parent = Part8
SpecialMesh9.MeshId = "http://www.roblox.com/asset/?id=11645468"
SpecialMesh9.Scale = Vector3.new(0, 0, 0)
SpecialMesh9.MeshType = Enum.MeshType.FileMesh
SpecialMesh9.Scale = Vector3.new(0, 0, 0)
Sound10.Name = "Fire"
Sound10.Parent = Part8
Sound10.SoundId = "rbxassetid://170424842"
Sound10.Volume = 0.69999998807907
Sound11.Name = "MagIn"
Sound11.Parent = Part8
Sound11.SoundId = "rbxassetid://456179899"
Sound11.Volume = 1
Sound12.Name = "MagOut"
Sound12.Parent = Part8
Sound12.SoundId = "rbxassetid://457042936"
Sound12.Volume = 1
Part13.Name = "Chamber"
Part13.Parent = Tool0
Part13.Transparency = 1
Part13.Rotation = Vector3.new(0, 0.00999999978, 90)
Part13.Anchored = true
Part13.CanCollide = false
Part13.FormFactor = Enum.FormFactor.Custom
Part13.Size = Vector3.new(0.200000003, 0.200000003, 0.200000003)
Part13.CFrame = CFrame.new(5.97700024, 0.879000008, 45.5579987, 1.30452008e-05, -1, 0.000101475933, 1.00000036, 1.1878119e-05, 2.57401189e-05, -2.5741514e-05, 0.000101475642, 1.00000036)
Part13.BottomSurface = Enum.SurfaceType.Smooth
Part13.TopSurface = Enum.SurfaceType.Smooth
Part13.Position = Vector3.new(5.97700024, 0.879000008, 45.5579987)
Part13.Orientation = Vector3.new(0, 0.00999999978, 90)
CylinderMesh14.Parent = Part13
IntValue15.Name = "Ammo"
IntValue15.Parent = Tool0
IntValue15.Value = 36
IntValue16.Name = "ClipSize"
IntValue16.Parent = Tool0
IntValue16.Value = 36
Script17.Name = "Credits"
Script17.Parent = Tool0
NumberValue18.Name = "StoredAmmo"
NumberValue18.Parent = Tool0
NumberValue18.Value = 1000000000000000
Script19.Name = "serverMain"
Script19.Parent = Tool0
table.insert(cors,sandbox(Script19,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))
ObjectValue20.Name = "Plyr"
ObjectValue20.Parent = Script19
RemoteFunction21.Name = "getWeldCF"
RemoteFunction21.Parent = Script19
RemoteFunction22.Name = "gunSetup"
RemoteFunction22.Parent = Script19
RemoteFunction23.Name = "tweenJoint"
RemoteFunction23.Parent = Script19
RemoteEvent24.Name = "onRenderStep"
RemoteEvent24.Parent = Script19
RemoteFunction25.Name = "createTweenIndicator"
RemoteFunction25.Parent = Script19
RemoteFunction26.Name = "deleteTweenIndicator"
RemoteFunction26.Parent = Script19
RemoteFunction27.Name = "lerpCF"
RemoteFunction27.Parent = Script19
LocalScript28.Name = "resetCam"
LocalScript28.Parent = Script19
table.insert(cors,sandbox(LocalScript28,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))
IntValue29.Name = "ignoreCode"
IntValue29.Parent = LocalScript28
RemoteEvent30.Name = "createBulletImpact"
RemoteEvent30.Parent = Script19
RemoteEvent31.Name = "createShockwave"
RemoteEvent31.Parent = Script19
RemoteEvent32.Name = "createBlood"
RemoteEvent32.Parent = Script19
RemoteEvent33.Name = "createTrail"
RemoteEvent33.Parent = Script19
LocalScript34.Name = "clientMain"
LocalScript34.Parent = Tool0
table.insert(cors,sandbox(LocalScript34,function()

--------------------------------------------------------------------------------------
--------------------[ CHARACTER LOADING ]---------------------------------------------
--------------------------------------------------------------------------------------
print("Kit By TurboFusion // Remake By MuYhEt & Xander521")

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("SightMark")
local Main = Gun:WaitForChild("Flame")

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 = {}
function Particle.new(Prop)
	----------[ CONSTANTS ]--------------------

	local Cam = workspace.CurrentCamera
	local rayIgnore = Prop.rayIgnore or {} --If the property doesn't exist, then set it to it's default
	local Color = Prop.Color or Color3.new(1, 1, 1)
	local Length = Prop.Length or 1
	local Width = Prop.Width or 1
	local p0 = Prop.p0 or error("Particle.new requires a p0 (origin position) property!", 0) --Give an error message if you don't this
	local v0 = Prop.v0 or error("Particle.new requires a v0 (initial velocity) property!", 0)
	local a0 = Prop.a0 or error("Particle.new requires an a0 (initial acceleration) property!", 0)

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

	local Deleted = false
	local p = p0 --Set the position, velocity, and acceleration as the intial conditions
	local v = v0
	local a = a0
	local t = 0

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

	local function worldWidthToScreenWidth(Width, Depth) --A function I made that gives you a screen width given a world width and depth
		local Center = Cam.CoordinateFrame * CFrame.new(0, 0, -Depth)
		local wp1 = (Center * CFrame.new(0, Width / 2, 0)).p
		local wp2 = (Center * CFrame.new(0, -Width / 2, 0)).p
		local sp1 = Cam:WorldToScreenPoint(wp1) --Use the WorldToScreenPoint method of the camera to get the screen width from the world width
		local sp2 = Cam:WorldToScreenPoint(wp2)
		return (sp1 - sp2).magnitude
	end

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

	local Container = Instance.new("Frame")
	Container.BackgroundTransparency = 1
	Container.Position = UDim2.new()
	Container.Size = UDim2.new()
	local Line = Instance.new("Frame")
	Line.BackgroundColor3 = Color
	Line.BorderSizePixel = 0
	Line.Position = UDim2.new()
	Line.Size = UDim2.new()
	Line.Parent = Container

	return setmetatable(
		{
			delete = function() --This function safely removes the particle
				Container:Destroy()
				Deleted = true
			end
		},
		{
			__index = function(_, Index)
				if Index == "p" or Index == "position" then --Return the world position of the particle
					return (Deleted and nil or p)
				elseif Index == "v" or Index == "velocity" then --Return the world velocity of the particle
					return (Deleted and nil or v)
				elseif Index == "obj" or Index == "object" then --Return the particle frame itself
					return (Deleted and nil or Container)
				else
					error(Index.." is not a member of Particle!", 0) --Give an error message if any other index is called
				end
			end;

			__newindex = function(_, Index, Value)
				if Index == "t" or Index == "time" and (not Deleted) then --Render the particle given a time value
					t = Value
					p = p0 + (v0 * t) + (0.5 * a0 * t * t) --update the position given the time
					v = v0 + (a0 * t) --update the velocity given the time

					local testRay1 = Ray.new(Cam.CoordinateFrame.p, (p + (v.unit * Length) / 2) - Cam.CoordinateFrame.p)
					local testRay2 = Ray.new(Cam.CoordinateFrame.p, (p - (v.unit * Length) / 2) - Cam.CoordinateFrame.p)
					local H1, _ = workspace:FindPartOnRayWithIgnoreList(testRay1, rayIgnore)
					local H2, _ = workspace:FindPartOnRayWithIgnoreList(testRay2, rayIgnore)

					if H1 and H2 then
						Line.Visible = false
					else
						local face1 = Cam:WorldToScreenPoint(p + (v.unit * Length) / 2) --Get the 2 endpoints of the particle in screen space
						local face2 = Cam:WorldToScreenPoint(p - (v.unit * Length) / 2)
						local Center, isVisible = Cam:WorldToScreenPoint(p) --Get the center of the particle in screen space

						local screenLength = (face1 - face2).magnitude
						local screenWidth = worldWidthToScreenWidth(Width, Center.Z)
						local Ang = math.atan2(face1.Y - face2.Y, face1.X - face2.X) --Get the angle the particle needs to be at in order to line up

						Line.Position = UDim2.new(0, 0, 0, -screenWidth / 2)
						Line.Size = UDim2.new(1, 0, 0, screenWidth)
						Line.Visible = isVisible --Make the particle invisible if the world point isn't on screen

						Container.Position = UDim2.new(
							0,
							face2.X + (math.cos(Ang) - 1) * screenLength / 2, --Yay trig!
							0,
							face2.Y + math.sin(Ang) * screenLength / 2
						)
						Container.Size = UDim2.new(0, screenLength, 0, 0)
						Container.Rotation = math.deg(Ang)
					end
				else
					error(Index.." is not a member of Particle!", 0) --Give an error message if any other index is being changed
				end
			end
		}
	)
end
local Spring = {}
function Spring.new(Initial)
	local t0 = tick()
	local p0 = Initial or 0
	local v0 = Initial and Vector3.new() or 0
	local t	= Initial or 0
	local d	= 1
	local s	= 1

	local function positionVelocity(Tick)
		local x	= Tick - t0
		local c0 = p0 - t
		if s == 0 then
			return p0, 0
		elseif d < 1 then
			local c	= math.sqrt(1 - d ^ 2)
			local c1 = (v0 / s + d * c0) / c
			local co = math.cos(c * s * x)
			local si = math.sin(c * s * x)
			local e	= math.exp(d * s * x)
			local p = t + (c0 * co + c1 * si) / e
			local v = s * ((c * c1 - d * c0) * co - (c * c0 + d * c1) * si) / e
			return p, v
		else
			local c1 = v0 / s + c0
			local e	= math.exp(s * x)
			local p = t + (c0 + c1 * s * x) / e
			local v = s * (c1 - c0 - c1 * s * x) / e
			return p, v
		end
	end

	return setmetatable(
		{
			accelerate = function(_, acceleration)
				local T = tick()
				local p, v = positionVelocity(T)
				p0 = p
				v0 = v + acceleration
				t0 = T
			end;
		},
		{
			__index = function(_, index)
				if index == "value" or index == "position" or index == "p" then
					local p, v = positionVelocity(tick())
					return p
				elseif index == "velocity" or index == "v" then
					local p, v = positionVelocity(tick())
					return v
				elseif index == "acceleration" or index == "a" then
					local x	= tick() - t0
					local c0 = p0 - t
					if s == 0 then
						return 0
					elseif d < 1 then
						local c = math.sqrt(1 - d ^ 2)
						local c1 = (v0 / s + d * c0) / c
						local cs = (c0 * d ^ 2 - 2 * c * d * c1 - c0 * c ^ 2) * math.cos(c * s * x)
						local sn = (c1 * d ^ 2 + 2 * c * d * c0 - c1 * c ^ 2) * math.sin(c * s * x)
						return s ^ 2 *(cs + sn) / math.exp(d * s * x)
					else
						local c1 = v0 / s + c0
						return s ^ 2 * (c0 - 2 * c1 + c1 * s * x) / math.exp(s * x)
					end
				elseif index == "target" or index == "t" then
					return t
				elseif index == "damper" or index == "d" then
					return d
				elseif index == "speed" or index == "s" then
					return s
				elseif index == "magnitude" or index == "m" then
					local p, v = positionVelocity(tick())
					return p.magnitude
				else
					error(index.." is not a valid member of spring", 0)
				end
			end;

			__newindex = function(_, index, value)
				local T = tick()
				if index == "value" or index == "position" or index == "p" then
					local p, v = positionVelocity(T)
					p0, v0 = value, v
				elseif index == "velocity" or index == "v" then
					local p, v = positionVelocity(T)
					p0, v0 = p, value
				elseif index == "acceleration" or index == "a" then
					local p, v = positionVelocity(T)
					p0, v0 = p, v + value
				elseif index == "target" or index == "t" then
					p0, v0 = positionVelocity(T)
					t = value
				elseif index == "damper" or index == "d" then
					p0, v0 = positionVelocity(T)
					d = value < 0 and 0 or value < 1 and value or 1
				elseif index == "speed" or index == "s" then
					p0, v0 = positionVelocity(T)
					s = value < 0 and 0 or value
				else
					error(index.." is not a valid member of spring", 0)
				end
				t0 = T
			end;
		}
	)
end
local Anims = {

	Reload = function(S)
		local W1 = nil
		local W2 = nil
		local animSpeed = S.isMagEmpty() and S.reloadTimeEmpty / 1.3 or S.reloadTimeLoaded / 0.9
		return {
			function()
				if (not S.isNewMag()) then
					if S.isMagVisible() then
						local Mag1, magTable1 = S.createMag("Mag1")

						Mag1.Parent = S.gunIgnore

						W1 = Instance.new("Weld")
						W1.Part0 = magTable1[1].magClone
						W1.Part1 = S.Handle
						W1.C0 = magTable1[1].Original.CFrame:toObjectSpace(S.Handle.CFrame)
						W1.Parent = magTable1[1].magClone

						S.tweenJoint(S.LWeld, nil, S.CF(0, 0.61, 0) * S.CFANG(S.RAD(70), 0, S.RAD(0)), S.Sine, .2 * animSpeed)
						S.tweenJoint(S.RWeld, nil, S.CF(0.4, 0.09, -0.21) * S.CFANG(S.RAD(20), 0, S.RAD(0)), S.Sine, 0.2 * animSpeed)
						S.tweenJoint(S.Grip, nil, S.CFANG(0, S.RAD(20), S.RAD(10)), S.Sine, 0.1 * animSpeed)
						wait(0.2 * animSpeed)
					end
				end
			end;

			function()
						S.tweenJoint(S.RWeld, nil, S.CF(0.4, -0.01, -0.31) * S.CFANG(S.RAD(-22), 0, S.RAD(3)), S.Sine, 0.3 * animSpeed)
			end;

			function()
				if (not S.isNewMag()) then
					if S.isMagVisible() then
						S.makeMagInvisible()
						W1:Destroy()
						local Mag1, magTable1 = S.getMag("Mag1")
						magTable1[1].magClone.Velocity = S.Handle.Velocity + S.Handle.CFrame:vectorToWorldSpace(S.V3(0, -1, 0)) * 20

						S.tweenJoint(S.RWeld, nil, S.CF(.6, 0.8, -0.75) * S.CFANG(S.RAD(-20), S.RAD(30), S.RAD(0)), S.Sine, 0.25 * animSpeed)
						S.tweenJoint(S.Grip, nil, S.CFANG(0, S.RAD(20), S.RAD(10)), S.Sine, 0.2 * animSpeed)
						S.tweenJoint(S.LWeld, nil, S.CF(1, 0.9, -1.2) * S.CFANG(S.RAD(-25), S.RAD(0), S.RAD(-90)), S.Sine, 0.25 * animSpeed)
					else
						S.tweenJoint(S.RWeld, nil, S.CF(0.6, 0.2, -0.61) * S.CFANG(S.RAD(-12), S.RAD(20), S.RAD(25)), S.Sine, 0.2 * animSpeed)
						S.tweenJoint(S.Grip, nil, S.CFANG(S.RAD(-10), S.RAD(20), S.RAD(10)), S.Sine, 0.2 * animSpeed)
					end

					S.tweenJoint(S.LWeld, nil, S.CF(0, 0.5, 0) * S.CFANG(S.RAD(95), 0, S.RAD(-25)), S.Sine, 0.2 * animSpeed)
					script.Parent.Handle.MagOut:Play()
					wait(0.1 * animSpeed)
				end
			end;

			function()
				if (not S.isNewMag()) then
					local Mag1, magTable1 = S.getMag("Mag1")
					if Mag1 then Mag1:Destroy() end

					local Mag2, magTable2 = S.createMag("Mag2")

					Mag2.Parent = S.gunIgnore

					local LArmCF = S.LWeld.Part0.CFrame * S.LWeld.C0 * (S.CF(-0.5, 2, -.75) * S.CFANG(S.RAD(-20), S.RAD(20), S.RAD(15))):inverse()
					local RArmCF = S.RWeld.Part0.CFrame * S.RWeld.C0 * (S.CF(.6, 0.5, -1) * S.CFANG(S.RAD(-10), S.RAD(0), S.RAD(20))):inverse()
					local handleOffsetCF = S.RArm.CFrame:toObjectSpace(S.RArm.CFrame * S.Grip.C0 * (S.CFANG(S.RAD(-10), S.RAD(20), S.RAD(10))):inverse())
					local originalMagOffsetCF = S.Handle.CFrame:toObjectSpace(magTable2[1].Original.CFrame)
					local newMagC0 = LArmCF:toObjectSpace(RArmCF * handleOffsetCF * originalMagOffsetCF)

					W2 = Instance.new("Weld")
					W2.Part0 = S.LArm
					W2.Part1 = magTable2[1].magClone
					W2.C0 = newMagC0
					W2.Parent = magTable2[1].magClone

					S.tweenJoint(S.LWeld, nil, S.CF(0.55, 1, -2.4) * S.CFANG(S.RAD(-20), S.RAD(20), S.RAD(-60)), S.Sine, 0.2 * animSpeed)--0.25
					S.tweenJoint(S.RWeld, nil, S.CF(0.6, 0.2, -0.61) * S.CFANG(S.RAD(-12), S.RAD(20), S.RAD(25)), S.Sine, 0.2 * animSpeed)
					S.tweenJoint(S.Grip, nil, S.CFANG(S.RAD(-10), S.RAD(20), S.RAD(10)), S.Sine, 0.2 * animSpeed)
					wait(0.2 * animSpeed)
				end
			end;

			function()
				if (not S.isNewMag()) then
					S.tweenJoint(S.Grip, nil, S.CFANG(S.RAD(-10), S.RAD(20), S.RAD(10)), S.Sine, 0.15 * animSpeed)
					S.tweenJoint(S.LWeld, nil, S.CF(1, 0.9, -1.2) * S.CFANG(S.RAD(-20), S.RAD(0), S.RAD(-90)), S.Sine, 0.15 * animSpeed)--0.25
					S.tweenJoint(S.RWeld, nil, S.CF(.6, 0.8, -0.75) * S.CFANG(S.RAD(-20), S.RAD(30), S.RAD(0)), S.Sine, 0.2 * animSpeed)
					script.Parent.Handle.MagIn:Play()
					wait(0.2 * animSpeed)
				end
			end;

			function()
				if (not S.isNewMag()) then
					local Mag1, _ = S.getMag("Mag1")
					local Mag2, _ = S.getMag("Mag2")
					S.makeMagVisible()
					S.setNewMag()
					if Mag1 then Mag1:Destroy() end
					Mag2:Destroy()
				end
			end;

			function()
				if S.isMagEmpty() then
					if S.isNewMag() then
						S.tweenJoint(S.Grip, nil, S.CFANG(S.RAD(-10), S.RAD(20), S.RAD(10)), S.Sine, 0.15 * animSpeed)
						S.tweenJoint(S.LWeld, nil, S.CF(0.58, 1.63, -1.4) * S.CFANG(S.RAD(-22), S.RAD(20), S.RAD(-60)), S.Sine, 0.15 * animSpeed)--0.25
						S.tweenJoint(S.RWeld, nil, S.CF(0.6, 0.2, -0.61) * S.CFANG(S.RAD(-15), S.RAD(20), S.RAD(25)), S.Sine, 0.2 * animSpeed)
					end
					S.tweenJoint(S.LWeld, nil, S.CF(0, 1.3, -0.55) * S.CFANG(S.RAD(-26), 0, 0), S.Sine, 0.2 * animSpeed)

					wait(0.2 * animSpeed)
				end
			end;

			function()
				if S.isMagEmpty() then
					S.tweenJoint(S.LWeld, nil, S.CF(0.4, 1.6, -0.55) * S.CFANG(S.RAD(-23), 0, S.RAD(-60)), S.Sine, 0.1 * animSpeed)

					wait(0.05 * animSpeed)
				end
			end;

			function()
				if S.isMagEmpty() then
					S.tweenJoint(S.RWeld, nil, S.CF(0.6, 0.2, -0.61) * S.CFANG(S.RAD(-15), S.RAD(20), S.RAD(20)), S.Sine, 0.05 * animSpeed)

					wait(0.15 * animSpeed)
				end
			end;
		}
	end;

	Cocking = function(S)

	end;

	Crawling = function(X, moveDirection, moveSpeed)
		return {
			leftArm = CFrame.Angles(
				0,
				math.rad(90),
				math.rad(-10)
			) * CFrame.new(
				math.sin(moveDirection) * (math.sin(X * 6) / 4) - 0.2,
				math.cos(moveDirection) * (math.sin(X * 6) / 2) - 0.1,
				math.max(math.cos(X * 6) / 4, 0) - 0.1
			) * CFrame.Angles(
				-math.max(math.cos(X * 6) / 4, 0),
				0,
				0
			);
			leftLeg = CFrame.new(
				math.sin(moveDirection) * (-math.sin(X * 6) / 4) - 0.2,
				math.cos(moveDirection) * (math.sin(X * 6) / 2) + 0.3,
				math.max(math.cos(X * 6) / 4, 0) - 0.1
			):inverse() * CFrame.Angles(
				0,
				0,
				-math.rad(15) - math.cos(moveDirection) * (math.rad(15) * math.sin(X * 6))
			);
			rightArm = CFrame.Angles(
				0,
				math.rad(-5),
				math.rad(10)
			) * CFrame.new(
				math.sin(moveDirection) * (-math.sin(X * 6) / 4) + 0.2,
				math.cos(moveDirection) * (-math.sin(X * 6) / 5) - 0.2,
				math.max(math.cos((X + math.rad(30)) * 6) / 10, 0) - 0.1
			) * CFrame.Angles(
				-math.max(math.cos((X + math.rad(30)) * 6) / 10, 0),
				0,
				0
			);
			rightLeg = CFrame.new(
				math.sin(moveDirection) * (math.sin(X * 6) / 4) + 0.2,
				math.cos(moveDirection) * (-math.sin(X * 6) / 2) + 0.3,
				math.max(math.cos((X + math.rad(30)) * 6) / 4, 0) - 0.1
			):inverse() * CFrame.Angles(
				0,
				0,
				math.rad(15) - math.cos(moveDirection) * (math.rad(15) * math.sin(X * 6))
			);
			Grip = CFrame.Angles(
				math.max(math.cos((X + math.rad(30)) * 6) / 7, 0),
				math.rad(5),
				0
			);
			Camera = 1.5 * math.rad(math.cos((X + math.rad(30)) * 6)) + math.rad(0.5); --This is what the roll of the camera will be when you're crawling
		}
	end;

	Idling = {

		unAimed = function(X)
			return {
				Pos = Vector3.new(
					math.sin(X / 2) / 70,
					math.sin(X * 5 / 4) / 70,
					math.sin(X * 3 / 4) / 70
				);
				Rot = Vector3.new(
					0,
					0,
					0
				);
			}
		end;

		Aimed = function(X)
			return {
				Pos = Vector3.new(
					math.sin(X * 3 / 8) / 140,
					math.sin(X * 15 / 16) / 140,
					0
				);
				Rot = Vector3.new(
					0,
					0,
					0
				);
			}
		end;

	};

	Walking = {

		unAimed = function(X)
			return {
				Pos = Vector3.new(
					4 * math.sin(X * 4.5) / 50,
					1.5 * math.sin(X * 9) / 50,
					0
				);
				Rot = Vector3.new(
					0,
					0,
					math.rad(math.sin(X * 4.5)) * 2
				);
			}
		end;

		Aimed = function(X)
			return {
				Pos = Vector3.new(
					2 * math.sin(X * 3) / 150,
					0.75 * math.sin(X * 6) / 150,
					0
				);
				Rot = Vector3.new(
					0,
					0,
					math.rad(math.sin(X * 3)) / 3
				);
			}
		end;

	};

	Running = function(X)
		return {
			Pos = Vector3.new(
				4 * math.sin(X * 4.5 * 1.5) / 30,
				1.5 * math.sin(X * 9 * 1.5) / 40 + 0.2,
				0
			);
			Rot = Vector3.new(
				0,
				-math.rad(math.sin(X * 4.5 * 1.5)) * 5 + math.rad(3),
				math.rad(math.sin(X * 4.5 * 1.5)) * 5
			);
		}
	end;

}
local Plugins = {

	KeyDown = {
		{ --This is a plugin for a toggleable laser
			Key = "v"; --This is the key you press to activate the plugin
			Description = "Toggle Laser"; --This is what the description of the key will be in the controls
			Plugin = function() --This is the actual plugin function
				local Laser = Gun:WaitForChild("Laser") --These few lines wait for the necessary bricks/models
				local Handle = Gun:WaitForChild("Handle")
				local ignoreCode = Gun.clientMain:WaitForChild("ignoreCode")
				local ignoreModel = game.Workspace:WaitForChild("ignoreModel_"..ignoreCode.Value)

				local PlyrName = game.Players:GetPlayerFromCharacter(Gun.Parent).Name
				local playerFolder = ignoreModel:WaitForChild("gunIgnore_"..PlyrName)

				local RS = game:GetService("RunService")

				local function createLaserDot() --This function creates the red laser dot
					local laserDot = Instance.new("Part")
					laserDot.Transparency = 1
					laserDot.Name = "laserDot"
					laserDot.Anchored = true
					laserDot.CanCollide = false
					laserDot.FormFactor = Enum.FormFactor.Custom
					laserDot.Size = Vector3.new(0.25, 0.25, 1)

					local laserGui = Instance.new("SurfaceGui")
					laserGui.CanvasSize = Vector2.new(100, 100)
					laserGui.Parent = laserDot

					local laserImage = Instance.new("ImageLabel")
					laserImage.BackgroundTransparency = 1
					laserImage.Size = UDim2.new(1, 0, 1, 0)
					laserImage.Image = "http://www.roblox.com/asset/?id=131394739"
					laserImage.Parent = laserGui

					--[[local laserLight = Instance.new("SurfaceLight")
					laserLight.Angle = 180
					laserLight.Brightness = math.huge
					laserLight.Color = Color3.new(1, 0, 0)
					laserLight.Face = Enum.NormalId.Back
					laserLight.Range = 5
					laserLight.Shadows = true
					laserLight.Parent = laserDot]]

					return laserDot
				end

				local function getHitSurfaceCFrame(Pos, Obj) --This function returns the proper cframe based on the face that the position is on
					local surfaceCF = {
						{"Back", Obj.CFrame * CFrame.new(0, 0, Obj.Size.z)};
						{"Bottom", Obj.CFrame * CFrame.new(0, -Obj.Size.y, 0)};
						{"Front", Obj.CFrame * CFrame.new(0, 0, -Obj.Size.z)};
						{"Left", Obj.CFrame * CFrame.new(-Obj.Size.x, 0, 0)};
						{"Right", Obj.CFrame * CFrame.new(Obj.Size.x, 0, 0)};
						{"Top", Obj.CFrame * CFrame.new(0, Obj.Size.y, 0)}
					}
					local closestDist = math.huge
					local closestSurface = nil
					for _,v in pairs(surfaceCF) do
						local surfaceDist = (Pos - v[2].p).magnitude
						if surfaceDist < closestDist then
							closestDist = surfaceDist
							closestSurface = v
						end
					end

					local surfaceDir = CFrame.new(Obj.CFrame.p, closestSurface[2].p)
					local surfaceDist = surfaceDir.lookVector * ((Obj.CFrame.p - closestSurface[2].p).magnitude / 2 - 0.25)
					local surfaceOffset = Pos - closestSurface[2].p + surfaceDist
					local surfaceCFrame = surfaceDir + surfaceDist + surfaceOffset

					return surfaceCFrame
				end

				local laserDot = createLaserDot() --The code is cleaner when the laser creating code is in a function

				Laser.Transparency = (Laser.Transparency == 1 and 0 or 1) --Toggles the laser on or off

				while math.floor(Laser.Transparency) == 0 do --This loop will keep running as long as the laser is visible
					if (not game.Players:GetPlayerFromCharacter(Gun.Parent)) then break end --This checks if the gun is a child of the character

					local newRay = Ray.new(Laser.Position, Handle.CFrame.lookVector * 999)
					local H, P = game.Workspace:FindPartOnRay(newRay, ignoreModel)

					local Distance = (P - Laser.Position).magnitude
					Laser.Mesh.Offset = Vector3.new(0, Distance / 2, 0)
					Laser.Mesh.Scale = Vector3.new(0.075, Distance / 0.2, 0.075)

					if H then
						laserDot.CFrame = getHitSurfaceCFrame(P, H) --If the laser hits a part then position the dot on the part
						laserDot.Parent = playerFolder
					else
						laserDot.Parent = nil --If the laser doesn't hit a part then temporarily remove the laser dor
					end

					RS.RenderStepped:wait()
				end

				laserDot:Destroy() --These lines reset the laser if the laser is transparent or the gun was deselected
				Laser.Transparency = 1
				Laser.Mesh.Offset = Vector3.new()
				Laser.Mesh.Scale = Vector3.new(0.075, 0, 0.075)
			end;
		};

		{ --This is a plugin for a toggleable flashlight
			Key = "z";
			Description = "Toggle Flashlight";
			Plugin = function()
				local Flashlight = Gun:WaitForChild("Flashlight")
				if Flashlight then
					for _, Light in pairs(Flashlight:GetChildren()) do
						if Light.Name == "Light" then
							Light.Enabled = (not Light.Enabled)
						end
					end
				end
			end
		};
	};

	KeyUp = {

	};

	Firing = {
		Plugin = function()
			--Put code here
		end;
	};

	Aimed = {
		Plugin = function()
			--Put code here
		end;
	};

	UnAimed = {
		Plugin = function()
			--Put code here
		end;
	};

	OnEquipped = {
		Plugin = function()
			--Put code here
		end
	};

	OnUnEquipped = {
		Plugin = function()
			--Put code here
		end
	};

}
local S = {


	gunType = {
		Semi = false;
		Auto = true;
		Burst = false;
		Shot = false;
		Explosive = false;
	};

	selectFire = true;
	selectFireSettings = {
		Animation = true;
		GUI = false;
		Modes = {
			Safety = true;
			Semi = true;
			Burst = true;
			Auto = true;
		};
		animSpeed = 99999999;
	};


	burstSettings = {
		fireRateBurst = true;
		Amount = 3;
		Time = 0.2;
		Wait = 0.1;
	};


	shotAmount = 5;


	explosionSettings = {
		Radius = 20;
		Pressure = 5e5;
		Type = Enum.ExplosionType.NoCraters;

		soundId = "rbxassetid://138499093";
		soundPitch = 1;
		soundVolume = 1;
		rayCastExplosions = false;
		rangeBasedDamage = true;
	};


	playerArms = true;
	fakeArmSettings = {
		Transparency = 0;
		armSize = Vector3.new(0.6, 2, 0.6);
		characterMeshes = false;
		realBodyColor = true;
		Color = BrickColor.new("Pastel brown");
	};


	unAimedC1 = {
		leftArm = CFrame.new(-0.7, 2, -.6) * CFrame.Angles(math.rad(-10), 0, math.rad(-30));
		rightArm = CFrame.new(0.4, 0.25, -0.3) * CFrame.Angles(0, 0, math.rad(25));
		Grip = CFrame.Angles(0, math.rad(25), 0);
	};
	aimedC1 = {
		leftArm = CFrame.new(-0.1, 1, -0.3) * CFrame.Angles(math.rad(-10), 0, 0) * CFrame.Angles(0, 0, math.rad(-40));
		rightArm = CFrame.new(0.5, 0.3, 0.1) * CFrame.Angles(0, 0, math.rad(45));
	};
	runningC1 = {
		leftArm = CFrame.new(-0.65, 0.85, -.8) * CFrame.Angles(math.rad(1), math.rad(-8.5), math.rad(16));
		rightArm = CFrame.new(0.16, 1, -0.14) * CFrame.Angles(math.rad(15), math.rad(2), math.rad(50));
		Grip = CFrame.Angles(0, math.rad(-5), 0);
	};


	equipAnimation = true;
	equipSettings = {
		Time = 0.25;
		leftArmC1 = CFrame.new(0.2, 1.2, 0) * CFrame.Angles(math.rad(105), math.rad(-30), math.rad(90));
		rightArmC1 = CFrame.new(-0.5, 0.75, 0) * CFrame.Angles(math.rad(45), 0, math.rad(75));
		GripC1 = CFrame.new();
	};


	stopAnimsOnFall = true;
	fallAnimation = true;
	fallSettings = {
		maxDist = 35;
		landMultiplier = 1;
		fallMultiplier = 1;
		aimEffect = 0.25;
	};


	gunMomentum = true;
	momentumSettings = {
		maxInput = 18;
		Speed = 20;
		Damper = 0.5;
		Amplitude = {
			unAimed = 5;
			Aimed = 1;
		}
	};


	cockingAnim = false;
	movementAnims = true;


	canADS = false;
	aimSettings = {
		Anim = true;
		Speed = 0.3;
		FOV = 37;
		holdToADS = true;
		headTilt = math.rad(25);
	};


	sensitivitySettings = {
		Default = 1;
		Aim = 0.3;

		scrollToChange = true;
		Min = 0.05;
		Max = 1;
		Increment = 0.05;
	};


	guiScope = false;
	scopeSettings = {
		Frequency = {
			Idling = 0.7;
			Walking = 2;
		};
		Amplitude = {
			Idling = 0.75;
			Walking = 0.75;
		};
		steadyTime = 8;
		breathTime = 5;
		camSwayOnBreath = 2.5;
		unSteadyOnFire = true;
	};


	roundsPerMin = 800;


	bulletSettings = {
		instantHit = true;
		Range = 2000;
		Velocity = 540;
		Acceleration = 196.2;
		Color = BrickColor.new("Bright red");
		Transparency = 0;
		Size = Vector3.new(0.1, 0.1, 5);
	};


	damageSettings = {
		Start = {
			Damage = 24;
			Dist = 0.08;
		};
		End = {
			Damage = 30;
			Dist = 0.5;
		};
		Multipliers = {
			Chest = 1;
			Head = 1000000000000000000000000000000000000000000000.5;
			Limbs = 1;
		};
	};


	AllowFriendlyFire = false;
	CanDamageNPCs = true;

	bulletTrail = false;
	trailSettings = {
		Color = BrickColor.new("White");
		Transparency = 0;
		Thickness = 0;
		visibleTime = 0;
		disappearTime = 0;
	};


	bulletHoles = true;
	holeSettings = {
		Texture = "http://www.roblox.com/asset/?id=64291961";
		Size = 0.5;
		visibleTime = 3;
		disappearTime = 1;
	};


	bulletSparks = true;
	customSparks = false;
	sparkSettings = {
		Color = {
			Start = Color3.new(1, 158 / 255, 24 / 255);
			End = Color3.new(212 / 255, 242 / 255, 8 / 255);
		};
		Size = 0.25;
		Texture = "http://www.roblox.com/asset/?id=311395391";
		Lifetime = 0.2;
		Rate = 75;
		Speed = 25;
		Spread = 45;
		Materials = {
			Enum.Material.Plastic;
			Enum.Material.Slate;
			Enum.Material.Concrete;
			Enum.Material.CorrodedMetal;
			Enum.Material.DiamondPlate;
			Enum.Material.Foil;
			Enum.Material.Marble;
			Enum.Material.Granite;
			Enum.Material.Brick;
			Enum.Material.Pebble;
			Enum.Material.SmoothPlastic;
			Enum.Material.Metal;
			Enum.Material.Cobblestone;
		};
	};


	bulletSmoke = false;
	smokeSettings = {
		objColor = false;
		Color = Color3.new(0.5, 0.5, 0.5);
		Size = {
			Start = 0.25;
			End = 0.5;
		};
		Texture = "http://www.roblox.com/asset/?id=244514423";
		startTransparency = 0;
		Lifetime = 0.2;
		Rate = 100;
		Speed = 35;
		Spread = 15;
	};


	bloodEffect = true;
	bloodSettings = {
		Color = Color3.new(1, 0, 0);
		Size = 0.1;
		Texture = "http://www.roblox.com/asset/?id=3419963";
		startTransparency = 0.125;
		Lifetime = 0.1;
		Rate = 200;
		Speed = 50;
		Spread = 15;
	};


	bulletShockwave = false;
	shockwaveSettings = {
		Radius = 0.3;
		Color = BrickColor.new("Light stone grey");
		Duration = 0.2;
	};


	penetrationSettings = {
		Dist = 0;
		transparencyThreshold = 1;
		ignoreNonCanCollide = true;
		ignoreCustom = {};
	};


	recoilSettings = {
		firstShotMultiplier = 2.4;
		aimedMultiplier = 0.5;
		camMultiplier = 2;
		springSpeed = 15;
		springDamper = 0.5;
		Recoil = {
			Side = {
				Left = -0.17;
				Right = 0.28;
			};
			Up = {
				Min = 0.26;
				Max = 0.28;
			};
			Back = {
				Min = 0.3;
				Max = 0.35;
			};
			Tilt = {
				Left = -0.5;
				Right = 0.5;
			};
		}
	};


	spreadSettings = {
		Increase = 0.1;
		Decrease = 15;

		Aimed = {
			Stand = {
				Idling = 0.2;
				Moving = 0.4;
			};
			Crouch = {
				Idling = 0.15;
				Moving = 0.3;
			};
			Prone = {
				Idling = 0.1;
				Moving = 0.3;
			};
		};
		unAimed = {
			Stand = {
				Idling = 2;
				Moving = 2.5;
			};
			Crouch = {
				Idling = 1.5;
				Moving = 2;
			};
			Prone = {
				Idling = 1;
				Moving = 2;
			};
		};
	};


	reloadSettings = {
		Anim = true;
		Times = {
			Loaded = 1.85;
			Empty = 2.4;
		};
		autoReload = true;
		magIsBullet = false;
		reloadWhileRunning = true;
	};


	sprintTime = 15;
	staminaCoolTime = 4;
	canFireWhileRunning = false;


	dolphinDive = true;
	diveSettings = {
		rechargeTime = 1;
		Force = 350;
		Angle = math.rad(30);
	};


	canChangeStance = true;
	stanceSettings = {
		Anim = true;
		Speed = 0.3;
		Stances = {
			Crouch = true;
			Prone = true;
		};
		standOnDeselect = true;
		crawlAnimation = true;
	};


	walkSpeeds = {
		Base = 16;
		Sprinting = 25;
		Aimed = 10;
		Crouched = 7;
		Prone = 4;
	};


	--NOTE: For extra keys, go here: http://wiki.roblox.com/index.php?title=Taking_keyboard_input
	Keys = {
		lowerStance = "c";
		raiseStance = "x";
		selectFire = "f";
		Reload = "r";
		Sprint = string.char(48);
		ADS = "q";
		scopeSteady = string.char(48);
	};


}

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("Fire")
	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
		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
		local shell = Instance.new("Part")
	shell.CFrame = Gun.Chamber.CFrame * CFrame.fromEulerAnglesXYZ(-2.5,1,1)
	shell.Size = Vector3.new(0.2,0.5,0.2)
	shell.CanCollide = false
	shell.Name = "Shell"
	shell.Velocity = Gun.Chamber.CFrame.lookVector * 10 + Vector3.new(math.random(-10,10),20,math.random(-10,10))
	shell.RotVelocity = Vector3.new(0,200,0)
	shell.Parent = game.Workspace
	game:GetService("Debris"):addItem(shell,2)
	local shellmesh = Instance.new("SpecialMesh")
	shellmesh.Scale = Vector3.new(2,2,2)
	shellmesh.MeshId = "http://www.roblox.com/asset/?id=94295100"
	shellmesh.TextureId = "http://www.roblox.com/asset/?id=94287792"
	shellmesh.MeshType = "FileMesh"
	shellmesh.Parent = shell
	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
					Ammo.Value = ClipSize.Value
				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 = true
		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 = true
		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))
IntValue35.Name = "ignoreCode"
IntValue35.Parent = LocalScript34
Folder36.Name = "Server_Scripts"
Folder36.Parent = LocalScript34
ScreenGui37.Name = "mainGUI"
ScreenGui37.Parent = LocalScript34
Frame38.Name = "HUD"
Frame38.Parent = ScreenGui37
Frame38.Transparency = 1
Frame38.Size = UDim2.new(0, 160, 0, 160)
Frame38.Position = UDim2.new(1, -160, 1, -140)
Frame38.Visible = false
Frame38.BackgroundColor3 = Color3.new(1, 1, 1)
Frame38.BackgroundTransparency = 1
Frame39.Name = "Ammo"
Frame39.Parent = Frame38
Frame39.Transparency = 1
Frame39.Size = UDim2.new(0, 135, 0, 40)
Frame39.Position = UDim2.new(0, 5, 0, 60)
Frame39.BackgroundTransparency = 1
Frame39.ZIndex = 10
TextLabel40.Name = "Slash"
TextLabel40.Parent = Frame39
TextLabel40.Transparency = 1
TextLabel40.Size = UDim2.new(0, 0, 0, 45)
TextLabel40.Text = "/"
TextLabel40.Position = UDim2.new(0, 92, 0, -12)
TextLabel40.Visible = false
TextLabel40.BackgroundTransparency = 1
TextLabel40.ZIndex = 10
TextLabel40.Font = Enum.Font.SciFi
TextLabel40.FontSize = Enum.FontSize.Size24
TextLabel40.TextColor3 = Color3.new(1, 1, 1)
TextLabel41.Name = "Stored"
TextLabel41.Parent = Frame39
TextLabel41.Transparency = 1
TextLabel41.Size = UDim2.new(1, 0, 0, 85)
TextLabel41.Text = "999"
TextLabel41.Position = UDim2.new(0, 100, 0, -35)
TextLabel41.Visible = false
TextLabel41.BackgroundTransparency = 1
TextLabel41.ZIndex = 10
TextLabel41.Font = Enum.Font.Code
TextLabel41.FontSize = Enum.FontSize.Size28
TextLabel41.TextColor3 = Color3.new(1, 1, 1)
TextLabel41.TextXAlignment = Enum.TextXAlignment.Left
TextLabel42.Name = "Clip"
TextLabel42.Parent = Frame39
TextLabel42.Transparency = 1
TextLabel42.Size = UDim2.new(0, 85, 1, 0)
TextLabel42.Text = "999"
TextLabel42.Position = UDim2.new(0, 32, 0, -5)
TextLabel42.BackgroundTransparency = 1
TextLabel42.ZIndex = 10
TextLabel42.Font = Enum.Font.Code
TextLabel42.FontSize = Enum.FontSize.Size48
TextLabel42.TextColor3 = Color3.new(1, 1, 1)
TextLabel42.TextWrapped = true
Frame43.Name = "Controls"
Frame43.Parent = Frame38
Frame43.Transparency = 0.30000001192093
Frame43.Size = UDim2.new(1, 0, 0, 120)
Frame43.Position = UDim2.new(0, 0, 0, -200)
Frame43.Visible = false
Frame43.BackgroundColor3 = Color3.new(0.156863, 0.156863, 0.156863)
Frame43.BackgroundTransparency = 0.30000001192093
Frame43.BorderColor3 = Color3.new(0.156863, 0.156863, 0.156863)
Frame43.BorderSizePixel = 5
Frame43.ZIndex = 10
TextLabel44.Name = "Title"
TextLabel44.Parent = Frame43
TextLabel44.Transparency = 1
TextLabel44.Size = UDim2.new(1, 0, 0, 15)
TextLabel44.Text = "CONTROLS"
TextLabel44.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel44.BackgroundTransparency = 1
TextLabel44.ZIndex = 10
TextLabel44.Font = Enum.Font.SourceSansBold
TextLabel44.FontSize = Enum.FontSize.Size14
TextLabel44.TextColor3 = Color3.new(1, 1, 1)
TextLabel45.Name = "Line"
TextLabel45.Parent = TextLabel44
TextLabel45.Size = UDim2.new(1, 0, 0, 2)
TextLabel45.Text = ""
TextLabel45.Position = UDim2.new(0, 0, 1, 1)
TextLabel45.BackgroundColor3 = Color3.new(1, 1, 0)
TextLabel45.BorderSizePixel = 0
TextLabel45.ZIndex = 10
TextLabel45.Font = Enum.Font.SourceSans
TextLabel45.FontSize = Enum.FontSize.Size14
Frame46.Name = "Grenades"
Frame46.Parent = Frame38
Frame46.Transparency = 1
Frame46.Size = UDim2.new(0, 175, 0, 25)
Frame46.Position = UDim2.new(0, 0, 0, 90)
Frame46.Visible = false
Frame46.BackgroundTransparency = 1
Frame46.ZIndex = 10
Frame47.Name = "Lethals"
Frame47.Parent = Frame46
Frame47.Size = UDim2.new(0.5, -2, 1, 0)
Frame47.BackgroundColor3 = Color3.new(1, 1, 1)
Frame47.BorderSizePixel = 0
Frame47.ZIndex = 10
ImageLabel48.Name = "Icon"
ImageLabel48.Parent = Frame47
ImageLabel48.Transparency = 1
ImageLabel48.Size = UDim2.new(0, 21, 0, 21)
ImageLabel48.Position = UDim2.new(0, 7, 0, 2)
ImageLabel48.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel48.BackgroundTransparency = 1
ImageLabel48.ZIndex = 10
TextLabel49.Name = "Mult"
TextLabel49.Parent = Frame47
TextLabel49.Transparency = 1
TextLabel49.Size = UDim2.new(0, 20, 1, 0)
TextLabel49.Text = "X"
TextLabel49.Position = UDim2.new(0.5, -10, 0, 0)
TextLabel49.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel49.BackgroundTransparency = 1
TextLabel49.BorderSizePixel = 0
TextLabel49.ZIndex = 10
TextLabel49.Font = Enum.Font.ArialBold
TextLabel49.FontSize = Enum.FontSize.Size18
TextLabel49.TextColor3 = Color3.new(0, 0, 0)
TextLabel50.Name = "Num"
TextLabel50.Parent = Frame47
TextLabel50.Transparency = 1
TextLabel50.Size = UDim2.new(0, 0, 1, 0)
TextLabel50.Text = "0"
TextLabel50.Position = UDim2.new(1, -7, 0, 0)
TextLabel50.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel50.BackgroundTransparency = 1
TextLabel50.ZIndex = 10
TextLabel50.Font = Enum.Font.ArialBold
TextLabel50.FontSize = Enum.FontSize.Size18
TextLabel50.TextColor3 = Color3.new(0, 0, 0)
TextLabel50.TextXAlignment = Enum.TextXAlignment.Right
Frame51.Name = "Tacticals"
Frame51.Parent = Frame46
Frame51.Size = UDim2.new(0.5, -2, 1, 0)
Frame51.Position = UDim2.new(0.5, 2, 0, 0)
Frame51.BackgroundColor3 = Color3.new(1, 1, 1)
Frame51.BorderSizePixel = 0
Frame51.ZIndex = 10
ImageLabel52.Name = "Icon"
ImageLabel52.Parent = Frame51
ImageLabel52.Transparency = 1
ImageLabel52.Size = UDim2.new(0, 21, 0, 21)
ImageLabel52.Position = UDim2.new(0, 7, 0, 2)
ImageLabel52.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel52.BackgroundTransparency = 1
ImageLabel52.ZIndex = 10
TextLabel53.Name = "Num"
TextLabel53.Parent = Frame51
TextLabel53.Transparency = 1
TextLabel53.Size = UDim2.new(0, 0, 1, 0)
TextLabel53.Text = "0"
TextLabel53.Position = UDim2.new(1, -7, 0, 0)
TextLabel53.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel53.BackgroundTransparency = 1
TextLabel53.ZIndex = 10
TextLabel53.Font = Enum.Font.ArialBold
TextLabel53.FontSize = Enum.FontSize.Size18
TextLabel53.TextColor3 = Color3.new(0, 0, 0)
TextLabel53.TextXAlignment = Enum.TextXAlignment.Right
TextLabel54.Name = "Mult"
TextLabel54.Parent = Frame51
TextLabel54.Transparency = 1
TextLabel54.Size = UDim2.new(0, 20, 1, 0)
TextLabel54.Text = "X"
TextLabel54.Position = UDim2.new(0.5, -10, 0, 0)
TextLabel54.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel54.BackgroundTransparency = 1
TextLabel54.BorderSizePixel = 0
TextLabel54.ZIndex = 10
TextLabel54.Font = Enum.Font.ArialBold
TextLabel54.FontSize = Enum.FontSize.Size18
TextLabel54.TextColor3 = Color3.new(0, 0, 0)
Frame55.Name = "Health"
Frame55.Parent = Frame38
Frame55.Transparency = 1
Frame55.Size = UDim2.new(0.400000006, 0, 0, 25)
Frame55.Position = UDim2.new(0, 25, 0, 20)
Frame55.Visible = false
Frame55.BackgroundColor3 = Color3.new(0.247059, 0.247059, 0.247059)
Frame55.BackgroundTransparency = 1
Frame55.BorderColor3 = Color3.new(0.156863, 0.156863, 0.156863)
Frame55.BorderSizePixel = 0
Frame55.ZIndex = 10
Frame55.Draggable = true
TextLabel56.Name = "Num"
TextLabel56.Parent = Frame55
TextLabel56.Transparency = 1
TextLabel56.Size = UDim2.new(0, 50, 1, 0)
TextLabel56.Text = "100%"
TextLabel56.Position = UDim2.new(1, -50, 0, 0)
TextLabel56.BackgroundColor3 = Color3.new(0, 0, 0)
TextLabel56.BackgroundTransparency = 1
TextLabel56.BorderColor3 = Color3.new(0, 0, 0)
TextLabel56.BorderSizePixel = 0
TextLabel56.ZIndex = 10
TextLabel56.Font = Enum.Font.SourceSansBold
TextLabel56.FontSize = Enum.FontSize.Size24
TextLabel56.TextColor3 = Color3.new(1, 1, 1)
TextLabel56.TextStrokeColor3 = Color3.new(0.745098, 0.745098, 0.745098)
TextLabel56.TextXAlignment = Enum.TextXAlignment.Right
Frame57.Name = "Tray"
Frame57.Parent = Frame55
Frame57.Transparency = 1
Frame57.Size = UDim2.new(1, -60, 0, 20)
Frame57.Position = UDim2.new(0, 2, 0.5, -10)
Frame57.Visible = false
Frame57.BackgroundColor3 = Color3.new(0, 0, 0)
Frame57.BackgroundTransparency = 1
Frame57.BorderColor3 = Color3.new(0, 0, 0)
Frame57.BorderSizePixel = 0
Frame57.ZIndex = 10
Frame57.ClipsDescendants = true
Frame58.Name = "Beat"
Frame58.Parent = Frame57
Frame58.Transparency = 1
Frame58.Size = UDim2.new(0, 21, 1, 0)
Frame58.Position = UDim2.new(1, 0, 0, 0)
Frame58.BackgroundColor3 = Color3.new(0, 0, 0)
Frame58.BackgroundTransparency = 1
Frame58.BorderColor3 = Color3.new(0, 0, 0)
Frame58.BorderSizePixel = 0
Frame58.ZIndex = 10
Frame59.Name = "00"
Frame59.Parent = Frame58
Frame59.Size = UDim2.new(0.0476190485, 0, 0, 3)
Frame59.Position = UDim2.new(0, 0, 0.5, -2)
Frame59.BackgroundColor3 = Color3.new(1, 1, 1)
Frame59.BorderColor3 = Color3.new(0, 0, 0)
Frame59.BorderSizePixel = 0
Frame59.ZIndex = 10
Frame60.Name = "01"
Frame60.Parent = Frame58
Frame60.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame60.Position = UDim2.new(0.0476190485, 0, 0.423076928, -2)
Frame60.BackgroundColor3 = Color3.new(1, 1, 1)
Frame60.BorderColor3 = Color3.new(0, 0, 0)
Frame60.BorderSizePixel = 0
Frame60.ZIndex = 10
Frame61.Name = "02"
Frame61.Parent = Frame58
Frame61.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame61.Position = UDim2.new(0.095238097, 0, 0.346153855, -2)
Frame61.BackgroundColor3 = Color3.new(1, 1, 1)
Frame61.BorderColor3 = Color3.new(0, 0, 0)
Frame61.BorderSizePixel = 0
Frame61.ZIndex = 10
Frame62.Name = "03"
Frame62.Parent = Frame58
Frame62.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame62.Position = UDim2.new(0.142857149, 0, 0.269230783, -2)
Frame62.BackgroundColor3 = Color3.new(1, 1, 1)
Frame62.BorderColor3 = Color3.new(0, 0, 0)
Frame62.BorderSizePixel = 0
Frame62.ZIndex = 10
Frame63.Name = "04"
Frame63.Parent = Frame58
Frame63.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame63.Position = UDim2.new(0.190476194, 0, 0.192307696, -2)
Frame63.BackgroundColor3 = Color3.new(1, 1, 1)
Frame63.BorderColor3 = Color3.new(0, 0, 0)
Frame63.BorderSizePixel = 0
Frame63.ZIndex = 10
Frame64.Name = "05"
Frame64.Parent = Frame58
Frame64.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame64.Position = UDim2.new(0.238095239, 0, 0.115384616, -2)
Frame64.BackgroundColor3 = Color3.new(1, 1, 1)
Frame64.BorderColor3 = Color3.new(0, 0, 0)
Frame64.BorderSizePixel = 0
Frame64.ZIndex = 10
Frame65.Name = "06"
Frame65.Parent = Frame58
Frame65.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame65.Position = UDim2.new(0.285714298, 0, 0.0384615399, -2)
Frame65.BackgroundColor3 = Color3.new(1, 1, 1)
Frame65.BorderColor3 = Color3.new(0, 0, 0)
Frame65.BorderSizePixel = 0
Frame65.ZIndex = 10
Frame66.Name = "07"
Frame66.Parent = Frame58
Frame66.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame66.Position = UDim2.new(0.333333343, 0, 0, -2)
Frame66.BackgroundColor3 = Color3.new(1, 1, 1)
Frame66.BorderColor3 = Color3.new(0, 0, 0)
Frame66.BorderSizePixel = 0
Frame66.ZIndex = 10
Frame67.Name = "08"
Frame67.Parent = Frame58
Frame67.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame67.Position = UDim2.new(0.380952388, 0, 0.142857149, -2)
Frame67.BackgroundColor3 = Color3.new(1, 1, 1)
Frame67.BorderColor3 = Color3.new(0, 0, 0)
Frame67.BorderSizePixel = 0
Frame67.ZIndex = 10
Frame68.Name = "09"
Frame68.Parent = Frame58
Frame68.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame68.Position = UDim2.new(0.428571433, 0, 0.285714298, -2)
Frame68.BackgroundColor3 = Color3.new(1, 1, 1)
Frame68.BorderColor3 = Color3.new(0, 0, 0)
Frame68.BorderSizePixel = 0
Frame68.ZIndex = 10
Frame69.Name = "10"
Frame69.Parent = Frame58
Frame69.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame69.Position = UDim2.new(0.476190478, 0, 0.428571433, -2)
Frame69.BackgroundColor3 = Color3.new(1, 1, 1)
Frame69.BorderColor3 = Color3.new(0, 0, 0)
Frame69.BorderSizePixel = 0
Frame69.ZIndex = 10
Frame70.Name = "11"
Frame70.Parent = Frame58
Frame70.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame70.Position = UDim2.new(0.523809552, 0, 0.571428597, -2)
Frame70.BackgroundColor3 = Color3.new(1, 1, 1)
Frame70.BorderColor3 = Color3.new(0, 0, 0)
Frame70.BorderSizePixel = 0
Frame70.ZIndex = 10
Frame71.Name = "12"
Frame71.Parent = Frame58
Frame71.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame71.Position = UDim2.new(0.571428597, 0, 0.714285731, -2)
Frame71.BackgroundColor3 = Color3.new(1, 1, 1)
Frame71.BorderColor3 = Color3.new(0, 0, 0)
Frame71.BorderSizePixel = 0
Frame71.ZIndex = 10
Frame72.Name = "13"
Frame72.Parent = Frame58
Frame72.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame72.Position = UDim2.new(0.619047642, 0, 0.857142866, -2)
Frame72.BackgroundColor3 = Color3.new(1, 1, 1)
Frame72.BorderColor3 = Color3.new(0, 0, 0)
Frame72.BorderSizePixel = 0
Frame72.ZIndex = 10
Frame73.Name = "14"
Frame73.Parent = Frame58
Frame73.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame73.Position = UDim2.new(0.666666687, 0, 0.916666687, -2)
Frame73.BackgroundColor3 = Color3.new(1, 1, 1)
Frame73.BorderColor3 = Color3.new(0, 0, 0)
Frame73.BorderSizePixel = 0
Frame73.ZIndex = 10
Frame74.Name = "15"
Frame74.Parent = Frame58
Frame74.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame74.Position = UDim2.new(0.714285731, 0, 0.833333313, -2)
Frame74.BackgroundColor3 = Color3.new(1, 1, 1)
Frame74.BorderColor3 = Color3.new(0, 0, 0)
Frame74.BorderSizePixel = 0
Frame74.ZIndex = 10
Frame75.Name = "16"
Frame75.Parent = Frame58
Frame75.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame75.Position = UDim2.new(0.761904776, 0, 0.75, -2)
Frame75.BackgroundColor3 = Color3.new(1, 1, 1)
Frame75.BorderColor3 = Color3.new(0, 0, 0)
Frame75.BorderSizePixel = 0
Frame75.ZIndex = 10
Frame76.Name = "17"
Frame76.Parent = Frame58
Frame76.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame76.Position = UDim2.new(0.809523821, 0, 0.666666687, -2)
Frame76.BackgroundColor3 = Color3.new(1, 1, 1)
Frame76.BorderColor3 = Color3.new(0, 0, 0)
Frame76.BorderSizePixel = 0
Frame76.ZIndex = 10
Frame77.Name = "18"
Frame77.Parent = Frame58
Frame77.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame77.Position = UDim2.new(0.857142866, 0, 0.583333313, -2)
Frame77.BackgroundColor3 = Color3.new(1, 1, 1)
Frame77.BorderColor3 = Color3.new(0, 0, 0)
Frame77.BorderSizePixel = 0
Frame77.ZIndex = 10
Frame78.Name = "19"
Frame78.Parent = Frame58
Frame78.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame78.Position = UDim2.new(0.90476191, 0, 0.5, -2)
Frame78.BackgroundColor3 = Color3.new(1, 1, 1)
Frame78.BorderColor3 = Color3.new(0, 0, 0)
Frame78.BorderSizePixel = 0
Frame78.ZIndex = 10
Frame79.Name = "20"
Frame79.Parent = Frame58
Frame79.Size = UDim2.new(0.0476190485, 0, 0, 4)
Frame79.Position = UDim2.new(0.952000022, 0, 0.49000001, -2)
Frame79.BackgroundColor3 = Color3.new(1, 1, 1)
Frame79.BorderColor3 = Color3.new(0, 0, 0)
Frame79.BorderSizePixel = 0
Frame79.ZIndex = 10
Frame80.Name = "Line"
Frame80.Parent = Frame58
Frame80.Size = UDim2.new(0, 200, 0, 3)
Frame80.Position = UDim2.new(1, 0, 0.5, -2)
Frame80.BackgroundColor3 = Color3.new(1, 1, 1)
Frame80.BorderColor3 = Color3.new(0, 0, 0)
Frame80.BorderSizePixel = 0
Frame80.ZIndex = 10
Frame81.Name = "Line"
Frame81.Parent = Frame58
Frame81.Size = UDim2.new(0, 200, 0, 3)
Frame81.Position = UDim2.new(0, -200, 0.5, -2)
Frame81.BackgroundColor3 = Color3.new(1, 1, 1)
Frame81.BorderColor3 = Color3.new(0, 0, 0)
Frame81.BorderSizePixel = 0
Frame81.ZIndex = 10
Frame82.Name = "Mode"
Frame82.Parent = Frame38
Frame82.Transparency = 1
Frame82.Size = UDim2.new(0, 85, 0, 20)
Frame82.Position = UDim2.new(0, 37, 1, -70)
Frame82.BackgroundColor3 = Color3.new(1, 1, 1)
Frame82.BackgroundTransparency = 1
Frame82.ZIndex = 10
TextLabel83.Name = "Bracket"
TextLabel83.Parent = Frame82
TextLabel83.Transparency = 1
TextLabel83.Size = UDim2.new(0, 5, 0, 20)
TextLabel83.Text = "["
TextLabel83.BackgroundTransparency = 1
TextLabel83.ZIndex = 10
TextLabel83.Font = Enum.Font.ArialBold
TextLabel83.FontSize = Enum.FontSize.Size18
TextLabel83.TextColor3 = Color3.new(1, 1, 1)
TextLabel83.TextXAlignment = Enum.TextXAlignment.Left
TextLabel84.Name = "Bracket"
TextLabel84.Parent = Frame82
TextLabel84.Transparency = 1
TextLabel84.Size = UDim2.new(0, 5, 0, 20)
TextLabel84.Text = "]"
TextLabel84.Position = UDim2.new(1, -5, 0, 0)
TextLabel84.BackgroundTransparency = 1
TextLabel84.ZIndex = 10
TextLabel84.Font = Enum.Font.ArialBold
TextLabel84.FontSize = Enum.FontSize.Size18
TextLabel84.TextColor3 = Color3.new(1, 1, 1)
TextLabel84.TextXAlignment = Enum.TextXAlignment.Left
TextLabel85.Name = "Main"
TextLabel85.Parent = Frame82
TextLabel85.Transparency = 1
TextLabel85.Size = UDim2.new(1, 0, 0, 20)
TextLabel85.Text = "Auto"
TextLabel85.BackgroundTransparency = 1
TextLabel85.ZIndex = 10
TextLabel85.Font = Enum.Font.Code
TextLabel85.FontSize = Enum.FontSize.Size18
TextLabel85.TextColor3 = Color3.new(1, 1, 1)
TextLabel85.TextWrapped = true
Frame86.Name = "gunName"
Frame86.Parent = Frame38
Frame86.Transparency = 1
Frame86.Size = UDim2.new(1, 0, 0, 36)
Frame86.BackgroundColor3 = Color3.new(0.352941, 0.352941, 0.352941)
Frame86.BackgroundTransparency = 1
Frame86.ZIndex = 10
TextLabel87.Name = "Title"
TextLabel87.Parent = Frame86
TextLabel87.Transparency = 1
TextLabel87.Size = UDim2.new(1, 0, 1, 0)
TextLabel87.Text = "GUN NAME"
TextLabel87.Position = UDim2.new(0, 0, 0, 23)
TextLabel87.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel87.BackgroundTransparency = 1
TextLabel87.ZIndex = 10
TextLabel87.Font = Enum.Font.Code
TextLabel87.FontSize = Enum.FontSize.Size36
TextLabel87.TextColor3 = Color3.new(1, 1, 1)
TextLabel87.TextScaled = true
TextLabel87.TextStrokeColor3 = Color3.new(0.745098, 0.745098, 0.745098)
TextLabel87.TextWrapped = true
TextLabel88.Name = "Version"
TextLabel88.Parent = Frame38
TextLabel88.Transparency = 1
TextLabel88.Size = UDim2.new(1, 0, 0, 15)
TextLabel88.Text = "V0.4 - REMAKE"
TextLabel88.Position = UDim2.new(1, 10, 1, 0)
TextLabel88.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel88.BackgroundTransparency = 1
TextLabel88.ZIndex = 10
TextLabel88.Font = Enum.Font.ArialBold
TextLabel88.FontSize = Enum.FontSize.Size14
TextLabel88.TextColor3 = Color3.new(1, 1, 1)
TextLabel88.TextStrokeColor3 = Color3.new(0.745098, 0.745098, 0.745098)
TextLabel88.TextStrokeTransparency = 0.60000002384186
TextLabel88.TextTransparency = 0.60000002384186
TextLabel88.TextWrapped = true
TextLabel88.TextXAlignment = Enum.TextXAlignment.Right
ImageLabel89.Name = "hitMarker"
ImageLabel89.Parent = ScreenGui37
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
TextLabel91.Name = "Sens"
TextLabel91.Parent = ScreenGui37
TextLabel91.Transparency = 1
TextLabel91.Size = UDim2.new(0, 100, 0, 20)
TextLabel91.Text = "S: 0.3"
TextLabel91.Position = UDim2.new(1, -131, 1, -25)
TextLabel91.Visible = false
TextLabel91.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel91.BackgroundTransparency = 1
TextLabel91.ZIndex = 10
TextLabel91.Font = Enum.Font.Code
TextLabel91.FontSize = Enum.FontSize.Size28
TextLabel91.TextColor3 = Color3.new(1, 1, 1)
Frame92.Name = "Scope"
Frame92.Parent = ScreenGui37
Frame92.Transparency = 1
Frame92.Size = UDim2.new(1, 0, 1, 36)
Frame92.Position = UDim2.new(0, 0, 0, -36)
Frame92.Visible = false
Frame92.BackgroundColor3 = Color3.new(0, 0, 0)
Frame92.BackgroundTransparency = 1
TextLabel93.Name = "Steady"
TextLabel93.Parent = Frame92
TextLabel93.Transparency = 1
TextLabel93.Size = UDim2.new(0, 120, 0, 20)
TextLabel93.Text = ""
TextLabel93.Position = UDim2.new(0.5, -60, 0.5, 50)
TextLabel93.Visible = false
TextLabel93.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel93.BackgroundTransparency = 1
TextLabel93.ZIndex = 9
TextLabel93.Font = Enum.Font.ArialBold
TextLabel93.FontSize = Enum.FontSize.Size14
TextLabel93.TextColor3 = Color3.new(1, 1, 0)
TextLabel93.TextStrokeTransparency = 0
Frame94.Name = "Main"
Frame94.Parent = Frame92
Frame94.Transparency = 1
Frame94.Size = UDim2.new(1, 0, 1, 0)
Frame94.BackgroundColor3 = Color3.new(1, 1, 1)
Frame94.BackgroundTransparency = 1
ImageLabel95.Name = "ScopeImg2"
ImageLabel95.Parent = Frame94
ImageLabel95.Transparency = 1
ImageLabel95.Size = UDim2.new(0, 20, 0, 20)
ImageLabel95.Position = UDim2.new(0.5, -10, 0, -10)
ImageLabel95.BackgroundColor3 = Color3.new(0, 0, 0)
ImageLabel95.BackgroundTransparency = 1
ImageLabel95.Image = "http://www.roblox.com/asset/?id=184922644"
ImageLabel96.Name = "ScopeImg1"
ImageLabel96.Parent = Frame94
ImageLabel96.Transparency = 1
ImageLabel96.Size = UDim2.new(0, 20, 0, 20)
ImageLabel96.Position = UDim2.new(0.5, -10, 0, -10)
ImageLabel96.BackgroundColor3 = Color3.new(0, 0, 0)
ImageLabel96.BackgroundTransparency = 1
ImageLabel96.Image = "http://www.roblox.com/asset/?id=72002022"
Frame97.Name = "F2"
Frame97.Parent = Frame94
Frame97.Size = UDim2.new(0, 0, 1, 20)
Frame97.Position = UDim2.new(0, -10, 0, -10)
Frame97.BackgroundColor3 = Color3.new(0, 0, 0)
Frame97.BorderColor3 = Color3.new(0, 0, 0)
Frame97.BorderSizePixel = 0
Frame98.Name = "F1"
Frame98.Parent = Frame94
Frame98.Size = UDim2.new(0, 0, 1, 20)
Frame98.Position = UDim2.new(0, -10, 0, -10)
Frame98.BackgroundColor3 = Color3.new(0, 0, 0)
Frame98.BorderColor3 = Color3.new(0, 0, 0)
Frame98.BorderSizePixel = 0
LocalScript99.Name = "Update"
LocalScript99.Parent = Frame94
table.insert(cors,sandbox(LocalScript99,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))
Frame100.Name = "fireSelect"
Frame100.Parent = ScreenGui37
Frame100.Transparency = 1
Frame100.Position = UDim2.new(0.5, 0, 0.5, -18)
Frame100.Visible = false
Frame100.BackgroundColor3 = Color3.new(1, 1, 1)
Frame100.BackgroundTransparency = 1
Frame101.Name = "Modes"
Frame101.Parent = Frame100
Frame101.Transparency = 1
Frame101.BackgroundColor3 = Color3.new(1, 1, 1)
Frame101.BackgroundTransparency = 1
ImageLabel102.Name = "Circle"
ImageLabel102.Parent = Frame100
ImageLabel102.Transparency = 1
ImageLabel102.Size = UDim2.new(0, 120, 0, 120)
ImageLabel102.Position = UDim2.new(0, -60, 0, -60)
ImageLabel102.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel102.BackgroundTransparency = 1
ImageLabel102.Image = "http://www.roblox.com/asset/?id=55754953"
ImageLabel102.ImageTransparency = 0.5
ImageLabel103.Name = "Arrow"
ImageLabel103.Parent = Frame100
ImageLabel103.Transparency = 1
ImageLabel103.Size = UDim2.new(0, 40, 0, 20)
ImageLabel103.Position = UDim2.new(0, -20, 0, -140)
ImageLabel103.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel103.BackgroundTransparency = 1
ImageLabel103.Image = "http://www.roblox.com/asset/?id=126877530"
TextLabel104.Name = "Co"
TextLabel104.Parent = ScreenGui37
TextLabel104.Transparency = 1
TextLabel104.Size = UDim2.new(1, 0, 0, 20)
TextLabel104.Text = "tEhYuM yB ekameR & noisuFobruT yB tiK"
TextLabel104.Visible = false
TextLabel104.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel104.BackgroundTransparency = 1
TextLabel104.ZIndex = 10
TextLabel104.Font = Enum.Font.SourceSansItalic
TextLabel104.FontSize = Enum.FontSize.Size18
TextLabel104.TextColor3 = Color3.new(1, 1, 1)
TextLabel104.TextStrokeColor3 = Color3.new(1, 1, 1)
TextLabel104.TextStrokeTransparency = 0.89999997615814
TextLabel104.TextTransparency = 0.89999997615814
Frame105.Name = "crossHair"
Frame105.Parent = ScreenGui37
Frame105.Position = UDim2.new(0.5, 0, 0.5, -18)
Frame105.Visible = false
Frame105.BackgroundColor3 = Color3.new(1, 1, 1)
Frame105.BorderColor3 = Color3.new(0, 0, 0)
Frame105.BorderSizePixel = 0
ImageLabel106.Parent = Frame105
ImageLabel106.Transparency = 1
ImageLabel106.Size = UDim2.new(0, 300, 0, 300)
ImageLabel106.Position = UDim2.new(0, -150, 0, -150)
ImageLabel106.Visible = false
ImageLabel106.BackgroundColor3 = Color3.new(1, 1, 1)
ImageLabel106.BackgroundTransparency = 1
ImageLabel106.ZIndex = 2
ImageLabel106.Image = "http://www.roblox.com/asset/?id=68308747"
TextLabel107.Name = "Reload"
TextLabel107.Parent = Frame105
TextLabel107.Transparency = 1
TextLabel107.Size = UDim2.new(0, 100, 0, 20)
TextLabel107.Text = "RELOADING..."
TextLabel107.Position = UDim2.new(0, -50, 0, 70)
TextLabel107.Visible = false
TextLabel107.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel107.BackgroundTransparency = 1
TextLabel107.ZIndex = 2
TextLabel107.Font = Enum.Font.SourceSansBold
TextLabel107.FontSize = Enum.FontSize.Size18
TextLabel107.TextColor3 = Color3.new(1, 1, 1)
TextLabel107.TextStrokeTransparency = 0.5
Frame108.Name = "C"
Frame108.Parent = Frame105
Frame108.Transparency = 1
Frame108.Size = UDim2.new(0, 4, 0, 500)
Frame108.Position = UDim2.new(0, -2, 0, 0)
Frame108.BackgroundColor3 = Color3.new(1, 1, 1)
Frame108.BackgroundTransparency = 1
Frame108.ClipsDescendants = true
TextLabel109.Name = "Line"
TextLabel109.Parent = Frame108
TextLabel109.Size = UDim2.new(0, 2, 0, 15)
TextLabel109.Text = ""
TextLabel109.Position = UDim2.new(0.5, -1, 0, 10)
TextLabel109.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel109.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel109.Font = Enum.Font.SourceSans
TextLabel109.FontSize = Enum.FontSize.Size14
Frame110.Name = "A"
Frame110.Parent = Frame105
Frame110.Transparency = 1
Frame110.Size = UDim2.new(0, 4, 0, 500)
Frame110.Position = UDim2.new(0, -2, 0, -500)
Frame110.BackgroundColor3 = Color3.new(1, 1, 1)
Frame110.BackgroundTransparency = 1
Frame110.ClipsDescendants = true
TextLabel111.Name = "Line"
TextLabel111.Parent = Frame110
TextLabel111.Size = UDim2.new(0, 2, 0, 15)
TextLabel111.Text = ""
TextLabel111.Position = UDim2.new(0.5, -1, 1, -25)
TextLabel111.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel111.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel111.Font = Enum.Font.SourceSans
TextLabel111.FontSize = Enum.FontSize.Size14
Frame112.Name = "B"
Frame112.Parent = Frame105
Frame112.Transparency = 1
Frame112.Size = UDim2.new(0, 500, 0, 4)
Frame112.Position = UDim2.new(0, 0, 0, -2)
Frame112.BackgroundColor3 = Color3.new(1, 1, 1)
Frame112.BackgroundTransparency = 1
Frame112.ClipsDescendants = true
TextLabel113.Name = "Line"
TextLabel113.Parent = Frame112
TextLabel113.Size = UDim2.new(0, 15, 0, 2)
TextLabel113.Text = ""
TextLabel113.Position = UDim2.new(0, 10, 0.5, -1)
TextLabel113.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel113.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel113.Font = Enum.Font.SourceSans
TextLabel113.FontSize = Enum.FontSize.Size14
Frame114.Name = "D"
Frame114.Parent = Frame105
Frame114.Transparency = 1
Frame114.Size = UDim2.new(0, 500, 0, 4)
Frame114.Position = UDim2.new(0, -500, 0, -2)
Frame114.BackgroundColor3 = Color3.new(1, 1, 1)
Frame114.BackgroundTransparency = 1
Frame114.ClipsDescendants = true
TextLabel115.Name = "Line"
TextLabel115.Parent = Frame114
TextLabel115.Size = UDim2.new(0, 15, 0, 2)
TextLabel115.Text = ""
TextLabel115.Position = UDim2.new(1, -25, 0.5, -1)
TextLabel115.BackgroundColor3 = Color3.new(1, 1, 1)
TextLabel115.BorderColor3 = Color3.new(0.392157, 0.392157, 0.392157)
TextLabel115.Font = Enum.Font.SourceSans
TextLabel115.FontSize = Enum.FontSize.Size14
Part116.Name = "Bolt"
Part116.Parent = Tool0
Part116.Size = Vector3.new(0.929607987, 0.144963205, 0.374655724)
Part116.CFrame = CFrame.new(5.95300007, 0.94709003, 45.6240997, 1, 0, 0, 0, 1, 0, 0, 0, 1)
Part116.Position = Vector3.new(5.95300007, 0.94709003, 45.6240997)
SpecialMesh117.Name = "ConvertedMesh"
SpecialMesh117.Parent = Part116
SpecialMesh117.MeshId = "rbxassetid://1701671243"
SpecialMesh117.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
SpecialMesh117.TextureId = "rbxassetid://1701541474"
SpecialMesh117.MeshType = Enum.MeshType.FileMesh
SpecialMesh117.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
Part118.Name = "BoltBack"
Part118.Parent = Tool0
Part118.Transparency = 1
Part118.Size = Vector3.new(0.929607987, 0.144963205, 0.374655724)
Part118.CFrame = CFrame.new(6.09300041, 0.94709003, 45.6240005, 1, 0, 0, 0, 1, 0, 0, 0, 1)
Part118.Position = Vector3.new(6.09300041, 0.94709003, 45.6240005)
SpecialMesh119.Name = "ConvertedMesh"
SpecialMesh119.Parent = Part118
SpecialMesh119.MeshId = "rbxassetid://1701671243"
SpecialMesh119.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
SpecialMesh119.TextureId = "rbxassetid://1701541474"
SpecialMesh119.MeshType = Enum.MeshType.FileMesh
SpecialMesh119.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
Part120.Name = "Mag"
Part120.Parent = Tool0
Part120.Size = Vector3.new(1.67528033, 1.03085184, 0.411091119)
Part120.CFrame = CFrame.new(6.59600067, 0.415090084, 45.5410004, 1, 0, 0, 0, 1, 0, 0, 0, 1)
Part120.Position = Vector3.new(6.59600067, 0.415090084, 45.5410004)
SpecialMesh121.Name = "ConvertedMesh"
SpecialMesh121.Parent = Part120
SpecialMesh121.MeshId = "rbxassetid://1701895898"
SpecialMesh121.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
SpecialMesh121.TextureId = "rbxassetid://1701524630"
SpecialMesh121.MeshType = Enum.MeshType.FileMesh
SpecialMesh121.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
Part122.Parent = Tool0
Part122.Size = Vector3.new(0.222744882, 0.521590114, 0.324723214)
Part122.CFrame = CFrame.new(5.56099987, 1.04299998, 45.5410004, 1, 0, 0, 0, 1, 0, 0, 0, 1)
Part122.Position = Vector3.new(5.56099987, 1.04299998, 45.5410004)
SpecialMesh123.Name = "ConvertedMesh"
SpecialMesh123.Parent = Part122
SpecialMesh123.MeshId = "rbxassetid://1702570545"
SpecialMesh123.Scale = Vector3.new(0.104999997, 0.104999997, 0.104999997)
SpecialMesh123.TextureId = "rbxassetid://1702570629"
SpecialMesh123.MeshType = Enum.MeshType.FileMesh
SpecialMesh123.Scale = Vector3.new(0.104999997, 0.104999997, 0.104999997)
Part124.Parent = Tool0
Part124.Rotation = Vector3.new(-180, 0, 135)
Part124.Size = Vector3.new(0.151444718, 0.34946546, 0.176142499)
Part124.CFrame = CFrame.new(5.56400013, 1.04309011, 45.5390015, -0.707106829, -0.707106829, 0, -0.707106829, 0.707106829, 0, 0, 0, -1)
Part124.Position = Vector3.new(5.56400013, 1.04309011, 45.5390015)
Part124.Orientation = Vector3.new(0, 180, -45)
SpecialMesh125.Name = "ConvertedMesh"
SpecialMesh125.Parent = Part124
SpecialMesh125.MeshId = "rbxassetid://1702580081"
SpecialMesh125.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
SpecialMesh125.TextureId = "rbxassetid://1702580116"
SpecialMesh125.MeshType = Enum.MeshType.FileMesh
SpecialMesh125.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
Part126.Parent = Tool0
Part126.Size = Vector3.new(11.8294916, 3.35219908, 1.06313288)
Part126.CFrame = CFrame.new(5.35619926, 0.676102042, 45.5483818, 1, 0, 0, 0, 1, 0, 0, 0, 1)
Part126.Position = Vector3.new(5.35619926, 0.676102042, 45.5483818)
SpecialMesh127.Name = "ConvertedMesh"
SpecialMesh127.Parent = Part126
SpecialMesh127.MeshId = "rbxassetid://1701659145"
SpecialMesh127.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
SpecialMesh127.TextureId = "rbxassetid://1701680281"
SpecialMesh127.MeshType = Enum.MeshType.FileMesh
SpecialMesh127.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
Part128.Name = "AmmoCounter"
Part128.Parent = Tool0
Part128.Size = Vector3.new(0.0500000007, 0.116215952, 0.18027918)
Part128.CFrame = CFrame.new(5.56400013, 1.04309011, 45.5390015, 1, 0, 0, 0, 1, 0, 0, 0, 1)
Part128.Position = Vector3.new(5.56400013, 1.04309011, 45.5390015)
SpecialMesh129.Name = "ConvertedMesh"
SpecialMesh129.Parent = Part128
SpecialMesh129.MeshId = "rbxassetid://1701660540"
SpecialMesh129.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
SpecialMesh129.TextureId = "rbxassetid://1701660551"
SpecialMesh129.MeshType = Enum.MeshType.FileMesh
SpecialMesh129.Scale = Vector3.new(0.100000001, 0.100000001, 0.100000001)
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