Roblox/luau_corpus huggingface dataset:
-- A redundant check for those who loaded before the server runs this script
for i,v in pairs(game.Players:GetPlayers()) do
	if storage.GetData(v.UserId) == nil then
		storage.LoadData(v.UserId)
	end
end

game.Players.PlayerAdded:connect(function(player)
	storage.LoadData(player.UserId)
end)

game.Players.PlayerRemoving:connect(function(player)
	storage.SaveData(player.UserId)
end)
-- Variables

local MainGui = script.Parent
local TextButton = MainGui.Frame.TextLabel.TextButton
local sound = game.StarterPack.Phone.ClickSound
TextButton.MouseButton1Up:Connect(function()
	sound:Play()
end)
--Made by Luckymaxer

Players = game:GetService("Players")
Debris = game:GetService("Debris")
UserInputService = game:GetService("UserInputService")
ContextActionService = game:GetService("ContextActionService")

Player = Players.LocalPlayer
Character = Player.Character
Mouse = Player:GetMouse()

Humanoid = nil
for i, v in pairs(Character:GetChildren()) do
	if v:IsA("Humanoid") then
		Humanoid = v
		break
	end
end

ServerControl = script:WaitForChild("ServerControl").Value

function InvokeServer(mode, value)
	pcall(function()
		local ServerReturn = ServerControl:InvokeServer(mode, value)
		return ServerReturn
	end)
end

function Dismount()
	if DisableJump then
		DisableJump:disconnect()
	end
	InvokeServer("Dismount")
	if UserInputService.TouchEnabled then
		ContextActionService:UnbindAction("RidableHorse_Dismount")
	end
end

if Humanoid then
	DisableJump = Humanoid.Changed:connect(function(Property)
		if Property == "Jump" then
			Humanoid.Jump = false
			InvokeServer("Jump")
		end
	end)
end

UserInputService.InputBegan:connect(function(InputObject)
	if InputObject.KeyCode == Enum.KeyCode.LeftControl or InputObject.KeyCode == Enum.KeyCode.RightControl then
		Dismount()
	end
end)
--[[Brakes]]
Tune.ABSEnabled		= true		-- Implements ABS
Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS) 

Tune.FBrakeForce	= 1300		-- Front brake force
Tune.RBrakeForce	= 1500		-- Rear brake force
Tune.PBrakeForce	= 5000		-- Handbrake force

Tune.FLgcyBForce	= 15000		-- Front brake force [PGS OFF]
Tune.RLgcyBForce	= 10000		-- Rear brake force [PGS OFF]
Tune.LgcyPBForce	= 25000		-- Handbrake force [PGS OFF]
--------END RIGHT DOOR --------

game.Workspace.LightedDoorON.Value = false

end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
-- Force direction
function EjectionForce.CalculateForce()
	return Vector3.new(
		math.random(270,320) / 10, -- Side to side
		math.random(50,70) / 10, -- Up
		-math.random(300,320) / 10 -- Front
	)
end
-- Gradually regenerates the Humanoid's Health over time.

local REGEN_RATE = 10 / 100 -- Regenerate this fraction of MaxHealth per second.
local REGEN_STEP = 5 -- Wait this long between each regeneration step.
-- Value containing selected game mode
local SelectedMode = script:WaitForChild("SelectedMode")
--[ Services ]:

local RunSrv = game:GetService("RunService");

local Wrks = game:GetService("Workspace");
local Plrs = game:GetService("Players");
--[[
	Renderless component used to detect when a user clicks/taps anywhere
	outside of another component.

	Users commonly expect that a modal will be hidden when clicking anywhere
	outside of it, so this component allows you to set up that functionality.

	Usage:

		local FocusLostTest = Roact.Component:extend("FocusLostTest")

		function FocusLostTest:init()
			self.frame = Roact.createRef()
		end

		function FocusLostTest:render()
			return Roact.createFragment({
				Frame = Roact.createElement("Frame", {
					Size = UDim2.fromOffset(100, 100),
					[Roact.Ref] = self.frame,
				}),

				FocusLost = Roact.createElement(FocusLost, {
					ref = self.frame,
					callback = self.props.callback,
				}),
			})
		end
]]
local FocusLost = Roact.Component:extend("FocusLost")

local defaultProps = {
	UserInputService = UserInputService,
}

export type Props = typeof(defaultProps) & {
	ref: any, -- Roact ref
	callback: () -> (),
}

FocusLost.defaultProps = defaultProps

function FocusLost:init()
	self.wasRefClicked = function(input: InputObject)
		local props: Props = self.props
		local ref = props.ref:getValue()

		if ref then
			local playerGui: BasePlayerGui = ref:FindFirstAncestorWhichIsA("BasePlayerGui")

			if playerGui then
				for _, gui in ipairs(playerGui:GetGuiObjectsAtPosition(input.Position.X, input.Position.Y)) do
					if gui == ref or gui:IsDescendantOf(ref) then
						return true
					end
				end
			end
		end

		return false
	end

	self.handleFocusLost = function(input: InputObject)
		local props: Props = self.props

		if
			input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch
		then
			if not self.wasRefClicked(input) then
				props.callback()
			end
		end
	end
end

function FocusLost:render()
	local props: Props = self.props

	return Roact.createFragment({
		InputEnded = Roact.createElement(ExternalEventConnection, {
			callback = self.handleFocusLost,
			event = props.UserInputService.InputEnded,
		}),

		TouchTap = Roact.createElement(ExternalEventConnection, {
			callback = self.handleFocusLost,
			event = props.UserInputService.TouchTap,
		}),
	})
end

return FocusLost
--[=[
	Calls [Janitor.Cleanup](#Cleanup) and renders the Janitor unusable.

	:::warning
	Running this will make any attempts to call a function of Janitor error.
	:::
]=]
function Janitor:Destroy()
	self:Cleanup()
	table.clear(self)
	setmetatable(self, nil)
end

Janitor.__call = Janitor.Cleanup
-- Place in StarterGui.

local message = script.Chat
local color = script.Color
 
	game:GetService("StarterGui"):SetCore("ChatMakeSystemMessage",{
	Text = (message.Value);
	Color = color.Value;
	Font = Enum.Font.SourceSansBold; 
	FontSize = Enum.FontSize.Size18;
})
----- Connections -----

CreateSellListener()

Remotes.SellSpeed.OnServerEvent:Connect(SellSpeed)
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 220*1.3		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 750		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 1600		--		Use sliders to manipulate values
	Tune.Redline		= 1800		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 1400
	Tune.PeakSharpness	= 5
	Tune.CurveMult		= 0.5
	
	--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)
-- Made by UncRepresentingWAF
local Teleport = "Cuff TP" --Put the name of the Part between the quotation marks.
function Touch(hit) 
	if script.Parent.Locked == false and script.Parent.Parent:findFirstChild(Teleport).Locked == false then script.Parent.Locked = true script.Parent.Parent:findFirstChild(Teleport).Locked = true --Checks Debounce.
		local Pos = script.Parent.Parent:findFirstChild(Teleport) 
		hit.Parent:moveTo(Pos.Position) wait(1) script.Parent.Locked = false script.Parent.Parent:findFirstChild(Teleport).Locked = false end end 
script.Parent.Touched:connect(Touch)
--[[
	Merges dictionary-like tables together.
]]
function Immutable.JoinDictionaries(...)
	local result = {}

	for i = 1, select("#", ...) do
		local dictionary = select(i, ...)
		for key, value in next, dictionary do
			result[key] = value
		end
	end

	return result
end
--[[ Revisit, not needed atm
function map:CreateFatGrid()
	
	map.fatgrid = {}
	for x = 0, map.sizeX - 1, map.fatgridSize do
		for y = 0, map.sizeY - 1, map.fatgridSize do
			
			local node = {}
			node.x = x
			node.y = y
			node.nodes = {}
			map.fatgrid[Vector3.new(x/map.fatgridSize, y/map.fatgridSize)] = node
			
		end
	end
	
	
	for counter 
			--find all the edge cells that have connections (north soth east west)
			--top edge
			
			local tempList = {}
			for xx = 0, map.fatgridSize-1 do
				
				local coord = map:GetPoint( Vector3.new(x+xx, y + 0))
				local otherCoord = map:GetPoint( Vector3.new(x+xx, y + 0 - 1) )
				
				
				if (coord and otherCoord and coord.cost < map.impassible and otherCoord.cost < map.impassible) then
					--We have a link
					tempList[xx] = { coord, otherCoord }		
					--debugBall(coord,Color3.new(1,0,0))
					--debugBall(otherCoord, Color3.new(1,1,0))
				end
				
			end

			--Create a new list of connections with only 1 neighbor
			local newList = {}
			for xx = 0, map.fatgridSize-1 do
				if (tempList[xx] ~= nil and (tempList[xx-1] ==nil or tempList[xx+1] == nil)) then
					table.insert(newList, tempList[xx])
				end
				
			end
			
			local tileCol = Color3.fromHSV(math.random(),1,1)
			for key,tab in pairs(newList) do
				debugBall(tab[1], tileCol)
				debugBall(tab[2], Color3.new(1,1,0))
			end
			
	 
		end
	end
	
end
]]--

map:GenerateDummy()
map:CreateVisuals()


 



local server = {}
server.playerRecords = {}

function server:OnPlayerConnected(player)

	local playerRecord = {}
	playerRecord.userId = player.UserId
	playerRecord.name = player.Name
	playerRecord.displayName = player.DisplayName
	playerRecord.player = player
	
	self.playerRecords[player.UserId] = playerRecord
	
	nerds:PlayerConnected(playerRecord)
	
end

function server:GetPlayers()
	return self.playerRecords
end

function server:OnPlayerDisconnected(player)

	self.playerRecords[player.UserId] = nil
end


function server:Setup()
	
	nerds:Setup()

	
	game.Players.PlayerAdded:Connect(function(player)
		self:OnPlayerConnected(player)
	end)
	game.Players.PlayerRemoving:Connect(function(player)
		self:OnPlayerDisconnected(player)
	end)
	for key,player in pairs(game.Players:GetPlayers()) do
		self:OnPlayerConnected(player)
	end
	
	wait(10)
	nerds:SetMap(map)
	nerds:CreateNerds(1000, server)
end

server:Setup()
-- increment the time of day and then wait for a while 
l:SetMinutesAfterMidnight(l:GetMinutesAfterMidnight()+1) 
wait(.1)
end
--If this script has been installed already, we can stop this instance. Otherwise,
--this instance is the first to run of this version, so we'll install it to PlayerScripts.
--This is necessary because if we left it inside the Tool, it would stop running when the player
--dropped the tool or died, so our WeaponsSystem instance would be garbage-collected.
if ClientWeaponsScript and ClientWeaponsScript ~= script then
	return
else
	CollectionService:AddTag(script, "ClientWeaponsSystem")
	script.Parent = PlayerScripts
end
print("Starting ClientWeaponsScript")

local WeaponsSystemFolder = nil
local function searchForWeaponsSystem()
	local anyPossible = false
	for i, weaponsSystem in pairs(CollectionService:GetTagged(WEAPONS_SYSTEM_TAG)) do
		anyPossible = true
		if weaponsSystem:IsDescendantOf(ReplicatedStorage) then
			local systemVersionObj = weaponsSystem:WaitForChild("Version")
			if systemVersionObj and systemVersionObj.Value == ScriptVersion then
				WeaponsSystemFolder = weaponsSystem
				break
			end
		end
	end
	return anyPossible
end
--[=[
	Creates a new controller.

	:::caution
	Controllers must be created _before_ calling `Knit.Start()`.
	:::
	```lua
	-- Create a controller
	local MyController = Knit.CreateController {
		Name = "MyController",
	}

	function MyController:KnitStart()
		print("MyController started")
	end

	function MyController:KnitInit()
		print("MyController initialized")
	end
	```
]=]
function KnitClient.CreateController(controllerDef: ControllerDef): Controller
	assert(type(controllerDef) == "table", `Controller must be a table; got {type(controllerDef)}`)
	assert(type(controllerDef.Name) == "string", `Controller.Name must be a string; got {type(controllerDef.Name)}`)
	assert(#controllerDef.Name > 0, "Controller.Name must be a non-empty string")
	assert(not DoesControllerExist(controllerDef.Name), `Controller {controllerDef.Name} already exists`)
	local controller = controllerDef :: Controller
	controllers[controller.Name] = controller
	return controller
end
-- Replacement for runWithPriority in React internals.
exports.decoupleUpdatePriorityFromScheduler = true

exports.enableDiscreteEventFlushingChange = false

exports.enableEagerRootListeners = false

exports.enableDoubleInvokingEffects = false
return exports
--Script Created by CarloMagnificient
local songs = script.Parent
local tablee = {}
local lastsong = nil
 
for i,v in pairs(songs:GetChildren()) do
    if v:IsA("Sound") then
        table.insert(tablee,v)
    end
end
 
while true do
    for a,c in pairs(tablee) do
        local chosensong = tablee[math.random(1,#tablee)]
        repeat wait() chosensong = tablee[math.random(1,#tablee)] until chosensong ~= lastsong
        lastsong = chosensong
        chosensong:Play()
        chosensong.Ended:Wait()
        chosensong:Stop()
    end
    wait()
end
--[[ The Module ]]--
local BaseCharacterController = require(script.Parent:WaitForChild("BaseCharacterController"))
local TouchThumbpad = setmetatable({}, BaseCharacterController)
TouchThumbpad.__index = TouchThumbpad

function TouchThumbpad.new()
	local self = setmetatable(BaseCharacterController.new(), TouchThumbpad)
	
	self.thumbpadFrame = nil
	self.touchChangedConn = nil
	self.touchEndedConn = nil
	self.menuOpenedConn = nil
	self.screenPos = nil
	self.isRight, self.isLeft, self.isUp, self.isDown = false, false, false, false
	self.smArrowSize = nil
	self.lgArrowSize = nil
	self.smImgOffset = nil
	self.lgImgOffset = nil
	return self
end
--[[
mouse.KeyDown:Connect(function(key)
	if key == "l" then
		car.Body.Lights.EventHeadlights:FireServer("On")
	else
		car.Body.Lights.EventHeadlights:FireServer("Off")	
	end
end)

script.Parent.Values.Brake.Changed:Connect(function()
	local BrakeVal = script.Parent.Values.Brake.Value
	local GearVal = script.Parent.Values.Gear.Value
	if BrakeVal ~= 0 then
		car.Body.Lights.EventBrake:FireServer("On")
	else
		car.Body.Lights.EventBrake:FireServer("Off")	
	end
end)

script.Parent.Values.Gear.Changed:Connect(function()
	local GearVal = script.Parent.Values.Gear.Value
	if GearVal == -1 then
		car.Body.Lights.EventRev:FireServer("On")
	elseif GearVal == 1 then
		car.Body.Lights.EventRev:FireServer("Off")
	end
end)
]]--
--- Drops the bag full of money onto the ground.
---@param Player Player
---@param Amount number
local function Handler(Player: Player, Amount : number)
	local Character: Model = Player.Character

	--// Sanity checks
	if (Player.Data.Silver.Value <= Amount) then
		return
	end
	--// Takes away the cash you just dropped from your data
	Player.Data.Silver.Value -= Amount
	
	--// I split a lot of the components of this up because it *sucks* looking at a huge wall of property changes, this makes it a bit easier.
	local Dropped: BasePart = script.ItemTemplate:Clone()

	Dropped.Name = Player.Name.."'s Dropped Silver"
	Dropped.BillboardGui.Enabled = true
	Dropped.BillboardGui.ToolName.Text = Amount

	Dropped.CFrame = Character.HumanoidRootPart.CFrame * CFrame.new(0,-2,-3)
	Dropped.Parent = workspace.DroppedBags

	local HasHit = false
	local Connection; --// Moved down here because I literally thought this was a global at first.
	Connection = Dropped.Touched:Connect(function(Hit)
		if (HasHit) then return end

		if (IsCharacter(Hit.Parent)) then
			HasHit = GiveSilver(Amount, Hit.Parent); --// We know GiveSilver returns a boolean, so we can just set 'HasHit' to it.

			if (HasHit) then
				Dropped:Destroy()
				Connection:Disconnect()
			end
		end
	end)
end

Event.OnServerEvent:Connect(Handler)
--end)

game.ReplicatedStorage.Events.TirarSave1.OnServerEvent:Connect(function(player)
	player.Saves.Numerodesaves.Value = 0
end)

game.ReplicatedStorage.Events.TirarSave2.OnServerEvent:Connect(function(player)
	player.Saves.Numerodesaves3.Value = 0
end)
--[[
	Returns the value currently stored in this State object.
	The state object will be registered as a dependency unless `asDependency` is
	false.
]]
function class:get(asDependency: boolean?): any
	if asDependency ~= false then
		useDependency(self)
	end
	return self._value
end
--only works for R6
game.Players.PlayerAdded:connect(function(player)
		player.CharacterAdded:connect(function(character)
		player.Character.Animate.jump.JumpAnim.AnimationId = "http://www.roblox.com/asset/?id=6866114910" --Insert your animation's ID here or leave this one, I don't really care--
		end)
end)
-- Validator for custom enums created by enumerate

return function(enum)
	return function(value)
		return enum.isEnumValue(value)
	end
end
--- Get signal instance
Signal.Get = function(eventName)
	--- Variables
	eventName = string.lower(eventName)
	
	--
	return GetEvent(eventName)
end
-- This is auto installer :D
local anti = script.Anti
local human = script.HumanoidSettings
local main = script["JyAntiCheat.lua [READ]"]


game.Players.PlayerAdded:connect(function(Player)
	main.Name = "JyAntiCheat.lua"
	anti.Parent = game.StarterPlayer.StarterCharacterScripts
	main.Parent = game.StarterPlayer.StarterCharacterScripts
	human.Parent = game.StarterPlayer.StarterCharacterScripts
		anti:Clone()
	main:Clone()
	human:Clone()
	wait(.1);
	script:Destroy();
end)
--//VIPERGUTZ
--//TASER ANIMATIONS

local Tool = script.Parent
local IdleAnimation
local IdleTrack = nil
script.Parent.Equipped:Connect(function(mouse)
	local MyCharacter = Tool.Parent
	local MyPlayer = game:GetService('Players'):GetPlayerFromCharacter(MyCharacter)
	local MyHumanoid = MyCharacter:FindFirstChild('Humanoid')
	IdleAnimation = Tool:WaitForChild("Idle")
	if IdleAnimation then
		IdleTrack = MyHumanoid:LoadAnimation(IdleAnimation)
		IdleTrack.Priority = Enum.AnimationPriority.Movement
	end
	if IdleTrack then
		IdleTrack:Play()
	end
end)

script.Parent.Unequipped:Connect(function(mouse)
	if IdleTrack then
		IdleTrack:Stop()
	end
end)
--|| VARIABLES ||--
local Player = Players.LocalPlayer
local Character = script.Parent
local Humanoid = Character:WaitForChild"Humanoid"

local HumanoidRootPart = Character.HumanoidRootPart
local Torso = Character.Torso

local RootJoint = HumanoidRootPart.RootJoint
local LeftHipJoint = Torso["Left Hip"]
local RightHipJoint = Torso["Right Hip"]

local function Lerp(a, b, c)
	return a + (b - a) * c
end

local Force = nil
local Direction = nil
local Value1 = 0
local Value2 = 0

local RootJointC0 = RootJoint.C0
local LeftHipJointC0 = LeftHipJoint.C0
local RightHipJointC0 = RightHipJoint.C0

RunService.RenderStepped:Connect(function()
	--> To get the force, we multiply the velocity by 1,0,1, we don't want the Y value so we set y to 0
	Force = HumanoidRootPart.Velocity * Vector3.new(1,0,1)
	if Force.Magnitude > 2 then
		--> This represents the direction
		Direction = Force.Unit	
		Value1 = HumanoidRootPart.CFrame.RightVector:Dot(Direction)
		Value2 = HumanoidRootPart.CFrame.LookVector:Dot(Direction)
	else
		Value1 = 0
		Value2 = 0
	end
	
	--> the values being multiplied are how much you want to rotate by
	
	RootJoint.C0 = RootJoint.C0:Lerp(RootJointC0 * CFrame.Angles(math.rad(Value2 * 10), math.rad(-Value1 * 10), 0), 0.2)
	LeftHipJoint.C0 = LeftHipJoint.C0:Lerp(LeftHipJointC0 * CFrame.Angles(math.rad(Value1 * 10), 0, 0), 0.2)
	RightHipJoint.C0 = RightHipJoint.C0:Lerp(RightHipJointC0 * CFrame.Angles(math.rad(-Value1 * 10), 0, 0), 0.2)
end)
--Make sure players stay banned.
	
local DataStore = game:GetService("DataStoreService"):GetDataStore("motfAdminPanel")
function checkBan(player)	
	
	local Reason = DataStore:GetAsync(string.lower(player.Name))
	
	if Reason == nil or Reason == 0 then
		return
	end
	
	wait(1)
	if Reason == 1 then
		player:Kick("You are banned from this game.")
	else
		player:Kick("You are banned from this game for the following reason: " .. Reason)
	end
end

game.Players.PlayerAdded:connect(checkBan)
-- DESTROY/CLEANUP METHOD
function Icon:destroy()
	IconController.iconRemoved:Fire(self)
	self:clearNotices()
	self:setDropdown()
	self:setMenu()
	self._maid:clean()
end
Icon.Destroy = Icon.destroy -- an alias for you maid-using Pascal lovers



return Icon
------------------------------------------------------------

function ClickPlus()
	if (oper == "") then
		oper = "+"
		disp = disp.."+"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClPlus.MouseButton1Down:connect(ClickPlus)

function ClickMinus()
	if (oper == "") then
		oper = "-"
		disp = disp.."-"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClMin.MouseButton1Down:connect(ClickMinus)

function ClickMultiply()
	if (oper == "") then
		oper = "*"
		disp = disp.."*"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClMult.MouseButton1Down:connect(ClickMultiply)

function ClickDivide()
	if (oper == "") then
		oper = "/"
		disp = disp.."/"
		script.Parent.Display.Text = disp
	end
end

script.Parent.ClDiv.MouseButton1Down:connect(ClickDivide)
--Precalculated paths
local t,f,n=true,false,{}
local r={
[58]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58},t},
[49]={{46,47,48,49},t},
[16]={n,f},
[19]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19},t},
[59]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59},t},
[63]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,23,62,63},t},
[34]={{46,47,48,49,45,44,28,29,31,32,34},t},
[21]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,21},t},
[48]={{46,47,48},t},
[27]={{46,47,48,49,45,44,28,27},t},
[14]={n,f},
[31]={{46,47,48,49,45,44,28,29,31},t},
[56]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56},t},
[29]={{46,47,48,49,45,44,28,29},t},
[13]={n,f},
[47]={{46,47},t},
[12]={n,f},
[45]={{46,47,48,49,45},t},
[57]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,57},t},
[36]={{46,47,48,49,45,44,28,29,31,32,33,36},t},
[25]={{46,47,48,49,45,44,28,27,26,25},t},
[71]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71},t},
[20]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20},t},
[60]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,60},t},
[8]={n,f},
[4]={n,f},
[75]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76,73,75},t},
[22]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,21,22},t},
[74]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76,73,74},t},
[62]={{46,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]={{46,47,48,49,45,44,28,29,31,32,33,36,37},t},
[2]={n,f},
[35]={{46,47,48,49,45,44,28,29,31,32,34,35},t},
[53]={{46,47,52,53},t},
[73]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76,73},t},
[72]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72},t},
[33]={{46,47,48,49,45,44,28,29,31,32,33},t},
[69]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,60,69},t},
[65]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,65},t},
[26]={{46,47,48,49,45,44,28,27,26},t},
[68]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,67,68},t},
[76]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61,71,72,76},t},
[50]={{46,47,50},t},
[66]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66},t},
[10]={n,f},
[24]={{46,47,48,49,45,44,28,27,26,25,24},t},
[23]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,23},t},
[44]={{46,47,48,49,45,44},t},
[39]={{46,47,48,49,45,44,28,29,31,32,34,35,39},t},
[32]={{46,47,48,49,45,44,28,29,31,32},t},
[3]={n,f},
[30]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30},t},
[51]={{46,47,50,51},t},
[18]={n,f},
[67]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,67},t},
[61]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,59,61},t},
[55]={{46,47,52,53,54,55},t},
[46]={{46},t},
[42]={{46,47,48,49,45,44,28,29,31,32,34,35,38,42},t},
[40]={{46,47,48,49,45,44,28,29,31,32,34,35,40},t},
[52]={{46,47,52},t},
[54]={{46,47,52,53,54},t},
[43]={n,f},
[7]={n,f},
[9]={n,f},
[41]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41},t},
[17]={n,f},
[38]={{46,47,48,49,45,44,28,29,31,32,34,35,38},t},
[28]={{46,47,48,49,45,44,28},t},
[5]={n,f},
[64]={{46,47,48,49,45,44,28,29,31,32,34,35,39,41,30,56,58,20,19,66,64},t},
}
return r
--[=[
	@class EnumList
	Defines a new Enum.
]=]
local EnumList = {}
EnumList.__index = EnumList