using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BetterTerminal.Scripts.Language;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("BetterTerminal")]
[assembly: InternalsVisibleTo("STFO")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("STFO.Language")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+09dcc6a36661551cc3e378f1ce513b747a2397d4")]
[assembly: AssemblyProduct("STFO.Language")]
[assembly: AssemblyTitle("STFO.Language")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace BetterTerminal.Scripts.Runtime
{
	internal enum StfoValueType
	{
		None,
		Number,
		Boolean,
		Text,
		List,
		Map
	}
	internal readonly record struct StfoValue(StfoValueType Type, object? Raw)
	{
		internal static StfoValue None => new StfoValue(StfoValueType.None, null);

		internal double Number => (double)Raw;

		internal bool Boolean => (bool)Raw;

		internal string Text => (string)Raw;

		internal IReadOnlyList<StfoValue> List => (IReadOnlyList<StfoValue>)Raw;

		internal IReadOnlyDictionary<string, StfoValue> Map => (IReadOnlyDictionary<string, StfoValue>)Raw;

		internal int EstimatedBytes => Type switch
		{
			StfoValueType.None => 0, 
			StfoValueType.Number => 8, 
			StfoValueType.Boolean => 1, 
			StfoValueType.Text => Text.Length * 2, 
			StfoValueType.List => List.Sum((StfoValue item) => item.EstimatedBytes + IntPtr.Size), 
			StfoValueType.Map => Map.Sum<KeyValuePair<string, StfoValue>>((KeyValuePair<string, StfoValue> item) => item.Key.Length * 2 + item.Value.EstimatedBytes + IntPtr.Size), 
			_ => 0, 
		};

		internal static StfoValue FromNumber(double value)
		{
			return new StfoValue(StfoValueType.Number, value);
		}

		internal static StfoValue FromBoolean(bool value)
		{
			return new StfoValue(StfoValueType.Boolean, value);
		}

		internal static StfoValue FromText(string value)
		{
			return new StfoValue(StfoValueType.Text, value);
		}

		internal static StfoValue FromList(IReadOnlyList<StfoValue> value)
		{
			return new StfoValue(StfoValueType.List, value);
		}

		internal static StfoValue FromMap(IReadOnlyDictionary<string, StfoValue> value)
		{
			return new StfoValue(StfoValueType.Map, value);
		}

		public override string ToString()
		{
			return Type switch
			{
				StfoValueType.None => "NONE", 
				StfoValueType.Number => Number.ToString("0.###############", CultureInfo.InvariantCulture), 
				StfoValueType.Boolean => Boolean ? "TRUE" : "FALSE", 
				StfoValueType.Text => Text, 
				StfoValueType.List => "[" + string.Join(", ", List.Select((StfoValue item) => item.ToString())) + "]", 
				StfoValueType.Map => "{" + string.Join(", ", Map.Select<KeyValuePair<string, StfoValue>, string>((KeyValuePair<string, StfoValue> item) => $"{item.Key}: {item.Value}")) + "}", 
				_ => string.Empty, 
			};
		}

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			builder.Append("Type = ");
			builder.Append(Type.ToString());
			builder.Append(", Raw = ");
			builder.Append(Raw);
			return true;
		}
	}
	internal sealed record StfoExecutionResult(IReadOnlyList<string> PrintedLines, StfoValue Output, IReadOnlyList<StfoDiagnostic> Diagnostics, int Instructions, int EstimatedMemoryBytes, StfoInputRequest? InputRequest)
	{
		internal bool IsWaitingForInput => (object)InputRequest != null;

		internal bool Succeeded
		{
			get
			{
				if (!IsWaitingForInput)
				{
					return Diagnostics.All((StfoDiagnostic item) => item.Severity != StfoDiagnosticSeverity.Error);
				}
				return false;
			}
		}

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("PrintedLines = ");
			builder.Append(PrintedLines);
			builder.Append(", Output = ");
			builder.Append(Output.ToString());
			builder.Append(", Diagnostics = ");
			builder.Append(Diagnostics);
			builder.Append(", Instructions = ");
			builder.Append(Instructions.ToString());
			builder.Append(", EstimatedMemoryBytes = ");
			builder.Append(EstimatedMemoryBytes.ToString());
			builder.Append(", InputRequest = ");
			builder.Append(InputRequest);
			return true;
		}
	}
	internal enum StfoInputKind
	{
		Text,
		Number,
		Boolean,
		Option
	}
	internal sealed record StfoInputRequest(StfoInputKind Kind, string Prompt, IReadOnlyList<string>? Options = null);
	internal sealed class StfoVirtualMachine
	{
		private readonly StfoPolicy _policy;

		private readonly IStfoWorkspace _workspace;

		private readonly bool _allowFileWrites;

		private readonly Dictionary<string, StfoValue> _variables = new Dictionary<string, StfoValue>(StringComparer.OrdinalIgnoreCase);

		private readonly Stack<Dictionary<string, StfoValue>> _localScopes = new Stack<Dictionary<string, StfoValue>>();

		private readonly Dictionary<string, StfoFunctionBinding> _functions = new Dictionary<string, StfoFunctionBinding>(StringComparer.OrdinalIgnoreCase);

		private readonly HashSet<string> _executedImports = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly List<string> _printedLines = new List<string>();

		private readonly List<StfoDiagnostic> _diagnostics = new List<StfoDiagnostic>();

		private readonly Stopwatch _stopwatch = Stopwatch.StartNew();

		private StfoValue _output = StfoValue.None;

		private int _instructions;

		private int _estimatedMemoryBytes;

		private bool _stopped;

		private int _callDepth;

		private readonly Queue<string> _inputValues;

		private StfoInputRequest? _inputRequest;

		internal StfoVirtualMachine(StfoPolicy policy, IStfoWorkspace workspace, bool allowFileWrites, IEnumerable<string>? inputValues = null)
		{
			_policy = policy;
			_workspace = workspace;
			_allowFileWrites = allowFileWrites;
			_inputValues = new Queue<string>(inputValues ?? Array.Empty<string>());
		}

		internal StfoExecutionResult Execute(string entryPath, StfoEntryPointKind entryPointKind, StfoValue? pipelineInput = null)
		{
			string fullPath = Path.GetFullPath(entryPath);
			string file = Relative(fullPath);
			string source = File.ReadAllText(fullPath);
			StfoLexResult stfoLexResult = new StfoLexer(file, source).Lex();
			StfoEntryPoint entryPoint = StfoManifest.Parse(file, stfoLexResult.Tokens).GetEntryPoint(entryPointKind);
			if ((object)entryPoint == null)
			{
				ReportFatal((entryPointKind == StfoEntryPointKind.Program) ? StfoDiagnosticCode.MissingProgramEntryPoint : StfoDiagnosticCode.MissingPipelineEntryPoint, "SCRIPT DOES NOT DECLARE @" + entryPointKind.ToString().ToLowerInvariant() + ".", file, new StfoToken(StfoTokenKind.EndOfFile, string.Empty, 1, 1, 0));
			}
			else
			{
				ExecuteFile(fullPath);
				if (!_stopped)
				{
					IReadOnlyList<StfoValue> argumentValues = ((entryPointKind != StfoEntryPointKind.Pipeline) ? ((IReadOnlyList<StfoValue>)Array.Empty<StfoValue>()) : ((IReadOnlyList<StfoValue>)new StfoValue[1] { pipelineInput ?? StfoValue.None }));
					StfoValue output = InvokeFunction(entryPoint.FunctionName, argumentValues, file, entryPoint.Token);
					if (output.Type != StfoValueType.None)
					{
						_output = output;
					}
				}
			}
			return new StfoExecutionResult(_printedLines, _output, _diagnostics, _instructions, _estimatedMemoryBytes, _inputRequest);
		}

		private void ExecuteFile(string path)
		{
			if (_stopped || !_executedImports.Add(path))
			{
				return;
			}
			string text = Relative(path);
			try
			{
				string source = File.ReadAllText(path);
				StfoLexResult stfoLexResult = new StfoLexer(text, source).Lex();
				_diagnostics.AddRange(stfoLexResult.Diagnostics);
				if (stfoLexResult.Diagnostics.Any((StfoDiagnostic item) => item.Severity == StfoDiagnosticSeverity.Error))
				{
					_stopped = true;
					return;
				}
				StfoProgramSyntax stfoProgramSyntax = new StfoParser(text, stfoLexResult.Tokens).Parse();
				_diagnostics.AddRange(stfoProgramSyntax.Diagnostics);
				if (stfoProgramSyntax.Diagnostics.Any((StfoDiagnostic item) => item.Severity == StfoDiagnosticSeverity.Error))
				{
					_stopped = true;
					return;
				}
				foreach (StfoFunctionStatementSyntax item in stfoProgramSyntax.Statements.OfType<StfoFunctionStatementSyntax>())
				{
					_functions[item.Name] = new StfoFunctionBinding(item, path);
				}
				foreach (StfoStatementSyntax statement in stfoProgramSyntax.Statements)
				{
					if (_stopped || !ConsumeInstruction(statement.Token, text))
					{
						break;
					}
					ExecuteStatement(statement, path, text);
				}
			}
			catch (Exception ex)
			{
				ReportFatal(StfoDiagnosticCode.IoError, "EXECUTION FAILED: " + ex.Message, text, new StfoToken(StfoTokenKind.EndOfFile, string.Empty, 1, 1, 0));
			}
		}

		private void ExecuteStatement(StfoStatementSyntax statement, string currentPath, string currentFile)
		{
			string scriptPath;
			string error;
			if (!(statement is StfoImportStatementSyntax stfoImportStatementSyntax))
			{
				if (!(statement is StfoAssignmentStatementSyntax stfoAssignmentStatementSyntax))
				{
					if (!(statement is StfoPrintStatementSyntax stfoPrintStatementSyntax))
					{
						if (!(statement is StfoOutputStatementSyntax stfoOutputStatementSyntax))
						{
							if (!(statement is StfoExpressionStatementSyntax stfoExpressionStatementSyntax))
							{
								if (!(statement is StfoIfStatementSyntax statement2))
								{
									if (statement is StfoFunctionStatementSyntax)
									{
										return;
									}
									if (!(statement is StfoReturnStatementSyntax stfoReturnStatementSyntax))
									{
										if (!(statement is StfoForStatementSyntax statement3))
										{
											if (statement is StfoWhileStatementSyntax statement4)
											{
												ExecuteWhile(statement4, currentPath, currentFile);
											}
										}
										else
										{
											ExecuteFor(statement3, currentPath, currentFile);
										}
									}
									else
									{
										if (_callDepth != 0)
										{
											throw new StfoReturnSignal(Evaluate(stfoReturnStatementSyntax.Expression, currentFile));
										}
										ReportFatal(StfoDiagnosticCode.ReturnOutsideFunction, "RETURN USED OUTSIDE FUNCTION.", currentFile, stfoReturnStatementSyntax.Token);
									}
								}
								else
								{
									ExecuteIf(statement2, currentPath, currentFile);
								}
							}
							else
							{
								Evaluate(stfoExpressionStatementSyntax.Expression, currentFile);
							}
						}
						else
						{
							_output = Evaluate(stfoOutputStatementSyntax.Expression, currentFile);
							UpdateMemory(stfoOutputStatementSyntax.Token, currentFile);
						}
					}
					else
					{
						_printedLines.Add(Evaluate(stfoPrintStatementSyntax.Expression, currentFile).ToString());
						UpdateMemory(stfoPrintStatementSyntax.Token, currentFile);
					}
				}
				else
				{
					SetVariable(stfoAssignmentStatementSyntax.Name, Evaluate(stfoAssignmentStatementSyntax.Expression, currentFile), stfoAssignmentStatementSyntax.Token, currentFile);
				}
			}
			else if (!_workspace.TryResolveScript(stfoImportStatementSyntax.Path, out scriptPath, out error, Path.GetDirectoryName(currentPath)))
			{
				ReportFatal(StfoDiagnosticCode.ImportOutsideWorkspace, error, currentFile, stfoImportStatementSyntax.Token);
			}
			else
			{
				ExecuteFile(scriptPath);
			}
		}

		private void ExecuteFor(StfoForStatementSyntax statement, string currentPath, string currentFile)
		{
			StfoValue stfoValue = Evaluate(statement.Collection, currentFile);
			if (stfoValue.Type != StfoValueType.List)
			{
				ReportFatal(StfoDiagnosticCode.InvalidOperation, "FOR EXPECTS A LIST.", currentFile, statement.Token);
				return;
			}
			foreach (StfoValue item in stfoValue.List)
			{
				if (_stopped || !ConsumeInstruction(statement.Token, currentFile))
				{
					break;
				}
				SetVariable(statement.Variable, item, statement.Token, currentFile);
				foreach (StfoStatementSyntax item2 in statement.Body)
				{
					if (_stopped || !ConsumeInstruction(item2.Token, currentFile))
					{
						return;
					}
					ExecuteStatement(item2, currentPath, currentFile);
				}
			}
		}

		private void ExecuteWhile(StfoWhileStatementSyntax statement, string currentPath, string currentFile)
		{
			while (!_stopped && ConsumeInstruction(statement.Token, currentFile))
			{
				StfoValue stfoValue = Evaluate(statement.Condition, currentFile);
				if (stfoValue.Type != StfoValueType.Boolean)
				{
					ReportFatal(StfoDiagnosticCode.InvalidOperation, "WHILE CONDITION MUST BE BOOLEAN.", currentFile, statement.Token);
					break;
				}
				if (!stfoValue.Boolean)
				{
					break;
				}
				foreach (StfoStatementSyntax item in statement.Body)
				{
					if (_stopped || !ConsumeInstruction(item.Token, currentFile))
					{
						return;
					}
					ExecuteStatement(item, currentPath, currentFile);
				}
			}
		}

		private void ExecuteIf(StfoIfStatementSyntax statement, string currentPath, string currentFile)
		{
			StfoValue stfoValue = Evaluate(statement.Condition, currentFile);
			if (stfoValue.Type != StfoValueType.Boolean)
			{
				ReportFatal(StfoDiagnosticCode.InvalidOperation, "IF CONDITION MUST BE BOOLEAN.", currentFile, statement.Token);
				return;
			}
			foreach (StfoStatementSyntax item in stfoValue.Boolean ? statement.ThenStatements : statement.ElseStatements)
			{
				if (_stopped || !ConsumeInstruction(item.Token, currentFile))
				{
					break;
				}
				ExecuteStatement(item, currentPath, currentFile);
			}
		}

		private StfoValue Evaluate(StfoExpressionSyntax expression, string file)
		{
			if (_stopped || !ConsumeInstruction(expression.Token, file))
			{
				return StfoValue.None;
			}
			if (!(expression is StfoLiteralExpressionSyntax stfoLiteralExpressionSyntax))
			{
				if (!(expression is StfoNameExpressionSyntax expression2))
				{
					if (!(expression is StfoUnaryExpressionSyntax expression3))
					{
						if (!(expression is StfoBinaryExpressionSyntax expression4))
						{
							if (!(expression is StfoCallExpressionSyntax call))
							{
								if (expression is StfoListExpressionSyntax expression5)
								{
									return EvaluateList(expression5, file);
								}
								return StfoValue.None;
							}
							return EvaluateCall(call, file);
						}
						return EvaluateBinary(expression4, file);
					}
					return EvaluateUnary(expression3, file);
				}
				return GetVariable(expression2, file);
			}
			return FromLiteral(stfoLiteralExpressionSyntax.Value);
		}

		private StfoValue EvaluateList(StfoListExpressionSyntax expression, string file)
		{
			if (expression.Items.Count > _policy.MaximumCollectionSize)
			{
				ReportFatal(StfoDiagnosticCode.CollectionLimit, "MAXIMUM COLLECTION SIZE EXCEEDED.", file, expression.Token);
				return StfoValue.None;
			}
			List<StfoValue> list = new List<StfoValue>(expression.Items.Count);
			foreach (StfoExpressionSyntax item in expression.Items)
			{
				list.Add(Evaluate(item, file));
			}
			return StfoValue.FromList(list);
		}

		private StfoValue EvaluateCall(StfoCallExpressionSyntax call, string file)
		{
			List<StfoValue> list = new List<StfoValue>(call.Arguments.Count);
			foreach (StfoExpressionSyntax argument in call.Arguments)
			{
				list.Add(Evaluate(argument, file));
			}
			if (_stopped)
			{
				return StfoValue.None;
			}
			return InvokeFunction(call.Name, list, file, call.Token);
		}

		private StfoValue InvokeFunction(string functionName, IReadOnlyList<StfoValue> argumentValues, string file, StfoToken callToken)
		{
			if (TryInvokeBuiltin(functionName, argumentValues, file, callToken, out var result))
			{
				return result;
			}
			if (!_functions.TryGetValue(functionName, out StfoFunctionBinding value))
			{
				ReportFatal(StfoDiagnosticCode.UnknownFunction, "UNKNOWN FUNCTION: " + functionName, file, callToken);
				return StfoValue.None;
			}
			StfoFunctionStatementSyntax syntax = value.Syntax;
			if (argumentValues.Count != syntax.Parameters.Count)
			{
				ReportFatal(StfoDiagnosticCode.ArgumentCountMismatch, $"FUNCTION {syntax.Name} EXPECTS {syntax.Parameters.Count} ARGUMENTS, RECEIVED {argumentValues.Count}.", file, callToken);
				return StfoValue.None;
			}
			if (_callDepth >= _policy.MaximumCallDepth)
			{
				ReportFatal(StfoDiagnosticCode.CallDepthLimit, "MAXIMUM CALL DEPTH EXCEEDED.", file, callToken);
				return StfoValue.None;
			}
			Dictionary<string, StfoValue> dictionary = new Dictionary<string, StfoValue>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < syntax.Parameters.Count; i++)
			{
				dictionary[syntax.Parameters[i]] = argumentValues[i];
			}
			_localScopes.Push(dictionary);
			_callDepth++;
			try
			{
				foreach (StfoStatementSyntax item in syntax.Body)
				{
					if (!_stopped && ConsumeInstruction(item.Token, file))
					{
						ExecuteStatement(item, value.SourcePath, Relative(value.SourcePath));
						continue;
					}
					break;
				}
			}
			catch (StfoReturnSignal stfoReturnSignal)
			{
				return stfoReturnSignal.Value;
			}
			finally
			{
				_callDepth--;
				_localScopes.Pop();
			}
			return StfoValue.None;
		}

		private bool TryInvokeBuiltin(string functionName, IReadOnlyList<StfoValue> arguments, string file, StfoToken token, out StfoValue result)
		{
			result = StfoValue.None;
			if (!Enum.TryParse<StfoBuiltinFunction>(functionName.Replace("_", string.Empty), ignoreCase: true, out var result2))
			{
				return false;
			}
			switch (result2)
			{
			case StfoBuiltinFunction.Read:
			{
				if (!RequireArguments(arguments, 1, result2, file, token))
				{
					return true;
				}
				if (arguments[0].Type != StfoValueType.Text)
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				if (!TryResolveRuntimeFile(arguments[0].Text, file, out string filePath, out string error))
				{
					ReportFatal(StfoDiagnosticCode.ImportOutsideWorkspace, error, file, token);
					return true;
				}
				if (!File.Exists(filePath))
				{
					ReportFatal(StfoDiagnosticCode.IoError, "FILE NOT FOUND.", file, token);
					return true;
				}
				string text = File.ReadAllText(filePath);
				if (text.Length > _policy.MaximumStringLength)
				{
					ReportFatal(StfoDiagnosticCode.StringLimit, "FILE CONTENT EXCEEDS MAXIMUM STRING LENGTH.", file, token);
					return true;
				}
				result = StfoValue.FromText(text);
				return true;
			}
			case StfoBuiltinFunction.Write:
			{
				if (!RequireArguments(arguments, 2, result2, file, token))
				{
					return true;
				}
				if (arguments[0].Type != StfoValueType.Text || arguments[1].Type != StfoValueType.Text)
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				if (!_allowFileWrites)
				{
					ReportFatal(StfoDiagnosticCode.FileWriteDisabled, "SCRIPT FILE WRITES ARE DISABLED.", file, token);
					return true;
				}
				if (!TryResolveRuntimeFile(arguments[0].Text, file, out string filePath2, out string error2))
				{
					ReportFatal(StfoDiagnosticCode.ImportOutsideWorkspace, error2, file, token);
					return true;
				}
				string directoryName = Path.GetDirectoryName(filePath2);
				if (!string.IsNullOrEmpty(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				File.WriteAllText(filePath2, arguments[1].Text);
				result = StfoValue.FromBoolean(value: true);
				return true;
			}
			case StfoBuiltinFunction.Input:
			case StfoBuiltinFunction.InputNumber:
			case StfoBuiltinFunction.InputBool:
			{
				if (!RequireArguments(arguments, 1, result2, file, token))
				{
					return true;
				}
				if (arguments[0].Type != StfoValueType.Text)
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				StfoInputKind stfoInputKind = result2 switch
				{
					StfoBuiltinFunction.InputNumber => StfoInputKind.Number, 
					StfoBuiltinFunction.InputBool => StfoInputKind.Boolean, 
					_ => StfoInputKind.Text, 
				};
				if (_inputValues.Count == 0)
				{
					_inputRequest = new StfoInputRequest(stfoInputKind, arguments[0].Text);
					_stopped = true;
					return true;
				}
				string text2 = _inputValues.Dequeue();
				result = stfoInputKind switch
				{
					StfoInputKind.Number => StfoValue.FromNumber(double.Parse(text2, CultureInfo.InvariantCulture)), 
					StfoInputKind.Boolean => StfoValue.FromBoolean(ParseBooleanInput(text2)), 
					_ => StfoValue.FromText(text2), 
				};
				return true;
			}
			case StfoBuiltinFunction.Option:
			{
				if (!RequireArguments(arguments, 2, result2, file, token))
				{
					return true;
				}
				if (arguments[0].Type != StfoValueType.Text || arguments[1].Type != StfoValueType.List || arguments[1].List.Any((StfoValue item) => item.Type != StfoValueType.Text))
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				string[] array = arguments[1].List.Select((StfoValue item) => item.Text).ToArray();
				if (array.Length == 0)
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				if (_inputValues.Count == 0)
				{
					_inputRequest = new StfoInputRequest(StfoInputKind.Option, arguments[0].Text, array);
					_stopped = true;
					return true;
				}
				result = StfoValue.FromText(_inputValues.Dequeue());
				return true;
			}
			case StfoBuiltinFunction.Count:
				if (!RequireArguments(arguments, 1, result2, file, token))
				{
					return true;
				}
				result = arguments[0].Type switch
				{
					StfoValueType.List => StfoValue.FromNumber(arguments[0].List.Count), 
					StfoValueType.Text => StfoValue.FromNumber(arguments[0].Text.Length), 
					_ => InvalidBuiltinType(result2, file, token), 
				};
				return true;
			case StfoBuiltinFunction.Take:
			{
				if (!RequireArguments(arguments, 2, result2, file, token))
				{
					return true;
				}
				if (arguments[0].Type != StfoValueType.List || arguments[1].Type != StfoValueType.Number)
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				int count = Math.Max(0, (int)arguments[1].Number);
				result = StfoValue.FromList(arguments[0].List.Take(count).ToArray());
				return true;
			}
			case StfoBuiltinFunction.Where:
			{
				if (!RequireArguments(arguments, 3, result2, file, token))
				{
					return true;
				}
				if (arguments[0].Type != StfoValueType.List || arguments[1].Type != StfoValueType.Text)
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				string field = arguments[1].Text;
				string wanted = arguments[2].ToString();
				result = StfoValue.FromList(arguments[0].List.Where((StfoValue item) => item.Type == StfoValueType.Map && item.Map.TryGetValue(field, out var value) && value.ToString().Contains(wanted, StringComparison.OrdinalIgnoreCase)).ToArray());
				return true;
			}
			case StfoBuiltinFunction.Sort:
			{
				if (!RequireArguments(arguments, 2, result2, file, token))
				{
					return true;
				}
				if (arguments[0].Type != StfoValueType.List || arguments[1].Type != StfoValueType.Text)
				{
					result = InvalidBuiltinType(result2, file, token);
					return true;
				}
				string sortField = arguments[1].Text;
				result = StfoValue.FromList(arguments[0].List.OrderBy<StfoValue, string>((StfoValue item) => (item.Type != StfoValueType.Map || !item.Map.TryGetValue(sortField, out var value)) ? string.Empty : value.ToString(), StringComparer.OrdinalIgnoreCase).ToArray());
				return true;
			}
			default:
				return false;
			}
		}

		private bool RequireArguments(IReadOnlyList<StfoValue> arguments, int expected, StfoBuiltinFunction function, string file, StfoToken token)
		{
			if (arguments.Count == expected)
			{
				return true;
			}
			ReportFatal(StfoDiagnosticCode.ArgumentCountMismatch, $"{function.ToString().ToUpperInvariant()} EXPECTS {expected} ARGUMENTS.", file, token);
			return false;
		}

		private StfoValue InvalidBuiltinType(StfoBuiltinFunction function, string file, StfoToken token)
		{
			ReportFatal(StfoDiagnosticCode.InvalidOperation, "INVALID ARGUMENT TYPE FOR " + function.ToString().ToUpperInvariant() + ".", file, token);
			return StfoValue.None;
		}

		private StfoValue EvaluateUnary(StfoUnaryExpressionSyntax expression, string file)
		{
			StfoValue result = Evaluate(expression.Operand, file);
			if (result.Type != StfoValueType.Number)
			{
				ReportFatal(StfoDiagnosticCode.InvalidOperation, "UNARY OPERATOR EXPECTS NUMBER.", file, expression.Token);
				return StfoValue.None;
			}
			if (expression.Operator != StfoTokenKind.Minus)
			{
				return result;
			}
			return StfoValue.FromNumber(0.0 - result.Number);
		}

		private StfoValue EvaluateBinary(StfoBinaryExpressionSyntax expression, string file)
		{
			StfoValue stfoValue = Evaluate(expression.Left, file);
			StfoValue stfoValue2 = Evaluate(expression.Right, file);
			if (_stopped)
			{
				return StfoValue.None;
			}
			if (expression.Operator == StfoTokenKind.Plus && (stfoValue.Type == StfoValueType.Text || stfoValue2.Type == StfoValueType.Text))
			{
				string text = stfoValue.ToString() + stfoValue2;
				if (text.Length > _policy.MaximumStringLength)
				{
					ReportFatal(StfoDiagnosticCode.StringLimit, "MAXIMUM STRING LENGTH EXCEEDED.", file, expression.Token);
					return StfoValue.None;
				}
				return StfoValue.FromText(text);
			}
			StfoTokenKind stfoTokenKind = expression.Operator;
			if ((uint)(stfoTokenKind - 19) <= 1u)
			{
				bool flag = stfoValue.Type == stfoValue2.Type && object.Equals(stfoValue.Raw, stfoValue2.Raw);
				return StfoValue.FromBoolean((expression.Operator == StfoTokenKind.EqualEqual) ? flag : (!flag));
			}
			if (stfoValue.Type != StfoValueType.Number || stfoValue2.Type != StfoValueType.Number)
			{
				ReportFatal(StfoDiagnosticCode.InvalidOperation, "BINARY OPERATOR EXPECTS NUMBERS.", file, expression.Token);
				return StfoValue.None;
			}
			if (expression.Operator == StfoTokenKind.Slash && stfoValue2.Number == 0.0)
			{
				ReportFatal(StfoDiagnosticCode.DivisionByZero, "DIVISION BY ZERO.", file, expression.Token);
				return StfoValue.None;
			}
			return expression.Operator switch
			{
				StfoTokenKind.Plus => StfoValue.FromNumber(stfoValue.Number + stfoValue2.Number), 
				StfoTokenKind.Minus => StfoValue.FromNumber(stfoValue.Number - stfoValue2.Number), 
				StfoTokenKind.Star => StfoValue.FromNumber(stfoValue.Number * stfoValue2.Number), 
				StfoTokenKind.Slash => StfoValue.FromNumber(stfoValue.Number / stfoValue2.Number), 
				StfoTokenKind.Less => StfoValue.FromBoolean(stfoValue.Number < stfoValue2.Number), 
				StfoTokenKind.LessOrEqual => StfoValue.FromBoolean(stfoValue.Number <= stfoValue2.Number), 
				StfoTokenKind.Greater => StfoValue.FromBoolean(stfoValue.Number > stfoValue2.Number), 
				StfoTokenKind.GreaterOrEqual => StfoValue.FromBoolean(stfoValue.Number >= stfoValue2.Number), 
				_ => StfoValue.None, 
			};
		}

		private StfoValue GetVariable(StfoNameExpressionSyntax expression, string file)
		{
			if (_localScopes.Count > 0 && _localScopes.Peek().TryGetValue(expression.Name, out var value))
			{
				return value;
			}
			if (_variables.TryGetValue(expression.Name, out var value2))
			{
				return value2;
			}
			ReportFatal(StfoDiagnosticCode.UndefinedVariable, "UNDEFINED VARIABLE: " + expression.Name, file, expression.Token);
			return StfoValue.None;
		}

		private void SetVariable(string name, StfoValue value, StfoToken token, string file)
		{
			if (_localScopes.Count > 0)
			{
				_localScopes.Peek()[name] = value;
			}
			else
			{
				_variables[name] = value;
			}
			UpdateMemory(token, file);
		}

		private bool ConsumeInstruction(StfoToken token, string file)
		{
			_instructions++;
			if (_instructions > _policy.MaximumInstructions)
			{
				ReportFatal(StfoDiagnosticCode.InstructionLimit, "MAXIMUM INSTRUCTION COUNT EXCEEDED.", file, token);
				return false;
			}
			if (_stopwatch.Elapsed.TotalSeconds > (double)_policy.MaximumExecutionSeconds)
			{
				ReportFatal(StfoDiagnosticCode.TimeLimit, "MAXIMUM EXECUTION TIME EXCEEDED.", file, token);
				return false;
			}
			return true;
		}

		private void UpdateMemory(StfoToken token, string file)
		{
			_estimatedMemoryBytes = _variables.Sum<KeyValuePair<string, StfoValue>>((KeyValuePair<string, StfoValue> item) => item.Key.Length * 2 + item.Value.EstimatedBytes) + _localScopes.Sum((Dictionary<string, StfoValue> scope) => scope.Sum((KeyValuePair<string, StfoValue> item) => item.Key.Length * 2 + item.Value.EstimatedBytes)) + _printedLines.Sum((string line) => line.Length * 2) + _output.EstimatedBytes;
			if (_estimatedMemoryBytes > (long)_policy.MaximumMemoryKB * 1024L)
			{
				ReportFatal(StfoDiagnosticCode.MemoryLimit, "MAXIMUM SCRIPT MEMORY EXCEEDED.", file, token);
			}
		}

		private void ReportFatal(StfoDiagnosticCode code, string message, string file, StfoToken token)
		{
			_diagnostics.Add(new StfoDiagnostic(code, StfoDiagnosticSeverity.Error, message, new StfoSourceLocation(file, token.Line, token.Column, Math.Max(1, token.Text.Length))));
			_stopped = true;
		}

		private static StfoValue FromLiteral(object? value)
		{
			if (value != null)
			{
				if (!(value is double value2))
				{
					if (!(value is bool value3))
					{
						if (value is string value4)
						{
							return StfoValue.FromText(value4);
						}
						return StfoValue.None;
					}
					return StfoValue.FromBoolean(value3);
				}
				return StfoValue.FromNumber(value2);
			}
			return StfoValue.None;
		}

		private string Relative(string path)
		{
			return Path.GetRelativePath(_workspace.RootDirectory, path).Replace(Path.DirectorySeparatorChar, '/');
		}

		private bool TryResolveRuntimeFile(string requestedPath, string currentFile, out string filePath, out string error)
		{
			string fullPath = Path.GetFullPath(Path.Combine(_workspace.RootDirectory, currentFile));
			return _workspace.TryResolveFile(requestedPath, out filePath, out error, Path.GetDirectoryName(fullPath));
		}

		private static bool ParseBooleanInput(string input)
		{
			if (!input.Equals("TRUE", StringComparison.OrdinalIgnoreCase) && !input.Equals("ON", StringComparison.OrdinalIgnoreCase) && !input.Equals("YES", StringComparison.OrdinalIgnoreCase))
			{
				return input.Equals("SI", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
	internal sealed class StfoReturnSignal : Exception
	{
		internal StfoValue Value { get; }

		internal StfoReturnSignal(StfoValue value)
		{
			Value = value;
		}
	}
	internal enum StfoBuiltinFunction
	{
		Read,
		Write,
		Input,
		InputNumber,
		InputBool,
		Option,
		Count,
		Take,
		Where,
		Sort
	}
	internal sealed record StfoFunctionBinding(StfoFunctionStatementSyntax Syntax, string SourcePath);
}
namespace BetterTerminal.Scripts.Language
{
	internal interface IStfoWorkspace
	{
		string RootDirectory { get; }

		bool TryResolveScript(string scriptName, out string scriptPath, out string error, string? relativeToDirectory = null);

		bool TryResolveFile(string requestedPath, out string filePath, out string error, string? relativeToDirectory = null);
	}
	internal sealed record StfoAnalysisResult(IReadOnlyList<StfoDiagnostic> Diagnostics, IReadOnlyList<string> Files)
	{
		internal bool HasErrors => Diagnostics.Any((StfoDiagnostic item) => item.Severity == StfoDiagnosticSeverity.Error);

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("Diagnostics = ");
			builder.Append(Diagnostics);
			builder.Append(", Files = ");
			builder.Append(Files);
			return true;
		}
	}
	internal sealed class StfoAnalyzer
	{
		private readonly StfoPolicy _policy;

		private readonly IStfoWorkspace _workspace;

		private readonly List<StfoDiagnostic> _diagnostics = new List<StfoDiagnostic>();

		private readonly HashSet<string> _visited = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly HashSet<string> _active = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal StfoAnalyzer(StfoPolicy policy, IStfoWorkspace workspace)
		{
			_policy = policy;
			_workspace = workspace;
		}

		internal StfoAnalysisResult Analyze(string entryPath)
		{
			AnalyzeFile(Path.GetFullPath(entryPath), 0);
			return new StfoAnalysisResult(_diagnostics.OrderBy<StfoDiagnostic, string>((StfoDiagnostic item) => item.Location.File, StringComparer.OrdinalIgnoreCase).ThenBy((StfoDiagnostic item) => item.Location.Line).ThenBy((StfoDiagnostic item) => item.Location.Column)
				.ToArray(), _visited.OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase).ToArray());
		}

		private void AnalyzeFile(string path, int depth)
		{
			string text = Path.GetRelativePath(_workspace.RootDirectory, path).Replace(Path.DirectorySeparatorChar, '/');
			if (depth > _policy.MaximumImportDepth)
			{
				Add(StfoDiagnosticCode.ImportDepthExceeded, StfoDiagnosticSeverity.Error, $"IMPORT DEPTH EXCEEDS {_policy.MaximumImportDepth}.", text, 1, 1, 1);
			}
			else if (_active.Contains(path))
			{
				Add(StfoDiagnosticCode.CircularImport, StfoDiagnosticSeverity.Error, "CIRCULAR IMPORT DETECTED.", text, 1, 1, 1);
			}
			else
			{
				if (!_visited.Add(path))
				{
					return;
				}
				if (File.Exists(path))
				{
					try
					{
						long num = (long)_policy.MaximumSourceKB * 1024L;
						if (new FileInfo(path).Length > num)
						{
							Add(StfoDiagnosticCode.SourceTooLarge, StfoDiagnosticSeverity.Error, $"SOURCE EXCEEDS {_policy.MaximumSourceKB} KB.", text, 1, 1, 1);
						}
						else
						{
							string source = File.ReadAllText(path);
							StfoLexResult stfoLexResult = new StfoLexer(text, source).Lex();
							_diagnostics.AddRange(stfoLexResult.Diagnostics);
							if (!stfoLexResult.Diagnostics.Any((StfoDiagnostic item) => item.Severity == StfoDiagnosticSeverity.Error))
							{
								StfoProgramSyntax stfoProgramSyntax = new StfoParser(text, stfoLexResult.Tokens).Parse();
								_diagnostics.AddRange(stfoProgramSyntax.Diagnostics);
								StfoManifest stfoManifest = StfoManifest.Parse(text, stfoLexResult.Tokens);
								_diagnostics.AddRange(stfoManifest.Diagnostics);
								ValidateManifest(stfoManifest, stfoProgramSyntax, text);
								AnalyzeProgramSafety(stfoProgramSyntax, text);
							}
							_active.Add(path);
							AnalyzeDirectives(stfoLexResult.Tokens, text);
							AnalyzeImports(stfoLexResult.Tokens, path, text, depth);
							_active.Remove(path);
						}
						return;
					}
					catch (Exception ex)
					{
						Add(StfoDiagnosticCode.IoError, StfoDiagnosticSeverity.Error, "CANNOT READ SCRIPT: " + ex.Message, text, 1, 1, 1);
						return;
					}
				}
				Add(StfoDiagnosticCode.ImportNotFound, StfoDiagnosticSeverity.Error, "SCRIPT FILE NOT FOUND.", text, 1, 1, 1);
			}
		}

		private void AnalyzeDirectives(IReadOnlyList<StfoToken> tokens, string file)
		{
			for (int i = 0; i + 2 < tokens.Count; i++)
			{
				if (tokens[i].Kind != StfoTokenKind.At)
				{
					continue;
				}
				StfoToken stfoToken = tokens[i + 1];
				StfoToken stfoToken2 = tokens[i + 2];
				if (stfoToken.Kind == StfoTokenKind.Identifier && Enum.TryParse<StfoEntryPointKind>(stfoToken.Text, ignoreCase: true, out var _))
				{
					continue;
				}
				if (stfoToken.Kind == StfoTokenKind.Identifier && stfoToken.Text.Equals("STFO", StringComparison.OrdinalIgnoreCase) && stfoToken2.Kind == StfoTokenKind.Number)
				{
					if (stfoToken2.Text != "1")
					{
						Add(StfoDiagnosticCode.UnsupportedLanguageVersion, StfoDiagnosticSeverity.Error, "UNSUPPORTED STFO VERSION " + stfoToken2.Text + ". USE VERSION 1.", file, stfoToken2.Line, stfoToken2.Column, stfoToken2.Text.Length);
					}
					continue;
				}
				if (stfoToken.Kind != StfoTokenKind.Identifier || stfoToken2.Kind != StfoTokenKind.Number || !TryParseLimit(stfoToken.Text, out var kind) || !int.TryParse(stfoToken2.Text, out var result2))
				{
					Add(StfoDiagnosticCode.InvalidDirective, StfoDiagnosticSeverity.Error, "INVALID LIMIT DIRECTIVE.", file, stfoToken.Line, stfoToken.Column, Math.Max(1, stfoToken.Text.Length));
					continue;
				}
				int maximum = _policy.GetMaximum(kind);
				if (result2 > maximum)
				{
					Add(StfoDiagnosticCode.LimitExceedsPolicy, StfoDiagnosticSeverity.Error, $"REQUESTED {kind.ToString().ToUpperInvariant()} {result2} EXCEEDS {maximum}.", file, stfoToken2.Line, stfoToken2.Column, stfoToken2.Text.Length);
				}
			}
		}

		private void AnalyzeImports(IReadOnlyList<StfoToken> tokens, string currentPath, string currentFile, int depth)
		{
			for (int i = 0; i + 1 < tokens.Count; i++)
			{
				StfoToken stfoToken = tokens[i];
				if (stfoToken.Kind != StfoTokenKind.Identifier || !stfoToken.Text.Equals("IMPORT", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				StfoToken stfoToken2 = tokens[i + 1];
				if (stfoToken2.Kind == StfoTokenKind.String)
				{
					string text = Unquote(stfoToken2.Text);
					if (!_workspace.TryResolveScript(text, out string scriptPath, out string error, Path.GetDirectoryName(currentPath)))
					{
						Add(StfoDiagnosticCode.ImportOutsideWorkspace, StfoDiagnosticSeverity.Error, error, currentFile, stfoToken2.Line, stfoToken2.Column, stfoToken2.Text.Length);
					}
					else if (!File.Exists(scriptPath))
					{
						Add(StfoDiagnosticCode.ImportNotFound, StfoDiagnosticSeverity.Error, "IMPORT NOT FOUND: " + text, currentFile, stfoToken2.Line, stfoToken2.Column, stfoToken2.Text.Length);
					}
					else
					{
						AnalyzeFile(scriptPath, depth + 1);
					}
				}
			}
		}

		private static bool TryParseLimit(string text, out StfoLimitKind kind)
		{
			string text2 = text.Replace("_", string.Empty);
			if (text2.Equals("TIMEOUT", StringComparison.OrdinalIgnoreCase))
			{
				text2 = "TimeoutSeconds";
			}
			else if (text2.Equals("MEMORY", StringComparison.OrdinalIgnoreCase))
			{
				text2 = "MemoryKB";
			}
			else if (text2.Equals("CALLDEPTH", StringComparison.OrdinalIgnoreCase))
			{
				text2 = "CallDepth";
			}
			else if (text2.Equals("IMPORTDEPTH", StringComparison.OrdinalIgnoreCase))
			{
				text2 = "ImportDepth";
			}
			else if (text2.Equals("SOURCE", StringComparison.OrdinalIgnoreCase))
			{
				text2 = "SourceKB";
			}
			return Enum.TryParse<StfoLimitKind>(text2, ignoreCase: true, out kind);
		}

		private void AnalyzeProgramSafety(StfoProgramSyntax program, string file)
		{
			foreach (StfoFunctionStatementSyntax item in program.Statements.OfType<StfoFunctionStatementSyntax>())
			{
				bool num = ContainsCall(item.Body, item.Name);
				bool flag = ContainsConditional(item.Body);
				if (num && !flag)
				{
					Add(StfoDiagnosticCode.PossibleUnboundedRecursion, StfoDiagnosticSeverity.Warning, "FUNCTION " + item.Name + " CALLS ITSELF WITHOUT A DETECTABLE IF GUARD.", file, item.Token.Line, item.Token.Column, item.Token.Text.Length);
				}
			}
		}

		private void ValidateManifest(StfoManifest manifest, StfoProgramSyntax program, string file)
		{
			StfoEntryPointKind[] values = Enum.GetValues<StfoEntryPointKind>();
			for (int i = 0; i < values.Length; i++)
			{
				StfoEntryPointKind stfoEntryPointKind = values[i];
				StfoEntryPoint entryPoint = manifest.GetEntryPoint(stfoEntryPointKind);
				if ((object)entryPoint == null)
				{
					continue;
				}
				StfoFunctionStatementSyntax stfoFunctionStatementSyntax = program.Statements.OfType<StfoFunctionStatementSyntax>().FirstOrDefault((StfoFunctionStatementSyntax item) => item.Name.Equals(entryPoint.FunctionName, StringComparison.OrdinalIgnoreCase));
				if ((object)stfoFunctionStatementSyntax == null)
				{
					Add(StfoDiagnosticCode.EntryPointNotFound, StfoDiagnosticSeverity.Error, "ENTRY FUNCTION NOT FOUND: " + entryPoint.FunctionName, file, entryPoint.Token.Line, entryPoint.Token.Column, entryPoint.Token.Text.Length);
					continue;
				}
				int num = ((stfoEntryPointKind != StfoEntryPointKind.Program) ? 1 : 0);
				if (stfoFunctionStatementSyntax.Parameters.Count != num)
				{
					Add(StfoDiagnosticCode.InvalidEntryPointSignature, StfoDiagnosticSeverity.Error, $"{stfoEntryPointKind.ToString().ToUpperInvariant()} ENTRY FUNCTION MUST HAVE {num} PARAMETER(S).", file, stfoFunctionStatementSyntax.Token.Line, stfoFunctionStatementSyntax.Token.Column, stfoFunctionStatementSyntax.Token.Text.Length);
				}
			}
		}

		private static bool ContainsConditional(IEnumerable<StfoStatementSyntax> statements)
		{
			return statements.Any(delegate(StfoStatementSyntax statement)
			{
				if (statement is StfoIfStatementSyntax)
				{
					return true;
				}
				if (statement is StfoForStatementSyntax stfoForStatementSyntax)
				{
					return ContainsConditional(stfoForStatementSyntax.Body);
				}
				return statement is StfoWhileStatementSyntax stfoWhileStatementSyntax && ContainsConditional(stfoWhileStatementSyntax.Body);
			});
		}

		private static bool ContainsCall(IEnumerable<StfoStatementSyntax> statements, string functionName)
		{
			return statements.Any(delegate(StfoStatementSyntax statement)
			{
				if (statement is StfoAssignmentStatementSyntax stfoAssignmentStatementSyntax)
				{
					return ContainsCall(stfoAssignmentStatementSyntax.Expression, functionName);
				}
				if (statement is StfoPrintStatementSyntax stfoPrintStatementSyntax)
				{
					return ContainsCall(stfoPrintStatementSyntax.Expression, functionName);
				}
				if (statement is StfoOutputStatementSyntax stfoOutputStatementSyntax)
				{
					return ContainsCall(stfoOutputStatementSyntax.Expression, functionName);
				}
				if (statement is StfoExpressionStatementSyntax stfoExpressionStatementSyntax)
				{
					return ContainsCall(stfoExpressionStatementSyntax.Expression, functionName);
				}
				if (statement is StfoReturnStatementSyntax stfoReturnStatementSyntax)
				{
					return ContainsCall(stfoReturnStatementSyntax.Expression, functionName);
				}
				if (statement is StfoIfStatementSyntax stfoIfStatementSyntax)
				{
					return ContainsCall(stfoIfStatementSyntax.Condition, functionName) || ContainsCall(stfoIfStatementSyntax.ThenStatements, functionName) || ContainsCall(stfoIfStatementSyntax.ElseStatements, functionName);
				}
				if (statement is StfoForStatementSyntax stfoForStatementSyntax)
				{
					return ContainsCall(stfoForStatementSyntax.Collection, functionName) || ContainsCall(stfoForStatementSyntax.Body, functionName);
				}
				return statement is StfoWhileStatementSyntax stfoWhileStatementSyntax && (ContainsCall(stfoWhileStatementSyntax.Condition, functionName) || ContainsCall(stfoWhileStatementSyntax.Body, functionName));
			});
		}

		private static bool ContainsCall(StfoExpressionSyntax expression, string functionName)
		{
			if (!(expression is StfoCallExpressionSyntax stfoCallExpressionSyntax))
			{
				if (!(expression is StfoUnaryExpressionSyntax stfoUnaryExpressionSyntax))
				{
					if (!(expression is StfoBinaryExpressionSyntax stfoBinaryExpressionSyntax))
					{
						if (expression is StfoListExpressionSyntax stfoListExpressionSyntax)
						{
							return stfoListExpressionSyntax.Items.Any((StfoExpressionSyntax item) => ContainsCall(item, functionName));
						}
						return false;
					}
					return ContainsCall(stfoBinaryExpressionSyntax.Left, functionName) || ContainsCall(stfoBinaryExpressionSyntax.Right, functionName);
				}
				return ContainsCall(stfoUnaryExpressionSyntax.Operand, functionName);
			}
			return stfoCallExpressionSyntax.Name.Equals(functionName, StringComparison.OrdinalIgnoreCase) || stfoCallExpressionSyntax.Arguments.Any((StfoExpressionSyntax argument) => ContainsCall(argument, functionName));
		}

		private static string Unquote(string value)
		{
			if (value.Length < 2)
			{
				return value;
			}
			return value.Substring(1, value.Length - 1 - 1);
		}

		private void Add(StfoDiagnosticCode code, StfoDiagnosticSeverity severity, string message, string file, int line, int column, int length)
		{
			_diagnostics.Add(new StfoDiagnostic(code, severity, message, new StfoSourceLocation(file, line, column, length)));
		}
	}
	internal enum StfoDiagnosticSeverity
	{
		Info,
		Warning,
		Error
	}
	internal enum StfoDiagnosticCode
	{
		InvalidCharacter = 1001,
		UnterminatedString = 1002,
		InvalidNumber = 1003,
		SourceTooLarge = 1004,
		InvalidDirective = 2001,
		LimitExceedsPolicy = 2002,
		UnsupportedLanguageVersion = 2003,
		SyntaxError = 2101,
		UndefinedVariable = 2102,
		InvalidOperation = 2103,
		DivisionByZero = 2104,
		PossibleUnboundedRecursion = 2201,
		DuplicateEntryPoint = 2301,
		EntryPointNotFound = 2302,
		InvalidEntryPointSignature = 2303,
		MissingProgramEntryPoint = 2304,
		MissingPipelineEntryPoint = 2305,
		InstructionLimit = 5001,
		MemoryLimit = 5002,
		TimeLimit = 5003,
		CallDepthLimit = 5004,
		UnknownFunction = 5005,
		ArgumentCountMismatch = 5006,
		ReturnOutsideFunction = 5007,
		CollectionLimit = 5008,
		StringLimit = 5009,
		FileWriteDisabled = 5010,
		ImportNotFound = 3001,
		ImportOutsideWorkspace = 3002,
		CircularImport = 3003,
		ImportDepthExceeded = 3004,
		IoError = 4001
	}
	internal sealed record StfoSourceLocation(string File, int Line, int Column, int Length);
	internal sealed record StfoDiagnostic(StfoDiagnosticCode Code, StfoDiagnosticSeverity Severity, string Message, StfoSourceLocation Location)
	{
		internal string Format()
		{
			return $"{Severity.ToString().ToUpperInvariant()} STFO{Code:D4} {Location.File}:{Location.Line}:{Location.Column} " + Message;
		}
	}
	internal sealed class StfoLexer
	{
		private readonly string _file;

		private readonly string _source;

		private readonly List<StfoToken> _tokens = new List<StfoToken>();

		private readonly List<StfoDiagnostic> _diagnostics = new List<StfoDiagnostic>();

		private int _offset;

		private int _line = 1;

		private int _column = 1;

		private bool IsAtEnd => _offset >= _source.Length;

		private char Current
		{
			get
			{
				if (!IsAtEnd)
				{
					return _source[_offset];
				}
				return '\0';
			}
		}

		internal StfoLexer(string file, string source)
		{
			_file = file;
			_source = source;
		}

		internal StfoLexResult Lex()
		{
			while (!IsAtEnd)
			{
				char current = Current;
				if ((current == '\t' || current == '\r' || current == ' ') ? true : false)
				{
					Advance();
					continue;
				}
				switch (current)
				{
				case '#':
					SkipComment();
					continue;
				case '\n':
					AddSingle(StfoTokenKind.NewLine);
					_line++;
					_column = 1;
					continue;
				}
				if (IsIdentifierStart(current))
				{
					ReadIdentifier();
				}
				else if (char.IsDigit(current))
				{
					ReadNumber();
				}
				else if ((current == '"' || current == '\'') ? true : false)
				{
					ReadString(current);
				}
				else
				{
					ReadSymbol();
				}
			}
			_tokens.Add(new StfoToken(StfoTokenKind.EndOfFile, string.Empty, _line, _column, _offset));
			return new StfoLexResult(_tokens, _diagnostics);
		}

		private void ReadIdentifier()
		{
			int offset = _offset;
			int line = _line;
			int column = _column;
			while (!IsAtEnd && IsIdentifierPart(Current))
			{
				Advance();
			}
			AddToken(StfoTokenKind.Identifier, offset, line, column);
		}

		private void ReadNumber()
		{
			int offset = _offset;
			int line = _line;
			int column = _column;
			while (!IsAtEnd && char.IsDigit(Current))
			{
				Advance();
			}
			if (!IsAtEnd && Current == '.' && char.IsDigit(Peek(1)))
			{
				Advance();
				while (!IsAtEnd && char.IsDigit(Current))
				{
					Advance();
				}
			}
			string source = _source;
			int num = offset;
			string text = source.Substring(num, _offset - num);
			if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var _))
			{
				AddDiagnostic(StfoDiagnosticCode.InvalidNumber, StfoDiagnosticSeverity.Error, "INVALID NUMBER '" + text + "'.", line, column, text.Length);
			}
			_tokens.Add(new StfoToken(StfoTokenKind.Number, text, line, column, offset));
		}

		private void ReadString(char quote)
		{
			int offset = _offset;
			int line = _line;
			int column = _column;
			Advance();
			bool flag = false;
			while (!IsAtEnd && Current != '\n')
			{
				if (Current == '\\' && Peek(1) != 0)
				{
					Advance();
					Advance();
					continue;
				}
				if (Current == quote)
				{
					Advance();
					flag = true;
					break;
				}
				Advance();
			}
			if (!flag)
			{
				AddDiagnostic(StfoDiagnosticCode.UnterminatedString, StfoDiagnosticSeverity.Error, "UNTERMINATED STRING.", line, column, Math.Max(1, _offset - offset));
			}
			AddToken(StfoTokenKind.String, offset, line, column);
		}

		private void ReadSymbol()
		{
			int line = _line;
			int column = _column;
			StfoTokenKind? stfoTokenKind;
			switch (Current)
			{
			case '@':
				stfoTokenKind = StfoTokenKind.At;
				break;
			case '(':
				stfoTokenKind = StfoTokenKind.LeftParenthesis;
				break;
			case ')':
				stfoTokenKind = StfoTokenKind.RightParenthesis;
				break;
			case '[':
				stfoTokenKind = StfoTokenKind.LeftBracket;
				break;
			case ']':
				stfoTokenKind = StfoTokenKind.RightBracket;
				break;
			case ',':
				stfoTokenKind = StfoTokenKind.Comma;
				break;
			case ':':
				stfoTokenKind = StfoTokenKind.Colon;
				break;
			case '.':
				stfoTokenKind = StfoTokenKind.Dot;
				break;
			case '|':
				stfoTokenKind = StfoTokenKind.Pipe;
				break;
			case '+':
				stfoTokenKind = StfoTokenKind.Plus;
				break;
			case '-':
				stfoTokenKind = StfoTokenKind.Minus;
				break;
			case '*':
				stfoTokenKind = StfoTokenKind.Star;
				break;
			case '/':
				stfoTokenKind = StfoTokenKind.Slash;
				break;
			case '=':
				stfoTokenKind = ((Peek(1) != '=') ? new StfoTokenKind?(StfoTokenKind.Assign) : new StfoTokenKind?(StfoTokenKind.EqualEqual));
				break;
			case '!':
				if (Peek(1) == '=')
				{
					stfoTokenKind = StfoTokenKind.NotEqual;
					break;
				}
				goto default;
			case '<':
				stfoTokenKind = ((Peek(1) != '=') ? new StfoTokenKind?(StfoTokenKind.Less) : new StfoTokenKind?(StfoTokenKind.LessOrEqual));
				break;
			case '>':
				stfoTokenKind = ((Peek(1) != '=') ? new StfoTokenKind?(StfoTokenKind.Greater) : new StfoTokenKind?(StfoTokenKind.GreaterOrEqual));
				break;
			default:
				stfoTokenKind = null;
				break;
			}
			StfoTokenKind? stfoTokenKind2 = stfoTokenKind;
			if (!stfoTokenKind2.HasValue)
			{
				AddDiagnostic(StfoDiagnosticCode.InvalidCharacter, StfoDiagnosticSeverity.Error, $"INVALID CHARACTER '{Current}'.", line, column, 1);
				Advance();
				return;
			}
			bool flag;
			switch (stfoTokenKind2)
			{
			case StfoTokenKind.EqualEqual:
			case StfoTokenKind.NotEqual:
			case StfoTokenKind.LessOrEqual:
			case StfoTokenKind.GreaterOrEqual:
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			int num = ((!flag) ? 1 : 2);
			int offset = _offset;
			for (int i = 0; i < num; i++)
			{
				Advance();
			}
			_tokens.Add(new StfoToken(stfoTokenKind2.Value, _source.Substring(offset, num), line, column, offset));
		}

		private void AddSingle(StfoTokenKind kind)
		{
			int offset = _offset;
			int line = _line;
			int column = _column;
			Advance();
			_tokens.Add(new StfoToken(kind, _source[offset].ToString(), line, column, offset));
		}

		private void AddToken(StfoTokenKind kind, int start, int line, int column)
		{
			_tokens.Add(new StfoToken(kind, _source.Substring(start, _offset - start), line, column, start));
		}

		private void SkipComment()
		{
			while (!IsAtEnd && Current != '\n')
			{
				Advance();
			}
		}

		private void AddDiagnostic(StfoDiagnosticCode code, StfoDiagnosticSeverity severity, string message, int line, int column, int length)
		{
			_diagnostics.Add(new StfoDiagnostic(code, severity, message, new StfoSourceLocation(_file, line, column, length)));
		}

		private char Peek(int distance)
		{
			if (_offset + distance < _source.Length)
			{
				return _source[_offset + distance];
			}
			return '\0';
		}

		private void Advance()
		{
			_offset++;
			_column++;
		}

		private static bool IsIdentifierStart(char value)
		{
			if (!char.IsLetter(value))
			{
				return value == '_';
			}
			return true;
		}

		private static bool IsIdentifierPart(char value)
		{
			if (!char.IsLetterOrDigit(value))
			{
				return value == '_';
			}
			return true;
		}
	}
	internal enum StfoEntryPointKind
	{
		Program,
		Pipeline
	}
	internal sealed record StfoEntryPoint(StfoEntryPointKind Kind, string FunctionName, StfoToken Token);
	internal sealed record StfoManifest(StfoEntryPoint? Program, StfoEntryPoint? Pipeline, IReadOnlyList<StfoDiagnostic> Diagnostics)
	{
		internal StfoEntryPoint? GetEntryPoint(StfoEntryPointKind kind)
		{
			return kind switch
			{
				StfoEntryPointKind.Program => Program, 
				StfoEntryPointKind.Pipeline => Pipeline, 
				_ => throw new ArgumentOutOfRangeException("kind"), 
			};
		}

		internal static StfoManifest Parse(string file, IReadOnlyList<StfoToken> tokens)
		{
			StfoEntryPoint stfoEntryPoint = null;
			StfoEntryPoint stfoEntryPoint2 = null;
			List<StfoDiagnostic> list = new List<StfoDiagnostic>();
			for (int i = 0; i + 2 < tokens.Count; i++)
			{
				if (tokens[i].Kind == StfoTokenKind.At && tokens[i + 1].Kind == StfoTokenKind.Identifier && tokens[i + 2].Kind == StfoTokenKind.Identifier && Enum.TryParse<StfoEntryPointKind>(tokens[i + 1].Text, ignoreCase: true, out var result))
				{
					StfoEntryPoint stfoEntryPoint3 = new StfoEntryPoint(result, tokens[i + 2].Text, tokens[i + 1]);
					if (result switch
					{
						StfoEntryPointKind.Program => stfoEntryPoint, 
						StfoEntryPointKind.Pipeline => stfoEntryPoint2, 
						_ => null, 
					} != null)
					{
						list.Add(new StfoDiagnostic(StfoDiagnosticCode.DuplicateEntryPoint, StfoDiagnosticSeverity.Error, "DUPLICATE " + result.ToString().ToUpperInvariant() + " ENTRY POINT.", new StfoSourceLocation(file, tokens[i + 1].Line, tokens[i + 1].Column, tokens[i + 1].Text.Length)));
					}
					else if (result == StfoEntryPointKind.Program)
					{
						stfoEntryPoint = stfoEntryPoint3;
					}
					else
					{
						stfoEntryPoint2 = stfoEntryPoint3;
					}
				}
			}
			return new StfoManifest(stfoEntryPoint, stfoEntryPoint2, list);
		}
	}
	internal sealed class StfoParser
	{
		private readonly string _file;

		private readonly IReadOnlyList<StfoToken> _tokens;

		private readonly List<StfoDiagnostic> _diagnostics = new List<StfoDiagnostic>();

		private int _position;

		private StfoToken Current => Peek(0);

		internal StfoParser(string file, IReadOnlyList<StfoToken> tokens)
		{
			_file = file;
			_tokens = tokens;
		}

		internal StfoProgramSyntax Parse()
		{
			return new StfoProgramSyntax(ParseStatementList(), _diagnostics);
		}

		private IReadOnlyList<StfoStatementSyntax> ParseStatementList(params string[] stopKeywords)
		{
			List<StfoStatementSyntax> list = new List<StfoStatementSyntax>();
			while (Current.Kind != StfoTokenKind.EndOfFile)
			{
				SkipNewLines();
				if (Current.Kind == StfoTokenKind.EndOfFile || stopKeywords.Any(IsKeyword))
				{
					break;
				}
				if (Current.Kind == StfoTokenKind.At)
				{
					SkipLine();
					continue;
				}
				StfoStatementSyntax stfoStatementSyntax = ParseStatement();
				if ((object)stfoStatementSyntax != null)
				{
					list.Add(stfoStatementSyntax);
				}
				StfoTokenKind kind = Current.Kind;
				if ((uint)kind > 1u)
				{
					Report(Current, "EXPECTED END OF LINE.");
					SkipLine();
				}
			}
			return list;
		}

		private StfoStatementSyntax? ParseStatement()
		{
			if (IsKeyword("IMPORT"))
			{
				return ParseImport();
			}
			if (IsKeyword("PRINT"))
			{
				return ParseCommandExpression(isOutput: false);
			}
			if (IsKeyword("OUTPUT"))
			{
				return ParseCommandExpression(isOutput: true);
			}
			if (IsKeyword("IF"))
			{
				return ParseIf();
			}
			if (IsKeyword("FUNCTION"))
			{
				return ParseFunction();
			}
			if (IsKeyword("RETURN"))
			{
				return ParseReturn();
			}
			if (IsKeyword("FOR"))
			{
				return ParseFor();
			}
			if (IsKeyword("WHILE"))
			{
				return ParseWhile();
			}
			if (Current.Kind == StfoTokenKind.Identifier && Peek(1).Kind == StfoTokenKind.Assign)
			{
				StfoToken stfoToken = NextToken();
				NextToken();
				return new StfoAssignmentStatementSyntax(Expression: ParseExpression(), Token: stfoToken, Name: stfoToken.Text);
			}
			StfoExpressionSyntax stfoExpressionSyntax = ParseExpression();
			return new StfoExpressionStatementSyntax(stfoExpressionSyntax.Token, stfoExpressionSyntax);
		}

		private StfoStatementSyntax ParseIf()
		{
			StfoToken stfoToken = NextToken();
			StfoExpressionSyntax condition = ParseExpression();
			RequireBlockLineEnd();
			IReadOnlyList<StfoStatementSyntax> thenStatements = ParseStatementList("ELSE", "END");
			IReadOnlyList<StfoStatementSyntax> elseStatements = Array.Empty<StfoStatementSyntax>();
			if (IsKeyword("ELSE"))
			{
				NextToken();
				RequireBlockLineEnd();
				elseStatements = ParseStatementList("END");
			}
			RequireEnd(stfoToken);
			return new StfoIfStatementSyntax(stfoToken, condition, thenStatements, elseStatements);
		}

		private StfoStatementSyntax ParseFunction()
		{
			StfoToken stfoToken = NextToken();
			if (Current.Kind != StfoTokenKind.Identifier)
			{
				Report(Current, "FUNCTION EXPECTS A NAME.");
				SkipLine();
				return new StfoFunctionStatementSyntax(stfoToken, "INVALID", Array.Empty<string>(), Array.Empty<StfoStatementSyntax>());
			}
			string text = NextToken().Text;
			List<string> list = new List<string>();
			if (!Match(StfoTokenKind.LeftParenthesis))
			{
				Report(Current, "FUNCTION EXPECTS '('.");
			}
			do
			{
				StfoTokenKind kind = Current.Kind;
				if (((uint)kind <= 1u || kind == StfoTokenKind.RightParenthesis) ? true : false)
				{
					break;
				}
				if (Current.Kind != StfoTokenKind.Identifier)
				{
					Report(Current, "EXPECTED PARAMETER NAME.");
					break;
				}
				list.Add(NextToken().Text);
			}
			while (Match(StfoTokenKind.Comma));
			if (!Match(StfoTokenKind.RightParenthesis))
			{
				Report(Current, "FUNCTION EXPECTS ')'.");
			}
			RequireBlockLineEnd();
			IReadOnlyList<StfoStatementSyntax> body = ParseStatementList("END");
			RequireEnd(stfoToken);
			return new StfoFunctionStatementSyntax(stfoToken, text, list, body);
		}

		private StfoStatementSyntax ParseReturn()
		{
			return new StfoReturnStatementSyntax(NextToken(), ParseExpression());
		}

		private StfoStatementSyntax ParseFor()
		{
			StfoToken stfoToken = NextToken();
			if (Current.Kind != StfoTokenKind.Identifier)
			{
				Report(Current, "FOR EXPECTS A VARIABLE NAME.");
				SkipLine();
				return new StfoForStatementSyntax(stfoToken, "INVALID", new StfoLiteralExpressionSyntax(stfoToken, null), Array.Empty<StfoStatementSyntax>());
			}
			string text = NextToken().Text;
			if (!IsKeyword("IN"))
			{
				Report(Current, "FOR EXPECTS IN.");
			}
			else
			{
				NextToken();
			}
			StfoExpressionSyntax collection = ParseExpression();
			RequireBlockLineEnd();
			IReadOnlyList<StfoStatementSyntax> body = ParseStatementList("END");
			RequireEnd(stfoToken);
			return new StfoForStatementSyntax(stfoToken, text, collection, body);
		}

		private StfoStatementSyntax ParseWhile()
		{
			StfoToken stfoToken = NextToken();
			StfoExpressionSyntax condition = ParseExpression();
			RequireBlockLineEnd();
			IReadOnlyList<StfoStatementSyntax> body = ParseStatementList("END");
			RequireEnd(stfoToken);
			return new StfoWhileStatementSyntax(stfoToken, condition, body);
		}

		private StfoStatementSyntax? ParseImport()
		{
			StfoToken token = NextToken();
			if (Current.Kind != StfoTokenKind.String)
			{
				Report(Current, "IMPORT EXPECTS A STRING PATH.");
				return null;
			}
			return new StfoImportStatementSyntax(token, UnescapeString(NextToken().Text));
		}

		private StfoStatementSyntax ParseCommandExpression(bool isOutput)
		{
			StfoToken token = NextToken();
			bool num = Match(StfoTokenKind.LeftParenthesis);
			StfoExpressionSyntax expression = ParseExpression();
			if (num && !Match(StfoTokenKind.RightParenthesis))
			{
				Report(Current, "EXPECTED ')'.");
			}
			if (!isOutput)
			{
				return new StfoPrintStatementSyntax(token, expression);
			}
			return new StfoOutputStatementSyntax(token, expression);
		}

		private StfoExpressionSyntax ParseExpression(int parentPrecedence = 0)
		{
			int unaryPrecedence = GetUnaryPrecedence(Current.Kind);
			StfoExpressionSyntax stfoExpressionSyntax;
			if (unaryPrecedence > 0)
			{
				StfoToken stfoToken = NextToken();
				stfoExpressionSyntax = new StfoUnaryExpressionSyntax(Operand: ParseExpression(unaryPrecedence), Token: stfoToken, Operator: stfoToken.Kind);
			}
			else
			{
				stfoExpressionSyntax = ParsePrimaryExpression();
			}
			while (true)
			{
				int binaryPrecedence = GetBinaryPrecedence(Current.Kind);
				if (binaryPrecedence == 0 || binaryPrecedence <= parentPrecedence)
				{
					break;
				}
				StfoToken stfoToken2 = NextToken();
				StfoExpressionSyntax right = ParseExpression(binaryPrecedence);
				stfoExpressionSyntax = new StfoBinaryExpressionSyntax(stfoToken2, stfoExpressionSyntax, stfoToken2.Kind, right);
			}
			return stfoExpressionSyntax;
		}

		private StfoExpressionSyntax ParsePrimaryExpression()
		{
			if (Current.Kind == StfoTokenKind.LeftBracket)
			{
				return ParseListExpression();
			}
			if (Match(StfoTokenKind.LeftParenthesis))
			{
				StfoExpressionSyntax result = ParseExpression();
				if (!Match(StfoTokenKind.RightParenthesis))
				{
					Report(Current, "EXPECTED ')'.");
				}
				return result;
			}
			StfoToken stfoToken = NextToken();
			if (stfoToken.Kind == StfoTokenKind.Number)
			{
				double.TryParse(stfoToken.Text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2);
				return new StfoLiteralExpressionSyntax(stfoToken, result2);
			}
			if (stfoToken.Kind == StfoTokenKind.String)
			{
				return new StfoLiteralExpressionSyntax(stfoToken, UnescapeString(stfoToken.Text));
			}
			if (stfoToken.Kind == StfoTokenKind.Identifier)
			{
				if (stfoToken.Text.Equals("TRUE", StringComparison.OrdinalIgnoreCase))
				{
					return new StfoLiteralExpressionSyntax(stfoToken, true);
				}
				if (stfoToken.Text.Equals("FALSE", StringComparison.OrdinalIgnoreCase))
				{
					return new StfoLiteralExpressionSyntax(stfoToken, false);
				}
				if (stfoToken.Text.Equals("NONE", StringComparison.OrdinalIgnoreCase))
				{
					return new StfoLiteralExpressionSyntax(stfoToken, null);
				}
				if (Match(StfoTokenKind.LeftParenthesis))
				{
					List<StfoExpressionSyntax> list = new List<StfoExpressionSyntax>();
					do
					{
						StfoTokenKind kind = Current.Kind;
						if (((uint)kind <= 1u || kind == StfoTokenKind.RightParenthesis) ? true : false)
						{
							break;
						}
						list.Add(ParseExpression());
					}
					while (Match(StfoTokenKind.Comma));
					if (!Match(StfoTokenKind.RightParenthesis))
					{
						Report(Current, "EXPECTED ')' AFTER ARGUMENTS.");
					}
					return new StfoCallExpressionSyntax(stfoToken, stfoToken.Text, list);
				}
				return new StfoNameExpressionSyntax(stfoToken, stfoToken.Text);
			}
			Report(stfoToken, $"EXPECTED EXPRESSION, FOUND {stfoToken.Kind}.");
			return new StfoLiteralExpressionSyntax(stfoToken, null);
		}

		private StfoExpressionSyntax ParseListExpression()
		{
			StfoToken token = NextToken();
			List<StfoExpressionSyntax> list = new List<StfoExpressionSyntax>();
			do
			{
				StfoTokenKind kind = Current.Kind;
				if (((uint)kind <= 1u || kind == StfoTokenKind.RightBracket) ? true : false)
				{
					break;
				}
				list.Add(ParseExpression());
			}
			while (Match(StfoTokenKind.Comma));
			if (!Match(StfoTokenKind.RightBracket))
			{
				Report(Current, "EXPECTED ']'.");
			}
			return new StfoListExpressionSyntax(token, list);
		}

		private static int GetUnaryPrecedence(StfoTokenKind kind)
		{
			if ((uint)(kind - 15) <= 1u)
			{
				return 6;
			}
			return 0;
		}

		private static int GetBinaryPrecedence(StfoTokenKind kind)
		{
			switch (kind)
			{
			case StfoTokenKind.Star:
			case StfoTokenKind.Slash:
				return 5;
			case StfoTokenKind.Plus:
			case StfoTokenKind.Minus:
				return 4;
			case StfoTokenKind.Less:
			case StfoTokenKind.LessOrEqual:
			case StfoTokenKind.Greater:
			case StfoTokenKind.GreaterOrEqual:
				return 3;
			case StfoTokenKind.EqualEqual:
			case StfoTokenKind.NotEqual:
				return 2;
			default:
				return 0;
			}
		}

		private bool IsKeyword(string keyword)
		{
			if (Current.Kind == StfoTokenKind.Identifier)
			{
				return Current.Text.Equals(keyword, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private bool Match(StfoTokenKind kind)
		{
			if (Current.Kind != kind)
			{
				return false;
			}
			NextToken();
			return true;
		}

		private void SkipNewLines()
		{
			while (Current.Kind == StfoTokenKind.NewLine)
			{
				NextToken();
			}
		}

		private void SkipLine()
		{
			while (true)
			{
				StfoTokenKind kind = Current.Kind;
				if ((uint)kind > 1u)
				{
					NextToken();
					continue;
				}
				break;
			}
		}

		private void RequireBlockLineEnd()
		{
			if (Current.Kind == StfoTokenKind.NewLine)
			{
				NextToken();
			}
			else if (Current.Kind != StfoTokenKind.EndOfFile)
			{
				Report(Current, "EXPECTED END OF LINE BEFORE BLOCK.");
				SkipLine();
				if (Current.Kind == StfoTokenKind.NewLine)
				{
					NextToken();
				}
			}
		}

		private void RequireEnd(StfoToken openingToken)
		{
			SkipNewLines();
			if (!IsKeyword("END"))
			{
				Report(Current, $"EXPECTED END FOR BLOCK STARTED AT LINE {openingToken.Line}.");
			}
			else
			{
				NextToken();
			}
		}

		private StfoToken NextToken()
		{
			StfoToken current = Current;
			if (_position < _tokens.Count - 1)
			{
				_position++;
			}
			return current;
		}

		private StfoToken Peek(int offset)
		{
			int index = Math.Min(_position + offset, _tokens.Count - 1);
			return _tokens[index];
		}

		private void Report(StfoToken token, string message)
		{
			_diagnostics.Add(new StfoDiagnostic(StfoDiagnosticCode.SyntaxError, StfoDiagnosticSeverity.Error, message, new StfoSourceLocation(_file, token.Line, token.Column, Math.Max(1, token.Text.Length))));
		}

		private static string UnescapeString(string text)
		{
			if (text.Length < 2)
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length - 2);
			for (int i = 1; i < text.Length - 1; i++)
			{
				if (text[i] != '\\' || i + 1 >= text.Length - 1)
				{
					stringBuilder.Append(text[i]);
					continue;
				}
				i++;
				StringBuilder stringBuilder2 = stringBuilder;
				stringBuilder2.Append(text[i] switch
				{
					'n' => '\n', 
					'r' => '\r', 
					't' => '\t', 
					'\\' => '\\', 
					'"' => '"', 
					'\'' => '\'', 
					_ => text[i], 
				});
			}
			return stringBuilder.ToString();
		}
	}
	internal enum StfoLimitKind
	{
		Instructions,
		MemoryKB,
		TimeoutSeconds,
		CallDepth,
		ImportDepth,
		SourceKB,
		CollectionSize,
		StringLength
	}
	internal sealed record StfoPolicy(int MaximumInstructions, int MaximumMemoryKB, int MaximumExecutionSeconds, int MaximumCallDepth, int MaximumImportDepth, int MaximumSourceKB, int MaximumCollectionSize, int MaximumStringLength)
	{
		internal int GetMaximum(StfoLimitKind kind)
		{
			return kind switch
			{
				StfoLimitKind.Instructions => MaximumInstructions, 
				StfoLimitKind.MemoryKB => MaximumMemoryKB, 
				StfoLimitKind.TimeoutSeconds => MaximumExecutionSeconds, 
				StfoLimitKind.CallDepth => MaximumCallDepth, 
				StfoLimitKind.ImportDepth => MaximumImportDepth, 
				StfoLimitKind.SourceKB => MaximumSourceKB, 
				StfoLimitKind.CollectionSize => MaximumCollectionSize, 
				StfoLimitKind.StringLength => MaximumStringLength, 
				_ => throw new ArgumentOutOfRangeException("kind"), 
			};
		}
	}
	internal abstract record StfoSyntaxNode(StfoToken Token);
	internal sealed record StfoProgramSyntax(IReadOnlyList<StfoStatementSyntax> Statements, IReadOnlyList<StfoDiagnostic> Diagnostics);
	internal abstract record StfoStatementSyntax : StfoSyntaxNode
	{
		protected StfoStatementSyntax(StfoToken Token)
			: base(Token)
		{
		}

		[CompilerGenerated]
		public new void Deconstruct(out StfoToken Token)
		{
			Token = base.Token;
		}
	}
	internal sealed record StfoImportStatementSyntax : StfoStatementSyntax
	{
		public string Path { get; init; }

		public StfoImportStatementSyntax(StfoToken Token, string Path)
		{
			this.Path = Path;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out string Path)
		{
			Token = base.Token;
			Path = this.Path;
		}
	}
	internal sealed record StfoAssignmentStatementSyntax : StfoStatementSyntax
	{
		public string Name { get; init; }

		public StfoExpressionSyntax Expression { get; init; }

		public StfoAssignmentStatementSyntax(StfoToken Token, string Name, StfoExpressionSyntax Expression)
		{
			this.Name = Name;
			this.Expression = Expression;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out string Name, out StfoExpressionSyntax Expression)
		{
			Token = base.Token;
			Name = this.Name;
			Expression = this.Expression;
		}
	}
	internal sealed record StfoPrintStatementSyntax : StfoStatementSyntax
	{
		public StfoExpressionSyntax Expression { get; init; }

		public StfoPrintStatementSyntax(StfoToken Token, StfoExpressionSyntax Expression)
		{
			this.Expression = Expression;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoExpressionSyntax Expression)
		{
			Token = base.Token;
			Expression = this.Expression;
		}
	}
	internal sealed record StfoOutputStatementSyntax : StfoStatementSyntax
	{
		public StfoExpressionSyntax Expression { get; init; }

		public StfoOutputStatementSyntax(StfoToken Token, StfoExpressionSyntax Expression)
		{
			this.Expression = Expression;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoExpressionSyntax Expression)
		{
			Token = base.Token;
			Expression = this.Expression;
		}
	}
	internal sealed record StfoExpressionStatementSyntax : StfoStatementSyntax
	{
		public StfoExpressionSyntax Expression { get; init; }

		public StfoExpressionStatementSyntax(StfoToken Token, StfoExpressionSyntax Expression)
		{
			this.Expression = Expression;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoExpressionSyntax Expression)
		{
			Token = base.Token;
			Expression = this.Expression;
		}
	}
	internal sealed record StfoIfStatementSyntax : StfoStatementSyntax
	{
		public StfoExpressionSyntax Condition { get; init; }

		public IReadOnlyList<StfoStatementSyntax> ThenStatements { get; init; }

		public IReadOnlyList<StfoStatementSyntax> ElseStatements { get; init; }

		public StfoIfStatementSyntax(StfoToken Token, StfoExpressionSyntax Condition, IReadOnlyList<StfoStatementSyntax> ThenStatements, IReadOnlyList<StfoStatementSyntax> ElseStatements)
		{
			this.Condition = Condition;
			this.ThenStatements = ThenStatements;
			this.ElseStatements = ElseStatements;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoExpressionSyntax Condition, out IReadOnlyList<StfoStatementSyntax> ThenStatements, out IReadOnlyList<StfoStatementSyntax> ElseStatements)
		{
			Token = base.Token;
			Condition = this.Condition;
			ThenStatements = this.ThenStatements;
			ElseStatements = this.ElseStatements;
		}
	}
	internal sealed record StfoFunctionStatementSyntax : StfoStatementSyntax
	{
		public string Name { get; init; }

		public IReadOnlyList<string> Parameters { get; init; }

		public IReadOnlyList<StfoStatementSyntax> Body { get; init; }

		public StfoFunctionStatementSyntax(StfoToken Token, string Name, IReadOnlyList<string> Parameters, IReadOnlyList<StfoStatementSyntax> Body)
		{
			this.Name = Name;
			this.Parameters = Parameters;
			this.Body = Body;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out string Name, out IReadOnlyList<string> Parameters, out IReadOnlyList<StfoStatementSyntax> Body)
		{
			Token = base.Token;
			Name = this.Name;
			Parameters = this.Parameters;
			Body = this.Body;
		}
	}
	internal sealed record StfoReturnStatementSyntax : StfoStatementSyntax
	{
		public StfoExpressionSyntax Expression { get; init; }

		public StfoReturnStatementSyntax(StfoToken Token, StfoExpressionSyntax Expression)
		{
			this.Expression = Expression;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoExpressionSyntax Expression)
		{
			Token = base.Token;
			Expression = this.Expression;
		}
	}
	internal sealed record StfoForStatementSyntax : StfoStatementSyntax
	{
		public string Variable { get; init; }

		public StfoExpressionSyntax Collection { get; init; }

		public IReadOnlyList<StfoStatementSyntax> Body { get; init; }

		public StfoForStatementSyntax(StfoToken Token, string Variable, StfoExpressionSyntax Collection, IReadOnlyList<StfoStatementSyntax> Body)
		{
			this.Variable = Variable;
			this.Collection = Collection;
			this.Body = Body;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out string Variable, out StfoExpressionSyntax Collection, out IReadOnlyList<StfoStatementSyntax> Body)
		{
			Token = base.Token;
			Variable = this.Variable;
			Collection = this.Collection;
			Body = this.Body;
		}
	}
	internal sealed record StfoWhileStatementSyntax : StfoStatementSyntax
	{
		public StfoExpressionSyntax Condition { get; init; }

		public IReadOnlyList<StfoStatementSyntax> Body { get; init; }

		public StfoWhileStatementSyntax(StfoToken Token, StfoExpressionSyntax Condition, IReadOnlyList<StfoStatementSyntax> Body)
		{
			this.Condition = Condition;
			this.Body = Body;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoExpressionSyntax Condition, out IReadOnlyList<StfoStatementSyntax> Body)
		{
			Token = base.Token;
			Condition = this.Condition;
			Body = this.Body;
		}
	}
	internal abstract record StfoExpressionSyntax : StfoSyntaxNode
	{
		protected StfoExpressionSyntax(StfoToken Token)
			: base(Token)
		{
		}

		[CompilerGenerated]
		public new void Deconstruct(out StfoToken Token)
		{
			Token = base.Token;
		}
	}
	internal sealed record StfoLiteralExpressionSyntax : StfoExpressionSyntax
	{
		public object? Value { get; init; }

		public StfoLiteralExpressionSyntax(StfoToken Token, object? Value)
		{
			this.Value = Value;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out object? Value)
		{
			Token = base.Token;
			Value = this.Value;
		}
	}
	internal sealed record StfoNameExpressionSyntax : StfoExpressionSyntax
	{
		public string Name { get; init; }

		public StfoNameExpressionSyntax(StfoToken Token, string Name)
		{
			this.Name = Name;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out string Name)
		{
			Token = base.Token;
			Name = this.Name;
		}
	}
	internal sealed record StfoUnaryExpressionSyntax : StfoExpressionSyntax
	{
		public StfoTokenKind Operator { get; init; }

		public StfoExpressionSyntax Operand { get; init; }

		public StfoUnaryExpressionSyntax(StfoToken Token, StfoTokenKind Operator, StfoExpressionSyntax Operand)
		{
			this.Operator = Operator;
			this.Operand = Operand;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoTokenKind Operator, out StfoExpressionSyntax Operand)
		{
			Token = base.Token;
			Operator = this.Operator;
			Operand = this.Operand;
		}
	}
	internal sealed record StfoBinaryExpressionSyntax : StfoExpressionSyntax
	{
		public StfoExpressionSyntax Left { get; init; }

		public StfoTokenKind Operator { get; init; }

		public StfoExpressionSyntax Right { get; init; }

		public StfoBinaryExpressionSyntax(StfoToken Token, StfoExpressionSyntax Left, StfoTokenKind Operator, StfoExpressionSyntax Right)
		{
			this.Left = Left;
			this.Operator = Operator;
			this.Right = Right;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out StfoExpressionSyntax Left, out StfoTokenKind Operator, out StfoExpressionSyntax Right)
		{
			Token = base.Token;
			Left = this.Left;
			Operator = this.Operator;
			Right = this.Right;
		}
	}
	internal sealed record StfoCallExpressionSyntax : StfoExpressionSyntax
	{
		public string Name { get; init; }

		public IReadOnlyList<StfoExpressionSyntax> Arguments { get; init; }

		public StfoCallExpressionSyntax(StfoToken Token, string Name, IReadOnlyList<StfoExpressionSyntax> Arguments)
		{
			this.Name = Name;
			this.Arguments = Arguments;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out string Name, out IReadOnlyList<StfoExpressionSyntax> Arguments)
		{
			Token = base.Token;
			Name = this.Name;
			Arguments = this.Arguments;
		}
	}
	internal sealed record StfoListExpressionSyntax : StfoExpressionSyntax
	{
		public IReadOnlyList<StfoExpressionSyntax> Items { get; init; }

		public StfoListExpressionSyntax(StfoToken Token, IReadOnlyList<StfoExpressionSyntax> Items)
		{
			this.Items = Items;
			base..ctor(Token);
		}

		[CompilerGenerated]
		public void Deconstruct(out StfoToken Token, out IReadOnlyList<StfoExpressionSyntax> Items)
		{
			Token = base.Token;
			Items = this.Items;
		}
	}
	internal enum StfoTokenKind
	{
		EndOfFile,
		NewLine,
		Identifier,
		Number,
		String,
		At,
		LeftParenthesis,
		RightParenthesis,
		LeftBracket,
		RightBracket,
		Comma,
		Colon,
		Dot,
		Assign,
		Pipe,
		Plus,
		Minus,
		Star,
		Slash,
		EqualEqual,
		NotEqual,
		Less,
		LessOrEqual,
		Greater,
		GreaterOrEqual
	}
	internal sealed record StfoToken(StfoTokenKind Kind, string Text, int Line, int Column, int Offset);
	internal sealed record StfoLexResult(IReadOnlyList<StfoToken> Tokens, IReadOnlyList<StfoDiagnostic> Diagnostics);
}