Pinkstack/roblox-luau-corpus-text huggingface dataset:
--		{"MONTH", TOAL DAYS TO YEAR, DAYS}	<- Format


		{"January",31,31};
		{"February",59,28};
		{"March",90,31};
		{"April",120,30};
		{"May",151,31};
		{"June",181,30};
		{"July",212,31};
		{"August",243,31};
		{"September",273,30};
		{"October",304,31};
		{"November",334,30};
		{"December",365,31};
	}
	year = math.floor(1970+(t/31579200))
	if ((year%4) == 0) then	-- Check for leap year
		months[2][3] = 29
		for i,v in pairs(months) do
			if (i ~= 1) then
				v[2] = (v[2]+1)
			end
		end
	end
	day = math.floor(((t/86400)%365.25)+1)	-- Get current day of the year. Starts at 0, so 1 is added	(365.25 is the average # of days in a year due to leap year)
	for i,m in pairs(months) do
		if ((m[2]-m[3]) <= day) then	-- Get month based on day
			month = i
		end
	end
	local m = months[month]
	day = (day+m[3]-m[2])	-- Get day of the month
	year,day = tostring(year),tostring(day)
	local c,s = ", "," "	-- Comma, space
	Date = (months[month][1] .. s .. day .. c .. year)
end

function getTime()
	local min = math.floor((t/60)%60)
	local hour = math.floor((t/3600)%24)
	min = tostring((min < 10 and "0" or "") .. min)
	tag = (Type == 0 and (hour < 24 and "" or "") or "")
	hour = ((Type == 1 and hour < 24 and "0" or "") .. tostring(Type == 0 and (hour == 0 and 24 or hour > 24 and (hour-24) or hour) or hour))	-- Ternary operators FTW. Helps get rid of 'if then' stuff. Actually learned this off of Java programming:	z = (x == y ? "Yes" : "No")
	local c,s = ":",(Type == 0 and " " or "")	-- Colon, (space if 12 hr clock)
	Time = (hour .. c .. min .. (Sec and "") .. s .. tag)
end

function display(start)
	if (start) then
		getDate()
		getTime()
		delay(0,function()
			for i = 1,0,-0.05 do
				script.Parent.Time.TextTransparency,script.Parent.Date.TextTransparency = i,i
				wait()
			end
			script.Parent.Time.TextTransparency,script.Parent.Date.TextTransparency = 0,0
		end)
	end
	script.Parent.Time.Text = Time	-- ORLY?
	script.Parent.Date.Text = Date
end



function start()
	
	display(true)
	while (true) do
		-- Simplicity FTW:
		t = tick()
		getDate()
		getTime()
		display()
		wait()
	end
end

start()
-- Don't mess with anything in the script. The constants and variables are all mixed together



local Type = 0		-- Manipulated by GUI	(0 = 12 hr, 1 = 24 hr)
local Sec = true	-- Manipulated by GUI

local year = 1970
local month = 1
local day = 1
local Date = "January 1, 1970"

local hour = 0
local min = 0
local tag = "AM"
local Time = "12:00 AM"

function getDate()
	local months = {
--All loading and saving data should be done in this module
--Currently uses DataPersistence but could be changed to use a DataStore easily


local dataHandler = {}

local function recurLoadNumber(key, player, depth)
	local ok, number = pcall(function() return player:LoadNumber(key) end)
	if not ok or number == 0 then
		if depth >= 5 then
			return number
		else
			return recurLoadNumber(key, player, depth + 1)
		end
	end
	return number
end

local function recurSaveNumber(key, player, depth, value)
	local ok = pcall(function() player:SaveNumber(key, value) end)
	if not ok then
		if depth < 5 then
			return recurSaveNumber(key, player, depth + 1, value)
		end
	end
end

function dataHandler:LoadNumber(player, key)
	return recurLoadNumber(key, player, 0)
end

function dataHandler:SaveNumber(player, key, value)
	return recurSaveNumber(key, player, 0, value)
end

return dataHandler
--// All global vars will be wiped/replaced except script



return function(data)
	local playergui = service.PlayerGui
	local localplayer = service.Players.LocalPlayer
	local scr = client.UI.Prepare(script.Parent.Parent)
	local main = scr.Main
	local t1 = main.Title
	local t2 = main.Message
	local msg = data.Message
	local color = data.Color
	--[[
	local found = client.UI.Get("Output")
	if found then
		for i,v in pairs(found) do
			local p = v.Object
			if p and p.Parent then
				p.Main.Position = UDim2.new(0, 0, 0.35, p.Main.Position.Y.Offset+50)
			end
		end
	end--]]

	t2.Text = msg
	t2.Font = "Arial"
	--t2.Position = UDim2.new(0, 0, 0.35, 0)
	gTable.Ready()
	wait(5)
	gTable.Destroy()
end
---------------
--// Code
---------------


while true do

	task.wait()

	count1 = count1 + 0.001*speed
	count2 = count2 + 0.001*speed2

	if count1 > 1 then
		count1 = 0
	end

	if count2 > 1 then
		count2 = 0
	end
	
	local Color1 = ColorSequenceKeypoint.new(0, Color3.fromHSV(count1,1,1))
	local Color2 = ColorSequenceKeypoint.new(1, Color3.fromHSV(count2,1,1))
	
	local Color4 = ColorSequenceKeypoint.new(1, Color3.fromHSV(count1,1,1))
	local Color5 = ColorSequenceKeypoint.new(0, Color3.fromHSV(count2,1,1))

	
	for i,v in pairs(script.Parent:GetChildren()) do
		if v:IsA("SurfaceGui") then
			
			if v.Name == "Top" then
				v.Frame.UIGradient.Color =  ColorSequence.new({Color5, Color2})

			elseif v.Name == "Bottom" then
				v.Frame.UIGradient.Color =  ColorSequence.new({Color1, Color4})

			else
				
				v.Frame.UIGradient.Color =  ColorSequence.new({Color1, Color2})
			end
			
		end
	end



end
-- ROBLOX FIXME: Can we define ClientChatModules statically in the project config


pcall(function() ChatLocalization = require((game:GetService("Chat") :: any).ClientChatModules.ChatLocalization :: any) end)
if ChatLocalization == nil then ChatLocalization = {} end
if not ChatLocalization.FormatMessageToSend or not ChatLocalization.LocalizeFormattedMessage then
	function ChatLocalization:FormatMessageToSend(key,default) return default end
end

local MAX_BYTES_PER_UTF8_CODEPOINT = 6
local DISALLOWED_WHITESPACE = {"\n", "\r", "\t", "\v", "\f"}

if ChatSettings.DisallowedWhiteSpace then
	DISALLOWED_WHITESPACE = ChatSettings.DisallowedWhiteSpace
end

local function isMessageValidServer(msg)
    -- worst-case byte length check - fast for large strings
    if msg:len() > ChatSettings.MaximumMessageLength*MAX_BYTES_PER_UTF8_CODEPOINT then
        return false
    end
 
    -- check for invalid unicode sequence
    -- avoid normalizing first because utf8.nfcnormalize throws for invalid sequences
    if utf8.len(msg) == nil then
        return false
    end
 
    -- check codepoint length
    if utf8.len(utf8.nfcnormalize(msg)) > ChatSettings.MaximumMessageLength then
        return false
    end
 
    return true
end

local function CanUserChat(playerObj)
	if RunService:IsStudio() then
		return true
	end
	local success, canChat = pcall(function()
		return Chat:CanUserChatAsync(playerObj.UserId)
	end)
	return success and canChat
end

local function Run(ChatService)
	local function ValidateChatFunction(speakerName, message, channel)
		local speakerObj = ChatService:GetSpeaker(speakerName)
		local playerObj = speakerObj:GetPlayer()
		if not speakerObj then return false end
		if not playerObj then return false end

		if not RunService:IsStudio() and playerObj.UserId < 1 then
			return true
		end

		if not CanUserChat(playerObj) then
			speakerObj:SendSystemMessage(ChatLocalization:FormatMessageToSend(
				"GameChat_ChatMessageValidator_SettingsError",
				"Your chat settings prevent you from sending messages."
			), channel)
			return true
		end

		if not isMessageValidServer(message) then
			local localizedError = ChatLocalization:FormatMessageToSend(
				"GameChat_ChatMessageValidator_MaxLengthError",
				"Your message exceeds the maximum message length."
			)
			speakerObj:SendSystemMessage(localizedError, channel)
			return true
		end

		for _, whitespace in pairs(DISALLOWED_WHITESPACE) do
			if message:find(whitespace) then
				speakerObj:SendSystemMessage(ChatLocalization:FormatMessageToSend(
					"GameChat_ChatMessageValidator_WhitespaceError",
					"Your message contains whitespace that is not allowed."
				), channel)
				return true
			end
		end

		return false
	end

	ChatService:RegisterProcessCommandsFunction("message_validation", ValidateChatFunction, ChatConstants.VeryHighPriority)
end

return Run
--[=[
	Runs the given callback once an instance has been parented to the DataModel.

	This is used in particular for adding Gamepad support because Setting
	[GuiService.SelectedObject] requires that an instance be fully parented to
	the DM, which isn't always a guarantee with Roact.

	@within Modules
]=]


local function onInstanceLoaded(instance: Instance, callback: () -> ())
	task.spawn(function()
		while not instance:IsDescendantOf(game) do
			instance.AncestryChanged:Wait()
		end

		callback()
	end)
end

return onInstanceLoaded
-- create arrow


local p = Instance.new("Part")
p.formFactor = 2
p.Size = Vector3.new(1,.4,1)
p.Transparency = .5
p.BrickColor = BrickColor.new(119)
p.CanCollide = false
p.Locked = true
p.RotVelocity = Vector3.new(math.random(), math.random(), math.random()) * 10
local v = Vector3.new(script.Parent.Torso.CFrame.lookVector.x, 0, script.Parent.Torso.CFrame.lookVector.z)

p.CFrame = CFrame.new(script.Parent.Torso.CFrame.p + v * 8, v.unit)

local m = script.ArrowMesh:Clone() -- NASTY
m.Parent = p



local b = Instance.new("BodyPosition")
b.position = p.Position
b.Parent = p

local g = Instance.new("BodyGyro")
g.cframe = CFrame.new(Vector3.new(0,0,0), Vector3.new(0,0,1)) -- point North
g.maxTorque = Vector3.new(7e7, 7e7, 7e7)
g.Parent = p



p.Parent = game.Workspace







debris:AddItem(p, 10)


wait(5)

script.Parent = nil
--damage values



damagelimbs = {
	["Left Arm"] = 15,
	["Right Arm"] = 15,
	["Left Leg"] = 25,
	["Right Leg"] = 25,
	["Torso"] = 35,
	["HumanoidRootPart"] = 35,
	["UpperTorso"] = 35,
	["LowerTorso"] = 30,
	["Head"] = 80,
}
---////==========================================\\\---	
--To install the product, group them together with the switch. You can have multiple products installed and be controlled by one switch!--
--Products include, but not limited to: some fans, lights, alarms, etc. 
---////==========================================\\\---	


IsOn = false
function onClicked()
	if IsOn == false then
	IsOn = true	
 	script.Parent.Parent.Switch2.Transparency = 1
	script.Parent.Parent.Switch1.Transparency = 0
	script.Parent.Parent.IsOn.Value = true	
	elseif IsOn == true then
	IsOn = false	
	script.Parent.Parent.Switch2.Transparency = 0.1
	script.Parent.Parent.Switch1.Transparency = 1
	script.Parent.Parent.IsOn.Value = false
	end
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
---------------------------------------------------



This = script.Parent
Lift = This.Parent.Parent.Parent
CustomLabel = require(Lift.CustomLabel)
Characters = require(script.Characters)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Lift:WaitForChild("Floor").Changed:connect(function(floor)
  --custom indicator code--
  ChangeFloor(tostring(floor))
end)

function ChangeFloor(SF)
	if CustomText[tonumber(SF)] then
		SF = CustomText[tonumber(SF)]
	end
	SetDisplay(1,(string.len(SF) == 2 and SF:sub(1,1) or "NIL"))		
	SetDisplay(2,(string.len(SF) == 2 and SF:sub(2,2) or SF))
end



function SetDisplay(ID,CHAR)
	if This.Display:FindFirstChild("DIG"..ID) and Characters[CHAR] ~= nil then
 		for i,l in pairs(Characters[CHAR]) do 
			for r=1,7 do	
				This.Display["DIG"..ID]["D"..r].BrickColor = (l:sub(r,r) == "1" and BrickColor.new("Dark green") or BrickColor.new("Really black"))
			end
		end
	end
end
--fs.Reflectance = (val1.Value-120)*0.01
--bs.Reflectance = (val1.Value-120)*0.01


end
if val1.Value > 130 and val1.Value <= 135 then
ch1m.MaxVelocity = 0.65-(val1.Value-125)*0.005
ch2m.MaxVelocity = 0.65-(val1.Value-125)*0.005
ch3m.MaxVelocity = 0.65-(val1.Value-125)*0.005
fs.Transparency = 1-(val1.Value-120)*0.01
bs.Transparency = 1-(val1.Value-120)*0.01
-- Local functions



local function FormatThousands(n) -- Credit to http://richard.warburton.it
	local left, num, right = string.match(n, '^([^%d]*%d)(%d*)(.-)$')
	return left .. (num:reverse():gsub('(%d%d%d)','%1,'):reverse()) .. right
end

local function ConvertToShortNum(number)
	local exponent = math.floor(math.log10(number))
	
	-- Check if the number is too short	
	if (exponent <= 2) then
		return tostring(number)
	end
	-- Create a table for the symbols
	local symbols = {
		[1] = { "3", "k" }, [2] = { "6", "M" }, [3] = { "9", "G" },
		[4] = { "12", "T" }, [5] = { "15", "P" }, [6] = { "18", "E" },
		[7] = { "21", "Z" }, [8] = { "24", "Y" }	
	}
	
	local suffix = ""
	local currentExponent = 1
			
	-- Loop through the symbols
	for index = 1, #symbols do
		local info = symbols[index] 
		
		-- Check if the index is not the last entry in the table
		if (index ~= #symbols) then			
			-- Check if the symbol's exponent is less than the number's
			if (exponent >= tonumber(info[1])) then
				-- Change the last exponent and suffix to the current symbol's
				currentExponent = tonumber(info[1])
				suffix = info[2]
				
				-- Continue so that the loop does not break
				continue
			end
			
			-- Break as the symbol's exponent is greater than the numbers
			break
		end
	end
	
	-- Get the divisor and the final string
	local divisor = math.pow(10, currentExponent)	
	local str =	("%.2f%s"):format(number / divisor, suffix) 	
	
	-- Return the string						
	return str
end
-- (Hat Giver Script - Loaded.)



debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "Fairy Wings"
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle" 
		p.formFactor = 0
		p.Size = Vector3.new(2,2,2) 
		p.BottomSurface = 0 
		p.TopSurface = 0 
		p.Locked = true 
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentForward = Vector3.new(-0, -0, -1)
		h.AttachmentPos = Vector3.new(0, 1.45, -1.7)
		h.AttachmentRight = Vector3.new(1, 0, 0)
		h.AttachmentUp = Vector3.new(0, 1, 0)
		wait(5)
		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)
--[[
	p1 = Instance.new("Part")
	p1.FormFactor = "Custom"
	p1.Size = Vector3.new(0,0,0)
	p1.Name = "Aimer" 
	p1.Transparency = 0.5 
	mesh = Instance.new("BlockMesh")
	mesh.Parent = p1
	mesh.Scale = Vector3.new(0.5,0.5,8)
	mesh.Offset = Vector3.new(0,0,-1) 
	p1.Anchored = true
	p1.CanCollide = false
	p1.BrickColor = BrickColor.new("Institutional white")
	p2 = p1:clone()
	p3 = p1:clone()
	p4 = p1:clone()
	]]


enabled = true
down = false
mouser = game.Players.LocalPlayer:GetMouse()
-- New


function StringLabel.new(label)
	local newStringLabel = {}
	setmetatable(newStringLabel, StringLabel)
	
	newStringLabel._textLabel = label
	newStringLabel._textFrame = nil
	newStringLabel._characters = {}
	newStringLabel._characterLabels = {}
	newStringLabel._oldCharacterLabels = {}
	newStringLabel._lastChangedTime = 0
	newStringLabel._lastAbsolutePosition = nil
	newStringLabel._lastAbsoluteSize = nil
	newStringLabel._lastAbsolutePositionUpdateTime = 0
	newStringLabel._lastAbsoluteSizeUpdateTime = 0

	setup(newStringLabel)
	
	if label.Text ~= "" then
		if label.AbsoluteSize.X > 0 and label.AbsoluteSize.Y > 0 then
			update(newStringLabel)
		else
			delay(1, function()
				update(newStringLabel)
			end)
		end
	end
	
	return newStringLabel
end

return StringLabel
----


local FOV = 80				-- HOW MUCH YOU WANT CAMERA TO ZOOM IN.  70 IS DEFAULT.  SMALLER NUMBER = MORE ZOOM
local cooldowntime = .0		-- HOW LONG BEFORE THEY CAN ZOOM IN/OUT AGAIN.
local KEYBIND = Enum.KeyCode.R	-- CHANGE E TO WHATEVER KEY YOU WANT THEM TO PRESS TO ZOOM.
-- url : (string)
-- customHeaders : (dictionary<string, string>, optional)
-- returns : (promise<HttpResponse/HttpError>)


function Networking:GET(url, customHeaders)
	if not customHeaders then
		customHeaders = self._headers
	end

	assert(type(url) == "string", "expected 'url' to be a string")
	assert(type(customHeaders) == "table", "expected 'customHeaders' to be a dictionary")

	local httpFunc = function()
		return self._httpImpl:RequestAsync({
			Url = url,
			Method = "GET",
			Headers = customHeaders,
		})
	end

	return commonHttpHandler(url, httpFunc)
end
-- ROBLOX FIXME: these *should* return a function, but they don't. we're misaligned on types and implementation here


local function getReceivedColorForChalkInstance(chalkInstance: Chalk): any --: DiffOptionsColor
	-- return function(_: string): string
	local level = chalkInstance.level

	if level == 3 then
		return chalkInstance.rgb(bForeground3[1], bForeground3[2], bForeground3[3])
			.. chalkInstance.bgRgb(bBackground3[1], bBackground3[2], bBackground3[3])
	end

	if level == 2 then
		return chalkInstance.ansi256(bForeground2) .. chalkInstance.bgAnsi256(bBackground2)
	end

	return chalkInstance.cyan .. chalk.bgWhiteBright -- also known as teal
	-- end
end

local aSnapshotColor = getSnapshotColorForChalkInstance(chalk)
local bReceivedColor = getReceivedColorForChalkInstance(chalk)

local function noColor(string_: string)
	return string_
end

local HINT_ARG = "hint"
local SNAPSHOT_ARG = "snapshot"
local PROPERTIES_ARG = "properties"

local function matcherHintFromConfig(matchSnapshotConfig: MatchSnapshotConfig, isUpdatable: boolean): string
	local context = matchSnapshotConfig.context
	local hint = matchSnapshotConfig.hint
	local inlineSnapshot = matchSnapshotConfig.inlineSnapshot
	local matcherName = matchSnapshotConfig.matcherName
	local properties = matchSnapshotConfig.properties

	local options: MatcherHintOptions = {
		isNot = context.isNot,
		promise = context.promise,
	}
	if isUpdatable then
		options.receivedColor = bReceivedColor
	end

	local expectedArgument = ""

	if typeof(properties) == "table" then
		expectedArgument = PROPERTIES_ARG
		if isUpdatable then
			options.expectedColor = noColor
		end

		if typeof(hint) == "string" and #hint ~= 0 then
			options.secondArgument = HINT_ARG
			options.secondArgumentColor = BOLD_WEIGHT
		elseif typeof(inlineSnapshot) == "string" then
			options.secondArgument = SNAPSHOT_ARG
			if isUpdatable then
				options.secondArgumentColor = aSnapshotColor
			else
				options.secondArgumentColor = noColor
			end
		end
	else
		if typeof(hint) == "string" and #hint ~= 0 then
			expectedArgument = HINT_ARG
			options.expectedColor = BOLD_WEIGHT
		elseif typeof(inlineSnapshot) == "string" then
			expectedArgument = SNAPSHOT_ARG
			if isUpdatable then
				options.expectedColor = aSnapshotColor
			end
		end
	end

	return matcherHint(matcherName, nil, expectedArgument, options)
end
------------------
--| Clock Loop |--
------------------



while true do
	if Running and TimeObject.Value >= 0 then -- Change TimeObject's Value by how much time has passed
		local now = tick()
		local deltaTime = now - LastTime
		if CountingDown then
			TimeObject.Value = TimeObject.Value - deltaTime
		else
			TimeObject.Value = TimeObject.Value + deltaTime
		end
		LastTime = now
	end
	wait()
end
--
-- Verify that everything is where it should be


    assert(Self:FindFirstChild'Humanoid' ~= nil, 'Monster does not have a humanoid')
    assert(Settings ~= nil, 'Monster does not have a Configurations object')
	assert(Settings:FindFirstChild'MaximumDetectionDistance' ~= nil and Settings.MaximumDetectionDistance:IsA'NumberValue', 'Monster does not have a MaximumDetectionDistance (NumberValue) setting')
	assert(Settings:FindFirstChild'CanGiveUp' ~= nil and Settings.CanGiveUp:IsA'BoolValue', 'Monster does not have a CanGiveUp (BoolValue) setting')
	assert(Settings:FindFirstChild'CanRespawn' ~= nil and Settings.CanRespawn:IsA'BoolValue', 'Monster does not have a CanRespawn (BoolValue) setting')
	assert(Settings:FindFirstChild'SpawnPoint' ~= nil and Settings.SpawnPoint:IsA'Vector3Value', 'Monster does not have a SpawnPoint (Vector3Value) setting')
	assert(Settings:FindFirstChild'AutoDetectSpawnPoint' ~= nil and Settings.AutoDetectSpawnPoint:IsA'BoolValue', 'Monster does not have a AutoDetectSpawnPoint (BoolValue) setting')
	assert(Settings:FindFirstChild'FriendlyTeam' ~= nil and Settings.FriendlyTeam:IsA'BrickColorValue', 'Monster does not have a FriendlyTeam (BrickColorValue) setting')
	assert(Settings:FindFirstChild'AttackDamage' ~= nil and Settings.AttackDamage:IsA'NumberValue', 'Monster does not have a AttackDamage (NumberValue) setting')
	assert(Settings:FindFirstChild'AttackFrequency' ~= nil and Settings.AttackFrequency:IsA'NumberValue', 'Monster does not have a AttackFrequency (NumberValue) setting')
	assert(Settings:FindFirstChild'AttackRange' ~= nil and Settings.AttackRange:IsA'NumberValue', 'Monster does not have a AttackRange (NumberValue) setting')
    assert(Mind ~= nil, 'Monster does not have a Mind object')
	assert(Mind:FindFirstChild'CurrentTargetHumanoid' ~= nil and Mind.CurrentTargetHumanoid:IsA'ObjectValue', 'Monster does not have a CurrentTargetHumanoid (ObjectValue) mind setting')
assert(script:FindFirstChild'Attack' and script.Attack:IsA'Animation', 'Monster does not have a MonsterScript.Attack Animation')
--// DON'T EDIT BELOW



local target = plr.Character.HumanoidRootPart

local vel,pvel = script.Parent.Vel , script.Parent.PVel

local sensitivity = Vector3.new(sens,sens,sens)

local slurAngle = 0
local previousDesiredAngle = 0
local spinSpeed = 1 --ratio per second
local rotationOffset = -90 --in degrees
rotationOffset = math.rad(rotationOffset)

function Rotate()
	local vec = target.CFrame.lookVector
	local desiredAngle = math.atan2(vec.z, vec.x)
	if desiredAngle < -1.57 and previousDesiredAngle > 1.57 then
		slurAngle = slurAngle - math.pi*2
	elseif desiredAngle > 1.57 and previousDesiredAngle < -1.57 then
		slurAngle = slurAngle + math.pi*2
	end
	slurAngle = slurAngle*(1-spinSpeed) + desiredAngle*spinSpeed
	local a = slurAngle + rotationOffset
	previousDesiredAngle = desiredAngle
	script.Parent.F.Rotation = -math.deg(a)
end
while true do
	vel.Value = target.Velocity
	wait() --REQUIRED while loop
	pvel.Value = vel.Value
	vel.Value = target.Velocity
	
	local diff = script.Parent.Diff
	diff.Value = ((pvel.Value-vel.Value) * sensitivity)
	
	local xz = ((diff.Value.X)/20)
	xz = math.min(xz,.5) xz = math.max(xz,-.5)
	
	local yz = ((diff.Value.Z)/20)
	yz = math.min(yz,.5) yz = math.max(yz,-.5)
	Rotate()
	script.Parent.F.Dot.Position = UDim2.new(-xz+.5,-8,(-yz)+.5,-8)
	
	local mag = Vector2.new(diff.Value.X/2,diff.Value.Z/2).Magnitude
	if mag < min then mag = 0 end
	script.Parent.TL.Text = math.floor(math.min(mag,max)*100)/100 .. " G"
end
-- when player is added


game.Players.PlayerAdded:Connect( function(Player)
	Player.CharacterAdded:Connect( function(Char)
		-- get character geometry 
		for _,part in pairs(Char:GetChildren()) do
			if( part:IsA("BasePart") or part:IsA("MeshPart")) then
				-- set collision group
				PhysicsService:SetPartCollisionGroup(part,"Player")
			end
		end
	end)
end)
--[[*
 * Compile a regular expression from the `state` object returned by the
 * [parse()](#parse) method.
 *
 * @param {Object} `state`
 * @param {Object} `options`
 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
 * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
 * @return {RegExp}
 * @api public
 ]]



picomatch.compileRe = function(state: Object, options: Object?, returnOutput_: boolean?, returnState_: boolean?): RegExp
	local returnOutput = returnOutput_ or false
	local returnState = returnState_ or false

	if returnOutput == true then
		return state.output
	end

	local opts: Object = options or {}
	local prepend = if Boolean.toJSBoolean(opts.contains) then "" else "^"
	local append = if Boolean.toJSBoolean(opts.contains) then "" else "$"

	local source = ("%s(?:%s)%s"):format(prepend, tostring(state.output), append)
	if typeof(state) == "table" and state.negated == true then
		source = ("^(?!%s).*$"):format(source)
	end

	local regex = picomatch.toRegex(source, options)
	if returnState == true then
		regex.state = state
	end

	return regex
end
-----------------
--| Constants |--
-----------------



local BLAST_RADIUS = 50 -- Blast radius of the explosion
local BLAST_DAMAGE = 125 -- Amount of damage done to players
local BLAST_FORCE = 0 -- Amount of force applied to parts

local IGNORE_LIST = {rocket = 1, handle = 1, effect = 1, water = 1} -- Rocket will fly through things named these