AnimationEditor.rbxmx

<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
	<External>null</External>
	<External>nil</External>
	<Item class="Folder" referent="RBX9E1527C11C344E1583FD4792D54C6E7A">
		<Properties>
			<string name="Name">Plugin</string>
		</Properties>
		<Item class="Script" referent="RBX7C4413FB08E647B8A869426680264373">
			<Properties>
				<bool name="Disabled">true</bool>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">createBlockRig</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[local rigCreator = require(script.Parent.RigCreator)

local toolbar = plugin:CreateToolbar("Animations")
local button = toolbar:CreateButton(
	"", -- The text next to the icon. Leave this blank if the icon is sufficient.
	"Create Block Rig", -- hover text
	"http://www.roblox.com/asset/?id=142301446" -- The icon file's name
)

button.Click:connect(function()
	if (_G["AnimationEdit"] == true) then
		print("Cannot create rig while in edit mode.")
		return
	end
	--
	local rig = rigCreator.CreateR6Rig()	
	rig:MoveTo(Vector3.new(0, 5.2, 0))
end)]]></ProtectedString>
			</Properties>
		</Item>
		<Item class="Script" referent="RBXE47092D4EB914B6D8AAF426FE501BB5F">
			<Properties>
				<bool name="Disabled">true</bool>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">createMeshBoyRig</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[local rigCreator = require(script.Parent.RigCreator)

local toolbar = plugin:CreateToolbar("Animations")
local button = toolbar:CreateButton(
	"", -- The text next to the icon. Leave this blank if the icon is sufficient.
	"Create Man Rig", -- hover text
	"http://www.roblox.com/asset/?id=142301579" -- The icon file's name.
)

button.Click:connect(function()
	if (_G["AnimationEdit"] == true) then
		print("Cannot create rig while in edit mode.")
		return
	end

	local rig = rigCreator.CreateR6Rig()

	local LArmMesh = Instance.new("CharacterMesh", rig)
	LArmMesh.MeshId = 82907977
	LArmMesh.BodyPart = 2

	local RArmMesh = Instance.new("CharacterMesh", rig)
	RArmMesh.MeshId = 82908019
	RArmMesh.BodyPart = 3


	local LLegMesh = Instance.new("CharacterMesh", rig)
	LLegMesh.MeshId = 81487640
	LLegMesh.BodyPart = 4

	local RLegMesh = Instance.new("CharacterMesh", rig)
	RLegMesh.MeshId = 81487710
	RLegMesh.BodyPart = 5

	local TorsoMesh = Instance.new("CharacterMesh", rig)
	TorsoMesh.MeshId = 82907945
	TorsoMesh.BodyPart = 1


	local HeadMesh = Instance.new("SpecialMesh", rig.Head)
	HeadMesh.MeshType = 0
	HeadMesh.Scale = Vector3.new(1.25, 1.25, 1.25)


	rig:MoveTo(Vector3.new(0, 5.2, 0))
end)]]></ProtectedString>
			</Properties>
		</Item>
		<Item class="Script" referent="RBXF5512FC251E74CD0B688D433B5D9F7DB">
			<Properties>
				<bool name="Disabled">true</bool>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">createMeshGirlRig</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[local rigCreator = require(script.Parent.RigCreator)

local toolbar = plugin:CreateToolbar("Animations")
local button = toolbar:CreateButton(
	"", -- The text next to the icon. Leave this blank if the icon is sufficient.
	"Create Woman Rig", -- hover text
	"http://www.roblox.com/asset/?id=142301608" -- The icon file's name. 
)

button.Click:connect(function()
	if (_G["AnimationEdit"] == true) then
		print("Cannot create rig while in edit mode.")
		return
	end

	local rig = rigCreator.CreateR6Rig()

	local LArmMesh = Instance.new("CharacterMesh", rig)
	LArmMesh.MeshId = 83001137
	LArmMesh.BodyPart = 2

	local RArmMesh = Instance.new("CharacterMesh", rig)
	RArmMesh.MeshId = 83001181
	RArmMesh.BodyPart = 3


	local LLegMesh = Instance.new("CharacterMesh", rig)
	LLegMesh.MeshId = 81628361
	LLegMesh.BodyPart = 4

	local RLegMesh = Instance.new("CharacterMesh", rig)
	RLegMesh.MeshId = 81628308
	RLegMesh.BodyPart = 5

	local TorsoMesh = Instance.new("CharacterMesh", rig)
	TorsoMesh.MeshId = 82987757
	TorsoMesh.BodyPart = 1

	local HeadMesh = Instance.new("SpecialMesh", rig.Head)
	HeadMesh.MeshType = 0
	HeadMesh.Scale = Vector3.new(1.25, 1.25, 1.25)


	rig:MoveTo(Vector3.new(0, 5.2, 0))
end)]]></ProtectedString>
			</Properties>
		</Item>
		<Item class="Script" referent="RBX158AAE6963B1477580A1D45249EEC870">
			<Properties>
				<bool name="Disabled">true</bool>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">createMeshRig</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[local rigCreator = require(script.Parent.RigCreator)

local toolbar = plugin:CreateToolbar("Animations")
local button = toolbar:CreateButton(
	"", -- The text next to the icon. Leave this blank if the icon is sufficient.
	"Create Mesh Rig", -- hover text
	"http://www.roblox.com/asset/?id=142301531" -- The icon file's name.
)

button.Click:connect(function()
	if (_G["AnimationEdit"] == true) then
		print("Cannot create rig while in edit mode.")
		return
	end
	
	local rig = rigCreator.CreateR6Rig()

	local LArmMesh = Instance.new("CharacterMesh", rig)
	LArmMesh.MeshId = 27111419
	LArmMesh.BodyPart = 2

	local RArmMesh = Instance.new("CharacterMesh", rig)
	RArmMesh.MeshId = 27111864
	RArmMesh.BodyPart = 3


	local LLegMesh = Instance.new("CharacterMesh", rig)
	LLegMesh.MeshId = 27111857
	LLegMesh.BodyPart = 4

	local RLegMesh = Instance.new("CharacterMesh", rig)
	RLegMesh.MeshId = 27111882
	RLegMesh.BodyPart = 5

	local TorsoMesh = Instance.new("CharacterMesh", rig)
	TorsoMesh.MeshId = 27111894
	TorsoMesh.BodyPart = 1


	local HeadMesh = Instance.new("SpecialMesh", rig.Head)
	HeadMesh.MeshType = 0
	HeadMesh.Scale = Vector3.new(1.25, 1.25, 1.25)


	rig:MoveTo(Vector3.new(0, 5.2, 0))
end)]]></ProtectedString>
			</Properties>
		</Item>
		<Item class="Script" referent="RBX6466DBE39F2847E2A6576793B25B732C">
			<Properties>
				<bool name="Disabled">false</bool>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">AnimationEditor</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[--[[
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
NOTES FOR ANYBODY READING / MODIFYING THE EDITOR!

-Almost all UI code has been moved to the MenuHandler ModuleScript. There is still a lot of earlier UI code in here that can be cleaned, can probably reduce 500 - 1000 lines
-It would be nice to prebuild the timeline (as has been done with UI) so the generation does not need to be done in code
-Rewrite code that uses variables timelineScale, animationLength so that these can be calculated more cleanly instead of being done often
-MenuManager works by being passed functions to be called when they are done running.

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
--]]
local version = "3.3.2" --try to keep this up to date :)
_G["AnimationEdit"] = false
local toolbar = plugin:CreateToolbar("Animations")
local button = toolbar:CreateButton(
	"Animation Editor",
	"Create, preview and publish animations for character rigs", -- The text next to the icon. Leave Othis blank if the icon is sufficient.
	"http://www.roblox.com/asset/?id=620849296" -- The icon file's name
)

--The envRoot is for a testing environment. When developing the plugin, you can loadstring instead of reloading studio.
local envRoot = script ~= nil and script.Parent or game.Workspace:findFirstChild("Plugin"):clone()
local rootPart
local menuManager = require(envRoot.AnimationEditor.MenuHandler)
local easingStyles = require(envRoot.AnimationEditor.EasingStyles)
local guis = envRoot.AnimationEditor.GUIs
local cleanup = {}--Parts to be cleaned up on close

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- 3.1 Flag Code
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------

local fbxFlagExists, fbxFlagValue = pcall(function () return settings():GetFFlag("DebugStudioRigImporter") end)
--In the middle of a flag name transition...
if not fbxFlagExists then
	fbxFlagExists, fbxFlagValue = pcall(function () return settings():GetFFlag("StudioFbxRigImporting") end)
end
-----------------------------------------...
local DebugEnabled = false
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- PREFERENCES
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------

local preferences = {
	["TweenCursor"] = plugin:GetSetting("AnimEditor_TweenCursor"),
	["Snapping"] = true,
	["TransparentSelect"] = plugin:GetSetting("AnimEditor_TransparentSelect"),
	["Interpolation"] = plugin:GetSetting("AnimEditor_Interpolation"),
	["Tooltips"] = plugin:GetSetting("AnimEditor_Tooltips")
}
if preferences["TweenCursor"] == nil then
	preferences["TweenCursor"] = true
end
if preferences["TransparentSelect"] == nil then
	preferences["TransparentSelect"] = true
end
if preferences["Tooltips"] == nil then
	preferences["Tooltips"] = true
end
if preferences["Interpolation"] == nil then
	preferences["Interpolation"] = true
end

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- G E N E R I C    U T I L    C O D E
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------

local function Repeat(func)
	local flag = true
	spawn(function()
		while flag do
			func()
			wait()
		end	
	end)

	return (function()	flag = false end)
end


function repairedCFrameSnailVersion(cf)
	local sq=math.sqrt
	local x,y,z,a,b,c,d,e,f,g,h,i=cf:components()
	local j,k,l=f*g-d*i,a*i-c*g,c*d-a*f
	local m,n,o=d*l-k*g,j*g-l*a,a*k-j*d
	local l1,l2,l3=sq(a^2+d^2+g^2),sq(j^2+k^2+l^2),sq(m^2+n^2+o^2)
	return CFrame.new(x,y,z,a/l1,j/l2,m/l3,d/l1,k/l2,n/l3,g/l1,l/l2,o/l3)
end

function repairedCFrame(cf)
	local x,y,z,a,b,c,d,e,f,g,h,i=cf:components()
	local j,k,l=f*g-d*i,a*i-c*g,c*d-a*f
	local m,n,o=d*l-k*g,j*g-l*a,a*k-j*d
	local l1,l2,l3=(a^2+d^2+g^2)^0.5,(j^2+k^2+l^2)^0.5,(m^2+n^2+o^2)^0.5
	return CFrame.new(x,y,z,a/l1,j/l2,m/l3,d/l1,k/l2,n/l3,g/l1,l/l2,o/l3)
end

function isCFrameBroken(cframe)
	local x, y, z, a, b, c, d, e, f, g, h, i = cframe:components()
	
	local r1 = Vector3.new(a, d, g)
	local r2 = Vector3.new(b, e, h)
	local r3 = Vector3.new(c, f, i)
	
	local function fuzzyEq(a, b)
		return math.abs(a - b) < 0.001
	end
		
	return (not fuzzyEq(r1.magnitude, 1) ) or (not fuzzyEq(r2.magnitude, 1) ) or (not fuzzyEq(r3.magnitude, 1) )
end

function approx(arg)
	return math.floor(arg * 1000) / 1000
end

function spairs(t, order)
    -- collect the keys
    local keys = {}
    for k in pairs(t) do keys[#keys+1] = k end

    -- if order function given, sort by it by passing the table and keys a, b,
    -- otherwise just sort the keys 
    if order then
        table.sort(keys, function(a,b) return order(t, a, b) end)
    else
        table.sort(keys)
    end

    -- return the iterator function
    local i = 0
    return function()
        i = i + 1
        if keys[i] then
            return keys[i], t[keys[i]]
        end
    end
end

----------- udim stuff ----------------------------
local function UD(a, b, c, d)
	return UDim2.new(a, b, c, d)
end
local function CenterPos(w, h)
	return UD(0.5, -w/2, 0.5, -h/2)
end
local function ConstSize(w, h)
	return UD(0, w, 0, h)
end

function Make(ty, data)
	local obj = Instance.new(ty)
	for k, v in pairs(data) do
		if type(k) == 'number' then
			v.Parent = obj
		else
			obj[k] = v
		end
	end
	return obj
end

function round(val)
  return math.floor(val + 0.5)
end

function printCFrame(name, cf)
	local anarray = {cf:components()}
	local str = ""
	for i,v in pairs(anarray) do
		str = str .. " " .. i .. "# " .. v
	end 
	print(name .. " " .. str)
end

function printVector(vec)
	print("X " .. vec.x .. " Y " .. vec.y .. " Z " .. vec.z)
end

function tablelength(T)
  local count = 0
  for _ in pairs(T) do count = count + 1 end
  return count
end

local function weldBetween(a, b, optionalParent)
    local weld = Instance.new("Motor6D")
    weld.Part0 = a
    weld.Part1 = b
    weld.C0 = CFrame.new()
    weld.C1 = b.CFrame:inverse()*a.CFrame
    weld.Parent = optionalParent ~= nil and optionalParent or a
    return weld;
end

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- MOUSE EVENT CODE
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------

local mouseOnLClick = {}
local mouseOnRClick = {}

local mouseOnLUp = {}
local mouseOnRUp = {}

function safeNil(item)
	if (item == nil) then
		return "NIL"
	else
		return item
	end
end

function isSafeNIL(item)
	return (item == "NIL")
end

function registerOn(event, guiElement, func)
	guiElement = safeNil(guiElement)
	local ord = 1
	if (isSafeNIL(guiElement)) then
		ord = 0
	else 
		local parent = guiElement.Parent
		while (parent ~= nil and parent ~= game.Workspace) do
			ord = ord + 1
			parent = parent.Parent
		end
	end
	local eventInstance = { Element = guiElement, Function = func, Order = ord}
	table.insert(event, eventInstance)
	return eventInstance
end

function unregisterOn(event, guiElement)
	guiElement = safeNil(guiElement)
	local i=1
	while i <= #event do
	    if event[i].Element == guiElement then
	        table.remove(event, i)
	    else
	        i = i + 1
	    end
	end
end

function unregisterEvent(event, eventInstance)
	local i=1
	while i <= #event do
	    if event[i] == eventInstance then
	        table.remove(event, i)
--	        print("Remove " .. eventInstance.Element.Name )
	    else
	        i = i + 1
	    end
	end
end

function clearAllEvents()
	mouseOnLClick = {}
	mouseOnRClick = {}

	mouseOnLUp = {}
	mouseOnRUp = {}
end

function isIn(guiElement, X, Y)
	if (X >= guiElement.AbsolutePosition.X and X <= guiElement.AbsolutePosition.X + guiElement.AbsoluteSize.X and
		Y >= guiElement.AbsolutePosition.Y and Y <= guiElement.AbsolutePosition.Y + guiElement.AbsoluteSize.Y) then
		return true
	else
		return false
	end			
end

function listEvent(event)
	print("Event List --------------------------------------")
	local i=1
	while i <= #event do
		local consume = "false"
		if (event[i].Consume) then
			consume = "true"
		end
		if (isSafeNIL(event[i].Element)) then
			print("Nil " .. event[i].Order )
		else
			print(event[i].Element.Name .. " " .. event[i].Order)
		end
        i = i + 1
	end
end


--------------------------------------------------------------------------------------------
-- GUI Mouse Handlers
--------------------------------------------------------------------------------------------

local function mouseCallbackCheck(list)
	local mouse = plugin:GetMouse()
	for _,elem in spairs(list, function(t, a, b) return t[a].Order > t[b].Order end) do
		if (isSafeNIL(elem.Element)) then
			if (elem.Function(mouse.X, mouse.Y)) then
				break
			end
		elseif isIn(elem.Element, mouse.X, mouse.Y) then
			if (elem.Function(mouse.X - elem.Element.AbsolutePosition.X, mouse.Y - elem.Element.AbsolutePosition.Y)) then
				break
			end
		end
	end
end

plugin:GetMouse().Button1Down:connect(function()
		mouseCallbackCheck(mouseOnLClick)
	end
)
plugin:GetMouse().Button2Down:connect(function()
		mouseCallbackCheck(mouseOnRClick)
	end
)
plugin:GetMouse().Button1Up:connect(function()
		mouseCallbackCheck(mouseOnLUp)
	end
)
plugin:GetMouse().Button2Up:connect(function()
		mouseCallbackCheck(mouseOnRUp)
	end
)
game:GetService("UserInputService").InputEnded:connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		mouseCallbackCheck(mouseOnLUp)
	end
end)

local mousePosition2d = Vector2.new()
game:GetService("UserInputService").InputChanged:connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseMovement then
		mousePosition2d = Vector2.new(input.Position.X, input.Position.Y)
	end
end)


function saveModel()
	local model = animationController.Parent:Clone()
	model.Parent = game:GetService("ServerStorage")
	model.Name = "AnimationEditorDebugModel"
end

function mouseRaycast(ignoreList)
	local ray = workspace.CurrentCamera:ViewportPointToRay(mousePosition2d.X, mousePosition2d.Y)
	ray = Ray.new(ray.Origin, ray.Direction.Unit * 512)
		
	local part, point, normal
	
	--infinite loop that is broken out of, so don't worry
	while true do
		part, point, normal = workspace:FindPartOnRayWithIgnoreList(ray, ignoreList)
		
		if part then
			local isTransparent = (part.Transparency > 0.9 and preferences["TransparentSelect"] == false) or part.Name == "SelectionPart"
			local isHumanoidRootPart = part.Name == "HumanoidRootPart"
			
			--calculate whether it's an active part or not
			local isDisabled = false
			local animatedPart = findAnimatedPart(part)
			if animatedPart then
				isDisabled = not partInclude[animatedPart.Name]
			end
			
			local shouldSkip = isTransparent or isHumanoidRootPart or isDisabled
			
			if shouldSkip then
				table.insert(ignoreList, part)
			else
				break
			end
		else
			break
		end
	end
	
	return part, point, normal
end


----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- G L O B A L S 																						(Globals for CTRL-F)
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------


timelineUI = nil
menuUI = nil
saveUI = nil
loadUI = nil
stopAnimUI = nil
timeChangeUI = nil
selectedLine = nil
rotateMoveUI = nil

local timelinemarginSize = 40
local marginSize = 5
local lineSize = 10
local buttonSize = 15
local nameSize = 150
local headerSize = 45
local timelineLength = 0
local tickSeparation = 50
local ticks = 1
local tickSpacing = 0.25
local lineCount = 0
local cursorTime = 0
local timeScale = 0.05 -- Pixels per second of animation
--New Timeline
local tickIncrements = plugin:GetSetting("AnimEditor_TickIncrement") == nil and 0.1 or plugin:GetSetting("AnimEditor_TickIncrement")
local timelineWidth = 0
local dragSnapIncrements = plugin:GetSetting("AnimEditor_SnapIncrement") == nil and 0.05 or plugin:GetSetting("AnimEditor_SnapIncrement")

partList = {}
undoMemory = {}
redoMemory = {}
undoPointer = 0
partListByName = {}
partToItemMap = {}
partToLineNumber = {}
rootPart = nil
animationController = nil

partInclude = {}

cursorClick = false
modal = false
rotateMode = true
partSelection = nil
selectedKeyframe = nil
rotateStep = 0
moveStep = 0
game.Workspace:WaitForChild("Camera")
screenWidth = game.Workspace.Camera.ViewportSize.X

buttonOnColor = Color3.new(200/255, 200/255, 200/255)
buttonOffColor = Color3.new(50/255, 50/255, 50/255)

dropDownColor = Color3.new(21/255, 21/255, 21/255)--Color3.new(100/255, 100/255, 150/255)

local lastAutoSaveTime = 0



----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- D R O P   D O W N    M E N U
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
dropDownMouseClickEater = nil
dropDownMenuClearEvent = nil

function displayDropDownMenu(parent, choiceList, x, y)
	local retval = nil
	modal = true

	local numButtons = tablelength(choiceList)

	-- create frame
	local dropDownUI = Make('Frame', {
			Parent = timelineUI.RootFrame,
			Name = 'RootFrame',
			Style = 'Custom',
			Position = UD(0, x - 100, 0, y),
			Size = UD(0, 100, 0, (marginSize) + numButtons * (buttonSize + marginSize)),
			BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
			BackgroundTransparency = 0.3,
			ZIndex = 10,
		})

	local waitLock = false
	local buttonIdx = 0
	for idx, value in pairs(choiceList) do

		local button = Make('TextButton', {
			Parent = dropDownUI,
			Name = value ..'Button',
			Font = 'ArialBold',
			FontSize = GuiSettings.TextMed,
			TextColor3 = GuiSettings.TextColor,
			Position = UD(0.05, 0, 0, marginSize + buttonIdx * (buttonSize + marginSize)),
			Size = UD(0.9, 0, 0, buttonSize),
			BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
			BackgroundTransparency = 0,
			Text = value,
			ZIndex = 11,
		})

		button.MouseButton1Click:connect(function()
			waitLock = true
			retval = value
		end)


		buttonIdx = buttonIdx + 1
		
	end

	dropDownMouseClickEater = registerOn(mouseOnLClick, dropDownUI, function(x, y)	return true	end)
	dropDownMenuClearEvent = registerOn(mouseOnLClick, nil, function(x, y)
		waitLock = true
		return true
	end)

	while( not waitLock ) do
		wait()
	end

	dropDownUI.Parent = nil
	unregisterEvent(mouseOnLClick, dropDownMouseClickEater)
	unregisterEvent(mouseOnLClick, dropDownMenuClearEvent)

	modal = false
	return retval
end

function displayOptionsMenu(x, y)
	if timelineUI.RootFrame:findFirstChild("OptionsRootFrame") ~= nil then timelineUI.RootFrame.OptionsRootFrame.Parent = nil end
	modal = true
	local loopButton = loopAnimation == true and "Loop: on" or "Loop: off"
	local priorityType = "Priority: "..timelineUI.RootFrame.PriorityDisplay.Text
	local cursorText = preferences["TweenCursor"] == true and "Tween Cursor: on" or "Tween Cursor: off"
	local transparentToggle = preferences["TransparentSelect"] == true and "Select Invisible: yes" or "Select Invisible: no"
	
	local choiceList = {"Change Length","Tick Interval: "..tostring(tickIncrements),"Snap Interval: "..tostring(dragSnapIncrements),loopButton, priorityType, cursorText, transparentToggle}
	local choiceNames = {"Length","Tick","Snap","Loop","Priority","TweenCursor","TransparentToggle"}

	local numButtons = tablelength(choiceList)
	local buttonSize = buttonSize + 4
	-- create frame
	local dropDownUI = Make('Frame', {
			Parent = timelineUI.RootFrame,
			Name = 'OptionsRootFrame',
			Style = 'Custom',
			Position = UD(0, x, 0, y),
			Size = UD(0, 200, 0, (marginSize) + numButtons * (buttonSize + marginSize)),
			BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
			BackgroundTransparency = 0.3,
			ZIndex = 10,
	})
	
	local waitLock = false
	local buttonIdx = 0
	local buttons = {}	
	
	for idx, value in pairs(choiceList) do
		local button = Make('TextButton', {
			Parent = dropDownUI,
			Name = value ..'Button',
			Font = 'ArialBold',
			FontSize = GuiSettings.TextMed,
			TextColor3 = GuiSettings.TextColor,
			Position = UD(0.05, 0, 0, marginSize + buttonIdx * (buttonSize + marginSize)),
			Size = UD(0.9, 0, 0, buttonSize),
			BackgroundColor3 = (idx %2) == 0 and Color3.new(150/255, 150/255, 150/255) or Color3.new(170/255, 170/255, 170/255),
			BackgroundTransparency = 0,
			Text = " "..value,
			ZIndex = 11,
			TextXAlignment = Enum.TextXAlignment.Left,
			TextStrokeTransparency = 0.9,
		})
		buttons[choiceNames[idx]] = button
		buttonIdx = buttonIdx + 1
	end
	
	buttons["Length"].MouseButton1Click:connect(function()
		timeChangeUI.RootFrame.SaveNameFrame.AnimLengthBox.Text = tostring(animationLength)
		timeChangeUI.Parent = game:GetService("CoreGui")
	end)
	
	buttons["Tick"].MouseButton1Click:connect(function()
		tickChangeUI.RootFrame.SaveNameFrame.TickIncrementBox.Text = tostring(tickIncrements)
		tickChangeUI.Parent = game:GetService("CoreGui")
	end)
	
	buttons["Snap"].MouseButton1Click:connect(function()
		snapChangeUI.RootFrame.SaveNameFrame.SnapIncrementBox.Text = tostring(dragSnapIncrements)
		snapChangeUI.Parent = game:GetService("CoreGui")
	end)
	
	buttons["Loop"].MouseButton1Click:connect(function()
		loopAnimation = not loopAnimation
		buttons["Loop"].Text = loopAnimation and "Loop: on" or "Loop: off"
	end)
	
	buttons["Priority"].MouseButton1Click:connect(function()
		local mouse = plugin:GetMouse()
		local newPriority = displayDropDownMenu(timelineUI.RootFrame.PriorityDisplay, animationPriorityList, x + 300, mouse.Y)
		if (newPriority ~= nil) then
			animationPriority = newPriority
			timelineUI.RootFrame.PriorityDisplay.Text = newPriority
			buttons["Priority"].Text = "Priority: "..newPriority
		end			
	end)
	
	buttons["TweenCursor"].MouseButton1Click:connect(function()
		preferences["TweenCursor"] = not preferences["TweenCursor"]
		buttons["TweenCursor"].Text = preferences["TweenCursor"] == true and "Tween Cursor: on" or "Tween Cursor: off"
	end)
	
	buttons["TransparentToggle"].MouseButton1Click:connect(function()
		preferences["TransparentSelect"] = not preferences["TransparentSelect"]
		buttons["TransparentToggle"].Text = preferences["TransparentSelect"] == true and "Select Invisible: yes" or "Select Invisible: no"
	end)
	
	local close
	close = plugin:GetMouse().Button1Down:connect(function()
		local mouse = plugin:GetMouse()
		if mouse.X > x + (200) or mouse.X < x then
			if mouse.Y > y + (marginSize) + numButtons * (buttonSize + marginSize) or mouse.Y < y then
				close:disconnect()
				dropDownUI:Destroy()
				modal = false
			end
		end
	end)

end


----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- T E X T   E N T R Y   D I A L O G
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------

function showTextExtryDialog(title, default)

	modal = true

	local dialogUI = Make('ScreenGui', 
		{	
			Name = "SaveUI",
			Make('Frame', {
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 400, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = title,
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('Frame', {
					Parent = timelineUI,
					Name = 'SaveNameFrame',
					Style = 'Custom',
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 1),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 100/255),
					BackgroundTransparency = 0.3,
					Make('TextBox', {
						Name = 'SaveNameBox',
						Font = 'ArialBold',
						FontSize = 'Size14',
						TextColor3 = GuiSettings.TextColor,
						Position = UD(0.05, 0, 0, 0),
						Size = UD(0.9, 0, 1, 0),
						BackgroundTransparency = 1,
						Text = default,
						TextXAlignment = Enum.TextXAlignment.Left,
					}),
				}),

				Make('TextButton', {
					Name = 'OKButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "OK",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.55, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Cancel",
				}),

			}),
		})

		local retval = default
		local waitLock = false

		dialogUI.RootFrame.OKButton.MouseButton1Click:connect(function()
			retval = dialogUI.RootFrame.SaveNameFrame.SaveNameBox.Text
			waitLock = true
		end)

		dialogUI.RootFrame.CancelButton.MouseButton1Click:connect(function()
			retval = nil
			waitLock = true
		end)


		dialogUI.Parent = game:GetService("CoreGui")


		while( not waitLock ) do
			wait()
		end

		dialogUI.Parent = nil
		modal = false
		return retval

	end

--confirm dialogue
function showConfirmationDialog(text)

	modal = true

	local dialogUI = Make('ScreenGui', 
		{	
			Name = "SaveUI",
			Make('Frame', {
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 400, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				BorderSizePixel = 0,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundTransparency = 1,
					Text = text,
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('TextButton', {
					Name = 'OKButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "OK",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.55, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Cancel",
				}),

			}),
		})

		local retval = default
		local waitLock = false

		dialogUI.RootFrame.OKButton.MouseButton1Click:connect(function()
			retval = true
			waitLock = true
		end)

		dialogUI.RootFrame.CancelButton.MouseButton1Click:connect(function()
			retval = false
			waitLock = true
		end)


		dialogUI.Parent = game:GetService("CoreGui")


		while( not waitLock ) do
			wait()
		end

		dialogUI.Parent = nil
		modal = false
		return retval

	end


----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- K E Y  F R A M E    C O D E
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
animationPriorityList = { 
	"Core",
	"Idle",
	"Movement",
	"Action"
}

animationPlayID = 0
animationLength = 2.0
keyframeList = {}
loopAnimation = false
animationPriority = "Core"
animationFramerate = 1 / 20
copyPoseList = {}
poseColor =  Color3.new(200/255, 50/255, 150/255)
copyPoseColor = Color3.new(150/255, 150/255, 200/255)


function copyPose(part, pose)

	if (copyPoseList[part.Name] == pose) then
		copyPoseList[part.Name].UI.BackgroundColor3 = poseColor
		copyPoseList[part.Name] = nil
		return
	elseif (copyPoseList[part.Name] ~= nil) then
		copyPoseList[part.Name].UI.BackgroundColor3 = poseColor
	end

	copyPoseList[part.Name] = pose
	pose.updateColor(true)
	
end

function resetCopyPoseList()
	for partName, pose in pairs(copyPoseList) do
		pose.updateColor(false)
	end
	copyPoseList = {}
end

function pastePoses()
	if (tablelength(copyPoseList) <= 0) then
		return
	end

	local keyframe = getKeyframe(cursorTime)
	if (keyframe == nil) then
		keyframe = createKeyframe(cursorTime)
	end

	for partName, pose in pairs(copyPoseList) do
		local item = partListByName[partName]
		if (keyframe.Poses[item.Item] ~= pose) then
			if (keyframe.Poses[item.Item] == nil) then
				keyframe.Poses[item.Item] = initializePose(keyframe, item.Item)
			end
			
			if keyframe.Poses[item.Item] then
				keyframe.Poses[item.Item].CFrame = pose.CFrame
				keyframe.Poses[item.Item].EasingDirection = pose.EasingDirection
				keyframe.Poses[item.Item].EasingStyle = pose.EasingStyle
				keyframe.Poses[item.Item].updateColor()
			end
		end
	end	

	resetCopyPoseList()
	updateCursorPosition()
end

function keyframeTimeClamp(time)
	-- clamp to their desired snapping property
	if time > animationLength then return animationLength end
	if preferences["Snapping"] then
		--time = round(time / (tickIncrements / 2))
		--time = time * animationFramerate
		time = time + (dragSnapIncrements / 2)
		local t = time - (time % dragSnapIncrements)
		return t
	end

	return time	
end

function deletePose(keyframe, part)
	local active = partInclude[part.Name]
	if (active and keyframe ~= nil and partToItemMap[part] ~= nil and partToItemMap[part].Motor6D ~= nil and keyframe.Poses[part] ~= nil) then

		-- remove pose if it is currently the copied pose for this part
		if (copyPoseList[part.Name] == keyframe.Poses[part]) then
			copyPoseList[part.Name] = nil
		end

		keyframe.Poses[part] = nil

		local ui = keyframe.UI:FindFirstChild('Pose' .. part.Name)

		if (ui ~= nil) then
			ui.Parent = nil
			unregisterOn(mouseOnRClick, ui)
			unregisterOn(mouseOnLClick, ui)
		end


		updateCursorPosition()
	end
end

function initializePose(keyframe, part, poseObject, override)
	local active = partInclude[part.Name]
	if ((not active and (override == false or override == nil)) or keyframe == nil) then
		return nil
	end
	
	local pose = keyframe.Poses[part]
	if (pose == nil and partToItemMap[part] ~= nil and partToItemMap[part].Motor6D ~= nil) then
		resetCopyPoseList()
		local previousPose = getClosestPose(keyframe.Time, part)
		pose = {}
		
		if (previousPose == nil) then
			pose.CFrame = CFrame.new()
		else
			pose.CFrame = previousPose.CFrame
		end
		
		local data = partToItemMap[part]
		pose.CFrame = getMotorC1(data, keyframe.Time) * data.OriginC1:inverse()
		
		pose.Item = partToItemMap[part]
		pose.Time = keyframe.Time
		
		if poseObject then
			pose.EasingStyle = poseObject.EasingStyle
			pose.EasingDirection = poseObject.EasingDirection
		else
			pose.EasingStyle = Enum.PoseEasingStyle.Linear
			pose.EasingDirection = Enum.PoseEasingDirection.Out
		end
		
		
		keyframe.Poses[part] = pose
		
		newPoseUI = Make('TextButton', {
			Parent = keyframe.UI,
			Name = 'Pose' .. part.Name,
			Style = 'Custom',
			Position = UD(0, -lineSize / 2 + 1, 0, ((partToLineNumber[part]) * (lineSize + marginSize) + lineSize / 3) - 8 - timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y),
			Size = UD(0, lineSize, 0, lineSize),
			BackgroundColor3 = poseColor,
			BackgroundTransparency = 0,
			Text = "",
			TextColor3 = Color3.new(1,1,1),
		})
		pose.UI = newPoseUI
		
		pose.updateUI = function()
			if partToLineNumber[part] then
				pose.UI.Position = UD(0, -lineSize / 2 + 1, 0, ((partToLineNumber[part]) * (lineSize + marginSize) + lineSize / 3) - 8 - timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
			end
		end

		newPoseUI.MouseButton1Click:connect(function()
			if isKeyDown("ctrl") then
				copyPose(part, pose)
			elseif isKeyDown("alt") then
				registerUndo( {
					action = "deletePose",
				})
				deletePose(keyframe, part)
			else
				modal = true
				menuManager.SetEasingStyle(pose, (function() modal = false  pose.updateColor() end))
			end
		end)

		pose.updateNodePosition = function()
			local shift = timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y
			pose.UI.Position = UD(0, -lineSize / 2 + 1, 0, ((partToLineNumber[part]) * (lineSize + marginSize) + lineSize / 3) - 8 - shift)
		end

		pose.updateColor = function(copy)
			if copy then
				pose.UI.BackgroundColor3 = copyPoseColor
			else
				local styleName = pose.EasingStyle.Name
				if styleName == "Linear" then
					pose.UI.Text = ""
					pose.UI.BackgroundColor3 = poseColor
				elseif styleName == "Constant" then
					pose.UI.Text = "-"
					pose.UI.BackgroundColor3 = Color3.new(61/255, 61/255, 61/255)
				elseif styleName == "Cubic" then
					pose.UI.Text = "C"
					pose.UI.BackgroundColor3 = Color3.new(255/255, 106/255, 0/255)
				elseif styleName == "Elastic" then
					pose.UI.Text = "E"
					pose.UI.BackgroundColor3 = Color3.new(71/255, 204/255, 86/255)
				elseif styleName == "Bounce" then
					pose.UI.Text = "B"
					pose.UI.BackgroundColor3 = Color3.new(14/255, 188/255, 204/255)
				else
					pose.UI.Text = "?"
					pose.UI.BackgroundColor3 = Color3.new(1,1,1)
				end
			end
		end
		
		--Initialize Pose
		pose.updateColor()

		registerOn(mouseOnRClick, newPoseUI, function(x, y)
			if (isKeyDown("shift") and keyframe.Time > 0) then
				deletePose(keyframe, part)
			end
			return true
		end)

		registerOn(mouseOnLClick, newPoseUI, function(x, y)
			if (isKeyDown("ctrl")) then
				copyPose(part, pose)
				return true
			end
			return false
		end)
	end
	return pose
end

function deleteKeyframe(time, undoRegister)
	if undoRegister == true then
		registerUndo( {
			action = "deleteKeyframe",
		})
	end
	time = keyframeTimeClamp(time)
	local keyframe = keyframeList[time]
	if (keyframe ~= nil) then
		for part, pose in pairs(keyframe.Poses) do
			deletePose(keyframe, pose.Item.Item)
		end
		keyframe.UI.Parent = nil
		keyframe.UI = nil
		keyframeList[time] = nil
	end
end

function createKeyframe(time, undoRegister)
	if (undoRegister == true or undoRegister == nil) and time > 0 then
		registerUndo( {
			action = "createKeyframe",
		})
	end
	time = keyframeTimeClamp(time)
	local newKeyframe = keyframeList[time]
	if (newKeyframe == nil) then
		newKeyframe = {
			Time = time,
			Poses = {},		
			Name = "Keyframe",
			UI = Make('Frame', {
				Parent = timelineUI.RootFrame.KeyframeContainer.TimelineFrame,
				Name = 'Keyframe' .. time,
				Style = 'Custom',
				Position = UD(0, --[[nameSize + marginSize + ]](time * timeScale), 0--[[ -lineSize - marginSize]]),
				Size = UD(0, 2, 0, (lineSize + marginSize) * (lineCount + 1)),
				BackgroundColor3 = Color3.new(200/255, 50/255, 150/255),
				BackgroundTransparency = 0,
				Make("TextButton", {
					Parent = timelineUI.RootFrame,
					Name = "OptionsButton",
					Size = UD(0, 12, 0, 12),
					Position = UD(0.5, -6, 0, 0),
					BackgroundColor3 = Color3.new(200/255, 50/255, 150/255),
					TextScaled = true,
					TextColor3 = GuiSettings.TextColor,
					Text = "...",
					ZIndex = 3,
				})
			}),
		}
		local OptionsButton	= newKeyframe.UI.OptionsButton	
		local function getXY()
			if not timelineUI:FindFirstChild("RootFrame") then
				return 0, 0
			end
			
			local x = newKeyframe.UI.AbsolutePosition.X - timelineUI.RootFrame.KeyframeContainer.TimelineFrame.AbsolutePosition.X
			local y = 0
			return x, y
		end
		
		newKeyframe.setPos = function(time)
			local pos = time * timeScale
			if newKeyframe.Time >= animationLength- 0.009 then
				pos = pos - 5
			end
			newKeyframe.UI.Position = UD(0, pos, 0, 0)
		end
		
		newKeyframe.adjust = function()
			newKeyframe.setPos(newKeyframe.Time)
		end
		newKeyframe.adjust()
		
		local function moveOptionsButton()
			if not timelineUI:FindFirstChild("RootFrame") then return end
			
			--[[local x, y = getXY()
			x = x + timelineUI.RootFrame.KeyframeContainer.TimelineFrame.AbsolutePosition.X
			local desiredX = (x - 6)
			local deltaX = desiredX - newKeyframe.UI.OptionsButton.AbsolutePosition.X
			OptionsButton.Position = newKeyframe.UI.OptionsButton.Position + UDim2.new(0, deltaX, 0, 0)]]
		end
		
		
		local mouseDownTime = 0
		local pos
		
		OptionsButton.MouseButton1Down:connect(function()
			lockUndoStep("keyframeMove")
			mouseDownTime = tick()
			pos = newKeyframe.Position
			selectedKeyframe = newKeyframe
		end)
		
		OptionsButton.MouseButton1Click:connect(function()
			mouseCallbackCheck(mouseOnLUp)
			--print("Clickup")
			local timeSinceMouseDown = tick() - mouseDownTime
			--If 2s passes since clicking or the pos is changed, do not open menu.
			if newKeyframe.Position ~= pos then return end
			if timeSinceMouseDown > 2 then return end
			
			local x, y = getXY()
			--print("Options menu")
			keyframeContextMenu(x, y, false)
		end)
		
		OptionsButton.MouseButton1Down:connect(function()
			--print("Options clicked")
			selectedKeyframe = newKeyframe
			local x, y = getXY()
			keyframePositionShift(x, y)
		end)

		
		newKeyframe.UI.Changed:connect(function()
			moveOptionsButton()
		end)
		moveOptionsButton()

		if (time <= 0.0) then
			for part,elem in pairs(partList) do
				initializePose(newKeyframe, part)
			end
		end

		keyframeList[time] = newKeyframe
	end
	return newKeyframe
end

function adjustKeyframes()
	for i, v in pairs(keyframeList) do
		--print("Adjusting "..tostring(i))
		v.adjust()
		for z, x in pairs(v.Poses) do
			x.updateNodePosition()
		end
	end
end

function resetKeyframeToDefaultPose(keyframe)
	for part, item in pairs(partList) do
		initializePose(keyframe, part)
		local pose = keyframe.Poses[part]
		if pose then
			pose.CFrame = CFrame.new()	
			item.Motor6D.C1 = item.OriginC1
			pose.EasingStyle = Enum.PoseEasingStyle.Linear
			pose.EasingDirection = Enum.PoseEasingDirection.Out
			pose.updateColor()
		end
	end
end

function moveKeyframe(keyframe, time)
	if (keyframeList[time] == nil) then
		registerUndo({
			action = "keyframeMove",
			keyframe = keyframe,
			oldTime = keyframe.Time,
		})
		keyframeList[keyframe.Time] = nil
		keyframe.Time = time
		for _, pose in pairs(keyframe.Poses) do
			pose.Time = keyframe.Time
		end
		keyframe.setPos(time)
		keyframeList[time] = keyframe
		updateCursorPosition()
		wait()
	end
end

function nudgeView()
	local mainPart = rootPart.Item
	mainPart.CFrame = mainPart.CFrame*CFrame.new(0, 1, 0)
	mainPart.CFrame = mainPart.CFrame*CFrame.new(0, -1, 0)
end

local function findTime(x)
	--The following line takes the larger
	timelineLength = math.max(timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset, timelineUI.RootFrame.KeyframeContainer.AbsoluteSize.X)
	timeScale =  timelineLength / animationLength
	local X = x-- - timelineUI.RootFrame.KeyframeContainer.CanvasPosition.X
	--print("finding time at "..tostring(X))
	local time = X / timeScale
	local clamped = keyframeTimeClamp(time)
	return clamped
end

function getKeyframe(time)
	time = keyframeTimeClamp(time)
	return keyframeList[time]
end

function getKeyframeData(part, time, createKeyframeIfNil, createPoseIfNil)
	local keyframe = getKeyframe(time)
	if (keyframe == nil and createKeyframeIfNil) then
		keyframe = createKeyframe(cursorTime)
	end

	if (keyframe ~= nil and partToItemMap[part] ~= nil and partToItemMap[part].Motor6D ~= nil) then
		if (keyframe.Poses[part] == nil and createPoseIfNil) then
			initializePose(keyframe, part)
		end
		return keyframe.Poses[part]
	else
		return nil
	end	
end

function getCurrentKeyframeData(part, createIfNil, createPoseIfNil)
	return getKeyframeData(part, cursorTime, createIfNil, createPoseIfNil)
end

function getClosestPose(time, part)
	local closestPose = nil
	
	for keyframeTime,  keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
		if keyframeTime > time then
			break
		end
		
		if keyframe.Poses[part] then
			closestPose = keyframe.Poses[part]
		end
	end

	return closestPose
end

function getClosestNextPose(time, part)
	local closestPose = nil
	
	for keyframeTime,  keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time > t[b].Time end) do
		if keyframeTime <= time then
			break
		end
		
		if keyframe.Poses[part] then
			closestPose = keyframe.Poses[part]
		end
	end

	return closestPose
end

function resetKeyframes()
	resetCopyPoseList()
	
	for time, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
		deleteKeyframe(time)
	end

	keyframeList = {}
end

function undo()
	--print("Memory: "..tostring(#undoMemory).." : "..tostring(#redoMemory))
	--undoMemory is table name
	--undoPointer refers to where in the table we are, for redo purposes
	if #undoMemory <= 0 then return end
	local undoStep = undoMemory[#undoMemory]
	table.remove(undoMemory, #undoMemory)
	local newUndo = createAnimationFromCurrentData()
	loadImportAnim(undoStep.undo)
	updateTimeLabels()
	undoStep.undo = newUndo
	table.insert(redoMemory, undoStep)
end

function redo()
	--print("Memory: "..tostring(#undoMemory).." : "..tostring(#redoMemory))
	if  #redoMemory > 0 then
		--print("CAN REDO")
		local redoStep = redoMemory[#redoMemory]
		local newRedo = createAnimationFromCurrentData()
		loadImportAnim(redoStep.undo)
		redoStep.undo = newRedo
		table.remove(redoMemory, #redoMemory)
		table.insert(undoMemory, redoStep)
	end
end

function registerUndo(a)
	--Trim stack, remove any undo steps
	redoMemory = {}
	----limbTransform
	if #undoMemory > 0 then
		--Because handle dragging and whatnot fire multiple times per action, we ignore repeated or similar actions.
		local lastAction = undoMemory[#undoMemory]
		if a.action == "editTransform" or a.action == "editRotate" or a.action == "keyframeMove" then
			if not (lastAction.action == a.action and lastAction.item == a.item) or (lastAction.locked == true) then
				a.undo = createAnimationFromCurrentData()
				--print("Registering undo "..a.action)
				table.insert(undoMemory, a)
			end
		else
			a.undo = createAnimationFromCurrentData()
			--print("Registering undo "..a.action)
			table.insert(undoMemory, a)
		end
	else
		a.undo = createAnimationFromCurrentData()
		--print("Registering undo "..a.action)
		table.insert(undoMemory, a)		
	end
end

--Basically, when you drag a keyframe or handle, you want to mark that as a "save". Locking the last undo step makes it not skip the next undo change even if the action is the same

function lockUndoStep(doublecheck)
	--print("Locking "..doublecheck)
	if #undoMemory > 0 then
		if undoMemory[#undoMemory].action == doublecheck then
			undoMemory[#undoMemory].locked = true
		end
	end
end

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- C U R S O R    C O D E
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
doNotUpdateCursor = false

local ShowingInEditorInterpolation = true

function toggleInEditorInterpolation()
	ShowingInEditorInterpolation = not ShowingInEditorInterpolation
	
	if ShowingInEditorInterpolation then
		menuUI.RootFrame.ToggleInterpolationButton.Text = "Lerp (on)"
	else
		menuUI.RootFrame.ToggleInterpolationButton.Text = "Lerp (off)"
	end
	
	updateCursorPosition()
end

function isJustTranslation(c1, c2)
	local x1, y1, z1, a1, b1, c1, d1, e1, f1, g1, h1, i1 = c1:components()
	local x2, y2, z2, a2, b2, c2, d2, e2, f2, g2, h2, i2 = c2:components()
	local dx = x2 - x1
	local dy = y2 - y1
	local dz = z2 - z1
	local da = a2 - a1
	local db = b2 - b1
	local dc = c2 - c1
	local dd = d2 - d1
	local de = e2 - e1
	local df = f2 - f1
	local dg = g2 - g1
	local dh = h2 - h1
	local di = i2 - i1
	
	local returnValue = true
	for _, delta in pairs{da, db, dc, dd, de, df, dg, dh, di} do
		if math.abs(delta) > 0.001 then
			returnValue = false
		end
	end
	
	return returnValue
end

function getMotorC1(data, time)
	time = keyframeTimeClamp(time)
	
	if data.Motor6D and data.Item then
		local part = data.Item
		local active = partInclude[part.Name]
		if active then
			local lastPose = getClosestPose(time, part)
			local nextPose = getClosestNextPose(time, part)
			
			if lastPose then
				if preferences["Interpolation"] and nextPose and (lastPose.CFrame ~= nextPose.CFrame) and (time ~= lastPose.Time) then
					local timeChunk = nextPose.Time - lastPose.Time
					local timeIn = time - lastPose.Time
					local weight = timeIn / timeChunk
					
					--print(lastPose.EasingStyle)
					weight = easingStyles.GetEasing(lastPose.EasingStyle.Name,lastPose.EasingDirection.Name, 1-weight)

					local lastCFrame = lastPose.CFrame
					local lastPosition = lastCFrame.p
					local lastRotation = (lastCFrame - lastPosition)
					
					local nextCFrame = nextPose.CFrame
					local nextPosition = nextCFrame.p
					local nextRotation = (nextCFrame - nextPosition)
										
					
					local retPos = lastPosition:Lerp(nextPosition, weight)
					local retRot = lastRotation:lerp(nextRotation, weight)
					
					local retVal = lastCFrame:inverse():lerp(nextCFrame:inverse(), weight):inverse() * data.OriginC1--this
					
					retVal = repairedCFrame(retVal)
					return retVal
				else
					return lastPose.CFrame * data.OriginC1
				end
			else
				return data.OriginC1
			end
		else
			return data.OriginC1
		end
	end
end

function updateCursorPosition()
	if (doNotUpdateCursor) then
		return
	end

	-- move UI
	local scroll = timelineUI.RootFrame.KeyframeContainer.CanvasPosition.X
	--timelineUI.RootFrame.Cursor.Position = UD(0, nameSize + marginSize - (lineSize / 2) + (cursorTime * timeScale), 0, (lineSize + marginSize))
	--Timeline 2.0
	local tweenPos = (cursorTime * timeScale) - (lineSize / 2)
	if cursorTime >= animationLength - 0.03 then
		tweenPos = tweenPos - 5
	end
	if preferences["TweenCursor"] then
		if timelineUI.Parent ~= nil then
			timelineUI.RootFrame.KeyframeContainer.Cursor:TweenPosition(UD(0, tweenPos, 0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y),"Out","Quad", 0.3, true)
		end	
	else
		timelineUI.RootFrame.KeyframeContainer.Cursor.Position = UD(0, tweenPos, 0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
	end
	
	--move the model
	for part, data in pairs(partList) do
		local active = partInclude[part.Name]
		if data.Motor6D then
			data.Motor6D.C1 = getMotorC1(data, cursorTime) --seen it
			updateProxyPart()
			nudgeView()
		end
	end
end

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
-- P A R T    S E L E C T I O N     C O D E
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
function selectPartUI(part)
	if not timelineUI then return end
	selectedLine.Parent = timelineUI.RootFrame.ScrollingFrame
	selectedLine.Position = UD(0, marginSize, 0,  23 + ((lineSize + marginSize) * (partToLineNumber[part] - 1)))
	selectedLine2.Parent = timelineUI.RootFrame.KeyframeContainer
	selectedLine2.Position = UD(0, marginSize, 0,  23 + ((lineSize + marginSize) * (partToLineNumber[part] - 1)))
end

function unselectPartUI()
	selectedLine.Parent = nil
	selectedLine2.Parent = nil
end
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
function repairWholeRig()
	for part, data in pairs(partList) do
		if data.Motor6D then
			--data.Motor6D.C0 = repairedCFrame(data.Motor6D.C0)
			--data.Motor6D.C1 = repairedCFrame(data.Motor6D.C1)
		end
	end	
end

------------------------------------------------------------
local function MakePartSelectGui(baseItem)
	local trueSize = Vector2.new(100, lineSize + marginSize * 3)
	local renderSize = Vector2.new(100, lineSize + marginSize * 2)
	
	if (rotateMoveUI == nil) then
		rotateMoveUI = Make('ScreenGui', 
		{	
			Name = "rotateMoveUI",
			
			--world/local space
			Make('Frame', {
				Name = 'SpaceFrame',
				Style = 'Custom',
				Position = UD(0, 15, 1.0, -15 - trueSize.Y * 3),
				Size = UD(0, renderSize.X, 0, renderSize.Y),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextButton', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Local Space (Y)",
					TextXAlignment = Enum.TextXAlignment.Center,
				}),
			}),
			
			--rotate/translate
			Make('Frame', {
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0, 15, 1.0, -15 - trueSize.Y * 2),
				Size = UD(0, renderSize.X, 0, renderSize.Y),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextButton', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Rotate (R)",
					TextXAlignment = Enum.TextXAlignment.Center,
				}),
			}),
			
			--steps!
			Make('Frame', {
				Name = 'StepFrame',
				Style = 'Custom',
				Position = UD(0, 15, 1.0, -15 - trueSize.Y),
				Size = UD(0, renderSize.X - renderSize.Y - 1, 0, renderSize.Y),
				BackgroundColor3 = Color3.new(50/255, 50/255, 50/255),
				BackgroundTransparency = 0.3,
				Make('TextButton', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Step: Free (T)",
					TextXAlignment = Enum.TextXAlignment.Center,
				}),
				Make('TextButton',{
					Name = 'StepOptions',
					Style = 'Custom',
					Position = UD(1, 2, 0, 0),
					Size = UD(0, renderSize.Y, 0, renderSize.Y),
					BackgroundTransparency = 0.5,
					--BackgroundColor3 = Color3.new(50/255, 50/255, 50/255),
					TextColor3 = Color3.new(1,1,1),
					BorderSizePixel = 1,
					Text = '...',
					ZIndex = 2,
				}),
			}),
		})
	end

	--selection boxes
	local mHoverBox = Make('SelectionBox', {
		Name = "HoverBox",
		Color = envRoot.AnimationEditor.Customize.MouseoverColor.Value,
		Transparency = 0.5,
		LineThickness = 0.02,
		Parent = game:GetService("CoreGui"),
		Archivable = false,
	})
	
	local HoverBoxes = {}
	local SelectionBoxes = {}

	local mSelectBox = Make('SelectionBox', {
		Name = "SelectBox",
		Color = envRoot.AnimationEditor.Customize.SelectedColor.Value,--Legit selection box
		Transparency = 0,
		LineThickness = 0.02,
		Parent = game:GetService("CoreGui"),
		Archivable = false,
	})

	local mDragHandles = Make('Handles', {
		Color = BrickColor.new"Black",--BrickColor.new(23),
--		Style = 'Resize',
		Style = 'Movement',
		Parent = game:GetService('CoreGui'),
		Archivable = false,
	})

	local mProxyPart = Make('Part', {
--		Size = Vector3.new(0.8,0.8,0.8);
		Size = Vector3.new(0.8,0.8,0.8),
		Name = 'ProxyPart',
		Shape = 'Ball',
		Archivable = false,
		Parent = game.Workspace,
		BrickColor = BrickColor.new(23),
		Anchored = false,
		CanCollide = false,
		Transparency = 0.5,
		TopSurface = 'Smooth',
		BottomSurface = 'Smooth',
	})	

	local mRotateHandles = Make('ArcHandles', {
		Color = BrickColor.new(23),
		Parent = game:GetService('CoreGui'),
		Archivable = false,
	})


	local mHover = nil
	local mCanOffset = nil
	local mShowControls = nil
	local mStartTransformCF = nil
	local mProxyWeld = nil
	
	local InWorldSpace = false
	local PartCFrameAtTransformStart = nil
	-------------

	function displayHandles()
		if (partSelection ~= nil) then
			local item = partSelection

			mProxyPart.Size = Vector3.new(0.2, 0.2, 0.2)
			updateProxyPart()

			if (rotateMode) then
				mRotateHandles.Adornee = mProxyPart
				mDragHandles.Adornee = nil
			else
				mRotateHandles.Adornee = nil
				mDragHandles.Adornee = mProxyPart
			end
		end
	end
	
	function updateProxyPart()
		if partSelection then
			local item = partSelection
			
			--Get 2nd largest dimension of the part!
			local sx = item.Item.Size.X
			local sy = item.Item.Size.Y
			local sz = item.Item.Size.Z
			--local dim = math.min(math.max(sx,sy), math.max(sx,sz))
			local dim = math.min(math.min(sx,sy), math.min(sx,sz))
			mProxyPart.Size = Vector3.new(dim, dim, dim)
			
			if (mProxyWeld ~= nil) then
				mProxyWeld:Destroy()
			end
			
			local pivotCFrame = (item.Motor6D.Part0.CFrame * item.Motor6D.C0)
			local pivotInOriginPartSpace = (item.Motor6D.Part0.CFrame * item.Motor6D.C0 * item.OriginC1:inverse()):toObjectSpace(pivotCFrame)
			local point = item.Item.CFrame:toWorldSpace(pivotInOriginPartSpace).p
			
			if InWorldSpace then
				mProxyPart.CFrame = CFrame.new(point)
			else
				mProxyPart.CFrame = item.Item.CFrame + (point - item.Item.CFrame.p)
			end
			mProxyWeld = weldBetween(item.Item, mProxyPart, mProxyPart)
		end
	end

	function toggleHandles()
		if (partSelection ~= nil) then
			rotateMode = not rotateMode
			if (rotateMode) then
				rotateMoveUI.RootFrame.TitleBar.Text = "Rotate (R)"
			else
				rotateMoveUI.RootFrame.TitleBar.Text = "Move (R)"
			end
			updateStepDisplay()
			displayHandles()
		end
	end
	
	function toggleTransformSpace()
		InWorldSpace = not InWorldSpace
		
		if InWorldSpace then
			rotateMoveUI.SpaceFrame.TitleBar.Text = "World Space (Y)"
		else
			rotateMoveUI.SpaceFrame.TitleBar.Text = "Local Space (Y)"
		end
		
		updateProxyPart()
	end

	function toggleStep()
		if (partSelection ~= nil) then
			if (rotateMode) then
				if (rotateStep == 0) then
					rotateStep = 10
				elseif (rotateStep == 10) then
					rotateStep = 45
				else
					rotateStep = 0
				end
			else
				if (moveStep == 0) then
					moveStep = 0.2
				elseif (moveStep == 0.2) then
					moveStep = 1
				else
					moveStep = 0
				end
			end
			updateStepDisplay()
			displayHandles()
		end
	end

	function updateStepDisplay()
		if (rotateMode) then
			if (rotateStep == 0) then
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: Free (T)"
			elseif (rotateStep == 10) then
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: 10 (T)"
			elseif rotateStep == 45 then
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: 45 (T)"
			else
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: "..tostring(rotateStep).." (T)"
			end
		else
			if (moveStep == 0) then
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: Free (T)"
			elseif (moveStep == 0.2) then
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: 0.2 (T)"
			elseif moveStep == 1 then
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: 1 (T)"
			else
				rotateMoveUI.StepFrame.TitleBar.Text = "Step: "..tostring(moveStep).." (T)"
			end
		end
	end


	local function setSelection(item, showControls, canoffset)
		partSelection = item
		if item then
			mSelectBox.Adornee = item.Item
			selectPartUI(item.Item)
		else
			mSelectBox.Adornee = nil
			unselectPartUI()
		end
		mDragHandles.Adornee = nil
		mRotateHandles.Adornee = nil
		mProxyPart.Parent = nil
		mCanOffset = canoffset
		mShowControls = showControls
		if showControls then
			if canoffset then
				displayHandles()
			else
				mSelectBox.Adornee = nil
				mRotateHandles.Adornee = mProxyPart
				mProxyPart.Parent = game.Workspace
				if item then
					mProxyPart.CFrame = item.Item.CFrame * item.OriginC1
				end
			end
			if rotateMoveUI then
				rotateMoveUI.Parent = game:GetService("CoreGui")
			end
		else
			if rotateMoveUI then
				rotateMoveUI.Parent = nil
			end
		end
	end

	local function getSelection()
		return partSelection
	end
	
	function getHandleSelection()
		return partSelection
	end
	
	function resetHandleSelection()
		setSelection(nil, false, false)
	end

	function setHandleSelection(item)
		setSelection(item, true, true)
	end

	-------------
	-- used for keyframe settings
	local  mKeyframeData = { 
		CanOffset = true,
	}

	mRotateHandles.MouseDrag:connect(function(axisRaw, relAngle, delRadius)
		if (not modal) then
			local rotateStepRad = (rotateStep / 180 ) * math.pi
			if rotateStepRad > 0 then
				relAngle =  math.floor((relAngle / rotateStepRad) + 0.5) * rotateStepRad
			end

			local item = getSelection()
			local part = item.Item
			local kfd = getCurrentKeyframeData(part, true, true)

			local transform = CFrame.fromAxisAngle(Vector3.FromAxis(axisRaw), -relAngle)
			
			registerUndo( {
				action = "editRotate",
				keyframe = kfd,
				oldKeyframeCFrame = kfd.CFrame,
				item = item,
				oldC1 = item.Motor6D.C1
			})
			
			if InWorldSpace then
				transform = CFrame.fromAxisAngle(Vector3.FromAxis(axisRaw), relAngle)
				
				local pivotCFrame = item.Motor6D.Part0.CFrame * item.Motor6D.C0
				local pivotPosition = (PartCFrameAtTransformStart * item.OriginC1).p
				local delta = pivotPosition - pivotCFrame.p
				pivotCFrame = pivotCFrame + delta
				
				local relativeToPivot = pivotCFrame:toObjectSpace(PartCFrameAtTransformStart)
				local newPartCFrame = (transform * (pivotCFrame - pivotCFrame.p) + pivotCFrame.p):toWorldSpace(relativeToPivot)
				
				local newMotorC1 = repairedCFrame(newPartCFrame:inverse() * (pivotCFrame - delta))
				kfd.CFrame = newMotorC1 * item.OriginC1:inverse()
				item.Motor6D.C1 = newMotorC1
			else
				local partcf = item.Motor6D.Part0.CFrame * item.Motor6D.C0 * 
							   mStartTransformCF * transform:inverse() *
							   item.OriginC1:inverse()
				local cf = partcf:inverse() * 
						   item.Motor6D.Part0.CFrame * item.Motor6D.C0 
						   * item.OriginC1:inverse()

				local A = item.Motor6D.Part0.CFrame
				local B = item.Motor6D.C0 
				local C = transform
				local D = mStartTransformCF
				local E = item.OriginC1
				local F = part.CFrame

				local ARot = item.Motor6D.Part0.CFrame - item.Motor6D.Part0.CFrame.p
				local BRot = item.Motor6D.C0 - item.Motor6D.C0.p
				local ERot = E - E.p
				local ETrans = CFrame.new(E.p)

				kfd.CFrame = (ETrans * C * ETrans:inverse() * D)
				item.Motor6D.C1 = (kfd.CFrame*item.OriginC1)
			end
			
			nudgeView()
			updateProxyPart()
		end

	end)


	mRotateHandles.MouseButton1Down:connect(function() 
		if (not modal) then
			local item = getSelection()
			local part = item.Item
			local kfd = getCurrentKeyframeData(part, true, true)
			if mKeyframeData.CanOffset then
				mStartTransformCF = kfd.CFrame
			else
				mStartTransformCF = item.Motor6D.C0:inverse() * item.Motor6D.Part0.CFrame:inverse() *
				                    part.CFrame * item.OriginC1
			end
			
			PartCFrameAtTransformStart = part.CFrame
		end
	end)
	
	mRotateHandles.MouseButton1Up:connect(function()
		lockUndoStep("editRotate")
	end)


	mDragHandles.MouseDrag:connect(function(face, dist)
		if (not modal) then
			if moveStep > 0 then
				dist = math.floor(dist / moveStep) * moveStep
			end
			
			local item = getSelection()
			local part = item.Item
			local kfd = getCurrentKeyframeData(part, true, true)
			
			registerUndo( {
				action = "editTransform",
				keyframe = kfd,
				oldKeyframeCFrame = kfd.CFrame,
				item = item,
				oldC1 = item.Motor6D.C1
			})
			
			if InWorldSpace then
				local translation = Vector3.FromNormalId(face) * dist -- good
				
				local newPartCFrame = PartCFrameAtTransformStart + translation -- good
				
				
				local pivotCFrame = item.Motor6D.Part0.CFrame * item.Motor6D.C0
				
				local newMotorC1 = repairedCFrame(newPartCFrame:inverse() * pivotCFrame)
				kfd.CFrame = (newMotorC1 * item.OriginC1:inverse())
				item.Motor6D.C1 = (newMotorC1)
			else
				axis = Vector3.FromNormalId(face)

				kfd.CFrame = (CFrame.new(-axis*dist)*mStartTransformCF)
				item.Motor6D.C1 = (kfd.CFrame*item.OriginC1)
			end
			
			nudgeView()
			updateProxyPart()
		end
	end)

	mDragHandles.MouseButton1Down:connect(function() 
		if (not modal) then
			local item = getSelection()
			local part = item.Item
			local kfd = getCurrentKeyframeData(part, true, true)
			mStartTransformCF = kfd.CFrame
			
			PartCFrameAtTransformStart = part.CFrame
		end
	end)
	
	mDragHandles.MouseButton1Up:connect(function()
		lockUndoStep("editTransform")
	end)

	local mouse = plugin:GetMouse()

	MouseTargeterHalt = Repeat(function()
		local part = mouseRaycast{}
		if part then
			part = findAnimatedPart(part)
			if part then
				part = part.Item
			end
		end
		
		if part ~= mHover  and _G["AnimationEdit"] == true then
			mHover = part
			
			--clear old hover boxes
			for _, hoverBox in pairs(HoverBoxes) do
				hoverBox:Destroy()
			end
			
			--make new hover boxes
			local model = Instance.new("Model")
			for _, chunkPart in pairs(getAnimatedChunk(part)) do
				local newPart = chunkPart:Clone()
				if newPart then
					newPart.Parent = model
					
					if partToItemMap[chunkPart] then
						model.PrimaryPart = newPart
					end
				end
			end
			local selectionPart = Make("Part", {
				Name = 'SelectionPart',
				Transparency = 1,
				Anchored = true,
				CanCollide = false,
				Archivable = false,
				CFrame = model:GetModelCFrame(),
				Parent = workspace,
			})
			--this can't be in the table since form factor must be set first
			selectionPart.Size = model:GetExtentsSize()
			
			table.insert(HoverBoxes, selectionPart)
			
			local hoverBox = Make("SelectionBox", {
				Name = "HoverBox2",
				LineThickness = 0.02,
				Archivable = false,
				Adornee = selectionPart,
				Parent = game:GetService("CoreGui"),
				Color = envRoot.AnimationEditor.Customize.MouseoverColor.Value,
			})
			table.insert(HoverBoxes, hoverBox)
		end
	end)

	function destroySelectionBoxes()
		if (mSelectBox) then
			mSelectBox.Adornee = nil
			mSelectBox.Parent = nil
		end
		if (mHoverBox) then
			mHoverBox.Adornee = nil
			mHoverBox.Parent = nil
		end
		if (mDragHandles) then
			mDragHandles.Adornee = nil
			mDragHandles.Parent = nil
		end
		if (mRotateHandles) then
			mRotateHandles.Adornee = nil
			mRotateHandles.Parent = nil
		end
		if (mProxyPart) then
			mProxyPart:Destroy()
		end
		
		for _, hoverBox in pairs(HoverBoxes) do
			hoverBox:Destroy()
		end
		
		for i, v in pairs(cleanup) do
			v:Destroy()
		end
	end
	
	function tableHasValue(t, v)
		for _, val in pairs(t) do
			if val == v then
				return true
			end
		end
		return false
	end
	
	function getAnimatedChunk(part)
		local parts = {part}
		
		local function recurse(parent)
			if not parent then return end
			
			for _, child in pairs(parent:GetConnectedParts()) do
				if (not partToItemMap[child]) and (not tableHasValue(parts, child)) then
					table.insert(parts, child)
					recurse(child)
				end
			end
		end
		recurse(part)
		
		return parts
	end
	
	function findAnimatedPart(clickedPart, partsChecked)
		partsChecked = partsChecked or {}
		
		if tableHasValue(partsChecked, clickedPart) then return end
		table.insert(partsChecked, clickedPart)
		
		if partToItemMap[clickedPart] then
			return partToItemMap[clickedPart]
		end
		
		for _, part in pairs(clickedPart:GetConnectedParts()) do
			local animatedPart = findAnimatedPart(part, partsChecked)
			if animatedPart then
				return animatedPart
			end
		end
		
		return nil
	end

	registerOn(mouseOnLClick, nil, function()
		if not rootPart then return end
		
		if (not modal) then
			local part, point, normal = mouseRaycast{mProxyPart, rootPart.Item}
			
			if (part ~= nil) then
				local item = findAnimatedPart(part)
				local active = false
				if item then
					active = partInclude[item.Item.Name]
				end

				if (active and item ~= rootPart) then
					if (item ~= nil) then
						setSelection(item, true, true) --select it, (true = with movement controls)
					else
						setSelection(nil, false, false) --select it, (true = with movement controls)
					end
				else
					setSelection(nil, false, false)
				end
			else
				setSelection(nil, false, false) --select it, (true = with movement controls)
			end
		end
		return false
	end)

	rotateMoveUI.RootFrame.TitleBar.MouseButton1Click:connect(function()
		toggleHandles()
	end)

	rotateMoveUI.StepFrame.TitleBar.MouseButton1Click:connect(function()
		toggleStep()
	end)
	
	rotateMoveUI.StepFrame.StepOptions.MouseButton1Click:connect(function()
		if modal then return end
		modal = true
		local input = tonumber(menuManager.PromptInput("Interval:","<degrees>"))
		if input ~= nil and input > 0 then
				if rotateMode then
					rotateStep = input
				else
					moveStep = input
				end
			updateStepDisplay()
		end
		modal = false
	end)
	
	rotateMoveUI.SpaceFrame.TitleBar.MouseButton1Click:connect(function()
		toggleTransformSpace()
	end)

	

--[[
	registerOn(registerOn(mouseOnLClick, nil, function()
		local part = mouse.Target

		--clamp the selection to a single 
--		local sel = mKeyframeStrip.getSelection()

		--do selection
		local item = mPartToItemMap[part]
		if item and mKeyframeData.Enabled[item] then
			--ne selection? Pretend we're at frame 1
			if sel.x == 0 then sel.x = 1 end

			--clamp the selection to one x value for editing
			mKeyframeStrip.setSlider(sel.x)
			local kfdata = mKeyframeData[sel.x][item]
			mKeyframeStrip.setItemSelection(item)
			local canoffset = mKeyframeData.CanOffset
			if item.Motor6D and kfdata then
				mPartSelection.setSelection(item, true, canoffset) --select it, (true = with movement controls)
			else
				mPartSelection.setSelection(item, false, canoffset) --it's the root, false => no controls
			end
		end
	end))
--]]

end

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------



-----------------------------------------------------

GuiSettings = {}
GuiSettings.TextLarge = 'Size24'
GuiSettings.TextMed = 'Size18'
GuiSettings.TextSmall = 'Size14'
GuiSettings.TextColor = Color3.new(221/255, 221/255, 221/255)

guiWindow = nil


local function selectObjectToAnimate()
	-- creating test GUI
	if (guiWindow == nil) then

		guiWindow = Make('ScreenGui', 
		{
			Name = "TestGUI",
			Make('Frame', {
				Parent = guiWindow,
				Name = 'TestFrame',
				Style = 'DropShadow',
				Position = UD(0.5, -200, 0.8, -100),
				Size = UD(0, 400, 0, 130),
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Size = UD(1, 0, 0, 20),
					BackgroundTransparency = 1,
					Text = "Select the root part of your rig",
				}),
				Make('TextLabel', {
					Name = 'SelectionText',
					Font = 'Arial',
					FontSize = GuiSettings.TextSmall,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0, 100, 0, 20),
					Size = UD(1, -100, 0, 20),
					BackgroundTransparency = 1,
					---------------------------
					Text = "<none>",
				}),
				Make('TextButton', {
					Name = 'OkayButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextSmall,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0, 0, 0, 40),
					Size = UD(0.5, 0, 0, 30),
					Style = 'RobloxRoundDefaultButton',
					Visible = false,
					--------------------------
					Text = "Okay",
				}),
				------------------------------
				Make('TextButton', {
					Name = 'HelpButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextSmall,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0, 0, 0, 80),
					Size = UD(1, 0, 0, 30),
					Style = 'RobloxRoundButton',
					--------------------------
					Text = "Need Help? Click Here!",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextSmall,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.5, 0, 0, 40),
					Size = UD(0.5, 0, 0, 30),
					Style = 'RobloxRoundButton',
					---------------------------
					Text = "Cancel",
				}),
			}),
		})

	end


	--------------------------------
	local mSelectionHoverBox = Make('SelectionBox', {
		Name = 'AnimEdit_SelectionBox',
		Color = envRoot.AnimationEditor.Customize.MouseoverColor.Value,--BrickColor.new(21),
		Transparency = 0.5,
		Parent = game:GetService("CoreGui"),
	})

	local mSelectionBox = Make('SelectionBox', {
		Name = 'AnimEdit_SelectionBox',
		Color = envRoot.AnimationEditor.Customize.MouseoverColor.Value,--BrickColor.new(23),
		Parent = game:GetService("CoreGui"),
	})

	local mCurrentSelection = nil
	local mHoverRepeater = nil
	local mOnClickCn
	local waitLock = true

	local mouse = plugin:GetMouse()



	local halt = Repeat(function() mSelectionHoverBox.Adornee = mouse.Target end)

--[[
	Spawn(function()
		while mFlag do
			mSelectionHoverBox.Adornee = mouse.Target
			wait()
		end	
	end)

	local function halt()
		mFlag = false
	end
--]]

	---------------------------
	local function delete()
		if mOnClickCn then
			mOnClickCn:disconnect()
			mOnClickCn = nil
		end
		mSelectionBox.Adornee = nil
		mSelectionHoverBox.Adornee = nil
		mSelectionBox.Parent = nil
		mSelectionHoverBox.Parent = nil
		halt()
	end
	
	local GetAbsoluteRoot = function(what)
		local possibleRoot = what:GetRootPart()
		local found = nil
		local getRoot
		getRoot = function(p)
			for i, v in pairs(p:GetChildren()) do
				if v:IsA("Motor6D") and v.Part1 == possibleRoot then
					found = v.Part0
				elseif v:IsA("BasePart") or v:IsA("Model") then
					getRoot(v)
				end
			end
		end
		getRoot(possibleRoot.Parent)
		if found then return found end
		return possibleRoot
		
	end

	local function setCurrentSelection(selection)

		if (selection == nil) then
			return
		end

		--selection = selection:GetRootPart(selection)
		selection = GetAbsoluteRoot(selection)
		if not selection then return end

		local tempAnimControl = selection.Parent:FindFirstChild("Humanoid")

		tempAnimControl = selection.Parent:FindFirstChild("Humanoid")
		if (not tempAnimControl) then
			tempAnimControl = selection.Parent:FindFirstChild("AnimationController")
			if (not tempAnimControl) then
				warn("Animation Editor was unable to find a Humanoid or AnimationController in the selected model.")
				_G["AnimationEdit"] = false
				return
			end
		end

		animationController = tempAnimControl

		mCurrentSelection = selection	
		mSelectionBox.Adornee = selection

		if selection then
			guiWindow.TestFrame.OkayButton.Visible = true
			guiWindow.TestFrame.SelectionText.Text = selection.Name
			if not selection.Anchored then
				local issuePart = selection
				guiWindow.TestFrame.SelectionText.TextColor3 = Color3.new(1,0,0)
				guiWindow.TestFrame.SelectionText.Text = guiWindow.TestFrame.SelectionText.Text.."  [Warning: Unanchored]"
				repeat wait() 
				until selection == nil or selection ~= issuePart or selection.Anchored == true
				if selection == issuePart and issuePart.Anchored == true then
					guiWindow.TestFrame.SelectionText.Text = issuePart.Name.."  [Resolved]"
					guiWindow.TestFrame.SelectionText.TextColor3 = Color3.new(1,1,1)
				elseif selection ~= issuePart and (selection == nil or selection.Anchored == false) then
					guiWindow.TestFrame.SelectionText.TextColor3 = Color3.new(1,1,1)
				end
			else
				guiWindow.TestFrame.SelectionText.TextColor3 = Color3.new(1,1,1)
			end
		else
			guiWindow.TestFrame.OkayButton.Visible = false
			guiWindow.TestFrame.SelectionText.Text = "<none>"
			guiWindow.TestFrame.SelectionText.TextColor3 = Color3.new(1,1,1)
		end

	end

	local function getSelection()
		return mCurrentSelection
	end

	mOnClickCn = mouse.Button1Down:connect(function()
		setCurrentSelection(mouse.Target)
	end)


	guiWindow.TestFrame.OkayButton.MouseButton1Click:connect(function()
		delete()
		waitLock = false
	end)
	guiWindow.TestFrame.CancelButton.MouseButton1Click:connect(function()
		mCurrentSelection = nil
		delete()
		waitLock = false
		exitPlugin()
	end)
	guiWindow.TestFrame.HelpButton.MouseButton1Click:connect(function()
		local success, msg = pcall(function()
			plugin:OpenWikiPage("Animations")
		end)
		if not success then
			guiWindow.TestFrame.HelpButton.Text = "Coming Very Soon!"
		end
	end)

	-- reset GUI from previous incarnations
	guiWindow.TestFrame.OkayButton.Visible = false
	guiWindow.TestFrame.SelectionText.Text = "<none>"

	guiWindow.Parent = game:GetService("CoreGui")

	while (waitLock) do
		wait()
	end

	-- clean up selection stuff
	delete()
	guiWindow.Parent = nil
	return mCurrentSelection
end



loadButtonList = {}

function showLoadGame()
	if (loadUI == nil) then
		loadUI = Make('ScreenGui', 
		{	
			Name = "LoadUI",
			Make('Frame', {
				Parent = timelineUI,
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 200, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Load:",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
			}),
		})
	end

	-- clean up old buttons
	for _, part in pairs(loadButtonList) do
		part.Parent = nil
	end

	local humanoid = rootPart.Item.Parent
	local AnimationBlock = humanoid:FindFirstChild("AnimSaves")
	local fileCount = 0

	if (AnimationBlock ~= nil) then
		-- add button for saved games
		for _, childPart in pairs(AnimationBlock:GetChildren()) do
			if (childPart:IsA("KeyframeSequence")) then
				local newButton = Make('TextButton', {
					Parent = loadUI.RootFrame,
					Name = childPart.Name,
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * (1 + fileCount * 2)),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = childPart.Name,
				})
				fileCount = fileCount + 1	
				loadButtonList[fileCount] = newButton


				newButton.MouseButton1Click:connect(function()
					loadUI.Parent = nil
					loadCurrentAnimation(childPart.Name)
					modal = false
				end)

			end
		end
	end

	if (fileCount > 0) then
		local newButton = Make('TextButton', {
			Parent = loadUI.RootFrame,
			Name = 'CancelButton',
			Font = 'ArialBold',
			FontSize = GuiSettings.TextMed,
			TextColor3 = GuiSettings.TextColor,
			Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * (1 + fileCount * 2)),
			Size = UD(0.9, 0, 0, lineSize * 2),
			BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
			BackgroundTransparency = 0,
			Text = 'Cancel',
		})
		fileCount = fileCount + 1	
		loadButtonList[fileCount] = newButton

		newButton.MouseButton1Click:connect(function()
			loadUI.Parent = nil
			modal = false
		end)

		loadUI.RootFrame.Size = UD(0, 200, 0, marginSize + (lineSize + marginSize) * (1 + fileCount * 2))
		loadUI.Parent = game:GetService("CoreGui")
	else
		modal = false
	end
end

function showExportAnim()
	-- Update the model to start positions
	local motorOrig = {}
	for part,elem in pairs(partList) do
		if (elem.Motor6D ~= nil) then
			elem.Motor6D.C1 = elem.OriginC1
			nudgeView()
		end
	end

	local kfsp = game:GetService('KeyframeSequenceProvider')

	local kfs = createAnimationFromCurrentData()
	local animID = kfsp:RegisterKeyframeSequence(kfs)
	local dummy = rootPart.Item.Parent

-- EXPORT HERE
--			print("AnimID = " .. animID)

	local AnimationBlock = dummy:FindFirstChild("AnimSaves")
	if AnimationBlock == nil then
		AnimationBlock = Instance.new('Model')
		AnimationBlock.Name = "AnimSaves"
		AnimationBlock.Parent = dummy
	end

	local Animation = AnimationBlock:FindFirstChild("ExportAnim")
	if Animation == nil then
		Animation = Instance.new('Animation')
		Animation.Name = "ExportAnim"
		Animation.Parent = AnimationBlock
	end
	Animation.AnimationId = animID

	local OldKeyframeSqeuence = Animation:FindFirstChild("Test")
	if OldKeyframeSqeuence ~= nil then
--		print("Found old sequence")
		OldKeyframeSqeuence.Parent = nil
	end

	kfs.Parent = Animation

	local selectionSet = {}
	table.insert(selectionSet, kfs)

	game.Selection:Set(selectionSet)
	wait()
	plugin:SaveSelectedToRoblox()

--[[
	local selectionSet = {}
	table.insert(selectionSet, Animation)

	game.Selection:Set(selectionSet)
	wait()
	plugin:SaveSelectedToRoblox()
--]]

	modal = false
end


function showImportAnimText()
	local id = plugin:PromptForExistingAssetId("Animation")
	if (id ~= nil and tonumber(id) > 0) then
		  loadImportAnim(tonumber(id))
	end
end
					

function showImportAnim()
	local animPage = 1
	local userID = plugin:GetStudioUserId()
	local kfsp = game:GetService('KeyframeSequenceProvider')
	local animList = kfsp:GetAnimations(userID, animPage)

	if (loadUI == nil) then
		loadUI = Make('ScreenGui', 
		{	
			Name = "LoadUI",
			Make('Frame', {
				Parent = timelineUI,
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.25, 0),
				Size = UD(0, 200, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Load:",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
			}),
		})
	end

	-- clean up old buttons
	for _, part in pairs(loadButtonList) do
		part.Parent = nil
	end

	local humanoid = rootPart.Item.Parent
	local AnimationBlock = humanoid:FindFirstChild("AnimSaves")
	local fileCount = 0
	local rowCount = 0

--[[
	print("Anims Loaded " .. #animList)
	for _, childPart in pairs(animList) do
		print("File - " .. childPart.Name)
	end
--]]
	if (animList ~= nil) then
		-- add button for saved games
		for _, childPart in pairs(animList) do
			local newButton = Make('TextButton', {
				Parent = loadUI.RootFrame,
				Name = childPart.Name,
				Font = 'ArialBold',
				FontSize = GuiSettings.TextMed,
				TextColor3 = GuiSettings.TextColor,
				Position = UD(0, 10 + 200 * rowCount, 0, marginSize + (lineSize + marginSize) * (1 + fileCount * 2)),
				Size = UD(0, 180, 0, lineSize * 2),
				BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
				BackgroundTransparency = 0,
				Text = childPart.Name,
			})
			fileCount = fileCount + 1	
			if (fileCount > 10) then
				fileCount = 0
				rowCount = rowCount + 1
			end
			loadButtonList[fileCount] = newButton


			newButton.MouseButton1Click:connect(function()
				loadUI.Parent = nil
				loadImportAnim(childPart.Id)
				modal = false
			end)
		end
	end

--	print("File Count " .. fileCount)
	if (fileCount > 0 or rowCount > 0) then
		local newButton = Make('TextButton', {
			Parent = loadUI.RootFrame,
			Name = 'CancelButton',
			Font = 'ArialBold',
			FontSize = GuiSettings.TextMed,
			TextColor3 = GuiSettings.TextColor,
			Position = UD(0, 10 + 200 * rowCount, 0, marginSize + (lineSize + marginSize) * (1 + fileCount * 2)),
			Size = UD(0, 180, 0, lineSize * 2),
			BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
			BackgroundTransparency = 0,
			Text = 'Cancel',
		})
		fileCount = fileCount + 1	
		loadButtonList[fileCount] = newButton

		newButton.MouseButton1Click:connect(function()
			loadUI.Parent = nil
			modal = false
		end)

		loadUI.RootFrame.Size = UD(0, 200  * (rowCount + 1), 0, marginSize + (lineSize + marginSize) * (1 + fileCount * 2))
		loadUI.Parent = game:GetService("CoreGui")
	else
		modal = false
	end

end

function importPose(keyframe, pose)
	item = partListByName[pose.Name]
	if (item ~= nil) then
		LocalPose = initializePose(keyframe, item.Item, pose, true)
		if (LocalPose ~= nil) then
			if (item.OriginC1 ~= nil) then
				LocalPose.CFrame = item.OriginC1*pose.CFrame:inverse()*item.OriginC1:inverse()
			else
				LocalPose.CFrame = pose.CFrame
			end
			
			-- Easing Style Importing
			LocalPose.EasingStyle = pose.EasingStyle
			LocalPose.EasingDirection = pose.EasingDirection
			LocalPose.updateColor()
			
			if (pose.Parent:IsA('Pose')) and (pose.Weight > 0) then
				importPartInclude[pose.Name] = true
			end
		end
	end

	for id, childPose in pairs(pose:GetChildren()) do
		importPose(keyframe, childPose)
	end
end

--AbstractAlex rewrite of importPose
function loadPose(keyframe, pose)
	local item = partListByName[pose.Name]
	if item ~= nil and pose.Weight > 0 then
		local LocalPose = initializePose(keyframe, item.Item, pose, true)
		if (LocalPose ~= nil) then
			if (item.OriginC1 ~= nil) then
				LocalPose.CFrame = item.OriginC1*pose.CFrame:inverse()*item.OriginC1:inverse()
			else
				LocalPose.CFrame = pose.CFrame
			end
			
			--Easing Style Importing
			LocalPose.EasingStyle = pose.EasingStyle
			LocalPose.EasingDirection = pose.EasingDirection
			LocalPose.updateColor()
			
			if (pose.Parent:IsA('Pose')) and (pose.Weight > 0) then
				importPartInclude[pose.Name] = true
			end
		end
	end

	for id, childPose in pairs(pose:GetChildren()) do
		loadPose(keyframe, childPose)
	end
end

importPartInclude = {} --What is this? Todo: Remove this and see if anything breaks. It's declared in loadKeyframeSequence

function loadImportAnim(animId)
	---------------------------------
	-------------NEW-----------------
	---------------------------------
	local isNumber = type(animId) == "number"
	local isUserdata = type(animId) == "userdata"
	
	if (isNumber and animId > 0) or isUserdata then
		doNotUpdateCursor = true
		resetKeyframes()
		importPartInclude = {}

		local kfs
		if isNumber then
			local kfsp = game:GetService('KeyframeSequenceProvider')
			kfs = kfsp:GetKeyframeSequenceById(animId, false) -- Test 2
		else
			kfs = animId
		end	
		loadKeyframeSequence(kfs)
	end
		
	---------------------------------
	-------------OLD-----------------
	---------------------------------
	--[[
	local isNumber = type(animId) == "number"
	local isUserdata = type(animId) == "userdata"
	
	if (isNumber and animId > 0) or isUserdata then
		doNotUpdateCursor = true
		resetKeyframes()
		importPartInclude = {}

		local kfs
		if isNumber then
			local kfsp = game:GetService('KeyframeSequenceProvider')
			kfs = kfsp:GetKeyframeSequenceById(animId, false) -- Test 2
		else
			kfs = animId
		end
		
		--update the animation length
		animationLength = 0
		for _, keyframe in pairs(kfs:GetChildren()) do
			if keyframe.Time > animationLength then
				animationLength = keyframe.Time
			end
		end
		
		--update the framerate so that the keyframes are imported properly
		updateAnimationFramerate()
		updateTimeLabels()
		
		--import the poses
		local LocalKeyframe = nil
		for _, keyframe in pairs(kfs:GetChildren()) do
			--print("\nImporting keyframe "..keyframe.Name.."["..tostring(keyframe.Time).."]")
			LocalKeyframe = createKeyframe(keyframe.Time, false)
			LocalKeyframe.Name = keyframe.Name
			for __, pose in pairs(keyframe:GetChildren()) do
				importPose(LocalKeyframe, pose)
			end
			local countPoses = function()
				local c = 0
				for i, v in pairs(LocalKeyframe.Poses) do
					c = c + 1
				end
				return c
			end
			
		end

		-- cull duplication poses
		
		for time, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
			if (time > 0) then
				for part, pose in pairs(keyframe.Poses) do
					local previousPose = getClosestPose(time - animationFramerate, part)
					local nextPose = getClosestNextPose(time + animationFramerate, part)
					
					local previousStyle = Enum.PoseEasingStyle.Linear
					local previousDirection = Enum.PoseEasingDirection.Out
					
					local myStyle = pose.EasingStyle
					local myDirection = pose.EasingDirection
					
					local nextStyle = Enum.PoseEasingStyle.Linear
					local nextDirection = Enum.PoseEasingDirection.Out
					
					if nextPose then
						nextStyle = nextPose.EasingStyle
						nextDirection = nextPose.EasingDirection
					end
					if previousPose then
						previousStyle = previousPose.EasingStyle
						previousDirection = previousPose.EasingDirection
					end
					
					local easingDifferent = false
					if previousPose then
						if previousStyle ~= myStyle or previousDirection ~= myDirection then
							easingDifferent = true
						end
					end
					if nextPose then
						if nextStyle ~= myStyle or nextDirection ~= myDirection then
							easingDifferent = true
						end
					end
					

					if (previousPose ~= nil and previousPose.CFrame == pose.CFrame and (nextPose == nil or nextPose.CFrame == pose.CFrame)) and not easingDifferent then
						deletePose(keyframe, part)
					end
				end
			end
		end


		loopAnimation = kfs.Loop
		animationPriority = kfs.Priority.Name

		-- set proper keyframe locations
		for time, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
			--keyframe.UI.Position = UD(0, nameSize + marginSize + (time * timeScale), 0, -lineSize - marginSize)
			keyframe.setPos(time)
		end

		--cursorTime = 0
		if cursorTime > animationLength then
			cursorTime = 0
		end

		for partName, setting in pairs(partInclude) do
			if (importPartInclude[partName] ~= nil) then
				partInclude[partName] = true
			else
				partInclude[partName] = false
			end
		end

		doNotUpdateCursor = false

		updatePartInclude()
		updateCursorPosition()
		nudgeView()
		updateLoopButton()
		updatePriorityLabel()
		adjustKeyframes()
	end
	]]
end

--AbstractAlex Remade Loading Code
function loadKeyframeSequence(kfs)
	local keyframes = kfs:GetChildren()
	
	animationLength = 0
	for i, v in pairs(keyframes) do
		if v.Time > animationLength then
			animationLength = v.Time
		end
	end
	
	--update the framerate so that the keyframes are imported properly
	updateAnimationFramerate()
	updateTimeLabels()		
	
	--import the poses
	local LocalKeyframe = nil
	for _, keyframe in pairs(keyframes) do
		--print("\nImporting keyframe "..keyframe.Name.."["..tostring(keyframe.Time).."]")
		LocalKeyframe = createKeyframe(keyframe.Time, false)
		LocalKeyframe.Name = keyframe.Name
		for __, pose in pairs(keyframe:GetChildren()) do
			loadPose(LocalKeyframe, pose)
		end
	end
	
	loopAnimation = kfs.Loop
	animationPriority = kfs.Priority.Name

	-- set proper keyframe locations
	for time, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
		--keyframe.UI.Position = UD(0, nameSize + marginSize + (time * timeScale), 0, -lineSize - marginSize)
		keyframe.setPos(time)
	end

	--cursorTime = 0
	if cursorTime > animationLength then
		cursorTime = 0
	end

	for partName, setting in pairs(partInclude) do
		if (importPartInclude[partName] ~= nil) then
			partInclude[partName] = true
		else
			partInclude[partName] = false
		end
	end

	doNotUpdateCursor = false

	updatePartInclude()
	updateCursorPosition()
	nudgeView()
	updateLoopButton()
	updatePriorityLabel()
	adjustKeyframes()
end


function updatePriorityLabel()
	if (animationPriority == nil) then
		animationPriority = "Core"
	end
	timelineUI.RootFrame.PriorityDisplay.Text = animationPriority
end

function updateLoopButton()
	if (loopAnimation) then
		timelineUI.RootFrame.LoopButton.BackgroundColor3 = buttonOnColor
	else
		timelineUI.RootFrame.LoopButton.BackgroundColor3 = buttonOffColor
	end
end

animationLabelsList = {}

function updateTimeLabels()
	-- delete existing labels
	for _, label in pairs(animationLabelsList) do
		label.Parent = nil
	end
	animationLabelsList = {}

	timelineLength = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
	minTickSeparation = 50
	tickSpacing = 0
	tickSeparation = 0
	local tickScale = 0

	while tickSeparation < minTickSeparation do
		tickScale = tickScale + 1
		ticks = math.floor(animationLength / (animationFramerate * tickScale))
		tickSeparation = timelineLength / ticks
		tickSpacing = animationFramerate * tickScale
	end

	timeScale =  timelineLength / animationLength
	
	local totalTickSpace = (nameSize + marginSize + (ticks * tickSpacing * timeScale) ) / timelineUI.RootFrame.AbsoluteSize.X
	if totalTickSpace > 0.97 then
		ticks = ticks - 1
	end
	
	local numberOfTicks = math.floor(animationLength / tickIncrements)
	local pNumberOfTicks = animationLength / tickIncrements -- Precise
	
	for tickNum = 0, numberOfTicks do		
		--local tickTime = math.floor((animationLength * (tickNum / numberOfTicks))*10)/10
		local tickTime = tickNum * tickIncrements
		--print(tickTime)
		local label = Make('TextLabel', {
			Parent = timelineUI.RootFrame.KeyframeContainer.TimeListFrame,
			Name = 'Tick' .. tickNum,
			Font = 'ArialBold',
			FontSize = 'Size10',
			TextColor3 = GuiSettings.TextColor,
			ZIndex = 4,
			Active = false,
			--Position = UD(0, nameSize + marginSize + (tickNum * tickSpacing * timeScale), 0, lineSize +  marginSize),
			--Timeline 2.0
			Position = UD((tickNum/pNumberOfTicks), 0, 0, 0), 
			Size = UD(0, 10, 0, lineSize),
			BackgroundTransparency = 1,
			--Text = string.format("%.2f", tickNum * tickSpacing),
			--Timeline 2.0
			Text = tostring(tickTime),
			TextXAlignment = Enum.TextXAlignment.Right,
			Make('TextLabel',{
				Name = 'TickIndicator',
				Size = UD(0,2,1000,0),
				Text = "",
				BackgroundColor3 = Color3.new(1,1,1),
				BackgroundTransparency = 0.9,
				BorderSizePixel = 0,
			})
		})
		animationLabelsList[tickNum] = label
	end

	-- end tick
	local endMarker = Make('TextLabel', {
		Parent = timelineUI.RootFrame.KeyframeContainer.TimeListFrame,
		Name = 'TickEnd',
		Font = 'ArialBold',
		FontSize = 'Size10',
		TextColor3 = GuiSettings.TextColor,
		Position = UD(1, -5, 0, 0),
		Size = UD(0, 10, 0, lineSize),
		BackgroundTransparency = 1,
		ZIndex = 5,
		Active = false,
		Text = string.format("%.2f", animationLength),
		TextXAlignment = Enum.TextXAlignment.Right,
			Make('TextLabel',{
				Name = 'TickIndicator',
				Size = UD(0,2,1000,0),
				Text = "",
				BackgroundColor3 = Color3.new(1,1,1),
				BackgroundTransparency = 0.9,
				BorderSizePixel = 0,
			})
	})
	animationLabelsList['TickEnd'] = endMarker


	registerOn(mouseOnLClick, endMarker, function(x, y)
		--[[if (not modal and cursorTime ~= animationLength) then
			timeChangeUI.RootFrame.SaveNameFrame.AnimLengthBox.Text = animationLength
			timeChangeUI.Parent = game:GetService("CoreGui")
			modal = true
		end]]
		return true
	end)
end

function changeKeyframePosition(keyframe, time)
	time = keyframeTimeClamp(time)
	
	if (keyframeList[time] == nil) then
		keyframeList[keyframe.Time] = nil
		keyframe.Time = time
		--keyframe.UI.Position = UD(0, nameSize + marginSize + (time * timeScale), 0, -lineSize - marginSize)
		keyframe.setPos(time)
		keyframeList[time] = keyframe
		
		for _, pose in pairs(keyframe.Poses) do
			pose.Time = time
		end
	end
end

function addTimeAtCursor(addedTime)
	if (animationLength + addedTime > 30) then return end
	if (addedTime <= 0) then return end
	
	animationLength = animationLength + addedTime
	timelineLength = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
	timeScale =  timelineLength / animationLength
	updateAnimationFramerate()
	
	local currentKeyframes = {}
	for timePosition, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
		currentKeyframes[keyframe.Time] = keyframe
	end
	keyframeList = {}
	
	for timePosition, keyframe in spairs(currentKeyframes, function(t, a, b) return t[a].Time < t[b].Time end) do
		local newTime
		if keyframe.Time > cursorTime then
			newTime = keyframe.Time + addedTime
		else
			newTime = keyframe.Time
		end
		
		--changeKeyframePosition(keyframe, newTime)
		keyframe.setPos(newTime)
	end
	setAnimationLength(animationLength)
	updateTimeLabels()
	updateCursorPosition()
end

function addTimeAtCursorNew(addedTime)
	if tonumber(addedTime) == nil or tonumber(addedTime) < 0 or animationLength + addedTime > 30 then
		return
	end
	--Add animation length
	animationLength = animationLength + addedTime
	timelineLength = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
	timeScale =  timelineLength / animationLength
	updateAnimationFramerate()
	--First step. Copy all of these keyframes and wipe the list.
	local keyframeListCache = {}
	for timePosition, keyframe in pairs(keyframeList) do
		keyframeListCache[timePosition] = keyframe
	end
	--Second step. Wipe the list, and adjust times.
	keyframeList = {}
	for timePosition, keyframe in pairs(keyframeListCache) do
		if keyframe.Time > cursorTime then
			keyframe.Time = keyframe.Time + addedTime
			for _, pose in pairs(keyframe.Poses) do
				pose.Time = keyframe.Time
			end
		end
	end
	--Third step.Repopulate original keyframeList.
	for ignore, keyframe in pairs(keyframeListCache) do
		keyframeList[keyframe.Time] = keyframe
	end
	--Update the view
	setAnimationLength(animationLength)
	updateTimeLabels()
	updateCursorPosition()
end

function removeTimeAtCursorNew(addedTime)
	if tonumber(addedTime) == nil or tonumber(addedTime) < 0 or animationLength - addedTime < 0.1 then
		return
	end
	--Add animation length
	animationLength = animationLength - addedTime
	timelineLength = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
	timeScale =  timelineLength / animationLength
	updateAnimationFramerate()
	--First step. Copy all of these keyframes and wipe the list.
	local keyframeListCache = {}
	for timePosition, keyframe in pairs(keyframeList) do
		--If in the "erase zone", don't store it
		if timePosition > cursorTime and timePosition < cursorTime + addedTime then
			--Ignore it. It's in the killzone.
		else
			keyframeListCache[timePosition] = keyframe
		end
	end
	--Second step. Wipe the list, and adjust times.
	keyframeList = {}
	for timePosition, keyframe in pairs(keyframeListCache) do
		if keyframe.Time > cursorTime then
			keyframe.Time = keyframe.Time - addedTime
		end
	end
	--Third step.Repopulate original keyframeList.
	for ignore, keyframe in pairs(keyframeListCache) do
		keyframeList[keyframe.Time] = keyframe
		keyframe.setPos(keyframe.Time)
	end
	--Update the view
	setAnimationLength(animationLength)
	updateTimeLabels()
	updateCursorPosition()
end

function removeTimeAtCursor(removedTime)
	if (animationLength - removedTime < 0.1) then return end
	if (cursorTime + removedTime > animationLength) then
		removedTime = animationLength - cursorTime
	end
	if (removedTime <= 0) then return end
	
	local currentKeyframes = {}
	local removedKeyframes = {}
	local willRemoveKeyframes = false
	for timePosition, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
		if keyframe.Time > cursorTime and keyframe.Time < cursorTime + removedTime then
			removedKeyframes[keyframe.Time] = keyframe
			willRemoveKeyframes = true
		else
			currentKeyframes[keyframe.Time] = keyframe
		end
	end
	
	if willRemoveKeyframes then
		if not showConfirmationDialog("This will remove keyframes.\nAre you sure?") then
			return
		end
	end
	
	for timePosition, removedKeyframe in pairs(removedKeyframes) do
		deleteKeyframe(removedKeyframe.Time)
	end
	
	animationLength = animationLength - removedTime
	updateAnimationFramerate()
	updateTimeLabels()
	updateCursorPosition()
	keyframeList = {}
	
	for timePosition, keyframe in spairs(currentKeyframes, function(t, a, b) return t[a].Time < t[b].Time end) do
		local newTime
		if keyframe.Time > cursorTime then
			newTime = keyframe.Time - removedTime
		else
			newTime = keyframe.Time
		end
		
		changeKeyframePosition(keyframe, newTime)
	end
	setAnimationLength(animationLength)
end

function updateAnimationFramerate()
	local framesPerLength = 40
	local framesPerSecond = 50 / animationLength
	animationFramerate = 1 / framesPerSecond
end

local function createTimelineUI(rootNode)

	if (saveUI == nil) then
		saveUI = Make('ScreenGui', 
		{	
			Name = "SaveUI",
			Make('Frame', {
				Parent = timelineUI,
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 400, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Save As:",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('Frame', {
					Parent = timelineUI,
					Name = 'SaveNameFrame',
					Style = 'Custom',
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 1),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 100/255),
					BackgroundTransparency = 0.3,
					Make('TextBox', {
						Name = 'SaveNameBox',
						Font = 'ArialBold',
						FontSize = 'Size14',
						TextColor3 = GuiSettings.TextColor,
						Position = UD(0.05, 0, 0, 0),
						Size = UD(0.9, 0, 1, 0),
						BackgroundTransparency = 1,
						Text = "<name>",
						TextXAlignment = Enum.TextXAlignment.Left,
					}),
				}),

				Make('TextButton', {
					Name = 'OKButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "OK",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.55, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Cancel",
				}),

			}),
		})


		saveUI.RootFrame.OKButton.MouseButton1Click:connect(function()
			saveUI.Parent = nil
			saveCurrentAnimation(saveUI.RootFrame.SaveNameFrame.SaveNameBox.Text)
			modal = false
		end)

		saveUI.RootFrame.CancelButton.MouseButton1Click:connect(function()
			saveUI.Parent = nil
			modal = false
		end)

	end



	if (timeChangeUI == nil) then
		timeChangeUI = Make('ScreenGui', 
		{	
			Name = "TimeChangeUI",
			Make('Frame', {
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 400, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Animation Length:",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('Frame', {
					Parent = timelineUI,
					Name = 'SaveNameFrame',
					Style = 'Custom',
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 1),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 100/255),
					BackgroundTransparency = 0.3,
					Make('TextBox', {
						Name = 'AnimLengthBox',
						Font = 'ArialBold',
						FontSize = 'Size14',
						TextColor3 = GuiSettings.TextColor,
						Position = UD(0.05, 0, 0, 0),
						Size = UD(0.9, 0, 1, 0),
						BackgroundTransparency = 1,
						Text = animationLength,
						TextXAlignment = Enum.TextXAlignment.Left,
					}),
				}),

				Make('TextButton', {
					Name = 'OKButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "OK",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.55, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Cancel",
				}),

			}),
		})


		timeChangeUI.RootFrame.OKButton.MouseButton1Click:connect(function()
			timeChangeUI.Parent = nil
			setAnimationLength(tonumber(timeChangeUI.RootFrame.SaveNameFrame.AnimLengthBox.Text))
			modal = false
		end)

		timeChangeUI.RootFrame.CancelButton.MouseButton1Click:connect(function()
			timeChangeUI.Parent = nil
			modal = false
		end)

	end
	
	
	if (snapChangeUI == nil) then
		snapChangeUI = Make('ScreenGui', 
		{	
			Name = "SnapChangeUI",
			Make('Frame', {
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 400, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Snap At Increment (Min 0.02):",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('Frame', {
					Parent = timelineUI,
					Name = 'SaveNameFrame',
					Style = 'Custom',
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 1),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 100/255),
					BackgroundTransparency = 0.3,
					Make('TextBox', {
						Name = 'SnapIncrementBox',
						Font = 'ArialBold',
						FontSize = 'Size14',
						TextColor3 = GuiSettings.TextColor,
						Position = UD(0.05, 0, 0, 0),
						Size = UD(0.9, 0, 1, 0),
						BackgroundTransparency = 1,
						Text = animationLength,
						TextXAlignment = Enum.TextXAlignment.Left,
					}),
				}),

				Make('TextButton', {
					Name = 'OKButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "OK",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.55, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Cancel",
				}),

			}),
		})
		
		snapChangeUI.RootFrame.OKButton.MouseButton1Click:connect(function()
			local newSnap = tonumber(snapChangeUI.RootFrame.SaveNameFrame.SnapIncrementBox.Text)
			if newSnap ~= nil and newSnap >= 0.02 then
				dragSnapIncrements = newSnap
			end
			snapChangeUI.Parent = nil
			modal = false
		end)
		
		snapChangeUI.RootFrame.CancelButton.MouseButton1Click:connect(function()
			snapChangeUI.Parent = nil
			modal = false
		end)
	end
	
if (angleChangeUI == nil) then
		angleChangeUI = Make('ScreenGui', 
		{	
			Name = "AngleChangeUI",
			Make('Frame', {
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 400, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Interval:",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('Frame', {
					Parent = timelineUI,
					Name = 'SaveNameFrame',
					Style = 'Custom',
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 1),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 100/255),
					BackgroundTransparency = 0.3,
					Make('TextBox', {
						Name = 'AngleIncrementBox',
						Font = 'ArialBold',
						FontSize = 'Size14',
						TextColor3 = GuiSettings.TextColor,
						Position = UD(0.05, 0, 0, 0),
						Size = UD(0.9, 0, 1, 0),
						BackgroundTransparency = 1,
						Text = animationLength,
						TextXAlignment = Enum.TextXAlignment.Left,
					}),
				}),

				Make('TextButton', {
					Name = 'OKButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "OK",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.55, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Cancel",
				}),

			}),
		})
		
		angleChangeUI.RootFrame.OKButton.MouseButton1Click:connect(function()
			local value = tonumber(angleChangeUI.RootFrame.SaveNameFrame.AngleIncrementBox.Text)
			if value ~= nil then
				if rotateMode then
					rotateStep = value
				else
					moveStep = value
				end
			end
			updateStepDisplay()
			angleChangeUI.Parent = nil
			modal = false
		end)
		
		angleChangeUI.RootFrame.CancelButton.MouseButton1Click:connect(function()
			angleChangeUI.Parent = nil
			modal = false
		end)
	end
	
	if (tickChangeUI == nil) then
		tickChangeUI = Make('ScreenGui', 
		{	
			Name = "TickChangeUI",
			Make('Frame', {
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.5, -200, 0.5, 0),
				Size = UD(0, 400, 0, marginSize + (lineSize + marginSize) * 5),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.5,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Timeline Increment (Min 0.02):",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('Frame', {
					Parent = timelineUI,
					Name = 'SaveNameFrame',
					Style = 'Custom',
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 1),
					Size = UD(0.9, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 100/255),
					BackgroundTransparency = 0.3,
					Make('TextBox', {
						Name = 'TickIncrementBox',
						Font = 'ArialBold',
						FontSize = 'Size14',
						TextColor3 = GuiSettings.TextColor,
						Position = UD(0.05, 0, 0, 0),
						Size = UD(0.9, 0, 1, 0),
						BackgroundTransparency = 1,
						Text = animationLength,
						TextXAlignment = Enum.TextXAlignment.Left,
					}),
				}),

				Make('TextButton', {
					Name = 'OKButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "OK",
				}),
				Make('TextButton', {
					Name = 'CancelButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.55, 0, 0, marginSize + (lineSize + marginSize) * 3),
					Size = UD(0.4, 0, 0, lineSize * 2),
					BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Cancel",
				}),

			}),
		})
		
		tickChangeUI.RootFrame.OKButton.MouseButton1Click:connect(function()
			local newSnap = tonumber(tickChangeUI.RootFrame.SaveNameFrame.TickIncrementBox.Text)
			if newSnap ~= nil and newSnap >= 0.02 then
				tickIncrements = newSnap
			end
			tickChangeUI.Parent = nil
			modal = false
			setAnimationLength(animationLength)
		end)
		
		tickChangeUI.RootFrame.CancelButton.MouseButton1Click:connect(function()
			tickChangeUI.Parent = nil
			modal = false
		end)
	end

	if (menuUI == nil) then
		menuUI = Make('ScreenGui', 
		{
			Name = "MenuUI",
			Make('Frame', {
				Parent = timelineUI,
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0, lineSize, 0, lineSize),
				Size = UD(0, 100, 0, (lineSize + (2*marginSize)) + 10 * (buttonSize + marginSize)),
				BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
				BackgroundTransparency = 0.3,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Menu",
					TextXAlignment = Enum.TextXAlignment.Center,
				}),
				Make('TextButton', {
					Name = 'PlayButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, lineSize + (2*marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Play",
				}),
				Make('TextButton', {
					Name = 'SaveButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2*marginSize)) + (buttonSize + marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Save",
				}),
				Make('TextButton', {
					Name = 'LoadButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2*marginSize)) + 2 * (buttonSize + marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Load",
				}),
				Make('TextButton', {
					Name = 'ImportButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2*marginSize)) + 3 * (buttonSize + marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Import",
				}),
				Make('TextButton', {
					Name = 'ExportButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2*marginSize)) + 4 * (buttonSize + marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Export",
				}),
				Make('TextButton', {
					Name = 'ResetButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2*marginSize)) + 5 * (buttonSize + marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Reset",
				}),
				Make('TextButton', {
					Name = 'DebugButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2*marginSize)) + 6 * (buttonSize + marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Debug",
				}),
				Make("TextButton", {
					Name = "AddTimeButton",
					Font = "ArialBold",
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2 * marginSize) ) + 7 * (buttonSize + marginSize) ),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "+ Time",
				}),
				Make("TextButton", {
					Name = "RemoveTimeButton",
					Font = "ArialBold",
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2 * marginSize) ) + 8 * (buttonSize + marginSize) ),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "- Time",
				}),
				Make("TextButton", {
					Name = "ToggleInterpolationButton",
					Font = "ArialBold",
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, (lineSize + (2 * marginSize) ) + 9 * (buttonSize + marginSize) ),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Lerp (on)",
				})
			}),
		})
	end
	--TimelineUIStart
	-- creating test GUI
	if (timelineUI == nil) then

		lineCount = 0

		timelineUI = Make('ScreenGui', 
		{
			Name = "TimelineUI",
			Make('TextButton',{
				Name = "Resize",
				Size = UDim2.new(0, 35, 0, 15),
				Position = UDim2.new(1, -35, 0, lineSize * 16),
				Text = "==",
				TextColor3 = Color3.new(0.8,0.8,0.8),
				BackgroundColor3 = Color3.new(98/255, 98/255, 98/255),
				BackgroundTransparency = 0,
				BorderSizePixel = 0,
				Draggable = true,
			}),
			Make('Frame', {
				Parent = timelineUI,
				Name = 'RootFrame',
				Position = UD(0, 0, 0, 0),
				Size = UD(1, 0, 0, lineSize * 16),
				BackgroundColor3 = Color3.new(98/255, 98/255, 98/255),
				BackgroundTransparency = 0,
				BorderSizePixel = 0,
				Make("ScrollingFrame", {
					Name = "ScrollingFrame",
					Position = UD(0, 0, 0, (lineSize + marginSize)),
					Size = UD(0, nameSize + marginSize, 1, -headerSize + 30),
					BackgroundTransparency = 1,
					BorderSizePixel = 0,
					ScrollBarThickness = 0,
				}),
				--Timeline Scrollingframe
				Make("ScrollingFrame",{
					Name = 'KeyframeContainer',
					Position = UD(0, lineSize + (marginSize*2) + nameSize - 15, 0, (lineSize + marginSize)),
					Size = UD(1, -(nameSize + marginSize) - 35, 1, -headerSize + 30),
					BackgroundColor3 = Color3.new(21/255, 21/255, 21/255),
					BackgroundTransparency = 0.5,
					BorderSizePixel = 0,
					CanvasSize = UD(0, 2000, 1, 0),
					ScrollBarThickness = 0,
					Make('Frame', {
						Name = 'TimeListFrame',
						Style = 'Custom',
						Position = UD(0, 0, 0, 0),
						--Size = UD(1, -(marginSize + nameSize + timelinemarginSize), 0, lineSize),
						--Timeline 2.0
						Size = UD(1, 0, 0, lineSize),
						BackgroundColor3 = Color3.new(98/255, 98/255, 98/255),
						BackgroundTransparency = 0.1,
						BorderSizePixel = 0,
						ZIndex = 3,
					}),
					Make('TextButton', {
						Name = 'TimelineFrame',
						Style = 'Custom',
						Text = "",
						Active = false,
						AutoButtonColor = false,
						Position = UD(0, 0, 0, (lineSize + marginSize)),
						--Size = UD(1, -(marginSize + nameSize + timelinemarginSize), 0, lineSize),
						--Timeline 2.0
						Size = UD(1, 0, 0, lineSize),
						BackgroundColor3 = Color3.new(200/255, 200/255, 200/255),
						BackgroundTransparency = 0.1,
					}),
					--Create Cursor
					Make('Frame', {
						Name = 'Cursor',
						Style = 'Custom',
						Position = UD(0, nameSize + marginSize - (lineSize / 2) , 0, 1 * (lineSize + marginSize)),
						Size = UD(0, lineSize + 2, 0, lineSize + 2),
						BackgroundColor3 = Color3.new(250/255, 50/255, 50/255),
						BackgroundTransparency = 0,
						BorderColor3 = Color3.new(250/255, 50/255, 50/255),
						ZIndex = 4,
						Make('Frame', {
							Name = 'CursorLine',
							Style = 'Custom',
							Position = UD(0, (lineSize / 2), 0, 0),
							Size = UD(0, 2, 1000, 0),
							BackgroundColor3 = Color3.new(250/255, 50/255, 50/255),
							BackgroundTransparency = 0,
							BorderSizePixel = 0,
							ZIndex = 0,
						}),
					}),	
				}),
				--
				--Vertical scroll proxy
				Make("ScrollingFrame", {
					Name = "VerticalProxy",
					Position = UD(1, -40, 0, (lineSize + marginSize)),
					Size = UD(0, 15, 1, -headerSize + 30),
					BackgroundTransparency = 1,
					BorderSizePixel = 0,
					ScrollBarThickness = 10,
				}),
				--Horizontal scroll proxy
				Make("ScrollingFrame", {
					Name = "HorizontalProxy",
					Position = UD(0, lineSize + (marginSize*2) + nameSize - 15, 1, -headerSize + 35),
					Size = UD(1, -(nameSize + marginSize) - 35, 0, 10),
					BackgroundTransparency = 1,
					BorderSizePixel = 0.5,
					ScrollBarThickness = 10,
				}),
				-----------------------
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.25, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Timeline",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),
				Make('TextButton', {
					Name = 'MoreButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0, lineSize, 0, lineSize),
					Size = UD(0, lineSize * 1.1, 
					          0, lineSize * 1.1),
					BackgroundColor3 = Color3.new(50/255, 50/255, 50/255),
					BackgroundTransparency = 0,
					Text = "+",
				}),
				Make('ImageButton', {
					Name = 'SettingsButton',
					Position = UD(0, lineSize * 3, 0, lineSize),
					Size = UD(0, lineSize * 1.1, 
					          0, lineSize * 1.1),
					BackgroundColor3 = Color3.new(50/255, 50/255, 50/255),
					BackgroundTransparency = 0,
					Image = "rbxassetid://299306324",
				}),
				Make('TextButton', {
					Name = 'CloseButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(1, -20, 0, 20),
					Size = UD(0, 15, 
					          0, 15),
					BackgroundColor3 = Color3.new(168/255, 34/255, 34/255),
					BackgroundTransparency = 0,
					BorderSizePixel = 0,
					Text = "X",
					ZIndex = 5
				}),
				Make('TextButton', {
					Name = 'TimelineZoomIn',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(1, -32, 1, -26),
					Size = UD(0, 15,
					          0, 18),
					BackgroundColor3 = Color3.new(50/255, 50/255, 50/255),
					BackgroundTransparency = 0,
					BorderSizePixel = 0.5,
					Text = "+",
				}),
				Make('TextButton', {
					Name = 'TimelineZoomOut',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(1, -17, 1, -26),
					Size = UD(0, 14, 
					          0, 18),
					BackgroundColor3 = Color3.new(50/255, 50/255, 50/255),
					BackgroundTransparency = 0.5,
					BorderSizePixel = 0,
					Text = "-",
				}),
				--[[Make('TextLabel', {
					Name = 'PriorityLabel',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.6, 0, 0, 1),
					Size = UD(0.1, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Priority:",
					TextXAlignment = Enum.TextXAlignment.Left,
				}),]]
				Make('TextLabel', {
					Name = 'PriorityDisplay',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.6, 55, 0, 1),
					Size = UD(0, 100, 0, lineSize),
					BackgroundTransparency = 0.5,
					Text = "Action",
					TextXAlignment = Enum.TextXAlignment.Center,
					BackgroundColor3 = dropDownColor,
					Visible = false,
				}),
				Make('TextLabel', {
					Name = 'LoopLabel',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.8, 0, 0, 1),
					Size = UD(0.1, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Loop:",
					TextXAlignment = Enum.TextXAlignment.Left,
					Visible = false,
				}),
				Make('TextButton', {
					Name = 'LoopButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.8, 45, 0, 0),
					Size = UD(0, lineSize * 1.1, 
					          0, lineSize * 1.1),
					BackgroundColor3 = Color3.new(50/255, 50/255, 50/255),
					BackgroundTransparency = 0,
					Text = "",
					Visible = false,
				}),	
			}),
		})
		
		--for some reason, the scrolling frame captures input
		-- timelineUI.RootFrame.ScrollingFrame.InputEnded:connect(function(input)
			-- if input.UserInputType == Enum.UserInputType.MouseButton1 then
				-- mouseCallbackCheck(mouseOnLUp)
			-- end
		-- end)

		-- adding labels
		--timelineUI.RootFrame.KeyframeContainer.CanvasSize = UDim2.new(timelineUI.RootFrame.KeyframeContainer.AbsoluteSize.Y, 0, 1, 0)
		timelineUI.RootFrame.MoreButton.Visible = false
		timelineUI.RootFrame.SettingsButton.Visible = false
		timelineUI.Parent = game:GetService("CoreGui")
		timelineUI.RootFrame.KeyframeContainer.CanvasSize = UDim2.new(0, timelineUI.RootFrame.KeyframeContainer.AbsoluteSize.X, 1, 0)
		menuManager.RegisterTooltip(timelineUI.RootFrame.TimelineZoomIn, "Zoom in to the timeline")
		menuManager.RegisterTooltip(timelineUI.RootFrame.TimelineZoomOut, "Zoom out of the timeline")
		wait(0.1)
		updateTimeLabels()
		-- M E N U 
		-- P L A Y
		menuUI.RootFrame.PlayButton.MouseButton1Click:connect(function()
			closePopupMenu()
			playCurrentAnimation()
		end)

		-- S A V E
		menuUI.RootFrame.SaveButton.MouseButton1Click:connect(function()
			closePopupMenu()
			PromptSave()
		end)

		-- L O A D
		menuUI.RootFrame.LoadButton.MouseButton1Click:connect(function()
			closePopupMenu()
			PromptLoad()
			--showLoadGame()
		end)

		-- I M P O R T 
		menuUI.RootFrame.ImportButton.MouseButton1Click:connect(function()
			closePopupMenu()
			modal = true
--			showImportAnim()
			showImportAnimText()
			modal = false
		end)

		-- E X P O R T
		menuUI.RootFrame.ExportButton.MouseButton1Click:connect(function()
			closePopupMenu()
			modal = true
			showExportAnim()
		end)

		-- R E S E T 
		menuUI.RootFrame.ResetButton.MouseButton1Click:connect(function()
			closePopupMenu()
			resetAnimation()
		end)

		-- D E B U G 
		menuUI.RootFrame.DebugButton.MouseButton1Click:connect(function()
--			listEvent(mouseOnLClick)
			for time, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
				print("keyframe time " .. time .. " poses " .. tablelength(keyframe.Poses))
			end
		end)
		
		--add time
		menuUI.RootFrame.AddTimeButton.MouseButton1Click:connect(function()
			closePopupMenu()
			
			local timeAdded = tonumber(showTextExtryDialog("Amount of time to add?", "0.1") )
			if timeAdded and timeAdded > 0 then
				addTimeAtCursor(timeAdded)
			end
			timelineLength = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
			timeScale =  timelineLength / animationLength
			
			updateCursorPosition()
			adjustKeyframes()

		end)
		
		--remove time
		menuUI.RootFrame.RemoveTimeButton.MouseButton1Click:connect(function()
			closePopupMenu()
			
			local timeRemoved = tonumber(showTextExtryDialog("Amount of time to remove?", "0.1") )
			if timeRemoved and timeRemoved > 0 then
				removeTimeAtCursor(timeRemoved)
			end
			timelineLength = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
			timeScale =  timelineLength / animationLength
			updateCursorPosition()
			adjustKeyframes()
		end)
		
		--lerp
		menuUI.RootFrame.ToggleInterpolationButton.MouseButton1Click:connect(function()
			closePopupMenu()
			toggleInEditorInterpolation()
		end)
		
		--zoom timeline
		timelineUI.RootFrame.TimelineZoomIn.MouseButton1Click:connect(function()
			local currentSize = timelineUI.RootFrame.KeyframeContainer.AbsoluteSize.X	
			local frameSize = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset	
			local newSize = frameSize + 100	
			timelineUI.RootFrame.KeyframeContainer.CanvasSize = UD(0, newSize, 0, timelineUI.RootFrame.KeyframeContainer.CanvasSize.Y.Offset)		
			timelineUI.RootFrame.HorizontalProxy.CanvasSize = UD(0, newSize, 0, timelineUI.RootFrame.HorizontalProxy.CanvasSize.Y.Offset)		
			timelineLength = newSize
			timeScale =  timelineLength / animationLength
			adjustKeyframes()
			updateCursorPosition()
			--setAnimationLength(animationLength)
		end)
		
		timelineUI.RootFrame.TimelineZoomOut.MouseButton1Click:connect(function()
			local currentSize = timelineUI.RootFrame.KeyframeContainer.AbsoluteSize.X
			local frameSize = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
			local newSize = frameSize - 100
			if newSize < currentSize then
				newSize = currentSize
			end
			timelineUI.RootFrame.KeyframeContainer.CanvasSize = UD(0, newSize, 0, timelineUI.RootFrame.KeyframeContainer.CanvasSize.Y.Offset)
			timelineUI.RootFrame.HorizontalProxy.CanvasSize = UD(0, newSize, 0, timelineUI.RootFrame.HorizontalProxy.CanvasSize.Y.Offset)
			timelineLength = newSize
			timeScale =  timelineLength / animationLength
			adjustKeyframes()
			updateCursorPosition()
			--setAnimationLength(animationLength)
		end)
		
		timelineUI.Resize.Changed:connect(function()
			local obj = timelineUI:findFirstChild("Resize")
			if obj then
				local newSize = obj.Position.Y.Offset
				obj.Position = UDim2.new(1, -obj.Size.X.Offset, 0, newSize)
				timelineUI.RootFrame.Size = UDim2.new(1, 0, 0, newSize)
			end
		end)
		
		timelineUI.RootFrame.SettingsButton.MouseButton1Click:connect(function()
			loadOptionsMenu()
		end)
		
		function loadOptionsMenu()
			local mouse = plugin:GetMouse()
			displayOptionsMenu(mouse.X, mouse.Y)
			local mouse = plugin:GetMouse()
			local loopButton = loopAnimation == true and "Loop (true)" or "Loop (false)"
			local priorityType = "Priority: "..timelineUI.RootFrame.PriorityDisplay.Text
			local cursorText = preferences["TweenCursor"] == true and "Cursor Tween (true)" or "Cursor Tween (false)"
			local transparentToggle = preferences["TransparentSelect"] == true and "Select Invisible: yes" or "Select Invisible: no"
			local options = {"Change Length","Tick Interval","Snap Interval",loopButton, priorityType, cursorText, transparentToggle}
			
			if selection == nil then return end
			if (selection == "Change Length") then
				timeChangeUI.Parent = game:GetService("CoreGui")
				modal = true
			elseif selection == "Tick Interval" then
				tickChangeUI.Parent = game:GetService("CoreGui")
				modal = true
			elseif selection == "Snap Interval" then
				snapChangeUI.Parent = game:GetService("CoreGui")
				modal = true
			elseif selection == "Loop (false)" then
				loopAnimation = true
			elseif selection == "Loop (true)" then
				loopAnimation = false
			elseif selection == "Cursor Tween (true)" then
				preferences["TweenCursor"] = false
			elseif selection == "Cursor Tween (false)" then
				preferences["TweenCursor"] = true
			elseif string.find(selection, "Priority") then
				local mouse = plugin:GetMouse()
				spawn(function()
					local newPriority = displayDropDownMenu(timelineUI.RootFrame.PriorityDisplay, animationPriorityList, sx + 300, mouse.Y)
					if (newPriority ~= nil) then
						animationPriority = newPriority
						timelineUI.RootFrame.PriorityDisplay.Text = newPriority
					end	
					loadOptionsMenu(sx, sy)	
				end)
			elseif selection == "Select Invisible: yes" then
				preferences["TransparentSelect"] = false
			elseif selection == "Select Invisible: no" then
				preferences["TransparentSelect"] = true
			end			
			--loadOptionsMenu(sx, sy)
		end

		toggleInEditorInterpolation()
		toggleInEditorInterpolation()


		function closePopupMenu(x, y)
			menuUI.Parent = nil
			unregisterEvent(mouseOnLClick, mouseClickEater)
			unregisterEvent(mouseOnLClick, menuClearEvent)
			return true
		end

		timelineUI.RootFrame.MoreButton.MouseButton1Click:connect(function()
			if (not modal) then
				menuUI.Parent = game:GetService("CoreGui")
				mouseClickEater = registerOn(mouseOnLClick,menuUI.RootFrame, function(x, y)	return true	end)
				menuClearEvent = registerOn(mouseOnLClick, nil, closePopupMenu)		
			end
		end)

		timelineUI.RootFrame.CloseButton.MouseButton1Down:connect(function()
			if (not modal) then
				autoSave()
				--[[timelineUI.Parent = nil
				resetAnimation()
				clearAllEvents()
				if (MouseTargeterHalt ~= nil) then
					MouseTargeterHalt()
				end
				destroySelectionBoxes()]]
				exitPlugin()
				plugin:SetSetting("AnimEditor_TweenCursor", preferences["TweenCursor"])
				plugin:SetSetting("AnimEditor_AnimLength", animationLength)
				plugin:SetSetting("AnimEditor_SnapIncrement", dragSnapIncrements)
				plugin:SetSetting("AnimEditor_TickIncrement", tickIncrements)
				plugin:SetSetting("AnimEditor_TransparentSelect", preferences["TransparentSelect"])
				plugin:SetSetting("AnimEditor_Interpolation", preferences["Interpolation"])
				plugin:SetSetting("AnimEditor_Tooltips", preferences["Tooltips"])
			end
		end)

		--[[timelineUI.RootFrame.LoopButton.MouseButton1Click:connect(function()
			if (not modal) then
				loopAnimation = not loopAnimation
				updateLoopButton()
			end
		end)]]
		
		timelineUI.RootFrame.KeyframeContainer.TimelineFrame.MouseButton1Click:connect(function()
			selectedKeyframe = nil
		end)


		registerOn(mouseOnLClick, timelineUI.RootFrame.PriorityDisplay, function(x, y)
			if (not modal) then
				local mouse = plugin:GetMouse()
				local newPriority = displayDropDownMenu(timelineUI.RootFrame.PriorityDisplay, animationPriorityList, mouse.X, mouse.Y + 10)
				if (newPriority ~= nil) then
					animationPriority = newPriority
					timelineUI.RootFrame.PriorityDisplay.Text = newPriority
				end
			end
		end)

		-- hooking up clicks


		-- sliding keyframe cursor
		registerOn(mouseOnLClick, timelineUI.RootFrame.KeyframeContainer.TimelineFrame, function(x, y)
			keyframePositionShift(x, y)
		end)


		-- create or delete keyframe
		registerOn(mouseOnRClick, timelineUI.RootFrame.KeyframeContainer.TimelineFrame, function(x, y)
			return keyframeContextMenu(x, y, true)
		end)

		-- moving time cursor
		registerOn(mouseOnLClick, timelineUI.RootFrame.KeyframeContainer.TimeListFrame, function(x, y)
			wait()
			if (not modal and not cursorClick) then
				--print("Timeline click")
				if (cursorTime ~= findTime(x)) then
					cursorTime = findTime(x)
					updateCursorPosition()
					wait()
					return true
				end
			end
			return false
		end)

		-- sliding time cursor
		registerOn(mouseOnLClick, timelineUI.RootFrame.KeyframeContainer.Cursor, function(x, y)
			if (not modal) then
				--print("Cursor click")
				local halt = Repeat(function()
						local mouse = plugin:GetMouse()
						xvalue = mouse.X - timelineUI.RootFrame.KeyframeContainer.TimelineFrame.AbsolutePosition.X
						cursorTime = findTime(xvalue)
						if (cursorTime < 0) then
							cursorTime = 0
						elseif (cursorTime > animationLength) then
							cursorTime = animationLength
						end
						updateCursorPosition()
						wait()
					end)
				local unregisterEvent = registerOn(mouseOnLUp, nil, function(x, y)
					unregisterEvent(mouseOnLUp, unregisterEvent)
					halt()
					return false
				end)
				return true
			end
			return false
		end)
		
		timelineUI.RootFrame.KeyframeContainer.Cursor.InputBegan:connect(function(input)
			if input.UserInputType == Enum.UserInputType.MouseButton1 then
				cursorClick = true
				--print("CC")
				delay(0.1, function()
					cursorClick = false
				end)			
			end
		end)
		
		--[[timelineUI.RootFrame.KeyframeContainer.Cursor.MouseButton1Down:connect(function()
			if not modal then
				print("CC")
				--cursorClick = true
				delay(0.1, function()
					cursorClick = false
				end)
			end
		end)]]
		
	end

	local function createLine(node, indentLevel)
		if (node == nil) then
			return
		end

		local newLine = Make('TextLabel', {
								Name = 'Line' .. lineCount,
								Font = 'Arial',
								FontSize = GuiSettings.TextSmall,
								TextColor3 = GuiSettings.TextColor,
								TextXAlignment = Enum.TextXAlignment.Left,
								Position = UD(0, 10, 0, (25 + (lineSize + marginSize) * lineCount)),
								Size = UD(0, nameSize, 0, lineSize),
								BackgroundTransparency = 1,
								Parent = timelineUI.RootFrame.ScrollingFrame,
								---------------------------
								Text = string.rep('  ', indentLevel) .. node.Name,
							})

		registerOn(mouseOnLClick, newLine, function(x, y)
			if (not modal) then
				if (getHandleSelection() ~= node and node ~= rootNode) then
					setHandleSelection(node)
				else
					resetHandleSelection()
				end
				updateCursorPosition()
				return true
			end
		end)
							
		if (node.Motor6D ~= nil) then
			local newLineButton = Make('TextButton', {
									Name = 'LineButton' .. node.Name,
									Font = 'Arial',
									FontSize = GuiSettings.TextSmall,
									TextColor3 = GuiSettings.TextColor,
									TextXAlignment = Enum.TextXAlignment.Left,
									BackgroundColor3 = buttonOffColor,
									Position = UD(0, nameSize - lineSize, 0, 25 + ((lineSize + marginSize) * lineCount)),
									Size = UD(0, lineSize, 0, lineSize),
									BackgroundTransparency = 0,
									Parent = timelineUI.RootFrame.ScrollingFrame,
									Text = ' ',
								})

			newLineButton.MouseButton1Click:connect(function()
				partInclude[node.Name] = not partInclude[node.Name]
				if partInclude[node.Name] then
					newLineButton.BackgroundColor3 = buttonOnColor
				else
					newLineButton.BackgroundColor3 = buttonOffColor		
				end
				resetHandleSelection()
				updateCursorPosition()		
			end)
		end

		lineCount = lineCount + 1
		for _, c in pairs(node.Children) do
			createLine(c, indentLevel + 1)
		end
	end
	createLine(rootNode, 0)
	updatePartInclude()

	selectedLine = 	Make('Frame', {
					Name = 'SelectedLineFrame',
					Style = 'Custom',
					Position = UD(0, marginSize, 0, (marginSize / 2) + 1 + ((lineSize + marginSize) * (lineCount - 1))),
					Size = UD(1, -(marginSize * 2), 0, lineSize + marginSize),
					BackgroundColor3 = Color3.new(200/255, 200/255, 150/255),
					BackgroundTransparency = 0.9,
	})
	selectedLine.Parent = timelineUI.RootFrame
	
	selectedLine2 = 	Make('Frame', {
					Name = 'SelectedLineFrame2',
					Style = 'Custom',
					Position = UD(0, marginSize, 0, (marginSize / 2) + 1 + ((lineSize + marginSize) * (lineCount - 1))),
					Size = UD(1, -(marginSize * 2), 0, lineSize + marginSize),
					BackgroundColor3 = Color3.new(200/255, 200/255, 150/255),
					BackgroundTransparency = 0.9,
	})
	selectedLine2.Parent = timelineUI.RootFrame.KeyframeContainer


	timelineUI.RootFrame.ScrollingFrame.CanvasSize = UD(1, 0, 0, 30 + marginSize + ((lineSize + marginSize) * lineCount --[[+ 8]]))
	--timelineUI.RootFrame.KeyframeContainer.CanvasSize = UD(0, 2000, 0, 30 + marginSize + ((lineSize + marginSize) * lineCount))
	timelineUI.RootFrame.KeyframeContainer.CanvasSize = UD(0, timelineUI.RootFrame.KeyframeContainer.AbsoluteSize.X, 0, 30 + marginSize + ((lineSize + marginSize) * lineCount))
	timelineUI.RootFrame.VerticalProxy.CanvasSize = UD(0, 0, 0, 30 + marginSize + ((lineSize + marginSize) * lineCount --[[+ 8]]))
	timelineUI.RootFrame.HorizontalProxy.CanvasSize = UD(0, timelineUI.RootFrame.KeyframeContainer.AbsoluteSize.X, 0, 0)
	
	local function moveTimelineBars()
		timelineUI.RootFrame.KeyframeContainer.TimeListFrame.Position = UD(0, 0, 0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
		timelineUI.RootFrame.KeyframeContainer.TimelineFrame.Position = UD(0, 0, 0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y + (lineSize + marginSize))
		adjustKeyframes()
		local tweenPos = (cursorTime * timeScale) - (lineSize / 2)
		if cursorTime >= animationLength - 0.03 then
			tweenPos = tweenPos - 5
		end
		timelineUI.RootFrame.KeyframeContainer.Cursor.Position = UD(0, tweenPos, 0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
	end	
	
	--Match scrollingframe positions
	timelineUI.RootFrame.KeyframeContainer.Changed:connect(function()
		if timelineUI and timelineUI:findFirstChild("RootFrame") then
			timelineUI.RootFrame.ScrollingFrame.CanvasPosition = Vector2.new(0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
			timelineUI.RootFrame.VerticalProxy.CanvasPosition = Vector2.new(0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
			moveTimelineBars()
		end
	end)
	timelineUI.RootFrame.ScrollingFrame.Changed:connect(function()
		if timelineUI and timelineUI:findFirstChild("RootFrame") then
			timelineUI.RootFrame.KeyframeContainer.CanvasPosition = Vector2.new(timelineUI.RootFrame.KeyframeContainer.CanvasPosition.X, timelineUI.RootFrame.ScrollingFrame.CanvasPosition.Y)
			timelineUI.RootFrame.VerticalProxy.CanvasPosition = Vector2.new(0, timelineUI.RootFrame.ScrollingFrame.CanvasPosition.Y)
		end
	end)
	timelineUI.RootFrame.VerticalProxy.Changed:connect(function()
		if timelineUI and timelineUI:findFirstChild("RootFrame") then
			timelineUI.RootFrame.KeyframeContainer.CanvasPosition = Vector2.new(timelineUI.RootFrame.KeyframeContainer.CanvasPosition.X, timelineUI.RootFrame.VerticalProxy.CanvasPosition.Y)
			timelineUI.RootFrame.ScrollingFrame.CanvasPosition = Vector2.new(0, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
		end
	end)
	
	timelineUI.RootFrame.HorizontalProxy.Changed:connect(function()
		if timelineUI and timelineUI:findFirstChild("RootFrame") then
			timelineUI.RootFrame.KeyframeContainer.CanvasPosition = Vector2.new(timelineUI.RootFrame.HorizontalProxy.CanvasPosition.X, timelineUI.RootFrame.KeyframeContainer.CanvasPosition.Y)
		end
	end)	
	
	
	timelineUI.Parent = game:GetService("CoreGui")
end

function setAnimationLength(length)
	--length = approx(length)
	
	registerUndo({action = "lengthChange"})	
	
	length = math.floor(length * 10000)/10000
	--print("Setting length "..length)
	local scale = length / animationLength
	animationLength = length
	timeScale =  timelineLength / animationLength
	if (animationLength > 30) then
		animationLength = 30
	end
	plugin:SetSetting("AnimEditor_AnimLength", animationLength)

	-- modify animation framerate (easier than trying to combine keyframes)
	updateAnimationFramerate()
	
	-- copy out all keyframes
	local tempKeyFrameList = {}
	for time, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
		tempKeyFrameList[keyframe.Time] = keyframe
	end
	keyframeList = {}

	-- scale all keyframes
	for time, keyframe in spairs(tempKeyFrameList, function(t, a, b) return t[a].Time < t[b].Time end) do
		local newTime = keyframeTimeClamp(scale * time)
		keyframe.Time = newTime
		for _, pose in pairs(keyframe.Poses) do
			pose.Time = keyframe.Time
		end
		keyframeList[keyframe.Time] = keyframe
		keyframe.adjust()
	end



	-- update animation length display
	updateTimeLabels()

	-- update cursor location
	cursorTime = cursorTime * scale
	
	
	--timelineLength = timelineUI.RootFrame.KeyframeContainer.CanvasSize.X.Offset
	--timeScale =  timelineLength / animationLength
	--updateCursorPosition()
	wait(2)
	--adjustKeyframes()
	updateCursorPosition()
end

function keyframeContextMenu(x, y, needsShift)
	if (not modal and ( (not needsShift) or isKeyDown("shift") ) ) then
		time = findTime(x)
		--local key = getKeyframe(time)
		local key = selectedKeyframe
		if (key == nil) then
			createKeyframe(time)
		else
			local keyframeMenu = { "Delete", "Rename", "Copy", "Reset" }
			if DebugEnabled then table.insert(keyframeMenu, "Debug") end
			local mouse = plugin:GetMouse()
			local selection = displayDropDownMenu(timelineUI.RootFrame.KeyframeContainer.TimelineFrame, keyframeMenu, mouse.X, mouse.Y)
			if (selection == "Delete") then
				if (time > 0) then
					deleteKeyframe(time, true)
				end
				
			elseif (selection == "Rename") then
				local newName = showTextExtryDialog("Enter Keyframe Name:", key.Name)
				if (newName ~= nil) then
					key.Name = newName
				end
			
			elseif selection == "Copy" then
				for part, pose in pairs(key.Poses) do
					copyPose(part, pose)
				end
			
			elseif selection == "Reset" then
				resetKeyframeToDefaultPose(key)
			elseif selection == "Debug" then
				print("------------------------------")
				for i, v in pairs(key.Poses) do
					print(v.Item.Name)
				end
				print("------------------------------")
			end
		end
	end
	return false
end

function keyframePositionShift(x, y)
	if (not modal) then
		time = findTime(x)
		--local keyframe = getKeyframe(time)
		local keyframe = selectedKeyframe

		if (keyframe ~= nil and time > 0) then
			local halt = Repeat(function()
					local mouse = plugin:GetMouse()
					xvalue = mouse.X - timelineUI.RootFrame.KeyframeContainer.TimelineFrame.AbsolutePosition.X
					mouseTime = findTime(xvalue)
					if (mouseTime < 0) then
						mouseTime = 0
					elseif (mouseTime > animationLength) then
						mouseTime = animationLength
					end
					local currentKeyframe = getKeyframe(mouseTime)
					while (getKeyframe(mouseTime) ~= nil and getKeyframe(mouseTime) ~= keyframe) do
						mouseTime = mouseTime + animationFramerate
					end
					if (mouseTime > animationLength) then
						while (mouseTime > animationLength or (getKeyframe(mouseTime) ~= nil and getKeyframe(mouseTime) ~= keyframe)) do
							mouseTime = mouseTime - animationFramerate
						end
					end
					moveKeyframe(keyframe, mouseTime)
				end)	
			local unregisterEvent = registerOn(mouseOnLUp, nil, function(x, y)
				unregisterEvent(mouseOnLUp, unregisterEvent)
				halt()
				return false
			end)
			return true
		end
	end
	return false
end

function PromptSave()
	modal = true
	--saveUI.Parent = game:GetService("CoreGui")
	local exitFunc = function(givenName)
		modal = false
		if givenName ~= nil then
			saveCurrentAnimation(givenName)
		end
	end
	menuManager.GetSaveName(rootPart.Item.Parent, exitFunc)
end

function PromptLoad()
	modal = true
	menuManager.GetLoadName(rootPart.Item.Parent, function(name)
		if name ~= nil and name ~= "" then
			loadCurrentAnimation(name)
		end
		modal = false
	end)
end

function updatePartInclude()
	for partName, setting in pairs(partInclude) do
		local item = partListByName[partName]
		local button =timelineUI.RootFrame.ScrollingFrame:FindFirstChild('LineButton' .. partName)
		if (button ~= nil) then
			if setting then
				button.BackgroundColor3 = buttonOnColor		
			else
				button.BackgroundColor3 = buttonOffColor		
			end
		end
	end
end

function resetAnimation()
	undoMemory = {}
	redoMemory = {}
	doNotUpdateCursor = true
	resetCopyPoseList()
	resetKeyframes()
	local savedLength = plugin:GetSetting("AnimEditor_AnimLength")
	animationLength = savedLength ~= nil and savedLength or 2
	cursorTime = 0
	loopAnimation = false
	animationPriority = "Core"
	
	createKeyframe(0)
	doNotUpdateCursor = false
	updateTimeLabels()
	updateCursorPosition()
	resetHandleSelection()
	updateLoopButton()
	updatePriorityLabel()
	
	for partName, setting in pairs(partInclude) do
		partInclude[partName] = true
	end
	updatePartInclude()

end


stopAnim = false
function showStopAnimUI()
	if (stopAnimUI == nil) then
		stopAnimUI = Make('ScreenGui', 
		{
			Name = "StopAnimUI",
			Make('Frame', {
				Parent = timelineUI,
				Name = 'RootFrame',
				Style = 'Custom',
				Position = UD(0.1, 0, 0.5, 0),
				Size = UD(0, 150, 0, lineSize + buttonSize + 3*marginSize),
				BackgroundColor3 = Color3.new(100/255, 100/255, 150/255),
				BackgroundTransparency = 0.3,
				Make('TextLabel', {
					Name = 'TitleBar',
					Font = 'ArialBold',
					FontSize = 'Size14',
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, marginSize),
					Size = UD(0.9, 0, 0, lineSize),
					BackgroundTransparency = 1,
					Text = "Animation Playing",
					TextXAlignment = Enum.TextXAlignment.Center,
				}),
				Make('TextButton', {
					Name = 'StopButton',
					Font = 'ArialBold',
					FontSize = GuiSettings.TextMed,
					TextColor3 = GuiSettings.TextColor,
					Position = UD(0.05, 0, 0, lineSize + (2*marginSize)),
					Size = UD(0.9, 0, 0, buttonSize),
					BackgroundColor3 = Color3.new(150/255, 150/255, 150/255),
					BackgroundTransparency = 0,
					Text = "Stop",
				}),
			}),
		})
	end

	stopAnim = false
	stopAnimUI.Parent = game:GetService("CoreGui")
	stopAnimUI.RootFrame.StopButton.MouseButton1Click:connect(function()
		stopAnim = true
		stopAnimUI.Parent = nil
	end)

end




	function createPoseFromLastKeyframe(time, keyframeData, part)
		if (part ~= nil) then
			local poseParent = keyframeData

			-- see if we can find a pose for this part
			local pose = getClosestPose(time, part)

			if (pose ~= nil) then
				local item = pose.Item
				poseParent = Make('Pose', {					
					Name = part.Name,
					Parent = keyframeData,
					Weight = 1,
					CFrame =(item.OriginC1 
						         and item.OriginC1:inverse()*pose.CFrame:inverse()*item.OriginC1
						         or  pose.CFrame)
				})

				poseParent.EasingStyle = pose.EasingStyle
				poseParent.EasingDirection = pose.EasingDirection
			end

			for _, childPart in pairs(part.Children) do
				createPoseFromLastKeyframe(time, poseParent, childPart)
			end
		end
	end
	
	function createPosesFromKeyframeHelper(keyframeData, poseParent, partData)
		if not partData then return end
		local poseData = keyframeData.Poses[partData.Item]
		local didCreatePose = false
				
		if poseData then
			local posedPartData = poseData.Item
			poseParent = Make("Pose", {
				Name = partData.Name,
				Parent = poseParent,
				Weight = 1,
				MaskWeight = 0,
				CFrame = (posedPartData.OriginC1 and posedPartData.OriginC1:inverse() * poseData.CFrame:inverse() * posedPartData.OriginC1) or poseData.CFrame,
			})

			poseParent.EasingStyle = poseData.EasingStyle
			poseParent.EasingDirection = poseData.EasingDirection
			didCreatePose = true
		end
		
		--Creates parent poses. Weight set to 0 because these are poses that did not exist that we create for saving only.
		--When importing a pose, we ignore poses with weight 0.
		for _, childPartData in pairs(partData.Children) do
			if keyframeData.Poses[childPartData.Item] and not didCreatePose then
				poseParent = Make("Pose", {
					Name = partData.Name,
					Parent = poseParent,
					Weight = 0,
					MaskWeight = 0,
					CFrame = CFrame.new(),
				})

				poseParent.EasingStyle = Enum.PoseEasingStyle.Linear
				poseParent.EasingDirection = Enum.PoseEasingDirection.Out
				didCreatePose = true
			end
			
			createPosesFromKeyframe(keyframeData, poseParent, childPartData)
		end
	end
	
	function removeUnincludedParts(keyframe)
		--Collect all poses in given keyframe
		local poses = {}
		local function recurse(parent)
			for _, child in pairs(parent:GetChildren()) do
				if child:IsA("Pose") then
					table.insert(poses, child)
				end
				recurse(child)
			end
		end
		recurse(keyframe)
		
		
		for _, pose in pairs(poses) do
			local poseHasIncludedChildren = false
			local poseIncluded = partInclude[pose.Name] and (pose.Name ~= "HumanoidRootPart")
			for _, child in pairs(pose:GetChildren()) do
				if partInclude[child.Name] then
					poseHasIncludedChildren = true
					break
				end
			end
			
			if (not poseIncluded) then
				pose.Weight = 0
				
				if (not poseHasIncludedChildren) then
					for _, child in pairs(pose:GetChildren()) do
						child.Parent = pose.Parent
					end
					pose:Destroy()
				end
			end
		end
	end
	
	function createPosesFromKeyframe(keyframeData, poseParent, partData)
		createPosesFromKeyframeHelper(keyframeData, poseParent, partData)
		removeUnincludedParts(poseParent)
	end

	function createAnimationFromCurrentData()
		local kfs = Make('KeyframeSequence', {
			Name = "Test",
			Loop = loopAnimation,
			Priority = animationPriority,
		})

		for time, keyframe in spairs(keyframeList, function(t, a, b) return t[a].Time < t[b].Time end) do
			-- print("Time " .. time)

			local kfd = Make('Keyframe', {
				Name = keyframe.Name,
				Time = time,
				Parent = kfs,
			})

			-- go through part heirarach
			createPosesFromKeyframe(keyframe, kfd, rootPart)
		end

		-- check for end animation keyframe
		local keyframe = getKeyframe(animationLength)
		if (keyframe == nil) then
			local kfd = Make('Keyframe', {
				Name = "KF" .. animationLength,
				Time = animationLength,
				Parent = kfs,
			})

			createPoseFromLastKeyframe(animationLength, kfd, rootPart)
		end
		return kfs
	end
	

	playingAnim = false
	function playCurrentAnimation()
		if (not playingAnim) then
			modal = true
			game:GetService("ChangeHistoryService"):SetEnabled(true)
			game:GetService("ChangeHistoryService"):SetWaypoint("Animation_Play")

			playingAnim = true
			stopAnim = false
			animationPlayID = animationPlayID + 1

			-- Update the model to start positions
			local motorOrig = {}
			for part,elem in pairs(partList) do
				if (elem.Motor6D ~= nil) then
--					local pose = getClosestPose(0, part)
--					elem.Motor6D.C1 = pose.CFrame * pose.Item.OriginC1
					elem.Motor6D.C1 = elem.OriginC1
					nudgeView()
				end
			end

			local kfsp = game:GetService('KeyframeSequenceProvider')

			local kfs = createAnimationFromCurrentData()
			local animID = kfsp:RegisterKeyframeSequence(kfs)
			local dummy = rootPart.Item.Parent

--			print("AnimID = " .. animID)

			local AnimationBlock = dummy:FindFirstChild("AnimSaves")
			if AnimationBlock == nil then
				AnimationBlock = Instance.new('Model')
				AnimationBlock.Name = "AnimSaves"
				AnimationBlock.Parent = dummy
			end

			local Animation = AnimationBlock:FindFirstChild("TestAnim")
			if Animation == nil then
				Animation = Instance.new('Animation')
				Animation.Name = "TestAnim"
				Animation.Parent = AnimationBlock
			end
			Animation.AnimationId = animID

			wait()
			game:GetService('RunService'):Run()
			wait()

			local endEarly = menuManager.GetStopRequest(function()
				stopAnim = true
			end)
			
			currentAnimTrack = animationController:LoadAnimation(Animation)
			currentAnimTrack:Play()

			if (not loopAnimation) then
				Spawn(function()
					local ID = animationPlayID
					time = tick()
					while (tick() - time < animationLength ) do
						wait()
					end	
					if (ID == animationPlayID) then
						if not stopAnim then
							endEarly()
						end
						stopAnim = true
					end
				end)
			end

			while (not stopAnim) do
				wait()
			end

			currentAnimTrack:Stop(0)
			wait()
			
			game:GetService('RunService'):Stop()

			wait()
			playingAnim = false
			modal = false
			--game:GetService("ChangeHistoryService"):Undo()
			for part,elem in pairs(partList) do
				if (elem.Motor6D ~= nil) then
					elem.Motor6D.CurrentAngle = 0
					elem.Motor6D.C1 = elem.OriginC1
				end
			end
			
			updateCursorPosition()
		end
	end

	function saveCurrentAnimation(animName)
		if playingAnim then return end
	
		-- save to string item
		local dummy = rootPart.Item.Parent
		local AnimationBlock = dummy:FindFirstChild("AnimSaves")
		if AnimationBlock == nil then
			AnimationBlock = Instance.new('Model')
			AnimationBlock.Name = "AnimSaves"
			AnimationBlock.Parent = dummy
		end

		local save = AnimationBlock:FindFirstChild(animName)
		if save then
			save:Destroy()
		end
		save = createAnimationFromCurrentData()
		save.Name = animName
		save.Parent = AnimationBlock
	end
	
	function autoSave()
		if not rootPart then return end
		if not _G["AnimationEdit"] then return end
		
		local timeSinceLastAutoSave = tick() - lastAutoSaveTime
		
		if timeSinceLastAutoSave > 1 then
			saveCurrentAnimation("Automatic Save")
			lastAutoSaveTime = tick()
		end
	end

	function loadCurrentAnimation(animName)
		if playingAnim then return end
		-- get string item
		local dummy = rootPart.Item.Parent
		local AnimationBlock = dummy:FindFirstChild("AnimSaves")
		if AnimationBlock == nil then
			return
		end

		local Animation = AnimationBlock:FindFirstChild(animName)
		if Animation == nil then
			return
		end
		
		loadImportAnim(Animation)
	end
	
	function promptChangeLength()
		modal = true
		local desiredLength = promptInput("Change Animation Length",tostring(animationLength))
		if desiredLength ~= nil and tonumber(desiredLength) ~= nil then
			setAnimationLength(tonumber(desiredLength))
		end
		modal = false
	end
	
	function promptTickChange()
		local newSnap = tonumber(promptInput("Tick Line Increment (seconds)", tostring(tickIncrements)))
		if newSnap ~= nil and newSnap >= 0.02 then
			tickIncrements = newSnap
		end
		setAnimationLength(animationLength)
	end
	
	function promptSnapChange()
		local newSnap = tonumber(promptInput("Cursor Snap Increment (seconds)", tostring(dragSnapIncrements)))
		if newSnap ~= nil and newSnap >= 0.02 then
			dragSnapIncrements = newSnap
		end
	end
	
	function promptAddTime()
		local time = tonumber(promptInput("Add Time At Cursor", "<time>"))
		if time ~= nil and time > 0 then
			addTimeAtCursorNew(time)
		end
	end
	
	function promptRemoveTime()
		local time = tonumber(promptInput("Remove Time At Cursor", "<time>"))
		if time ~= nil and time > 0 then
			removeTimeAtCursorNew(time)
		end		
	end
	
	function promptChangePriority()
		modal = true
		menuManager.GetPriority(plugin, function(newPriority) 
			modal = false 
			animationPriority = newPriority 
		end)
	end
	
	function promptChangeLooping()
		modal = true
		menuManager.GetLoop(plugin, function(loopDecision) 
			modal = false 
			loopAnimation = loopDecision
		end)
	end
	
	function promptInput(title, def)
		modal = true
		local val = menuManager.PromptInput(title, def)
		modal = false
		return val
	end
	
	function promptNew()
		modal = true
		local val = menuManager.PromptOkCancel("Are you sure? Unsaved progress will be lost.")
		modal = false
		if val == true then
			registerUndo( {
				action = "deleteKeyframe",
			})
			resetAnimation()			
		end
	end
	
	function requestValue(val)
		if val == "Loop" then
			return loopAnimation
		elseif val == "Snap" then
			return dragSnapIncrements
		elseif val == "Priority" then
			return animationPriority
		elseif val == "Lines" then
			return tickIncrements
		end
	end
	
	function importFbxAnimation()
		local dummy = rootPart.Item.Parent
		--Sanity check
		if dummy:findFirstChild("InitialPoses") then
			resetAnimation()
			local conn
			conn = game.Workspace.ChildAdded:connect(function(c)
				if c.Name == "ImportedAnimation" then
					--Move to AnimSaves
					if dummy:findFirstChild("AnimSaves") == nil then
						local m = Instance.new("Model", dummy)
						m.Name = "AnimSaves"
					end
					wait()
					c.Parent = dummy.AnimSaves
					c.Priority = "Core" --move this to C++ at some point
					loadKeyframeSequence(c)
					conn:disconnect()
				end
			end)
			plugin:ImportFbxAnimation(dummy)
		else
			warn("Rig does not have initial pose data. Rig must be imported via FBX to use this feature!")
		end
	end


----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------

keysDown = {}
keyDownListener = nil
keyUpListener = nil


function isKeyDown(key)
	if ( keysDown[key] == nil ) then
		return false
	else
		return keysDown[key]
	end
end

function onKeyDown(key)
	if ( string.byte(key) == 48 ) then
		keysDown["shift"] = true
	elseif  ( string.byte(key) == 50 ) then
		keysDown["ctrl"] = true
	elseif  ( string.byte(key) == 52 ) then
		keysDown["alt"] = true
	elseif  ( string.byte(key) == 118 ) then
		keysDown["v"] = true
		pastePoses()
	elseif  ( string.byte(key) == 114 ) then
		keysDown["r"] = true
		toggleHandles()
	elseif  ( string.byte(key) == 116 ) then
		keysDown["t"] = true
		toggleStep()
	elseif ( string.byte(key) == 121 ) then
		keysDown["y"] = true
		if not keysDown["shift"] then
			toggleTransformSpace()
		else
			redo()
		end
	elseif key == "z" and keysDown["shift"] then
		undo()
	end
end

function onKeyUp(key)
--  print("Key UP:", key, " Code:", string.byte(key))
	if ( string.byte(key) == 48 ) then
		keysDown["shift"] = false
	elseif  ( string.byte(key) == 50 ) then
		keysDown["ctrl"] = false
	elseif  ( string.byte(key) == 52 ) then
		keysDown["alt"] = false
	elseif  ( string.byte(key) == 118 ) then
		keysDown["v"] = false
	elseif  ( string.byte(key) == 114 ) then
		keysDown["r"] = false
	elseif ( string.byte(key) == 121) then
		keysDown["y"] = false
	end
end

function releaseListeners()
	if (keyUpListener ~= nil) then
		keyUpListener:disconnect()
	end
	if (keyDownListener ~= nil) then
		keyDownListener:disconnect()
	end

end

function connectListeners(mouse)
	if (mouse ~= nil) then
		releaseListeners()
		keysDown = {}
		keyDownListener = mouse.KeyDown:connect(onKeyDown)
		keyUpListener = mouse.KeyUp:connect(onKeyUp)
	end
end

----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------



function exitPlugin()
	local okToQuit = false
	if _G["AnimationEdit"] then
		modal = true
		okToQuit = menuManager.PromptOkCancel("You will lose unsaved progress. Are you sure?")
		modal = false
	else
		okToQuit = true
	end
	if okToQuit then
		plugin:Activate(false)
		pcall(function()
			destroySelectionBoxes()
		end)
		if mProxyPart ~= nil then
			mProxyPart:Destroy()
		end
		_G["AnimationEdit"] = false
		modal = false
		--new
		releaseListeners()
		--resetAnimation()
		clearAllEvents()
		if (MouseTargeterHalt ~= nil) then
			MouseTargeterHalt()
		end
		--
		menuManager.Quit()
		if destroySelectionBoxes then destroySelectionBoxes() end
		game:GetService("ChangeHistoryService"):SetEnabled(true)
		game:GetService("ChangeHistoryService"):ResetWaypoints()
		button:SetActive(false)
	end
end

plugin.Deactivation:connect(function()
	autoSave()
	
	_G["AnimationEdit"] = false
	releaseListeners()
	if timelineUI then
		resetAnimation()
		timelineUI:Destroy()
	end
	timelineUI = nil
	if menuUI then
		menuUI:Destroy()
	end
	menuUI = nil
	if saveUI then
		saveUI:Destroy()
	end
	saveUI = nil
	if loadUI then
		loadUI:Destroy()
	end
	loadUI = nil
	if stopAnimUI then
		stopAnimUI:Destroy()
	end
	stopAnimUI = nil
	if timeChangeUI then
		timeChangeUI:Destroy()
	end
	if snapChangeUI then
		snapChangeUI:Destroy()
	end
	if angleChangeUI then
		angleChangeUI:Destroy()
	end
	if tickChangeUI then
		tickChangeUI:Destroy()
	end
	timeChangeUI = nil
	if (rotateMoveUI) then
		rotateMoveUI:Destroy()
	end
	rotateMoveUI = nil
	if (destroySelectionBoxes) then
		destroySelectionBoxes()
	end

	modal = false
	rotateMode = true
	partSelection = nil
	rotateStep = 0
	moveStep = 0

end)

function CreateGrid(obj)
	spawn(function()
		local USE_FADE_EFFECT = false
		local USE_GROW_EFFET = true
		--local center = obj.Parent:GetModelCFrame().p
		local center = CFrame.new(0,0,0).p
		local extents = obj.Parent:GetExtentsSize()
		local width = math.max(extents.X, extents.Z)
		width = width + 3
		local lineSpacing = width / 10
		local dstToFloor = (extents.Y * 0.5) + (obj.Position.Y - obj.Parent:GetModelCFrame().p.Y)
		local floorCenter = center - Vector3.new(0, dstToFloor, 0)
		local lineModel = Instance.new("Folder", game.CoreGui)
		lineModel.Name = "AnimEdit_Lines"
		table.insert(cleanup, lineModel)
		--floorCenter = floorCenter - obj.Position
		--Build the grid
		
		local fade = function(line)
			spawn(function()
				for i = 1, 10 do
					if line then
						line.Transparency = 1 - i/10
						wait(0.07)
					end
				end
			end)		
		end
		
		local grow = function(line, finish)
			spawn(function()
				for i = 1, 60 do
					if line then
						line.Length = finish * (i/60)
						game:GetService("RunService").RenderStepped:wait()
					end
				end
			end)			
		end
		
		for z = -5, 5 do
			local line = Instance.new("LineHandleAdornment")
			line.Thickness = 2
			line.Color = envRoot.AnimationEditor.Customize.GridColor.Value--BrickColor.new"Bright red"
			line.Length = width
			line.Adornee = obj
			line.CFrame = CFrame.new(floorCenter) + Vector3.new(z * lineSpacing, 0, width / 2)
			if USE_FADE_EFFECT then
				--Beta fade
				line.Transparency = 1
				fade(line)
				wait(0.05)
				--End of beta fade
			end
			if USE_GROW_EFFET then
				grow(line, width)
				wait(0.05)				
			end
			
			line.Parent = lineModel
			table.insert(cleanup, line)
		end
		for x = -5, 5 do
			local line = Instance.new("LineHandleAdornment")
			line.Thickness = 2
			line.Color = envRoot.AnimationEditor.Customize.GridColor.Value--BrickColor.new"Bright red"
			line.Length = width
			line.Adornee = obj
			line.CFrame = (CFrame.new(floorCenter) + Vector3.new(width / 2, 0, x * lineSpacing)) * CFrame.Angles(0, math.pi/2, 0)
			if USE_FADE_EFFECT then
				--Beta fade
				line.Transparency = 1
				fade(line)
				wait(0.05)
				--End of beta fade
			end	
			if USE_GROW_EFFET then
				grow(line, width)
				wait(0.05)				
			end		
			
			line.Parent = lineModel
			table.insert(cleanup, line)
		end
	end)
end

function menuRequest(arg)
	wait()
	if modal then return end
	if arg == "Save" then
		PromptSave()
	elseif arg == "Load" then
		PromptLoad()
	elseif arg == "Export" then
		modal = true
		showExportAnim()
	elseif arg == "Import" then
		modal = true
		showImportAnimText()
		modal = false
	elseif arg == "Help" then
		plugin:OpenWikiPage("Animations")
	elseif arg == "EditHelp" then
		plugin:OpenWikiPage("Animations#Edit_Menu")
	elseif arg == "SettingsHelp" then
		plugin:OpenWikiPage("Animations#Settings_Menu")
	elseif arg == "New" then
		promptNew()
	elseif arg == "Play" then
		modal = true
		playCurrentAnimation()
	elseif arg == "Paste" then
		pastePoses()
	elseif arg == "CreateKeyframe" then
		createKeyframe(cursorTime)
	elseif arg == "Undo" then
		undo()
	elseif arg == "Redo" then
		redo()
	elseif arg == "ChangeLength" then
		promptChangeLength()
	elseif arg == "Lines" then
		promptTickChange()
	elseif arg == "Snap" then
		promptSnapChange()
	elseif arg == "AddTime" then
		promptAddTime()
	elseif arg == "RemoveTime" then
		promptRemoveTime()
	elseif arg == "Priority" then
		promptChangePriority()
	elseif arg == "Loop" then
		promptChangeLooping()
	elseif arg == "TweenCursor" then
		preferences["TweenCursor"] = not preferences["TweenCursor"]
	elseif arg == "Interpolation" then
		preferences["Interpolation"] = not preferences["Interpolation"]
	elseif arg == "ShowTooltips" then
		preferences["Tooltips"] = not preferences["Tooltips"]
	elseif arg == "SelectInvisible" then
		preferences["SelectInvisible"] = not preferences["SelectInvisible"]
	elseif arg == "FBXImport" then
		importFbxAnimation()
	end
end

button.Click:connect(function()
	if _G["AnimationEdit"] == true then --Only if the timeline has already launched
		exitPlugin()
	elseif menuManager.HasActiveWindow() then --Is the "root picker" UI open?
		exitPlugin()
	else
		plugin:Activate(true)
		button:SetActive(true)
		local retFunc = function(selectedObject)
			if selectedObject ~= nil then
				_G["AnimationEdit"] = true
				game:GetService("ChangeHistoryService"):SetEnabled(false)
				-- reset UI
				timelineUI = nil
				menuUI = nil
				saveUI = nil
				loadUI = nil
				stopAnimUI = nil
				timeChangeUI = nil
				snapChangeUI = nil
				angleChangeUI = nil
				tickChangeUI = nil
			
				-- reset the assembly information
				partList = {}
				partListByName = {}
				partToItemMap = {}
				partToLineNumber = {}
				rootPart = nil
			
				partInclude = {}
				modal = false
				rotateMode = true
				partSelection = nil
				rotateStep = 0
				moveStep = 0
			
				local mouse = plugin:GetMouse()
				connectListeners(mouse)
				
				local getController = function(p)
					for i, v in pairs(p:GetChildren()) do
						if v:IsA("Humanoid") or v:IsA("AnimationController") then
							return v
						end
					end
					return nil
				end
				
				animationController = getController(selectedObject.Parent)
			
				-- find the hierarchy
				--first, gather the info on what's being animated
				local mBaseItem = { --recursive structure holding hierarchy of items
					Item = selectedObject,
					Name = selectedObject.Name,
					Motor6D = nil,
					OriginC1 = CFrame.new(),
					Children = {},
					Parent = nil,
				}
				rootPart = mBaseItem
	
				local joints = {}
				local function recurse(obj)
					if obj:IsA("Motor6D") then
						table.insert(joints, obj)
					end
					
					for _, child in pairs(obj:GetChildren()) do
						recurse(child)
					end
				end
				recurse(rootPart.Item.Parent)
				
				local partCount = 1
				do
					local visitedParts = {}
					local function findPairedJoints(parent)
						local parentObject = parent.Item
						local childList = {}
						local jointList = {}
						for _, joint in pairs(joints) do
							if (joint.Part1 and joint.Part1.Name == "ProxyPart") or (joint.Part0 and joint.Part0.Name == "ProxyPart") then
								break 
							else
								if joint.Part0 == parentObject and joint.Part1 ~= nil and visitedParts[joint.Part1.Name] == nil then
									table.insert(childList, joint.Part1)
									table.insert(jointList, joint)
								elseif joint.Part1 == parentObject and joint.Part0 ~= nil and visitedParts[joint.Part0.Name] == nil then
									table.insert(childList, joint.Part0)
									table.insert(jointList, joint)
								end
							end
						end					
						return childList, jointList
					end
					
					local function doCalculate(item)
						visitedParts[item.Name] = item
			--			mAllItems[#mAllItems+1] = item
						partList[item.Item] = item
						partListByName[item.Name] = item
						partToItemMap[item.Item] = item
						partToLineNumber[item.Item] = partCount
						partInclude[item.Name] = true
			
						local childList, jointList = findPairedJoints(item)
						for idx, joinedTo in pairs(childList) do
							local p = jointList[idx]
								
							local it = {
								Item = joinedTo,
								Name = joinedTo.Name,
								Motor6D = p,
								OriginC1 = repairedCFrame(p.C1),
								Children = {},
								Parent = item,
							}
							item.Children[#item.Children+1] = it
							partCount = partCount+1
							doCalculate(it)
						end
					end
					doCalculate(mBaseItem)
				end
							
				MakePartSelectGui(mBaseItem)
				createTimelineUI(mBaseItem)
				menuManager.InitializeSettings({
					Interpolation = preferences["Interpolation"],
					SelectInvisible = preferences["TransparentSelect"],
					TweenCursor = preferences["TweenCursor"],
					ShowTooltips = preferences["Tooltips"],
				})
				menuManager.InitializeTopbar(timelineUI.RootFrame,function() return modal == false end, function() modal = true end, function() modal = false end, menuRequest, requestValue)
				menuManager.InitializeTooltips()
				resetAnimation()
				CreateGrid(selectedObject)
			else
				plugin:Activate(false)
				button:SetActive(false)
			end
		end	
		menuManager.SelectRig(plugin:GetMouse(), plugin, retFunc)
	end
end)]]></ProtectedString>
			</Properties>
			<Item class="ModuleScript" referent="RBXB596248A8D154E0D8F4F502910996B1D">
				<Properties>
					<Content name="LinkedSource"><null></null></Content>
					<string name="Name">EasingStyles</string>
					<string name="ScriptGuid"></string>
					<ProtectedString name="Source"><![CDATA[local module = {}

--Ignore semicolons. Converted from C++

module.GetEasing = function(style, direction, percent)
	if style == "Bounce" then
		if direction == "Out" then
			return 1 - easeOut(percent, bounce)
		elseif direction == "In" then
			return 1 - bounce(percent)
		else
			return 1 - easeInOut(percent, bounce)
		end
	elseif style == "Elastic" then
		if direction == "Out" then
			local totalTime = 1
			local p = totalTime*.3;
			local t = 1 - percent;
			local s = p/4;
			return (1 +2^(-10*t) * math.sin( (t*totalTime-s)*(math.pi*2)/p ));
		elseif direction == "In" then
			local totalTime = 1
			local p = totalTime*.3;
			local t = percent;
			local s = p/4;
			return 1 - (1 + 2^(-10*t) * math.sin( (t*totalTime-s)*(math.pi*2)/p ));
		elseif direction == "InOut" then
			local t = percent *2;
			local p = (.3*1.5);
			local s = p/4;
			if (t < 1) then
				t = t - 1;
				return 1 - (-.5 * 2^(10*t) * math.sin((t-s)*(math.pi*2)/p ));
			else
				t  = t - 1;
				return 1 - (1 + 0.5 * 2^(-10*t) * math.sin((t-s)*(math.pi*2)/p ));
			end
		end
	elseif style == "Cubic" then
		if direction == "Out" then
			return 1 - easeOut(percent, cubic)
		elseif direction == "In" then
			return 1 - cubic(percent)
		elseif direction == "InOut" then
			return 1 - easeInOut(percent, cubic)
		end
	elseif style == "Linear" then
		return 1 - percent
	elseif style == "Constant" then
		if style == "Out" then
			return 1
		elseif style == "In" then
			return 0
		elseif style == "InOut" then
			return 0.5
		end
	end
end

function easeIn(t,func)
	return func(t)
end

function easeOut(t,func)
	return 1-func(1-t)
end

function easeInOut(t,func)
	t=t*2
	if t < 1 then
		return easeIn(t,func)*.5
	else
		return .5+easeOut(t-1,func)*.5
	end
end

function bounce(t)
	if t<.36363636 then
		return 7.5625*t*t
	elseif t<.72727272 then
		t=t-.54545454
		return 7.5625*t*t+.75
	elseif t<.90909090 then
		t=t-.81818181
		return 7.5625*t*t+.9375
	else
		t=t-.95454545
		return 7.5625*t*t+.984375
	end
end

function cubic(t)
	return t^3
end

return module
]]></ProtectedString>
				</Properties>
			</Item>
			<Item class="Folder" referent="RBX45F0BCA935FE48A7B4A608ED62DCEF41">
				<Properties>
					<string name="Name">GUIs</string>
				</Properties>
				<Item class="Frame" referent="RBXD14480146DDA42F5AD516AB5BF750187">
					<Properties>
						<bool name="Active">true</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">true</bool>
						<string name="Name">EasingStyle</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0</XS>
							<XO>50</XO>
							<YS>0.5</YS>
							<YO>-125</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>350</XO>
							<YS>0</YS>
							<YO>250</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBX4DDEEB104E1F469C9A5C2CCC3EFBD954">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Submit</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>210</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>150</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Okay</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX765FA39BCCF840189F547320FD44A196">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>185</XO>
								<YS>0</YS>
								<YO>210</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>150</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Cancel</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX1DBC1907DCFB4A0B99719E9B69A5CC60">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX9B01E9911B4640BFAF1C377A6A2FD9A3">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Easing Style:</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="Frame" referent="RBX50CA18E1BD984394B56132E6F66A1A68">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4294967295</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<string name="Name">Styles</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>100</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="TextButton" referent="RBX9D94B7756EB24786979812D7F6DE5577">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4285583175</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Linear</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Linear</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX353493E5D82E4517BE4F678C1419D73B">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4278214144</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Cubic</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>125</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Cubic</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX3B3129F5E5F64A6FAE95D24B4BCEDCBF">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4278214144</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Constant</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>235</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Constant</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX3C8ABFC22574406C976BB2DE1D985296">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4278214144</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Elastic</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>70</XO>
									<YS>0</YS>
									<YO>35</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Elastic</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX49B0C759D4D8410CA087D6DB047963E5">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4278214144</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Bounce</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>180</XO>
									<YS>0</YS>
									<YO>35</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Bounce</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="Color3Value" referent="RBX591ECAFB1B394DB28C37F2FD62A737AB">
							<Properties>
								<string name="Name">DeselectedColor</string>
								<Color3 name="Value">4282269246</Color3>
							</Properties>
						</Item>
						<Item class="Color3Value" referent="RBXAC852656AFE64B848211C371B42F5616">
							<Properties>
								<string name="Name">SelectedColor</string>
								<Color3 name="Value">4285953654</Color3>
							</Properties>
						</Item>
					</Item>
					<Item class="TextLabel" referent="RBX7009E546704547E1B8C7C1A603E72C84">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>110</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Easing Direction</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="Frame" referent="RBXAE554C0D2B574D92826F95E51788D532">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4294967295</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<string name="Name">Directions</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>140</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="TextButton" referent="RBX1D79A56EE3F6404EA12CC3F415056BCB">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4283804415</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Out</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Out</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX8222E43DFA1F4188BA96F71A9CF5DF09">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4281675421</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">InOut</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>125</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">InOut</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX0D663CFF47B948D49083738E467A321C">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4281675421</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">In</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>235</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>100</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">In</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="Color3Value" referent="RBXE341F9844B964C43935EFF9920883028">
							<Properties>
								<string name="Name">SelectedColor</string>
								<Color3 name="Value">4285953654</Color3>
							</Properties>
						</Item>
						<Item class="Color3Value" referent="RBXE90DB564C32944138B72B49FCC786E7E">
							<Properties>
								<string name="Name">DeselectedColor</string>
								<Color3 name="Value">4282269246</Color3>
							</Properties>
						</Item>
					</Item>
					<Item class="TextLabel" referent="RBXD5A79AB796764681B54037AFECF7A4FE">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4294967295</Color3>
							<float name="BackgroundTransparency">0.400000006</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.0500000007</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>190</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0.899999976</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>1</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
				<Item class="Frame" referent="RBXCA511D8FAB5E427F8E3C11BF08507C72">
					<Properties>
						<bool name="Active">true</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">true</bool>
						<string name="Name">Save</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0</XS>
							<XO>50</XO>
							<YS>0.5</YS>
							<YO>-125</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>200</XO>
							<YS>0</YS>
							<YO>300</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBXB26708415B45487FA995EECF286E8A2C">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Save</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>80</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Save</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBXBD8D6098F586453A81290F2F3401A5F6">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>105</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>80</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Cancel</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX7645A40C4831420992D926D5C4E4570D">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX2DF9C21844EF49AFAE8EBA595C69951A">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Overwrite</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX276AE7B2BA7C43B5B08620C9684FE4C6">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4294967295</Color3>
							<float name="BackgroundTransparency">0.400000006</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.0500000007</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>225</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0.899999976</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>1</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextBox" referent="RBX591FE4B4DA7547AA89159B9C34D2C167">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279374354</Color3>
							<float name="BackgroundTransparency">0.5</float>
							<Color3 name="BorderColor3">4278190080</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClearTextOnFocus">true</bool>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="MultiLine">false</bool>
							<string name="Name">TextBox</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>235</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<bool name="ShowNativeInput">true</bool>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">&lt;enter name&gt;</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.699999988</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXED70DAA7823943F6BFDEC6FD603C125C">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>205</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Save</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="ScrollingFrame" referent="RBX167DA69F6766491E8756A2891CD956A5">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279374354</Color3>
							<float name="BackgroundTransparency">0.5</float>
							<Color3 name="BorderColor3">4278190080</Color3>
							<int name="BorderSizePixel">1</int>
							<Content name="BottomImage"><url>rbxasset://textures/ui/Scroll/scroll-bottom.png</url></Content>
							<Vector2 name="CanvasPosition">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<UDim2 name="CanvasSize">
								<XS>0</XS>
								<XO>0</XO>
								<YS>2</YS>
								<YO>0</YO>
							</UDim2>
							<bool name="ClipsDescendants">true</bool>
							<bool name="Draggable">false</bool>
							<Content name="MidImage"><url>rbxasset://textures/ui/Scroll/scroll-middle.png</url></Content>
							<string name="Name">ScrollingFrame</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<int name="ScrollBarThickness">12</int>
							<bool name="ScrollingEnabled">true</bool>
							<bool name="Selectable">true</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>170</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<Content name="TopImage"><url>rbxasset://textures/ui/Scroll/scroll-top.png</url></Content>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX81FE0C382CDF41439C75CED3529D0372">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Template</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Save</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
				<Item class="Frame" referent="RBX659E448CCB53407F98B0D5AA5FB6F06A">
					<Properties>
						<bool name="Active">true</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">true</bool>
						<string name="Name">Load</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0</XS>
							<XO>50</XO>
							<YS>0.5</YS>
							<YO>-125</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>200</XO>
							<YS>0</YS>
							<YO>300</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBX6CDFB70E08AE4274BD21A8F24B9FB29A">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Load</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>80</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Load</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX65D8B8CD94F449D497DC9354CC6F9015">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>105</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>80</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Cancel</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX3D4896CFF3844BAB8951EAF9CE2BE606">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX001A394FD90149638691EB209E34A07B">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Load</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="ScrollingFrame" referent="RBXB3462B316E7A4A3D933E1768F2C79335">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279374354</Color3>
							<float name="BackgroundTransparency">0.5</float>
							<Color3 name="BorderColor3">4278190080</Color3>
							<int name="BorderSizePixel">1</int>
							<Content name="BottomImage"><url>rbxasset://textures/ui/Scroll/scroll-bottom.png</url></Content>
							<Vector2 name="CanvasPosition">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<UDim2 name="CanvasSize">
								<XS>0</XS>
								<XO>0</XO>
								<YS>2</YS>
								<YO>0</YO>
							</UDim2>
							<bool name="ClipsDescendants">true</bool>
							<bool name="Draggable">false</bool>
							<Content name="MidImage"><url>rbxasset://textures/ui/Scroll/scroll-middle.png</url></Content>
							<string name="Name">ScrollingFrame</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<int name="ScrollBarThickness">12</int>
							<bool name="ScrollingEnabled">true</bool>
							<bool name="Selectable">true</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>210</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<Content name="TopImage"><url>rbxasset://textures/ui/Scroll/scroll-top.png</url></Content>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX7CE22D5B072F43678511232556087BD9">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Template</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Save</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXC1EB9B2561324B30A8A8FBD24D18E3BA">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">LoadTitle</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>240</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
				<Item class="Frame" referent="RBXFC1736F7BF9342159B43A80615BF86CA">
					<Properties>
						<bool name="Active">false</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4280821800</Color3>
						<float name="BackgroundTransparency">0</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">false</bool>
						<string name="Name">Topbar</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0</XS>
							<XO>0</XO>
							<YS>0</YS>
							<YO>0</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>1</XS>
							<XO>0</XO>
							<YS>0</YS>
							<YO>15</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBX59150EFADB954FC8B481EA3FD31A22C9">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4280821800</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">File</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>40</XO>
								<YS>1</YS>
								<YO>0</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">FILE</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">2</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBXB44E650D9F0443B39238E4BA3E9F4211">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4280821800</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Edit</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>40</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>40</XO>
								<YS>1</YS>
								<YO>0</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">EDIT</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">2</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX2CA2982010D14A5DBA96AF6A540BB090">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4280821800</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Settings</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>80</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>60</XO>
								<YS>1</YS>
								<YO>0</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">SETTINGS</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">2</int>
						</Properties>
					</Item>
					<Item class="Frame" referent="RBX2782C0614C5149DC9944F50C804EE1FD">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4280821800</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<string name="Name">FileFrame</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>15</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>200</XO>
								<YS>0</YS>
								<YO>230</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">5</int>
						</Properties>
						<Item class="TextButton" referent="RBXA8C47418E57C45C692539CEBDEF44242">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">New</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>40</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">New</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXD91A13F79C9F49D58334BC0C14679745">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620779843</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX79A5428640E849AC8756F3BF09A8636F">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Start a new animation</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX6C58755D3A654C609390606547D054DD">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Load</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>70</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Load</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXC122533F650C4E688A4F97B1BBE3B6E4">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620779845</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXCC85F9C7EC1D45528523C7448D027FDF">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Load an animation saved in this rig</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX202CB48298FF412FA3F64C52AF940F0B">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Save</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>100</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Save</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX6FB368A64C17414B8D79D864F95542C5">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620783624</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXDD1CED6EB7534C14A81F954F0A3B16D0">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Save the current animation in this place. This does not upload your animation.</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX2B6B3A2B8C594E5E92FB767888887A22">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Import</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>130</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Import</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXAEEFB340A3C547C4BBD1BCF636E48FC6">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620779848</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXB3363C94DA154C269442FB145421552F">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Import an animation from the website</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX3A4A33D4533D4B0DB5A07A05E5DD006D">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Export</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>160</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Export</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXC2B9D1A50E3645D1AD12E901B22138AD">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620778180</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX7E9816E1E5E5459EBF2E1EB2BEC43CF0">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Export an animation to the website</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX8912F80FD503498A9F70D1C7D9033E59">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Help</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>190</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Help</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX2CE4B3B701CA4153A2AE3EBF06920BD4">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620778168</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXDF5AA35E28CC426FAFAEF797A09D7CB3">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Play</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>10</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Play</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX04B56CED0C4947358E49047B1F8AF12D">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620783615</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX57DD8854B090409BABA1C276BC351801">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Play the animation</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX53ED4965DA0F45A2BA68287D1DAF6552">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">FBXImport</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>220</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Import FBX Animation</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX5335A5863C7E4241AE2AF12755602E60">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620778180</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXB9D1F442DA1E4FB29C1AF7C217099130">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Experimental FBX importing.</string>
								</Properties>
							</Item>
						</Item>
					</Item>
					<Item class="Frame" referent="RBX29D02E2203E149D2B34F23B6B3935F02">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4280821800</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<string name="Name">EditFrame</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>40</XO>
								<YS>0</YS>
								<YO>15</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>200</XO>
								<YS>0</YS>
								<YO>320</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">5</int>
						</Properties>
						<Item class="TextButton" referent="RBX25A4AC7694BB4C1F8565C16C66FF6C23">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Undo</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>70</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Undo</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXC56D8B6B4AA7411EBAFF87FA1BF9EB12">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620791041</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX06D7C8266C1B44269F2A78DEA2FCB62E">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Redo</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>100</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Redo</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX7F8818BA92E747F087058E3370CA2D55">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620783612</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXBE2B0C92E4CF4D948AA514A151609BD7">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">ChangeLength</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>130</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Change Length</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX8B85E723DDF44E69B9B24CE241703735">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620779847</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX4641CA608759411BBC95EDEDB37F70A3">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Change the animation length</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXF8E4D1ABA02D4B95A1683ECEE4426559">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">AddTime</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>160</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Add Time At Cursor</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX12762195B7984AE3870F801A5208786A">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620778167</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX642D45753DA3490EAFA54F31F38C99DA">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Insert time at the cursor. Pushes keyframes forward</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX678DE6AC9E6A448F9DE1CEF64A73601A">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">RemoveTime</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>190</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Remove Time At Cursor</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX595ECB1028C04243AF2D33B20B212B85">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620783622</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXD36C3E50B5414D3998CCD72FF5514BAB">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Remove time at the cursor. Pulls keyframes backwards</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX79ACC2E56768495FA71DDEE09E2BFD6A">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Loop</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>220</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Set Looping</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXD5A2C14FF7AB4603BBAF005D344C00E9">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620779846</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX2A98819A2C0649E1AAB4AC3A880E9C57">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Set if the animation should loop or not</string>
								</Properties>
							</Item>
							<Item class="TextLabel" referent="RBX49F388F953B74E9C9D5CEFD250D6E234">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4282664004</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<token name="Font">4</token>
									<token name="FontSize">5</token>
									<string name="Name">CurrentValue</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>1</XS>
										<XO>-10</XO>
										<YS>1</YS>
										<YO>0</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<string name="Text"></string>
									<Color3 name="TextColor3">4294967295</Color3>
									<bool name="TextScaled">false</bool>
									<float name="TextSize">14</float>
									<Color3 name="TextStrokeColor3">4278190080</Color3>
									<float name="TextStrokeTransparency">1</float>
									<float name="TextTransparency">0</float>
									<bool name="TextWrapped">false</bool>
									<token name="TextXAlignment">1</token>
									<token name="TextYAlignment">1</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXB66D6BC988204463A02575A85D7A27B7">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Priority</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>250</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Set Priority</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX86D6A3DA2C1741ACAD70CC0978F0CA92">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620783627</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX65BFCACECB9D41BBB68DAE82B6DD147C">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Set the animation priority</string>
								</Properties>
							</Item>
							<Item class="TextLabel" referent="RBX2670AA99FE58488588BE9CE98A2C0326">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4282664004</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<token name="Font">4</token>
									<token name="FontSize">5</token>
									<string name="Name">CurrentValue</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>1</XS>
										<XO>-10</XO>
										<YS>1</YS>
										<YO>0</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<string name="Text"></string>
									<Color3 name="TextColor3">4294967295</Color3>
									<bool name="TextScaled">false</bool>
									<float name="TextSize">14</float>
									<Color3 name="TextStrokeColor3">4278190080</Color3>
									<float name="TextStrokeTransparency">1</float>
									<float name="TextTransparency">0</float>
									<bool name="TextWrapped">false</bool>
									<token name="TextXAlignment">1</token>
									<token name="TextYAlignment">1</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX82307756374C4C028BB25339E65FBFE1">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">EditHelp</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>280</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Edit Help</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX0D1A3BAF7FA649C1ADE1E4159598C0D8">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620778168</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX14D9EFFDABD540C891A3613801B7D2AC">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Paste</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>40</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Paste</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXA95EF0CB642341D5874911FC38CBADE7">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620783618</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXDAA1FBB3CF274155A91CBA2FB0F80BA8">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Paste copied pose</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX57003F22C3BF4ECE9D04C2E3218426AE">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">CreateKeyframe</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>10</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Insert Keyframe</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX2DF76441E51F4BBA9D677848163F1D3E">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620779849</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX18251A9800A9460EA8314ED06450D7F4">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Create a blank keyframe at the cursor</string>
								</Properties>
							</Item>
						</Item>
					</Item>
					<Item class="Frame" referent="RBX426CA4398DE6440788300D1C3AC6F88B">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4280821800</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<string name="Name">SettingsFrame</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>80</XO>
								<YS>0</YS>
								<YO>15</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>250</XO>
								<YS>0</YS>
								<YO>230</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">5</int>
						</Properties>
						<Item class="TextButton" referent="RBX365C41ED66CF475786671506E4FD0195">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">TweenCursor</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>10</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Cursor Animation</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX52E25BA74A724D9D9D7333BBDC0986C7">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620791039</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX5AC12D4545494F51A43336B0559E20F1">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Should the cursor use the tween effect?</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX9B72FC6308D8466EBBFD6E9EF605EE3F">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Interpolation</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>40</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Interpolation</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXCFC8FBC1E6C9473B9FDF939BFD8ADDB2">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620791039</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX8757BE17C004473E92CAC07803493E74">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Show partial poses, or only on keyframes?</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXA857E7E74605484889A86E8A17D48A8A">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">SelectInvisible</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>70</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Select Invisible Parts</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXF47AB9DB7AFD43B3AA512309F3BAB936">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620791039</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXF4CB1FDFC87340459A0EE3C297BF9489">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Select invisible parts, or ignore them?</string>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXFCC175BBD68042B689E22E88DDB6C8CE">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Snap</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>130</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Cursor Snap Increment</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBXEE19F1B1312340F7BD691CF030A11126">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620778173</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXA2155763A905415BAB2A7A347F2C6099">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">What times should the cursor snap at?</string>
								</Properties>
							</Item>
							<Item class="TextLabel" referent="RBX57BA62952C6545E489D80441DE65380F">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4282664004</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<token name="Font">4</token>
									<token name="FontSize">5</token>
									<string name="Name">CurrentValue</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>1</XS>
										<XO>-10</XO>
										<YS>1</YS>
										<YO>0</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<string name="Text"></string>
									<Color3 name="TextColor3">4294967295</Color3>
									<bool name="TextScaled">false</bool>
									<float name="TextSize">14</float>
									<Color3 name="TextStrokeColor3">4278190080</Color3>
									<float name="TextStrokeTransparency">1</float>
									<float name="TextTransparency">0</float>
									<bool name="TextWrapped">false</bool>
									<token name="TextXAlignment">1</token>
									<token name="TextYAlignment">1</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXF9D447FD5D0542DF93E0A7556C89535B">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Lines</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>160</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Line Increment</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX021235B9ADA04347ADC5398F16F5BCA8">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620779847</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBX1BC17BE646744C308CD8F86EEB1605BD">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">How often should markers be shown on the timeline?</string>
								</Properties>
							</Item>
							<Item class="TextLabel" referent="RBXFAEA36CEE4F04DF2B7FF25BB8E2B6760">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4282664004</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<token name="Font">4</token>
									<token name="FontSize">5</token>
									<string name="Name">CurrentValue</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>1</XS>
										<XO>-10</XO>
										<YS>1</YS>
										<YO>0</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<string name="Text"></string>
									<Color3 name="TextColor3">4294967295</Color3>
									<bool name="TextScaled">false</bool>
									<float name="TextSize">14</float>
									<Color3 name="TextStrokeColor3">4278190080</Color3>
									<float name="TextStrokeTransparency">1</float>
									<float name="TextTransparency">0</float>
									<bool name="TextWrapped">false</bool>
									<token name="TextXAlignment">1</token>
									<token name="TextYAlignment">1</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBXC49754905C164AC98551591502634655">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">SettingsHelp</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>190</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Settings Help</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX0A2E91927C0345769085A835BE672D6D">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620778168</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
						</Item>
						<Item class="TextButton" referent="RBX81CDA156CF6A4A2CA7E2A932F23B0930">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4280821800</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">1</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">ShowTooltips</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>40</XO>
									<YS>0</YS>
									<YO>100</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-40</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Show Tooltips</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">5</int>
							</Properties>
							<Item class="ImageLabel" referent="RBX273EA8B24E0D43FEA0514BA351375DDD">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4294967295</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<Content name="Image"><url>http://www.roblox.com/asset/?id=620791039</url></Content>
									<Color3 name="ImageColor3">4294967295</Color3>
									<Vector2 name="ImageRectOffset">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Vector2 name="ImageRectSize">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<float name="ImageTransparency">0</float>
									<string name="Name">ImageLabel</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>-32</XO>
										<YS>0.5</YS>
										<YO>-10</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<token name="ScaleType">0</token>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0</XS>
										<XO>20</XO>
										<YS>0</YS>
										<YO>20</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<Rect2D name="SliceCenter">
										<min>
											<X>0</X>
											<Y>0</Y>
										</min>
										<max>
											<X>0</X>
											<Y>0</Y>
										</max>
									</Rect2D>
									<bool name="Visible">true</bool>
									<int name="ZIndex">5</int>
								</Properties>
							</Item>
							<Item class="StringValue" referent="RBXAA5BF2DF14FF4106817FEB5D3E890580">
								<Properties>
									<string name="Name">Tooltip</string>
									<string name="Value">Show tooltips? This text is a tooltip!</string>
								</Properties>
							</Item>
						</Item>
					</Item>
				</Item>
				<Item class="Frame" referent="RBXCA745502F12F4DEDBC11416FF715C5C9">
					<Properties>
						<bool name="Active">false</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">false</bool>
						<string name="Name">InputTemplate</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0.5</XS>
							<XO>-175</XO>
							<YS>0.5</YS>
							<YO>-50</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>350</XO>
							<YS>0</YS>
							<YO>100</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextBox" referent="RBX598E6219A8434CEEB7D86C82378AC846">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4282795590</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClearTextOnFocus">true</bool>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<bool name="MultiLine">false</bool>
							<string name="Name">Input</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<bool name="ShowNativeInput">true</bool>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>320</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">&lt;input&gt;</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX02E4DA2A18B2422F98AA564047F6BA02">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Submit</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>60</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>150</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Okay</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBXA137FFAE2D5C4AA595AE02EEB16D5F53">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>185</XO>
								<YS>0</YS>
								<YO>60</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>150</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Cancel</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX5203B330595043FAB6E23AC7208F70CC">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX919934CDE54E402FB5A37674921CC96D">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Enter the response here:</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
				<Item class="Frame" referent="RBX175F8047751E48479EB405EF8ADA0DE4">
					<Properties>
						<bool name="Active">true</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">true</bool>
						<string name="Name">Priority</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0</XS>
							<XO>50</XO>
							<YS>0.5</YS>
							<YO>-125</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>200</XO>
							<YS>0</YS>
							<YO>170</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBXFF47452C7979477A8ABAE0F145F2BC62">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Core</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Core</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="StringValue" referent="RBX014B12EFE4924B599E0C2719AC1CCC30">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Lowest priority</string>
							</Properties>
						</Item>
					</Item>
					<Item class="TextLabel" referent="RBXEA652ECFC831462092FDEF598E802F46">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX74EA29FA16244FE08BFDCBDB3DDC7487">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>10</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Set Priority</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX5F3B4EBD48E64AF2A44A599EA2174CE3">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Template</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Save</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX055BC2E7398C45D488C55D75EBB93CCF">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Idle</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>70</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Idle</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="StringValue" referent="RBX43B7AE80B7CF44AC821F626E2601437A">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Plays on top of core animations</string>
							</Properties>
						</Item>
					</Item>
					<Item class="TextButton" referent="RBX8A7BEC384CDF4147BE3B7A949FCC9290">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Movement</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>100</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Movement</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="StringValue" referent="RBX2171F9675DE141A4A504E7736AC8A254">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Plays on top of idle animations</string>
							</Properties>
						</Item>
					</Item>
					<Item class="TextButton" referent="RBX5183BB79A7A04FA18EFDBE4CAA2A13FB">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Action</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>130</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Action</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="StringValue" referent="RBX6D597A3C0411426ABE6AACA9085BD76B">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Plays on top of movement animations</string>
							</Properties>
						</Item>
					</Item>
					<Item class="TextButton" referent="RBX2F0417CD1FC6426C80E9FBB832C6A029">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Help</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>165</XO>
								<YS>0</YS>
								<YO>10</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>20</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">?</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="StringValue" referent="RBX033C4E016F3A48D09C1F0FAE43D9B15F">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Lowest priority</string>
							</Properties>
						</Item>
					</Item>
				</Item>
				<Item class="Frame" referent="RBX592F05BDC9654EE184A6EE4BE4F9B3AD">
					<Properties>
						<bool name="Active">true</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">true</bool>
						<string name="Name">Looping</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0</XS>
							<XO>50</XO>
							<YS>0.5</YS>
							<YO>-125</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>200</XO>
							<YS>0</YS>
							<YO>100</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">5</int>
					</Properties>
					<Item class="TextButton" referent="RBXA9DEA16A9C344FBC865DC098B4D63E28">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Yes</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Yes</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">5</int>
						</Properties>
						<Item class="StringValue" referent="RBX0C8BFEDE13904DE69C716BD93D59895A">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Animation will restart once it has ended</string>
							</Properties>
						</Item>
					</Item>
					<Item class="TextLabel" referent="RBXA079EFDAD579423E818B67ACDE91EF90">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">5</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX8671759A48FE49DDA310EE80235D3C28">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>10</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Loop?</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">5</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX01F399D855F143E19807ED3FA7F39017">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Template</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>270</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Save</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">5</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX1AE65D1972854132A0EA0D8B2F252992">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">No</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>70</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">No</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">5</int>
						</Properties>
						<Item class="StringValue" referent="RBXFDDEA6901BD14B0DA010DE1E06AA6852">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Animation stops when it ends</string>
							</Properties>
						</Item>
					</Item>
					<Item class="TextButton" referent="RBXEBB2D68E049C4A61A18929727401DB90">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Help</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>165</XO>
								<YS>0</YS>
								<YO>10</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>20</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">?</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">5</int>
						</Properties>
						<Item class="StringValue" referent="RBX7320D14078D34428ADD8DC4BF93F25FE">
							<Properties>
								<string name="Name">Tooltip</string>
								<string name="Value">Lowest priority</string>
							</Properties>
						</Item>
					</Item>
				</Item>
				<Item class="Frame" referent="RBX3BA20396DAD848BEA3ED3576FE4906DD">
					<Properties>
						<bool name="Active">false</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">false</bool>
						<string name="Name">PlayFrame</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0</XS>
							<XO>50</XO>
							<YS>0.5</YS>
							<YO>-50</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>200</XO>
							<YS>0</YS>
							<YO>100</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBXF4B63BDB895C468DA87CC170BB5E4F36">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>60</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>170</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Return To Editor</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXC2065BB2C90646079E70A9E2F40EF2EB">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXC18BC8258A8A472EA61B0A7BC72E7F38">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Playing animation...</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
				<Item class="Frame" referent="RBXFAB0D53DB85F4F008BC94DE968907952">
					<Properties>
						<bool name="Active">false</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">false</bool>
						<string name="Name">OkCancelTemplate</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0.5</XS>
							<XO>-175</XO>
							<YS>0.5</YS>
							<YO>-50</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>350</XO>
							<YS>0</YS>
							<YO>100</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBXC5ACB253C48C47779589C601A4388CF9">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Submit</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>60</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>150</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Okay</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBXB14F07594C1E49379C80D3338750441F">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>185</XO>
								<YS>0</YS>
								<YO>60</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>150</XO>
								<YS>0</YS>
								<YO>25</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Cancel</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX884479CAB48C464783A6336A6045792B">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX4F09E0FD9F314B04A2FEFBF0EBCFFD47">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>-30</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Is this okay?</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
				<Item class="Frame" referent="RBX4795348FCD8A44BD8A7372A186830626">
					<Properties>
						<bool name="Active">true</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">true</bool>
						<string name="Name">StartScreen</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>1</XS>
							<XO>-450</XO>
							<YS>1</YS>
							<YO>-200</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>400</XO>
							<YS>0</YS>
							<YO>150</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBXEDD0BFA7E55F43088C6390A90E5C3FE6">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Select</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>10</XO>
								<YS>0</YS>
								<YO>110</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>120</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Select</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBXF7874C02FAC54084B1FA6C58F9F28B48">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>140</XO>
								<YS>0</YS>
								<YO>110</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>120</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Cancel</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXECD5FEA8CA2F46828B4FD7260CC3EF16">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX7B0AEF59A12843C09F5AF468D7842390">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Select A Rig To Animate</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">0</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBXC0E5946C47F74CA9B0A152CF88DCD6D4">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Help</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>270</XO>
								<YS>0</YS>
								<YO>110</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>120</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Help</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX35E30417929B42F7AA350742A90D2D72">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">RigName</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>-30</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">&lt;No Rig Selected&gt;</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXE689A26D65E345AA8CFB990283C3A74C">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Warning</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>70</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>-30</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Warning: Root Part Is Unanchored</string>
							<Color3 name="TextColor3">4294944010</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="Frame" referent="RBX6FF8DB6129AE46CB8526EF0C2A43FE21">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279242768</Color3>
							<float name="BackgroundTransparency">0.5</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">true</bool>
							<string name="Name">ScriptWarning</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.5</XS>
								<XO>-200</XO>
								<YS>0</YS>
								<YO>-120</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>400</XO>
								<YS>0</YS>
								<YO>100</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="TextLabel" referent="RBX41D74F4234F248F391DBBCC7400D31CA">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">3</token>
								<token name="FontSize">5</token>
								<string name="Name">Topbar</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>5</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text"></string>
								<Color3 name="TextColor3">4279970357</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX4384A1CE8E58428BBD5FC0D6D82A184C">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">Title</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>5</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">WARNING</string>
								<Color3 name="TextColor3">4294938688</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX94117B3F83E94977B70061A488244A3D">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">RigName</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-30</XO>
									<YS>0</YS>
									<YO>60</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">Animating in a place with scripts or moving parts may make unwanted changes to your place. Script(s) have been detected in this place.</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">true</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBXD39DBF4E44A941A8A21CE19481B03638">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">Warning</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>70</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-30</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">Warning: Root Part Is Unanchored</string>
								<Color3 name="TextColor3">4294944010</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">false</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
					</Item>
					<Item class="Frame" referent="RBX59B054C68F1C4CF0BF88181C44F44A63">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279242768</Color3>
							<float name="BackgroundTransparency">0.5</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">true</bool>
							<string name="Name">AnchorWarning</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.5</XS>
								<XO>-150</XO>
								<YS>0</YS>
								<YO>-200</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>300</XO>
								<YS>0</YS>
								<YO>150</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="TextLabel" referent="RBXD7CE2D30BE5A4629A65FE19661B384CD">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">3</token>
								<token name="FontSize">5</token>
								<string name="Name">Topbar</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>5</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text"></string>
								<Color3 name="TextColor3">4279970357</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX2731416BFD8D451D9D149FEEC4F5E67A">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">Title</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>5</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">WARNING</string>
								<Color3 name="TextColor3">4294938688</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">0</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX6E969DF8FAB5487E9D257C701AC74C89">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">RigName</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-30</XO>
									<YS>0</YS>
									<YO>60</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">Your root part is not anchored. This may lead to weird behavior. Want us to anchor it for you?</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">true</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX423DC8E0A2964B6195AF68C255A56641">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">Warning</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>15</XO>
									<YS>0</YS>
									<YO>70</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>-30</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">Warning: Root Part Is Unanchored</string>
								<Color3 name="TextColor3">4294944010</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">false</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBXC4116CCADD6B41318AEC8319253265AD">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4294944010</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">Yes</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>20</XO>
									<YS>0</YS>
									<YO>110</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>120</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Anchor</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX997774F16FFE4D379305C60D9D034860">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">true</bool>
								<Color3 name="BackgroundColor3">4286874756</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4281413937</Color3>
								<int name="BorderSizePixel">1</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<bool name="Modal">false</bool>
								<string name="Name">No</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>1</XS>
									<XO>-140</XO>
									<YS>0</YS>
									<YO>110</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0</XS>
									<XO>120</XO>
									<YS>0</YS>
									<YO>30</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">Leave it</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">0.75</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
					</Item>
				</Item>
			</Item>
			<Item class="ModuleScript" referent="RBX1159E94CCC2E44329EB2A73DECBDA07B">
				<Properties>
					<Content name="LinkedSource"><null></null></Content>
					<string name="Name">MenuHandler</string>
					<string name="ScriptGuid"></string>
					<ProtectedString name="Source"><![CDATA[local module = {}
local uis = script.Parent.GUIs

---------------------Toggles------------------------
module.toggles = {
	["Interpolation"] = true,
	["TweenCursor"] = true,
	["SelectInvisible"] = false,
	["ShowTooltips"] = true,
}
module.selectedImage = "http://www.roblox.com/asset/?id=620778172"
module.deselectedImage = "http://www.roblox.com/asset/?id=620791039"
module.toggleTrigger = false
module.clickTrigger = false
----------------------------------------------------
---------------------Tooltips-----------------------
module.tooltips = {
	
}

module.activeWindow = nil
module.mouse = nil
module.cleanup = {} -- Events to kill
module.killFunction = nil--If the process is cut short (i.e. the user quits in the middle of a select dialog)


module.space = nil
module.menuHover = false

module.CreateTip = function()
	module.tip = Instance.new("TextLabel")
	module.tip.Size = UDim2.new(0,100,0,30)
	module.tip.Parent = module.space
	module.tip.BackgroundTransparency = 1
	module.tip.TextXAlignment = Enum.TextXAlignment.Left
	module.tip.Text = ""
	module.tip.TextColor3 = Color3.new(1,1,1)
	module.tip.ZIndex = 9
	module.tip.FontSize = Enum.FontSize.Size12
	module.tip.TextStrokeTransparency = 0.6	
end

module.CreateTip()

module.Quit = function()
	for i = #module.cleanup, 1, -1 do
		module.cleanup[i]:disconnect()
	end
	if module.activeWindow then
		module.activeWindow:Destroy()
	end
	if module.killFunction then
		module.killFunction()
		module.killFunction = nil
	end
	module.tooltips = {}
	module.tip.Text = ""
	module.tip.Parent = nil
	module.activeWindow = nil
end

--Returns if the module has a window open. [Used to detect if the editor is closed while picking a root]
module.HasActiveWindow = function()
	return module.activeWindow ~= nil
end

module.SetEasingStyle = function(pose, exitFunction)
	if module.activeWindow == nil then
		local ui = uis.EasingStyle:clone()
		
		--Keep track of initial values in case cancel
		local initialEasingStyle = pose.EasingStyle.Name
		local selectedEasingStyle = pose.EasingStyle.Name
		local initialEasingDirection = pose.EasingDirection.Name
		local selectedEasingDirection = pose.EasingDirection.Name
		
		local function updateColors()
			--Style
			local str = tostring(selectedEasingStyle) == "nil" and "Linear" or selectedEasingStyle
			for i, v in pairs(ui.Styles:GetChildren()) do
				if v:IsA("TextButton") then
					if str == v.Name then
						v.BackgroundColor3 = ui.Styles.SelectedColor.Value
					else
						v.BackgroundColor3 = ui.Styles.DeselectedColor.Value
					end
				end
			end
			--Direction
			str = tostring(selectedEasingDirection) == "nil" and "In" or selectedEasingDirection
			for i, v in pairs(ui.Directions:GetChildren()) do
				if v:IsA("TextButton") then
					if str == v.Name then
						v.BackgroundColor3 = ui.Directions.SelectedColor.Value
					else
						v.BackgroundColor3 = ui.Directions.DeselectedColor.Value
					end
				end
			end	
		end
		
		for i, v in pairs(ui.Styles:GetChildren()) do
			if v:IsA("TextButton") then
				v.MouseButton1Click:connect(function()
					selectedEasingStyle = v.Name --Enum.PoseEasingStyle[v.Name]
					updateColors()
				end)
			end
		end
		
		for i, v in pairs(ui.Directions:GetChildren()) do
			if v:IsA("TextButton") then
				v.MouseButton1Click:connect(function()
					selectedEasingDirection = v.Name --Enum.PoseEasingDirection[v.Name]
					updateColors()
				end)
			end
		end
		
		ui.Submit.MouseButton1Click:connect(function()
			ui:Destroy()
			module.activeWindow = nil
			if pose then
				pose.EasingStyle = Enum.PoseEasingStyle[selectedEasingStyle]
				pose.EasingDirection = Enum.PoseEasingDirection[selectedEasingDirection]
			end
			if exitFunction then exitFunction() end
		end)
		
		ui.Cancel.MouseButton1Click:connect(function()
			ui:Destroy()
			module.activeWindow = nil
			if exitFunction then exitFunction() end
		end)
		
		updateColors()
		
		ui.Parent = module.space
		module.activeWindow = ui
	end
end

module.PromptInput = function(text, defaultText)
	if defaultText == nil then
		defaultText = "<input>"
	end
	if module.activeWindow == nil then
		local gui = script.Parent.GUIs.InputTemplate:clone()
		gui.Parent = module.space
		module.activeWindow = gui
		gui.Title.Text = text
		gui.Input.Text = defaultText
		local done = false
		gui.Submit.MouseButton1Click:connect(function()
			done = true
		end)
		gui.Cancel.MouseButton1Click:connect(function()
			gui.Input.Text = ""
			done = true
		end)
		repeat wait() until done
		local retVal = gui.Input.Text
		module.activeWindow = nil
		gui:Destroy()
		return retVal
	end
end

module.PromptOkCancel = function(text)
	if module.activeWindow == nil then
		local gui = script.Parent.GUIs.OkCancelTemplate:clone()
		gui.Parent = module.space
		module.activeWindow = gui
		gui.Title.Text = text
		local done = false
		local retVal = false
		gui.Submit.MouseButton1Click:connect(function()
			done = true
			retVal = true
		end)
		gui.Cancel.MouseButton1Click:connect(function()
			done = true
			retVal = false
		end)
		repeat wait() until done
		module.activeWindow = nil
		gui:Destroy()
		return retVal
	end
end

module.GetPriority = function(plugin, exitFunction)
	if module.activeWindow == nil then
		local gui = script.Parent.GUIs.Priority:clone()
		gui.Parent = module.space
		
		--What priority they click
		local function setupBtn(btn) 
			module.RegisterTooltip(btn, btn.Tooltip.Value)
			btn.MouseButton1Click:connect(function()
				module.activeWindow = nil
				gui:Destroy()
				exitFunction(btn.Name)
			end)
		end
		
		setupBtn(gui.Core)
		setupBtn(gui.Idle)
		setupBtn(gui.Movement)
		setupBtn(gui.Action)
		
		gui.Help.MouseButton1Click:connect(function()
			plugin:OpenWikiPage("Animations#Priority")
		end)
		
		module.activeWindow = gui
	end
end

module.GetLoop = function(plugin, exitFunction)
	if module.activeWindow == nil then
		local gui = script.Parent.GUIs.Looping:clone()
		gui.Parent = module.space
		
		gui.Help.MouseButton1Click:connect(function()
			plugin:OpenWikiPage("Animations#Looping")
		end)
		
		gui.Yes.MouseButton1Click:connect(function()
			module.activeWindow = nil
			gui:Destroy()
			exitFunction(true)
		end)
		
		gui.No.MouseButton1Click:connect(function()
			module.activeWindow = nil
			gui:Destroy()
			exitFunction(false)
		end)
		
		module.RegisterTooltip(gui.Yes, gui.Yes.Tooltip.Value)
		module.RegisterTooltip(gui.No, gui.No.Tooltip.Value)
		
		module.activeWindow = gui
	end
end

module.GetSaveName = function(rig, exitFunction)
	if module.activeWindow == nil then
		local gui = script.Parent.GUIs.Save:clone()
		
		if rig:findFirstChild("AnimSaves") ~= nil then
			local items = rig.AnimSaves:GetChildren()
			local sf = function(a, b) return a.Name < b.Name end
			table.sort(items, sf)
			local count = 0
			for i, v in pairs(items) do
				if v:IsA("KeyframeSequence") and v.Name ~= "Automatic Save" then
					local btn = gui.Template:clone()
					btn.Text = v.Name
					btn.Position = UDim2.new(0, 0, 0, 23 * (count))
					btn.Parent = gui.ScrollingFrame
					btn.Visible = true
					btn.MouseButton1Click:connect(function()
						gui.TextBox.Text = btn.Text
					end)
					count = count + 1
				end
			end
		end
		
		gui.Save.MouseButton1Click:connect(function()
			local txt = gui.TextBox.Text
			if txt == "<enter name>" then
				exitFunction(nil)
			else
				exitFunction(txt)
			end
			module.activeWindow = nil
			gui:Destroy()
		end)
		
		gui.Cancel.MouseButton1Click:connect(function()
			exitFunction(nil)
			module.activeWindow = nil
			gui:Destroy()
		end)		
		
		local numOverwrite = #gui.ScrollingFrame:GetChildren()
		gui.ScrollingFrame.CanvasSize = UDim2.new(0,0,0,23 * numOverwrite)
		
		gui.Parent = module.space
		module.activeWindow = gui
	end
end

module.GetLoadName = function(rig, exitFunction)
	if module.activeWindow == nil then
		local gui = script.Parent.GUIs.Load:clone()
		
		if rig:findFirstChild("AnimSaves") ~= nil then
			local items = rig.AnimSaves:GetChildren()
			local sf = function(a, b) return a.Name < b.Name end
			table.sort(items, sf)
			local count = 0
			for i, v in pairs(items) do
				if v:IsA("KeyframeSequence") then
					local btn = gui.Template:clone()
					btn.Text = v.Name
					btn.Position = UDim2.new(0, 0, 0, 23 * (count))
					btn.Parent = gui.ScrollingFrame
					btn.Visible = true
					btn.MouseButton1Click:connect(function()
						gui.LoadTitle.Text = btn.Text
					end)
					count = count + 1
				end
			end
		end
		
		gui.Load.MouseButton1Click:connect(function()
			local txt = gui.LoadTitle.Text
			if #txt == 0 then
				exitFunction(nil)
			else
				exitFunction(txt)
			end
			module.activeWindow = nil
			gui:Destroy()
		end)
		
		gui.Cancel.MouseButton1Click:connect(function()
			exitFunction(nil)
			module.activeWindow = nil
			gui:Destroy()
		end)		
		
		local numOverwrite = #gui.ScrollingFrame:GetChildren()
		gui.ScrollingFrame.CanvasSize = UDim2.new(0,0,0,23 * numOverwrite)
		
		gui.Parent = module.space
		module.activeWindow = gui
	end
end

module.SelectRig = function(mouse, plugin, exitFunc)
	if module.activeWindow == nil then
		local sg = Instance.new("ScreenGui", game:GetService("CoreGui"))
		module.mouse = mouse
		local gui = script.Parent.GUIs.StartScreen:clone()
		local selectionBox = Instance.new("SelectionBox", game.CoreGui)
		local hoverBox = Instance.new("SelectionBox", game.CoreGui)
		local running = true
		selectionBox.Color = BrickColor.new"Teal"
		selectionBox.LineThickness = 0.1
		hoverBox.LineThickness = 0.09
		local selected = nil
		
		local cleanupEvents = {}
		
		local function cleanup()
			for i, v in pairs(cleanupEvents) do
				v:disconnect()
			end
			selectionBox:Destroy()
			hoverBox:Destroy()
			gui:Destroy()
			module.activeWindow = nil
		end
		
		local function isPlaceSafe()
			local scripts = {}
			local search
			search = function(item)
				for i, v in pairs(item:GetChildren()) do
					if v:IsA("Script") and not v.Disabled then
						table.insert(scripts, v)
					else
						search(v)
					end
				end
			end
			search(workspace)
			search(game.ServerScriptService)
			if #scripts > 0 then
				return false
			end
			return true
		end
		
		local isValidParent = function(p)
			for i, v in pairs(p:GetChildren()) do
				if v:IsA("Humanoid") or v:IsA("AnimationController") then
					return true
				end
			end
			return false
		end
		
		local function getRoot(part)
			if part then
				local base = part:GetRootPart()
				if base and isValidParent(base.Parent) then
					return base
				end
			end			
			return nil
		end
		
		local GetAbsoluteRoot = function(what)
			if not what then return nil end
			local possibleRoot = what:GetRootPart()
			local found = nil
			local getRoot		
			
			getRoot = function(p)
				for i, v in pairs(p:GetChildren()) do
					if v:IsA("Motor6D") and v.Part1 == possibleRoot and isValidParent(v.Parent.Parent) then
						found = v.Part0
					elseif v:IsA("BasePart") or v:IsA("Model") then
						getRoot(v)
					end
				end
			end
				
			if possibleRoot and not isValidParent(possibleRoot.Parent) then
				possibleRoot = nil
			else
				getRoot(possibleRoot.Parent)
			end	
			
			if found then return found end
			return possibleRoot
			
		end
		
		spawn(function()
			while running do
				local target = mouse.target
				hoverBox.Adornee = GetAbsoluteRoot(target)
				wait(0.1)
			end
		end)
		
		local mouseDownEvent = mouse.Button1Down:connect(function()
			local target = GetAbsoluteRoot(mouse.Target)
			selected = target
			selectionBox.Adornee = target
			if selected then
				gui.Select.Visible = true
				gui.RigName.Text = selected.Parent.Name
			else
				gui.Select.Visible = false
				gui.RigName.Text = "<No Rig Selected>"
			end
		end)
		table.insert(cleanupEvents, mouseDownEvent)
		
		gui.Cancel.MouseButton1Click:connect(function()
			running = false
			cleanup()
			exitFunc(nil)
		end)
		
		gui.Select.MouseButton1Click:connect(function()
			running = false
			if selected and selected.Anchored == false then
				--Prompt to anchor it
				gui.Select.Visible = false
				gui.Cancel.Visible = false
				gui.Help.Visible = false
				gui.AnchorWarning.Visible = true
				gui.ScriptWarning.Visible = false
				local done = false
				local answer = false
				local aw = gui.AnchorWarning
				aw.Yes.MouseButton1Click:connect(function()
					answer = true
					done = true
				end)
				aw.No.MouseButton1Click:connect(function()
					answer = false
					done = true
				end)
				while not done do wait() end
				if answer == true then
					selected.Anchored = true
				end
			end
			module.killFunction = nil
			cleanup()
			exitFunc(selected)
		end)
		
		gui.Help.MouseButton1Click:connect(function()
			plugin:OpenWikiPage("Animations")
		end)
		
		if not isPlaceSafe() then
			gui.ScriptWarning.Visible = true
		end
		
		gui.Parent = sg
		module.activeWindow = gui
		module.killFunction = function() cleanup() end
	end
end

module.GetStopRequest = function(callback)
	local gui = script.Parent.GUIs.PlayFrame:clone()
	gui.Parent = module.space
	local function stop()
		gui:Destroy()
	end
	
	--Callback. This is if the user prompts the play to stop.
	gui.Cancel.MouseButton1Click:connect(function()
		stop()
		callback()
	end)
	
	--The returned method is if the editor informs us to stop. (The animation reached the end)
	return stop
end

module.RegisterTooltip = function(button, ttip)
	local tooltip = {btn = button, tip = ttip}
	table.insert(module.tooltips, tooltip)
end

module.InitializeTooltips = function()
	local tooltipEvent = game:GetService("UserInputService").InputChanged:connect(function(input)
			if input.UserInputType == Enum.UserInputType.MouseMovement and module.toggles["ShowTooltips"] == true then
				local potential = {}
				local x = input.Position.X
				local y = input.Position.Y
				for i = #module.tooltips, 0, -1 do
					local v = module.tooltips[i]
					if v and v.btn ~= nil and v.btn.Parent ~= nil then
						if v.btn.Visible and (v.btn.Parent:IsA("ScreenGui") == true or v.btn.Parent.Visible) then
							local minx = v.btn.AbsolutePosition.X
							local miny = v.btn.AbsolutePosition.Y
							local maxx = minx + v.btn.AbsoluteSize.X
							local maxy = miny + v.btn.AbsoluteSize.Y
							if x >= minx and x <= maxx and y >= miny and y <= maxy then
								table.insert(potential, v)
							end 
						end
					else
						table.remove(module.tooltips, i)
					end
				end
				module.tip.Position = UDim2.new(0, x, 0, y)
				if #potential == 1 then
					local str = potential[1].tip
					--local size = game:GetService("TextService"):GetTextSize(str, Enum.FontSize.Size12, Enum.Font.Legacy, Vector2.new(0,0))
					module.tip.Text = str
					module.tip.BackgroundTransparency = 0
					local desiredXSize = module.tip.TextBounds.X + 5
					local desiredXPos = x + 15
					if desiredXPos + desiredXSize > game.Workspace.CurrentCamera.ViewportSize.X then
						desiredXPos = desiredXPos - (desiredXPos + desiredXSize - game.Workspace.CurrentCamera.ViewportSize.X)
					end
					module.tip.Size = UDim2.new(0, desiredXSize, 0, module.tip.TextBounds.Y + 5)
					module.tip.Position = UDim2.new(0, desiredXPos, 0, y + 15)
					--module.tip.Size = UDim2.new(0, size.X, 0, 30)
				else
					module.tip.Text = ""
					module.tip.BackgroundTransparency = 1
				end
			else
				module.tip.Text = ""
				module.tip.BackgroundTransparency = 1
			end
		end)
		table.insert(module.cleanup, tooltipEvent)
end

module.InitializeSettings = function(defaults)
	for i, v in pairs(defaults) do
		module.toggles[i] = v
	end
end

module.InitializeTopbar = function(timeline, canOpenFunc, openFunc, closeFunc, fireFunc, valueRequest)
	--Space
	module.space = Instance.new("Frame")
	module.space.BackgroundTransparency = 1
	module.space.Name = "AnimationEditorMenuModule"	
	module.space.Size = UDim2.new(1,0,1,0)
	module.space.Parent = timeline.Parent
	--
	local tb = script.Parent.GUIs.Topbar:clone()
	tb.Parent = timeline
	if module.tip.Parent ~= nil then
		module.tip.Parent = timeline
	else
		module.CreateTip()
	end
	
	--Artist Commands
	local fbxFlagExists, fbxFlagValue = pcall(function () return settings():GetFFlag("DebugStudioRigImporter") end)
	--Fallback code for flag name change
	if not fbxFlagExists then
		fbxFlagExists, fbxFlagValue = pcall(function () return settings():GetFFlag("StudioFbxRigImporting") end)
	end
	------------------------------------
	if fbxFlagExists and fbxFlagValue == true then
		tb.FileFrame.Size = tb.FileFrame.Size + UDim2.new(0,0,0,30)
	else
		tb.FileFrame.FBXImport:Destroy()
	end
	--
	
	local function updateSettingToggles()
		for i, v in pairs(module.toggles) do
			tb.SettingsFrame[i].ImageLabel.Image = v == true and module.selectedImage or module.deselectedImage
		end
	end
	
	local function updateValues()
		for i, v in pairs(tb.FileFrame:GetChildren()) do
			if v:findFirstChild("CurrentValue") then
				v.CurrentValue.Text = "["..tostring(valueRequest(v.Name)).."]"
			end
		end
		for i, v in pairs(tb.EditFrame:GetChildren()) do
			if v:findFirstChild("CurrentValue") then
				v.CurrentValue.Text = "["..tostring(valueRequest(v.Name)).."]"
			end
		end
		for i, v in pairs(tb.SettingsFrame:GetChildren()) do
			if v:findFirstChild("CurrentValue") then
				v.CurrentValue.Text = "["..tostring(valueRequest(v.Name)).."]"
			end
		end
	end
	
	local function hoverOver()
		tb.File.MouseEnter:connect(function()
			if module.menuHover then
				module.activeWindow = tb.FileFrame
				tb.FileFrame.Visible = true
				tb.EditFrame.Visible = false
				tb.SettingsFrame.Visible = false
			end
		end)
		
		tb.Edit.MouseEnter:connect(function()
			if module.menuHover then
				module.activeWindow = tb.EditFrame
				tb.FileFrame.Visible = false
				tb.EditFrame.Visible = true
				tb.SettingsFrame.Visible = false
			end
		end)
		
		tb.Settings.MouseEnter:connect(function()
			if module.menuHover then
				module.activeWindow = tb.SettingsFrame
				tb.FileFrame.Visible = false
				tb.EditFrame.Visible = false
				tb.SettingsFrame.Visible = true
			end
		end)
	end
	
	local function isToggle(btn)
		for i, v in pairs(module.toggles) do
			if btn.Name == i then
				return true
			end
		end
		return false
	end
	
	local function fireCommands()
		for i, v in pairs(tb.FileFrame:GetChildren()) do
			local doClick = function()
				module.activeWindow = nil
				spawn(function() module.clickTrigger = true fireFunc(v.Name) end)	
			end
			v.MouseButton1Down:connect(function()
				doClick()
			end)
			if v:findFirstChild("ImageLabel") then
				v.ImageLabel.InputBegan:connect(function(uio, proc)
					if not proc and uio.UserInputType == Enum.UserInputType.MouseButton1 then
						doClick()
					end
				end)
			end
			--Register tooltip
			if v:findFirstChild("Tooltip") then
				module.RegisterTooltip(v, v.Tooltip.Value)
			end
		end
		for i, v in pairs(tb.EditFrame:GetChildren()) do
			local doClick = function()
				module.activeWindow = nil
				spawn(function() module.clickTrigger = true fireFunc(v.Name) end)	
			end

			v.MouseButton1Down:connect(function()
				doClick()
			end)
			if v:findFirstChild("ImageLabel") then
				v.ImageLabel.InputBegan:connect(function(uio, proc)
					if not proc and uio.UserInputType == Enum.UserInputType.MouseButton1 then
						doClick()
					end
				end)
			end
			--Register tooltip
			if v:findFirstChild("Tooltip") then
				module.RegisterTooltip(v, v.Tooltip.Value)
			end
		end
		for i, v in pairs(tb.SettingsFrame:GetChildren()) do
			local doClick = function()
				if isToggle(v) then
					module.toggles[v.Name] = not module.toggles[v.Name]
					module.toggleTrigger = true
					updateSettingToggles()
					spawn(function() fireFunc(v.Name, module.toggles[v.Name]) end)
				else
					module.activeWindow = nil
					spawn(function() module.clickTrigger = true fireFunc(v.Name) end)
				end				
			end
			v.MouseButton1Down:connect(function()
				doClick()
			end)
			if v:findFirstChild("ImageLabel") then
				v.ImageLabel.InputBegan:connect(function(uio, proc)
					if not proc and uio.UserInputType == Enum.UserInputType.MouseButton1 then
						doClick()
					end
				end)
			end	
			--Register tooltip
			if v:findFirstChild("Tooltip") then
				module.RegisterTooltip(v, v.Tooltip.Value)
			end
		end
	end
	
	local function quit()
		if tb:findFirstChild("FileFrame") then tb.FileFrame.Visible = false end
		if tb:findFirstChild("EditFrame") then tb.EditFrame.Visible = false end
		if tb:findFirstChild("SettingsFrame") then tb.SettingsFrame.Visible = false end
		module.activeWindow = nil
	end
	
	tb.File.MouseButton1Click:connect(function()
		updateValues()
		if module.activeWindow == nil and canOpenFunc() then
			module.activeWindow = tb.FileFrame
			module.menuHover = true
			tb.FileFrame.Visible = true
		end
	end)
	
	tb.Edit.MouseButton1Click:connect(function()
		updateValues()
		if module.activeWindow == nil and canOpenFunc() then
			module.activeWindow = tb.EditFrame
			module.menuHover = true
			tb.EditFrame.Visible = true
		end		
	end)
	
	tb.Settings.MouseButton1Click:connect(function()
		updateValues()
		if module.activeWindow == nil and canOpenFunc() then
			module.activeWindow = tb.SettingsFrame
			module.menuHover = true
			tb.SettingsFrame.Visible = true
		end
	end)
	
	game:GetService("UserInputService").InputBegan:connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			wait()
			if not module.toggleTrigger then
				if module.menuHover then
					module.menuHover = false
					wait()
					quit()
					if not module.clickTrigger then
						closeFunc()
					else
						module.clickTrigger = false
					end
				end
			else
				module.toggleTrigger = false
			end
		end
	end)
	
	hoverOver()
	fireCommands()
	updateSettingToggles()
end

return module
]]></ProtectedString>
				</Properties>
			</Item>
			<Item class="Folder" referent="RBXC988BFAB56A34F84858721D54DF0D69C">
				<Properties>
					<string name="Name">Customize</string>
				</Properties>
				<Item class="BrickColorValue" referent="RBX0F69798BE68444CC8A678588A2B2A382">
					<Properties>
						<string name="Name">MouseoverColor</string>
						<int name="Value">1015</int>
					</Properties>
				</Item>
				<Item class="BrickColorValue" referent="RBX7BC6F1A0AD764C388850DAA7698EA001">
					<Properties>
						<string name="Name">SelectedColor</string>
						<int name="Value">1017</int>
					</Properties>
				</Item>
				<Item class="BrickColorValue" referent="RBXF92260F371BC486188F11AF974441BFD">
					<Properties>
						<string name="Name">GridColor</string>
						<int name="Value">1001</int>
					</Properties>
				</Item>
			</Item>
		</Item>
		<Item class="ModuleScript" referent="RBXC497BE5DF2BC48EFA3AB392514A2CD17">
			<Properties>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">RigCreator</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[local rigCreator = {}

local function weldBetween(a, b)
    local weld = Instance.new("Motor6D")
    weld.Part0 = a
    weld.Part1 = b
    weld.C0 = CFrame.new()
    weld.C1 = b.CFrame:inverse()*a.CFrame
    weld.Parent = a
    return weld;
end

local function jointBetween(a, b, cfa, cfb)
    local weld = Instance.new("Motor6D")
    weld.Part0 = a
    weld.Part1 = b
    weld.C0 = cfa
    weld.C1 = cfb
    weld.Parent = a
    return weld;
end

function rigCreator.CreateR6Rig()
	local parent = Instance.new("Model", game.Workspace)
    parent.Name = "Dummy"
    
	local Root = Instance.new("Part")
	Root.Name = "HumanoidRootPart"	
	Root.Anchored = true
	Root.CanCollide = true
	Root.Transparency = 0.5
	Root.Size = Vector3.new(2, 2, 1)
	Root.Parent = parent	
	Root.CFrame = CFrame.new(0, 5.2, 4.5)
	Root.BottomSurface = "Smooth"
	Root.TopSurface = "Smooth"
	parent.PrimaryPart = Root

	local Torso = Instance.new("Part")
	Torso.Name = "Torso"
	Torso.Anchored = false
	Torso.CanCollide = false
	Torso.Size = Vector3.new(2, 2, 1)
	Torso.Parent = parent
	Torso.CFrame = CFrame.new(0, 5.2, 4.5)
	Torso.BottomSurface = "Smooth"
	Torso.TopSurface = "Smooth"

	local RCA = CFrame.new(0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 1, 0 )
	local RCB = RCA
	local RootHip = jointBetween(Root, Torso, RCA, RCB)
	RootHip.Name = "Root Hip"
	RootHip.MaxVelocity = 0.1


	local LeftLeg = Instance.new("Part", parent)
	LeftLeg.Name = "Left Leg"
	LeftLeg.Anchored = false
	LeftLeg.CanCollide = false
	LeftLeg.Size = Vector3.new(1, 2, 1)
	LeftLeg.CFrame = CFrame.new(0.5, 3.2, 4.5)
	LeftLeg.BottomSurface = "Smooth"
	LeftLeg.TopSurface = "Smooth"

	local LHCA = CFrame.new(-1, -1, 0) * CFrame.fromAxisAngle(Vector3.new(0, 1, 0), -math.pi/2)
	local LHCB = CFrame.new(-0.5, 1, 0) * CFrame.fromAxisAngle(Vector3.new(0, 1, 0), -math.pi/2)
	local LeftHip = jointBetween(Torso, LeftLeg, LHCA, LHCB)
	LeftHip.Name = "Left Hip"
	LeftHip.MaxVelocity = 0.1


	local RightLeg = Instance.new("Part", parent)
	RightLeg.Name = "Right Leg"
	RightLeg.Anchored = false
	RightLeg.CanCollide = false
	RightLeg.Size = Vector3.new(1, 2, 1)
	RightLeg.CFrame = CFrame.new(-0.5, 3.2, 4.5)
	RightLeg.BottomSurface = "Smooth"
	RightLeg.TopSurface = "Smooth"


	local RHCA = CFrame.new(1, -1, 0) * CFrame.fromAxisAngle(Vector3.new(0, -1, 0), -math.pi/2)
	local RHCB = CFrame.new(0.5, 1, 0) * CFrame.fromAxisAngle(Vector3.new(0, 1, 0), math.pi/2)
	local RightHip = jointBetween(Torso, RightLeg, RHCA, RHCB)
	RightHip.Name = "Right Hip"
	RightHip.MaxVelocity = 0.1


	local LeftArm = Instance.new("Part", parent)
	LeftArm.Name = "Left Arm"
	LeftArm.Anchored = false
	LeftArm.CanCollide = false
	LeftArm.Size = Vector3.new(1, 2, 1)
	LeftArm.CFrame = CFrame.new(1.5, 5.2, 4.5)
	LeftArm.BottomSurface = "Smooth"
	LeftArm.TopSurface = "Smooth"


	local LSCA = CFrame.new(-1.0, 0.5, 0) * CFrame.fromAxisAngle(Vector3.new(0, 1, 0), -math.pi/2)
	local LSCB = CFrame.new(0.5, 0.5, 0) * CFrame.fromAxisAngle(Vector3.new(0, 1, 0), -math.pi/2)
	local LeftShoulder = jointBetween(Torso, LeftArm, LSCA, LSCB)
	LeftShoulder.Name = "Left Shoulder"
	LeftShoulder.MaxVelocity = 0.1


	local RightArm = Instance.new("Part", parent)
	RightArm.Name = "Right Arm"
	RightArm.Anchored = false
	RightArm.CanCollide = false
	RightArm.Size = Vector3.new(1, 2, 1)
	RightArm.CFrame = CFrame.new(-1.5, 5.2, 4.5)
	RightArm.BottomSurface = "Smooth"
	RightArm.TopSurface = "Smooth"

	local RSCA = CFrame.new(1.0, 0.5, 0) * CFrame.fromAxisAngle(Vector3.new(0, -1, 0), -math.pi/2)
	local RSCB = CFrame.new(-0.5, 0.5, 0) * CFrame.fromAxisAngle(Vector3.new(0, 1, 0), math.pi/2)
	local RightShoulder = jointBetween(Torso, RightArm, RSCA, RSCB)
	RightShoulder.Name = "Right Shoulder"
	RightShoulder.MaxVelocity = 0.1


	local Head = Instance.new("Part", parent)
	Head.Name = "Head"
	Head.Anchored = false
	Head.CanCollide = true
	Head.Size = Vector3.new(2, 1, 1)
	Head.CFrame = CFrame.new(0, 6.7, 4.5)
	Head.BottomSurface = "Smooth"
	Head.TopSurface = "Smooth"

	local NCA = CFrame.new(0, 1, 0, -1, 0, 0, 0, 0, 1, 0, 1, 0)
	local NCB = CFrame.new(0, -0.5, 0, -1, 0, 0, 0, 0, 1, 0, 1, 0)
	local Neck = jointBetween(Torso, Head, NCA, NCB)
	Neck.Name = "Neck"
	Neck.MaxVelocity = 0.1
	
	local Face = Instance.new("Decal", Head)
	Face.Name = "Face"
	Face.Texture = "rbxasset://textures/face.png"
	
	Instance.new("Humanoid", parent)	
	
	return parent
end

function rigCreator.CreateR6MeshRig()
	local rig = rigCreator.CreateR6Rig()

	local LArmMesh = Instance.new("CharacterMesh", rig)
	LArmMesh.MeshId = 27111419
	LArmMesh.BodyPart = 2

	local RArmMesh = Instance.new("CharacterMesh", rig)
	RArmMesh.MeshId = 27111864
	RArmMesh.BodyPart = 3


	local LLegMesh = Instance.new("CharacterMesh", rig)
	LLegMesh.MeshId = 27111857
	LLegMesh.BodyPart = 4

	local RLegMesh = Instance.new("CharacterMesh", rig)
	RLegMesh.MeshId = 27111882
	RLegMesh.BodyPart = 5

	local TorsoMesh = Instance.new("CharacterMesh", rig)
	TorsoMesh.MeshId = 27111894
	TorsoMesh.BodyPart = 1


	local HeadMesh = Instance.new("SpecialMesh", rig.Head)
	HeadMesh.MeshType = 0
	HeadMesh.Scale = Vector3.new(1.25, 1.25, 1.25)
	return rig
end

function rigCreator.CreateR6MeshBoyRig()
	local rig = rigCreator.CreateR6Rig()

	local LArmMesh = Instance.new("CharacterMesh", rig)
	LArmMesh.MeshId = 82907977
	LArmMesh.BodyPart = 2

	local RArmMesh = Instance.new("CharacterMesh", rig)
	RArmMesh.MeshId = 82908019
	RArmMesh.BodyPart = 3


	local LLegMesh = Instance.new("CharacterMesh", rig)
	LLegMesh.MeshId = 81487640
	LLegMesh.BodyPart = 4

	local RLegMesh = Instance.new("CharacterMesh", rig)
	RLegMesh.MeshId = 81487710
	RLegMesh.BodyPart = 5

	local TorsoMesh = Instance.new("CharacterMesh", rig)
	TorsoMesh.MeshId = 82907945
	TorsoMesh.BodyPart = 1


	local HeadMesh = Instance.new("SpecialMesh", rig.Head)
	HeadMesh.MeshType = 0
	HeadMesh.Scale = Vector3.new(1.25, 1.25, 1.25)
	return rig
end

function rigCreator.CreateR6MeshGirlRig()
	local rig = rigCreator.CreateR6Rig()

	local LArmMesh = Instance.new("CharacterMesh", rig)
	LArmMesh.MeshId = 83001137
	LArmMesh.BodyPart = 2

	local RArmMesh = Instance.new("CharacterMesh", rig)
	RArmMesh.MeshId = 83001181
	RArmMesh.BodyPart = 3


	local LLegMesh = Instance.new("CharacterMesh", rig)
	LLegMesh.MeshId = 81628361
	LLegMesh.BodyPart = 4

	local RLegMesh = Instance.new("CharacterMesh", rig)
	RLegMesh.MeshId = 81628308
	RLegMesh.BodyPart = 5

	local TorsoMesh = Instance.new("CharacterMesh", rig)
	TorsoMesh.MeshId = 82987757
	TorsoMesh.BodyPart = 1

	local HeadMesh = Instance.new("SpecialMesh", rig.Head)
	HeadMesh.MeshType = 0
	HeadMesh.Scale = Vector3.new(1.25, 1.25, 1.25)
	return rig
end

function rigCreator.BuildR15Rig(package)
	--Model, HRP & Head
	local m = Instance.new("Model", workspace)
	local headMesh = nil
	local face = nil
	if package ~= nil then
		local pkIds = game:GetService("AssetService"):GetAssetIdsForPackage(package)
		--Load the assets and parse
		for i, v in pairs(pkIds) do
			local a = game:GetService("InsertService"):LoadAsset(v)
			if a:findFirstChild("R15") then
				for z, x in pairs(a.R15:GetChildren()) do
					x.Parent = m
				end
			elseif a:findFirstChild("face") then
				face = a.face
			elseif a:findFirstChild("Face") then
				face = a.Face
			elseif a:findFirstChild("Mesh") then
				headMesh = a.Mesh
			end
		end
	end
	local rig = r15RigImported(m)
	if headMesh then
		rig.Head.Mesh:Destroy()
		headMesh.Parent = rig.Head
	end
	if face then
		for i, v in pairs(rig.Head:GetChildren()) do
			if v.Name == "face" or v.Name == "Face" then
				v:Destroy()
			end
		end
		face.Parent = rig.Head
	end
	return rig
end

local function buildJoint(parentAttachment, partForJointAttachment)
    local newMotor = Instance.new("Motor6D")
	newMotor.Name = parentAttachment.Name:gsub("RigAttachment", "")
	
    newMotor.Part0 = parentAttachment.Parent
    newMotor.Part1 = partForJointAttachment.Parent
    
	newMotor.C0 = parentAttachment.CFrame
    newMotor.C1 = partForJointAttachment.CFrame
	
	---------------------
	local oldMotor = partForJointAttachment.Parent:FindFirstChild(newMotor.Name)
	while oldMotor do
		oldMotor:Destroy()
		oldMotor = partForJointAttachment.Parent:FindFirstChild(newMotor.Name)
	end
	
    newMotor.Parent = partForJointAttachment.Parent
end

-- Removes old Motor6Ds and builds the rig from the attachments in the parts
-- Call this with nil, HumanoidRootPart
function buildRigFromAttachments(last, part)
	for _, attachment in pairs(part:GetChildren()) do
		if attachment:IsA("Attachment") and string.find(attachment.Name, "RigAttachment") then
			for _, sibling in pairs(part.Parent:GetChildren()) do
				if sibling ~= part and sibling ~= last then
					local matchingAttachment = sibling:FindFirstChild(attachment.Name)
					if matchingAttachment then
						buildJoint(attachment, matchingAttachment)
						-- Continue the recursive tree traversal building joints
						buildRigFromAttachments(part, matchingAttachment.Parent)
					end
				end
			end
		end
	end
end


function r15RigImported(R15Rig)
	-- This wait is necessary because the imported rig is added to workspace 
	-- before all the parts are loaded
	wait(.5)
	
	-- Not all packages have all their parts, we load MrGreyR15 first then substitute the parts we did load
	local R15Dummy = game:GetService("InsertService"):LoadAsset(516159357):GetChildren()[1]
	
	for _, part in pairs(R15Rig:GetChildren()) do
		local matchingPart = R15Dummy:FindFirstChild(part.Name)
		if matchingPart then
			matchingPart:Destroy()
		end
		part.Parent = R15Dummy
	end
	R15Rig:Destroy()
	
	R15Rig = R15Dummy
	R15Rig.Parent = game.Workspace
	buildRigFromAttachments(nil, R15Rig.HumanoidRootPart)
	
	local r15Head = R15Rig:WaitForChild("Head", 1) -- 1 second timeout
	
	local Face = Instance.new("Decal", r15Head)
	Face.Name = "face"
	Face.Texture = "rbxasset://textures/face.png"
	return R15Rig
end

return rigCreator
]]></ProtectedString>
			</Properties>
		</Item>
		<Item class="Script" referent="RBX4B834EC21D6744D884B0D24DADE12901">
			<Properties>
				<bool name="Disabled">false</bool>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">RigBuilder</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[--Startup
local toolbar = plugin:CreateToolbar("Animations")
local button = toolbar:CreateButton(
	"Rig Builder", -- The text next to the icon. Leave this blank if the icon is sufficient.
	"Insert rigs to animate", -- hover text
	"http://www.roblox.com/asset/?id=620849303" -- The icon file's name
)

--Environment
local env = script ~= nil and script or game.Workspace.Plugin["RigBuilder"] --For easy rapid testing
local rigModule = script ~= nil and require(script.Parent.RigCreator) or require(game.Workspace.Plugin.RigCreator:clone())

--Constants
local RIG_COLOR = BrickColor.new"Medium stone grey"

--Variables
local gui = nil
local open = false
local mode = "R15"
local options = {"Block Rig", "Mesh Rig", "Man Rig", "Woman Rig"}

--Functions
function insertRig(name)
	closeGui()
	local rig
	if mode == "R6" then
		if name == "Block Rig" then
			rig = rigModule.CreateR6Rig()
		elseif name == "Mesh Rig" then
			rig = rigModule.CreateR6MeshRig()
		elseif name == "Man Rig" then
			rig = rigModule.CreateR6MeshBoyRig()
		elseif name == "Woman Rig" then
			rig = rigModule.CreateR6MeshGirlRig()
		end
	elseif mode == "R15" then
		if name == "Block Rig" then
			rig = rigModule.BuildR15Rig()
		elseif name == "Man Rig" then
			rig = rigModule.BuildR15Rig(86500185)
		elseif name == "Woman Rig" then
			rig = rigModule.BuildR15Rig(86499905)
		elseif name == "Mesh Rig" then
			rig = rigModule.BuildR15Rig(27112438)
		end
	end
	--Some housekeeping
	rig.Name = "Dummy"
	rig.HumanoidRootPart.Anchored = true
	rig.HumanoidRootPart.Transparency = 0.5
	--Color it
	for i, v in pairs(rig:GetChildren()) do
		if v:IsA("BasePart") then
			v.BrickColor = RIG_COLOR
		end
	end
	--Here we go!
	rig:MoveTo(getCameraLookat(10))
	game.Selection:Set({rig})
end

function openGui()
	gui = env.RigBuilder:clone()
	--Build options
	for i, v in pairs(options) do
		local btn = gui.Frame.ListTemplate:clone()
		btn.Visible = true
		btn.Text = v
		btn.Position = UDim2.new(0,0,0, (btn.Size.Y.Offset + 5) * (i-1))
		btn.Parent = gui.Frame.Options
		btn.MouseButton1Click:connect(function() insertRig(v) end)
	end
	--Slider
	local sl = gui.Frame.Slider
	sl.R15.MouseButton1Click:connect(function()
		sl.R15.BackgroundTransparency = 0
		sl.R6.BackgroundTransparency = 1
		sl.Slider:TweenPosition(UDim2.new(0,0,1,-3), "Out", "Quad", 0.15)
		mode = "R15"
	end)
	sl.R6.MouseButton1Click:connect(function()
		sl.R15.BackgroundTransparency = 1
		sl.R6.BackgroundTransparency = 0
		sl.Slider:TweenPosition(UDim2.new(0.5,0,1,-3), "Out", "Quad", 0.15)
		mode = "R6"
	end)
	gui.Frame.Close.MouseButton1Click:connect(closeGui)
	gui.Frame.Options.CanvasSize = UDim2.new(0,0,0, (gui.Frame.ListTemplate.Size.Y.Offset + 5) * (#options-1))
	gui.Parent = game.CoreGui
	open = true
	plugin:Activate(true)
	button:SetActive(true)
end

function closeGui()
	gui:Destroy()
	open = false
	plugin:Activate(false)
	button:SetActive(false)
end

function getCameraLookat(maxRange)
	if maxRange == nil then maxRange = 10 end
	local cam = game.Workspace:findFirstChild("Camera")
	if cam then
		local ray = Ray.new(cam.CFrame.p, cam.CFrame.lookVector * maxRange)
		local hit, pos = game.Workspace:FindPartOnRay(ray)
		cam.Focus = CFrame.new(pos)
		return pos
	else
		--Default position if they did weird stuff
		print("Unable to find default camera.")
		return Vector3.new(0,5.2,0)
	end
end

--Code
button.Click:connect(function()
	mode = "R15"
	if not open then
		openGui()
	else
		closeGui()
	end
end)
]]></ProtectedString>
			</Properties>
			<Item class="ScreenGui" referent="RBXE8686DFB87A742EE884806915175BAE5">
				<Properties>
					<int name="DisplayOrder">0</int>
					<bool name="Enabled">true</bool>
					<string name="Name">RigBuilder</string>
					<bool name="ResetOnSpawn">true</bool>
				</Properties>
				<Item class="Frame" referent="RBXB6E44D47224E427E8DF5CF20325443F2">
					<Properties>
						<bool name="Active">false</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">false</bool>
						<string name="Name">Frame</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0.5</XS>
							<XO>-100</XO>
							<YS>0.5</YS>
							<YO>-150</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>200</XO>
							<YS>0</YS>
							<YO>200</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextLabel" referent="RBXB494CD7D286846A3A2C24CB1F116D865">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="Frame" referent="RBXF0F461E4D16A44E38DCA923FE62C7212">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4278211967</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<string name="Name">Slider</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.100000001</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0.800000012</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="TextButton" referent="RBX8FDCFE4E76424FBE93F1F4E6CE3F0029">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">false</bool>
								<Color3 name="BackgroundColor3">4283804415</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">2</token>
								<token name="FontSize">7</token>
								<bool name="Modal">false</bool>
								<string name="Name">R15</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0.5</XS>
									<XO>0</XO>
									<YS>1</YS>
									<YO>0</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">R15</string>
								<Color3 name="TextColor3">4294046193</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">24</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextButton" referent="RBX24128785484D48FA9AEF8A85E439BC5E">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<bool name="AutoButtonColor">false</bool>
								<Color3 name="BackgroundColor3">4283804415</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">2</token>
								<token name="FontSize">7</token>
								<bool name="Modal">false</bool>
								<string name="Name">R6</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0.5</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">true</bool>
								<bool name="Selected">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0.5</XS>
									<XO>0</XO>
									<YS>1</YS>
									<YO>0</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<string name="Text">R6</string>
								<Color3 name="TextColor3">4294046193</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">24</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX91BD4071921942748C8B0EE51D07665F">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4283826175</Color3>
								<float name="BackgroundTransparency">0</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">3</token>
								<token name="FontSize">5</token>
								<string name="Name">Slider</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>1</YS>
									<YO>-3</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>0.5</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>3</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text"></string>
								<Color3 name="TextColor3">4279970357</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
					</Item>
					<Item class="TextButton" referent="RBX0C1437128EDE4E3B90DD1328149190DA">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">0</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Close</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>1</XS>
								<XO>-20</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>20</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">X</string>
							<Color3 name="TextColor3">4294046193</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="ScrollingFrame" referent="RBXA1F286AEFC164A13A215EEB93896CBBF">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279242768</Color3>
							<float name="BackgroundTransparency">0.5</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<Content name="BottomImage"><url>rbxasset://textures/ui/Scroll/scroll-middle.png</url></Content>
							<Vector2 name="CanvasPosition">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<UDim2 name="CanvasSize">
								<XS>0</XS>
								<XO>0</XO>
								<YS>2</YS>
								<YO>0</YO>
							</UDim2>
							<bool name="ClipsDescendants">true</bool>
							<bool name="Draggable">false</bool>
							<Content name="MidImage"><url>rbxasset://textures/ui/Scroll/scroll-middle.png</url></Content>
							<string name="Name">Options</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.100000001</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>80</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<int name="ScrollBarThickness">6</int>
							<bool name="ScrollingEnabled">true</bool>
							<bool name="Selectable">true</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0.800000012</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>100</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<Content name="TopImage"><url>rbxasset://textures/ui/Scroll/scroll-middle.png</url></Content>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX5D29A6A7C2D44CA0B993CCEAAAD7C6E4">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4283804415</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">ListTemplate</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Button</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.870000005</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXC8337E4C85A447A6B6022F1DE158601E">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4294967295</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">5</token>
							<token name="FontSize">7</token>
							<string name="Name">TextLabel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0.5</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Rig Builder</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">24</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
			</Item>
		</Item>
		<Item class="Script" referent="RBX59470A2F5F8042EFA1D71A6BD2FA7F71">
			<Properties>
				<bool name="Disabled">false</bool>
				<Content name="LinkedSource"><null></null></Content>
				<string name="Name">createFbxImportRig</string>
				<string name="ScriptGuid"></string>
				<ProtectedString name="Source"><![CDATA[local rigCreator = require(script.Parent.RigCreator)

local toolbar = plugin:CreateToolbar("Animations")
local fbxFlagExists, fbxFlagValue = pcall(function() return settings():GetFFlag("StudioFbxRigImporting") end)
local packageIdsFromAssetIdsFlagExists, packageIdsFromAssetIdsFlagValue = pcall(function() return settings():GetFFlag("GetAssetIdsFromPackageAPI") end)
local canUseSimpleR6import = (packageIdsFromAssetIdsFlagExists == true and packageIdsFromAssetIdsFlagValue == true)
local saveSelectionFlagExists, saveSelectionFlagValue = pcall(function() return settings():GetFFlag("PluginSaveSelection") end)
local saveSelectionExport = (saveSelectionFlagExists and saveSelectionFlagValue == true)

local R15PartMapping = {
	["Head"] = {"Head"},
	["Left Leg"] = {"LeftFoot", "LeftLowerLeg", "LeftUpperLeg"},
	["Right Leg"] = {"RightFoot", "RightLowerLeg", "RightUpperLeg"},
	["Torso"] = {"UpperTorso", "LowerTorso"},
	["Right Arm"] = {"RightUpperArm", "RightLowerArm", "RightHand"},
	["Left Arm"] = {"LeftUpperArm", "LeftLowerArm", "LeftHand"}
}

-- If the old CharacterMeshs are imported by ID then this will contain a map in the format:
-- BodyPart.Name => AssetId
local assetIdMap = {}

function setupTextClearOnFocus(textbox)
	-- We do want to clear the text on focus if it is the template text
	textbox.Focused:connect(function() 
		if string.find(textbox.Text, "<") ~= nil then
			textbox.Text = ""
		end
	end)
end

function textboxListSetup(frame, template, nameList)
	table.sort(nameList)
	for i = 1, #nameList do
		local newTextbox = template:Clone()
		newTextbox.Name = nameList[i]
		newTextbox.Parent = frame
		newTextbox.Position = template.Position + UDim2.new(0, 0, 0, (i-1)*newTextbox.Size.Y.Offset)
		newTextbox.Description.Text = nameList[i]
		for _, obj in pairs(newTextbox:GetChildren()) do
			if obj:IsA("TextBox") then
				setupTextClearOnFocus(obj)
			end
		end
	end
	template:Destroy()
end

function createConfigureGui(R15Folder, R6Folder)	
	local screenGui = script.FBXimport:Clone()	
	screenGui.Parent = game:GetService("CoreGui")
	
	local rigConfigurationFrame = screenGui.RigConfiguration
	
	rigConfigurationFrame.Cancel.MouseButton1Down:connect(function() 
		screenGui:Destroy() 
	end)
	
	-- Do initial setup of TextBox fields
	local R15TextureIds = rigConfigurationFrame.R15.TextureIDs
	local textboxTemplate = R15TextureIds.TextboxTemplate
	local nameList = {}

	for key, _ in pairs(R15PartMapping) do
		table.insert(nameList, key)
	end
	textboxListSetup(R15TextureIds, textboxTemplate, nameList)
	
	nameList = {}
	for _, enum in pairs(Enum.BodyPart:GetEnumItems()) do
		table.insert(nameList, enum.Name)
	end
	
	local R6CharaterMeshes = rigConfigurationFrame.R6.CharacterMeshIDs
	textboxTemplate = R6CharaterMeshes.TextboxTemplate
	textboxListSetup(R6CharaterMeshes, textboxTemplate, nameList)
	
	local R6TextureTextboxes = rigConfigurationFrame.R6.TextureIDs.Textboxes
	setupTextClearOnFocus(R6TextureTextboxes.BaseTextureId)
	setupTextClearOnFocus(R6TextureTextboxes.OverlayTextureId)
	
	-- Show the current values from the rig
	for _, obj in pairs(R15TextureIds:GetChildren()) do
		local id = tonumber(obj.TextureID.Text)
		for _, name in pairs(R15PartMapping[obj.Name]) do
			local part = R15Folder:FindFirstChild(name)
			if part and part:IsA("MeshPart") and part.TextureID ~= "" then
				local assetUrl = "http://roblox.com/asset/?id="
				local textureId = part.TextureID
				if string.find(textureId, assetUrl, 1, true) ~= nil then
					textureId = string.sub(textureId, assetUrl:len() + 1)
				end
				obj.TextureID.Text = textureId
				break
			end
		end
	end

	local R6AssetIdFrame = rigConfigurationFrame.R6.AssetId
	if canUseSimpleR6import then
		R6AssetIdFrame.Visible = true
		setupTextClearOnFocus(R6AssetIdFrame.OldAssetId)
	end
	
	for _, obj in pairs(R6Folder:GetChildren()) do
		if obj:IsA("CharacterMesh") then
			if tostring(obj.BaseTextureId) ~= "" and obj.BaseTextureId ~= 0 then
				R6TextureTextboxes.BaseTextureId.Text = tostring(obj.BaseTextureId)
			end
			
			if tostring(obj.OverlayTextureId) ~= "" and obj.OverlayTextureId ~= 0 then
				R6TextureTextboxes.OverlayTextureId.Text = tostring(obj.OverlayTextureId)
			end
			
			if tostring(obj.MeshId) ~= "" and obj.MeshId ~= 0 then
				R6CharaterMeshes[obj.BodyPart.Name].MeshId.Text = tostring(obj.MeshId)
			end 
		end
	end
	
	rigConfigurationFrame.Done.MouseButton1Down:connect(function()
		if R15Folder and R6Folder then
	    	-- Fill the values from the TextBox fields into the rig
			for _, obj in pairs(R15TextureIds:GetChildren()) do
				local id = obj.TextureID.Text
				if id ~= "" and string.find(id, "<") == nil then
					local assetString = "http://roblox.com/asset/?id="
					if string.find(id, assetString, 1, true) == nil then
						id = assetString.. "" ..id
					end
					
					for _, name in pairs(R15PartMapping[obj.Name]) do
						local part = R15Folder:FindFirstChild(name)
						if part and part:IsA("MeshPart") then
							part.TextureID = id
						end
					end
				end
			end

			local R6TextureTextboxes = rigConfigurationFrame.R6.TextureIDs.Textboxes
			
			if tonumber(R6AssetIdFrame.OldAssetId.Text) == nil then 
				for _, enum in pairs(Enum.BodyPart:GetEnumItems()) do
					local meshId = tonumber(R6CharaterMeshes[enum.Name].MeshId.Text)
					local baseTextureId = tonumber(R6TextureTextboxes.BaseTextureId.Text)
					local overlayTextureId = tonumber(R6TextureTextboxes.OverlayTextureId.Text)
					
					if meshId or baseTextureId or overlayTextureId then		
						local characterMesh = nil
						
						for _, characterObject in pairs(R6Folder:GetChildren()) do
							if characterObject:IsA("CharacterMesh") and characterObject.BodyPart == enum then
								characterMesh = characterObject
							end
						end					
						
						if not characterMesh then
							characterMesh = Instance.new("CharacterMesh")
							characterMesh.BodyPart = enum
							characterMesh.Parent = R6Folder						
						end
						
						if meshId then
							characterMesh.MeshId = meshId
						end
	
						if baseTextureId then
							characterMesh.BaseTextureId = baseTextureId
						end
	
						if overlayTextureId then
							characterMesh.OverlayTextureId = overlayTextureId
						end
					end
				end
			else
				-- We can get the R6 package information from the asset of the old packages
				local R6PackageAssetId = tonumber(R6AssetIdFrame.OldAssetId.Text)
				local bodyPartAssetIds = game:GetService("AssetService"):GetAssetIdsForPackage(R6PackageAssetId)
				for _, assetId in pairs(bodyPartAssetIds) do
					local model = game:GetService("InsertService"):LoadAsset(assetId)
					local children = model:GetChildren()
					if model:FindFirstChild("R6") then
						-- This is the new dual format for packages
						children = model.R6:GetChildren()
					end
					for _, child in pairs(children) do
						if child:IsA("CharacterMesh") then
							assetIdMap[child.BodyPart.Name] = assetId
							-- Destroy duplicates of this Character mesh if there are any
							for _, existingPart in pairs(R6Folder:GetChildren()) do
								if existingPart:IsA("CharacterMesh") and existingPart.BodyPart == child.BodyPart then
									existingPart:Destroy()
								end
							end
							child.Parent = R6Folder
						end
					end
					model:Destroy()
				end
			end
		end
		screenGui:Destroy()
	end)
end

-- Makes a copy of the rig in the export format
function makeExportVersion(R15Model, R6Model)
	-- Remove existing export models
	for _, model in pairs(game.ServerStorage:GetChildren()) do
		if model.Name == "PackageExport" then
			model:Destroy()
		end
	end

	local exportModel = Instance.new("Model")
	exportModel.Name = "PackageExport"
	exportModel.Parent = game.ServerStorage
	
	local function populateExportModel()
		-- The model is repopulated every time a property of any descendant changes
		exportModel:ClearAllChildren()
		
		for r6Name, r15Names in pairs(R15PartMapping) do
			local partFolder = Instance.new("Folder", exportModel)
			partFolder.Name = r6Name
			
			local R15subfolder = Instance.new("Folder", partFolder)
			R15subfolder.Name = "R15"
			
			for _, r15Name in pairs(r15Names) do
				local R15part = R15Model:FindFirstChild(r15Name)
				if R15part then
					R15part:Clone().Parent = R15subfolder
				end
			end			
			
			local R6subfolder = Instance.new("Folder", partFolder)
			R6subfolder.Name = "R6"
			
			for _, child in pairs(R6Model:GetChildren()) do
				if child:IsA("CharacterMesh") then
					local R6EnumName = r6Name:gsub("%s+", "")
					if child.BodyPart.Name == R6EnumName then
						child:Clone().Parent = R6subfolder
					end
				end
			end
		end
	end
	populateExportModel()
	
		
	local changed = false	
	spawn(function()
		-- Refresh export model every second if it's been updates
		-- Should be fast enough that export model is always up to date
		-- but slow enough to not effect performance too much
		while R15Model and R6Model do
			if changed then
				populateExportModel()
				changed = false
			end
			wait(1)
		end
	end)
	
	local function recurCheckChanged(obj)
		obj.Changed:connect(function() changed = true end)
		for _, childObj in pairs(obj:GetChildren()) do
			recurCheckChanged(childObj)
		end
	end
	recurCheckChanged(R15Model)
	recurCheckChanged(R6Model)
	
	-- For added CharacterMesh objects
	R6Model.ChildAdded:connect(function(child) 
		child.Changed:connect(populateExportModel) 
		changed = true
	end)
	R6Model.ChildRemoved:connect(function() changed = true end)	
end

local function buildJoint(parentAttachment, partForJointAttachment)
    local newMotor = Instance.new("Motor6D")
	newMotor.Name = parentAttachment.Name:gsub("RigAttachment", "")
	
    newMotor.Part0 = parentAttachment.Parent
    newMotor.Part1 = partForJointAttachment.Parent
    
	newMotor.C0 = parentAttachment.CFrame
    newMotor.C1 = partForJointAttachment.CFrame
	
	local oldMotor = partForJointAttachment.Parent:FindFirstChild(newMotor.Name)
	while oldMotor do
		oldMotor:Destroy()
		oldMotor = partForJointAttachment.Parent:FindFirstChild(newMotor.Name)
	end
	
    newMotor.Parent = partForJointAttachment.Parent
    return weld
end

-- Removes old Motor6Ds and builds the rig from the attachments in the parts
-- Call this with nil, HumanoidRootPart
function buildRigFromAttachments(last, part)
	for _, attachment in pairs(part:GetChildren()) do
		if attachment:IsA("Attachment") and string.find(attachment.Name, "RigAttachment") then
			for _, sibling in pairs(part.Parent:GetChildren()) do
				if sibling ~= part and sibling ~= last then
					local matchingAttachment = sibling:FindFirstChild(attachment.Name)
					if matchingAttachment then
						buildJoint(attachment, matchingAttachment)
						-- Continue the recursive tree traversal building joints
						buildRigFromAttachments(part, matchingAttachment.Parent)
					end
				end
			end
		end
	end
end

-- Mr Grey R15
local r15DummyId = 516159357

function fbxRigImported(R15Rig)
	-- This wait is necessary because the imported rig is added to workspace 
	-- before all the parts are loaded
	wait(.5)
	
	-- Not all packages have all their parts, we load MrGreyR15 first then substitute the parts we did load
	local R15Dummy = game:GetService("InsertService"):LoadAsset(r15DummyId):GetChildren()[1]
	
	for _, part in pairs(R15Rig:GetChildren()) do
		local matchingPart = R15Dummy:FindFirstChild(part.Name)
		if matchingPart then
			matchingPart:Destroy()
		end
		part.Parent = R15Dummy
	end
	R15Rig:Destroy()
	
	R15Rig = R15Dummy
	buildRigFromAttachments(nil, R15Rig.HumanoidRootPart)
	
	R15Rig.Parent = game.Workspace
	R15Rig:MoveTo(Vector3.new(0, 0, 0))
	
	local r15Head = R15Rig:WaitForChild("Head", 1) -- 1 second timeout

	if not r15Head:FindFirstChildOfClass("Decal") then
		local Face = Instance.new("Decal", r15Head)
		Face.Name = "Face"
		Face.Texture = "rbxasset://textures/face.png"
	end

	-- Remove duplicates if re-importing
	for _, obj in pairs(game.Workspace:GetChildren()) do
		if obj.Name == "ImportedFbx" then
			obj:Destroy()
		end
	end
	
	local rigModel = Instance.new("Model")
	rigModel.Name = "ImportedFbx"
	rigModel.Parent = game.Workspace
	
	local R6Folder = Instance.new("Model")
	R6Folder.Name = "R6"
	R6Folder.Parent = rigModel
	
	local R15Folder = Instance.new("Model")
	R15Folder.Name = "R15"
	R15Folder.Parent = rigModel
	
	for _, obj in pairs(R15Rig:GetChildren()) do
		obj.Parent = R15Folder
	end
	R15Rig:Destroy()
	
	local R6Rig = rigCreator.CreateR6Rig()
	R6Rig.HumanoidRootPart.Transparency = 1
	R6Rig:MoveTo(Vector3.new(5, 0, 0))
	
	local HeadMesh = Instance.new("SpecialMesh", R6Rig.Head)
	HeadMesh.MeshType = 0
	HeadMesh.Scale = Vector3.new(1.25, 1.25, 1.25)
	
	for _, obj in pairs(R6Rig:GetChildren()) do
		obj.Parent = R6Folder
	end
	R6Rig:Destroy()

	createConfigureGui(R15Folder, R6Folder)
	makeExportVersion(R15Folder, R6Folder)
end

-- Hook up events to make export copy of rig for already imported Fbx rigs
for _, obj in pairs(game.Workspace:GetChildren()) do
	if obj.Name == "ImportedFbx" then
		local R15Folder = obj:FindFirstChild("R15")
		local R6Folder = obj:FindFirstChild("R6")
		if R15Folder and R6Folder then
			makeExportVersion(R15Folder, R6Folder)
		end
	end
end

if fbxFlagExists and fbxFlagValue == true then
	local button = toolbar:CreateButton(
		"", -- The text next to the icon. Leave this blank if the icon is sufficient.
		"Import FBX Rig", -- hover text
		"http://roblox.com/asset/?id=467691760" -- The icon file's name.
	)
	
	button.Click:connect(function()
		if (_G["AnimationEdit"] == true) then
			print("Cannot import rig while in edit mode.")
			return
		end		
		
		warn("This operation may take a few seconds depending on rig complexity!")
		local importedRig = plugin:ImportFbxRig()
		if importedRig then
			fbxRigImported(importedRig)
		end
	end)
	
	local configureButton = toolbar:CreateButton(
		"",
		"Configure FBX rig",
		"http://roblox.com/asset/?id=467691760"	
	)
	
	configureButton.Click:connect(function()
		local fbxImport = game.Workspace:FindFirstChild("ImportedFbx")
		
		if fbxImport then
			local R15Model = fbxImport:FindFirstChild("R15")
			local R6Model = fbxImport:FindFirstChild("R6")
			
			createConfigureGui(R15Model, R6Model)
		end
	end)
	
	if saveSelectionExport then
		local saveButton = toolbar:CreateButton(
			"",
			"Export Package",
			"http://roblox.com/asset/?id=467691760"	
		)
		
		saveButton.Click:connect(function()
			local exportModel = game.ServerStorage:FindFirstChild("PackageExport")
			if exportModel then
				for _, folder in pairs(exportModel:GetChildren()) do
					if folder.Name ~= "Head" then
						game.Selection:Set(folder:GetChildren())
						local outputFileName = folder.Name
						local bodyPartName = folder.Name:gsub("%s+", "")
						if assetIdMap[bodyPartName] then
							outputFileName = assetIdMap[bodyPartName]
						end
						plugin:PromptSaveSelection(outputFileName)
					end
				end
			end
		end)
	end
end


]]></ProtectedString>
			</Properties>
			<Item class="ScreenGui" referent="RBX9C9737840CE148628CB2B2FB0505EF46">
				<Properties>
					<int name="DisplayOrder">0</int>
					<bool name="Enabled">true</bool>
					<string name="Name">FBXimport</string>
					<bool name="ResetOnSpawn">true</bool>
				</Properties>
				<Item class="Frame" referent="RBXFE0241D1BEFF48389B997297F8C7E1D0">
					<Properties>
						<bool name="Active">true</bool>
						<Vector2 name="AnchorPoint">
							<X>0</X>
							<Y>0</Y>
						</Vector2>
						<Color3 name="BackgroundColor3">4279242768</Color3>
						<float name="BackgroundTransparency">0.5</float>
						<Color3 name="BorderColor3">4279970357</Color3>
						<int name="BorderSizePixel">0</int>
						<bool name="ClipsDescendants">false</bool>
						<bool name="Draggable">true</bool>
						<string name="Name">RigConfiguration</string>
						<Ref name="NextSelectionDown">null</Ref>
						<Ref name="NextSelectionLeft">null</Ref>
						<Ref name="NextSelectionRight">null</Ref>
						<Ref name="NextSelectionUp">null</Ref>
						<UDim2 name="Position">
							<XS>0.5</XS>
							<XO>-300</XO>
							<YS>0.5</YS>
							<YO>-250</YO>
						</UDim2>
						<float name="Rotation">0</float>
						<bool name="Selectable">false</bool>
						<Ref name="SelectionImageObject">null</Ref>
						<UDim2 name="Size">
							<XS>0</XS>
							<XO>600</XO>
							<YS>0</YS>
							<YO>400</YO>
						</UDim2>
						<token name="SizeConstraint">0</token>
						<token name="Style">0</token>
						<bool name="Visible">true</bool>
						<int name="ZIndex">1</int>
					</Properties>
					<Item class="TextButton" referent="RBXA7E4FB087453418DBEC88A6BCEBAED9D">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4284124895</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Select</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>10</XO>
								<YS>0</YS>
								<YO>110</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>120</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Select</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX08E80FB32B20476BBACA2D110AA8F6E1">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4286874756</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Cancel</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>1</XS>
								<XO>-270</XO>
								<YS>1</YS>
								<YO>-40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>120</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Cancel</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBX3FDA66D191C14394A802EEC19AD37231">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">3</token>
							<token name="FontSize">5</token>
							<string name="Name">Topbar</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>0</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text"></string>
							<Color3 name="TextColor3">4279970357</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXB7CBCF2E78144DF5BFAE95EF3210473F">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">6</token>
							<string name="Name">Title</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>5</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>0</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Configure Imported Rig</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">18</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextButton" referent="RBX0C85095A71234645B31AD8843A80AFE2">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<bool name="AutoButtonColor">true</bool>
							<Color3 name="BackgroundColor3">4294944010</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4281413937</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<bool name="Modal">false</bool>
							<string name="Name">Done</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>1</XS>
								<XO>-140</XO>
								<YS>1</YS>
								<YO>-40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">true</bool>
							<bool name="Selected">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>120</XO>
								<YS>0</YS>
								<YO>30</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<string name="Text">Done</string>
							<Color3 name="TextColor3">4294967295</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">0.75</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="TextLabel" referent="RBXF0CBDE2EFFD849BDBBC7EE08537E6F96">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4281413937</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<token name="Font">4</token>
							<token name="FontSize">5</token>
							<string name="Name">Warning</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>15</XO>
								<YS>0</YS>
								<YO>70</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>1</XS>
								<XO>-30</XO>
								<YS>0</YS>
								<YO>20</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<string name="Text">Warning: Root Part Is Unanchored</string>
							<Color3 name="TextColor3">4294944010</Color3>
							<bool name="TextScaled">false</bool>
							<float name="TextSize">14</float>
							<Color3 name="TextStrokeColor3">4278190080</Color3>
							<float name="TextStrokeTransparency">1</float>
							<float name="TextTransparency">0</float>
							<bool name="TextWrapped">false</bool>
							<token name="TextXAlignment">2</token>
							<token name="TextYAlignment">1</token>
							<bool name="Visible">false</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
					<Item class="Frame" referent="RBX42E590023C2C44D9A9F1BD3DB0F6C2C9">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279242768</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">true</bool>
							<string name="Name">R15</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.5</XS>
								<XO>5</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0.5</XS>
								<XO>-5</XO>
								<YS>1</YS>
								<YO>-100</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="TextLabel" referent="RBX8975303FC0344F25B95652467293378B">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">6</token>
								<string name="Name">SubTitle</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">R15</string>
								<Color3 name="TextColor3">4294944010</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">18</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">2</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX793967E7459C4AEA9C23CCDFEAEC1017">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">Instructions</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>5</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">Enter TextureIDs</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="Frame" referent="RBX3625C4E9BE444FB1BF1EF805AB9B4B50">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4279242768</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<string name="Name">TextureIDs</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>45</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>1</YS>
									<YO>-20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
							<Item class="Frame" referent="RBX45B944CA2F4D47C49193BFB8DCA9351D">
								<Properties>
									<bool name="Active">true</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4279242768</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<string name="Name">TextboxTemplate</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>5</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>1</XS>
										<XO>-10</XO>
										<YS>0</YS>
										<YO>25</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<token name="Style">0</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">1</int>
								</Properties>
								<Item class="TextBox" referent="RBX40E05C5F81C44B83BF664E11E55E53A7">
									<Properties>
										<bool name="Active">true</bool>
										<Vector2 name="AnchorPoint">
											<X>0</X>
											<Y>0</Y>
										</Vector2>
										<Color3 name="BackgroundColor3">4282795590</Color3>
										<float name="BackgroundTransparency">0</float>
										<Color3 name="BorderColor3">4281413937</Color3>
										<int name="BorderSizePixel">1</int>
										<bool name="ClearTextOnFocus">false</bool>
										<bool name="ClipsDescendants">false</bool>
										<bool name="Draggable">false</bool>
										<token name="Font">3</token>
										<token name="FontSize">5</token>
										<bool name="MultiLine">false</bool>
										<string name="Name">TextureID</string>
										<Ref name="NextSelectionDown">null</Ref>
										<Ref name="NextSelectionLeft">null</Ref>
										<Ref name="NextSelectionRight">null</Ref>
										<Ref name="NextSelectionUp">null</Ref>
										<UDim2 name="Position">
											<XS>0.5</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>0</YO>
										</UDim2>
										<float name="Rotation">0</float>
										<bool name="Selectable">true</bool>
										<Ref name="SelectionImageObject">null</Ref>
										<bool name="ShowNativeInput">true</bool>
										<UDim2 name="Size">
											<XS>0.5</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>25</YO>
										</UDim2>
										<token name="SizeConstraint">0</token>
										<string name="Text">&lt;TextureID&gt;</string>
										<Color3 name="TextColor3">4294967295</Color3>
										<bool name="TextScaled">false</bool>
										<float name="TextSize">14</float>
										<Color3 name="TextStrokeColor3">4278190080</Color3>
										<float name="TextStrokeTransparency">1</float>
										<float name="TextTransparency">0</float>
										<bool name="TextWrapped">false</bool>
										<token name="TextXAlignment">2</token>
										<token name="TextYAlignment">1</token>
										<bool name="Visible">true</bool>
										<int name="ZIndex">1</int>
									</Properties>
								</Item>
								<Item class="TextLabel" referent="RBX68B57F64DC684A3F93694C8B8AFAC55D">
									<Properties>
										<bool name="Active">false</bool>
										<Vector2 name="AnchorPoint">
											<X>0</X>
											<Y>0</Y>
										</Vector2>
										<Color3 name="BackgroundColor3">4281413937</Color3>
										<float name="BackgroundTransparency">1</float>
										<Color3 name="BorderColor3">4279970357</Color3>
										<int name="BorderSizePixel">0</int>
										<bool name="ClipsDescendants">false</bool>
										<bool name="Draggable">false</bool>
										<token name="Font">4</token>
										<token name="FontSize">5</token>
										<string name="Name">Description</string>
										<Ref name="NextSelectionDown">null</Ref>
										<Ref name="NextSelectionLeft">null</Ref>
										<Ref name="NextSelectionRight">null</Ref>
										<Ref name="NextSelectionUp">null</Ref>
										<UDim2 name="Position">
											<XS>0</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>0</YO>
										</UDim2>
										<float name="Rotation">0</float>
										<bool name="Selectable">false</bool>
										<Ref name="SelectionImageObject">null</Ref>
										<UDim2 name="Size">
											<XS>0.5</XS>
											<XO>-5</XO>
											<YS>0</YS>
											<YO>25</YO>
										</UDim2>
										<token name="SizeConstraint">0</token>
										<string name="Text">RightUpperLeg:</string>
										<Color3 name="TextColor3">4294967295</Color3>
										<bool name="TextScaled">false</bool>
										<float name="TextSize">14</float>
										<Color3 name="TextStrokeColor3">4278190080</Color3>
										<float name="TextStrokeTransparency">1</float>
										<float name="TextTransparency">0</float>
										<bool name="TextWrapped">false</bool>
										<token name="TextXAlignment">1</token>
										<token name="TextYAlignment">1</token>
										<bool name="Visible">true</bool>
										<int name="ZIndex">1</int>
									</Properties>
								</Item>
							</Item>
						</Item>
					</Item>
					<Item class="Frame" referent="RBXE275D84A31624775BB91F990F8616039">
						<Properties>
							<bool name="Active">true</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4279242768</Color3>
							<float name="BackgroundTransparency">1</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">0</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">true</bool>
							<string name="Name">R6</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0</XS>
								<XO>5</XO>
								<YS>0</YS>
								<YO>40</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0.5</XS>
								<XO>-10</XO>
								<YS>1</YS>
								<YO>-100</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
						<Item class="TextLabel" referent="RBX019906D603C94CCC86FB70CCDB3E4174">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">6</token>
								<string name="Name">SubTitle</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>0</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">R6</string>
								<Color3 name="TextColor3">4294944010</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">18</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">2</int>
							</Properties>
						</Item>
						<Item class="TextLabel" referent="RBX09FF4AA2E4E940898B20A2EDCB6F07E9">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">TextureIdsInstructions</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">Enter TextureIDs</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="Frame" referent="RBXBEC4DBD3EBF14F79A2E633A930E9640D">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4279242768</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<string name="Name">TextureIDs</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>45</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>60</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
							<Item class="Frame" referent="RBX7D115926CBC64D5FAC4D354A2649CC42">
								<Properties>
									<bool name="Active">true</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4279242768</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<string name="Name">Textboxes</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>5</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>1</XS>
										<XO>-10</XO>
										<YS>0</YS>
										<YO>25</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<token name="Style">0</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">1</int>
								</Properties>
								<Item class="TextBox" referent="RBXF4DDFF7DC4BF498E8D0D244C15760AAD">
									<Properties>
										<bool name="Active">true</bool>
										<Vector2 name="AnchorPoint">
											<X>0</X>
											<Y>0</Y>
										</Vector2>
										<Color3 name="BackgroundColor3">4282795590</Color3>
										<float name="BackgroundTransparency">0</float>
										<Color3 name="BorderColor3">4281413937</Color3>
										<int name="BorderSizePixel">1</int>
										<bool name="ClearTextOnFocus">false</bool>
										<bool name="ClipsDescendants">false</bool>
										<bool name="Draggable">false</bool>
										<token name="Font">3</token>
										<token name="FontSize">5</token>
										<bool name="MultiLine">false</bool>
										<string name="Name">BaseTextureId</string>
										<Ref name="NextSelectionDown">null</Ref>
										<Ref name="NextSelectionLeft">null</Ref>
										<Ref name="NextSelectionRight">null</Ref>
										<Ref name="NextSelectionUp">null</Ref>
										<UDim2 name="Position">
											<XS>0</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>0</YO>
										</UDim2>
										<float name="Rotation">0</float>
										<bool name="Selectable">true</bool>
										<Ref name="SelectionImageObject">null</Ref>
										<bool name="ShowNativeInput">true</bool>
										<UDim2 name="Size">
											<XS>0.5</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>25</YO>
										</UDim2>
										<token name="SizeConstraint">0</token>
										<string name="Text">&lt;BaseTextureId&gt;</string>
										<Color3 name="TextColor3">4294967295</Color3>
										<bool name="TextScaled">false</bool>
										<float name="TextSize">14</float>
										<Color3 name="TextStrokeColor3">4278190080</Color3>
										<float name="TextStrokeTransparency">1</float>
										<float name="TextTransparency">0</float>
										<bool name="TextWrapped">false</bool>
										<token name="TextXAlignment">2</token>
										<token name="TextYAlignment">1</token>
										<bool name="Visible">true</bool>
										<int name="ZIndex">1</int>
									</Properties>
								</Item>
								<Item class="TextBox" referent="RBX18926C5152534E3BB140CE3FB89A933A">
									<Properties>
										<bool name="Active">true</bool>
										<Vector2 name="AnchorPoint">
											<X>0</X>
											<Y>0</Y>
										</Vector2>
										<Color3 name="BackgroundColor3">4282795590</Color3>
										<float name="BackgroundTransparency">0</float>
										<Color3 name="BorderColor3">4281413937</Color3>
										<int name="BorderSizePixel">1</int>
										<bool name="ClearTextOnFocus">false</bool>
										<bool name="ClipsDescendants">false</bool>
										<bool name="Draggable">false</bool>
										<token name="Font">3</token>
										<token name="FontSize">5</token>
										<bool name="MultiLine">false</bool>
										<string name="Name">OverlayTextureId</string>
										<Ref name="NextSelectionDown">null</Ref>
										<Ref name="NextSelectionLeft">null</Ref>
										<Ref name="NextSelectionRight">null</Ref>
										<Ref name="NextSelectionUp">null</Ref>
										<UDim2 name="Position">
											<XS>0.5</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>0</YO>
										</UDim2>
										<float name="Rotation">0</float>
										<bool name="Selectable">true</bool>
										<Ref name="SelectionImageObject">null</Ref>
										<bool name="ShowNativeInput">true</bool>
										<UDim2 name="Size">
											<XS>0.5</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>25</YO>
										</UDim2>
										<token name="SizeConstraint">0</token>
										<string name="Text">&lt;OverlayTextureId&gt;</string>
										<Color3 name="TextColor3">4294967295</Color3>
										<bool name="TextScaled">false</bool>
										<float name="TextSize">14</float>
										<Color3 name="TextStrokeColor3">4278190080</Color3>
										<float name="TextStrokeTransparency">1</float>
										<float name="TextTransparency">0</float>
										<bool name="TextWrapped">false</bool>
										<token name="TextXAlignment">2</token>
										<token name="TextYAlignment">1</token>
										<bool name="Visible">true</bool>
										<int name="ZIndex">1</int>
									</Properties>
								</Item>
							</Item>
						</Item>
						<Item class="TextLabel" referent="RBXBDC693A5EF9C41DBA0F24008298A16F0">
							<Properties>
								<bool name="Active">false</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4281413937</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<token name="Font">4</token>
								<token name="FontSize">5</token>
								<string name="Name">CharacterMeshInstructions</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>100</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>20</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<string name="Text">Enter Character MeshIDs</string>
								<Color3 name="TextColor3">4294967295</Color3>
								<bool name="TextScaled">false</bool>
								<float name="TextSize">14</float>
								<Color3 name="TextStrokeColor3">4278190080</Color3>
								<float name="TextStrokeTransparency">1</float>
								<float name="TextTransparency">0</float>
								<bool name="TextWrapped">false</bool>
								<token name="TextXAlignment">2</token>
								<token name="TextYAlignment">1</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
						</Item>
						<Item class="Frame" referent="RBX16990FA36C0C42938D1B128A41B3D2C2">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4279242768</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<string name="Name">CharacterMeshIDs</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>125</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>175</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<bool name="Visible">true</bool>
								<int name="ZIndex">1</int>
							</Properties>
							<Item class="Frame" referent="RBX7CA74927F3754F12AA3E10C59224E756">
								<Properties>
									<bool name="Active">true</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4279242768</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<string name="Name">TextboxTemplate</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>5</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>1</XS>
										<XO>-10</XO>
										<YS>0</YS>
										<YO>25</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<token name="Style">0</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">1</int>
								</Properties>
								<Item class="TextBox" referent="RBX847DE95908D2476EB49AB8FBA60E112D">
									<Properties>
										<bool name="Active">true</bool>
										<Vector2 name="AnchorPoint">
											<X>0</X>
											<Y>0</Y>
										</Vector2>
										<Color3 name="BackgroundColor3">4282795590</Color3>
										<float name="BackgroundTransparency">0</float>
										<Color3 name="BorderColor3">4281413937</Color3>
										<int name="BorderSizePixel">1</int>
										<bool name="ClearTextOnFocus">false</bool>
										<bool name="ClipsDescendants">false</bool>
										<bool name="Draggable">false</bool>
										<token name="Font">3</token>
										<token name="FontSize">5</token>
										<bool name="MultiLine">false</bool>
										<string name="Name">MeshId</string>
										<Ref name="NextSelectionDown">null</Ref>
										<Ref name="NextSelectionLeft">null</Ref>
										<Ref name="NextSelectionRight">null</Ref>
										<Ref name="NextSelectionUp">null</Ref>
										<UDim2 name="Position">
											<XS>0.5</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>0</YO>
										</UDim2>
										<float name="Rotation">0</float>
										<bool name="Selectable">true</bool>
										<Ref name="SelectionImageObject">null</Ref>
										<bool name="ShowNativeInput">true</bool>
										<UDim2 name="Size">
											<XS>0.5</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>25</YO>
										</UDim2>
										<token name="SizeConstraint">0</token>
										<string name="Text">&lt;MeshId&gt;</string>
										<Color3 name="TextColor3">4294967295</Color3>
										<bool name="TextScaled">false</bool>
										<float name="TextSize">14</float>
										<Color3 name="TextStrokeColor3">4278190080</Color3>
										<float name="TextStrokeTransparency">1</float>
										<float name="TextTransparency">0</float>
										<bool name="TextWrapped">false</bool>
										<token name="TextXAlignment">2</token>
										<token name="TextYAlignment">1</token>
										<bool name="Visible">true</bool>
										<int name="ZIndex">1</int>
									</Properties>
								</Item>
								<Item class="TextLabel" referent="RBX9DCB78A804DE4A9CA570F8A49CD57DB8">
									<Properties>
										<bool name="Active">false</bool>
										<Vector2 name="AnchorPoint">
											<X>0</X>
											<Y>0</Y>
										</Vector2>
										<Color3 name="BackgroundColor3">4281413937</Color3>
										<float name="BackgroundTransparency">1</float>
										<Color3 name="BorderColor3">4279970357</Color3>
										<int name="BorderSizePixel">0</int>
										<bool name="ClipsDescendants">false</bool>
										<bool name="Draggable">false</bool>
										<token name="Font">4</token>
										<token name="FontSize">5</token>
										<string name="Name">Description</string>
										<Ref name="NextSelectionDown">null</Ref>
										<Ref name="NextSelectionLeft">null</Ref>
										<Ref name="NextSelectionRight">null</Ref>
										<Ref name="NextSelectionUp">null</Ref>
										<UDim2 name="Position">
											<XS>0</XS>
											<XO>0</XO>
											<YS>0</YS>
											<YO>0</YO>
										</UDim2>
										<float name="Rotation">0</float>
										<bool name="Selectable">false</bool>
										<Ref name="SelectionImageObject">null</Ref>
										<UDim2 name="Size">
											<XS>0.5</XS>
											<XO>-5</XO>
											<YS>0</YS>
											<YO>25</YO>
										</UDim2>
										<token name="SizeConstraint">0</token>
										<string name="Text">Right Leg:</string>
										<Color3 name="TextColor3">4294967295</Color3>
										<bool name="TextScaled">false</bool>
										<float name="TextSize">14</float>
										<Color3 name="TextStrokeColor3">4278190080</Color3>
										<float name="TextStrokeTransparency">1</float>
										<float name="TextTransparency">0</float>
										<bool name="TextWrapped">false</bool>
										<token name="TextXAlignment">1</token>
										<token name="TextYAlignment">1</token>
										<bool name="Visible">true</bool>
										<int name="ZIndex">1</int>
									</Properties>
								</Item>
							</Item>
						</Item>
						<Item class="Frame" referent="RBXD9A2CD84B62A486795EE53E397446D8F">
							<Properties>
								<bool name="Active">true</bool>
								<Vector2 name="AnchorPoint">
									<X>0</X>
									<Y>0</Y>
								</Vector2>
								<Color3 name="BackgroundColor3">4279242768</Color3>
								<float name="BackgroundTransparency">1</float>
								<Color3 name="BorderColor3">4279970357</Color3>
								<int name="BorderSizePixel">0</int>
								<bool name="ClipsDescendants">false</bool>
								<bool name="Draggable">false</bool>
								<string name="Name">AssetId</string>
								<Ref name="NextSelectionDown">null</Ref>
								<Ref name="NextSelectionLeft">null</Ref>
								<Ref name="NextSelectionRight">null</Ref>
								<Ref name="NextSelectionUp">null</Ref>
								<UDim2 name="Position">
									<XS>0</XS>
									<XO>0</XO>
									<YS>1</YS>
									<YO>-10</YO>
								</UDim2>
								<float name="Rotation">0</float>
								<bool name="Selectable">false</bool>
								<Ref name="SelectionImageObject">null</Ref>
								<UDim2 name="Size">
									<XS>1</XS>
									<XO>0</XO>
									<YS>0</YS>
									<YO>25</YO>
								</UDim2>
								<token name="SizeConstraint">0</token>
								<token name="Style">0</token>
								<bool name="Visible">false</bool>
								<int name="ZIndex">1</int>
							</Properties>
							<Item class="TextBox" referent="RBXF9D44509351C4292A1C6A5CD996DE296">
								<Properties>
									<bool name="Active">true</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4282795590</Color3>
									<float name="BackgroundTransparency">0</float>
									<Color3 name="BorderColor3">4281413937</Color3>
									<int name="BorderSizePixel">1</int>
									<bool name="ClearTextOnFocus">false</bool>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<token name="Font">3</token>
									<token name="FontSize">5</token>
									<bool name="MultiLine">false</bool>
									<string name="Name">OldAssetId</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0.5</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">true</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<bool name="ShowNativeInput">true</bool>
									<UDim2 name="Size">
										<XS>0.5</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>25</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<string name="Text">&lt;AssetId&gt;</string>
									<Color3 name="TextColor3">4294967295</Color3>
									<bool name="TextScaled">false</bool>
									<float name="TextSize">14</float>
									<Color3 name="TextStrokeColor3">4278190080</Color3>
									<float name="TextStrokeTransparency">1</float>
									<float name="TextTransparency">0</float>
									<bool name="TextWrapped">false</bool>
									<token name="TextXAlignment">2</token>
									<token name="TextYAlignment">1</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">1</int>
								</Properties>
							</Item>
							<Item class="TextLabel" referent="RBX68A02F64706D48729320E0B29E7A6AEB">
								<Properties>
									<bool name="Active">false</bool>
									<Vector2 name="AnchorPoint">
										<X>0</X>
										<Y>0</Y>
									</Vector2>
									<Color3 name="BackgroundColor3">4281413937</Color3>
									<float name="BackgroundTransparency">1</float>
									<Color3 name="BorderColor3">4279970357</Color3>
									<int name="BorderSizePixel">0</int>
									<bool name="ClipsDescendants">false</bool>
									<bool name="Draggable">false</bool>
									<token name="Font">4</token>
									<token name="FontSize">5</token>
									<string name="Name">AssetIdInstructions</string>
									<Ref name="NextSelectionDown">null</Ref>
									<Ref name="NextSelectionLeft">null</Ref>
									<Ref name="NextSelectionRight">null</Ref>
									<Ref name="NextSelectionUp">null</Ref>
									<UDim2 name="Position">
										<XS>0</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>0</YO>
									</UDim2>
									<float name="Rotation">0</float>
									<bool name="Selectable">false</bool>
									<Ref name="SelectionImageObject">null</Ref>
									<UDim2 name="Size">
										<XS>0.5</XS>
										<XO>0</XO>
										<YS>0</YS>
										<YO>25</YO>
									</UDim2>
									<token name="SizeConstraint">0</token>
									<string name="Text">Enter Old Package AssetId</string>
									<Color3 name="TextColor3">4294967295</Color3>
									<bool name="TextScaled">false</bool>
									<float name="TextSize">14</float>
									<Color3 name="TextStrokeColor3">4278190080</Color3>
									<float name="TextStrokeTransparency">1</float>
									<float name="TextTransparency">0</float>
									<bool name="TextWrapped">false</bool>
									<token name="TextXAlignment">2</token>
									<token name="TextYAlignment">1</token>
									<bool name="Visible">true</bool>
									<int name="ZIndex">1</int>
								</Properties>
							</Item>
						</Item>
					</Item>
					<Item class="Frame" referent="RBX7990C11CEF02450C99A9EE30626B0AD3">
						<Properties>
							<bool name="Active">false</bool>
							<Vector2 name="AnchorPoint">
								<X>0</X>
								<Y>0</Y>
							</Vector2>
							<Color3 name="BackgroundColor3">4294944010</Color3>
							<float name="BackgroundTransparency">0</float>
							<Color3 name="BorderColor3">4279970357</Color3>
							<int name="BorderSizePixel">1</int>
							<bool name="ClipsDescendants">false</bool>
							<bool name="Draggable">false</bool>
							<string name="Name">Divide</string>
							<Ref name="NextSelectionDown">null</Ref>
							<Ref name="NextSelectionLeft">null</Ref>
							<Ref name="NextSelectionRight">null</Ref>
							<Ref name="NextSelectionUp">null</Ref>
							<UDim2 name="Position">
								<XS>0.5</XS>
								<XO>2</XO>
								<YS>0</YS>
								<YO>60</YO>
							</UDim2>
							<float name="Rotation">0</float>
							<bool name="Selectable">false</bool>
							<Ref name="SelectionImageObject">null</Ref>
							<UDim2 name="Size">
								<XS>0</XS>
								<XO>2</XO>
								<YS>1</YS>
								<YO>-66</YO>
							</UDim2>
							<token name="SizeConstraint">0</token>
							<token name="Style">0</token>
							<bool name="Visible">true</bool>
							<int name="ZIndex">1</int>
						</Properties>
					</Item>
				</Item>
			</Item>
		</Item>
	</Item>
</roblox>