Pinkstack/roblox-luau-corpus-text huggingface dataset:
------------------------------------------------------------------------
-- the following priority table consists of pairs of left/right values
-- for binary operators (was a static const struct); grep for ORDER OPR
-- * the following struct is replaced:
--   static const struct {
--     lu_byte left;  /* left priority for each binary operator */
--     lu_byte right; /* right priority */
--   } priority[] = {  /* ORDER OPR */
------------------------------------------------------------------------


luaY.priority = {
  {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, -- `+' `-' `/' `%'
  {10, 9}, {5, 4},                 -- power and concat (right associative)
  {3, 3}, {3, 3},                  -- equality
  {3, 3}, {3, 3}, {3, 3}, {3, 3},  -- order
  {2, 2}, {1, 1}                   -- logical (and/or)
}

luaY.UNARY_PRIORITY = 8  -- priority for unary operators
--[=[
	Determines if the passed object is a Janitor. This checks the metatable directly.

	@param Object any -- The object you are checking.
	@return boolean -- `true` if `Object` is a Janitor.
]=]


function Janitor.Is(Object: any): boolean
	return type(Object) == "table" and getmetatable(Object) == Janitor
end

type StringOrTrue = string | boolean
--- Active


script.Parent.OnServerEvent:Connect(function(Player)
	local Projectile = game.ReplicatedStorage.Dragon.SkillZ.LightFX:Clone()
	local BV = Instance.new("BodyVelocity",Projectile)
	BV.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
	BV.Velocity = Player.Character.HumanoidRootPart.CFrame.LookVector * 0
	Projectile.Parent = workspace
	Projectile.CanCollide = false
	Projectile.Anchored = false
	Projectile.CFrame = Player.Character.HumanoidRootPart.CFrame * CFrame.new(0,2,0) * CFrame.fromEulerAnglesXYZ(0,0,0)
	Projectile.Touched:Connect(function(hit)
	if hit.Parent:FindFirstChild("Humanoid") and hit.Parent.Name ~= Player.Name and hit.Parent:WaitForChild("Humanoid") ~= nil and hit.Parent:WaitForChild("Humanoid").Health ~= 0 and not hit.Parent:FindFirstChild("AlreadyHit") then
			local Check = Instance.new("IntValue", hit.Parent)
				Check.Name = "AlreadyHit"
				game.Debris:AddItem(Check ,1)
			local VCharacter = game.Workspace:FindFirstChild(Player.Name)
	        local vPlayer = game.Players:GetPlayerFromCharacter(VCharacter)
	        local Humanoid = hit.Parent:WaitForChild("Humanoid")
			Humanoid:TakeDamage(10)
			tagHumanoid(hit.Parent:FindFirstChild("Humanoid"),vPlayer)
			wait(0.05)
			untagHumanoid(hit.Parent:FindFirstChild("Humanoid"))	
		end
	end)
	wait(3)
	BV:Destroy()
	Projectile.Anchored = false
	wait(2)
	Projectile.CanCollide = false
	wait(1)
	for i = 1,5 do
				wait(0.025)
				Projectile.Transparency = Projectile.Transparency + 0.1
				Projectile.Texture1.Transparency = Projectile.Texture1.Transparency + 0.1
				Projectile.Texture2.Transparency = Projectile.Texture2.Transparency + 0.1
			end
    Projectile:Destroy()
    end)
-------- OMG HAX



r = game:service("RunService")


local damage = 0


local slash_damage = 0


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


local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "http://www.roblox.com/Asset/?ID=12135982"
SlashSound.Parent = sword
SlashSound.Volume = 0

function isTurbo(character)
	return character:FindFirstChild("PaperHat") ~= nil
end


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
				local d = damage
				if (isTurbo(vCharacter) == true) then d = d * 2.5 end
				tagHumanoid(humanoid, vPlayer)
				humanoid:TakeDamage(d)
				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 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



Tool.Enabled = true

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

	

	attack()

	wait(.4)

	Tool.Enabled = true
end


function onEquipped()
	SlashSound:play()
end


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


connection = sword.Touched:connect(blow)
--Rear Suspension


Tune.RSusDamping	= 500		-- Spring Dampening
Tune.RSusStiffness	= 9000		-- Spring Force
Tune.RSusLength		= 2			-- Suspension length (in studs)
Tune.RSusMaxExt		= .3		-- Max Extension Travel (in studs)
Tune.RSusMaxComp	= .1		-- Max Compression Travel (in studs)
Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

Tune.RWsBoneLen		= 5			-- Wishbone Length
Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	--[[Lateral]]		-.4		,	-- positive = outward
	--[[Vertical]]		-.5		,	-- positive = upward
	--[[Forward]]		0		}	-- positive = forward
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------


function luaK:exp2RK(fs, e)
  self:exp2val(fs, e)
  local k = e.k
  if k == "VKNUM" or k == "VTRUE" or k == "VFALSE" or k == "VNIL" then
    if fs.nk <= luaP.MAXINDEXRK then  -- constant fit in RK operand?
      -- converted from a 2-deep ternary operator expression
      if e.k == "VNIL" then
        e.info = self:nilK(fs)
      else
        e.info = (e.k == "VKNUM") and self:numberK(fs, e.nval)
                                  or self:boolK(fs, e.k == "VTRUE")
      end
      e.k = "VK"
      return luaP:RKASK(e.info)
    end
  elseif k == "VK" then
    if e.info <= luaP.MAXINDEXRK then  -- constant fit in argC?
      return luaP:RKASK(e.info)
    end
  else
    -- default
  end
  -- not a constant in the right range: put it in a register
  return self:exp2anyreg(fs, e)
end
--Tune--


local StockHP = 500	--Power output desmos: https://www.desmos.com/calculator/wezfve8j90 (does not come with torque curve)
local TurboCount = 2	--(1 = SingleTurbo),(2 = TwinTurbo),(if bigger then it will default to 2 turbos)
local TurboSize = 65	--bigger the turbo, the more lag it has
local WasteGatePressure = 12	--Max PSI for each turbo (if twin and running 10 PSI, thats 10PSI for each turbo)
local CompressionRatio = 9/1	--Compression of your car (look up the compression of the engine you are running)
local AntiLag = true	--if true basically keeps the turbo spooled up so less lag

local BOV_Loudness = 1	--volume of the BOV (not exact volume so you kinda have to experiment with it)
local TurboLoudness = 1 --volume of the Turbo (not exact volume so you kinda have to experiment with it also)
--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 ClassInformationTable = require(game.ReplicatedStorage.Source.Modules.CharacterScripts.Classes.ClassInformation)
	return ClassInformationTable:GetClassFolder(player,"Warlock").FastCasting.Value and ClassInformationTable:GetClassFolder(player,"Warlock").PocketStep.Value ~= true
end
-- Returns whether the inputted status passes the TextFilter, otherwise also returns an error


function UpdateProfileRemoteFunction.OnServerInvoke(playerFiring, playerSelected, statusText)
	local filteredStatus = filterText(statusText, playerSelected.UserId, playerFiring.UserId)
	if filteredStatus == statusText then
		playerFiring:SetAttribute("status", filteredStatus)
	end
	return { success = filteredStatus == statusText }
end
--[[
local frame = game.StarterGui.HDAdminGUIs.MainFrame
for a,b in pairs(frame:GetDescendants()) do
	if b:IsA("GuiObject") then
		b.ZIndex = b.ZIndex + 10
	end
end

game:GetService("StarterGui"):SetCoreGuiEnabled(Enum.CoreGuiType.Chat, false)	
game:GetService("StarterGui"):SetCore("TopbarEnabled", false)

--]]





return module
--- All the (>level 2) services, all at EOS to same memory and typing strokes :D


Services.AssetService = 						game:GetService("AssetService")
Services.BadgeService = 						game:GetService("BadgeService")
Services.CollectionService = 					game:GetService("CollectionService")
Services.ContextActionService = 				game:GetService("ContextActionService")
Services.ControllerService = 					game:GetService("ControllerService")
Services.DataStoreService = 					 require(game:GetService("ReplicatedStorage").DataStoreService)
Services.FriendService = 						game:GetService("FriendService")
Services.GamepadService = 						game:GetService("GamepadService")
Services.GamePassService = 						game:GetService("GamePassService")
Services.GroupService = 						game:GetService("GroupService")
Services.GuiService = 							game:GetService("GuiService")
Services.HapticService = 						game:GetService("HapticService")
Services.HttpService = 							game:GetService("HttpService")
Services.InsertService = 						game:GetService("InsertService")
Services.JointsService = 						game:GetService("JointsService")
Services.KeyboardService = 						game:GetService("KeyboardService")
Services.LocalizationService = 					game:GetService("LocalizationService")
Services.LoginService = 						game:GetService("LoginService")
Services.LogService = 							game:GetService("LogService")
Services.MarketplaceService = 					game:GetService("MarketplaceService")
Services.MouseService = 						game:GetService("MouseService")
Services.MessagingService =                     game:GetService("MessagingService")
Services.NotificationService = 					game:GetService("NotificationService")
Services.PathfindingService = 					game:GetService("PathfindingService")
Services.PhysicsService = 						game:GetService("PhysicsService")
Services.PointsService = 						game:GetService("PointsService")
Services.RunService = 							game:GetService("RunService")
Services.SoundService = 						game:GetService("SoundService")
Services.TeleportService = 						game:GetService("TeleportService")
Services.TextService = 							game:GetService("TextService")
Services.TweenService = 						game:GetService("TweenService")
Services.TouchInputService = 					game:GetService("TouchInputService")
Services.UserInputService = 					game:GetService("UserInputService")
Services.VRService = 							game:GetService("VRService")
--// SS3 controls for AC6 by Itzt, originally for 2014 Infiniti QX80. i don't know how to tune ac lol


 
wait(0.1)
local player = game.Players.LocalPlayer
local HUB = script.Parent.HUB
local HUB2 = script.Parent.HUB2
local limitButton = HUB.Name
local FE = game.Workspace.FilteringEnabled
local lightOn = false
local Camera = game.Workspace.CurrentCamera
local cam = script.Parent.nxtcam.Value
local carSeat = script.Parent.CarSeat.Value
local mouse = game.Players.LocalPlayer:GetMouse()
local windows = false
local handler = carSeat:WaitForChild('Filter')
local winfob = HUB.Parent.Music
local pal = false
local palpal = HUB.Parent.Palette
local red = 0
local green = 0
local blue = 1
local debounce = false

script.Parent.Infotainment.Main.User.Text = "Hello, "..(player.Name)

local scr = false
--(FL.RotVelocity.Magnitude+FR.RotVelocity.Magnitude+RL.RotVelocity.Magnitude+RR.RotVelocity.Magnitude+(speed/1.33034))/5



while wait() do
speed = carSeat.Velocity.Magnitude
power = 0
average = 10*(1-(carSeat.Storage.BrakeBias.Value/100))
track = carSeat.Velocity.Unit*carSeat.CFrame.lookVector
	slipDetection = track.X+track.Z
	
	Right = (carSeat.Parent.Parent.Wheels.RR.Wheel.Velocity.Magnitude+carSeat.Parent.Parent.Wheels.FR.Wheel.Velocity.Magnitude)/2
	Left = (carSeat.Parent.Parent.Wheels.RL.Wheel.Velocity.Magnitude+carSeat.Parent.Parent.Wheels.FL.Wheel.Velocity.Magnitude)/2
	
	if Right > Left then
	left = true
	else
		left = false
	end
	
if script.OVERRIDE.Value == false then	
if carSeat.Storage.ASC.Value == true then
if speed > 45 then
		if carSeat.Steer ~= 0 then
			if slipDetection < 0.995 and left == false then
						script.Toggle.Value = true
						carSeat.Storage.TC.Value = true
			else
				script.Toggle.Value = false
				carSeat.Storage.TC.Value = false
			end
		
		elseif carSeat.Steer == 0 then
			if slipDetection < 0.99984 and left == false then
			--carSeat.Storage.TC.Value = true
			--script.Toggle.Value = true
			else 
				script.Toggle.Value = false
				carSeat.Storage.TC.Value = false
			end
		
		else 
			script.Toggle.Value = false
		end
		else script.Toggle.Value = false
end
-- Maid class



local destructors = {
	['function'] = function(item)
		item()
	end;
	['RBXScriptConnection'] = function(item)
		item:Disconnect()
	end;
	['Instance'] = function(item)
		item:Destroy()
	end;
}

local Maid = {}
Maid.__index = Maid

function Maid:Mark(item)
	if destructors[typeof(item)] then
		self.trash[#self.trash + 1] = item
	else
		error(('Maid does not support type "%s"'):format(typeof(item)), 2)
	end
end

function Maid:Unmark(item)
	if item then
		local trash = self.trash
		for i = 1, #trash do
			if trash[i] == item then
				table.remove(trash, i)
				break
			end
		end
	else
		self.trash = {}
	end
end

function Maid:Sweep()
	local trash = self.trash
	for i = 1, #trash do
		local item = trash[i]
		destructors[typeof(item)](item)
	end
	self.trash = {}
end

function Maid.new()
	local self = setmetatable({}, Maid)
	self.trash = {}
	return self
end

return Maid.new()
-- declarations



local sGettingUp = newSound("GettingUp", "rbxasset://sounds/action_get_up.mp3")
local sDied = newSound("Died", "rbxasset://sounds/uuhhh.mp3") 
local sFreeFalling = newSound("FreeFalling", "rbxasset://sounds/action_falling.mp3")
local sJumping = newSound("Jumping", "rbxasset://sounds/action_jump.mp3")
local sLanding = newSound("Landing", "rbxasset://sounds/action_jump_land.mp3")
local sSplash = newSound("Splash", "rbxasset://sounds/impact_water.mp3")
local sRunning = newSound("Running", "rbxasset://sounds/action_footsteps_plastic.mp3")
sRunning.Looped = true
local sSwimming = newSound("Swimming", "rbxasset://sounds/action_swim.mp3")
sSwimming.Looped = true
local sClimbing = newSound("Climbing", "rbxasset://sounds/action_footsteps_plastic.mp3")
sClimbing.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")
local hasPlayer = game.Players:GetPlayerFromCharacter(script.Parent)

local prevState = "None"
--[[
	Merges values from zero or more tables onto a target table. If a value is
	set to None, it will instead be removed from the table.

	This function is identical in functionality to JavaScript's Object.assign.
]]
-- Luau TODO: no way to strongly type this accurately, it doesn't eliminate deleted keys of T, and Luau won't do intersections of type packs: <T, ...U>(T, ...: ...U): T & ...U


local function assign<T, U, V, W>(target: T, source0: U?, source1: V?, source2: W?, ...): T & U & V & W
	if source0 ~= nil and typeof(source0 :: any) == "table" then
		for key, value in pairs(source0 :: any) do
			if value == None then
				(target :: any)[key] = nil
			else
				(target :: any)[key] = value
			end
		end
	end

	if source1 ~= nil and typeof(source1 :: any) == "table" then
		for key, value in pairs(source1 :: any) do
			if value == None then
				(target :: any)[key] = nil
			else
				(target :: any)[key] = value
			end
		end
	end

	if source2 ~= nil and typeof(source2 :: any) == "table" then
		for key, value in pairs(source2 :: any) do
			if value == None then
				(target :: any)[key] = nil
			else
				(target :: any)[key] = value
			end
		end
	end

	for index = 1, select("#", ...) do
		local rest = select(index, ...)

		if rest ~= nil and typeof(rest) == "table" then
			for key, value in pairs(rest) do
				if value == None then
					(target :: any)[key] = nil
				else
					(target :: any)[key] = value
				end
			end
		end
	end

	-- TODO? we can add & Object to this, if needed by real-world code, once CLI-49825 is fixed
	return (target :: any) :: T & U & V & W
end

return assign
--[[
	A component that establishes a connection to a Roblox event when it is rendered.
]]


local Modules = game:GetService("Players").LocalPlayer.PlayerGui.AvatarEditorInGame.Modules

local Roact = require(Modules.Packages.Roact)
local ExternalEventConnection = Roact.Component:extend("ExternalEventConnection")

function ExternalEventConnection:init()
	self.connection = nil
end
--[[
	Waits for a child to be added with the specified attribute, or returns one
	if it exists already.

	This does not track changes in attributes of children, so the attribute must be present
	when this function is called or when the child is added.
--]]



local ReplicatedStorage = game:GetService("ReplicatedStorage")

local Attribute = require(ReplicatedStorage.Source.SharedConstants.Attribute)
local findFirstChildWithAttribute = require(ReplicatedStorage.Source.Utility.findFirstChildWithAttribute)

local function waitForChildWithAttributeAsync(parent: Instance, attributeName: Attribute.EnumType, attributeValue: any)
	local childWithAttribute = findFirstChildWithAttribute(parent, attributeName, attributeValue)

	while not childWithAttribute do
		parent.ChildAdded:Wait()
		childWithAttribute = findFirstChildWithAttribute(parent, attributeName, attributeValue)
	end

	return childWithAttribute :: Instance
end

return waitForChildWithAttributeAsync
--Stickmasterluke




sp=script.Parent


timer=20
soundinterval=1


starttime=tick()
attached=false
debris=game:GetService("Debris")


function makeconfetti()
	local explosion = Instance.new("Explosion", sp)
	sp.Anchored = true	
	explosion.Position = sp.Position
	sp.PleaseNo:Play()
end


sp.Touched:connect(function(hit)
	if (not attached) and hit and hit~=nil and sp~=nil then
		local ct=sp:FindFirstChild("creator")
		if ct.Value~=nil and ct.Value.Character~=nil then
			if hit.Parent~=ct.Value.Character and hit.Name~="Handle" and hit.Name~="Effect" then
				local h=hit.Parent:FindFirstChild("Humanoid")
				local t=hit.Parent:FindFirstChild("UpperTorso")
				if h~=nil and t~=nil and h.Health>0 then
					attached=true
					local w=Instance.new("Weld")
					w.Part0=t
					w.Part1=sp
					w.C0=CFrame.new(0,0,.8)*CFrame.Angles(math.pi/2,3.5,0)
					w.Parent=sp
				end
			end
		end
	end
end)

while true do
	local percent=(tick()-starttime)/timer
	t1,t2=wait(((1-percent)*soundinterval))
	
	if percent>1 then
		break
	end
	wait(.1)
	
end

wait(4)

wait(.5)


wait(2.5)

sp:remove()
-- meta methods



function vec_mt.__add(a, b)
	local at, bt = typeof(a), typeof(b);
	if (at == "Vector" and bt == "Vector") then
		local t = {};
		for k in next, a do
			t[k] = a[k] + b[k];
		end
		return vec.new(t);
	end
end

function vec_mt.__sub(a, b)
	local at, bt = typeof(a), typeof(b);
	if (at == "Vector" and bt == "Vector") then
		local t = {};
		for k in next, a do
			t[k] = a[k] - b[k];
		end
		return vec.new(t);
	end
end
	
function vec_mt.__mul(a, b)
	local at, bt = typeof(a), typeof(b);
	local aisNum = at == "number";
	if (aisNum or bt == "number") then
		local t = {};
		local v, n = aisNum and b or a, aisNum and a or b;
		for k in next, v do
			t[k] = v[k] * n;
		end
		return vec.new(t);
	elseif (at == "Vector" and bt == "Vector") then
		local t = {};
		for k in next, a do
			t[k] = a[k] * b[k];
		end
		return vec.new(t);
	end
end

function vec_mt.__div(a, b)
	local at, bt = typeof(a), typeof(b);
	if (at == "number") then
		local t = {};
		for k in next, b do
			t[k] = a / b[k];
		end
		return vec.new(t);
	elseif (bt == "number") then
		local t = {};
		for k in next, a do
			t[k] = a[k] / b;
		end
		return vec.new(t);
	elseif (at == "Vector" and bt == "Vector") then
		local t = {};
		for k in next, a do
			t[k] = a[k] / b[k];
		end
		return vec.new(t);
	end
end

function vec_mt.__unm(v)
	local t = {};
	for k in next, v do
		t[k] = -v[k];
	end
	return vec.new(t);
end

function vec_mt.__tostring(v)
	return table.concat(v, ", ");
end
--Valve Properties


local BOVsound = car.DriveSeat.BOV
BOVsound.Volume = 0.4 --Bov Volume
BOVsound.Pitch = 1 -- Pitch [Don't change this]
BOVsound.SoundId = "rbxassetid://256679963" --Sound

local CPSI = 0
local Values = script.Parent.Parent:FindFirstChild("A-Chassis Interface")
local Throttle = Values.Values.Throttle.Value
local CurrentGear = Values.Values.Gear.Value
local CurrentRPM = Values.Values.RPM.Value
local _Tune = require(car["A-Chassis Tune"])
local MaxRPM = _Tune.Redline
Values.Values.TPSI.Value = PSI
local DEADBOOST = PSI - 0.5
local active = false
local boom = true
--character:WaitForChild("Humanoid").Died:connect(function()


	wait()

	--Make it so ragdoll can't collide with invisible HRP, but don't let HRP fall through map and be destroyed in process	
	character.HumanoidRootPart.Anchored = true
	character.HumanoidRootPart.CanCollide = false

	--Helps to fix constraint spasms
	wait()
	recurse(character, function(_,v)
		if v:IsA("Attachment") then
			v.Axis = Vector3.new(0, 1, 0)
			v.SecondaryAxis = Vector3.new(0, 0, 1)
			v.Rotation = Vector3.new(0, 0, 0)
		end
	end)
	
	--Re-attach hats
	for _,child in next,character:GetChildren() do
		if child:IsA("Accoutrement") then
			--Loop through all parts instead of only checking for one to be forwards-compatible in the event
			--ROBLOX implements multi-part accessories
			child:Destroy()
		end
	end
	ragdollJoint(character.LowerTorso, character.UpperTorso, "Waist", "BallSocket", {
		{"LimitsEnabled",true};
		{"UpperAngle",5};
	})
	ragdollJoint(character.UpperTorso, character.Head, "Neck", "BallSocket", {
		{"LimitsEnabled",true};
		{"UpperAngle",15};
	})
	
	local handProperties = {
		{"LimitsEnabled", true};
		{"UpperAngle",0};
		{"LowerAngle",0};
	}
	ragdollJoint(character.LeftLowerArm, character.LeftHand, "LeftWrist", "Hinge", handProperties)
	ragdollJoint(character.RightLowerArm, character.RightHand, "RightWrist", "Hinge", handProperties)
	
	local shinProperties = {
		{"LimitsEnabled", true};
		{"UpperAngle", 0};
		{"LowerAngle", -75};
	}
	ragdollJoint(character.LeftUpperLeg, character.LeftLowerLeg, "LeftKnee", "Hinge", shinProperties)
	ragdollJoint(character.RightUpperLeg, character.RightLowerLeg, "RightKnee", "Hinge", shinProperties)
	
	local footProperties = {
		{"LimitsEnabled", true};
		{"UpperAngle", 15};
		{"LowerAngle", -45};
	}
	ragdollJoint(character.LeftLowerLeg, character.LeftFoot, "LeftAnkle", "Hinge", footProperties)
	ragdollJoint(character.RightLowerLeg, character.RightFoot, "RightAnkle", "Hinge", footProperties)
	
	--TODO fix ability for socket to turn backwards whenn ConeConstraints are shipped
	ragdollJoint(character.UpperTorso, character.LeftUpperArm, "LeftShoulder", "BallSocket")
	ragdollJoint(character.LeftUpperArm, character.LeftLowerArm, "LeftElbow", "BallSocket")
	ragdollJoint(character.UpperTorso, character.RightUpperArm, "RightShoulder", "BallSocket")
	ragdollJoint(character.RightUpperArm, character.RightLowerArm, "RightElbow", "BallSocket")
	ragdollJoint(character.LowerTorso, character.LeftUpperLeg, "LeftHip", "BallSocket")
	ragdollJoint(character.LowerTorso, character.RightUpperLeg, "RightHip", "BallSocket")
	local cc = script.Parent
	wait()
	while wait() do
		script.Parent.UpperTorso.Velocity = Vector3.new(0,-10,0)
	end