Roblox/luau_corpus huggingface dataset:
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
elseif guntype == 3 then--pistol
local lleg = model.Parent:FindFirstChild("Left Leg")
local rleg = model.Parent:FindFirstChild("Right Leg")
if lleg ~= nil and rleg ~= nil then
if weldmode == 1 then--pistol on right leg
local w = Instance.new("Weld")
w.Part0 = rleg
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance *-1, 0 +y, -0.25 +x *-1) * CFrame.fromEulerAnglesXYZ(math.pi / 2, 0, 0)
elseif weldmode == 2 then--pistol on left leg
local w = Instance.new("Weld")
w.Part0 = lleg
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance, 0 +y, -0.25 +x *-1) * CFrame.fromEulerAnglesXYZ(math.pi / 2, 0, 0)
elseif weldmode == 3 then--knife in pant's back, gangsta like
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance *-1, 0 +y, 0.25 +x) * CFrame.fromEulerAnglesXYZ(math.pi / 2 , math.pi / 2, 0)
elseif weldmode == 4 then--knife in pant's front, gangsta like
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance, 0 +y, 0.25 +x) * CFrame.fromEulerAnglesXYZ(math.pi / 2 , math.pi / 2 *-1, 0)
end
end
--[[
TheNexusAvenger

Applies body colors to the player.
--]]

local SKIN_COLOR = BrickColor.new("Bright yellow")
local TORSO_COLOR = BrickColor.new("Light stone grey")
local LEG_COLOR = BrickColor.new("Dark green")



local BodyColors = Instance.new("BodyColors")
BodyColors.HeadColor = SKIN_COLOR
BodyColors.LeftArmColor = SKIN_COLOR
BodyColors.RightArmColor = SKIN_COLOR
BodyColors.TorsoColor = TORSO_COLOR
BodyColors.LeftLegColor = LEG_COLOR
BodyColors.RightLegColor = LEG_COLOR
BodyColors.Parent = script.Parent

wait()
script:Destroy()
-- Morning time
morning_h1,morning_m1 = 5,30	--start
morning_h2,morning_m2 = 7,00	-- end
local morning_time1 = (morning_h1 + (morning_m1/60)) * 60
local morning_time2 = (morning_h2 + (morning_m2/60)) * 60
-- Helper function
function SetInformation(index)
	bg.T.Text = Vehicles[index].Name
end

local locked = false
bg.S.MouseButton1Click:connect(function()
	if (locked) then return end
	locked = true
	local vehicleName = player.Name.."'s Car"
	if game.Workspace:FindFirstChild(player.Name.."'s Car") then
		game.Workspace[player.Name.."'s Car"]:Destroy()
	end
	if (not workspace:FindFirstChild(vehicleName)) then
		local model = Vehicles[index]:Clone()
		model.Name = vehicleName
		model.Parent = game.Workspace
		model:MakeJoints()
		model:MoveTo(player.Character.Torso.Position + Vector3.new(0, 0, 0))
		bg.Visible = false
	end	
	locked = false
end)

bg.B.MouseButton1Click:connect(function()
	index = index - 1
	if (index < 1) then index = #Vehicles end
	SetInformation(index)
end)

bg.N.MouseButton1Click:connect(function()
	index = index + 1
	if (index > #Vehicles) then index = 1 end
	SetInformation(index)
end)

SetInformation(index)
--			loca = 10
		elseif sel == 4 then
			input(true)
		elseif sel == 5 then
			home()
		end
	elseif loca == 7 then
		if sel == 1 then
			handler:FireServer('PM','Valet',.4)
		elseif sel == 2 then
			handler:FireServer('PM','Eco',.65)
		elseif sel == 3 then
			handler:FireServer('PM','Comfort',.825)
		elseif sel == 4 then
			handler:FireServer('PM','Sport',1)
		elseif sel == 5 then
			home()
		end
	elseif loca == 8 then
		if sel == 1 then
			handler:FireServer('Dyn',2.2)
		elseif sel == 2 then
			handler:FireServer('Dyn',2.15)
		elseif sel == 3 then
			handler:FireServer('Dyn',2.1)
		elseif sel == 4 then
			home()
		end
-- Roblox character sound script

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local FootstepsSoundGroup = game:GetService("SoundService"):WaitForChild("Footsteps")

local SOUND_DATA = {
	Climbing = {
		SoundId = "rbxasset://sounds/action_footsteps_plastic.mp3",
		Looped = true,
	},
	Died = {
		SoundId = "rbxasset://sounds/uuhhh.mp3",
	},
	FreeFalling = {
		SoundId = "rbxasset://sounds/action_falling.mp3",
		Looped = true,
	},
	GettingUp = {
		SoundId = "rbxasset://sounds/action_get_up.mp3",
	},
	Jumping = {
		SoundId = "rbxasset://sounds/action_jump.mp3",
	},
	Landing = {
		SoundId = "rbxasset://sounds/action_jump_land.mp3",
	},
	Running = {
		SoundId = '' ,
		Looped = true,
		Playing = true,
		Pitch = 1,
	},
	Splash = {
		SoundId = "rbxasset://sounds/impact_water.mp3",
	},
	Swimming = {
		SoundId = "rbxasset://sounds/action_swim.mp3",
		Looped = true,
		Pitch = 1.6,
	},
}

 -- wait for the first of the passed signals to fire
local function waitForFirst(...)
	local shunt = Instance.new("BindableEvent")
	local slots = {...}

	local function fire(...)
		for i = 1, #slots do
			slots[i]:Disconnect()
		end

		return shunt:Fire(...)
	end

	for i = 1, #slots do
		slots[i] = slots[i]:Connect(fire)
	end

	return shunt.Event:Wait()
end
--Spooky--

local function AttachParticleControl(source_part)
	
	local prtc = nil
	
	local function Start()
		prtc = script.Spook:clone()
		prtc.Parent = source_part
	end
	
	local function Update()
		
	end
	
	local function Stop()
		if prtc ~= nil then
			prtc:destroy()
			prtc = nil
		end
	end
	
	return {Start = Start, Update = Update, Stop = Stop}
end

return AttachParticleControl
--- Removes raycast points using only vector3 values. Use the same vector3 table from SetPoints
-- @param object BasePart or Bone, the original instance you used for SetPoints
-- @param table of vector values that are in local space relative to the basePart
function Hitbox:RemovePoints(object: BasePart | Bone, vectorPoints: {[number]: Vector3})
	for i = #self.HitboxRaycastPoints, 1, -1 do
		local part = (self.HitboxRaycastPoints[i] :: Point).Instances[1]

		if part == object then
			local originalVector = (self.HitboxRaycastPoints[i] :: Point).Instances[2]

			for _: number, vector: Vector3 in ipairs(vectorPoints) do
				if vector == originalVector :: Vector3 then
					table.remove(self.HitboxRaycastPoints, i)
					break
				end
			end
		end
	end
end
------------------------------------------------------------------------------
--------------------[ FUNCTIONS ]---------------------------------------------
------------------------------------------------------------------------------

local CreateShockwave = function(Center, Radius)
	local Shockwave = Instance.new("Part")
	Shockwave.BrickColor = S.ShockwaveColor
	Shockwave.Material = Enum.Material.SmoothPlastic
	Shockwave.Name = "Shockwave"
	Shockwave.Anchored = true
	Shockwave.CanCollide = false
	Shockwave.FormFactor = Enum.FormFactor.Symmetric
	Shockwave.Size = VEC3(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 = VEC3()
	Mesh.Parent = Shockwave
	Shockwave.Parent = Main.Parent
	Shockwave.CFrame = CF(Center)
	spawn(function()
		for i = 0, 1, 1 / (30 * S.ShockwaveDuration) do
			local Scale = 2 * Radius * i
			Mesh.Scale = VEC3(Scale, Scale, Scale)
			Shockwave.Transparency = i
			wait()
		end
		Shockwave:Destroy()
	end)
end

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

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

local Sine = function(Alpha)
	return math.sin(math.rad(Alpha))
end

local IsIgnored = function(Obj)
	for _,v in pairs(Ignore) do
		if Obj == v or Obj:IsDescendantOf(v) then
			return true
		end
	end
	return false
end
--Casts a ray to find the height for the character to hover at even if the path is going up or down
function findHeight(distanceInFront)
	local ray = Ray.new(
    Vector3.new(character.Torso.Position.X, character.Torso.Position.Y + 50, character.Torso.Position.Z - distanceInFront), 	-- origin
    (Vector3.new(0, -1, 0)).unit * 300)	 																						-- direction
	local ignore = character
	local hit, position = game.Workspace:FindPartOnRay(ray, ignore)
	return position.Y + 40
end

function highest(tableOfValues)
	local highestSoFar = tableOfValues[1]
	for i = 2, #tableOfValues do
		if tableOfValues[i] > highestSoFar then
			highestSoFar = tableOfValues[i]
		end
	end
	return highestSoFar
end

function fastStart()
	if started == false then	
		started = true
		local fastStartPosition = Instance.new("BodyPosition")
		fastStartPosition.Name = "FastStart"
		fastStartPosition.maxForce = Vector3.new(0, 15000, 0)
		fastStartPosition.Parent = character.Torso
		local fastStartVelocity = Instance.new("BodyVelocity")
		fastStartVelocity.maxForce = Vector3.new(0, 0, 15000)
		fastStartVelocity.velocity = Vector3.new(0, 0, -150)
		fastStartVelocity.Parent = character.Torso
		fastStartPosition.position = Vector3.new(0, highest({findHeight(0), findHeight(10), findHeight(20), findHeight(30)}), 0)
		while character.Torso.Position.Z > spawnLocation.Z - 1000 do
			wait(1)
			if character:FindFirstChild("Torso") == nil then
				break
			end
			fastStartPosition.position = Vector3.new(0, highest({findHeight(0), findHeight(10), findHeight(20), findHeight(30)}), 0)
		end
		fastStartVelocity.velocity = Vector3.new(0, 0, 0)
		wait(2)
		if character:FindFirstChild("Torso") then
			fastStartPosition:Destroy()
			fastStartVelocity:Destroy()
			local shield = Instance.new("ForceField")
			shield.Name = "Shield"		
			shield.Parent = character
			game:GetService("Debris"):AddItem(shield, 3)
		end
		fastStart:Destroy()
		script:Destroy()
	end
end

fastStart() --Script starts disabled, only enabled when a player starts running
-- declarations

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")
--Multibay Config

return {
	--/ Button /--
	["ClickDetector"] = false, -- Apply Legacy ClickDetector, but not for Alarm button
	--["CallLock"] = {}, -- Locked Call Buttons
	["ButtonLit"] = "Bright blue", -- Default Button Lit Colour
	["ButtonUnLit"] = "Institutional white", -- Default Button UnLit Colour
	
}
--[[Weight and CG]]
	Tune.Weight			= 3428		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		7		,
	 --[[Height]]		4		,
	 --[[Length]]		17		}
	Tune.WeightDist		= 51		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 2			-- Size of structural members (larger = MORE STABLE / carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members
--[Constants]:

local Cam = game.Workspace.CurrentCamera

local Plr = game.Players.LocalPlayer
local Mouse = Plr:GetMouse()
local Body = Plr.Character or Plr.CharacterAdded:wait()
local Head = Body:WaitForChild("Head")
local Hum = Body:WaitForChild("Humanoid")
local Core = Body:WaitForChild("HumanoidRootPart")
local IsR6 = (Hum.RigType.Value==0)	--[Checking if the player is using R15 or R6.]
local Trso = (IsR6 and Body:WaitForChild("Torso")) or Body:WaitForChild("UpperTorso")
local Neck = (IsR6 and Trso:WaitForChild("Neck")) or Head:WaitForChild("Neck")	--[Once we know the Rig, we know what to find.]
local Waist = (not IsR6 and Trso:WaitForChild("Waist"))	--[R6 doesn't have a waist joint, unfortunately.]
--followPath(destination)
-------------------------------------------------------------------
-------------------------------------------------------------------
-------------------------------------------------------------------


function AI()

	if Mode == 0 then
			--waypoint = nil
			--print("Patrol mode")
			wait(math.random(5,15)/10)
			followPath(hroot.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)))

			--human:MoveTo(zombie.Torso.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)), CurrentPart)

	elseif Mode == 1 then

		target = findNearestTorso(hroot.Position)

		if target ~= nil then
		if CanSee == true and (hroot.Position - target.Position).Magnitude <= MinDistance then
			waypoint = nil
		else
			
		path:ComputeAsync(hroot.Position, target.Position)
		waypoint = path:GetWaypoints()

		local connection;
		local function checkw(t)
			local ci = 3
			if ci > #t then
				ci = 3
			end
			if t[ci] == nil and ci < #t then
				repeat ci = ci + 1 wait() until t[ci] ~= nil
				return Vector3.new(1,0,0) + t[ci]
			else
				ci = 3
				return t[ci]
			end
		end
		if path.Status == Enum.PathStatus.Success then
			--print("Chasing "..target.Parent.Name)
			human.WalkToPart = nil
		if  waypoint or checkw(waypoint) then
			if checkw(waypoint) ~= nil and checkw(waypoint).Action == Enum.PathWaypointAction.Walk then
				human:MoveTo( checkw(waypoint).Position)
			end
			
			
			if connection then
				connection:Disconnect()
			end
			
		else
			for i = 3, #waypoint do
				human:MoveTo( waypoint[i].Position )	
			end
		end
		else
			--print("No Path,Patrolling")
			wait(math.random(10,25)/10)
			followPath(hroot.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)))

		end
		end
		end
	elseif Mode == 2 then

		target = findNearestTorso(hroot.Position)

		if target ~= nil then
		if CanSee == true and (hroot.Position - target.Position).Magnitude <= MinDistance then
			waypoint = {}
			waypoint = nil
		else
			
		path:ComputeAsync(hroot.Position, target.Position)
		waypoint = path:GetWaypoints()

		local connection;
		local function checkw(t)
			local ci = 3
			if ci > #t then
				ci = 3
			end
			if t[ci] == nil and ci < #t then
				repeat ci = ci + 1 wait() until t[ci] ~= nil
				return Vector3.new(1,0,0) + t[ci]
			else
				ci = 3
				return t[ci]
			end
		end
		if path.Status == Enum.PathStatus.Success and Memory > 0 then
			--print("Chasing "..target.Parent.Name)
			human.WalkToPart = nil
			if  waypoint or checkw(waypoint) then
				if checkw(waypoint) ~= nil and checkw(waypoint).Action == Enum.PathWaypointAction.Walk then
					human:MoveTo( checkw(waypoint).Position )
				end
			
			
				if connection then
					connection:Disconnect()
				end
			
			else
				for i = 3, #waypoint do
					human:MoveTo( waypoint[i].Position )	
				end
			end
		else
			waypoint = nil
			--print("No Path,Patrolling")
			wait(math.random(5,15)/10)
			followPath(hroot.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)))

		end
		end
		end
	elseif Mode == 3 then
		--	print("Guarding")
	end	
end
-- KeyBinding
if KEY1 then
	ContextActionService:BindAction("ToggleInteraction", toggleKeyboard, false, KEY1)
end
-- A task which can be accepted for cleanup.
export type Task =
	Instance |
	RBXScriptConnection |
	() -> () |
	{destroy: (any) -> ()} |
	{Destroy: (any) -> ()} |
	{Task}
--// bolekinds

script.Parent.MouseButton1Click:Connect(function()
	if game.Players.LocalPlayer.YouCash.Value >= 1000 and not workspace["Floppa NPC"]["Floppa cube"].autoclick.Value == true then
		script.Parent.Parent.Parent.Ching:Play()
	else
		script.Parent.Parent.Parent.Thud:Play()
	end
end)
-- Libraries
local Roact = require(Vendor:WaitForChild 'Roact')
local Maid = require(Libraries:WaitForChild 'Maid')
-- Import into a single datastore:
local function importPairsFromTable(origin, destination, interface, warnFunc, methodName, prefix, isOrdered)
	for key, value in pairs(origin) do
		if type(key) ~= "string" then
			warnFunc(("%s: ignored %s > '%s' (key is not a string, but a %s)")
				:format(methodName, prefix, tostring(key), typeof(key)))
		elseif not utf8.len(key) then
			warnFunc(("%s: ignored %s > '%s' (key is not valid UTF-8)")
				:format(methodName, prefix, tostring(key)))
		elseif #key > Constants.MAX_LENGTH_KEY then
			warnFunc(("%s: ignored %s > '%s' (key exceeds %d character limit)")
				:format(methodName, prefix, key, Constants.MAX_LENGTH_KEY))
		elseif type(value) == "string" and #value > Constants.MAX_LENGTH_DATA then
			warnFunc(("%s: ignored %s > '%s' (length of value exceeds %d character limit)")
				:format(methodName, prefix, key, Constants.MAX_LENGTH_DATA))
		elseif type(value) == "table" and #HttpService:JSONEncode(value) > Constants.MAX_LENGTH_DATA then
			warnFunc(("%s: ignored %s > '%s' (length of encoded value exceeds %d character limit)")
				:format(methodName, prefix, key, Constants.MAX_LENGTH_DATA))
		elseif type(value) == "function" or type(value) == "userdata" or type(value) == "thread" then
			warnFunc(("%s: ignored %s > '%s' (cannot store value '%s' of type %s)")
				:format(methodName, prefix, key, tostring(value), type(value)))
		elseif isOrdered and type(value) ~= "number" then
			warnFunc(("%s: ignored %s > '%s' (cannot store value '%s' of type %s in OrderedDataStore)")
				:format(methodName, prefix, key, tostring(value), type(value)))
		elseif isOrdered and value % 1 ~= 0 then
			warnFunc(("%s: ignored %s > '%s' (cannot store non-integer value '%s' in OrderedDataStore)")
				:format(methodName, prefix, key, tostring(value)))
		elseif type(value) == "string" and not utf8.len(value) then
			warnFunc(("%s: ignored %s > '%s' (string value is not valid UTF-8)")
				:format(methodName, prefix, key, tostring(value), type(value)))
		else
			local isValid = true
			local keyPath, reason
			if type(value) == "table" then
				isValid, keyPath, reason = scanValidity(value)
			end
			if isOrdered then
				value = math.floor(value + .5)
			end
			if isValid then
				local old = destination[key]
				destination[key] = value
				if interface and old ~= value then -- hacky block to fire OnUpdate signals
					if isOrdered and interface then -- hacky block to populate internal structures for OrderedDataStores
						if interface.__ref[key] then
							interface.__ref[key].Value = value
							interface.__changed = true
						else
							interface.__ref[key] = {Key = key, Value = interface.__data[key]}
							table.insert(interface.__sorted, interface.__ref[key])
							interface.__changed = true
						end
					end
					interface.__event:Fire(key, value)
				end
			else
				warnFunc(("%s: ignored %s > '%s' (table has invalid entry at <%s>: %s)")
					:format(methodName, prefix, key, getStringPath(keyPath), reason))
			end
		end
	end
end
--[[

	LOWGames Studios
	Date: 27 October 2022
	by Elder
	
]]--

while not require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library")).Loaded do
	game:GetService("RunService").Heartbeat:Wait();
end;
return function(p1, p2, ...)
	p1.title.Text = ...;
end;
-- Function to bind to reload event
local function reload()
	if not reloading then
		tool.ReloadSound:Play()
		reloading = true
		canFire = false
		wait(reloadTime)
		currentAmmo = clipSize
		canFire = true
		reloading = false
	end
end

reloadEvent.OnServerEvent:connect(reload)
--Muffins stuff that has to do with the module things
local ComfShift = _Tune.ComfortShift
-- Support for debounce
function PlayCutscene()
	if bin then
		bin = false
		Music:Play()
		if ProtectTheCharacterWhilePlaying and ProtectTheCharacterWhilePlaying.Value and Player.Character then
			CharacterProtector.Parent = Player.Character
		end
		Demo:Play()
	end
end

Demo.EStop.Event:Connect(function()
	wait_time(Debounce.Value)
	CharacterProtector.Parent = nil
	if PlayOnce then
		if not PlayOnce.Value then
			bin = true
		end
	else
		bin = true
	end
	if StopMusicWhenFinished and StopMusicWhenFinished.Value then
		Music:Stop()
		if OnFinishedRemove then
			for i,v in pairs(OnFinishedRemove:GetChildren()) do
				if v:IsA("ObjectValue") then
					if v.Value then
						v.Value:Destroy()
					end
				end
			end
		end
	end
end)
-- Bind drawer opening function to remote event
for _, Child in pairs(dresser:GetChildren()) do
	if Child.ClassName == "Model" and Child.Name == "Drawer" then
		Child.DrawerPadding.ROBLOXInteractionEvent.OnServerEvent:connect(function(player, arguments)
			openDrawer(player, Child)
		end)
		Child.PrimaryPart = Child.Front
	end
end

while true do
	for _, drawer in pairs(dresser:GetChildren()) do
		if drawer.ClassName == "Model" and drawer.Name == "Drawer" then
			local drawerStep = drawer.Front.CFrame.lookVector.unit * stepDistance
			if drawer.Open.Value and drawer.Step.Value < 20 then
				drawer:SetPrimaryPartCFrame(drawer.Front.CFrame + drawerStep)
				drawer.Step.Value = drawer.Step.Value + 1
			end
			if not drawer.Open.Value and drawer.Step.Value > 0 then
				drawer:SetPrimaryPartCFrame(drawer.Front.CFrame - drawerStep)
				drawer.Step.Value = drawer.Step.Value - 1
			end
		end
	end
	wait()
end
-- Unequip logic here
function OnUnequipped()
	LeftButtonDown = false
	Reloading = false
	MyCharacter = nil
	MyHumanoid = nil
	MyTorso = nil
	MyPlayer = nil
	if OnFireConnection then
		OnFireConnection:disconnect()
	end
	if OnReloadConnection then
		OnReloadConnection:disconnect()
	end
	if FlashHolder then
		FlashHolder = nil
	end
	if WeaponGui then
		WeaponGui.Parent = nil
		WeaponGui = nil
	end
	if EquipTrack then
		EquipTrack:Stop()
	end
	if PumpTrack then
		PumpTrack:Stop()
	end
end

Tool.Equipped:connect(OnEquipped)
Tool.Unequipped:connect(OnUnequipped)
-- Implements Javascript's `Array.prototype.every` as defined below
-- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every
return function<T, U>(t: Array<T>, callback: callbackFn<T> | callbackFnWithThisArg<T, U>, thisArg: U?): boolean
	if _G.__DEV__ then
		if typeof(t) ~= "table" then
			error(string.format("Array.every called on %s", typeof(t)))
		end
		if typeof(callback) ~= "function" then
			error("callback is not a function")
		end
	end

	local len = #t
	local k = 1

	while k <= len do
		local kValue = t[k]
		local testResult

		if kValue ~= nil then
			if thisArg ~= nil then
				testResult = (callback :: callbackFnWithThisArg<T, U>)(thisArg, kValue, k, t)
			else
				testResult = (callback :: callbackFn<T>)(kValue, k, t)
			end

			if not testResult then
				return false
			end
		end
		k += 1
	end
	return true
end
--[[
Creates a top wall part.
--]]
local function CreateTopWallPart(Size,CF,Parent)
	return CreatePart(TOP_WALL_COLOR,Size,CF,Parent)
end
-- Libraries
local Support = require(Libraries:WaitForChild 'SupportLibrary')
local Roact = require(Vendor:WaitForChild 'Roact')
-- CONNECTIONS
-- RenderStep
RunService:BindToRenderStep("InteractionCheck", Enum.RenderPriority.Camera.Value-1, interactionCheck)
--Global reference interface
function global_reference:Get()
	if self.cur_p == nil then
		InitialReference(self)
	end
	return self.cur_p
end

return global_reference
--[[**
	ensures value is an integer

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.integer(value)
	local success, errMsg = t.number(value)
	if not success then
		return false, errMsg or ""
	end

	if value % 1 == 0 then
		return true
	else
		return false, string.format("integer expected, got %s", value)
	end
end
-- declarations

local sDied = newSound("rbxasset://sounds/uuhhh.wav")
sDied.Pitch = 0.75
local sFallingDown = newSound("rbxasset://sounds/splat.wav")
local sFreeFalling = newSound("rbxasset://sounds/swoosh.wav")
local sGettingUp = newSound("rbxasset://sounds/hit.wav")
local sJumping = newSound("rbxasset://sounds/button.wav")
local sRunning = newSound("rbxasset://sounds/bfsl-minifigfoots1.mp3")
sRunning.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")
--Made by Stickmasterluke


sp=script.Parent


firerate=0.1
range=950
power=300
rate=2/50
spinuptime=0
barreloffset=Vector3.new(0,0.375,-2.625)
windvec=Vector3.new(2,-1,1).unit
firetime=0
maxammo=50
reloadtime = 2.75
ammo=maxammo

debris=game:GetService("Debris")
equipped=false
check=true
firing=false
reloading=false
fireanimdelay=0
handle=sp:WaitForChild("Handle")