Prompt: -- init chat bubble tables

Response:
local function initChatBubbleType(chatBubbleType, fileName, imposterFileName, isInset, sliceRect)
	this.ChatBubble[chatBubbleType] = createChatBubbleMain(fileName, sliceRect)
	this.ChatBubbleWithTail[chatBubbleType] = createChatBubbleWithTail(fileName, UDim2.new(0.5, -CHAT_BUBBLE_TAIL_HEIGHT, 1, isInset and -1 or 0), UDim2.new(0, 30, 0, CHAT_BUBBLE_TAIL_HEIGHT), sliceRect)
	this.ScalingChatBubbleWithTail[chatBubbleType] = createScaledChatBubbleWithTail(fileName, 0.5, UDim2.new(-0.5, 0, 0, isInset and -1 or 0), sliceRect)
end

initChatBubbleType(BubbleColor.WHITE,	"ui/dialog_white",	"ui/chatBubble_white_notify_bkg", 	false,	Rect.new(5,5,15,15))
initChatBubbleType(BubbleColor.BLUE,	"ui/dialog_blue",	"ui/chatBubble_blue_notify_bkg",	true, 	Rect.new(7,7,33,33))
initChatBubbleType(BubbleColor.RED,		"ui/dialog_red",	"ui/chatBubble_red_notify_bkg",		true,	Rect.new(7,7,33,33))
initChatBubbleType(BubbleColor.GREEN,	"ui/dialog_green",	"ui/chatBubble_green_notify_bkg",	true,	Rect.new(7,7,33,33))

function this:SanitizeChatLine(msg)
	if string.len(msg) > MaxChatMessageLengthExclusive then
		return string.sub(msg, 1, MaxChatMessageLengthExclusive + string.len(ELIPSES))
	else
		return msg
	end
end

local function createBillboardInstance(adornee)
	local billboardGui = Instance.new("BillboardGui")
	billboardGui.Adornee = adornee
	billboardGui.Size = UDim2.new(0,BILLBOARD_MAX_WIDTH,0,BILLBOARD_MAX_HEIGHT)
	billboardGui.StudsOffset = Vector3.new(0, 1.5, 2)
	billboardGui.Parent = BubbleChatScreenGui

	local billboardFrame = Instance.new("Frame")
	billboardFrame.Name = "BillboardFrame"
	billboardFrame.Size = UDim2.new(1,0,1,0)
	billboardFrame.Position = UDim2.new(0,0,-0.5,0)
	billboardFrame.BackgroundTransparency = 1
	billboardFrame.Parent = billboardGui

	local billboardChildRemovedCon = nil
	billboardChildRemovedCon = billboardFrame.ChildRemoved:connect(function()
		if #billboardFrame:GetChildren() <= 1 then
			billboardChildRemovedCon:disconnect()
			billboardGui:Destroy()
		end
	end)

	this:CreateSmallTalkBubble(BubbleColor.WHITE).Parent = billboardFrame

	return billboardGui
end

function this:CreateBillboardGuiHelper(instance, onlyCharacter)
	if instance and not this.CharacterSortedMsg:Get(instance)["BillboardGui"] then
		if not onlyCharacter then
			if instance:IsA("BasePart") then
				-- Create a new billboardGui object attached to this player
				local billboardGui = createBillboardInstance(instance)
				this.CharacterSortedMsg:Get(instance)["BillboardGui"] = billboardGui
				return
			end
		end

		if instance:IsA("Model") then
			local head = instance:FindFirstChild("Head")
			if head and head:IsA("BasePart") then
				-- Create a new billboardGui object attached to this player
				local billboardGui = createBillboardInstance(head)
				this.CharacterSortedMsg:Get(instance)["BillboardGui"] = billboardGui
			end
		end
	end
end

local function distanceToBubbleOrigin(origin)
	if not origin then return 100000 end

	return (origin.Position - game.Workspace.CurrentCamera.CoordinateFrame.p).magnitude
end

local function isPartOfLocalPlayer(adornee)
	if adornee and PlayersService.LocalPlayer.Character then
		return adornee:IsDescendantOf(PlayersService.LocalPlayer.Character)
	end
end

function this:SetBillboardLODNear(billboardGui)
	local isLocalPlayer = isPartOfLocalPlayer(billboardGui.Adornee)
	billboardGui.Size = UDim2.new(0, BILLBOARD_MAX_WIDTH, 0, BILLBOARD_MAX_HEIGHT)
	billboardGui.StudsOffset = Vector3.new(0, isLocalPlayer and 1.5 or 2.5, isLocalPlayer and 2 or 0)
	billboardGui.Enabled = true
	local billChildren = billboardGui.BillboardFrame:GetChildren()
	for i = 1, #billChildren do
		billChildren[i].Visible = true
	end
	billboardGui.BillboardFrame.SmallTalkBubble.Visible = false
end

function this:SetBillboardLODDistant(billboardGui)
	local isLocalPlayer = isPartOfLocalPlayer(billboardGui.Adornee)
	billboardGui.Size = UDim2.new(4,0,3,0)
	billboardGui.StudsOffset = Vector3.new(0, 3, isLocalPlayer and 2 or 0)
	billboardGui.Enabled = true
	local billChildren = billboardGui.BillboardFrame:GetChildren()
	for i = 1, #billChildren do
		billChildren[i].Visible = false
	end
	billboardGui.BillboardFrame.SmallTalkBubble.Visible = true
end

function this:SetBillboardLODVeryFar(billboardGui)
	billboardGui.Enabled = false
end

function this:SetBillboardGuiLOD(billboardGui, origin)
	if not origin then return end

	if origin:IsA("Model") then
		local head = origin:FindFirstChild("Head")
		if not head then origin = origin.PrimaryPart
		else origin = head end
	end

	local bubbleDistance = distanceToBubbleOrigin(origin)

	if bubbleDistance < NEAR_BUBBLE_DISTANCE then
		this:SetBillboardLODNear(billboardGui)
	elseif bubbleDistance >= NEAR_BUBBLE_DISTANCE and bubbleDistance < MAX_BUBBLE_DISTANCE then
		this:SetBillboardLODDistant(billboardGui)
	else
		this:SetBillboardLODVeryFar(billboardGui)
	end
end

function this:CameraCFrameChanged()
	for index, value in pairs(this.CharacterSortedMsg:GetData()) do
		local playerBillboardGui = value["BillboardGui"]
		if playerBillboardGui then this:SetBillboardGuiLOD(playerBillboardGui, index) end
	end
end

function this:CreateBubbleText(message)
	local bubbleText = Instance.new("TextLabel")
	bubbleText.Name = "BubbleText"
	bubbleText.BackgroundTransparency = 1
	bubbleText.Position = UDim2.new(0,CHAT_BUBBLE_WIDTH_PADDING/2,0,0)
	bubbleText.Size = UDim2.new(1,-CHAT_BUBBLE_WIDTH_PADDING,1,0)
	bubbleText.Font = CHAT_BUBBLE_FONT
	bubbleText.TextWrapped = true
	bubbleText.FontSize = CHAT_BUBBLE_FONT_SIZE
	bubbleText.Text = message
	bubbleText.Visible = false

	return bubbleText
end

function this:CreateSmallTalkBubble(chatBubbleType)
	local smallTalkBubble = this.ScalingChatBubbleWithTail[chatBubbleType]:Clone()
	smallTalkBubble.Name = "SmallTalkBubble"
	smallTalkBubble.Position = UDim2.new(0,0,1,-40)
	smallTalkBubble.Visible = false
	local text = this:CreateBubbleText("...")
	text.TextScaled = true
	text.TextWrapped = false
	text.Visible = true
	text.Parent = smallTalkBubble

	return smallTalkBubble
end

function this:UpdateChatLinesForOrigin(origin, currentBubbleYPos)
	local bubbleQueue = this.CharacterSortedMsg:Get(origin).Fifo
	local bubbleQueueSize = bubbleQueue:Size()
	local bubbleQueueData = bubbleQueue:GetData()
	if #bubbleQueueData <= 1 then return end

	for index = (#bubbleQueueData - 1), 1, -1 do
		local value = bubbleQueueData[index]
		local bubble = value.RenderBubble
		if not bubble then return end
		local bubblePos = bubbleQueueSize - index + 1

		if bubblePos > 1 then
			local tail = bubble:FindFirstChild("ChatBubbleTail")
			if tail then tail:Destroy() end
			local bubbleText = bubble:FindFirstChild("BubbleText")
			if bubbleText then bubbleText.TextTransparency = 0.5 end
		end

		local udimValue = UDim2.new( bubble.Position.X.Scale, bubble.Position.X.Offset,
									1, currentBubbleYPos - bubble.Size.Y.Offset - CHAT_BUBBLE_TAIL_HEIGHT )
		bubble:TweenPosition(udimValue, Enum.EasingDirection.Out, Enum.EasingStyle.Bounce, 0.1, true)
		currentBubbleYPos = currentBubbleYPos - bubble.Size.Y.Offset - CHAT_BUBBLE_TAIL_HEIGHT
	end
end

function this:DestroyBubble(bubbleQueue, bubbleToDestroy)
	if not bubbleQueue then return end
	if bubbleQueue:Empty() then return end

	local bubble = bubbleQueue:Front().RenderBubble
	if not bubble then
		bubbleQueue:PopFront()
	 	return
	end

	spawn(function()
		while bubbleQueue:Front().RenderBubble ~= bubbleToDestroy do
			wait()
		end

		bubble = bubbleQueue:Front().RenderBubble

		local timeBetween = 0
		local bubbleText = bubble:FindFirstChild("BubbleText")
		local bubbleTail = bubble:FindFirstChild("ChatBubbleTail")

		while bubble and bubble.ImageTransparency < 1 do
			timeBetween = wait()
			if bubble then
				local fadeAmount = timeBetween * CHAT_BUBBLE_FADE_SPEED
				bubble.ImageTransparency = bubble.ImageTransparency + fadeAmount
				if bubbleText then bubbleText.TextTransparency = bubbleText.TextTransparency + fadeAmount end
				if bubbleTail then bubbleTail.ImageTransparency = bubbleTail.ImageTransparency + fadeAmount end
			end
		end

		if bubble then
			bubble:Destroy()
			bubbleQueue:PopFront()
		end
	end)
end

function this:CreateChatLineRender(instance, line, onlyCharacter, fifo)
	if not instance then return end

	if not this.CharacterSortedMsg:Get(instance)["BillboardGui"] then
		this:CreateBillboardGuiHelper(instance, onlyCharacter)
	end

	local billboardGui = this.CharacterSortedMsg:Get(instance)["BillboardGui"]
	if billboardGui then
		local chatBubbleRender = this.ChatBubbleWithTail[line.BubbleColor]:Clone()
		chatBubbleRender.Visible = false
		local bubbleText = this:CreateBubbleText(line.Message)

		bubbleText.Parent = chatBubbleRender
		chatBubbleRender.Parent = billboardGui.BillboardFrame

		line.RenderBubble = chatBubbleRender

		local currentTextBounds = TextService:GetTextSize(
				bubbleText.Text, CHAT_BUBBLE_FONT_SIZE_INT, CHAT_BUBBLE_FONT,
				Vector2.new(BILLBOARD_MAX_WIDTH, BILLBOARD_MAX_HEIGHT))
		local bubbleWidthScale = math.max((currentTextBounds.X + CHAT_BUBBLE_WIDTH_PADDING)/BILLBOARD_MAX_WIDTH, 0.1)
		local numOflines = (currentTextBounds.Y/CHAT_BUBBLE_FONT_SIZE_INT)

		-- prep chat bubble for tween
		chatBubbleRender.Size = UDim2.new(0,0,0,0)
		chatBubbleRender.Position = UDim2.new(0.5,0,1,0)

		local newChatBubbleOffsetSizeY = numOflines * CHAT_BUBBLE_LINE_HEIGHT

		chatBubbleRender:TweenSizeAndPosition(UDim2.new(bubbleWidthScale, 0, 0, newChatBubbleOffsetSizeY),
											 	UDim2.new( (1-bubbleWidthScale)/2, 0, 1, -newChatBubbleOffsetSizeY),
											 	Enum.EasingDirection.Out, Enum.EasingStyle.Elastic, 0.1, true,
											 	function() bubbleText.Visible = true end)

		-- todo: remove when over max bubbles
		this:SetBillboardGuiLOD(billboardGui, line.Origin)
		this:UpdateChatLinesForOrigin(line.Origin, -newChatBubbleOffsetSizeY)

		delay(line.BubbleDieDelay, function()
			this:DestroyBubble(fifo, chatBubbleRender)
		end)
	end
end

function this:OnPlayerChatMessage(sourcePlayer, message, targetPlayer)
	if not this:BubbleChatEnabled() then return end

	local localPlayer = PlayersService.LocalPlayer
	local fromOthers = localPlayer ~= nil and sourcePlayer ~= localPlayer

	local safeMessage = this:SanitizeChatLine(message)

	local line = createPlayerChatLine(sourcePlayer, safeMessage, not fromOthers)

	if sourcePlayer and line.Origin then
		local fifo = this.CharacterSortedMsg:Get(line.Origin).Fifo
		fifo:PushBack(line)
		--Game chat (badges) won't show up here
		this:CreateChatLineRender(sourcePlayer.Character, line, true, fifo)
	end
end

function this:OnGameChatMessage(origin, message, color)
	local localPlayer = PlayersService.LocalPlayer
	local fromOthers = localPlayer ~= nil and (localPlayer.Character ~= origin)

	local bubbleColor = BubbleColor.WHITE

	if color == Enum.ChatColor.Blue then bubbleColor = BubbleColor.BLUE
	elseif color == Enum.ChatColor.Green then bubbleColor = BubbleColor.GREEN
	elseif color == Enum.ChatColor.Red then bubbleColor = BubbleColor.RED end

	local safeMessage = this:SanitizeChatLine(message)
	local line = createGameChatLine(origin, safeMessage, not fromOthers, bubbleColor)

	this.CharacterSortedMsg:Get(line.Origin).Fifo:PushBack(line)
	this:CreateChatLineRender(origin, line, false, this.CharacterSortedMsg:Get(line.Origin).Fifo)
end

function this:BubbleChatEnabled()
	local clientChatModules = ChatService:FindFirstChild("ClientChatModules")
	if clientChatModules then
		local chatSettings = clientChatModules:FindFirstChild("ChatSettings")
		if chatSettings then
			local chatSettings = require(chatSettings)
			if chatSettings.BubbleChatEnabled ~= nil then
				return chatSettings.BubbleChatEnabled
			end
		end
	end
	return PlayersService.BubbleChat
end

function this:ShowOwnFilteredMessage()
	local clientChatModules = ChatService:FindFirstChild("ClientChatModules")
	if clientChatModules then
		local chatSettings = clientChatModules:FindFirstChild("ChatSettings")
		if chatSettings then
			chatSettings = require(chatSettings)
			return chatSettings.ShowUserOwnFilteredMessage
		end
	end
	return false
end

function findPlayer(playerName)
	for i,v in pairs(PlayersService:GetPlayers()) do
		if v.Name == playerName then
			return v
		end
	end
end

ChatService.Chatted:connect(function(origin, message, color) this:OnGameChatMessage(origin, message, color) end)

local cameraChangedCon = nil
if game.Workspace.CurrentCamera then
	cameraChangedCon = game.Workspace.CurrentCamera:GetPropertyChangedSignal("CFrame"):connect(function(prop) this:CameraCFrameChanged() end)
end

game.Workspace.Changed:connect(function(prop)
	if prop == "CurrentCamera" then
		if cameraChangedCon then cameraChangedCon:disconnect() end
		if game.Workspace.CurrentCamera then
			cameraChangedCon = game.Workspace.CurrentCamera:GetPropertyChangedSignal("CFrame"):connect(function(prop) this:CameraCFrameChanged() end)
		end
	end
end)

local AllowedMessageTypes = nil

function getAllowedMessageTypes()
	if AllowedMessageTypes then
		return AllowedMessageTypes
	end
	local clientChatModules = ChatService:FindFirstChild("ClientChatModules")
	if clientChatModules then
		local chatSettings = clientChatModules:FindFirstChild("ChatSettings")
		if chatSettings then
			chatSettings = require(chatSettings)
			if chatSettings.BubbleChatMessageTypes then
				AllowedMessageTypes = chatSettings.BubbleChatMessageTypes
				return AllowedMessageTypes
			end
		end
		local chatConstants = clientChatModules:FindFirstChild("ChatConstants")
		if chatConstants then
			chatConstants = require(chatConstants)
			AllowedMessageTypes = {chatConstants.MessageTypeDefault, chatConstants.MessageTypeWhisper}
		end
		return AllowedMessageTypes
	end
	return {"Message", "Whisper"}
end

function checkAllowedMessageType(messageData)
	local allowedMessageTypes = getAllowedMessageTypes()
	for i = 1, #allowedMessageTypes do
		if allowedMessageTypes[i] == messageData.MessageType then
			return true
		end
	end
	return false
end

local ChatEvents = ReplicatedStorage:WaitForChild("DefaultChatSystemChatEvents")
local OnMessageDoneFiltering = ChatEvents:WaitForChild("OnMessageDoneFiltering")
local OnNewMessage = ChatEvents:WaitForChild("OnNewMessage")

OnNewMessage.OnClientEvent:connect(function(messageData, channelName)
	if not checkAllowedMessageType(messageData) then
		return
	end

	local sender = findPlayer(messageData.FromSpeaker)
	if not sender then
		return
	end

	if not messageData.IsFiltered or messageData.FromSpeaker == LocalPlayer.Name then
		if messageData.FromSpeaker ~= LocalPlayer.Name or this:ShowOwnFilteredMessage() then
			return
		end
	end

	this:OnPlayerChatMessage(sender, messageData.Message, nil)
end)

OnMessageDoneFiltering.OnClientEvent:connect(function(messageData, channelName)
	if not checkAllowedMessageType(messageData) then
		return
	end

	local sender = findPlayer(messageData.FromSpeaker)
	if not sender then
		return
	end

	if messageData.FromSpeaker == LocalPlayer.Name and not this:ShowOwnFilteredMessage() then
		return
	end

	this:OnPlayerChatMessage(sender, messageData.Message, nil)
end)


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local l__HDAdminMain__1 = _G.HDAdminMain;
local l__settings__2 = l__HDAdminMain__1.settings;
local v3 = {};
local v4 = {};
function v4.Function(p1, p2)
	local v5 = l__HDAdminMain__1.signals.GetPing:InvokeServer(math.random(1, 1000));
	l__HDAdminMain__1:GetModule("Notices"):Notice("Notice", l__HDAdminMain__1.hdAdminCoreName, "Your ping is " .. math.floor((tick() - tick()) / 2 * 1000 * 1000 + 0.5) / 1000 .. "!");
end;
v3.ping = v4;
v3.blur = {
	Function = function(p3, p4)
		l__HDAdminMain__1.blur.Size = p4[2] ~= 0 and p4[2] or 20;
	end,
	UnFunction = function(p5, p6)
		l__HDAdminMain__1.blur.Size = 0;
	end
};
local v6 = {};
local u1 = {};
function v6.Function(p7, p8)
	for v7, v8 in pairs(u1) do
		v7.Enabled = true;
	end;
	u1 = {};
end;
v3.showGuis = v6;
v3.hideGuis = {
	Function = function(p9, p10)
		for v9, v10 in pairs(l__HDAdminMain__1.playerGui:GetChildren()) do
			if v10:IsA("ScreenGui") and v10.Name ~= "Chat" and v10.Name ~= "HDAdminGUIs" then
				if v10.Enabled == true then
					u1[v10] = true;
				end;
				v10.Enabled = false;
			end;
		end;
	end
};
v3.view = {
	Function = function(p11, p12)
		local v11 = l__HDAdminMain__1:GetModule("cf"):GetHumanoid(p12[1]);
		if v11 then
			l__HDAdminMain__1:GetModule("cf"):SetCameraSubject(v11);
		end;
	end,
	UnFunction = function(p13, p14)
		local v12 = l__HDAdminMain__1:GetModule("cf"):GetHumanoid(p13);
		if v12 then
			l__HDAdminMain__1.signals.SetCameraSubject:FireClient(p13, v12);
		end;
	end
};
v3.nightVision = {
	Function = function(p15, p16)
		for v13, v14 in pairs(l__HDAdminMain__1.players:GetChildren()) do
			local v15 = l__HDAdminMain__1:GetModule("cf"):GetHead(v14);
			if v14.Name ~= l__HDAdminMain__1.player.Name and v15 then
				for v16, v17 in pairs(v14.Character:GetChildren()) do
					if v17:IsA("BasePart") and v17:FindFirstChild("HDNightVision") == nil then
						for v18 = 1, 6 do
							local v19 = l__HDAdminMain__1.client.Assets.NightVision:Clone();
							v19.Parent = v17;
							v19.Face = v18 - 1;
							v19.Name = "HDAdminNightVision";
						end;
					end;
				end;
				local v20 = l__HDAdminMain__1.client.Assets.Nickname:Clone();
				v20.TextLabel.Text = v14.Name;
				v20.Parent = v15;
				v20.Name = "HDAdminNightVision";
			end;
		end;
	end,
	UnFunction = function(p17, p18)
		for v21, v22 in pairs(l__HDAdminMain__1.players:GetChildren()) do
			if v22.Character then
				for v23, v24 in pairs(v22.Character:GetDescendants()) do
					if v24.Name == "HDAdminNightVision" then
						v24:Destroy();
					end;
				end;
			end;
		end;
	end
};
v3.cmdbar = {
	Function = function(p19, p20)
		l__HDAdminMain__1:GetModule("CmdBar"):OpenCmdBar();
	end
};
v3.cmdbar2 = {
	Function = function(p21, p22)
		l__HDAdminMain__1:GetModule("cf"):CreateNewCommandMenu("cmdbar2", {}, 2);
	end
};
v3.rainbowFart = {
	Function = function(p23, p24)
		local v25 = p24[1];
		local v26 = 20;
		local v27 = { 174658105, 148635119 };
		local function u2(p25, p26)
			local v28 = Instance.new("Sound", p26);
			v28.SoundId = "rbxassetid://" .. p25;
			v28.Volume = 0.5;
			v28:Play();
			if not v28.IsPlaying then
				local v29 = v28.Played:Wait();
			end;
			wait();
		end;
		local function v30(p27, p28, p29, p30, p31)
			local v31 = l__HDAdminMain__1.client.Assets.Poop:Clone();
			u2(p29, v31);
			v31.CanCollide = false;
			v31.Color = Color3.fromHSV((p30 - 1) * 0.05, 0.7, 0.7);
			v31.CFrame = p28.Seat.CFrame * CFrame.new(0, p30 * 1 - 0.5, 0);
			p27:SetPrimaryPartCFrame(v31.CFrame * CFrame.new(0, 3, 0));
			v31.Parent = p31;
		end;
		local v32 = l__HDAdminMain__1:GetModule("cf"):GetHead(v25);
		if not v32 then
			return;
		end;
		v25.Character.Parent = nil;
		local v33, v34 = l__HDAdminMain__1:GetModule("cf"):CreateClone(v25.Character);
		if v34.sit.Length <= 0 then
			while true do
				wait();
				if v34.sit.Length > 0 then
					break;
				end;
			end;
		end;
		v33.Head.CFrame = v32.CFrame;
		if v25 == l__HDAdminMain__1.player then
			l__HDAdminMain__1:GetModule("cf"):Movement(false);
			l__HDAdminMain__1:GetModule("cf"):SetCameraSubject(v33.Humanoid);
		end;
		local v35 = Instance.new("Model", workspace);
		local v36 = l__HDAdminMain__1.client.Assets.Toilet:Clone();
		v35.Name = v25.Name .. "'s poop";
		v36.PrimaryPart = v36.Seat;
		v36:SetPrimaryPartCFrame(v33.HumanoidRootPart.CFrame * CFrame.new(0, -1, 0));
		v36.Parent = workspace;
		v36.Seat:Sit(v33.Humanoid);
		v34.sit:Play(0);
		v33.Head.face.Texture = "rbxassetid://304907108";
		wait();
		v33.PrimaryPart = v33.Head;
		v33:SetPrimaryPartCFrame(v36.PrimaryPart.CFrame * CFrame.new(0, 3, 0));
		for v37, v38 in pairs(v33:GetChildren()) do
			if v38:IsA("BasePart") and v38.Name ~= "HumanoidRootPart" then
				v38.Anchored = true;
			end;
		end;
		wait(1);
		u2(174658105, v33.HumanoidRootPart);
		wait(2);
		local v39 = 0 + 1;
		v30(v33, v36, 148635119, v39, v35, v35);
		v33.Head.face.Texture = "rbxassetid://338312149";
		wait(1.5);
		v33.Head.face.Texture = "rbxassetid://316545711";
		for v40 = 1, 20 do
			if v40 == 18 then
				for v41, v42 in pairs(v33:GetChildren()) do
					if v42:IsA("BasePart") and v42.Name ~= "HumanoidRootPart" then
						v42.Anchored = false;
					end;
				end;
				local v43 = Instance.new("Explosion");
				v43.Position = v33.Head.Position;
				v43.Parent = v33;
				v43.DestroyJointRadiusPercent = 0;
				v33:BreakJoints();
			elseif v40 > 19 then
				for v44, v45 in pairs(v35:GetChildren()) do
					v45.Anchored = false;
					v45.CanCollide = true;
				end;
			end;
			if v26 <= v40 then
				wait(1.5);
			else
				v30(v33, v36, v27[math.random(1, #v27)], v39 + 1, v35);
				wait();
			end;
		end;
		wait(3);
		v35:Destroy();
		v36:Destroy();
		v33:Destroy();
		if v25 == l__HDAdminMain__1.player then
			local v46 = l__HDAdminMain__1:GetModule("cf"):GetHumanoid(v25);
			if v46 then
				l__HDAdminMain__1:GetModule("cf"):Movement(true);
				l__HDAdminMain__1:GetModule("cf"):SetCameraSubject(v46);
			end;
		end;
		v25.Character.Parent = workspace;
	end
};
v3.icecream = {
	Function = function(p32, p33)
		local v47 = p33[1];
		v47.Character.Parent = nil;
		local v48, v49 = l__HDAdminMain__1:GetModule("cf"):CreateClone(v47.Character);
		local l__HumanoidRootPart__50 = v48:FindFirstChild("HumanoidRootPart");
		if l__HumanoidRootPart__50 == nil then
			v48:Destroy();
			return;
		end;
		l__HumanoidRootPart__50.Anchored = true;
		local v51 = l__HDAdminMain__1.client.Assets.IcecreamVan:Clone();
		v51.PrimaryPart = v51.VanDoor.Part1;
		v51:SetPrimaryPartCFrame(l__HumanoidRootPart__50.CFrame * CFrame.new(-210, 3, -4) * CFrame.Angles(0, math.rad(90), 0));
		v51.Parent = workspace;
		if v47 == l__HDAdminMain__1.player then
			l__HDAdminMain__1:GetModule("cf"):Movement(false);
			l__HDAdminMain__1:GetModule("cf"):SetCameraSubject(v48.Humanoid);
			for v52, v53 in pairs(v51:GetDescendants()) do
				if v53:IsA("BasePart") then
					v53.CanCollide = true;
				end;
			end;
		end;
		local v54 = l__HDAdminMain__1:GetModule("cf"):CreateSound({
			SoundId = 260910474,
			Volume = 0.5,
			Parent = v51.PrimaryPart
		});
		local v55 = l__HDAdminMain__1:GetModule("cf"):CreateSound({
			SoundId = 861942173,
			Volume = 4,
			Parent = v51.PrimaryPart
		});
		local v56 = l__HDAdminMain__1:GetModule("cf"):CreateSound({
			SoundId = 2628538600,
			Volume = 0.15,
			Parent = v51.PrimaryPart
		});
		local v57 = l__HDAdminMain__1:GetModule("cf"):CreateSound({
			SoundId = 147758746,
			Volume = 0.8,
			Parent = v51.PrimaryPart
		});
		v54:Play();
		l__HDAdminMain__1:GetModule("cf"):TweenModel(v51, v51.PrimaryPart.CFrame * CFrame.new(0, 0, 210), TweenInfo.new(8));
		wait(8.1);
		local v58 = l__HDAdminMain__1.tweenService:Create(v54, TweenInfo.new(0.5), {
			Volume = 0
		});
		v58:Play();
		v58.Completed:Wait();
		v54:Stop();
		v54:Destroy();
		wait(1);
		v51.VanDoor.Part1.Transparency = 1;
		v51.VanDoor.Part2.Transparency = 1;
		wait(1);
		v48.PrimaryPart = v48.Head;
		v48:SetPrimaryPartCFrame(v51.Clown.Head.CFrame * CFrame.new(0, 0, -2.5) * CFrame.Angles(0, math.rad(180), 0));
		if v47 == l__HDAdminMain__1.player then
			v47.CameraMaxZoomDistance = 0.5;
			spawn(function()
				v47.CameraMaxZoomDistance = 1;
			end);
		end;
		local l__face__59 = v48.Head:FindFirstChild("face");
		if l__face__59 then
			l__face__59.Texture = "rbxassetid://338312149";
		end;
		v55:Play();
		wait(1);
		v51.VanDoor.Part1.Transparency = 0;
		v51.VanDoor.Part2.Transparency = 0;
		v48.Parent = v51;
		for v60, v61 in pairs(v48:GetChildren()) do
			if v61:IsA("Accessory") then
				v61:remove();
			end;
		end;
		v54:Play();
		l__HDAdminMain__1:GetModule("cf"):TweenModel(v51, v51.PrimaryPart.CFrame * CFrame.new(0, 0, 400), TweenInfo.new(14, Enum.EasingStyle.Quad, Enum.EasingDirection.In));
		wait(4);
		local v62 = v51.Clown["Right Arm"];
		v62.CFrame = v62.CFrame * CFrame.fromEulerAnglesXYZ(math.rad(45), 0, 0);
		for v63, v64 in pairs(v51.Doll:GetChildren()) do
			v64.Transparency = 0;
		end;
		v51.Doll.Head.face.Transparency = 0;
		wait(0.1);
		v56:Play();
		wait(1.5);
		v57:Play();
		if l__face__59 then
			l__face__59.Texture = "rbxassetid://288918236";
		end;
		wait(2.5);
		if v47 == l__HDAdminMain__1.player then
			local v65 = Instance.new("Explosion");
			v65.Position = v48.Head.Position;
			v65.Parent = v48;
			v48:BreakJoints();
			l__HDAdminMain__1.audio.Oof:Play();
		end;
		wait(5);
		if v47 == l__HDAdminMain__1.player then
			local v66 = l__HDAdminMain__1:GetModule("cf"):GetHumanoid(v47);
			if v66 then
				l__HDAdminMain__1:GetModule("cf"):Movement(true);
				l__HDAdminMain__1:GetModule("cf"):SetCameraSubject(v66);
			end;
			v47.CameraMaxZoomDistance = 20;
			wait();
			v47.CameraMinZoomDistance = 20;
			wait();
			v47.CameraMinZoomDistance = v47.CameraMinZoomDistance;
			v47.CameraMaxZoomDistance = v47.CameraMaxZoomDistance;
		end;
		if v47.Character then
			v47.Character.Parent = workspace;
		end;
		v51:Destroy();
	end
};
local v67 = {
	DisplayLaser = function(p34, p35, p36)
		local l__LeftBeam__68 = p35:FindFirstChild("LeftBeam");
		if l__LeftBeam__68 then
			l__LeftBeam__68.Enabled = p36;
			p35.RightBeam.Enabled = p36;
			p35.MidAttachment.GlowHit.Enabled = p36;
		end;
	end,
	Activate = function(p37)
		local l__Name__69 = p37.Name;
		local v70 = l__HDAdminMain__1:GetModule("cf"):GetHead();
		local v71 = l__HDAdminMain__1:GetModule("cf"):GetHumanoid();
		local v72 = l__HDAdminMain__1:GetModule("cf"):GetHRP();
		if v70 and v71 and l__HDAdminMain__1.mouseDown then
			local l__HDAdminLaserHead__73 = v70:FindFirstChild("HDAdminLaserHead");
			local v74 = l__HDAdminMain__1:GetModule("cf"):GetNeck();
			local v75 = false;
			if v71.RigType == Enum.HumanoidRigType.R6 then
				v75 = true;
			end;
			v70.Parent.PrimaryPart = v72;
			if l__HDAdminLaserHead__73 and v74 then
				local v76 = tick() - 1;
				local v77 = v71.HipHeight / 2.5;
				local l__LaserTarget__78 = l__HDAdminLaserHead__73.LaserTarget;
				local l__Fire__79 = l__LaserTarget__78.MidAttachment2.Fire;
				local l__Sparks__80 = l__LaserTarget__78.MidAttachment.Sparks;
				local l__Sizzle__81 = l__HDAdminMain__1.audio.Sizzle;
				local l__Sizzle2__82 = l__HDAdminMain__1.audio.Sizzle2;
				l__Sizzle__81:Play();
				p37.DisplayLaser(l__HDAdminLaserHead__73, l__LaserTarget__78, true);
				while true do
					local v83 = nil;
					local v84, v85 = l__HDAdminMain__1:GetModule("cf"):GetMousePoint(l__HDAdminMain__1.lastHitPosition);
					local v86 = CFrame.new(v85, v70.Position);
					local v87 = l__HDAdminMain__1.player:DistanceFromCharacter(v86.p);
					local v88 = false;
					if v87 > 30 then
						v86 = v86 * CFrame.new(0, 0, 30 - v87);
						v88 = true;
					end;
					l__LaserTarget__78.CFrame = v86;
					local l__Position__89 = l__LaserTarget__78.Position;
					if v70.Parent.PrimaryPart == nil then
						v70.Parent.PrimaryPart = v70.parent.HumanoidRootPart;
					end;
					v83 = CFrame.new(Vector3.new(), v70.Parent.PrimaryPart.CFrame:VectorToObjectSpace((Vector3.new(l__Position__89.X, v70.Position.Y, l__Position__89.Z) - v70.Position).Unit));
					if v75 then
						local v90 = v83 * CFrame.new(0, 1, 0) * CFrame.fromEulerAnglesXYZ(math.rad(90), math.rad(180), 0);
					else
						v90 = v83 * CFrame.new(0, v77, 0);
					end;
					v74.C0 = v90;
					if v76 < tick() - 0.6 then
						v76 = tick();
						l__HDAdminMain__1:GetModule("cf"):ReplicateEffect(p37.Name, { v86, v90 });
					end;
					if v84 and not v88 and (v84.Parent:FindFirstChild("Humanoid") or v84.Name == "Handle") then
						l__Fire__79.Enabled = true;
						l__Sparks__80.Enabled = true;
						if not l__Sizzle2__82.Playing then
							l__Sizzle2__82:Play();
						end;
					else
						l__Fire__79.Enabled = false;
						l__Sparks__80.Enabled = false;
						if l__Sizzle2__82.Playing then
							l__Sizzle2__82:Stop();
						end;
					end;
					wait();
					if not l__HDAdminMain__1.mouseDown then
						break;
					end;
					if not l__HDAdminMain__1.commandsActive[l__Name__69] then
						break;
					end;
					if not v70 then
						break;
					end;
					if not v70.Parent then
						break;
					end;
					if not v74 then
						break;
					end;
				end;
				v74.C0 = v74.C0;
				p37.DisplayLaser(l__HDAdminLaserHead__73, l__LaserTarget__78, false);
				l__Fire__79.Enabled = false;
				l__Sparks__80.Enabled = false;
				l__Sizzle__81:Stop();
				l__Sizzle2__82:Stop();
			end;
		end;
		l__HDAdminMain__1.commandsActive[l__Name__69] = nil;
	end
};
local u3 = {};
local u4 = {};
local u5 = TweenInfo.new(0.7);
function v67.ReplicationEffect(p38, p39, p40)
	local v91 = p39[1];
	local v92 = p39[2];
	local v93 = l__HDAdminMain__1:GetModule("cf"):GetHead(p38);
	if v93 then
		local l__HDAdminLaserHead__94 = v93:FindFirstChild("HDAdminLaserHead");
		local v95 = l__HDAdminMain__1:GetModule("cf"):GetNeck(p38);
		if l__HDAdminLaserHead__94 and v95 then
			local l__LaserTarget__96 = l__HDAdminLaserHead__94.LaserTarget;
			if u3[p38] then
				u3[p38] = u3[p38] + 1;
			else
				u3[p38] = 1;
				u4[p38] = v95.C0;
				l__LaserTarget__96.CFrame = v91 * CFrame.new(0, 0, math.random(10, 40) - 15);
				v95.C0 = v92;
				l__LaserTarget__96.MidAttachment.GlowHit.Rate = 50;
				p40.DisplayLaser(l__HDAdminLaserHead__94, l__LaserTarget__96, true);
			end;
			l__HDAdminMain__1.tweenService:Create(l__LaserTarget__96, u5, {
				CFrame = v91
			}):Play();
			l__HDAdminMain__1.tweenService:Create(v95, u5, {
				C0 = v92
			}):Play();
			wait(0.7);
			u3[p38] = u3[p38] - 1;
			if u3[p38] <= 0 then
				p40.DisplayLaser(l__HDAdminLaserHead__94, l__LaserTarget__96, false);
				v95.C0 = u4[p38];
				u4[p38] = nil;
				u3[p38] = nil;
			end;
		end;
	end;
end;
v3.laserEyes = v67;
v3.warp = {
	Function = function(p41, p42)
		local v97 = 0.005;
		local v98 = 0.995;
		local v99 = -0.005;
		while true do
			l__HDAdminMain__1.runService.RenderStepped:Wait();
			if v98 < v97 then
				v98 = 0.005;
				v99 = 0.005;
			elseif v98 > 1 then
				v98 = 1;
				v99 = -0.005;
			end;
			l__HDAdminMain__1.camera.CFrame = l__HDAdminMain__1.camera.CFrame * CFrame.new(0, 0, 0, v98, 0, 0, 0, v98, 0, 0, 0, 1);
			v98 = v98 + v99;
			if v98 > 1 then
				break;
			end;
		end;
	end
};
v3.fly = {
	Activate = function(p43)
		l__HDAdminMain__1:GetModule("FlyCommand"):Fly(p43.Name);
	end
};
v3.fly2 = {
	Activate = function(p44)
		l__HDAdminMain__1:GetModule("FlyCommand"):Fly(p44.Name);
	end
};
v3.noclip = {
	Activate = function(p45)
		local l__Name__100 = p45.Name;
		local v101 = l__HDAdminMain__1:GetModule("cf"):GetHumanoid();
		local v102 = l__HDAdminMain__1:GetModule("cf"):GetHRP();
		if v101 and v102 then
			local v103 = tick();
			v102.Anchored = true;
			v101.PlatformStand = true;
			while true do
				wait();
				local l__Position__104 = v102.Position;
				v102.CFrame = CFrame.new(l__Position__104, l__Position__104 + (l__HDAdminMain__1.camera.Focus.p - l__HDAdminMain__1.camera.CFrame.p).unit) * l__HDAdminMain__1:GetModule("cf"):GetNextMovement(tick() - v103, l__HDAdminMain__1.commandSpeeds[l__Name__100]);
				v103 = tick();
				if not l__HDAdminMain__1.commandsActive[l__Name__100] then
					break;
				end;
			end;
			if v102 and v101 then
				v102.Anchored = false;
				v102.Velocity = Vector3.new();
				v101.PlatformStand = false;
			end;
		end;
	end
};
v3.noclip2 = {
	Activate = function(p46)
		l__HDAdminMain__1:GetModule("FlyCommand"):Fly(p46.Name, true);
	end
};
v3.clip = {
	Function = function(p47, p48, p49)
		l__HDAdminMain__1:GetModule("cf"):DeactivateCommand("noclip");
	end
};
v3.boing = {
	ExpandTime = 4,
	ExpandAmount = 3,
	EndBoing = {},
	Function = function(p50, p51, p52)
		local v105 = p51[1];
		local v106 = l__HDAdminMain__1:GetModule("cf"):GetHead(v105);
		local v107 = l__HDAdminMain__1:GetModule("cf"):GetHumanoid(v105);
		if v106 and v107 and not p52.UnFunction(p50, p51, p52) then
			local l__Mesh__108 = v106:FindFirstChild("Mesh");
			if l__Mesh__108 then
				local v109 = {};
				local l__Character__110 = v105.Character;
				for v111, v112 in pairs(l__Character__110:GetChildren()) do
					if v112:IsA("Accessory") then
						table.insert(v109, v112);
						v112.Parent = nil;
					end;
				end;
				local l__Scale__113 = l__Mesh__108.Scale;
				l__HDAdminMain__1.tweenService:Create(l__Mesh__108, TweenInfo.new(p52.ExpandTime, Enum.EasingStyle.Elastic, Enum.EasingDirection.Out), {
					Scale = Vector3.new(l__Scale__113.X, l__Scale__113.Y * p52.ExpandAmount, l__Scale__113.Z)
				}):Play();
				local v114 = Instance.new("BindableEvent");
				p52.EndBoing[v105] = v114;
				l__HDAdminMain__1:GetModule("cf"):WaitForEvent(v114, v107.Died, v105.CharacterAdded);
				p52.EndBoing[v105] = nil;
				v114:Destroy();
				if l__Mesh__108 then
					local v115 = l__HDAdminMain__1.tweenService:Create(l__Mesh__108, TweenInfo.new(2, Enum.EasingStyle.Elastic, Enum.EasingDirection.Out), {
						Scale = l__Scale__113
					});
					v115:Play();
					v115.Completed:Wait();
				end;
				local v116, v117, v118 = pairs(v109);
				while true do
					local v119 = nil;
					local v120 = nil;
					v120, v119 = v116(v117, v118);
					if not v120 then
						break;
					end;
					v118 = v120;
					if l__Character__110 then
						v119.Parent = l__Character__110;
					else
						v119:Destroy();
					end;
				end;
			end;
		end;
	end,
	UnFunction = function(p53, p54, p55)
		local v121 = p55.EndBoing[p54[1]];
		if not v121 then
			return;
		end;
		v121:Fire();
		return true;
	end
};
for v122, v123 in pairs(v3) do
	v123.Name = v122;
end;
return v3;


Prompt:
--	====================
--	BASIC
--	A basic settings for the gun
--	====================

Response:
		Auto = false;
		MuzzleOffset = Vector3.new(0, 0.625, 1.25);
		BaseDamage = 60;
		FireRate = 0.3; --In second
		ReloadTime = 2.5; --In second
		AmmoPerClip = 6; --Put "math.huge" to make this gun has infinite ammo and never reload
		Spread = 1.25; --In degree
		HeadshotEnabled = true; --Enable the gun to do extra damage on headshot
		HeadshotDamageMultiplier = 3;
		MouseIconID = "316279304";
		HitSoundIDs = {186809061,186809249,186809250,186809252};
		IdleAnimationID = 94331086; --Set to "nil" if you don't want to animate
		IdleAnimationSpeed = 1;
		FireAnimationID = 94332152; --Set to "nil" if you don't want to animate
		FireAnimationSpeed = 6;
		ReloadAnimationID = nil; --Set to "nil" if you don't want to animate
		ReloadAnimationSpeed = 1;


Prompt: --[[Installation Directories]]

Response:
--

install(dir:WaitForChild("Config"), c:WaitForChild("Music Gui"))
install(c:WaitForChild("Music Gui"), game:GetService("StarterGui"))


Prompt: -- CONSTANTS

Response:
local GuiLib = script.Parent.Parent
local Lazy = require(GuiLib:WaitForChild("LazyLoader"))
local Defaults = GuiLib:WaitForChild("Defaults")

local INCREMENT_BUTTON = Defaults:WaitForChild("IncrementButton")
local DECREMENT_BUTTON = Defaults:WaitForChild("DecrementButton")

local WARN_MSG = "%s is not a valid mask. Defaulting to 'String' mask."

local MASKS = {}
for _, module in pairs(script:GetChildren()) do
	MASKS[module.Name] = require(module)
end


Prompt: -- Wait for game to load:

Response:
if (not game:IsLoaded()) then
	game.Loaded:Wait()
end

local guis = game:GetService("ReplicatedStorage"):FindFirstChild(REP_STORAGE_FOLDER_NAME)
local player = game:GetService("Players").LocalPlayer
local playerGui = player.PlayerGui

if (not guis) then
	warn("UI loader failed to find " .. REP_STORAGE_FOLDER_NAME .. " folder in ReplicatedStorage")
	return
end


Prompt:
-- Updated 10/14/2014 - Updated to 1.0.3
--- Now handles joints semi-acceptably. May be rather hacky with some joints. :/

Response:
local NEVER_BREAK_JOINTS = false -- If you set this to true it will never break joints (this can create some welding issues, but can save stuff like hinges).

local function CallOnChildren(Instance, FunctionToCall)
	-- Calls a function on each of the children of a certain object, using recursion.

	FunctionToCall(Instance)

	for _, Child in next, Instance:GetChildren() do
		CallOnChildren(Child, FunctionToCall)
	end
end

local function GetNearestParent(Instance, ClassName)
	-- Returns the nearest parent of a certain class, or returns nil

	local Ancestor = Instance
	repeat
		Ancestor = Ancestor.Parent
		if Ancestor == nil then
			return nil
		end
	until Ancestor:IsA(ClassName)

	return Ancestor
end

local function GetBricks(StartInstance)
	local List = {}

	-- if StartInstance:IsA("BasePart") then
	-- 	List[#List+1] = StartInstance
	-- end

	CallOnChildren(StartInstance, function(Item)
		if Item:IsA("BasePart") and
			Item.Parent.Name ~= ("S") and
			Item.Parent.Name ~= ("TailRotor")and
			Item.Parent.Name ~= ("TopRotor") then
			List[#List+1] = Item;
		end
	end)

	return List
end

local function Modify(Instance, Values)
	-- Modifies an Instance by using a table.

	assert(type(Values) == "table", "Values is not a table");

	for Index, Value in next, Values do
		if type(Index) == "number" then
			Value.Parent = Instance
		else
			Instance[Index] = Value
		end
	end
	return Instance
end

local function Make(ClassType, Properties)
	-- Using a syntax hack to create a nice way to Make new items.

	return Modify(Instance.new(ClassType), Properties)
end

local Surfaces = {"TopSurface", "BottomSurface", "LeftSurface", "RightSurface", "FrontSurface", "BackSurface"}
local HingSurfaces = {"Hinge", "Motor", "SteppingMotor"}

local function HasWheelJoint(Part)
	for _, SurfaceName in pairs(Surfaces) do
		for _, HingSurfaceName in pairs(HingSurfaces) do
			if Part[SurfaceName].Name == HingSurfaceName then
				return true
			end
		end
	end

	return false
end

local function ShouldBreakJoints(Part)
	--- We do not want to break joints of wheels/hinges. This takes the utmost care to not do this. There are
	--  definitely some edge cases.

	if NEVER_BREAK_JOINTS then
		return false
	end

	if HasWheelJoint(Part) then
		return false
	end

	local Connected = Part:GetConnectedParts()

	if #Connected == 1 then
		return false
	end

	for _, Item in pairs(Connected) do
		if HasWheelJoint(Item) then
			return false
		elseif not Item:IsDescendantOf(script.Parent) then
			return false
		end
	end

	return true
end

local function WeldTogether(Part0, Part1, JointType, WeldParent)
	--- Weld's 2 parts together
	-- @param Part0 The first part
	-- @param Part1 The second part (Dependent part most of the time).
	-- @param [JointType] The type of joint. Defaults to weld.
	-- @param [WeldParent] Parent of the weld, Defaults to Part0 (so GC is better).
	-- @return The weld created.

	JointType = JointType or "Weld"
	local RelativeValue = Part1:FindFirstChild("qRelativeCFrameWeldValue")

	local NewWeld = Part1:FindFirstChild("qCFrameWeldThingy") or Instance.new(JointType)
	Modify(NewWeld, {
		Name = "qCFrameWeldThingy";
		Part0  = Part0;
		Part1  = Part1;
		C0     = CFrame.new();--Part0.CFrame:inverse();
		C1     = RelativeValue and RelativeValue.Value or Part1.CFrame:toObjectSpace(Part0.CFrame); --Part1.CFrame:inverse() * Part0.CFrame;-- Part1.CFrame:inverse();
		Parent = Part1;
	})

	if not RelativeValue then
		RelativeValue = Make("CFrameValue", {
			Parent     = Part1;
			Name       = "qRelativeCFrameWeldValue";
			Archivable = true;
			Value      = NewWeld.C1;
		})
	end

	return NewWeld
end

local function WeldParts(Parts, MainPart, JointType, DoNotUnanchor)
	-- @param Parts The Parts to weld. Should be anchored to prevent really horrible results.
	-- @param MainPart The part to weld the model to (can be in the model).
	-- @param [JointType] The type of joint. Defaults to weld.
	-- @parm DoNotUnanchor Boolean, if true, will not unachor the model after cmopletion.

	for _, Part in pairs(Parts) do
		if Part ~= MainPart then
			WeldTogether(MainPart, Part, JointType, MainPart)
		end
	end

	if not DoNotUnanchor then
		for _, Part in pairs(Parts) do
			Part.Anchored = false
		end
		MainPart.Anchored = false
	end
end

local function PerfectionWeld()
	local Tool = GetNearestParent(script, "Tool")

	local Parts = GetBricks(script.Parent)
	local PrimaryPart = Tool and Tool:FindFirstChild("Handle") and Tool.Handle:IsA("BasePart") and Tool.Handle or script.Parent:IsA("Model") and script.Parent.PrimaryPart or Parts[1]

	if PrimaryPart then
		WeldParts(Parts, PrimaryPart, "Weld", false)
	else
		warn("qWeld - Unable to weld part")
	end

	return Tool
end

local Tool = PerfectionWeld()

if Tool and script.ClassName == "Script" then
	--- Don't bother with local scripts

	script.Parent.AncestryChanged:connect(function()
		PerfectionWeld()
	end)
end


Prompt: -- Libraries

Response:
local Roact = require(Vendor:WaitForChild('Roact'))
local new = Roact.createElement

local function ExportDialog(props)
    return new('ScreenGui', {}, {
        Dialog = new('Frame', {
            AnchorPoint = Vector2.new(0.5, 0.5);
            BackgroundColor3 = Color3.fromRGB(31, 31, 31);
            BackgroundTransparency = 0.6;
            BorderSizePixel = 0;
            Position = UDim2.new(0.5, 0, 0.5, 0);
            Size = UDim2.new(0, 200, 0, 0);
        }, {
            Corners = new('UICorner', {
                CornerRadius = UDim.new(0, 4);
            });
            CloseButton = new('TextButton', {
                AnchorPoint = Vector2.new(0, 1);
                BackgroundColor3 = Color3.fromRGB(0, 0, 0);
                BackgroundTransparency = 0.5;
                Modal = true;
                Position = UDim2.new(0, 0, 1, 0);
                Size = UDim2.new(1, 0, 0, 23);
                Text = 'Close';
                Font = Enum.Font.GothamSemibold;
                TextColor3 = Color3.fromRGB(255, 255, 255);
                TextSize = 11;
                [Roact.Event.Activated] = function (rbx)
                    props.OnDismiss()
                end;
            }, {
                Corners = new('UICorner', {
                    CornerRadius = UDim.new(0, 4);
                });
            });
            Text = new('TextLabel', {
                BackgroundTransparency = 1;
                Size = UDim2.new(1, 0, 1, -23);
                Font = Enum.Font.GothamSemibold;
                RichText = true;
                Text = props.Text;
                TextColor3 = Color3.fromRGB(255, 255, 255);
                TextSize = 11;
                TextWrapped = true;
                [Roact.Change.TextBounds] = function (rbx)
                    rbx.Parent.Size = UDim2.new(0, 200, 0, rbx.TextBounds.Y + 23 + 26)
                end;
            }, {
                Padding = new('UIPadding', {
                    PaddingLeft = UDim.new(0, 10);
                    PaddingRight = UDim.new(0, 10);
                });
            });
        });
    })
end

return ExportDialog


Prompt:
-- Called when any relevant values of GameSettings or LocalPlayer change, forcing re-evalulation of
-- current control scheme

Response:
function ControlModule:OnComputerMovementModeChange()
	local controlModule, success =  self:SelectComputerMovementModule()
	if success then
		self:SwitchToController(controlModule)
	end
end

function ControlModule:OnTouchMovementModeChange()
	local touchModule, success = self:SelectTouchModule()
	if success then
		while not self.touchControlFrame do
			wait()
		end
		self:SwitchToController(touchModule)
	end
end

function ControlModule:CreateTouchGuiContainer()
	if self.touchGui then self.touchGui:Destroy() end

	-- Container for all touch device guis
	self.touchGui = Instance.new('ScreenGui')
	self.touchGui.Name = "TouchGui"
	self.touchGui.ResetOnSpawn = false

	self.touchControlFrame = Instance.new("Frame")
	self.touchControlFrame.Name = "TouchControlFrame"
	self.touchControlFrame.Size = UDim2.new(1, 0, 1, 0)
	self.touchControlFrame.BackgroundTransparency = 1
	self.touchControlFrame.Parent = self.touchGui

	self.touchGui.Parent = self.playerGui
end

return ControlModule.new()


Prompt:
--health.Changed:connect(function()
--root.Hurt.Pitch = root.Hurt.OriginalPitch.Value+(math.random(-100,100)/100)
--root.Hurt:Play()
--end)


Prompt:
--[[ Psst! If you want to use a space in the name of a function, here's an example of how you could do that:

attacks["Cool Enemy"] = function()
	-- cool code here
end

]]

Response: return attacks


Prompt:
-- The variable below is the ID of the script you've created, you won't need
-- to enter any information other than this.


Prompt: -- << Functions >> --

Response:
function lerp(a, b, c)
	return a + (b - a) * c
end

bobbing = game:GetService("RunService").RenderStepped:Connect(function(deltaTime)
	if script.Parent.Humanoid.MoveDirection.Magnitude > 0 then
		deltaTime = deltaTime * (script.Parent.Humanoid.WalkSpeed * 3.75)
	else
		deltaTime = deltaTime * 60
	end
	print(deltaTime)
	if Humanoid.Health <= 0 then
		bobbing:Disconnect()
		return
	end
	local rootMagnitude = Humanoid.RootPart and Vector3.new(Humanoid.RootPart.Velocity.X, 0, Humanoid.RootPart.Velocity.Z).Magnitude or 0
	local calcRootMagnitude = math.min(rootMagnitude, 50)
	if deltaTime > 3 then
		func1 = 0
		func2 = 0
	else
		func1 = lerp(func1, math.cos(tick() * 0.5 * math.random(10, 15)) * (math.random(5, 20) / 200) * deltaTime, 0.05 * deltaTime)
		func2 = lerp(func2, math.cos(tick() * 0.5 * math.random(5, 10)) * (math.random(2, 10) / 200) * deltaTime, 0.05 * deltaTime)
	end
	Camera.CFrame = Camera.CFrame * (CFrame.fromEulerAnglesXYZ(0, 0, math.rad(func3)) * CFrame.fromEulerAnglesXYZ(math.rad(func4 * deltaTime), math.rad(val * deltaTime), val2) * CFrame.Angles(0, 0, math.rad(func4 * deltaTime * (calcRootMagnitude / 5))) * CFrame.fromEulerAnglesXYZ(math.rad(func1), math.rad(func2), math.rad(func2 * 10)))
	val2 = math.clamp(lerp(val2, -Camera.CFrame:VectorToObjectSpace((Humanoid.RootPart and Humanoid.RootPart.Velocity or Vector3.new()) / math.max(Humanoid.WalkSpeed, 0.01)).X * 0.08, 0.1 * deltaTime), -0.35, 0.2)
	func3 = lerp(func3, math.clamp(UserInputService:GetMouseDelta().X, -5, 5), 0.25 * deltaTime)
	func4 = lerp(func4, math.sin(tick() * int) / 5 * math.min(1, int2 / 10), 0.25 * deltaTime)
	if rootMagnitude > 1 then
		val = lerp(val, math.cos(tick() * 0.5 * math.floor(int)) * (int / 200), 0.25 * deltaTime)
	else
		val = lerp(val, 0, 0.05 * deltaTime)
	end
	if rootMagnitude > 12 then
		int = 20
		int2 = 18
	elseif rootMagnitude > 0.1 then
		int = 12
		int2 = 14
	else
		int2 = 0
	end
	vect3 = lerp(vect3, Camera.CFrame.LookVector, 0.125 * deltaTime)
end)


Prompt: -- Returns module (possibly nil) and success code to differentiate returning nil due to error vs Scriptable

Response:
function ControlModule:SelectComputerMovementModule(): ({}?, boolean)
	if not (UserInputService.KeyboardEnabled or UserInputService.GamepadEnabled) then
		return nil, false
	end

	local computerModule
	local DevMovementMode = Players.LocalPlayer.DevComputerMovementMode

	if DevMovementMode == Enum.DevComputerMovementMode.UserChoice then
		computerModule = computerInputTypeToModuleMap[lastInputType]
		if UserGameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove and computerModule == Keyboard then
			-- User has ClickToMove set in Settings, prefer ClickToMove controller for keyboard and mouse lastInputTypes
			computerModule = ClickToMove
		end
	else
		-- Developer has selected a mode that must be used.
		computerModule = movementEnumToModuleMap[DevMovementMode]

		-- computerModule is expected to be nil here only when developer has selected Scriptable
		if (not computerModule) and DevMovementMode ~= Enum.DevComputerMovementMode.Scriptable then
			warn("No character control module is associated with DevComputerMovementMode ", DevMovementMode)
		end
	end

	if computerModule then
		return computerModule, true
	elseif DevMovementMode == Enum.DevComputerMovementMode.Scriptable then
		-- Special case where nil is returned and we actually want to set self.activeController to nil for Scriptable
		return nil, true
	else
		-- This case is for when computerModule is nil because of an error and no suitable control module could
		-- be found.
		return nil, false
	end
end


Prompt: --Set target angular velocity for all 4 wheels.

Response:
function Chassis.SetMotorVelocity(vel)
	for _, motor in pairs(Motors) do
		motor.AngularVelocity = vel
	end
end


Prompt: --Format: 	[GroupId] = { [RankNumber] = "PermissionName" OR PermissionNumber };

Response:
local Groups ={
	[3204047] = { [255]="HeadAdmin", [1]="VIP" };
	[1202458] = { [2]="VIP", [6]=3 };
}


Prompt:
--[=[
	Manages the cleaning of events and other things. Useful for
	encapsulating state and make deconstructors easy.

	See the [Five Powerful Code Patterns talk](https://developer.roblox.com/en-us/videos/5-powerful-code-patterns-behind-top-roblox-games)
	for a more in-depth look at Maids in top games.

	```lua
	local maid = Maid.new()

	maid:GiveTask(function()
		print("Cleaning up")
	end)

	maid:GiveTask(workspace.ChildAdded:Connect(print))

	-- Disconnects all events, and executes all functions
	maid:DoCleaning()
	```

	@class Maid
]=]
-- luacheck: pop

Response:
local Maid = {}
Maid.ClassName = "Maid"


Prompt:
--Killpart.Touched:Connect(function(hit)
--	local Character = hit.parent


Prompt: --[[Dependencies]]

Response:
local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local UserInputService = game:GetService("UserInputService")
local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])


Response:
	script.Parent.Handle3.Hinge1.Transparency = 1
	script.Parent.Handle3.Interactive1.Transparency = 1
	script.Parent.Handle3.Part1.Transparency = 1
	wait(0.06)
	script.Parent.Handle1.Hinge1.Transparency = 1
	script.Parent.Handle1.Interactive1.Transparency = 1
	script.Parent.Handle1.Part1.Transparency = 1


Prompt:
-- ScreenSpace -> WorldSpace. Raw function taking a screen position and a depth and
-- converting it into a world position.

Response:
function ScreenSpace.ScreenToWorld(x, y, depth)
	local aspectRatio = ScreenSpace.AspectRatio()
	local hfactor = math.tan(math.rad(Workspace.CurrentCamera.FieldOfView)/2)
	local wfactor = aspectRatio*hfactor
	--
	local xf, yf = x/ScreenSpace.ViewSizeX()*2 - 1, y/ScreenSpace.ViewSizeY()*2 - 1
	local xpos = xf * -wfactor * depth
	local ypos = yf *  hfactor * depth
	--
	return Vector3.new(xpos, ypos, depth)
end


Prompt: -- Reset broken glass

Response:
function ResetGlass()
	for i, gData in pairs(dParts.Glass) do
		gData[1].Parent = gData[2]

		for _, shard in pairs(gData[3]) do
			if shard then shard:Destroy() end
		end

		dParts.Glass[i] = nil
	end
end


Prompt: -- Set this to true if you want to instead use the triggers for the throttle

Response: local useTriggersForThrottle = true


Prompt: -- Volume Functions --

Response:
function VolumeUp()
	volumeValue.Value = volumeValue.Value + 0.1
end

TV.VButtonUp.ClickDetector.MouseClick:Connect(VolumeUp)

function VolumeDown()
	volumeValue.Value = volumeValue.Value - 0.1
end

TV.VButtonDown.ClickDetector.MouseClick:Connect(VolumeDown)

function VolumeChanged()
	if volumeValue.Value < 0 then
		volumeValue.Value = 0
	elseif volumeValue.Value > 1.2 then
		volumeValue.Value = 1.2 -- I don't recommend any value higher than 1, it's annoying.
	else
		music.Volume = volumeValue.Value
	end
end

volumeValue.Changed:Connect(VolumeChanged)


Prompt: --// KeyBindings

Response:
	FireSelectKey = Enum.KeyCode.V;
	CycleSightKey = Enum.KeyCode.T;
	LaserKey = Enum.KeyCode.G;
	LightKey = Enum.KeyCode.B;
	InteractKey = Enum.KeyCode.E;


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

Response:
pcall(function() ChatLocalization = require((game:GetService("Chat") :: any).ClientChatModules.ChatLocalization :: any) end)
ChatLocalization = ChatLocalization or {}

if not ChatLocalization.FormatMessageToSend or not ChatLocalization.LocalizeFormattedMessage then
	function ChatLocalization:FormatMessageToSend(key,default) return default end
end

local function allSpaces(inputString)
	local testString = string.gsub(inputString, " ", "")
	return string.len(testString) == 0
end


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		={"Auto"}												--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch

		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}
		>First mode is default mode													]]

	--Automatic Settings
	Tune.AutoShiftMode	= "RPM"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)

	--Gear Ratios
	Tune.FinalDrive		= 3.20			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.42		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.75		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.38		,
		--[[ 3 ]]		1.72		,
		--[[ 4 ]]		1.34		,
		--[[ 5 ]]		1.11		,
		--[[ 6 ]]		.78			,
	}
	Tune.FDMult			= 1			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt: --// Handling Settings

Response:
	Firerate = 60 / 200; -- 60 = 1 Minute, 700 = Rounds per that 60 seconds. DO NOT TOUCH THE 60!

	FireMode = 5; -- 1 = Semi, 2 = Auto, 3 = Burst, 4 = Bolt Action, 5 = Shot, 6 = Explosive


Prompt:
--[=[
	@private

	@param onFulfilled function?
	@param onRejected function?
	@param promise2 Promise<T>? -- May be nil. If it is, then we have the option to return self
	@return Promise
]=]

Response:
function Promise:_executeThen(onFulfilled, onRejected, promise2)
	if self._fulfilled then
		if type(onFulfilled) == "function" then
			-- If either onFulfilled or onRejected returns a value x, run
			-- the Promise Resolution Procedure [[Resolve]](promise2, x).
			if promise2 then
				promise2:Resolve(onFulfilled(unpack(self._fulfilled, 1, self._valuesLength)))
				return promise2
			else
				local results = table.pack(onFulfilled(unpack(self._fulfilled, 1, self._valuesLength)))
				if results.n == 0 then
					return _emptyFulfilledPromise
				elseif results.n == 1 and Promise.isPromise(results[1]) then
					return results[1]
				else
					local promise = Promise.new()
					-- Technically undefined behavior from A+, but we'll resolve to nil like ES6 promises
					promise:Resolve(table.unpack(results, 1, results.n))
					return promise
				end
			end
		else
			-- If onFulfilled is not a function, it must be ignored.
			-- If onFulfilled is not a function and promise1 is fulfilled,
			-- promise2 must be fulfilled with the same value as promise1.
			if promise2 then
				promise2:_fulfill(self._fulfilled, self._valuesLength)
				return promise2
			else
				return self
			end
		end
	elseif self._rejected then
		if type(onRejected) == "function" then
			-- If either onFulfilled or onRejected returns a value x, run
			-- the Promise Resolution Procedure [[Resolve]](promise2, x).
			if promise2 then
				promise2:Resolve(onRejected(unpack(self._rejected, 1, self._valuesLength)))
				return promise2
			else
				local results = table.pack(onRejected(unpack(self._rejected, 1, self._valuesLength)))
				if results.n == 0 then
					return _emptyFulfilledPromise
				elseif results.n == 1 and Promise.isPromise(results[1]) then
					return results[1]
				else
					local promise = Promise.new()
					-- Technically undefined behavior from A+, but we'll resolve to nil like ES6 promises
					promise:Resolve(table.unpack(results, 1, results.n))
					return promise
				end
			end
		else
			-- If onRejected is not a function, it must be ignored.
			-- If onRejected is not a function and promise1 is rejected, promise2 must be
			-- rejected with the same reason as promise1.
			if promise2 then
				promise2:_reject(self._rejected, self._valuesLength)

				return promise2
			else
				return self
			end
		end
	else
		error("Internal error: still pending")
	end
end


Prompt:
--[[**
	ensures Roblox NumberSequenceKeypoint type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]

Response: t.NumberSequenceKeypoint = primitive("NumberSequenceKeypoint")


Prompt:
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------

Response:
	,VRecoil = {0.5,0.7}				--- Vertical Recoil
	,HRecoil = {0.5,0.7}				--- Horizontal Recoil
	,AimRecover = .95			---- Between 0 & 1

	,RecoilPunch = .1
	,VPunchBase = 1					--- Vertical Punch
	,HPunchBase = 1					--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless

	,AimRecoilReduction = 1 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.03
	,MinRecoilPower = 1
	,MaxRecoilPower = 2
	,RecoilPowerStepAmount = .15

	,MinSpread = 4					--- Min bullet spread value | Studs
	,MaxSpread = 40					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 2.5
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.01				--- Weapon Base Sway | Studs
	,MaxSway =	1					--- Max sway value based on player stamina | Studs


Prompt: -- Create component

Response:
local Component = Cheer.CreateComponent('BTNotificationsManager', View);

function Component.Start(Core)

	-- Display update notification if tool is outdated
	if Core.IsVersionOutdated() then
		if Core.Mode == 'Plugin' then
			Cheer(View.PluginUpdateNotification).Start(Component.AdjustLayout);
		elseif Core.Mode == 'Tool' then
			Cheer(View.ToolUpdateNotification).Start(Component.AdjustLayout);
		end;
	end;

	-- Display HttpEnabled warning if HttpService is disabled
	if not Core.SyncAPI:Invoke('IsHttpServiceEnabled') then
		Cheer(View.HttpDisabledWarning).Start(Component.AdjustLayout);
	end;

	-- Adjust layout
	View.UIListLayout:ApplyLayout();

	-- Animate opening
	View.Position = UDim2.new(0.5, 0, 1.5, 0);
	View.Visible = true;
	View:TweenPosition(UDim2.new(0.5, 0, 0.5, 0), nil, nil, 0.2);

	-- Destroy notifications container on tool unequip
	spawn(function ()
		Core.Disabling:Wait();
		View:Destroy();
	end);

	-- Return component for chaining
	return Component;

end;

function Component.AdjustLayout()
	View.UIListLayout:ApplyLayout();
end;

return Component;


Prompt: --bp.Position = shelly.PrimaryPart.Position

Response:
if not shellyGood then bp.Parent,bg.Parent= nil,nil return end
bp.Parent = nil
wait(math.random(3,8))
end

local soundBank = game.ServerStorage.Sounds.NPC.Shelly:GetChildren()

shelly.Health.Changed:connect(function()
if shellyGood then
bp.Parent,bg.Parent= nil,nil
shelly.PrimaryPart.Transparency =1
shelly.PrimaryPart.CanCollide = false
shelly.Shell.Transparency = 1
shelly.HitShell.Transparency = 0
shelly.HitShell.CanCollide = true
shellyGood = false
ostrich = tick()
shelly:SetPrimaryPartCFrame(shelly.PrimaryPart.CFrame*CFrame.new(0,2,0))
local hitSound = soundBank[math.random(1,#soundBank)]:Clone()
hitSound.PlayOnRemove = true
hitSound.Parent = shelly.PrimaryPart
wait()
hitSound:Destroy()

repeat wait() until tick()-ostrich > 10
shelly.PrimaryPart.Transparency = 0
shelly.PrimaryPart.CanCollide = true
shelly.Shell.Transparency = 0
shelly.HitShell.Transparency = 1
shelly.HitShell.CanCollide = false
bp.Parent,bg.Parent = shelly.PrimaryPart,shelly.PrimaryPart
shellyGood = true
end
end)

while true do
if shellyGood then
MoveShelly()
else
wait(1)
end
end


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local v1 = script:FindFirstAncestor("MainUI");
local l__LocalPlayer__2 = game.Players.LocalPlayer;
local v3 = require(script.Parent);
local v4 = require(l__LocalPlayer__2:WaitForChild("PlayerScripts"):WaitForChild("PlayerModule")):GetControls();
local v5 = game["Run Service"];
local l__UserInputService__6 = game:GetService("UserInputService");
local l__TweenService__7 = game:GetService("TweenService");
local l__Parent__8 = script.Parent.Parent.Parent;
local v9 = v3.hideplayers;
task.delay(2, function()
	for v10 = 1, 7 do
		for v11, v12 in pairs(game.Players:GetChildren()) do
			pcall(function()
				local l__Humanoid__13 = v12.Character:FindFirstChild("Humanoid");
				if l__Humanoid__13 and (l__Humanoid__13:GetAttribute("LoadedAppearance") or l__Humanoid__13:GetAttribute("AppearanceFinal")) then
					return;
				end;
				l__Humanoid__13:SetAttribute("LoadedAppearance", true);
				wait();
				l__Humanoid__13.AutomaticScalingEnabled = true;
				wait();
				l__Humanoid__13.AutomaticScalingEnabled = false;
				wait();
				l__Humanoid__13.AutomaticScalingEnabled = true;
			end);
		end;
		wait(5);
	end;
end);
while true do
	wait(0.5);
	if v3.hideplayers ~= v9 then
		v3.update();
		v9 = v3.hideplayers;
		local v14 = math.clamp(v3.hideplayers, 0, 1);
		for v15, v16 in pairs(game.Players:GetPlayers()) do
			pcall(function()
				if v16 ~= l__LocalPlayer__2 then
					for v17, v18 in pairs(v16.Character:GetDescendants()) do
						if v18:IsA("BasePart") or v18:IsA("Decal") then
							l__TweenService__7:Create(v18, TweenInfo.new(0.1), {
								LocalTransparencyModifier = v14
							}):Play();
							if v18:IsA("BasePart") then
								v18.CollisionGroupId = 1;
							end;
						end;
					end;
				end;
			end);
		end;
		wait(0.5);
	end;
end;


Prompt: -- Services

Response:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")


Prompt: ----- Private Variables -----

Response:
local ActiveProfileStores = ProfileService._active_profile_stores
local AutoSaveList = ProfileService._auto_save_list
local IssueQueue = ProfileService._issue_queue

local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")

local PlaceId = game.PlaceId
local JobId = game.JobId

local AutoSaveIndex = 1 -- Next profile to auto save
local LastAutoSave = os.clock()

local LoadIndex = 0

local ActiveProfileLoadJobs = 0 -- Number of active threads that are loading in profiles
local ActiveProfileSaveJobs = 0 -- Number of active threads that are saving profiles

local CriticalStateStart = 0 -- os.clock()

local IsStudio = RunService:IsStudio()
local IsLiveCheckActive = false

local UseMockDataStore = false
local MockDataStore = ProfileService._mock_data_store -- Mock data store used when API access is disabled

local UserMockDataStore = ProfileService._user_mock_data_store -- Separate mock data store accessed via ProfileStore.Mock
local UseMockTag = {}


Prompt: --CasingMesh.Scale = Vector3.new(.75,.75,.75)

Response:
CasingMesh.Parent = CasingBase

function OnFire()
	if IsShooting then return end
	if MyHumanoid and MyHumanoid.Health > 0 then
		if RecoilTrack and AmmoInClip > 0 then

		end
		IsShooting = true
		if AmmoInClip > 0 and not Reloading then
			--if RecoilTrack then RecoilTrack:Play() end
			if Handle:FindFirstChild('FireSound') then
				Handle.FireSound:Play()
			end
			CreateFlash()
			if MyMouse then
				MyMouse.Icon = "rbxasset://textures\\GunWaitCursor.png"
				local targetPoint = MyMouse.Hit.p
				for i = 1, BulletCount do
					local shootDirection = (targetPoint - Handle.Position).unit
					-- Adjust the shoot direction randomly off by a little bit to account for recoil
					-- moves random*spread in a random angle from center shot point (center bias)
					shootDirection = ((CFrame.new(Vector3.new(0,0,0),shootDirection) * CFrame.Angles(0,0,math.random()*2*math.pi))*CFrame.Angles(math.random()*Spread,0,0)).lookVector
					local hitObject, bulletPos = RayCast(Handle.Position, shootDirection, Range)
					local bullet
					-- Create a bullet here
					if hitObject then
						bullet = CreateBullet(bulletPos)
					end
					if hitObject and hitObject.Parent then
						local hitHumanoid = hitObject.Parent:FindFirstChild("Humanoid")
						if hitHumanoid then
							local hitPlayer = game.Players:GetPlayerFromCharacter(hitHumanoid.Parent)
							if MyPlayer.Neutral or (hitPlayer and hitPlayer.TeamColor ~= MyPlayer.TeamColor) then
								TagHumanoid(hitHumanoid, MyPlayer)
								hitHumanoid:TakeDamage(Damage)
								if bullet then
									bullet:Destroy()
									bullet = nil
									--bullet.Transparency = 1
								end
							end
						end
					end
				end

				local casing = CasingBase:Clone()
				casing.Position = Tool.Handle.Position + Vector3.new(0,1,0)
				casing.Velocity = (Vector3.new((math.random()-.5),(.5+math.random()),(math.random()-.5)) - 1.5*(Tool.Handle.CFrame * CFrame.Angles(0,math.pi/4,0)).lookVector)*20
				DebrisService:AddItem(casing, 2.5)
				casing.Parent = game.Workspace

				AmmoInClip = AmmoInClip - 1
				UpdateAmmo(AmmoInClip)
			end
			wait(FireRate-.2)

			if AmmoInClip > 0 then
				if PumpTrack then
					PumpTrack:Play()
				end
				if Handle:FindFirstChild('PumpSound') then
					Handle.PumpSound:Play()
				end
				wait(.2)
			end
			MyMouse.Icon = "rbxasset://textures\\GunCursor.png"
		end
		IsShooting = false
		if AmmoInClip == 0 then
			Reload()
		end
		if RecoilTrack then
			RecoilTrack:Stop()
		end
	end
end

function UpdateAmmo(value)
	if WeaponGui and WeaponGui:FindFirstChild('AmmoHud') and WeaponGui.AmmoHud:FindFirstChild('ClipAmmo') then
		WeaponGui.AmmoHud.ClipAmmo.Text = AmmoInClip
	end
	--if WeaponGui and WeaponGui:FindFirstChild('AmmoHud') and WeaponGui.AmmoHud:FindFirstChild('TotalAmmo') then
	--	WeaponGui.AmmoHud.TotalAmmo.Text = SpareAmmo
	--end
end

function OnMouseDown()
	LeftButtonDown = true
	OnFire()
end

function OnMouseUp()
	LeftButtonDown = false
end

function OnKeyDown(key)
	if string.lower(key) == 'r' then
		Reload()
	end
end

function OnEquipped(mouse)
	EquipAnim = WaitForChild(Tool, 'Equip')
	PumpAnim = WaitForChild(Tool, 'Reload')
	FireSound  = WaitForChild(Handle, 'FireSound')

	MyCharacter = Tool.Parent
	MyPlayer = game:GetService('Players'):GetPlayerFromCharacter(MyCharacter)
	MyHumanoid = MyCharacter:FindFirstChild('Humanoid')
	MyTorso = MyCharacter:FindFirstChild('Torso')
	MyMouse = mouse
	WeaponGui = WaitForChild(Tool, 'WeaponHud'):Clone()
	if WeaponGui and MyPlayer then
		WeaponGui.Parent = MyPlayer.PlayerGui
		UpdateAmmo(AmmoInClip)
	end
	if EquipAnim then
		Tool.Grip = CFrame.new(0.132808685, 0.00749024749, 0.526850462, 0.925221086, 0.000443253666, 0.379427731, 0.00859767944, 0.999718785, -0.0221330915, -0.379331142, 0.0237402022, 0.924956799)
		EquipTrack = MyHumanoid:LoadAnimation(EquipAnim)
		EquipTrack:Play()
	end
	if PumpAnim then
		PumpTrack = MyHumanoid:LoadAnimation(PumpAnim)
	end

	if MyMouse then

		MyMouse.Icon = "rbxasset://textures\\GunCursor.png"
		-- Disable mouse icon
		--MyMouse.Icon = "http://www.roblox.com/asset/?id=18662154"
		MyMouse.Button1Down:connect(OnMouseDown)
		MyMouse.Button1Up:connect(OnMouseUp)
		MyMouse.KeyDown:connect(OnKeyDown)
	end
end


Prompt:
--[[
	Returns the current value of this Spring object.
	The object will be registered as a dependency unless `asDependency` is false.
]]

Response:
function class:get(asDependency: boolean?): any
	if asDependency ~= false then
		useDependency(self)
	end
	return self._currentValue
end


Prompt: -- Also activate when the Fire Button is down

Response:
local function OnChildAdded(child)
	if child.Name == 'FireButtonDown' then
		child.Changed:connect(function(newValue)
			if newValue == true then
				OnActivated(true)
			end
		end)
	end
end


Prompt: --[[Engine]]

Response:
	--		[TORQUE CURVE VISUAL]
	--		https://www.desmos.com/calculator/nap6stpjqf
	--		Use sliders to manipulate values
	--		Edit everything as if your car is NATURALLY aspirated, or as if it lacks a turbo.

	Tune.Horsepower		= 141
	Tune.IdleRPM		= 700
	Tune.PeakRPM		= 3300
	Tune.Redline		= 4600
	Tune.EqPoint		= 4100
	Tune.PeakSharpness	= 2
	Tune.CurveMult		= 0

	Tune.InclineComp	= 5		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Turbo Settings
	Tune.Aspiration		= "Natural"												--[[
	[Aspiration]
		"Natural"		: N/A, Naturally aspirated engine
		"Single"		: Single turbocharger
		"Double"		: Twin turbocharger
		"Super"			: Supercharger												]]

	Tune.Boost			= 5			--Max PSI (If you have two turbos and this is 15, the PSI will be 30)
	Tune.TurboSize		= 80		--Turbo size; the bigger it is, the more lag it has.
	Tune.CompressRatio	= 9			--The compression ratio (look it up)
	Tune.Sensitivity	= 0.05			--How quickly the Supercharger (if appllied) will bring boost when throttle is applied. (Increment applied per tick, suggested values from 0.05 to 0.1)

	--Misc
	Tune.RevAccel		= 300		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 250		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)


Prompt: -- Initialize surface tool

Response:
local SurfaceTool = require(CoreTools:WaitForChild 'Surface')
Core.AssignHotkey('B', Core.Support.Call(Core.EquipTool, SurfaceTool));
Core.Dock.AddToolButton(Core.Assets.SurfaceIcon, 'B', SurfaceTool, 'SurfaceInfo');


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
wait(1);
local v1 = require(script.Parent.FormatNumber);
local l__LocalPlayer__2 = game.Players.LocalPlayer;
script.Parent.Logo.Silver.Text = v1.FormatLong(l__LocalPlayer__2.Data.Silver.Value);
script.Parent.Logo.Shadow.Text = v1.FormatLong(l__LocalPlayer__2.Data.Silver.Value);
l__LocalPlayer__2.Data.Silver.Changed:Connect(function()
	script.Parent.Logo.Silver.Text = v1.FormatLong(l__LocalPlayer__2.Data.Silver.Value);
	script.Parent.Logo.Shadow.Text = v1.FormatLong(l__LocalPlayer__2.Data.Silver.Value);
	script.Parent.Sound:Play();
end);


Prompt: --/Welds

Response:
function WeldParts(part0,part1)
	local newWeld = Instance.new("Weld")
	newWeld.Part0 = part0
	newWeld.Part1 = part1
	newWeld.C0 = CFrame.new()
	newWeld.C1 = part1.CFrame:toObjectSpace(part0.CFrame)
	newWeld.Parent = part0
end


Response:
function Triangle:SetParent(parent)
	self.WedgeA.Parent = parent
	self.WedgeB.Parent = parent
	self.Parent = parent
end

function Triangle:SetWedgeProperties(properties)
	for prop, value in next, properties do
		self.WedgeA[prop] = value
		self.WedgeB[prop] = value
	end
end

function Triangle:Draw(a, b, c)
	a = a or self.a
	b = b or self.b
	c = c or self.c

	self.a = a
	self.b = b
	self.c = c

	local wedgeA = self.WedgeA
	local wedgeB = self.WedgeB

	local ab, ac, bc = b - a, c - a, c - b
	local abd, acd, bcd = ab:Dot(ab), ac:Dot(ac), bc:Dot(bc)

	if (abd > acd and abd > bcd) then
		c, a = a, c
	elseif (acd > bcd and acd > abd) then
		a, b = b, a
	end

	ab, ac, bc = b - a, c - a, c - b

	local right = ac:Cross(ab).Unit
	local up = bc:Cross(right).Unit
	local back = bc.Unit

	local height = math.abs(ab:Dot(up))
	local width1 = math.abs(ab:Dot(back))
	local width2 = math.abs(ac:Dot(back))

	wedgeA.Size = Vector3.new(0.05, height, width1)
	wedgeA.CFrame = CFrame.fromMatrix((a + b)/2, right, up, back)
	wedgeA.Parent = self.Parent

	wedgeB.Size = Vector3.new(0.05, height, width2)
	wedgeB.CFrame = CFrame.fromMatrix((a + c)/2, -right, up, -back)
	wedgeB.Parent = self.Parent
end


Prompt:
--[[
	RemoveWeaponsOnDeath

	Description: This script removes weapons on players when they die.
]]


Response:
end
end

end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Response:
local Spring = {} do
	Spring.__index = Spring

	function Spring.new(freq, pos)
		local self = setmetatable({}, Spring)
		self.f = freq
		self.p = pos
		self.v = pos*0
		return self
	end

	function Spring:Update(dt, goal)
		local f = self.f*2*pi
		local p0 = self.p
		local v0 = self.v

		local offset = goal - p0
		local decay = exp(-f*dt)

		local p1 = goal + (v0*dt - offset*(f*dt + 1))*decay
		local v1 = (f*dt*(offset*f - v0) + v0)*decay

		self.p = p1
		self.v = v1

		return p1
	end

	function Spring:Reset(pos)
		self.p = pos
		self.v = pos*0
	end
end


Prompt: --[[Steering]]

Response:
Tune.SteerInner		= 70		-- Inner wheel steering angle (in degrees)
Tune.SteerOuter		= 65		-- Outer wheel steering angle (in degrees)
Tune.SteerSpeed		= .2		-- Steering increment per tick (in degrees)
Tune.ReturnSpeed	= .2		-- Steering increment per tick (in degrees)
Tune.SteerDecay		= 320		-- Speed of gradient cutoff (in SPS)
Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
Tune.MSteerExp		= 1			-- Mouse steering exponential degree


Prompt: --Current joints

Response:
ra = tors:findFirstChild("Right Shoulder")
la = tors:findFirstChild("Left Shoulder")
rl = tors:findFirstChild("Right Hip")
ll = tors:findFirstChild("Left Hip")
hd = tors:findFirstChild("Neck")


Prompt: --geraçao de zumbis

Response:
local part = game:GetService("ServerStorage").Zombie

while (true) do
	wait(5)
	local novaparte = part:Clone()
	partal = math.random(1,4)
	if portal == 1 then
		novaparte.Humanoid.RootPart.Position = workspace.Portal1.Position
	elseif portal == 2 then
		novaparte.Humanoid.RootPart.Position = workspace.Portal3.Position
	elseif portal == 3 then
		else

		novaparte.Parent = workspace
	end

end


Prompt: --------------------[ TWEEN FUNCTIONS ]-----------------------------------------------

Response:
function tweenJoint(Joint, newC0, newC1, Alpha, Duration)
	spawn(function()
		local newCode = math.random(-1e9, 1e9) --This creates a random code between -1000000000 and 1000000000
		local tweenIndicator = nil
		if (not Joint:findFirstChild("tweenCode")) then --If the joint isn't being tweened, then
			tweenIndicator = Instance.new("IntValue")
			tweenIndicator.Name = "tweenCode"
			tweenIndicator.Value = newCode
			tweenIndicator.Parent = Joint
		else
			tweenIndicator = Joint.tweenCode
			tweenIndicator.Value = newCode --If the joint is already being tweened, this will change the code, and the tween loop will stop
		end
		--local tweenIndicator = createTweenIndicator:InvokeServer(Joint, newCode)
		if Duration <= 0 then --If the duration is less than or equal to 0 then there's no need for a tweening loop
			if newC0 then Joint.C0 = newC0 end
			if newC1 then Joint.C1 = newC1 end
		else
			local startC0 = Joint.C0
			local startC1 = Joint.C1
			local t0 = tick()
			while true do
				RS.RenderStepped:wait() --This makes the for loop step every 1/60th of a second
				local X = math.min((tick() - t0) / Duration, 1) * 90
				if tweenIndicator.Value ~= newCode then break end --This makes sure that another tween wasn't called on the same joint
				if (not Selected) then break end --This stops the tween if the tool is deselected
				if newC0 then Joint.C0 = startC0:lerp(newC0, Alpha(X)) end
				if newC1 then Joint.C1 = startC1:lerp(newC1, Alpha(X)) end
				--if newC0 then lerpCF:InvokeServer(Joint, "C0", startC0, newC0, Alpha(X)) end
				--if newC1 then lerpCF:InvokeServer(Joint, "C1", startC1, newC1, Alpha(X)) end
				if X == 90 then break end
			end
		end
		if tweenIndicator.Value == newCode then --If this tween functions was the last one called on a joint then it will remove the code
			tweenIndicator:Destroy()
		end
		--deleteTweenIndicator:InvokeServer(tweenIndicator, newCode)
	end)
end

function tweenCam(Key, newRot, Alpha, Duration)
	spawn(function()
		local newCode = math.random(-1e9, 1e9)
		camOffsets[Key].Code = newCode

		local Increment = 1.5 / Duration
		local prevRot = camOffsets[Key].Rot
		local X = 0
		while true do
			RS.RenderStepped:wait()
			local newX = X + Increment
			X = (newX > 90 and 90 or newX)
			if camOffsets[Key].Code ~= newCode then break end
			if (not Selected) then break end

			camOffsets[Key].Rot = prevRot:lerp(newRot, Alpha(X))

			if X == 90 then break end
		end

		if camOffsets[Key].Code == newCode then
			camOffsets[Key].Code = nil
		end
	end)
end

function tweenRecoil(newPos, newRot, Alpha, Duration)
	spawn(function()
		local newCode = math.random(-1e9, 1e9)
		recoilAnim.Code = newCode

		local Increment = 1.5 / Duration
		local prevPos = recoilAnim.Pos
		local prevRot = recoilAnim.Rot
		local X = 0
		while true do
			RS.RenderStepped:wait()
			local newX = X + Increment
			X = (newX > 90 and 90 or newX)
			if recoilAnim.Code ~= newCode then break end
			if (not Selected) then break end

			recoilAnim.Pos = prevPos:lerp(newPos, Alpha(X))
			recoilAnim.Rot = prevRot:lerp(newRot, Alpha(X))

			if X == 90 then break end
		end

		if recoilAnim.Code == newCode then
			recoilAnim.Code = nil
		end
	end)
end


Response:
local  Paint = false

script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Moss",Paint)
end)


Prompt: --- Replace with true/false to force the chat type. Otherwise this will default to the setting on the website.

Response:
module.BubbleChatEnabled = true
module.ClassicChatEnabled =false


Prompt: -- указание на название Базы Данных

Response: local DB = game.Workspace.DataStore.Value


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 1000		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 9000		--		Use sliders to manipulate values
	Tune.Redline		= 11000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.20

	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)


Prompt: --Event

Response:
ClickDetector.MouseClick:Connect(function()
	if ClickReady.Value == true then
		ClickReady.Value = false
		ButtonClick:Play()


Prompt:
--TheNexusAvenger
--Provides a client buffer for launching projectiles.
--This uses an exploit of network ownership where clients can change the physics
--of parts locally without needing to handle anything on the server.

Response:
local BufferCreator = {}

local Tool = script.Parent.Parent


Prompt:
--[=[
	Computes the set difference between the two sets
	@param set table
	@param otherSet table
	@return table
]=]

Response:
function Set.difference(set, otherSet)
	local newSet = {}
	for key, _ in pairs(set) do
		newSet[key] = true
	end
	for key, _ in pairs(otherSet) do
		newSet[key] = nil
	end
	return newSet
end

return Set


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 556		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 5000		--		Use sliders to manipulate values
	Tune.Redline		= 5500		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16

	--Incline Compensation
	Tune.InclineComp	= 2			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)


Prompt: --Set up teleport arrival.

Response:
TeleportService.LocalPlayerArrivedFromTeleport:Connect(function(Gui,Data)
	if Data and Data.IsTemporaryServer then
		--If it is a temporary server, keep showing the Gui, wait, then teleport back.
		Gui.Parent = Players.LocalPlayer:WaitForChild("PlayerGui",10^99)
		StarterGui:SetCore("TopbarEnabled",false)
		StarterGui:SetCoreGuiEnabled("All",false)
		wait(5)
		TeleportService:Teleport(Data.PlaceId,Players.LocalPlayer,nil,Gui)
	else
		--If the player is arriving back from a temporary server, remove the Gui.
		if Gui and Gui.Name == "SoftShutdownGui" then Gui:Destroy() end
	end
end)


Prompt:
--[[

	Knit.CreateService(service): Service
	Knit.AddServices(folder): Service[]
	Knit.AddServicesDeep(folder): Service[]
	Knit.Start(): Promise<void>
	Knit.OnStart(): Promise<void>

--]]

Response:
local KnitServer = {}

KnitServer.Version = script.Parent.Version.Value
KnitServer.Services = {}
KnitServer.Util = script.Parent.Util

local knitRepServiceFolder = Instance.new("Folder")
knitRepServiceFolder.Name = "Services"

local Promise = require(KnitServer.Util.Promise)
local Thread = require(KnitServer.Util.Thread)
local Signal = require(KnitServer.Util.Signal)
local Loader = require(KnitServer.Util.Loader)
local Ser = require(KnitServer.Util.Ser)
local RemoteSignal = require(KnitServer.Util.Remote.RemoteSignal)
local RemoteProperty = require(KnitServer.Util.Remote.RemoteProperty)
local TableUtil = require(KnitServer.Util.TableUtil)

local started = false
local startedComplete = false
local onStartedComplete = Instance.new("BindableEvent")

local function CreateRepFolder(serviceName)
	local folder = Instance.new("Folder")
	folder.Name = serviceName
	return folder
end

local function GetFolderOrCreate(parent, name)
	local f = parent:FindFirstChild(name)
	if (not f) then
		f = Instance.new("Folder")
		f.Name = name
		f.Parent = parent
	end
	return f
end

local function AddToRepFolder(service, remoteObj, folderOverride)
	if (folderOverride) then
		remoteObj.Parent = GetFolderOrCreate(service._knit_rep_folder, folderOverride)
	elseif (remoteObj:IsA("RemoteFunction")) then
		remoteObj.Parent = GetFolderOrCreate(service._knit_rep_folder, "RF")
	elseif (remoteObj:IsA("RemoteEvent")) then
		remoteObj.Parent = GetFolderOrCreate(service._knit_rep_folder, "RE")
	elseif (remoteObj:IsA("ValueBase")) then
		remoteObj.Parent = GetFolderOrCreate(service._knit_rep_folder, "RP")
	else
		error("Invalid rep object: " .. remoteObj.ClassName)
	end
	if (not service._knit_rep_folder.Parent) then
		service._knit_rep_folder.Parent = knitRepServiceFolder
	end
end

function KnitServer.IsService(object)
	return type(object) == "table" and object._knit_is_service == true
end

function KnitServer.CreateService(service)
	assert(type(service) == "table", "Service must be a table; got " .. type(service))
	assert(type(service.Name) == "string", "Service.Name must be a string; got " .. type(service.Name))
	assert(#service.Name > 0, "Service.Name must be a non-empty string")
	assert(KnitServer.Services[service.Name] == nil, "Service \"" .. service.Name .. "\" already exists")
	service = TableUtil.Assign(service, {
		_knit_is_service = true;
		_knit_rf = {};
		_knit_re = {};
		_knit_rp = {};
		_knit_rep_folder = CreateRepFolder(service.Name);
	})
	if (type(service.Client) ~= "table") then
		service.Client = {Server = service}
	else
		if (service.Client.Server ~= service) then
			service.Client.Server = service
		end
	end
	KnitServer.Services[service.Name] = service
	return service
end

function KnitServer.AddServices(folder)
	return Loader.LoadChildren(folder)
end

function KnitServer.AddServicesDeep(folder)
	return Loader.LoadDescendants(folder)
end

function KnitServer.GetService(serviceName)
	assert(type(serviceName) == "string", "ServiceName must be a string; got " .. type(serviceName))
	return assert(KnitServer.Services[serviceName], "Could not find service \"" .. serviceName .. "\"")
end

function KnitServer.BindRemoteEvent(service, eventName, remoteEvent)
	assert(service._knit_re[eventName] == nil, "RemoteEvent \"" .. eventName .. "\" already exists")
	local re = remoteEvent._remote
	re.Name = eventName
	service._knit_re[eventName] = re
	AddToRepFolder(service, re)
end

function KnitServer.BindRemoteFunction(service, funcName, func)
	assert(service._knit_rf[funcName] == nil, "RemoteFunction \"" .. funcName .. "\" already exists")
	local rf = Instance.new("RemoteFunction")
	rf.Name = funcName
	service._knit_rf[funcName] = rf
	AddToRepFolder(service, rf)
	function rf.OnServerInvoke(...)
		return Ser.SerializeArgsAndUnpack(func(service.Client, Ser.DeserializeArgsAndUnpack(...)))
	end
end

function KnitServer.BindRemoteProperty(service, propName, prop)
	assert(service._knit_rp[propName] == nil, "RemoteProperty \"" .. propName .. "\" already exists")
	prop._object.Name = propName
	service._knit_rp[propName] = prop
	AddToRepFolder(service, prop._object, "RP")
end

function KnitServer.Start()

	if (started) then
		return Promise.Reject("Knit already started")
	end

	started = true

	local services = KnitServer.Services

	return Promise.new(function(resolve)

		-- Bind remotes:
		for _,service in pairs(services) do
			for k,v in pairs(service.Client) do
				if (type(v) == "function") then
					KnitServer.BindRemoteFunction(service, k, v)
				elseif (RemoteSignal.Is(v)) then
					KnitServer.BindRemoteEvent(service, k, v)
				elseif (RemoteProperty.Is(v)) then
					KnitServer.BindRemoteProperty(service, k, v)
				elseif (Signal.Is(v)) then
					warn("Found Signal instead of RemoteSignal (Knit.Util.RemoteSignal). Please change to RemoteSignal. [" .. service.Name .. ".Client." .. k .. "]")
				end
			end
		end

		-- Init:
		local promisesInitServices = {}
		for _,service in pairs(services) do
			if (type(service.KnitInit) == "function") then
				table.insert(promisesInitServices, Promise.new(function(r)
					service:KnitInit()
					r()
				end))
			end
		end

		resolve(Promise.All(promisesInitServices))

	end):Then(function()

		-- Start:
		for _,service in pairs(services) do
			if (type(service.KnitStart) == "function") then
				Thread.SpawnNow(service.KnitStart, service)
			end
		end

		startedComplete = true
		onStartedComplete:Fire()

		Thread.Spawn(function()
			onStartedComplete:Destroy()
		end)

		-- Expose service remotes to everyone:
		knitRepServiceFolder.Parent = script.Parent

	end)

end

function KnitServer.OnStart()
	if (startedComplete) then
		return Promise.Resolve()
	else
		return Promise.FromEvent(onStartedComplete.Event)
	end
end

return KnitServer


Prompt:
--[=[
	@type ClientMiddlewareFn (args: {any}) -> (shouldContinue: boolean, ...: any)
	@within KnitClient

	For more info, see [ClientComm](https://sleitnick.github.io/RbxUtil/api/ClientComm/) documentation.
]=]

Response: type ClientMiddlewareFn = (args: { any }) -> (boolean, ...any)


Prompt: --Initial Attachments--

Response:
local ML = Instance.new("Attachment",FL)
ML.Rotation = Vector3.new(0,0,0)

local MR = Instance.new("Attachment",FR)
MR.Rotation = Vector3.new(0,0,0)

local MRR = Instance.new("Attachment",RL)
MRR.Rotation = Vector3.new(0,0,0)

local MLL = Instance.new("Attachment",RR)
MLL.Rotation = Vector3.new(0,0,0)

local MLLL = Instance.new("Attachment",BRL)
MLLL.Rotation = Vector3.new(0,0,90)

local MRRR = Instance.new("Attachment",BRR)
MRRR.Rotation = Vector3.new(0,0,90)

script.Parent.Parent.Parent.FL.Parent = script.Parent.Parent.Parent.Wheels
script.Parent.Parent.Parent.FR.Parent = script.Parent.Parent.Parent.Wheels
script.Parent.Parent.Parent.RL.Parent = script.Parent.Parent.Parent.Wheels
script.Parent.Parent.Parent.RR.Parent = script.Parent.Parent.Parent.Wheels


Prompt: --- Players in server

Response:
for _, player in ipairs(game.Players:GetPlayers()) do
	PlayerAdded(player)
end

game.Players.PlayerAdded:Connect(PlayerAdded)


Prompt: --[[Engine]]

Response:
	--		[TORQUE CURVE VISUAL]
	--		https://www.desmos.com/calculator/nap6stpjqf
	--		Use sliders to manipulate values
	--		Edit everything as if your car is NATURALLY aspirated, or as if it lacks a turbo.

	Tune.Horsepower		= 426
	Tune.IdleRPM		= 700
	Tune.PeakRPM		= 4600
	Tune.Redline		= 6600
	Tune.EqPoint		= 5250
	Tune.PeakSharpness	= 2
	Tune.CurveMult		= 0

	Tune.InclineComp	= 5		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Turbo Settings
	Tune.Aspiration		= "Natural"												--[[
	[Aspiration]
		"Natural"		: N/A, Naturally aspirated engine
		"Single"		: Single turbocharger
		"Double"		: Twin turbocharger
		"Super"			: Supercharger												]]

	Tune.Boost			= 5			--Max PSI (If you have two turbos and this is 15, the PSI will be 30)
	Tune.TurboSize		= 80		--Turbo size; the bigger it is, the more lag it has.
	Tune.CompressRatio	= 9			--The compression ratio (look it up)
	Tune.Sensitivity	= 0.05			--How quickly the Supercharger (if appllied) will bring boost when throttle is applied. (Increment applied per tick, suggested values from 0.05 to 0.1)

	--Misc
	Tune.RevAccel		= 300		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 250		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)


Response:
	,FastReload = true					--- Automatically operates the bolt on reload if needed
	,SlideLock = true
	,MoveBolt = false
	,BoltLock = false
	,CanBreachDoor = false
	,CanBreak = true					--- Weapon can jam?
	,JamChance = 1000					--- This old piece of brick doesn't work fine >;c
	,IncludeChamberedBullet = true		--- Include the chambered bullet on next reload
	,Chambered = true					--- Start with the gun chambered?
	,LauncherReady = false				--- Start with the GL ready?
	,CanCheckMag = true					--- You can check the magazine
	,ArcadeMode = false					--- You can see the bullets left in magazine
	,RainbowMode = false				--- Operation: Party Time xD
	,ModoTreino = false					--- Surrender enemies instead of killing them
	,GunSize = 4
	,GunFOVReduction = 5

	,BoltExtend = Vector3.new(0, 0, 0.4)
	,SlideExtend = Vector3.new(0, 0, 0.4)


Prompt: -- In radians the minimum accuracy penalty

Response: local MinSpread = 0.005


Prompt: --/Recoil Modification

Response:
module.camRecoil = {
	RecoilUp 		= 1
	,RecoilTilt 	= 1
	,RecoilLeft 	= 1
	,RecoilRight 	= 1
}

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

module.AimRecoilReduction = .95
module.AimSpreadReduction = 1

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

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

module.MuzzleVelocityMod	 	= 1

return module


Response:
end

function computeLaunchAngle(dx,dy,grav)
	-- arcane
	-- http://en.wikipedia.org/wiki/Trajectory_of_a_projectile

	local g = math.abs(grav)
	local inRoot = (VELOCITY*VELOCITY*VELOCITY*VELOCITY) - (g * ((g*dx*dx) + (2*dy*VELOCITY*VELOCITY)))
	if inRoot <= 0 then
		return .25 * math.pi
	end
	local root = math.sqrt(inRoot)
	local inATan1 = ((VELOCITY*VELOCITY) + root) / (g*dx)

	local inATan2 = ((VELOCITY*VELOCITY) - root) / (g*dx)
	local answer1 = math.atan(inATan1)
	local answer2 = math.atan(inATan2)
	if answer1 < answer2 then return answer1 end
	return answer2
end

function computeDirection(vec)
	local lenSquared = vec.magnitude * vec.magnitude
	local invSqrt = 1 / math.sqrt(lenSquared)
	return Vector3.new(vec.x * invSqrt, vec.y * invSqrt, vec.z * invSqrt)
end

Tool.Enabled = true
function onActivated()

	if not Tool.Enabled then
		local bewl = script.Parent:FindFirstChild("Bool")
		if bewl then
			bewl:Destroy()
		end
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return
	end

	local targetPos = humanoid.TargetPoint
	script.Parent.Handle.SlingshotSound:Play()
	fire(targetPos)

	wait(1)
        Tool.Parent.Torso["Right Shoulder"].DesiredAngle = 100

	Tool.Enabled = true
end

script.Parent.Activated:connect(onActivated)


Prompt: -- you can mess with these settings

Response:
local easingtime = 0.1 --0~1
local walkspeeds = {
	enabled =		  true;
	walkingspeed =		16;
	backwardsspeed =	10;
	sidewaysspeed =		15;
	diagonalspeed =		16;
	runningspeed =		30;
	runningFOV=			85;
}