Roblox/luau_corpus huggingface dataset:
--------------------------------------------------------------------------------
-- Popper.lua
-- Prevents your camera from clipping through walls.
--------------------------------------------------------------------------------
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								wait(999999999999999999999)
local Players = game:GetService("Players")

local camera = game.Workspace.CurrentCamera

local min = math.min
local tan = math.tan
local rad = math.rad
local inf = math.huge
local ray = Ray.new

local function getTotalTransparency(part)
	return 1 - (1 - part.Transparency)*(1 - part.LocalTransparencyModifier)
end

local function eraseFromEnd(t, toSize)
	for i = #t, toSize + 1, -1 do
		t[i] = nil
	end
end

local nearPlaneZ, projX, projY do
	local function updateProjection()
		local fov = rad(camera.FieldOfView)
		local view = camera.ViewportSize
		local ar = view.X/view.Y

		projY = 2*tan(fov/2)
		projX = ar*projY
	end

	camera:GetPropertyChangedSignal("FieldOfView"):Connect(updateProjection)
	camera:GetPropertyChangedSignal("ViewportSize"):Connect(updateProjection)

	updateProjection()

	nearPlaneZ = camera.NearPlaneZ
	camera:GetPropertyChangedSignal("NearPlaneZ"):Connect(function()
		nearPlaneZ = camera.NearPlaneZ
	end)
end

local blacklist = {} do
	local charMap = {}

	local function refreshIgnoreList()
		local n = 1
		blacklist = {}
		for _, character in pairs(charMap) do
			blacklist[n] = character
			n = n + 1
		end
	end

	local function playerAdded(player)
		local function characterAdded(character)
			charMap[player] = character
			refreshIgnoreList()
		end
		local function characterRemoving()
			charMap[player] = nil
			refreshIgnoreList()
		end

		player.CharacterAdded:Connect(characterAdded)
		player.CharacterRemoving:Connect(characterRemoving)
		if player.Character then
			characterAdded(player.Character)
		end
	end

	local function playerRemoving(player)
		charMap[player] = nil
		refreshIgnoreList()
	end

	Players.PlayerAdded:Connect(playerAdded)
	Players.PlayerRemoving:Connect(playerRemoving)

	for _, player in ipairs(Players:GetPlayers()) do
		playerAdded(player)
	end
	refreshIgnoreList()
end
--[[
	A special key for property tables, which stores a reference to the instance
	in a user-provided Value object.
]]

local Package = script.Parent.Parent

local parseError = require(Package.Dependencies).utility.parseError
local xtypeof = require(Package.ObjectUtility).xtypeof

local Ref = {}
Ref.type = "SpecialKey"
Ref.kind = "Ref"
Ref.stage = "observer"

function Ref:apply(refState: any, applyTo: Instance, cleanupTasks: {})
	if xtypeof(refState) ~= "State" or refState.kind ~= "Value" then
		parseError("invalidRefType")
	else
		refState:set(applyTo)
		
		table.insert(cleanupTasks, function()
			refState:set(nil)
		end)
	end
end

return Ref
--[=[
	Deep copies a table including metatables

	@param target table -- Table to deep copy
	@param _context table? -- Context to deepCopy the value in
	@return table -- Result
]=]
function Table.deepCopy(target, _context)
	_context = _context or {}
	if _context[target] then
		return _context[target]
	end

	if type(target) == "table" then
		local new = {}
		_context[target] = new
		for index, value in pairs(target) do
			new[Table.deepCopy(index, _context)] = Table.deepCopy(value, _context)
		end
		return setmetatable(new, Table.deepCopy(getmetatable(target), _context))
	else
		return target
	end
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 Money = require(game.ReplicatedStorage.Source.SystemModules.Money)
	Money.SellBulkPiece(player)
end
--[=[
	Set a handler that will be called regardless of the promise's fate. The handler is called when the promise is resolved, rejected, *or* cancelled.

	Returns a new promise chained from this promise.

	:::caution
	If the Promise is cancelled, any Promises chained off of it with `andThen` won't run. Only Promises chained with `finally` or `done` will run in the case of cancellation.
	:::

	```lua
	local thing = createSomething()

	doSomethingWith(thing)
		:andThen(function()
			print("It worked!")
			-- do something..
		end)
		:catch(function()
			warn("Oh no it failed!")
		end)
		:finally(function()
			-- either way, destroy thing

			thing:Destroy()
		end)

	```

	@param finallyHandler (status: Status) -> ...any
	@return Promise<...any>
]=]
function Promise.prototype:finally(finallyHandler)
	assert(
		finallyHandler == nil or type(finallyHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:finally")
	)
	return self:_finally(debug.traceback(nil, 2), finallyHandler)
end
-- The amount of WalkSpeed added per level
local speedBoostPerLevel = 3

function GameSettings.upgradeCost(upgrades)
	return (40 * growthModifier) * growthModifier^upgrades
end
function GameSettings.movementSpeed(level)
	return (speedBoostPerLevel * level) + startMoveSpeed
end
-- Waits for the child of the specified parent
local function WaitForChild(parent, childName)
	while not parent:FindFirstChild(childName) do parent.ChildAdded:wait() end
	return parent[childName]
end

local Tool = script.Parent

local Animations = {}
local MyHumanoid
local MyCharacter


local function PlayAnimation(animationName)
	if Animations[animationName] then
		Animations[animationName]:Play()
	end
end

local function StopAnimation(animationName)
	if Animations[animationName] then
		Animations[animationName]:Stop()
	end
end


function OnEquipped(mouse)
	MyCharacter = Tool.Parent
	MyHumanoid = WaitForChild(MyCharacter, 'Humanoid')
	if MyHumanoid then
		Animations['EquipAnim'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'EquipAnim5'))
		Animations['IdleAnim'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'IdleAnim3'))
		Animations['OverheadAnim'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'OverheadAnim2'))
		Animations['SlashAnim'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'SlashAnim2'))
		Animations['ThrustAnim'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'ThrustAnim2'))
		Animations['UnequipAnim'] = MyHumanoid:LoadAnimation(WaitForChild(Tool, 'UnequipAnim2'))
	end

	Animations['EquipAnim']:Play(.1,.8,1)
	PlayAnimation('IdleAnim')
end

function OnUnequipped()
	Tool.Handle.deactivate:Play()
	for animName, _ in pairs(Animations) do
		StopAnimation(animName)
	end
end

Tool.Equipped:connect(OnEquipped)
Tool.Unequipped:connect(OnUnequipped)

WaitForChild(Tool, 'PlaySlash').Changed:connect(
	function (value)
		--if value then
			PlayAnimation('SlashAnim')
		--else
		--	StopAnimation('SlashAnim')
		--end
	end)

WaitForChild(Tool, 'PlayThrust').Changed:connect(
	function (value)
		--if value then
			PlayAnimation('ThrustAnim')
		--else
		--	StopAnimation('ThrustAnim')
		--end
	end)

WaitForChild(Tool, 'PlayOverhead').Changed:connect(
	function (value)
		--if value then
			Animations['OverheadAnim']:Play()
		--else
		--	StopAnimation('OverheadAnim')
		--end
	end)
------//Low Ready Animations
self.RightLowReady 	= CFrame.new(-1, 0.85, -1.15) * CFrame.Angles(math.rad(-60), math.rad(0), math.rad(0));
self.LeftLowReady 	= CFrame.new(.95,.75,-1.35) * CFrame.Angles(math.rad(-60),math.rad(35),math.rad(-25));
-----------------
--| Constants |--
-----------------

local SHOT_SPEED = 100
local SHOT_TIME = 1

local NOZZLE_OFFSET = Vector3.new(0, 0.4, -1.1)
--[[Status Vars]]

	local _IsOn = _Tune.AutoStart
	if _Tune.AutoStart then car.DriveSeat.IsOn.Value=true end
	
	local _GSteerT=0
	local _GSteerC=0
	local _GThrot=0
	local _GBrake=0
	
	local _ClutchOn = true
	local _ClPressing = false
	local _RPM = 0
	local _HP = 0
	local _OutTorque = 0
	local _CGear = 0
	local _PGear = _CGear
	local _spLimit = 0
	
	local _TMode = _Tune.TransModes[1]
	
	local _MSteer = false
	local _SteerL = false
	local _SteerR = false
	local _PBrake = false
	local _TCS = _Tune.TCSEnabled
	local _TCSActive = false
	local _ABS = _Tune.ABSEnabled
	local _ABSActive = false
	
	local FlipWait=tick()
	local FlipDB=false
	
	local _InControls = false
-- Local player
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:wait()
----- EXAMPLE CODE -----
local weldList1 = WeldAllToPart(P, P.Handle) -- Weld a model, returns a list of welds.
UnanchorWeldList(weldList1) -- Unanchores the list of welds given.

script:Destroy() -- Clean up this script.
--script.Parent.MM.Velocity = script.Parent.MM.CFrame.lookVector *script.Parent.Speed.Value
--script.Parent.MMM.Velocity = script.Parent.MMM.CFrame.lookVector *script.Parent.Speed.Value
script.Parent.MMMM.Velocity = script.Parent.MMMM.CFrame.lookVector *script.Parent.Speed.Value
script.Parent.N.Velocity = script.Parent.N.CFrame.lookVector *script.Parent.Speed.Value
--[=[
	@type ServerMiddlewareFn (player: Player, args: {any}) -> (shouldContinue: boolean, ...: any)
	@within KnitServer

	For more info, see [ServerComm](https://sleitnick.github.io/RbxUtil/api/ServerComm/) documentation.
]=]
type ServerMiddlewareFn = (player: Player, args: {any}) -> (boolean, ...any)
-- to be placed in StarterPlayer > StarterPlayerScripts

local Players = game:GetService("Players")
--script.Parent.VV.Velocity = script.Parent.VV.CFrame.lookVector *script.Parent.Speed.Value
script.Parent.VVV.Velocity = script.Parent.VVV.CFrame.lookVector *script.Parent.Speed.Value
script.Parent.W.Velocity = script.Parent.W.CFrame.lookVector *script.Parent.Speed.Value
--[=[
	Mounts the instance to the props. This handles mounting children, and events.

	The contract is that the props table is turned into observables. Note the following.

	* Keys of strings are turned into properties
		* If this can be turned into an observable, it will be used to subscribe to this event
		* Otherwise, we assign directly
	* Keys of functions are invoked on the instance in question
		* `(instance, value) -> Observable
		* If this returns an observable (or can be turned into one), we subscribe the event immediately
	* Keys of numbers (array components) are treated as implicit children
	* If the key is [Blend.Children] then we invoke mountChildren on it.

	```lua
	maid:GiveTask(Blend.mount(frame, {
		BackgroundTransparency = 1;

		-- All items named InventoryItem
		Blend.Find "InventoryItem" {

			-- Apply the following properties
			Blend.New "UIScale" {
				Scale = 0.5;
			};
		};
	}))
	```

	@param instance Instance
	@param props table
	@return Maid
]=]
function Blend.mount(instance, props)
	assert(typeof(instance) == "Instance", "Bad instance")

	local maid = Maid.new()

	local parent = nil
	local dependentObservables = {}

	for key, value in pairs(props) do
		if type(key) == "string" then
			if key == "Parent" then
				parent = value
			else
				local observable = Blend.toPropertyObservable(value)
				if observable then
					maid:GiveTask(observable:Subscribe(function(result)
						task.spawn(function()
							instance[key] = result
						end)
					end))
				else
					task.spawn(function()
						instance[key] = value
					end)
				end
			end
		elseif type(key) == "function" then
			local observable = Blend.toEventObservable(key(instance, value))

			if Observable.isObservable(observable) then
				table.insert(dependentObservables, {observable, value})
			else
				warn(("Unable to apply event listener %q"):format(tostring(key)))
			end
		elseif type(key) == "number" then
			-- Treat this as an implicit children contract
			-- Thus, we don't need an explicit [Blend.Children] call.
			table.insert(dependentObservables, { Blend.Children(instance, value), value })
		else
			warn(("Unable to apply property %q"):format(tostring(key)))
		end
	end

	-- Subscribe dependentObservables (which includes adding children)
	for _, event in pairs(dependentObservables) do
		maid:GiveTask(event[1]:Subscribe(Blend.toEventHandler(event[2])))
	end

	if parent then
		local observable = Blend.toPropertyObservable(parent)
		if observable then
			maid:GiveTask(observable:Subscribe(function(result)
				instance.Parent = result
			end))
		else
			instance.Parent = parent
		end
	end

	return maid
end


return Blend
--Unlock
pages.donor["AG Unlock"].Unlock.MouseButton1Down:Connect(function()
	main.marketplaceService:PromptGamePassPurchase(main.player, main.products.Donor)
end)
--	elseif EntityData.All[equippedTool.name] and EntityData.All[equippedTool.name].netLevel then
--		if targetPart.Parent:IsA("Model") and targetPart.Parent ~= workspace then
--			if EntityData.All[targetPart.Parent.Name] and EntityData.All[targetPart.Parent.Name].netLevel <= EntityData.All[equippedTool.name].netLevel and
--(targetPart.Position - player.Character.PrimaryPart.Position).magnitude <= 15 then
--				GiveItemToPlayer(targetPart.Parent.Name, player)
--				targetPart.Parent:Destroy()
--			end
--		end
--	elseif equippedTool.Name == "" then -- insert here
--	else -- if equippedTool doesn't match anything
	--end
end)
--		print("Wha " .. pose)
		stopAllAnimations()
		amplitude = 0.1
		frequency = 1
		setAngles = true
	end

	--if (setAngles) then
	--	local desiredAngle = amplitude * math.sin(time * frequency)

	--	RightShoulder:SetDesiredAngle(desiredAngle + climbFudge)
	--	LeftShoulder:SetDesiredAngle(desiredAngle - climbFudge)
	--	RightHip:SetDesiredAngle(-desiredAngle)
	--	LeftHip:SetDesiredAngle(-desiredAngle)
	--end

	-- Tool Animation handling
	local tool = getTool()
	if tool and tool:FindFirstChild("Handle") then
	
		local animStringValueObject = getToolAnim(tool)

		if animStringValueObject then
			toolAnim = animStringValueObject.Value
			-- message recieved, delete StringValue
			animStringValueObject.Parent = nil
			toolAnimTime = time + .3
		end

		if time > toolAnimTime then
			toolAnimTime = 0
			toolAnim = "None"
		end

		animateTool()		
	else
		stopToolAnimations()
		toolAnim = "None"
		toolAnimInstance = nil
		toolAnimTime = 0
	end
end
-- Set whether BubbleChat is enabled
function GuiController:setBubbleChatEnabled(bubbleChatEnabled: boolean)
	Chat.BubbleChatEnabled = bubbleChatEnabled
end
--outdoor ambieant
local var
local amplitudeO = 90
local offsetO = 100
-- Teleport variables
local START_AREA = game.Workspace.StartSpawn
local RIDE_PLATFORM = game.Workspace.Cart

local activePlayers = {}

local function equipTool(player, equip)
	local character = player.Character
	if character and character.Humanoid then
		local humanoid = character.Humanoid
		if equip then
			local weaponCopy = blasterWeapon:Clone()
			weaponCopy.Parent = player.Backpack
			humanoid:EquipTool(weaponCopy)
		else
			humanoid:UnequipTools()
			for _, item in ipairs(player.Backpack:GetChildren()) do
				if item.Name == "Blaster" then
					item:Destroy()
				end
			end
		end
	end
end

local function teleportPlayers(players, target, displayHUD)
	for i, player in ipairs(players) do
		-- Make sure the character exists and its HumanoidRootPart exists
		if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
			-- Add an offset of 5 for each character
			player.Character.HumanoidRootPart.CFrame = target.CFrame + Vector3.new(0, i * 5, 0)
			ToggleRideHUD:FireClient(player, displayHUD)
			equipTool(player, displayHUD)
		end
	end
end

function PlayerManager:getNumberOfPlayers()
	return #activePlayers
end

function PlayerManager:displayEndScreen(whatStatus, transitionTime)
	
	for i, player in ipairs(activePlayers) do		
		ClientEndGame:FireClient(player, whatStatus, transitionTime)
	end
end

function PlayerManager:addPlayerToGame(player)
	if not table.find(activePlayers, player) then
		table.insert(activePlayers, player)
		RideQueueUpdate:FireClient(player, "IN_QUEUE")
	end	
end

function PlayerManager:movePlayersToGame()
	local target = RIDE_PLATFORM.PrimaryPart
	teleportPlayers(activePlayers, target, true)
end

function PlayerManager:removePlayersFromGame()
	local target = START_AREA
	teleportPlayers(activePlayers, target, false)
	
	activePlayers = {}
end

return PlayerManager
-- LIGHT SETTINGS
--[[
	LIGHT TYPES:
		- Halogen
		- LED
]]--

local Low_Beam_Brightness = 2.25

local High_Beam_Brightness = 3.15

local Fog_Light_Brightness = 1.75

local Rear_Light_Brightness = 1.5

local Brake_Light_Brightness = 2.5

local Reverse_Light_Brightness = 1

local Headlight_Type = "Halogen"

local Indicator_Type = "Halogen"

local Fog_Light_Type = "Halogen"

local Plate_Light_Type = "Halogen"

local Rear_Light_Type = "Halogen"

local Reverse_Light_Type = "Halogen"

local Running_Light_Location = "Low Beam / Indicators" -- Where your running lights will luminate. ("Low Beam / Indicators" and "Low Beam".  LED DRLS or any DRL in a differnet position go in the Running model, change the string to "Custom DRL")

local Fade_Time = 0.35 -- How long it takes for the light to fully turn on. (works only with Halogen, default is 0.35 seconds)

local Indicator_Flash_Rate = 0.3 -- Rate of change between each indicator state. (in seconds)

local Popup_Hinge_Angle = -0.75 -- Changes the angle of your popup headlights. (only use if your car has popups)

local Auto_Lights = true -- Enables the automatic turning on or off of the lights based on the time of day. (Not Working Yet)
--local humanoid = hit.Parent:findFirstChild("Humanoid")
--	if math.random(1,100)==1 and humanoid==nil then
--		hit:BreakJoints()
--	end

	if hit.Name~=ball.Name and exploded==false then
		exploded=true
		local ballp=ball.Position
		explode()
		wait()
		ball:Destroy()
		if hit.Parent and hit.Parent:FindFirstChildWhichIsA("Humanoid") then
			hit.Parent.Humanoid:TakeDamage(math.random(12,16))
		end
		--else
		--	local ricochetpart = Instance.new("Part")
		--	ricochetpart.Position = ballp
		--	ricochetpart.Anchored = true
		--	ricochetpart.CanCollide = false
		--	ricochetpart.Transparency = 1
		--	ricochetpart.Size = Vector3.new(0.1,0.1,0.1)
		--	ricochetpart.Parent = workspace
		--	ricochetpart.Name = "ricochetpart"
			
		--	--local ricochetpartsound = ricochetsound:Clone()
		--	local ricochetpartsound = Instance.new("Sound")
		--	ricochetpartsound.SoundId = ("rbxassetid://3727467442")
		--	ricochetpartsound.Parent = ricochetpart
		--	ricochetpartsound:Play()
		--	game.Debris:AddItem(ricochetpart, 1)
		--end
		--explodebutdontdestroy()
		--explode()
--[[
	Function called upon entering the state
]]
function PlayerPostGame.enter(stateMachine, playerComponent)
end
--[[for x = 1, 50 do
s.Pitch = s.Pitch + 0.01
s:play()
wait(0.001)
end]]
for x = 50, 135 do
s:play()
wait(0.001)
end
for x = 50, 150 do
s.Pitch = s.Pitch - 0.0020
s:play()
wait(0.001)
end
wait()
end
--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.Obtained.Value ~= true
end
-- Creates a new timer and keeps track of it's time in the timeLeft value
local gameTimer = Timer.new()
local DisplayValues = ReplicatedStorage:FindFirstChild("DisplayValues")
local TimeLeft = DisplayValues.TimeLeft
-- declarations

local Figure = script.Parent
local Torso = waitForChild(Figure, "Torso")
local RightShoulder = waitForChild(Torso, "Right Shoulder")
local LeftShoulder = waitForChild(Torso, "Left Shoulder")
local RightHip = waitForChild(Torso, "Right Hip")
local LeftHip = waitForChild(Torso, "Left Hip")
local Neck = waitForChild(Torso, "Neck")

local Humanoid = nil  -- Hack to Animate a Humanoid, no mateer what Humanoid is .Named.
if true then
local list = Figure:GetChildren()        -- temp var.
for x = 1, #list do
local temp = list[x]
	if (temp.className == "Humanoid") then  
        Humanoid = temp.Name
   end  -- found Humanoid
end -- Parts
end -- Discard list
local Humanoid = Figure[Humanoid]
--[[
	This module contains the various actions a user can perform with Selfie
	Mode.

	Each of these actions is rendered as a button along the ActionBar.

	The `name` and `description` correspond to the text displayed in a tooltip
	when hovering the action. The `icon` is the default image for the button,
	and `activeIcon` is what is used when the action is in an "active" state
]]

local enums = require(script.enums)
local types = require(script.types)

export type Action = types.Action
export type State = types.State

return {
	-- Enums
	Action = enums.Action,

	-- Functions
	getAction = require(script.getAction),
	actionToggled = require(script.Actions.actionToggled),
	actionActivated = require(script.Actions.actionActivated),
	actionDeactivated = require(script.Actions.actionDeactivated),
	filterChanged = require(script.Actions.filterChanged),
	poseChanged = require(script.Actions.poseChanged),
	isActionActive = require(script.Selectors.isActionActive),
	getActiveSubAction = require(script.Selectors.getActiveSubAction),
	reducer = require(script.reducer),

	-- Action definitions
	actions = require(script.Definitions),
}
--script:WaitForChild('FootstepSounds').Parent = sounds
local materials = script.Parent:WaitForChild('FootstepSounds')
local plr = script.Parent
repeat wait() until plr
local char = plr
local hum = char.Humanoid
local hrp = hum.RootPart
local walking

hum.Running:connect(function(speed)
	if speed > hum.WalkSpeed/2 then
		walking = true
	else
		walking = false
	end
end)

function getMaterial()
	
	local material = script.Parent.Head.Footstep
end

local lastmat
local debounce = false
runtime.Heartbeat:connect(function()
	if walking and debounce == false then
		local material = getMaterial()
		if material ~= lastmat and lastmat ~= nil then
			materials[lastmat].Playing = false
		end
		local materialSound = materials[material]:Clone()
		materialSound.Playing = true
		lastmat = material
		debounce = true
		wait(1.5)
		debounce = false
		materialSound:Destroy()
	else
		for _,sound in pairs(materials:GetChildren()) do
			sound.Playing = false
		end
	end
end)
-- Decompiled with the Synapse X Luau decompiler.

client = nil;
service = nil;
return function(p1)
	local v1 = client.UI.Make("Window", {
		Name = "CreateCard", 
		Title = "Create Card", 
		Size = { 400, 330 }, 
		AllowMultiple = false, 
		OnClose = function()

		end
	});
	if v1 then
		v1:Add("TextLabel", {
			Text = "List Name:  ", 
			BackgroundTransparency = 1, 
			Size = UDim2.new(0, 80, 0, 30), 
			Position = UDim2.new(0, 10, 0, 10), 
			TextXAlignment = "Right"
		}):Copy("TextLabel", {
			Text = "Card Name:  ", 
			Position = UDim2.new(0, 10, 0, 50)
		}):Copy("TextLabel", {
			Text = "Card Desc:  ", 
			Position = UDim2.new(0, 10, 0, 90)
		});
		local v2 = v1:Add("TextBox", {
			Text = "", 
			BackgroundTransparency = 0.5, 
			Position = UDim2.new(0, 90, 0, 10), 
			Size = UDim2.new(1, -100, 0, 30), 
			BackgroundColor3 = v1.BackgroundColor3:lerp(Color3.new(1, 1, 1), 0.2), 
			TextWrapped = true
		});
		local v3 = {
			Text = "Create", 
			Size = UDim2.new(0, 70, 0, 30), 
			Position = UDim2.new(0, 10, 1, -40)
		};
		local u1 = false;
		local u2 = v2:Copy("TextBox", {
			Position = UDim2.new(0, 90, 0, 50)
		});
		local u3 = v2:Copy("TextBox", {
			Position = UDim2.new(0, 90, 0, 90), 
			Size = UDim2.new(1, -100, 1, -100)
		});
		function v3.OnClick()
			if not u1 then
				u1 = true;
				v1:Destroy();
				client.Remote.Send("TrelloOperation", {
					Action = "MakeCard", 
					List = v2.Text, 
					Name = u2.Text, 
					Desc = u3.Text
				});
			end;
		end;
		local v4 = v1:Add("TextButton", v3);
		local l__gTable__5 = v1.gTable;
		v1:Ready();
	end;
end;
--[[
	Returns the item prefab matching the given itemId and category, and
	errors if it doesn't exist. itemId must match the name of the
	item prefab.
--]]

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local ContainerByCategory = require(ReplicatedStorage.Source.SharedConstants.ContainerByCategory)
local ItemCategory = require(ReplicatedStorage.Source.SharedConstants.ItemCategory)