Roblox/luau_corpus huggingface dataset:
-------- OMG HAX

r = game:service("RunService")


local damage = 5


local slash_damage = 10
local lunge_damage = 20

sword = script.Parent.Handle
Tool = script.Parent


local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "rbxasset://sounds\\swordslash.wav"
SlashSound.Parent = sword
SlashSound.Volume = .7

local LungeSound = Instance.new("Sound")
LungeSound.SoundId = "rbxasset://sounds\\swordlunge.wav"
LungeSound.Parent = sword
LungeSound.Volume = .6

local UnsheathSound = Instance.new("Sound")
UnsheathSound.SoundId = "rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent = sword
UnsheathSound.Volume = 1


function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid~=nil and humanoid ~= hum and hum ~= nil then
		-- final check, make sure sword is in-hand

		local right_arm = vCharacter:FindFirstChild("Right Arm")
		if (right_arm ~= nil) then
			local joint = right_arm:FindFirstChild("RightGrip")
			if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
				tagHumanoid(humanoid, vPlayer)
				humanoid:TakeDamage(damage)
				wait(1)
				untagHumanoid(humanoid)
			end
		end


	end
end


function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end

function lunge()
	damage = lunge_damage

	LungeSound:play()

	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Lunge"
	anim.Parent = Tool
	
	
	force = Instance.new("BodyVelocity")
	force.velocity = Vector3.new(0,10,0) --Tool.Parent.Torso.CFrame.lookVector * 80
	force.Parent = Tool.Parent.Torso
	wait(.3)
	swordOut()
	wait(.3)
	force.Parent = nil
	wait(.5)
	swordUp()

	damage = slash_damage
end

function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
end

function swordAcross()
	-- parry
end


Tool.Enabled = true
local last_attack = 0
function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end

	t = r.Stepped:wait()

	if (t - last_attack < .2) then
		lunge()
	else
		attack()
	end

	last_attack = t

	wait(.5)

	Tool.Enabled = true
end


function onEquipped()
	UnsheathSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
-- This will do the edit gui popup
function Triggered(Player)
	local PlayerName = Player.Name
	if Owner.Value == PlayerName then
		UpdateSign:FireClient(Player)
	end
end

Prompt.Triggered:Connect(Triggered)
--[=[
	Detects if a dictionary has a certain key.
	
	```lua
	local Dictionary = {
		Hay = "A",
		MoreHay = "B",
		Needle = "C",
		SomeHay = "D",
	}
	
	print(TableKit.HasKey(Dictionary, "Needle")) -- prints true
	```
	
	@within TableKit
	@param dictionary table
	@param key unknown
	@return boolean
]=]
function TableKit.HasKey(dictionary: { [any]: unknown }, key: any): boolean
	return dictionary[key] ~= nil
end
-- Vitesse de déplacement en secondes
local moveSpeed = 2
local isAtEnd = false
-- Services
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ReplicatedFirst = game:GetService("ReplicatedFirst")
local Players = game:GetService("Players")
local TeleportService = game:GetService("TeleportService")
local StarterPack = game:GetService("StarterPack")

local Conf = require(ReplicatedFirst.Configurations.MainConfiguration)
local Log = require(ReplicatedStorage.Libraries.Log)
local Util = require(ReplicatedStorage.Libraries.Util)
local Broadcast = require(ReplicatedStorage.Libraries.Broadcast)

local MatchmakingDestination = require(ReplicatedStorage.Libraries.MatchmakingDestination)

local WeaponsSystem = require(ReplicatedStorage.WeaponsSystem.WeaponsSystem)
local DamageHandler = require(ReplicatedStorage.Core.DamageHandler)

local WeaponsFolder = ReplicatedStorage.Assets.Weapons
--[[Transmission]]
Tune.TransModes		= {"Auto", "Semi", "Manual"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
--------STAGE--------

game.Workspace.Screens.Current.Value = game.Workspace.Screens.Main.Value
game.Workspace.back1.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.back2.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.crewbig1.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.crewsmall1.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.djstand.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.djtv.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.side1.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.side2.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.side3.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.side4.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.side11.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.side12.Decal.Texture = game.Workspace.Screens.Main.Value
game.Workspace.sidebig1.Decal.Texture = game.Workspace.Screens.Main.Value

if game.Workspace.CurrentStageTV.Value == "1" then
game.Workspace.main1.Decal.Texture = game.Workspace.Screens.Main.Value
end
---------------------------------------------------------------------------------------

local defaultMenuFieldOfView = 70
local defaultMenuBlurIntensity = 20

local defaultMenuMusicVolume = 0.5
local defaultGameMusicVolume = 0.35
----------------------------------
------------FUNCTIONS-------------
----------------------------------

function WeldChanged(property)
	if property == "Parent" and SeatWeld.Parent == nil then
		SeatWeld = nil
		Deactivate()
		BreakSeatConnections()
	end
end
function ChildAdded(child)
	if child:IsA("Weld") then
		local root = child.Part1
		local character = root.Parent
		local player = game.Players:GetPlayerFromCharacter(character)
		if player then
			SeatWeld = child
			Activate(player)
			MakeSeatConnections()
		end
	end
end
-------------------------
function onClicked()
script.Parent.Parent.Down.ClickDetector.MaxActivationDistance = 0
script.Parent.Parent.Call2.ClickDetector.MaxActivationDistance = 0
script.Parent.Parent.Call.ClickDetector.MaxActivationDistance = 0
script.Parent.Click:Play()
script.Parent.BrickColor = BrickColor.new("Really red")
script.Parent.ClickDetector.MaxActivationDistance = 0
script.Parent.Parent.Up.ClickDetector.MaxActivationDistance = 0
wait(2)
script.Parent.Parent.DoorOutside2.CanCollide = true
script.Parent.Parent.DoorOutside2.Transparency = 0
script.Parent.Parent.DoorInside.Transparency = 0
script.Parent.Parent.DoorInside.CanCollide = true
script.Parent.Parent.DoorInside.Close:Play()
wait(3)
script.Parent.Parent.Screen.SurfaceGui.Frame.Down.Visible = true
Car.Start:Play()
Car.Run:Play()
LiftDown:Play()
wait(12)
script.Parent.Parent.Screen.SurfaceGui.Frame.TextLabel.Text = "SECRET BASE"
script.Parent.Parent.Screen.SurfaceGui.Frame.Down.Visible = false
Car.Start:Stop()
Car.Run:Stop()
Car.Stop:Play()
wait(2)
door.Transparency = 1
door.CanCollide = false
script.Parent.Parent.DoorOutside.CanCollide = false
script.Parent.Parent.DoorOutside.Transparency = 1
Car.Ding:Play()
wait(5)
script.Parent.Parent.Call2.ClickDetector.MaxActivationDistance = 12
script.Parent.BrickColor = BrickColor.new("Lime green")
script.Parent.Parent.Up.BrickColor = BrickColor.new("Lime green")
script.Parent.Parent.Up.ClickDetector.MaxActivationDistance = 12
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
--[=[
	Binds the given update function to render stepped.

	```lua
	local spring = Spring.new(0)
	local maid = Maid.new()

	local startAnimation, maid._stopAnimation = StepUtils.bindToRenderStep(function()
		local animating, position = SpringUtils.animating(spring)

		print(position)

		return animating
	end)

	spring.t = 1
	startAnimation()
	```

	:::tip
	Be sure to call the disconnect function when cleaning up, otherwise you may memory leak.
	:::

	@param update () -> boolean -- should return true while it needs to update
	@return (...) -> () -- Connect function
	@return () -> () -- Disconnect function
]=]
function StepUtils.bindToRenderStep(update)
	return StepUtils.bindToSignal(RunService.RenderStepped, update)
end
--[=[
	Retrieves the rank of the player in the group.

	@param player Player
	@param groupId number
	@return Promise<number> -- Generally from 0 to 255
]=]
function GroupUtils.promiseRankInGroup(player, groupId)
	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
	assert(type(groupId) == "number", "Bad groupId")

	return Promise.spawn(function(resolve, reject)
		local rank = nil
		local ok, err = pcall(function()
			rank = player:GetRankInGroup(groupId)
		end)

		if not ok then
			return reject(err)
		end

		if type(rank) ~= "number" then
			return reject("Rank is not a number")
		end

		return resolve(rank)
	end)
end
-----------------
--| Constants |--
-----------------

local BLAST_RADIUS = 8 -- Blast radius of the explosion
local BLAST_DAMAGE = 100 -- Amount of damage done to players
local BLAST_FORCE = 1000 -- Amount of force applied to parts

local IGNORE_LIST = {rocket = 1, handle = 1, effect = 1, water = 1} -- Rocket will fly through things named these
---- Change these settings to change stuff (keep the commas, lua doesn't understand n00b syntax)

local settings = {
	splatters_per_health_inc = 1,     ---- The amount of blood splatters made when you lose (damage_inc) of health
	damage_inc = 3,                   ---- The increment of damage that must be done at a time to trigger blood splatters
	remove_time = 20,                 ---- The time (in seconds) until a blood splatter is removed after it is created
	min_splatter_time = 0,            ---- The delay time (minimum) until another blood splatter is made
	max_splatter_time = 0.05,         ---- The delay time (maximum) until another blood splatter is made
	min_transparency = 0.2,           ---- The (minimum) transparency of a blood splatter
	max_transparency = 0,             ---- The (maximum) transparency of a blood splatter
	min_size_x = 3,                 ---- The (minimum) size of a blood splatter on the X axis
	max_size_x = 8,                   ---- The (maximum) size of a blood splatter on the X axis
	min_size_z = 3,                 ---- The (minimum) size of a blood splatter on the Z axis
	max_size_z = 8,                   ---- The (maximum) size of a blood splatter on the Z axis
	tran_tw_time_min = 0.1,           ---- The (minimum) time to tween the size of a blood splatter
	tran_tw_time_max = 0.5,           ---- The (maximum) time to tween the size of a blood splatter
	size_tw_time_min = 0.1,           ---- The (minimum) time to tween the transparency of a blood splatter
	size_tw_time_max = 0.6            ---- The (maximum) time to tween the transparency of a blood splatter
}
-- Initialize the tool
local MaterialTool = {

	Name = 'Material Tool';
	Color = BrickColor.new 'Bright violet';

};
--| Custom |--
local Distance = 30 -- Distance (hitbox)
local Damage = 10 -- damage
-- Inheritance:
rev_ReplicaSetParent.OnClientEvent:Connect(function(replica_id, parent_replica_id) -- (replica_id, parent_replica_id)
	local replica = Replicas[replica_id]
	local old_parent_children = replica.Parent.Children
	local new_parent = Replicas[parent_replica_id]
	table.remove(old_parent_children, table.find(old_parent_children, replica))
	table.insert(new_parent.Children, replica)
	replica.Parent = new_parent
	-- Trigger child added:
	local child_listener_table = ChildListeners[parent_replica_id]
	if child_listener_table ~= nil then
		for i = 1, #child_listener_table do
			child_listener_table[i](replica)
		end
	end
end)
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 1740		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 2000		--		Use sliders to manipulate values
	Tune.Redline		= 12000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)
----------------------This is just an example-----------------------------
	script.Parent.Parent.Ammo.Visible = true
	script.Parent.Parent.Ammo.Text = ammo2.Value
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
local toolAnimName = ""
local toolAnimTrack = nil
local toolAnimInstance = nil
local currentToolAnimKeyframeHandler = nil
function toolKeyFrameReachedFunc(frameName)
    if (frameName == "End") then
        --print("Keyframe : ".. frameName)
        playToolAnimation(toolAnimName, 0.0, Humanoid)
    end
end
function playToolAnimation(animName, transitionTime, humanoid) 
    local roll = math.random(1, animTable[animName].totalWeight) 
    local origRoll = roll
    local idx = 1
    while (roll > animTable[animName][idx].weight) do
        roll = roll - animTable[animName][idx].weight
        idx = idx + 1
    end
    --print(animName .. " * " .. idx .. " [" .. origRoll .. "]")
    local anim = animTable[animName][idx].anim
    if (toolAnimInstance ~= anim) then
        if (toolAnimTrack ~= nil) then
            toolAnimTrack:Stop()
            toolAnimTrack:Destroy()
            transitionTime = 0
        end
        -- load it to the humanoid; get AnimationTrack
        toolAnimTrack = humanoid:LoadAnimation(anim)
        -- play the animation
        toolAnimTrack:Play(transitionTime)
        toolAnimName = animName
        toolAnimInstance = anim
        currentToolAnimKeyframeHandler = toolAnimTrack.KeyframeReached:connect(toolKeyFrameReachedFunc)
    end
end
function stopToolAnimations()
    local oldAnim = toolAnimName
    if (currentToolAnimKeyframeHandler ~= nil) then
        currentToolAnimKeyframeHandler:disconnect()
    end
    toolAnimName = ""
    toolAnimInstance = nil
    if (toolAnimTrack ~= nil) then
        toolAnimTrack:Stop()
        toolAnimTrack:Destroy()
        toolAnimTrack = nil
    end
    return oldAnim
end
-- Make Connection strict
setmetatable(Connection, {
	__index = function(tb, key)
		error(("Attempt to get Connection::%s (not a valid member)"):format(tostring(key)), 2)
	end,
	__newindex = function(tb, key, value)
		error(("Attempt to set Connection::%s (not a valid member)"):format(tostring(key)), 2)
	end
})
-- Libraries
local ListenForManualWindowTrigger = require(Tool.Core:WaitForChild('ListenForManualWindowTrigger'))
local Roact = require(Vendor:WaitForChild('Roact'))
local ColorPicker = require(UI:WaitForChild('ColorPicker'))
local Dropdown = require(UI:WaitForChild('Dropdown'))
local Signal = require(Libraries:WaitForChild('Signal'))
-- Removes an object's tree node. Called when the object stops existing in the
-- game tree.
removeObject = function(object)
	local objectNode = NodeLookup[object]
	if not objectNode then
		return
	end

	local visible = nodeIsVisible(objectNode)

	Selection:Remove(object,true)

	local parent = objectNode.Parent
	remove(parent,objectNode.Index)
	NodeLookup[object] = nil
	connLookup[object]:disconnect()
	connLookup[object] = nil

	if visible then
		updateList()
	elseif nodeIsVisible(parent) then
		updateScroll()
	end
end
-- declarations

local head = script.Parent
local sound = head:findFirstChild("Victory")

function onTouched(part)
	local h = part.Parent:findFirstChild("Humanoid")
	if h~=nil then
sound:play()
if part.Parent:findFirstChild("Torso"):findFirstChild("roblox").Texture == nil then return end
part.Parent:findFirstChild("Torso"):findFirstChild("roblox").Texture=""
part.Parent:findFirstChild("Head").BrickColor = BrickColor.new(1)
part.Parent:findFirstChild("Torso").BrickColor = BrickColor.new(1)
part.Parent:findFirstChild("Left Arm").BrickColor = BrickColor.new(1)
part.Parent:findFirstChild("Right Arm").BrickColor = BrickColor.new(1)
part.Parent:findFirstChild("Left Leg").BrickColor = BrickColor.new(1) 
part.Parent:findFirstChild("Right Leg").BrickColor = BrickColor.new(1) 
	end
end

script.Parent.Touched:connect(onTouched)
-- jest --expand
--
-- Given array of aligned strings with inverse highlight formatting,
-- return joined lines with diff formatting.
local function joinAlignedDiffsExpand(diffs: Array<Diff>, options: DiffOptionsNormalized): string
	return table.concat(
		Array.map(diffs, function(diff, i: number, diffs_: { [number]: any }): string
			local line = diff[2]
			-- ROBLOX deviation: 1-indexing
			local isFirstOrLast = i == 1 or i == #diffs_

			local case = diff[1]
			if case == DIFF_DELETE then
				return printDeleteLine(line, isFirstOrLast, options)
			elseif case == DIFF_INSERT then
				return printInsertLine(line, isFirstOrLast, options)
			else
				return printCommonLine(line, isFirstOrLast, options)
			end
		end),
		"\n"
	)
end

return {
	joinAlignedDiffsNoExpand = joinAlignedDiffsNoExpand,
	joinAlignedDiffsExpand = joinAlignedDiffsExpand,
}
--[[
    Indexes the avatar joints and gives them a default orientation
]]
function ClientAvatarComponent:setupJoints()
	self.shoulders = {}
	self.hips = {}
	self.knees = {}

	local leftShoulder = self.avatar:FindFirstChild("LeftShoulder", true)
	local rightShoulder = self.avatar:FindFirstChild("RightShoulder", true)
	local leftHip = self.avatar:FindFirstChild("LeftHip", true)
	local rightHip = self.avatar:FindFirstChild("RightHip", true)
	local leftKnee = self.avatar:FindFirstChild("LeftKnee", true)
	local rightKnee = self.avatar:FindFirstChild("RightKnee", true)

	-- Transform doesn't replicate, so this is applied clientside on each client
	-- As animations can't be shared between users yet, we can't use an animation for this

	if leftShoulder and leftShoulder:IsA("Motor6D") then
		leftShoulder.Transform = CFrame.Angles(0.3 * math.pi, 0, 0)
		self.shoulders.left = leftShoulder
	end
	if rightShoulder and rightShoulder:IsA("Motor6D") then
		rightShoulder.Transform = CFrame.Angles(0.3 * math.pi, 0, 0)
		self.shoulders.right = rightShoulder
	end
	if leftHip and leftHip:IsA("Motor6D") then
		leftHip.Transform = CFrame.Angles(0.5 * math.pi, 0, 0)
		self.hips.left = leftHip
	end
	if rightHip and rightHip:IsA("Motor6D") then
		rightHip.Transform = CFrame.Angles(0.5 * math.pi, 0, 0)
		self.hips.right = rightHip
	end
	if leftKnee and leftKnee:IsA("Motor6D") then
		leftKnee.Transform = CFrame.Angles(-0.5 * math.pi, 0, 0)
		self.knees.left = leftKnee
	end
	if rightKnee and rightKnee:IsA("Motor6D") then
		rightKnee.Transform = CFrame.Angles(-0.5 * math.pi, 0, 0)
		self.knees.right = rightKnee
	end
end
--Reset First
LeftHip.C1 = CFrame.new(3,0,0)
RightHip.C1 = CFrame.new(-3,0,0)

print("Completed")

while true do
	LeftHip.C1 = CFrame.new(3,0,0-5)
	RightHip.C1 = CFrame.new(-3,0,0+5)
	for i = 1,10 do
		LeftHip.C1 = LeftHip.C1 * CFrame.new(0,-0.5,0.5)
		RightHip.C1 = RightHip.C1 * CFrame.new(0,0.5,-0.5)
		--sp.Parent.Waist.CFrame = sp.Parent.Waist.CFrame * CFrame.new(0,0.5,0)
		--sp.Parent.Waist.RotVelocity = sp.Parent.Waist.RotVelocity * Vector3.new(1,0,1)
		wait()
	end
	for i = 1,10 do
		LeftHip.C1 = LeftHip.C1 * CFrame.new(0,0.5,0.5)
		RightHip.C1 = RightHip.C1 * CFrame.new(0,-0.5,-0.5)
		--sp.Parent.Waist.CFrame = sp.Parent.Waist.CFrame * CFrame.new(0,-0.5,0)
		--sp.Parent.Waist.RotVelocity = sp.Parent.Waist.RotVelocity * Vector3.new(1,0,1)
		wait()
	end
	sp.Parent.Torso["Footstep"..math.random(1,3)]:Play()
	for i = 1,10 do
		LeftHip.C1 = LeftHip.C1 * CFrame.new(0,0.5,-0.5)
		RightHip.C1 = RightHip.C1 * CFrame.new(0,-0.5,0.5)
		--sp.Parent.Waist.CFrame = sp.Parent.Waist.CFrame * CFrame.new(0,0.5,0)
		--sp.Parent.Waist.RotVelocity = sp.Parent.Waist.RotVelocity * Vector3.new(1,0,1)
		wait()
	end
	for i = 1,10 do
		LeftHip.C1 = LeftHip.C1 * CFrame.new(0,-0.5,-0.5)
		RightHip.C1 = RightHip.C1 * CFrame.new(0,0.5,0.5)
		--sp.Parent.Waist.CFrame = sp.Parent.Waist.CFrame * CFrame.new(0,-0.5,0)
		--sp.Parent.Waist.RotVelocity = sp.Parent.Waist.RotVelocity * Vector3.new(1,0,1)
		wait()
	end
	sp.Parent.Torso["Footstep"..math.random(1,3)]:Play()
end
--[[if player and player.Parent:findFirstChild("Humanoid") then
local enemy = game.Players:findFirstChild(player.Parent.Name)
if enemy then
if enemy.TeamColor ~= pler.TeamColor then
if player.Parent:findFirstChild("Head") and not pler.PlayerGui:findFirstChild(player.Parent.Name) then

local big = Instance.new("BillboardGui",pler.PlayerGui)
big.Name = player.Parent.Name
big.Adornee = player.Parent:findFirstChild("Head")
big.Size = UDim2.new( 1.0, 0, 1.0, 0 )
big.StudsOffset = Vector3.new( 0, 2, 0 )

local name = Instance.new("TextLabel",big)
name.Position = UDim2.new( 0.5, 0, 0, 0 )
name.FontSize = 3
name.BackgroundTransparency = 1
name.Size = UDim2.new(0, 0, 0, 0 )
name.Text = player.Parent.Name
name.TextColor3 = Color3.new(25, 0, 0)

game.Debris:AddItem(big,1)

end
end
end
end]]
end
end
function on(mouse)
while true do
wait(.5)
Run(mouse)
end
end

Tool.Equipped:connect(on)
--[=[
	Observes all descendants that match a predicate

	@param parent Instance
	@param predicate ((value: Instance) -> boolean)? -- Optional filter
	@return Observable<Instance, boolean>
]=]
function RxInstanceUtils.observeDescendants(parent, predicate)
	assert(typeof(parent) == "Instance", "Bad parent")
	assert(type(predicate) == "function" or predicate == nil, "Bad predicate")

	return Observable.new(function(sub)
		local maid = Maid.new()
		local added = {}

		local function handleDescendant(child)
			if not predicate or predicate(child) then
				added[child] = true
				sub:Fire(child, true)
			end
		end

		maid:GiveTask(parent.DescendantAdded:Connect(handleDescendant))
		maid:GiveTask(parent.DescendantRemoving:Connect(function(child)
			if added[child] then
				added[child] = nil
				sub:Fire(child, false)
			end
		end))

		for _, descendant in pairs(parent:GetDescendants()) do
			handleDescendant(descendant)
		end

		return maid
	end)
end
--[=[
	@tag Component Instance
	@param componentClass ComponentClass
	@return Component?

	Retrieves another component instance bound to the same
	Roblox instance.

	```lua
	local MyComponent = Component.new({Tag = "MyComponent"})
	local AnotherComponent = require(somewhere.AnotherComponent)

	function MyComponent:Start()
		local another = self:GetComponent(AnotherComponent)
	end
	```
]=]
function Component:GetComponent(componentClass)
	return componentClass[KEY_INST_TO_COMPONENTS][self.Instance]
end
-- How many times per second the gun can fire
local FireRate = 5 / 30
-- Decompiled with the Synapse X Luau decompiler.

local l__Gas__1 = game.Players.LocalPlayer:WaitForChild("Data"):WaitForChild("Gas");
local l__TweenService__1 = game:GetService("TweenService");
local l__Parent__2 = script.Parent;
l__Gas__1.Changed:Connect(function()
	l__TweenService__1:Create(l__Parent__2, TweenInfo.new(0.3, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, 0, false, 0), {
		BackgroundTransparency = l__Gas__1.Value / 1
	}):Play();
end);