Roblox/luau_corpus huggingface dataset:
--Disable script if car is removed from workspace
Car.AncestryChanged:Connect(function()
	if not Car:IsDescendantOf(Workspace) then
		unbindActions()

		LocalVehicleSeating.ExitSeat()
		LocalVehicleSeating.DisconnectFromSeatExitEvent(onExitSeat)
		-- stop seated anim
		--print("car removed from workspace")

		script.Disabled = true
		ProximityPromptService.Enabled = true
	end
end)

local function exitVehicle(action, inputState, inputObj)
	if inputState == Enum.UserInputState.Begin then
		LocalVehicleSeating.ExitSeat()
		-- stop seated anim
	end
end

local function _updateRawInput(_, inputState, inputObj)
	local key = inputObj.KeyCode
	local data = Keymap.getData(key)
	
	if not data then 
		return
	end
	
	local axis = data.Axis
	local val = 0
	
	if axis then
		val = inputObj.Position:Dot(axis)
	else
		val = (inputState == Enum.UserInputState.Begin or inputState == Enum.UserInputState.Change) and 1 or 0
	end
	
	val = val * (data.Sign or 1)
	
	_rawInput[key] = val
	
	if data.Pass then
		return Enum.ContextActionResult.Pass
	end
end

local function _calculateInput(action)
	-- Loop through all mappings for this action and calculate a resultant value from the raw input
	local mappings = Keymap[action]
	local val = 0
	local absVal = val
	
	for _, data in ipairs(mappings) do
		local thisVal = _rawInput[data.KeyCode]
		if math.abs(thisVal) > absVal then
			val = thisVal
			absVal = math.abs(val)
		end
	end
	
	return val
end

ContextActionService:BindAction(
	EXIT_ACTION_NAME,
	exitVehicle,
	false,
	Keymap.EnterVehicleGamepad,
	Keymap.EnterVehicleKeyboard
)

ContextActionService:BindActionAtPriority(
	RAW_INPUT_ACTION_NAME,
	_updateRawInput,
	false,
	Enum.ContextActionPriority.High.Value,
	unpack(Keymap.allKeys()))
--[[
To make another trader, duplicate a trader and change the proximity prompt text in their UpperTorso
ActionText: "FinalItemName"
ObjectText = "ItemRequired: 0/AmountRequired"
]]
local function trade(PP)
	local char = plr.Character
	if not char then return end
	local tool = char:FindFirstChildWhichIsA("Tool")
	if not tool or not tool:FindFirstChild("Handle") then return end
	local args = string.split(PP.ObjectText, ": ")
	local required, amount = args[1], args[2]
	if not required or not amount then return end
	args = string.split(amount, "/")
	local given,max = args[1], args[2]
	given = tonumber(given)
	if tool.Name == required then
		given +=1
		local final = given >= tonumber(max)
		events.TradeItem:FireServer(PP, final)
		if final then
			PP.ObjectText = "Finished!"
		else
			PP.ObjectText = required .. ": " .. tostring(given) .. "/" .. max
		end
	end
end

NPCs.Seller.UpperTorso.ProximityPrompt.Triggered:Connect(function(plr)
	local char = plr.Character
	if not char then return end
	local tool = char:FindFirstChildWhichIsA("Tool")
	if not tool or not tool:FindFirstChild("Handle") then return end
	local res = tool.Handle:FindFirstChild("Price")
	if res then
		tool:Destroy()
		plr.Wallet.Value += res.Value
	end
end)
for i,trader in NPCs.Traders:GetChildren() do
	local PP = trader.UpperTorso.ProximityPrompt
	PP.Triggered:Connect(function()
		trade(PP)
	end)
end
--CHANGE THIS LINE--
Signal = script.Parent.Parent.Parent.ControlBox.PedValues.PedSignal2 -- Change last word
--Rescripted by Luckymaxer

Tool = script.Parent
Handle = Tool:WaitForChild("Handle")

Players = game:GetService("Players")

Animations = {}

ClientControl = Tool:WaitForChild("ClientControl")

ClientControl.OnClientInvoke = (function(Mode, Value)
	if Mode == "PlayAnimation" then
		for i, v in pairs(Animations) do
			if v.Animation == Value then
				v.AnimationTrack:Stop()
				table.remove(Animations, i)
			end
		end
		local AnimationTrack = Humanoid:LoadAnimation(Value.Animation)
		table.insert(Animations, {Animation = Value.Animation, AnimationTrack = AnimationTrack})
		AnimationTrack:Play(nil, nil, Value.Speed)
	end
end)

function Equipped(Mouse)
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChild("Humanoid")
	if not Player or not Humanoid or Humanoid.Health == 0 then
		return
	end
end

function Unequipped()
	for i, v in pairs(Animations) do
		if v and v.AnimationTrack then
			v.AnimationTrack:Stop()
		end
	end
	Animations = {}
end

Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)
--[=[
	Token to use for deleting.
	@server
	@class DataStoreDeleteToken
]=]

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

local Symbol = require("Symbol")

return Symbol.named("dataStoreDeleteToken")
--end
--if SignalValues.Signal1a.Value == 2 then
	SignalValues.Signal1a.Value = 3
--EDIT BELOW----------------------------------------------------------------------
settings.PianoSoundRange = 100

settings.KeyAesthetics = true

settings.PianoSounds = {
		"269058581", --C/C#
		"269058744", --D/D#
		"269058842", --E/F
		"269058899", --F#/G
		"269058974", --G#/A
		"269059048", --A#/B
	Fade = true;
}
-- Public Methods

function CheckboxLabelClass:GetValue()
	return self.Button.Checkmark.Visible
end

function CheckboxLabelClass:SetValue(bool)
	bool = not not bool
	
	local container = self.Frame.CheckContainer
	local colorA = container.BackgroundColor3
	local colorB = container.BorderColor3
	local colorC = container.Outline.BackgroundColor3
	
	local outlineColor = bool and colorB or colorC
	if (bool and container.CheckButton.BackgroundTransparency == 1) then
		outlineColor = colorC
	end
	
	for _, child in next, container.Outline:GetChildren() do
		child.BackgroundColor3 = outlineColor
	end
	
	container.CheckButton.BackgroundColor3 = bool and colorB or colorA
	container.CheckButton.Checkmark.Visible = bool
	
	self._ChangedBind:Fire(bool)
end

function CheckboxLabelClass:Destroy()
	self._Maid:Sweep()
	self.Frame:Destroy()
	self.Changed = nil
end
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {};
local l__ReplicatedStorage__2 = game.ReplicatedStorage;
local v3 = require(game.ReplicatedStorage.Modules.Xeno);
local v4 = require(game.ReplicatedStorage.Modules.CameraShaker);
local l__TweenService__5 = game.TweenService;
local l__Debris__6 = game.Debris;
local u1 = require(game.ReplicatedStorage.Modules.Lightning);
function v1.RunStompFx(p1, p2, p3, p4)
	if workspace.SpawnH:FindFirstChild(p3.Name) == nil then
		local v7 = workspace.SpawnH:WaitForChild(p3.Name);
		local v8 = game.ReplicatedStorage.KillFX.Souls.Sound:Clone();
		game.Debris:AddItem(v8, 10);
		v8.Parent = v7.HumanoidRootPart;
		v8:Play();
		for v9 = 1, 3 do
			local v10 = game.ReplicatedStorage.KillFX.Souls.ColorCorrection:Clone();
			v10.Parent = game.Lighting;
			game.Debris:AddItem(v10, 3);
			game.TweenService:Create(v10, TweenInfo.new(0.8, Enum.EasingStyle.Quart), {
				Brightness = 0, 
				Contrast = 0, 
				Saturation = 0, 
				TintColor = Color3.fromRGB(255, 255, 255)
			}):Play();
		end;
		local v11 = game.ReplicatedStorage.KillFX.Souls.Stomp:Clone();
		game.Debris:AddItem(v11, 10);
		v11.Parent = workspace;
		v11:Play();
		task.delay(0, function()
			local v12 = u1.Bolt((CFrame.new(v7.HumanoidRootPart.CFrame.p) * CFrame.new(0, 250, 0) * CFrame.new(math.random(-1, 1), math.random(-1, 1), math.random(-1, 1))).Position, (v7.HumanoidRootPart.CFrame * CFrame.new(math.random(-2, 2), math.random(-1, 1), math.random(-1, 1))).Position, 10, 0.25, false);
			v12.PulseSpeed = 12;
			v12.PulseLength = 5;
			v12.MinRadius = 0;
			v12.MaxRadius = 5;
			v12.FadeLength = 0.1;
			v12.Thickness = 3;
			v12.MinTransparency = 0.25;
			v12.MaxTransparency = 0.3;
			v12.Color = Color3.fromRGB(255, 0, 0);
		end);
	else
		local v13 = game.ReplicatedStorage.KillFX.Souls.arszg:Clone();
		game.Debris:AddItem(v13, 18);
		v13.Parent = p3.Character.PrimaryPart;
		v13:Play();
	end;
	return nil;
end;
return v1;
--[=[
	Wait for fire to be called, and return the arguments it was given.
	@yields
	@return T
]=]
function Signal:Wait()
	local key = self._bindableEvent.Event:Wait()
	local args = self._argMap[key]
	if args then
		return table.unpack(args, 1, args.n)
	else
		error("Missing arg data, probably due to reentrance.")
		return nil
	end
end
-------------------------
function onClicked()
R.BrickColor = BrickColor.new("Really red")
C.One.BrickColor = BrickColor.new("Really black")
C.Two.BrickColor = BrickColor.new("Really black")
C.Three.BrickColor = BrickColor.new("Really black")
C.Four.BrickColor = BrickColor.new("Really black")
C.MIC.BrickColor = BrickColor.new("Really black")
C.A.BrickColor = BrickColor.new("Really black")
C.M.BrickColor = BrickColor.new("Really black")
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
--// # key, Spotlight
mouse.KeyDown:connect(function(key)
	if key=="." then 
		veh.Lightbar.middle.SpotlightSound:Play()
		veh.Lightbar.Remotes.SpotlightEvent:FireServer(true)
	end
end)
-- local bindModule = require(script.Parent.Parent.bind)
-- type EachTests = bindModule.EachTests
type EachTests = any
local interpolationModule = require(script.Parent.interpolation)
type Headings = interpolationModule.Headings
type Template = interpolationModule.Template
type Templates = interpolationModule.Templates
local interpolateVariables = require(script.Parent.interpolation).interpolateVariables

local function default(title: string, headings: Headings, row: Global_Row): EachTests
	local table_ = convertRowToTable(row, headings)
	local templates = convertTableToTemplates(table_, headings)
	return Array.map(templates, function(template, index)
		return {
			arguments = { Object.assign({}, template) },
			-- ROBLOX FIXME Luau: analyze should know this is Template because of the Array.map() generic's callbackFn
			title = interpolateVariables(title, template :: Template, index),
		}
	end)
end

exports.default = default

function convertRowToTable(row: Global_Row, _headings: Headings): Global_Table
	-- ROBLOX deviation: rows are already formatted as arrays (because there are no tagged templates)
	return row
end

function convertTableToTemplates(table_: Global_Table, headings: Headings): Templates
	return Array.map(table_, function(row)
		return Array.reduce(row, function(acc, value, index)
			return Object.assign(acc, { [headings[index]] = value })
		end, {})
	end)
end

return exports
--magenta 12
if k == "m" and ibo.Value==true then
	bin.Blade.BrickColor = BrickColor.new("Magenta")
	bin.Blade2.BrickColor = BrickColor.new("Institutional white")
	bin.Blade.White.Enabled=false colorbin.white.Value = false
	bin.Blade.Blue.Enabled=false colorbin.blue.Value = false
	bin.Blade.Green.Enabled=false colorbin.green.Value = false
	bin.Blade.Magenta.Enabled=true colorbin.magenta.Value = true
	bin.Blade.Orange.Enabled=false colorbin.orange.Value = false
	bin.Blade.Viridian.Enabled=false colorbin.viridian.Value = false
	bin.Blade.Violet.Enabled=false colorbin.violet.Value = false
	bin.Blade.Red.Enabled=false colorbin.red.Value = false
	bin.Blade.Silver.Enabled=false colorbin.silver.Value = false
	bin.Blade.Black.Enabled=false colorbin.black.Value = false
	bin.Blade.NavyBlue.Enabled=false colorbin.navyblue.Value = false
	bin.Blade.Yellow.Enabled=false colorbin.yellow.Value = false
	bin.Blade.Cyan.Enabled=false colorbin.cyan.Value = false
    end
-- // NAMELESS SETTINGS
settings.IgnoreAdonisAdmins = true
settings.UseDiscordWebhook = false
settings.DiscordWebhookLink = ""

settings.Whitelist = {} -- Use UserIds, not player names



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

local BOV_Loudness = 2	--volume of the BOV (not exact volume so you kinda have to experiment with it)
local BOV_Pitch = 0.9	--max pitch of the BOV (not exact so might have to mess with it)
local TurboLoudness = 1 --volume of the Turbo (not exact volume so you kinda have to experiment with it also)
-- Roblox character sound script

local SetState = script:WaitForChild("SetState")

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

local SOUND_DATA = {
	Climbing = {
		SoundId = "rbxasset://sounds/action_footsteps_plastic.mp3",
		Looped = true,
	},
	Died = {
		SoundId = "rbxasset://sounds/uuhhh.mp3",
	},
	FreeFalling = {
		SoundId = "rbxasset://sounds/action_falling.mp3",
		Looped = true,
	},
	GettingUp = {
		SoundId = "rbxasset://sounds/action_get_up.mp3",
	},
	Jumping = {
		SoundId = "rbxasset://sounds/action_jump.mp3",
	},
	Landing = {
		SoundId = "rbxasset://sounds/action_jump_land.mp3",
	},
	Running = {
		SoundId = "rbxasset://sounds/action_footsteps_plastic.mp3",
		Looped = true,
		Pitch = 1.85,
	},
	Splash = {
		SoundId = "rbxasset://sounds/impact_water.mp3",
	},
	Swimming = {
		SoundId = "rbxasset://sounds/action_swim.mp3",
		Looped = true,
		Pitch = 1.6,
	},
}

 -- wait for the first of the passed signals to fire
local function waitForFirst(...)
	local shunt = Instance.new("BindableEvent")
	local slots = {...}

	local function fire(...)
		for i = 1, #slots do
			slots[i]:Disconnect()
		end

		return shunt:Fire(...)
	end

	for i = 1, #slots do
		slots[i] = slots[i]:Connect(fire)
	end

	return shunt.Event:Wait()
end
--[[
	Set up initial values.
]]
function BaseSystem:_init(model)
	self._isActive = true
	self._connections = {}
	self._health = DEFAULT_STARTING_HEALTH
	self._maxHealth = DEFAULT_STARTING_HEALTH

	self._model = model

	return self
end
--Commands and Sounds
local function updateSettings()
	for a,b in pairs(pages.custom:GetChildren()) do
		local settingName = string.sub(b.Name, 5)
		if b:FindFirstChild("SettingValue") then
			b.SettingName.TextLabel.Text = settingName..":"
			local settingValue = main.pdata[settingName]
			b.SettingValue.TextBox.Text = tostring(settingValue)
			local soundName
			local propertyStart
			if string.sub(settingName, 1, 5) == "Error" then
				soundName = "Error"
				propertyStart = 6
			elseif string.sub(settingName, 1, 6) == "Notice" then
				soundName = "Notice"
				propertyStart = 7
			end
			if soundName then
				local sound = main.audio[soundName]
				local propertyName = string.sub(settingName, propertyStart)
				if propertyName == "SoundId" then
					settingValue = "rbxassetid://"..settingValue
				end
				sound[propertyName] = settingValue
			end
		end
	end
	updateThemeSelection()
end
for a,b in pairs(pages.custom:GetChildren()) do
	local settingName = string.sub(b.Name, 5)
	if b:FindFirstChild("SettingValue") then
		local settingDe = true
		local textBox = b.SettingValue.TextBox
		local textLabel = b.SettingValue.TextLabel
		b.SettingValue.TextBox.FocusLost:connect(function(property)
			if settingDe then
				local newValue = b.SettingValue.TextBox.Text
				settingDe = false
				textBox.Visible = false
				textLabel.Visible = true
				textLabel.Text = "Loading..."
				local returnMsg = main.signals.ChangeSetting:InvokeServer{settingName, newValue}
				if returnMsg == "Success" then
					updateSettings()
					local noticeType = "Notice"
					local settingType = string.sub(settingName, 1, 5)
					if settingType == "Error" or settingType == "Alert" then
						noticeType = settingType
					end
					if settingName == "Prefix" then
						main:GetModule("PageCommands"):CreateCommands()
					end
					local noticeMessage = "Successfully changed '"..settingName.."' to '"..newValue.."'"
					if noticeType == "Alert" then
						main:GetModule("cf"):CreateNewCommandMenu("settings", {"Settings Alert", noticeMessage}, 8, true)
					else
						main:GetModule("Notices"):Notice(noticeType, "Settings", noticeMessage)
					end
				else
					textLabel.Text = returnMsg
					wait(1)
				end
				textBox.Visible = true
				textLabel.Visible = false
				b.SettingValue.TextBox.Text = tostring(main.pdata[settingName])
				settingDe = true
			end
		end)
	end
end
updateSettings()
---------------------------------------Function end here.
end


Tool.Enabled = true
function onActivated()

	if not Tool.Enabled then
		return
	end

	--Tool.Enabled = false

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

	local targetPos = humanoid.TargetPoint
	local lookAt = (targetPos - character.Head.Position).unit
	
	if (check()) then
	fire(lookAt)
	wait(0)
	onActivated()
	end
	return

	--Tool.Enabled = true
end


script.Parent.Activated:connect(onActivated)
--[=[
	@class Option

	Represents an optional value in Lua. This is useful to avoid `nil` bugs, which can
	go silently undetected within code and cause hidden or hard-to-find bugs.
]=]
local Option = {}
Option.__index = Option

function Option._new(value)
	local self = setmetatable({
		ClassName = CLASSNAME,
		_v = value,
		_s = (value ~= nil),
	}, Option)
	return self
end
-- we have a player in the radius
local playerRay = Ray.new(v.Position+Vector3.new(0,10,0),Vector3.new(0,-50,0))
local part,pos,norm,mat = workspace:FindPartOnRay(playerRay,v.Parent)
if part and mat ~= Enum.Material.Water then
--Main function
local function AttachAuraControl(source_part, eff_cont) --(source_part, effect_container)
	
	local AnimObj
	
	local function Start()
		AnimObj = {}
		AnimObj["MainPart"] = EFFECT_LIB.NewInvisiblePart()
		
		AnimObj["Emitter"] = script.ConspiracyEff:clone()
		AnimObj["Emitter"].Parent = AnimObj["MainPart"]
		
		AnimObj["MainPart"].Parent = eff_cont
	end
	
	local function Update()
		local loop = EFFECT_LIB.Loop(2)
		AnimObj["MainPart"].CFrame = source_part.CFrame * CFrame.Angles(0, math.rad(loop * 0), 0) * CFrame.new(0, 0, 0)
	end
	
	local function Stop()
		eff_cont:ClearAllChildren()
		AnimObj = nil
	end
	
	return {Start = Start, Update = Update, Stop = Stop}
end

return AttachAuraControl
--------------------------------------------------------------------------------------------------------------------------
----------------------------------------------GRENADES---------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------


VELOCITY = 90

function firenade(mouse_pos)
	nadeloaded=false
	local head=game.Workspace:findFirstChild(script.Parent.Parent.Name).Head
	if head == nil then return end
	
	local dir = mouse_pos - head.Position
	dir = computeDirection(dir)

	local launch = head.Position + 5 * dir

	local delta = mouse_pos - launch
	
	local dy = delta.y
	
	local new_delta = Vector3.new(delta.x, 0, delta.z)
	delta = new_delta

	local dx = delta.magnitude
	local unit_delta = delta.unit

	local g = (-9.81 * 20)

	local theta = computeLaunchAngle(dx, dy, g)

	local vy = math.sin(theta)
	local xz = math.cos(theta)
	local vx = unit_delta.x * xz
	local vz = unit_delta.z * xz

	local missile = Instance.new("Part")
	missile.Size = Vector3.new(1,1,1)
	missile.BrickColor=BrickColor.new(0)
	missile.Shape = 0
	missile.BottomSurface = 0
	missile.TopSurface = 0
	missile.Name = "Grenade"
	missile.Elasticity = .2
	missile.Reflectance = 0
	missile.Friction = .8        
	missile.Position = launch
	missile.Velocity = Vector3.new(vx,vy,vz) * VELOCITY

	script.Parent.GrenadeScript:clone().Parent=missile
	missile.GrenadeScript.Disabled = false

	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = game.Players.LocalPlayer
	creator_tag.Name = "creator"
	creator_tag.Parent = missile
	
	missile.Parent = game.Workspace

	wait(0.5)
	script.Parent.mode.Value=script.Parent.mode.Value-10
	wait(10)
	nadeloaded=true

end

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

	local inATan2 = ((VELOCITY^2) - 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
-- Call AddStamina or RemoveStamina and add a number into the brackets between 0-100 to add/deduct stamina.

local StaminaSystem = {}
StaminaSystem.StaminaValue = script.Parent.StaminaValue
StaminaSystem.StaminaCanRegen = true

function StaminaSystem.AddStamina(value)
	local newStamina = math.min(StaminaSystem.StaminaValue.Value + value, 100)
	StaminaSystem.StaminaValue.Value = newStamina
end

function StaminaSystem.RemoveStamina(value)
	local newStamina = math.max(StaminaSystem.StaminaValue.Value - value, 0)
	StaminaSystem.StaminaValue.Value = newStamina
end

return StaminaSystem
--// Services
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")
--Precalculated paths
local t,f,n=true,false,{}
local r={
[58]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58},t},
[49]={{52,47,48,49},t},
[16]={n,f},
[19]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19},t},
[59]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59},t},
[63]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,23,62,63},t},
[34]={{52,47,48,49,45,44,28,29,31,32,34},t},
[21]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,21},t},
[48]={{52,47,48},t},
[27]={{52,47,48,49,45,44,28,27},t},
[14]={n,f},
[31]={{52,47,48,49,45,44,28,29,31},t},
[56]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56},t},
[29]={{52,47,48,49,45,44,28,29},t},
[13]={n,f},
[47]={{52,47},t},
[12]={n,f},
[45]={{52,47,48,49,45},t},
[57]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,57},t},
[36]={{52,47,48,49,45,44,28,29,31,32,33,36},t},
[25]={{52,47,48,49,45,44,28,27,26,25},t},
[71]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71},t},
[20]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20},t},
[60]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,60},t},
[8]={n,f},
[4]={n,f},
[75]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76,73,75},t},
[22]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,21,22},t},
[74]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76,73,74},t},
[62]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,23,62},t},
[1]={n,f},
[6]={n,f},
[11]={n,f},
[15]={n,f},
[37]={{52,47,48,49,45,44,28,29,31,32,33,36,37},t},
[2]={n,f},
[35]={{52,47,48,49,45,44,28,29,31,32,34,35},t},
[53]={{52,53},t},
[73]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76,73},t},
[72]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72},t},
[33]={{52,47,48,49,45,44,28,29,31,32,33},t},
[69]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,60,69},t},
[65]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,65},t},
[26]={{52,47,48,49,45,44,28,27,26},t},
[68]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,67,68},t},
[76]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76},t},
[50]={{52,50},t},
[66]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66},t},
[10]={n,f},
[24]={{52,47,48,49,45,44,28,27,26,25,24},t},
[23]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,23},t},
[44]={{52,47,48,49,45,44},t},
[39]={{52,47,48,49,45,44,28,29,31,32,34,35,39},t},
[32]={{52,47,48,49,45,44,28,29,31,32},t},
[3]={n,f},
[30]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30},t},
[51]={{52,53,54,55,51},t},
[18]={n,f},
[67]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,67},t},
[61]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61},t},
[55]={{52,53,54,55},t},
[46]={{52,47,46},t},
[42]={{52,47,48,49,45,44,28,29,31,32,34,35,38,42},t},
[40]={{52,47,48,49,45,44,28,29,31,32,34,35,40},t},
[52]={{52},t},
[54]={{52,53,54},t},
[43]={n,f},
[7]={n,f},
[9]={n,f},
[41]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41},t},
[17]={n,f},
[38]={{52,47,48,49,45,44,28,29,31,32,34,35,38},t},
[28]={{52,47,48,49,45,44,28},t},
[5]={n,f},
[64]={{52,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64},t},
}
return r