Roblox/luau_corpus huggingface dataset:
--/Recoil Modification
module.camRecoil = {
	RecoilUp 		= .9
	,RecoilTilt 	= 1
	,RecoilLeft 	= 1.05
	,RecoilRight 	= 1.05
}

module.gunRecoil = {
	RecoilUp 		= .9
	,RecoilTilt 	= 1
	,RecoilLeft 	= 1.05
	,RecoilRight 	= 1.05
}

module.AimRecoilReduction = 1
module.AimSpreadReduction = 1

module.MinRecoilPower 			= 1
module.MaxRecoilPower 			= 1
module.RecoilPowerStepAmount 	= 1

module.MinSpread 				= 1.5
module.MaxSpread 				= 1				
module.AimInaccuracyStepAmount 	= 1
module.AimInaccuracyDecrease 	= 1
module.WalkMult 				= 1

module.MuzzleVelocityMod	 	= .75

return module
--[[**
	Links several instances to a janitor, which is then returned.
	@param [t:...Instance] ... All the instances you want linked.
	@returns [t:Janitor] A new janitor that can be used to manually disconnect all LinkToInstances.
**--]]
function Janitor.__index:LinkToInstances(...)
	local ManualCleanup = Janitor.new()
	for _, Object in ipairs({...}) do
		ManualCleanup:Add(self:LinkToInstance(Object, true), "Disconnect")
	end

	return ManualCleanup
end

return Janitor
--[[
	A function to return a unique ID, used for search results
]]

local lastId = 0

return function()
	lastId = lastId + 1
	return lastId
end
--Simultaneous Turn 2--: Simultaneous left turn for "SignalTurn1" and "SignalTurn1a" during a red light for all. 
--Next cycle, Simultaneous left turn for "SignalTurn2" and "SignalTurn2a" during a red light for all.
--USES: Signal1, Signal1a, Signal2, Signal2a, Turn1, Turn1a, Turn2, Turn2a
while true do
	PedValues = script.Parent.Parent.PedValues
	SignalValues = script.Parent.Parent.SignalValues
	TurnValues = script.Parent.Parent.TurnValues
--local HoldClose = Humanoid:LoadAnimation(AnimationsFolder.idleclosed)
--local Hold = Humanoid:LoadAnimation(AnimationsFolder.idle)
--local Open = Humanoid:LoadAnimation(AnimationsFolder.open)
--local Close = Humanoid:LoadAnimation(AnimationsFolder.close)
--local Relight = Humanoid:LoadAnimation(AnimationsFolder.relight)

script.Parent.Activated:Connect(function()
	if not DB and DB2 then
		DB = true
		DB2 = false
-- / Round Assets / --
local RoundAssets = game.ServerStorage.RoundAssets

local Scripts = RoundAssets.Scripts
--[[
	Roblox avatars are a nightmare to physically simulate, either because of innate clipping
	or because package hitboxes are insane. Don't believe me?
	
	- https://i.imgur.com/471ffsb.png (bundle id=475)
	- https://i.imgur.com/fRpkSdS.png (bundle id=429)
	- https://i.imgur.com/k07QVWR.png (bundle id=162)
	- https://i.imgur.com/F2lo4Te.jpg (bundle id=168)
	- https://i.imgur.com/je4GEas.png (bundle id=475)
	- https://i.imgur.com/0oUu1ra.png (bundle id=192)
	
	So we have to disable collisions between a bunch of parts to get them to simulate without
	spazzing out due to overconstraints.
	
	We don't want to disable all collision, as that would result in ugly things like the
	legs phasing through each other, or a hand phasing through a leg. Specifically looking
	at Roblox bundles, the torso clipping is by far the worst (e.g. Deathspeaker UpperTorso
	clips with EVERY OTHER BODY PART), with next up being nearby ballsocketish joints (e.g.
	a shoulder and the head, or the two upper legs). We can't just hardcode limb names
	and get it over with though (Humanoids are already bad enough at this...) if we want
	ragdolls to work with arbitrary characters, so my solution was:
	
	"Parent" limbs (e.g. torso is a parent to the head, arms, and legs) should not collide
	with their children. This solves the torso problem in a generic way that should work with
	most characters.
	
	Limb "roots" (e.g. shoulder, head, hips) can't collide with each other. Again, this solves
	the problems we had with Roblox bundles while still working with arbitrary characters
	
	Maybe this approach won't work for 100% of characters, but hopefully it should work in
	most cases.
--]]

local getLastWordFromPascaleCase = require(script.Parent:WaitForChild("getLastWordFromPascalCase"))
--[[
	Recalculates this Computed's cached value and dependencies.
	Returns true if it changed, or false if it's identical.
]]
function class:update(): boolean
	-- remove this object from its dependencies' dependent sets
	for dependency in pairs(self.dependencySet) do
		dependency.dependentSet[self] = nil
	end

	-- we need to create a new, empty dependency set to capture dependencies
	-- into, but in case there's an error, we want to restore our old set of
	-- dependencies. by using this table-swapping solution, we can avoid the
	-- overhead of allocating new tables each update.
	self._oldDependencySet, self.dependencySet = self.dependencySet, self._oldDependencySet
	table.clear(self.dependencySet)

	local ok, newValue = captureDependencies(self.dependencySet, self._callback)

	if ok then
		local oldValue = self._value
		self._value = newValue

		-- add this object to the dependencies' dependent sets
		for dependency in pairs(self.dependencySet) do
			dependency.dependentSet[self] = true
		end

		return oldValue ~= newValue
	else
		-- this needs to be non-fatal, because otherwise it'd disrupt the
		-- update process
		logErrorNonFatal("computedCallbackError", newValue)

		-- restore old dependencies, because the new dependencies may be corrupt
		self._oldDependencySet, self.dependencySet = self.dependencySet, self._oldDependencySet

		-- restore this object in the dependencies' dependent sets
		for dependency in pairs(self.dependencySet) do
			dependency.dependentSet[self] = true
		end

		return false
	end
end

local function Computed<T>(callback: () -> T): Types.Computed<T>
	local self = setmetatable({
		type = "State",
		kind = "Computed",
		dependencySet = {},
		-- if we held strong references to the dependents, then they wouldn't be
		-- able to get garbage collected when they fall out of scope
		dependentSet = setmetatable({}, WEAK_KEYS_METATABLE),
		_oldDependencySet = {},
		_callback = callback,
		_value = nil,
	}, CLASS_METATABLE)

	initDependency(self)
	self:update()

	return self
end

return Computed
--- VARIABLES/CONSTANTS ---

HitEntities = {}
AnimationStep = 1
-- / Workspace Assets / --
local GameHolder = game.Workspace.GameHolder
local GamemodesMapHolder = GameHolder.GamemodesMapHolder
local GameAssetsHolder = GameHolder.GameAssetsHolder

local Lobby = game.Workspace.Lobby

 -- / Game Assets / --
local GameAssets = game.ServerStorage.GameAssets
--[[ if your changing the DataStore name from LB 
		to anything else you should change it 
		inside the LeaderboardHandler too
	]]--
local leaderboardDS =  ds:GetOrderedDataStore("LB")


players.PlayerAdded:Connect(function(plr)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"
	leaderstats.Parent = plr
	
	local Cash = Instance.new("NumberValue")
	Cash.Name = "Cash"
	Cash.Parent = leaderstats
	
	local Coins = Instance.new("NumberValue")
	Coins.Name = "C"
	Coins.Parent = leaderstats
	
end)


while true do
	
	for i , v in pairs(players:GetPlayers()) do
		local succ , errmsg = pcall(function()
			-- saving the Coins value with the player's userid as the key
			leaderboardDS:SetAsync(v.UserId , v.leaderstats.Coins.Value)
		end)
	end	
	-- recommend waiting for a longer time
	task.wait(220)
end
--[[Drivetrain]]	
	Tune.Config			= "RWD"		--"FWD" , "RWD" , "AWD"
	
	--Differential Settings	
	Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 50		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 15		-- 1 - 100%
	Tune.RDiffLockThres	= 50		-- 0 - 100%
	Tune.CDiffSlipThres	= 50		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 50		-- 0 - 100%				[AWD Only]
	
	--Traction Control Settings
	Tune.TCSEnabled		= false		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)
-- Function to periodically save player data
local function autoSave()
	while wait(AUTOSAVE_INTERVAL) do
		print("Saving")
		for playerUserId, data in pairs(sessionData) do
			savePlayerData(playerUserId)
		end
	end
end
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 1 -- cooldown for use of the tool again

BoneModelName = "Ray zone" -- name the zone model

HumanoidName = "Humanoid"-- the name of player or mob u want to damage
--Made by Luckymaxer


Tool = script.Parent
Main = Tool:WaitForChild("Main")
FX = Main:WaitForChild("FX")
Handle = Tool:WaitForChild("Handle")
Light = Handle:WaitForChild("Light")
Recoil = script:WaitForChild("Recoil")

Players = game:GetService("Players")
Debris = game:GetService("Debris")

CastLaser = Tool:WaitForChild("CastLaser"):Clone()

Modules = Tool:WaitForChild("Modules")
Functions = require(Modules:WaitForChild("Functions"))
BaseUrl = "http://www.roblox.com/asset/?id="

ConfigurationBin = Tool:WaitForChild("Configuration")
Configuration = {}
Configuration = Functions.CreateConfiguration(ConfigurationBin, Configuration)

ToolEquipped = false

Remotes = Tool:WaitForChild("Remotes")

Sounds = {
	Fire = Handle:WaitForChild("Fire"),
	HeadShot = Handle:WaitForChild("HeadShot"),
}

BasePart = Instance.new("Part")
BasePart.Shape = Enum.PartType.Block
BasePart.Material = Enum.Material.Plastic
BasePart.TopSurface = Enum.SurfaceType.Smooth
BasePart.BottomSurface = Enum.SurfaceType.Smooth
BasePart.FormFactor = Enum.FormFactor.Custom
BasePart.Size = Vector3.new(0.2, 0.2, 0.2)
BasePart.CanCollide = true
BasePart.Locked = true
BasePart.Anchored = false

BaseRay = BasePart:Clone()
BaseRay.Name = "Ray"
BaseRay.BrickColor = BrickColor.new("Bright yellow")
BaseRay.Material = Enum.Material.SmoothPlastic
BaseRay.Size = Vector3.new(0.2, 0.2, 0.2)
BaseRay.Anchored = true
BaseRay.CanCollide = false
------------------------------------------------------------------------------------
local WaitTime = 15	-- Change this to the amount of time it takes for the button to re-enable.
local modelname = "Model"	-- If your model is not named this, then make the purple words the same name as the model!
--------------------------------------------------------------------------

local _WHEELTUNE = {
																		--[[	
			SS6 Presets
	[Eco]		
		WearSpeed = 1,
		TargetFriction = .7,
		MinFriction = .1,
	[Road]		
		WearSpeed = 2,
		TargetFriction = .7,
		MinFriction = .1,
	[Sport]		
		WearSpeed = 3,
		TargetFriction = .79,
		MinFriction = .1,											]]

	TireWearOn 		= true	,
	
	--Friction and Wear
	FWearSpeed		= .3	,
	FTargetFriction	= 0.79	,
	FMinFriction 	= .5	,
	
	RWearSpeed		= .3	,
	RTargetFriction	= 0.79	,
	RMinFriction	= .5	,
	
	--Tire Slip
	TCSOffRatio		= 1	,
	WheelLockRatio	= 1/2	,	--SS6 Default = 1/4
	WheelspinRatio	= 1/1.1	,	--SS6 Default = 1/1.2
	
	--Wheel Properties
	FFrictionWeight	= 1		,	--SS6 Default = 1
	RFrictionWeight	= 1		,	--SS6 Default = 1
	FLgcyFrWeight	= 10	,
	RLgcyFrWeight	= 10	,
	
	FElasticity		= 0		,	--SS6 Default = .5
	RElasticity		= 0		,	--SS6 Default = .5
	FLgcyElasticity	= 0		,
	RLgcyElasticity	= 0		,
	
	FElastWeight	= 1		,	--SS6 Default = 1
	RElastWeight	= 1		,	--SS6 Default = 1
	FLgcyElWeight	= 10	,
	RLgcyElWeight	= 10	,
	
	--Wear Regen
	RegenSpeed		= 3.6		--SS6 Default = 3.6
}
--	local Hover = function(bool)
--		local properties = { -- properties to affect when hovering, on and off modes
--				["Transparency"] = {on = .75,off = 0},
--				["ZIndex"] = {on = 100,off = 1},
--			}
--			
--		for property,values in next,properties do
--			frame.ImageLabel[property] = values[(bool and "on") or "off"]
--		end
--	end
--	
--	frame.MouseEnter:connect(function()
--		Hover(true)
--	end)
--	frame.MouseLeave:connect(function()
--		Hover(false)
--	end)
	
	frame.TextButton.Activated:connect(function()
		OpenList(frame.Name)
	end)
end
---
if 	script.Parent.Parent.Parent.IsOn.Value then
	script.Parent.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
end

script.Parent.Parent.Parent.IsOn.Changed:connect(function()
	if script.Parent.Parent.Parent.IsOn.Value then
		script.Parent.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
	end
end)
	
	script.Parent.MouseButton1Click:connect(function()
		if hinge.DesiredAngle == 0 then
			sound.SoundId = "rbxassetid://278329638"
			sound:Play()
			wait(.00000001)
			hinge.DesiredAngle = -.45
		else
			hinge.DesiredAngle = 0
			sound.SoundId = "rbxassetid://278329638"
			sound:Play()
		end
	end)
----------------------------------------------------------------------------------------------------
-----------------=[ General ]=----------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	 TeamKill = true					--- Enable TeamKill?
	,TeamDamageMultiplier = 0.4			--- Between 0-1 | This will make you cause less damage if you hit your teammate
	
	,ReplicatedBullets = true			--- Keep in mind that some bullets will pass through surfaces...
	
	,AntiBunnyHop = true				--- Enable anti bunny hop system?
	,JumpCoolDown = 3					--- Seconds before you can jump again
	,JumpPower = 50						--- Jump power, default is 50
	
	,RealisticLaser = false				--- True = Laser line is invisible
	,ReplicatedLaser = true				
	,ReplicatedFlashlight = true
	
	,EnableRagdoll = true				--- Enable ragdoll death?
	,TeamTags = true					--- Aaaaaaa
	,HitmarkerSound = false				--- GGWP MLG 360 NO SCOPE xD
-- Generic Roblox DataType lerp function.
local function RobloxLerp(V0, V1)
	return function(DeltaTime)
		return V0:Lerp(V1, DeltaTime)
	end
end

local function Lerp(Start, Finish, Alpha)
	return Start + Alpha * (Finish - Start)
end

local function SortByTime(a, b)
	return a.Time < b.Time
end

local Lerps = setmetatable({
	boolean = function(V0, V1)
		return function(DeltaTime)
			if DeltaTime < 0.5 then
				return V0
			else
				return V1
			end
		end
	end;

	number = function(V0, V1)
		local Delta = V1 - V0
		return function(DeltaTime)
			return V0 + Delta * DeltaTime
		end
	end;

	string = function(V0, V1)
		local RegularString = false

		local N0, D do
			local Sign0, H0, M0, S0 = string.match(V0, "^([+-]?)(%d*):[+-]?(%d*):[+-]?(%d*)$")
			local Sign1, H1, M1, S1 = string.match(V1, "^([+-]?)(%d*):[+-]?(%d*):[+-]?(%d*)$")
			if Sign0 and Sign1 then
				N0 = 3600 * (tonumber(H0) or 0) + 60 * (tonumber(M0) or 0) + (tonumber(S0) or 0)
				local N1 = 3600 * (tonumber(H1) or 0) + 60 * (tonumber(M1) or 0) + (tonumber(S1) or 0)
				if Sign0 == "-" then
					N0 = -N0
				end

				D = (43200 + (Sign1 ~= "-" and N1 or -N1) - N0) % 86400 - 43200
			else
				RegularString = true
			end
		end

		if RegularString then
			local Length = #V1
			return function(DeltaTime)
				local Alpha = 1 + Length * DeltaTime
				return string.sub(V1, 1, Alpha < Length and Alpha or Length)
			end
		else
			return function(DeltaTime)
				local FS = (N0 + D * DeltaTime) % 86400
				local S = FS >= 0 and FS or 0 - FS
				return string.format(
					FS < 0 and "-%.2u:%.2u:%.2u" or "%.2u:%.2u:%.2u",
					(S - S % 3600) / 3600,
					(S % 3600 - S % 60) / 60,
					S % 60
				)
			end
		end
	end;

	CFrame = RobloxLerp;
	Color3 = function(C0, C1)
--edit the function below to return true when you want this response/prompt to be valid
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	return plrData.Classes.Base.Scholar.XP.Value < 0  
end
--[[
	Returns the room associated with the window
]]
function RoomManager.getRoomByWindow(windowPart)
	local rooms = RoomManager.getRooms()

	return TableUtils.find(
		rooms,
		function(room)
			if room:hasWindow(windowPart) then
				return true
			end
		end
	)
end
--[[
	
	Returns an english translation of time (integer)
	
	EX: 1800 = "30 Minutes"
	
	Functions.TimeString(
		time,					<-- |REQ| 	Time integer (tick, os.time)
	)
	
--]]



return function(t)
	--- Split up time to several segments
	local days = _L.Functions.Round(t / 60 / 60 / 24 - 0.5)
	local hours = _L.Functions.Round(t / 60 / 60 % 24 - 0.5)
	local minutes = _L.Functions.Round(t / 60 % 60 - 0.5)
	local seconds = _L.Functions.Round(t % 60)
	
	--- Final string to be returned
	local str = ""
	
	--- Convert to a translated string based on appropriate parameters
	if days >= 1 then
		str = days .. (days > 1 and " Days" or " Day")
	elseif hours >= 1 then
		str = hours .. (hours > 1 and " Hours" or " Hour")
	elseif minutes >= 1 then
		str = minutes .. (minutes > 1 and " Minutes" or " Minute")
	else
		str = seconds .. (seconds > 1 and " Seconds" or " Second")
	end
	
	--
	return str
end
-- Arm And Leg

character.LeftUpperArm.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.RightUpperArm.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.RightUpperLeg.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.LeftUpperLeg.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.Head.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.RightLowerLeg.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.RightLowerArm.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.LeftLowerLeg.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.LeftLowerArm.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.RightHand.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.LeftHand.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.RightFoot.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
character.LeftFoot.CustomPhysicalProperties = PhysicalProperties.new(Ds,Fr,El,FrW,ElW)
--[[
	Function called upon entering the state - cleans up the previous game
]]
function ServerPostGame.onEnter(stateMachine, event, from, to)
	SystemManager.destroySystems()

	for _, child in pairs(workspace.Tools:GetChildren()) do
		child:Destroy()
	end

	wait(8)
	stateMachine:beginNextGame()
end
--edit the below function to execute code when this response is chosen OR this prompt is shown
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	plrData.Money.Gold.Value = plrData.Money.Gold.Value - 100
	plrData.Classes.Base.Smasher.HeavyWeaponTraining.Value = true
end
--[=[
	@class RxValueBaseUtils
]=]

local require = require(script.Parent.loader).load(script)

local RxInstanceUtils = require("RxInstanceUtils")
local RxBrioUtils = require("RxBrioUtils")

local RxValueBaseUtils = {}
------------------------------------------------------------------------
-- dump constant pool from function prototype
-- * bvalue(o), nvalue(o) and rawtsvalue(o) macros removed
------------------------------------------------------------------------
function luaU:DumpConstants(f, D)
  local n = f.sizek
  self:DumpInt(n, D)
  for i = 0, n - 1 do
    local o = f.k[i]  -- TValue
    local tt = self:ttype(o)
    self:DumpChar(tt, D)
    if tt == self.LUA_TNIL then
    elseif tt == self.LUA_TBOOLEAN then
      self:DumpChar(o.value and 1 or 0, D)
    elseif tt == self.LUA_TNUMBER then
      self:DumpNumber(o.value, D)
    elseif tt == self.LUA_TSTRING then
      self:DumpString(o.value, D)
    else
      --lua_assert(0)  -- cannot happen
    end
  end
  n = f.sizep
  self:DumpInt(n, D)
  for i = 0, n - 1 do
    self:DumpFunction(f.p[i], f.source, D)
  end
end
-- @specs https://docs.microsoft.com/en-us/windows/uwp/design/motion/timing-and-easing
local UWPAccelerate = Bezier(0.7, 0, 1, 0.5)
-- Function to enable dragging for an image button
local function enableDragging(button)
	local dragging = false
	local dragStartPos
	local offset
	local function onMouseButton1Down(x, y)
		dragging = true
		dragStartPos = button.AbsolutePosition
		offset = Vector2.new(x, y) - dragStartPos
	end
	local function onMouseMove(x, y)
		if dragging then
			button.Position = UDim2.new(0, x - offset.X, 0, y - offset.Y)
		end
	end
	local function onMouseButton1Up(x, y)
		dragging = false
	end
	button.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			onMouseButton1Down(input.Position.X, input.Position.Y)
		end
	end)
	button.InputChanged:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseMovement then
			onMouseMove(input.Position.X, input.Position.Y)
		end
	end)
	button.InputEnded:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			onMouseButton1Up(input.Position.X, input.Position.Y)
		end
	end)
end
--!strict
return {
	charCodeAt = require(script.charCodeAt),
	endsWith = require(script.endsWith),
	findOr = require(script.findOr),
	includes = require(script.includes),
	lastIndexOf = require(script.lastIndexOf),
	slice = require(script.slice),
	split = require(script.split),
	startsWith = require(script.startsWith),
	substr = require(script.substr),
	trim = require(script.trim),
	trimEnd = require(script.trimEnd),
	trimStart = require(script.trimStart),
	-- aliases for trimEnd and trimStart
	trimRight = require(script.trimEnd),
	trimLeft = require(script.trimStart),
}
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {};
local l__ReplicatedStorage__2 = game.ReplicatedStorage;
local v3 = require(game.ReplicatedStorage.Modules.Lightning);
local v4 = require(game.ReplicatedStorage.Modules.Xeno);
local v5 = require(game.ReplicatedStorage.Modules.CameraShaker);
local l__TweenService__6 = game.TweenService;
local l__Debris__7 = game.Debris;
function v1.RunStompFx(p1, p2, p3, p4)
	local v8 = game.ReplicatedStorage.KillFX.Kizzaro.Kizaru:Clone();
	v8.Parent = workspace.Ignored.Animations;
	v8.HumanoidRootPart.CFrame = CFrame.new(p2.Position) * CFrame.new(-5, 80, 20);
	game.Debris:AddItem(v8, 4);
	local v9 = v8.AnimationController:LoadAnimation(v8.Animation);
	v9:Play();
	v9:AdjustSpeed(1.2);
	local u1 = nil;
	u1 = v9:GetMarkerReachedSignal("start"):Connect(function()
		u1:Disconnect();
		v8.Part.a.Enabled = true;
		v8.Part.b.Enabled = true;
		v8.Part.Sound:Play();
		local u2 = nil;
		u2 = v9:GetMarkerReachedSignal("hit"):Connect(function()
			v8.Part.a.Enabled = false;
			v8.Part.b.Enabled = false;
			local v10 = game.ReplicatedStorage.KillFX.Kizzaro.HitPart:Clone();
			v10.Parent = workspace.Ignored.Animations;
			v10.Position = p2.Position;
			game.Debris:AddItem(v10, 2);
			v10.Sound:Play();
			task.delay(0.25, function()
				for v11, v12 in pairs(v10.Attachment:GetChildren()) do
					v12.Enabled = false;
				end;
			end);
			u2:Disconnect();
		end);
	end);
	return nil;
end;
return v1;