using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Scriban.Functions;
using Scriban.Helpers;
using Scriban.Parsing;
using Scriban.Runtime;
using Scriban.Runtime.Accessors;
using Scriban.Syntax;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Scriban.Tests")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Alexandre Mutel")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Alexandre Mutel")]
[assembly: AssemblyDescription("Scriban is a fast, powerful, safe and lightweight scripting language and engine for .NET, which was primarily developed for text templating with a compatibility mode for parsing liquid templates.")]
[assembly: AssemblyFileVersion("6.5.7.0")]
[assembly: AssemblyInformationalVersion("6.5.7+44876ae9de7b2855f1eb51d041c7b3ce5e1fe224")]
[assembly: AssemblyProduct("Scriban")]
[assembly: AssemblyTitle("Scriban")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/scriban/scriban")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("6.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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 Scriban
{
	[DebuggerDisplay("Count: {Count}")]
	public class LogMessageBag : IReadOnlyList<LogMessage>, IEnumerable<LogMessage>, IEnumerable, IReadOnlyCollection<LogMessage>
	{
		private readonly List<LogMessage> _messages;

		public int Count => _messages.Count;

		public LogMessage this[int index] => _messages[index];

		public bool HasErrors { get; private set; }

		public LogMessageBag()
		{
			_messages = new List<LogMessage>();
		}

		public void Add(LogMessage message)
		{
			if (message == null)
			{
				throw new ArgumentNullException("message");
			}
			if (message.Type == ParserMessageType.Error)
			{
				HasErrors = true;
			}
			_messages.Add(message);
		}

		public void AddRange(IEnumerable<LogMessage> messages)
		{
			if (messages == null)
			{
				throw new ArgumentNullException("messages");
			}
			foreach (LogMessage message in messages)
			{
				Add(message);
			}
		}

		public IEnumerator<LogMessage> GetEnumerator()
		{
			return _messages.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable)_messages).GetEnumerator();
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (LogMessage message in _messages)
			{
				stringBuilder.AppendLine(message.ToString());
			}
			return stringBuilder.ToString();
		}
	}
	public class Template
	{
		public string SourceFilePath { get; }

		public ScriptPage Page { get; private set; }

		public bool HasErrors { get; private set; }

		public LogMessageBag Messages { get; }

		public ParserOptions ParserOptions { get; }

		public LexerOptions LexerOptions { get; }

		private async ValueTask<object> EvaluateAndRenderAsync(TemplateContext context, bool render)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			CheckErrors();
			if (SourceFilePath != null)
			{
				context.PushSourceFile(SourceFilePath);
			}
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				object result = await context.EvaluateAsync(Page).ConfigureAwait(continueOnCapturedContext: false);
				if (render && Page != null && context.EnableOutput && result != null)
				{
					await context.WriteAsync(Page.Span, result).ConfigureAwait(continueOnCapturedContext: false);
				}
				return result;
			}
			finally
			{
				if (SourceFilePath != null)
				{
					context.PopSourceFile();
				}
			}
		}

		public async ValueTask<object> EvaluateAsync(TemplateContext context)
		{
			bool previousOutput = context.EnableOutput;
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				context.EnableOutput = false;
				return await EvaluateAndRenderAsync(context, render: false).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				context.EnableOutput = previousOutput;
			}
		}

		public static async ValueTask<object> EvaluateAsync(string expression, TemplateContext context)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = default(LexerOptions);
			lexerOptions.Mode = ScriptMode.ScriptOnly;
			LexerOptions value = lexerOptions;
			LexerOptions? lexerOptions2 = value;
			return await Parse(expression, null, null, lexerOptions2).EvaluateAsync(context).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async ValueTask<object> EvaluateAsync(object model = null, MemberRenamerDelegate memberRenamer = null, MemberFilterDelegate memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext context = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			context.EnableOutput = false;
			context.MemberRenamer = memberRenamer;
			context.MemberFilter = memberFilter;
			context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
			context.PushGlobal(scriptObject);
			object result = await EvaluateAsync(context).ConfigureAwait(continueOnCapturedContext: false);
			context.PopGlobal();
			return result;
		}

		public static async ValueTask<object> EvaluateAsync(string expression, object model, MemberRenamerDelegate memberRenamer = null, MemberFilterDelegate memberFilter = null)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = default(LexerOptions);
			lexerOptions.Mode = ScriptMode.ScriptOnly;
			LexerOptions value = lexerOptions;
			LexerOptions? lexerOptions2 = value;
			return await Parse(expression, null, null, lexerOptions2).EvaluateAsync(model, memberRenamer, memberFilter).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async ValueTask<string> RenderAsync(TemplateContext context)
		{
			await EvaluateAndRenderAsync(context, render: true).ConfigureAwait(continueOnCapturedContext: false);
			string? result = context.Output.ToString();
			if (context.Output is StringBuilderOutput stringBuilderOutput)
			{
				stringBuilderOutput.Builder.Length = 0;
			}
			return result;
		}

		public async ValueTask<string> RenderAsync(object model = null, MemberRenamerDelegate memberRenamer = null, MemberFilterDelegate memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext templateContext = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			templateContext.MemberRenamer = memberRenamer;
			templateContext.MemberFilter = memberFilter;
			templateContext.PushGlobal(scriptObject);
			return await RenderAsync(templateContext).ConfigureAwait(continueOnCapturedContext: false);
		}

		private Template(ParserOptions? parserOptions, LexerOptions? lexerOptions, string sourceFilePath)
		{
			ParserOptions = parserOptions.GetValueOrDefault();
			LexerOptions = lexerOptions.GetValueOrDefault();
			Messages = new LogMessageBag();
			SourceFilePath = sourceFilePath;
		}

		public static Template Parse(string text, string sourceFilePath = null, ParserOptions? parserOptions = null, LexerOptions? lexerOptions = null)
		{
			Template template = new Template(parserOptions, lexerOptions, sourceFilePath);
			template.ParseInternal(text, sourceFilePath);
			return template;
		}

		public static Template ParseLiquid(string text, string sourceFilePath = null, ParserOptions? parserOptions = null, LexerOptions? lexerOptions = null)
		{
			LexerOptions valueOrDefault = lexerOptions.GetValueOrDefault();
			valueOrDefault.Lang = ScriptLang.Liquid;
			return Parse(text, sourceFilePath, parserOptions, valueOrDefault);
		}

		public static object Evaluate(string expression, TemplateContext context)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = default(LexerOptions);
			lexerOptions.Mode = ScriptMode.ScriptOnly;
			LexerOptions value = lexerOptions;
			LexerOptions? lexerOptions2 = value;
			return Parse(expression, null, null, lexerOptions2).Evaluate(context);
		}

		public static object Evaluate(string expression, object model, MemberRenamerDelegate memberRenamer = null, MemberFilterDelegate memberFilter = null)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = default(LexerOptions);
			lexerOptions.Mode = ScriptMode.ScriptOnly;
			LexerOptions value = lexerOptions;
			LexerOptions? lexerOptions2 = value;
			return Parse(expression, null, null, lexerOptions2).Evaluate(model, memberRenamer, memberFilter);
		}

		public object Evaluate(TemplateContext context)
		{
			bool enableOutput = context.EnableOutput;
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				context.EnableOutput = false;
				return EvaluateAndRender(context, render: false);
			}
			finally
			{
				context.EnableOutput = enableOutput;
			}
		}

		public object Evaluate(object model = null, MemberRenamerDelegate memberRenamer = null, MemberFilterDelegate memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext templateContext = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			templateContext.EnableOutput = false;
			templateContext.MemberRenamer = memberRenamer;
			templateContext.MemberFilter = memberFilter;
			templateContext.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
			templateContext.PushGlobal(scriptObject);
			object result = Evaluate(templateContext);
			templateContext.PopGlobal();
			return result;
		}

		public string Render(TemplateContext context)
		{
			EvaluateAndRender(context, render: true);
			string? result = context.Output.ToString();
			if (context.Output is StringBuilderOutput stringBuilderOutput)
			{
				stringBuilderOutput.Builder.Length = 0;
			}
			return result;
		}

		public string Render(object model = null, MemberRenamerDelegate memberRenamer = null, MemberFilterDelegate memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext templateContext = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			templateContext.MemberRenamer = memberRenamer;
			templateContext.MemberFilter = memberFilter;
			templateContext.PushGlobal(scriptObject);
			return Render(templateContext);
		}

		public string ToText(ScriptPrinterOptions options = default(ScriptPrinterOptions))
		{
			CheckErrors();
			TextWriterOutput textWriterOutput = new TextWriterOutput();
			new ScriptPrinter(textWriterOutput, options).Write(Page);
			return textWriterOutput.ToString();
		}

		private object EvaluateAndRender(TemplateContext context, bool render)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			CheckErrors();
			if (SourceFilePath != null)
			{
				context.PushSourceFile(SourceFilePath);
			}
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				object obj = context.Evaluate(Page);
				if (render && Page != null && context.EnableOutput && obj != null)
				{
					context.Write(Page.Span, obj);
				}
				return obj;
			}
			finally
			{
				if (SourceFilePath != null)
				{
					context.PopSourceFile();
				}
			}
		}

		private void CheckErrors()
		{
			if (HasErrors)
			{
				throw new InvalidOperationException("This template has errors. Check the <Template.HasError> and <Template.Messages> before evaluating a template. Messages:\n" + string.Join("\n", Messages));
			}
		}

		private void ParseInternal(string text, string sourceFilePath)
		{
			if (string.IsNullOrEmpty(text))
			{
				HasErrors = false;
				Page = new ScriptPage
				{
					Span = new SourceSpan(sourceFilePath, default(TextPosition), TextPosition.Eof)
				};
			}
			else
			{
				Parser parser = new Parser(new Lexer(text, sourceFilePath, LexerOptions), ParserOptions);
				Page = parser.Run();
				HasErrors = parser.HasErrors;
				Messages.AddRange(parser.Messages);
			}
		}
	}
	public class TemplateContext : IFormatProvider
	{
		public delegate bool TryGetMemberDelegate(TemplateContext context, SourceSpan span, object target, string member, out object value);

		public delegate bool TryGetVariableDelegate(TemplateContext context, SourceSpan span, ScriptVariable variable, out object value);

		public delegate string RenderRuntimeExceptionDelegate(ScriptRuntimeException exception);

		internal enum LoopType
		{
			Default,
			Queryable
		}

		private class VariableContext
		{
			public IScriptObject LocalObject;

			public FastStack<ScriptObject> Loops;

			public VariableContext(IScriptObject localObject)
			{
				LocalObject = localObject;
				Loops = new FastStack<ScriptObject>(4);
			}
		}

		private enum VariableScope
		{
			Local,
			Loop
		}

		[CompilerGenerated]
		private sealed class <GetStoreForRead>d__306 : IEnumerable<IScriptObject>, IEnumerable, IEnumerator<IScriptObject>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private IScriptObject <>2__current;

			private int <>l__initialThreadId;

			private ScriptVariable variable;

			public ScriptVariable <>3__variable;

			public TemplateContext <>4__this;

			private bool <isInLoop>5__2;

			private int <i>5__3;

			private VariableContext <context>5__4;

			private ScriptObject[] <loopItems>5__5;

			private int <j>5__6;

			IScriptObject IEnumerator<IScriptObject>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetStoreForRead>d__306(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<context>5__4 = null;
				<loopItems>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				TemplateContext templateContext = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					ScriptVariableScope scope = variable.Scope;
					if (scope != 0)
					{
						if (scope == ScriptVariableScope.Local)
						{
							<loopItems>5__5 = templateContext._currentLocalContext.Loops.Items;
							<i>5__3 = templateContext._currentLocalContext.Loops.Count - 1;
							goto IL_01bf;
						}
						throw new NotImplementedException($"Variable scope `{scope}` is not implemented");
					}
					<isInLoop>5__2 = templateContext.IsInLoop;
					<i>5__3 = templateContext._globalContexts.Count - 1;
					goto IL_0149;
				}
				case 1:
					<>1__state = -1;
					<j>5__6--;
					goto IL_00ff;
				case 2:
					<>1__state = -1;
					<context>5__4 = null;
					<i>5__3--;
					goto IL_0149;
				case 3:
					<>1__state = -1;
					<i>5__3--;
					goto IL_01bf;
				case 4:
					<>1__state = -1;
					break;
				case 5:
					{
						<>1__state = -1;
						break;
					}
					IL_0149:
					if (<i>5__3 < 0)
					{
						break;
					}
					<context>5__4 = templateContext._globalContexts.Items[<i>5__3];
					if (<isInLoop>5__2)
					{
						int count = <context>5__4.Loops.Count;
						if (count > 0)
						{
							<loopItems>5__5 = <context>5__4.Loops.Items;
							<j>5__6 = count - 1;
							goto IL_00ff;
						}
					}
					goto IL_010f;
					IL_010f:
					<>2__current = <context>5__4.LocalObject;
					<>1__state = 2;
					return true;
					IL_01bf:
					if (<i>5__3 >= 0)
					{
						<>2__current = <loopItems>5__5[<i>5__3];
						<>1__state = 3;
						return true;
					}
					if (templateContext._currentLocalContext.LocalObject != null)
					{
						<>2__current = templateContext._currentLocalContext.LocalObject;
						<>1__state = 4;
						return true;
					}
					if (templateContext._globalContexts.Count > 0)
					{
						<>2__current = templateContext._globalContexts.Peek().LocalObject;
						<>1__state = 5;
						return true;
					}
					throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the local variable `{variable}` in the current context");
					IL_00ff:
					if (<j>5__6 >= 0)
					{
						<>2__current = <loopItems>5__5[<j>5__6];
						<>1__state = 1;
						return true;
					}
					<loopItems>5__5 = null;
					goto IL_010f;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<IScriptObject> IEnumerable<IScriptObject>.GetEnumerator()
			{
				<GetStoreForRead>d__306 <GetStoreForRead>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetStoreForRead>d__ = this;
				}
				else
				{
					<GetStoreForRead>d__ = new <GetStoreForRead>d__306(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetStoreForRead>d__.variable = <>3__variable;
				return <GetStoreForRead>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<IScriptObject>)this).GetEnumerator();
			}
		}

		private FastStack<ScriptObject> _availableStores;

		internal FastStack<ScriptBlockStatement> BlockDelegates;

		private FastStack<VariableContext> _globalContexts;

		private FastStack<CultureInfo> _cultures;

		private readonly Dictionary<Type, IListAccessor> _listAccessors;

		private FastStack<ScriptLoopStatementBase> _loops;

		private readonly Dictionary<Type, IObjectAccessor> _memberAccessors;

		private FastStack<IScriptOutput> _outputs;

		private FastStack<VariableContext> _localContexts;

		private VariableContext _currentLocalContext;

		private IScriptOutput _output;

		private FastStack<string> _sourceFiles;

		private FastStack<object> _caseValues;

		private int _callDepth;

		private bool _isFunctionCallDisabled;

		private int _loopStep;

		private int _getOrSetValueLevel;

		private FastStack<VariableContext> _availableGlobalContexts;

		private FastStack<VariableContext> _availableLocalContexts;

		private FastStack<ScriptPipeArguments> _availablePipeArguments;

		private FastStack<ScriptPipeArguments> _pipeArguments;

		private FastStack<List<ScriptExpression>> _availableScriptExpressionLists;

		private object[][] _availableReflectionArguments;

		private ScriptPipeArguments _currentPipeArguments;

		private bool _previousTextWasNewLine;

		private readonly IEqualityComparer<string> _keyComparer;

		public static RenderRuntimeExceptionDelegate RenderRuntimeExceptionDefault = (ScriptRuntimeException ex) => $"[{ex.OriginalMessage}]";

		private static readonly object TrueObject = true;

		private static readonly object FalseObject = false;

		private int _objectToStringLevel;

		private int _currentToStringLength;

		internal bool AllowPipeArguments => _getOrSetValueLevel <= 1;

		public CultureInfo CurrentCulture
		{
			get
			{
				if (_cultures.Count != 0)
				{
					return _cultures.Peek();
				}
				return CultureInfo.InvariantCulture;
			}
		}

		public ITemplateLoader TemplateLoader { get; set; }

		public bool IsLiquid { get; protected set; }

		public bool AutoIndent { get; set; }

		public bool IndentOnEmptyLines { get; set; }

		[Obsolete("Use AutoIndent instead. Note that AutoIndent is true by default.")]
		public bool IndentWithInclude
		{
			get
			{
				return AutoIndent;
			}
			set
			{
				AutoIndent = value;
			}
		}

		public int LimitToString { get; set; }

		public int ObjectRecursionLimit { get; set; }

		public string NewLine { get; set; }

		public ScriptLang Language { get; set; }

		public CancellationToken CancellationToken { get; set; }

		public ParserOptions TemplateLoaderParserOptions { get; set; }

		public LexerOptions TemplateLoaderLexerOptions { get; set; }

		public MemberRenamerDelegate MemberRenamer { get; set; }

		public MemberFilterDelegate MemberFilter { get; set; }

		public int LoopLimit { get; set; }

		public int? LoopLimitQueryable { get; set; }

		public int RecursiveLimit { get; set; }

		public bool EnableOutput { get; set; }

		public IScriptOutput Output => _output;

		public bool UseScientific { get; set; }

		public bool ErrorForStatementFunctionAsExpression { get; set; }

		public ScriptObject BuiltinObject { get; }

		public IScriptObject CurrentGlobal => _globalContexts.Peek()?.LocalObject;

		public Dictionary<string, Template> CachedTemplates { get; }

		public string CurrentSourceFile => _sourceFiles.Peek();

		public TryGetVariableDelegate TryGetVariable { get; set; }

		public RenderRuntimeExceptionDelegate RenderRuntimeException { get; set; }

		public TryGetMemberDelegate TryGetMember { get; set; }

		public Dictionary<object, object> Tags { get; }

		internal ScriptPipeArguments CurrentPipeArguments => _currentPipeArguments;

		public int GlobalCount => _globalContexts.Count;

		public int OutputCount => _outputs.Count;

		public int CultureCount => _cultures.Count;

		public int SourceFileCount => _sourceFiles.Count;

		internal ScriptFlowState FlowState { get; set; }

		public TimeSpan RegexTimeOut { get; set; }

		public bool StrictVariables { get; set; }

		public bool EnableBreakAndContinueAsReturnOutsideLoop { get; set; }

		public bool EnableRelaxedTargetAccess { get; set; }

		public bool EnableRelaxedMemberAccess { get; set; }

		public bool EnableRelaxedFunctionAccess { get; set; }

		public bool EnableRelaxedIndexerAccess { get; set; }

		public bool EnableNullIndexer { get; set; }

		public ScriptNode CurrentNode { get; private set; }

		public SourceSpan CurrentSpan => CurrentNode?.Span ?? default(SourceSpan);

		public string CurrentIndent { get; set; }

		internal bool IsInLoop => _loops.Count > 0;

		internal bool IgnoreExceptionsWhileRewritingScientific { get; set; }

		protected virtual async ValueTask<Template> CreateTemplateAsync(string templatePath, ScriptNode callerContext)
		{
			string text;
			try
			{
				text = await TemplateLoader.LoadAsync(this, callerContext.Span, templatePath).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(callerContext.Span, "Unexpected exception while creating template from path `" + templatePath + "`", ex);
			}
			if (text == null)
			{
				throw new ScriptRuntimeException(callerContext.Span, "The result of including `" + templatePath + "` cannot be null");
			}
			Template template = Template.Parse(text, templatePath, TemplateLoaderParserOptions, TemplateLoaderLexerOptions);
			if (template.HasErrors)
			{
				throw new ScriptParserRuntimeException(callerContext.Span, "Error while parsing template `" + templatePath + "`", template.Messages);
			}
			CachedTemplates.Add(templatePath, template);
			return template;
		}

		public virtual async ValueTask<object> EvaluateAsync(ScriptNode scriptNode, bool aliasReturnedFunction)
		{
			if (scriptNode == null)
			{
				return null;
			}
			bool previousFunctionCallState = _isFunctionCallDisabled;
			int previousLevel = _getOrSetValueLevel;
			ScriptNode previousNode = CurrentNode;
			try
			{
				CurrentNode = scriptNode;
				_getOrSetValueLevel = 0;
				_isFunctionCallDisabled = aliasReturnedFunction;
				return await scriptNode.EvaluateAsync(this).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (ScriptRuntimeException exception) when (RenderRuntimeException != null)
			{
				return RenderRuntimeException(exception);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				ScriptRuntimeException ex2 = new ScriptRuntimeException(scriptNode.Span, ex.Message, ex);
				if (RenderRuntimeException != null)
				{
					return RenderRuntimeException(ex2);
				}
				throw ex2;
			}
			finally
			{
				CurrentNode = previousNode;
				_getOrSetValueLevel = previousLevel;
				_isFunctionCallDisabled = previousFunctionCallState;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public async ValueTask<object> EvaluateAsync(ScriptNode scriptNode)
		{
			return await EvaluateAsync(scriptNode, aliasReturnedFunction: false).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async ValueTask<Template> GetOrCreateTemplateAsync(string templatePath, ScriptNode callerContext)
		{
			if (!CachedTemplates.TryGetValue(templatePath, out var value))
			{
				value = await CreateTemplateAsync(templatePath, callerContext).ConfigureAwait(continueOnCapturedContext: false);
				CachedTemplates[templatePath] = value;
			}
			return value;
		}

		private async ValueTask<object> GetOrSetValueAsync(ScriptExpression targetExpression, object valueToSet, bool setter)
		{
			object value = null;
			try
			{
				if (targetExpression is IScriptVariablePath scriptVariablePath)
				{
					if (setter)
					{
						await scriptVariablePath.SetValueAsync(this, valueToSet).ConfigureAwait(continueOnCapturedContext: false);
					}
					else
					{
						value = await scriptVariablePath.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
					}
				}
				else
				{
					if (setter)
					{
						throw new ScriptRuntimeException(targetExpression.Span, "Unsupported target expression for assignment.");
					}
					value = await EvaluateAsync(targetExpression).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			catch (Exception ex) when (_getOrSetValueLevel == 1 && !(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(targetExpression.Span, "Unexpected exception while accessing target expression: " + ex.Message, ex);
			}
			if (((_isFunctionCallDisabled && _getOrSetValueLevel > 1) || !_isFunctionCallDisabled) && ScriptFunctionCall.IsFunction(value))
			{
				value = await ScriptFunctionCall.CallAsync(this, targetExpression, value, _getOrSetValueLevel == 1, null).ConfigureAwait(continueOnCapturedContext: false);
			}
			return value;
		}

		public async ValueTask<object> GetValueAsync(ScriptExpression target)
		{
			ScriptNode previousNode = CurrentNode;
			_getOrSetValueLevel++;
			try
			{
				CurrentNode = target;
				return await GetOrSetValueAsync(target, null, setter: false).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				CurrentNode = previousNode;
				_getOrSetValueLevel--;
			}
		}

		public async ValueTask<string> RenderTemplateAsync(Template template, ScriptArray arguments, ScriptNode callerContext)
		{
			string result = null;
			EnterRecursive(callerContext);
			string previousIndent = CurrentIndent;
			CurrentIndent = null;
			PushOutput();
			PushLocal();
			try
			{
				SetValue(ScriptVariable.Arguments, arguments, asReadOnly: true, force: true);
				IEnumerable<ScriptNamedArgument> enumerable = (callerContext as ScriptFunctionCall)?.Arguments.OfType<ScriptNamedArgument>();
				if (enumerable != null)
				{
					foreach (ScriptNamedArgument item in enumerable)
					{
						string name = item.Name.Name;
						object value = await item.Value.EvaluateAsync(this).ConfigureAwait(continueOnCapturedContext: false);
						ScriptVariable variable = ScriptVariable.Create(name, ScriptVariableScope.Local);
						SetValue(variable, value, asReadOnly: false, force: true);
					}
				}
				if (previousIndent != null)
				{
					ResetPreviousNewLine();
				}
				result = await template.RenderAsync(this).ConfigureAwait(continueOnCapturedContext: false);
				if (previousIndent != null)
				{
					ResetPreviousNewLine();
				}
			}
			finally
			{
				PopLocal();
				PopOutput();
				CurrentIndent = previousIndent;
				ExitRecursive(callerContext);
			}
			return result;
		}

		public async ValueTask SetValueAsync(ScriptExpression target, object value)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			_getOrSetValueLevel++;
			try
			{
				await GetOrSetValueAsync(target, value, setter: true).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				_getOrSetValueLevel--;
			}
		}

		public async ValueTask<TemplateContext> WriteAsync(string text, int startIndex, int count)
		{
			if (text != null)
			{
				if (CurrentIndent != null)
				{
					int index = startIndex;
					int indexEnd = startIndex + count;
					while (index < indexEnd)
					{
						int newLineIndex = text.IndexOf('\n', index);
						if (newLineIndex < 0 || newLineIndex >= indexEnd)
						{
							if (_previousTextWasNewLine)
							{
								await Output.WriteAsync(CurrentIndent, 0, CurrentIndent.Length, CancellationToken).ConfigureAwait(continueOnCapturedContext: false);
								_previousTextWasNewLine = false;
							}
							await Output.WriteAsync(text, index, indexEnd - index, CancellationToken).ConfigureAwait(continueOnCapturedContext: false);
							break;
						}
						int length = newLineIndex - index;
						if (_previousTextWasNewLine && (IndentOnEmptyLines || (length != 0 && (length != 1 || text[index] != '\r'))))
						{
							await Output.WriteAsync(CurrentIndent, 0, CurrentIndent.Length, CancellationToken).ConfigureAwait(continueOnCapturedContext: false);
							_previousTextWasNewLine = false;
						}
						await Output.WriteAsync(text, index, length + 1, CancellationToken).ConfigureAwait(continueOnCapturedContext: false);
						index = newLineIndex + 1;
						_previousTextWasNewLine = true;
					}
				}
				else
				{
					if (count > 0)
					{
						_previousTextWasNewLine = text[startIndex + count - 1] == '\n';
					}
					await Output.WriteAsync(text, startIndex, count, CancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			return this;
		}

		public async ValueTask<TemplateContext> WriteAsync(string text)
		{
			if (text != null)
			{
				await WriteAsync(text, 0, text.Length).ConfigureAwait(continueOnCapturedContext: false);
			}
			return this;
		}

		public async ValueTask<TemplateContext> WriteAsync(ScriptStringSlice slice)
		{
			await WriteAsync(slice.FullText, slice.Index, slice.Length).ConfigureAwait(continueOnCapturedContext: false);
			return this;
		}

		public virtual async ValueTask<TemplateContext> WriteAsync(SourceSpan span, object textAsObject)
		{
			if (textAsObject != null)
			{
				string text = ObjectToString(textAsObject);
				await WriteAsync(text).ConfigureAwait(continueOnCapturedContext: false);
			}
			return this;
		}

		public async ValueTask<TemplateContext> WriteLineAsync()
		{
			await WriteAsync(NewLine).ConfigureAwait(continueOnCapturedContext: false);
			return this;
		}

		public TemplateContext()
			: this(null, null)
		{
		}

		public TemplateContext(ScriptObject builtin)
			: this(builtin, null)
		{
		}

		public TemplateContext(IEqualityComparer<string> keyComparer)
			: this(null, keyComparer)
		{
		}

		public TemplateContext(ScriptObject builtin, IEqualityComparer<string> keyComparer)
		{
			BuiltinObject = builtin ?? GetDefaultBuiltinObject();
			EnableOutput = true;
			EnableBreakAndContinueAsReturnOutsideLoop = false;
			EnableRelaxedTargetAccess = false;
			EnableRelaxedMemberAccess = true;
			EnableRelaxedFunctionAccess = false;
			EnableRelaxedIndexerAccess = true;
			AutoIndent = true;
			IndentOnEmptyLines = true;
			LoopLimit = 1000;
			RecursiveLimit = 100;
			LimitToString = 0;
			ObjectRecursionLimit = 0;
			MemberRenamer = StandardMemberRenamer.Default;
			RegexTimeOut = TimeSpan.FromSeconds(10.0);
			TemplateLoaderParserOptions = default(ParserOptions);
			TemplateLoaderLexerOptions = LexerOptions.Default;
			NewLine = Environment.NewLine;
			Language = ScriptLang.Default;
			_outputs = new FastStack<IScriptOutput>(4);
			_output = new StringBuilderOutput();
			_outputs.Push(_output);
			_globalContexts = new FastStack<VariableContext>(4);
			_availableGlobalContexts = new FastStack<VariableContext>(4);
			_availableLocalContexts = new FastStack<VariableContext>(4);
			_localContexts = new FastStack<VariableContext>(4);
			_availableStores = new FastStack<ScriptObject>(4);
			_cultures = new FastStack<CultureInfo>(4);
			_caseValues = new FastStack<object>(4);
			_sourceFiles = new FastStack<string>(4);
			_memberAccessors = new Dictionary<Type, IObjectAccessor>();
			_listAccessors = new Dictionary<Type, IListAccessor>();
			_loops = new FastStack<ScriptLoopStatementBase>(4);
			BlockDelegates = new FastStack<ScriptBlockStatement>(4);
			_availablePipeArguments = new FastStack<ScriptPipeArguments>(4);
			_pipeArguments = new FastStack<ScriptPipeArguments>(4);
			_availableScriptExpressionLists = new FastStack<List<ScriptExpression>>(4);
			_availableReflectionArguments = new object[65][];
			_keyComparer = keyComparer;
			for (int i = 0; i < _availableReflectionArguments.Length; i++)
			{
				_availableReflectionArguments[i] = new object[i];
			}
			_isFunctionCallDisabled = false;
			CachedTemplates = new Dictionary<string, Template>();
			Tags = new Dictionary<object, object>();
			PushGlobal(BuiltinObject);
		}

		public void CheckAbort()
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			CancellationToken cancellationToken = CancellationToken;
			if (cancellationToken.IsCancellationRequested)
			{
				throw new ScriptAbortException(CurrentNode?.Span ?? default(SourceSpan), cancellationToken);
			}
		}

		public void PushCulture(CultureInfo culture)
		{
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			_cultures.Push(culture);
		}

		public CultureInfo PopCulture()
		{
			if (_cultures.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopCulture more than PushCulture");
			}
			return _cultures.Pop();
		}

		internal void PushPipeArguments()
		{
			ScriptPipeArguments scriptPipeArguments = ((_availablePipeArguments.Count > 0) ? _availablePipeArguments.Pop() : new ScriptPipeArguments(1));
			_pipeArguments.Push(scriptPipeArguments);
			_currentPipeArguments = scriptPipeArguments;
		}

		internal void ClearPipeArguments()
		{
			while (_pipeArguments.Count > 0)
			{
				PopPipeArguments();
			}
		}

		internal List<ScriptExpression> GetOrCreateListOfScriptExpressions(int capacity)
		{
			List<ScriptExpression> list = ((_availableScriptExpressionLists.Count > 0) ? _availableScriptExpressionLists.Pop() : new List<ScriptExpression>());
			if (capacity > list.Capacity)
			{
				list.Capacity = capacity;
			}
			return list;
		}

		internal void ReleaseListOfScriptExpressions(List<ScriptExpression> list)
		{
			_availableScriptExpressionLists.Push(list);
			list.Clear();
		}

		internal object[] GetOrCreateReflectionArguments(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			if (length >= _availableReflectionArguments.Length)
			{
				return new object[length];
			}
			object[] array = _availableReflectionArguments[length] ?? new object[length];
			if (length > 0)
			{
				_availableReflectionArguments[length] = (object[])array[0];
				array[0] = null;
			}
			return array;
		}

		internal void ReleaseReflectionArguments(object[] reflectionArguments)
		{
			if (reflectionArguments != null && reflectionArguments.Length < _availableReflectionArguments.Length)
			{
				Array.Clear(reflectionArguments, 0, reflectionArguments.Length);
				object[] array = _availableReflectionArguments[reflectionArguments.Length];
				_availableReflectionArguments[reflectionArguments.Length] = reflectionArguments;
				if (reflectionArguments.Length != 0)
				{
					reflectionArguments[0] = array;
				}
			}
		}

		internal void PopPipeArguments()
		{
			if (_pipeArguments.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopPipeArguments more than PushPipeArguments");
			}
			ScriptPipeArguments scriptPipeArguments = _pipeArguments.Pop();
			scriptPipeArguments.Clear();
			_currentPipeArguments = ((_pipeArguments.Count > 0) ? _pipeArguments.Peek() : null);
			_availablePipeArguments.Push(scriptPipeArguments);
		}

		public void PushSourceFile(string sourceFile)
		{
			if (sourceFile == null)
			{
				throw new ArgumentNullException("sourceFile");
			}
			_sourceFiles.Push(sourceFile);
		}

		public string PopSourceFile()
		{
			if (_sourceFiles.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopSourceFile more than PushSourceFile");
			}
			return _sourceFiles.Pop();
		}

		public object GetValue(ScriptExpression target)
		{
			ScriptNode currentNode = CurrentNode;
			_getOrSetValueLevel++;
			try
			{
				CurrentNode = target;
				return GetOrSetValue(target, null, setter: false);
			}
			finally
			{
				CurrentNode = currentNode;
				_getOrSetValueLevel--;
			}
		}

		public void SetValue(ScriptVariable variable, bool value)
		{
			SetValue(variable, value ? TrueObject : FalseObject);
		}

		public virtual void Import(SourceSpan span, object objectToImport)
		{
			if (!(objectToImport is ScriptObject))
			{
				throw new ScriptRuntimeException(span, "Unexpected value `" + GetTypeName(objectToImport) + "` for import. Expecting an plain script object.");
			}
			CurrentGlobal.Import(objectToImport);
		}

		public void SetValue(ScriptExpression target, object value)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			_getOrSetValueLevel++;
			try
			{
				GetOrSetValue(target, value, setter: true);
			}
			finally
			{
				_getOrSetValueLevel--;
			}
		}

		public void PushOutput()
		{
			PushOutput(new StringBuilderOutput());
		}

		public void PushOutput(IScriptOutput output)
		{
			_output = output ?? throw new ArgumentNullException("output");
			_outputs.Push(_output);
		}

		public IScriptOutput PopOutput()
		{
			if (_outputs.Count == 1)
			{
				throw new InvalidOperationException("Unexpected PopOutput for top level writer");
			}
			IScriptOutput result = _outputs.Pop();
			_output = _outputs.Peek();
			return result;
		}

		public virtual TemplateContext Write(SourceSpan span, object textAsObject)
		{
			if (textAsObject != null)
			{
				string text = ObjectToString(textAsObject);
				Write(text);
			}
			return this;
		}

		public TemplateContext Write(string text)
		{
			if (text != null)
			{
				Write(text, 0, text.Length);
			}
			return this;
		}

		public TemplateContext WriteLine()
		{
			Write(NewLine);
			return this;
		}

		public TemplateContext Write(ScriptStringSlice slice)
		{
			Write(slice.FullText, slice.Index, slice.Length);
			return this;
		}

		public TemplateContext Write(string text, int startIndex, int count)
		{
			if (text != null)
			{
				if (CurrentIndent != null)
				{
					int num = startIndex;
					int num2 = startIndex + count;
					while (num < num2)
					{
						int num3 = text.IndexOf('\n', num);
						if (num3 < 0 || num3 >= num2)
						{
							if (_previousTextWasNewLine)
							{
								Output.Write(CurrentIndent, 0, CurrentIndent.Length);
								_previousTextWasNewLine = false;
							}
							Output.Write(text, num, num2 - num);
							break;
						}
						int num4 = num3 - num;
						if (_previousTextWasNewLine && (IndentOnEmptyLines || (num4 != 0 && (num4 != 1 || text[num] != '\r'))))
						{
							Output.Write(CurrentIndent, 0, CurrentIndent.Length);
							_previousTextWasNewLine = false;
						}
						Output.Write(text, num, num4 + 1);
						num = num3 + 1;
						_previousTextWasNewLine = true;
					}
				}
				else
				{
					if (count > 0)
					{
						_previousTextWasNewLine = text[startIndex + count - 1] == '\n';
					}
					Output.Write(text, startIndex, count);
				}
			}
			return this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public object Evaluate(ScriptNode scriptNode)
		{
			return Evaluate(scriptNode, aliasReturnedFunction: false);
		}

		public virtual object Evaluate(ScriptNode scriptNode, bool aliasReturnedFunction)
		{
			if (scriptNode == null)
			{
				return null;
			}
			bool isFunctionCallDisabled = _isFunctionCallDisabled;
			int getOrSetValueLevel = _getOrSetValueLevel;
			ScriptNode currentNode = CurrentNode;
			try
			{
				CurrentNode = scriptNode;
				_getOrSetValueLevel = 0;
				_isFunctionCallDisabled = aliasReturnedFunction;
				return scriptNode.Evaluate(this);
			}
			catch (ScriptRuntimeException exception) when (RenderRuntimeException != null)
			{
				return RenderRuntimeException(exception);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				ScriptRuntimeException ex2 = new ScriptRuntimeException(scriptNode.Span, ex.Message, ex);
				if (RenderRuntimeException != null)
				{
					return RenderRuntimeException(ex2);
				}
				throw ex2;
			}
			finally
			{
				CurrentNode = currentNode;
				_getOrSetValueLevel = getOrSetValueLevel;
				_isFunctionCallDisabled = isFunctionCallDisabled;
			}
		}

		public IObjectAccessor GetMemberAccessor(object target)
		{
			if (target == null)
			{
				return NullAccessor.Default;
			}
			Type type = target.GetType();
			if (!_memberAccessors.TryGetValue(type, out var value))
			{
				value = GetMemberAccessorImpl(target) ?? NullAccessor.Default;
				_memberAccessors.Add(type, value);
			}
			return value;
		}

		public virtual void Reset()
		{
			while (OutputCount > 1)
			{
				PopOutput();
			}
			((StringBuilderOutput)Output).Builder.Length = 0;
			while (GlobalCount > 1)
			{
				PopGlobal();
			}
			while (CultureCount > 0)
			{
				PopCulture();
			}
			while (SourceFileCount > 0)
			{
				PopSourceFile();
			}
		}

		protected virtual IObjectAccessor GetMemberAccessorImpl(object target)
		{
			Type type = target.GetType();
			if (target is IScriptObject)
			{
				return ScriptObjectAccessor.Default;
			}
			if (target is string)
			{
				return StringAccessor.Default;
			}
			if (type.IsPrimitiveOrDecimal())
			{
				return PrimitiveAccessor.Default;
			}
			if (!DictionaryAccessor.TryGet(target, out var accessor))
			{
				if (type.IsArray)
				{
					return ArrayAccessor.Default;
				}
				if (target is IList)
				{
					return ListAccessor.Default;
				}
				return new TypedObjectAccessor(type, _keyComparer, MemberFilter, MemberRenamer);
			}
			return accessor;
		}

		public static ScriptObject GetDefaultBuiltinObject()
		{
			return new BuiltinFunctions();
		}

		public void EnterRecursive(ScriptNode node)
		{
			try
			{
				RuntimeHelpers.EnsureSufficientExecutionStack();
			}
			catch (InsufficientExecutionStackException)
			{
				throw new ScriptRuntimeException(node.Span, "Exceeding recursive depth limit, near to stack overflow");
			}
			_callDepth++;
			if (RecursiveLimit != 0 && _callDepth > RecursiveLimit)
			{
				throw new ScriptRuntimeException(node.Span, $"Exceeding number of recursive depth limit `{RecursiveLimit}` for node: `{node}`");
			}
		}

		public void ExitRecursive(ScriptNode node)
		{
			_callDepth--;
			if (_callDepth < 0)
			{
				throw new ScriptRuntimeException(node.Span, $"unexpected ExitRecursive not matching EnterRecursive for `{node}`");
			}
		}

		internal void EnterFunction(ScriptNode caller)
		{
			EnterRecursive(caller);
		}

		internal void ExitFunction(ScriptNode caller)
		{
			ExitRecursive(caller);
		}

		internal void EnterLoop(ScriptLoopStatementBase loop)
		{
			if (loop == null)
			{
				throw new ArgumentNullException("loop");
			}
			_loops.Push(loop);
			PushVariableScope(VariableScope.Loop);
			OnEnterLoop(loop);
		}

		protected virtual void OnEnterLoop(ScriptLoopStatementBase loop)
		{
		}

		internal void ExitLoop(ScriptLoopStatementBase loop)
		{
			try
			{
				OnExitLoop(loop);
			}
			finally
			{
				PopVariableScope(VariableScope.Loop);
				_loops.Pop();
				if (!IsInLoop)
				{
					_loopStep = 0;
				}
			}
		}

		protected virtual void OnExitLoop(ScriptLoopStatementBase loop)
		{
		}

		internal bool StepLoop(ScriptLoopStatementBase loop, LoopType loopType = LoopType.Default)
		{
			_loopStep++;
			int num = ((loopType != LoopType.Queryable) ? LoopLimit : LoopLimitQueryable.GetValueOrDefault(LoopLimit));
			if (num != 0 && _loopStep > num)
			{
				throw new ScriptRuntimeException(_loops.Peek().Span, $"Exceeding number of iteration limit `{num}` for loop statement.");
			}
			return OnStepLoop(loop);
		}

		protected virtual bool OnStepLoop(ScriptLoopStatementBase loop)
		{
			return true;
		}

		internal void PushCase(object caseValue)
		{
			_caseValues.Push(caseValue);
		}

		internal object PeekCase()
		{
			return _caseValues.Peek();
		}

		internal object PopCase()
		{
			if (_caseValues.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopCase more than PushCase");
			}
			return _caseValues.Pop();
		}

		private object GetOrSetValue(ScriptExpression targetExpression, object valueToSet, bool setter)
		{
			object obj = null;
			try
			{
				if (targetExpression is IScriptVariablePath scriptVariablePath)
				{
					if (setter)
					{
						scriptVariablePath.SetValue(this, valueToSet);
					}
					else
					{
						obj = scriptVariablePath.GetValue(this);
					}
				}
				else
				{
					if (setter)
					{
						throw new ScriptRuntimeException(targetExpression.Span, "Unsupported target expression for assignment.");
					}
					obj = Evaluate(targetExpression);
				}
			}
			catch (Exception ex) when (_getOrSetValueLevel == 1 && !(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(targetExpression.Span, "Unexpected exception while accessing target expression: " + ex.Message, ex);
			}
			if (((_isFunctionCallDisabled && _getOrSetValueLevel > 1) || !_isFunctionCallDisabled) && ScriptFunctionCall.IsFunction(obj))
			{
				obj = ScriptFunctionCall.Call(this, targetExpression, obj, _getOrSetValueLevel == 1, null);
			}
			return obj;
		}

		public IListAccessor GetListAccessor(object target)
		{
			Type type = target.GetType();
			if (!_listAccessors.TryGetValue(type, out var value))
			{
				value = GetListAccessorImpl(target, type);
				_listAccessors.Add(type, value);
			}
			return value;
		}

		protected virtual IListAccessor GetListAccessorImpl(object target, Type type)
		{
			if (type.IsArray)
			{
				return ArrayAccessor.Default;
			}
			if (type == typeof(string))
			{
				return StringAccessor.Default;
			}
			if (type.IsPrimitiveOrDecimal())
			{
				return PrimitiveAccessor.Default;
			}
			if (target is IList)
			{
				return ListAccessor.Default;
			}
			return null;
		}

		public void ResetPreviousNewLine()
		{
			_previousTextWasNewLine = false;
		}

		public virtual string GetTemplatePathFromName(string templateName, ScriptNode callerContext)
		{
			if (string.IsNullOrEmpty(templateName))
			{
				throw new ScriptRuntimeException(callerContext.Span, "Include template name cannot be null or empty");
			}
			return ConvertTemplateNameToPath(templateName, callerContext);
		}

		protected string ConvertTemplateNameToPath(string templateName, ScriptNode callerContext)
		{
			if (TemplateLoader == null)
			{
				throw new ScriptRuntimeException(callerContext.Span, "Unable to include <" + templateName + ">. No TemplateLoader registered in TemplateContext.TemplateLoader");
			}
			string path;
			try
			{
				path = TemplateLoader.GetPath(this, callerContext.Span, templateName);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(callerContext.Span, "Unexpected exception while getting the path for the include name `" + templateName + "`", ex);
			}
			if (path == null)
			{
				throw new ScriptRuntimeException(callerContext.Span, "Include template path is null for `" + templateName);
			}
			return path;
		}

		public Template GetOrCreateTemplate(string templatePath, ScriptNode callerContext)
		{
			if (!CachedTemplates.TryGetValue(templatePath, out var value))
			{
				value = CreateTemplate(templatePath, callerContext);
				CachedTemplates[templatePath] = value;
			}
			return value;
		}

		protected virtual Template CreateTemplate(string templatePath, ScriptNode callerContext)
		{
			string text;
			try
			{
				text = TemplateLoader.Load(this, callerContext.Span, templatePath);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(callerContext.Span, "Unexpected exception while creating template from path `" + templatePath + "`", ex);
			}
			if (text == null)
			{
				throw new ScriptRuntimeException(callerContext.Span, "The result of including `" + templatePath + "` cannot be null");
			}
			Template template = Template.Parse(text, templatePath, TemplateLoaderParserOptions, TemplateLoaderLexerOptions);
			if (template.HasErrors)
			{
				throw new ScriptParserRuntimeException(callerContext.Span, "Error while parsing template `" + templatePath + "`", template.Messages);
			}
			CachedTemplates.Add(templatePath, template);
			return template;
		}

		public string RenderTemplate(Template template, ScriptArray arguments, ScriptNode callerContext)
		{
			string result = null;
			EnterRecursive(callerContext);
			string currentIndent = CurrentIndent;
			CurrentIndent = null;
			PushOutput();
			PushLocal();
			try
			{
				SetValue(ScriptVariable.Arguments, arguments, asReadOnly: true, force: true);
				IEnumerable<ScriptNamedArgument> enumerable = (callerContext as ScriptFunctionCall)?.Arguments.OfType<ScriptNamedArgument>();
				if (enumerable != null)
				{
					foreach (ScriptNamedArgument item in enumerable)
					{
						string name = item.Name.Name;
						object value = item.Value.Evaluate(this);
						ScriptVariable variable = ScriptVariable.Create(name, ScriptVariableScope.Local);
						SetValue(variable, value, asReadOnly: false, force: true);
					}
				}
				if (currentIndent != null)
				{
					ResetPreviousNewLine();
				}
				result = template.Render(this);
				if (currentIndent != null)
				{
					ResetPreviousNewLine();
				}
			}
			finally
			{
				PopLocal();
				PopOutput();
				CurrentIndent = currentIndent;
				ExitRecursive(callerContext);
			}
			return result;
		}

		public object GetFormat(Type formatType)
		{
			return CurrentCulture.GetFormat(formatType);
		}

		public virtual object IsEmpty(SourceSpan span, object against)
		{
			if (against == null)
			{
				return null;
			}
			if (against is IList)
			{
				return ((IList)against).Count == 0;
			}
			if (against is IEnumerable)
			{
				return !((IEnumerable)against).GetEnumerator().MoveNext();
			}
			if (against.GetType().IsPrimitiveOrDecimal())
			{
				return false;
			}
			return GetMemberAccessor(against).GetMemberCount(this, span, against) > 0;
		}

		public virtual IList ToList(SourceSpan span, object value)
		{
			if (value == null)
			{
				return null;
			}
			if (value is IList)
			{
				return (IList)value;
			}
			return new ScriptArray((value as IEnumerable) ?? throw new ScriptRuntimeException(span, "Unexpected list value. Expecting an array, list or iterator. Unable to convert to a list."));
		}

		public virtual string ObjectToString(object value, bool nested = false)
		{
			if (_objectToStringLevel == 0)
			{
				_currentToStringLength = 0;
			}
			try
			{
				_objectToStringLevel++;
				if (ObjectRecursionLimit != 0 && _objectToStringLevel > ObjectRecursionLimit)
				{
					throw new InvalidOperationException("Structure is too deeply nested or contains reference loops.");
				}
				string text = ObjectToStringImpl(value, nested);
				if (LimitToString > 0 && _objectToStringLevel == 1 && text != null && text.Length >= LimitToString)
				{
					return text + "...";
				}
				return text;
			}
			finally
			{
				_objectToStringLevel--;
			}
		}

		private string ObjectToStringImpl(object value, bool nested)
		{
			if (LimitToString > 0 && _currentToStringLength >= LimitToString)
			{
				return string.Empty;
			}
			if (value is string text)
			{
				if (LimitToString > 0 && _currentToStringLength + text.Length >= LimitToString)
				{
					int num = LimitToString - _currentToStringLength;
					if (num <= 0)
					{
						return string.Empty;
					}
					string text2 = text.Substring(0, num);
					if (!nested)
					{
						return text2;
					}
					return "\"" + StringFunctions.Escape(text2);
				}
				if (!nested)
				{
					return text;
				}
				return "\"" + StringFunctions.Escape(text) + "\"";
			}
			if (value == null || value == EmptyScriptObject.Default)
			{
				if (!nested)
				{
					return null;
				}
				return "null";
			}
			if (value is bool)
			{
				if (!(bool)value)
				{
					return "false";
				}
				return "true";
			}
			if (value is DateTime value2)
			{
				bool strictVariables = StrictVariables;
				try
				{
					StrictVariables = false;
					if (GetValue(DateTimeFunctions.DateVariable) is DateTimeFunctions dateTimeFunctions)
					{
						return dateTimeFunctions.ToString(value2, dateTimeFunctions.Format, CurrentCulture);
					}
				}
				finally
				{
					StrictVariables = strictVariables;
				}
			}
			if (value is IFormattable formattable)
			{
				return formattable.ToString(null, this);
			}
			if (value is IConvertible convertible)
			{
				return convertible.ToString(this);
			}
			if (value is IEnumerable enumerable)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("[");
				_currentToStringLength++;
				bool flag = true;
				foreach (object item in enumerable)
				{
					if (!flag)
					{
						stringBuilder.Append(", ");
						_currentToStringLength += 2;
					}
					string text3 = ObjectToString(item, nested: true);
					stringBuilder.Append(text3);
					if (text3 != null)
					{
						_currentToStringLength += text3.Length;
					}
					if (LimitToString > 0 && _currentToStringLength >= LimitToString)
					{
						return stringBuilder.ToString();
					}
					flag = false;
				}
				stringBuilder.Append("]");
				_currentToStringLength++;
				return stringBuilder.ToString();
			}
			string fullName = value.GetType().FullName;
			if (fullName != null && fullName.StartsWith("System.Collections.Generic.KeyValuePair"))
			{
				ScriptObject scriptObject = new ScriptObject(2);
				scriptObject.Import(value, null, MemberRenamer);
				return ObjectToString(scriptObject, nested: true);
			}
			if (value is IScriptCustomFunction && !(value is ScriptFunction))
			{
				return "<function>";
			}
			return value.ToString();
		}

		public virtual bool ToBool(SourceSpan span, object value)
		{
			if (value == null || value == EmptyScriptObject.Default)
			{
				return false;
			}
			if (value is bool)
			{
				return (bool)value;
			}
			if (UseScientific)
			{
				Type type = value.GetType();
				if (type.IsPrimitive || type == typeof(decimal))
				{
					return Convert.ToBoolean(value);
				}
				if (value is BigInteger bigInteger)
				{
					return bigInteger != BigInteger.Zero;
				}
			}
			return true;
		}

		public virtual int ToInt(SourceSpan span, object value)
		{
			if (value == null)
			{
				return 0;
			}
			if (value is int)
			{
				return (int)value;
			}
			checked
			{
				try
				{
					if (value is BigInteger bigInteger)
					{
						return (int)bigInteger;
					}
					if (value is IScriptConvertibleTo scriptConvertibleTo && scriptConvertibleTo.TryConvertTo(this, span, typeof(int), out object value2))
					{
						return (int)value2;
					}
					if (value is uint num)
					{
						return (int)num;
					}
					if (value is ulong num2)
					{
						return (int)num2;
					}
					return Convert.ToInt32(value, CurrentCulture);
				}
				catch (Exception innerException)
				{
					throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to int", innerException);
				}
			}
		}

		public virtual string GetTypeName(object value)
		{
			if (value == null)
			{
				return "null";
			}
			if (value is Type type)
			{
				return type.ScriptPrettyName();
			}
			if (value is IScriptCustomTypeInfo scriptCustomTypeInfo)
			{
				return scriptCustomTypeInfo.TypeName;
			}
			return value.GetType().ScriptPrettyName();
		}

		public T ToObject<T>(SourceSpan span, object value)
		{
			return (T)ToObject(span, value, typeof(T));
		}

		public virtual object ToObject(SourceSpan span, object value, Type destinationType)
		{
			if (destinationType == null)
			{
				throw new ArgumentNullException("destinationType");
			}
			(bool IsNullable, Type DestinationType) tuple = GetNullableInfo(destinationType);
			bool item = tuple.IsNullable;
			destinationType = tuple.DestinationType;
			Type type = value?.GetType();
			if (destinationType == type)
			{
				return value;
			}
			if (item && value == null)
			{
				return null;
			}
			if (destinationType == typeof(string))
			{
				return ObjectToString(value);
			}
			if (destinationType == typeof(int))
			{
				return ToInt(span, value);
			}
			if (destinationType == typeof(bool))
			{
				return ToBool(span, value);
			}
			if (value == null)
			{
				if (destinationType == typeof(double))
				{
					return 0.0;
				}
				if (destinationType == typeof(float))
				{
					return 0f;
				}
				if (destinationType == typeof(long))
				{
					return 0L;
				}
				if (destinationType == typeof(decimal))
				{
					return 0m;
				}
				if (destinationType == typeof(BigInteger))
				{
					return new BigInteger(0);
				}
				return null;
			}
			if (destinationType.IsEnum)
			{
				try
				{
					if (value is string value2)
					{
						return Enum.Parse(destinationType, value2);
					}
					return Enum.ToObject(destinationType, value);
				}
				catch (Exception innerException)
				{
					throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to `" + GetTypeName(destinationType) + "`", innerException);
				}
			}
			if (value is IScriptConvertibleTo scriptConvertibleTo && scriptConvertibleTo.TryConvertTo(this, span, destinationType, out object value3))
			{
				return value3;
			}
			if (typeof(IScriptConvertibleFrom).IsAssignableFrom(destinationType))
			{
				IScriptConvertibleFrom scriptConvertibleFrom = (IScriptConvertibleFrom)Activator.CreateInstance(destinationType);
				if (scriptConvertibleFrom.TryConvertFrom(this, span, value))
				{
					return scriptConvertibleFrom;
				}
			}
			Type c = type;
			if (type.IsPrimitiveOrDecimal() && destinationType.IsPrimitiveOrDecimal())
			{
				try
				{
					if (destinationType == typeof(BigInteger))
					{
						if (type == typeof(char))
						{
							return new BigInteger((char)value);
						}
						if (type == typeof(bool))
						{
							return new BigInteger(((bool)value) ? 1 : 0);
						}
						if (type == typeof(float))
						{
							return new BigInteger((float)value);
						}
						if (type == typeof(double))
						{
							return new BigInteger((double)value);
						}
						if (type == typeof(int))
						{
							return new BigInteger((int)value);
						}
						if (type == typeof(uint))
						{
							return new BigInteger((uint)value);
						}
						if (type == typeof(long))
						{
							return new BigInteger((long)value);
						}
						if (type == typeof(ulong))
						{
							return new BigInteger((ulong)value);
						}
					}
					else if (type == typeof(BigInteger))
					{
						if (destinationType == typeof(char))
						{
							return (char)(int)(BigInteger)value;
						}
						if (destinationType == typeof(float))
						{
							return (float)(BigInteger)value;
						}
						if (destinationType == typeof(double))
						{
							return (double)(BigInteger)value;
						}
						if (destinationType == typeof(uint))
						{
							return (uint)(BigInteger)value;
						}
						if (destinationType == typeof(long))
						{
							return (long)(BigInteger)value;
						}
						if (destinationType == typeof(ulong))
						{
							return (ulong)(BigInteger)value;
						}
					}
					return Convert.ChangeType(value, destinationType, CurrentCulture);
				}
				catch (Exception innerException2)
				{
					throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to `" + GetTypeName(destinationType) + "`", innerException2);
				}
			}
			if (destinationType == typeof(IList))
			{
				return ToList(span, value);
			}
			if (destinationType.IsAssignableFrom(c))
			{
				return value;
			}
			throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to `" + GetTypeName(destinationType) + "`");
			static (bool IsNullable, Type DestinationType) GetNullableInfo(Type destinationType)
			{
				destinationType = destinationType ?? throw new ArgumentNullException("destinationType");
				Type underlyingType = Nullable.GetUnderlyingType(destinationType);
				if ((object)underlyingType != null)
				{
					return (true, underlyingType);
				}
				return (false, destinationType);
			}
		}

		public void PushGlobal(IScriptObject scriptObject)
		{
			PushGlobalOnly(scriptObject);
			PushLocal();
		}

		internal void PushGlobalOnly(IScriptObject scriptObject)
		{
			if (scriptObject == null)
			{
				throw new ArgumentNullException("scriptObject");
			}
			_globalContexts.Push(GetOrCreateGlobalContext(scriptObject));
		}

		private VariableContext GetOrCreateGlobalContext(IScriptObject globalObject)
		{
			if (_availableGlobalContexts.Count == 0)
			{
				return new VariableContext(globalObject);
			}
			VariableContext variableContext = _availableGlobalContexts.Pop();
			variableContext.LocalObject = globalObject;
			return variableContext;
		}

		internal IScriptObject PopGlobalOnly()
		{
			if (_globalContexts.Count == 1)
			{
				throw new InvalidOperationException("Unexpected PopGlobal() not matching a PushGlobal");
			}
			VariableContext variableContext = _globalContexts.Pop();
			IScriptObject localObject = variableContext.LocalObject;
			variableContext.LocalObject = null;
			_availableGlobalContexts.Push(variableContext);
			return localObject;
		}

		public IScriptObject PopGlobal()
		{
			IScriptObject result = PopGlobalOnly();
			PopLocal();
			return result;
		}

		public void PushLocal()
		{
			PushVariableScope(VariableScope.Local);
		}

		public void PopLocal()
		{
			PopVariableScope(VariableScope.Local);
		}

		public void SetValue(ScriptVariable variable, object value, bool asReadOnly = false)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			if (!GetStoreForWrite(variable).TrySetValue(this, variable.Span, variable.Name, value, asReadOnly))
			{
				throw new ScriptRuntimeException(variable.Span, $"Cannot set value on the readonly variable `{variable}`");
			}
		}

		public void SetValue(ScriptVariable variable, object value, bool asReadOnly, bool force)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			IScriptObject storeForWrite = GetStoreForWrite(variable);
			if (force)
			{
				storeForWrite.Remove(variable.Name);
				storeForWrite.TrySetValue(this, variable.Span, variable.Name, value, asReadOnly);
			}
			else if (!storeForWrite.TrySetValue(this, variable.Span, variable.Name, value, asReadOnly))
			{
				throw new ScriptRuntimeException(variable.Span, $"Cannot set value on the readonly variable `{variable}`");
			}
		}

		public void DeleteValue(ScriptVariable variable)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			GetStoreForWrite(variable).Remove(variable.Name);
		}

		public void SetReadOnly(ScriptVariable variable, bool isReadOnly = true)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			GetStoreForWrite(variable).SetReadOnly(variable.Name, isReadOnly);
		}

		public virtual void SetLoopVariable(ScriptVariable variable, object value)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			VariableContext obj = ((variable.Scope == ScriptVariableScope.Global) ? _globalContexts.Peek() : _currentLocalContext);
			if (obj.Loops.Count == 0)
			{
				throw new InvalidOperationException("Cannot set a loop global variable without a loop variable store.");
			}
			if (!obj.Loops.Peek().TrySetValue(this, variable.Span, variable.Name, value, readOnly: false))
			{
				throw new ScriptRuntimeException(variable.Span, $"Cannot set value on the variable `{variable}`");
			}
		}

		private void PushLocalContext(ScriptObject locals = null)
		{
			VariableContext variableContext = ((_availableLocalContexts.Count > 0) ? _availableLocalContexts.Pop() : new VariableContext(null));
			variableContext.LocalObject = locals;
			_localContexts.Push(variableContext);
			_currentLocalContext = variableContext;
		}

		private ScriptObject PopLocalContext()
		{
			VariableContext variableContext = _localContexts.Pop();
			ScriptObject result = (ScriptObject)variableContext.LocalObject;
			variableContext.LocalObject = null;
			_availableLocalContexts.Push(variableContext);
			_currentLocalContext = _localContexts.Peek();
			return result;
		}

		public object GetValue(ScriptVariable variable)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			IEnumerable<IScriptObject> storeForRead = GetStoreForRead(variable);
			object value = null;
			foreach (IScriptObject item in storeForRead)
			{
				if (item.TryGetValue(this, variable.Span, variable.Name, out value))
				{
					return value;
				}
			}
			bool found = false;
			if (TryGetVariable != null && TryGetVariable(this, variable.Span, variable, out value))
			{
				found = true;
			}
			CheckVariableFound(variable, found);
			return value;
		}

		public object GetValue(ScriptVariableGlobal variable)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			object value = null;
			int count = _globalContexts.Count;
			VariableContext[] items = _globalContexts.Items;
			bool isInLoop = IsInLoop;
			for (int num = count - 1; num >= 0; num--)
			{
				VariableContext variableContext = items[num];
				if (isInLoop)
				{
					int count2 = variableContext.Loops.Count;
					if (count2 > 0)
					{
						ScriptObject[] items2 = variableContext.Loops.Items;
						for (int num2 = count2 - 1; num2 >= 0; num2--)
						{
							if (items2[num2].TryGetValue(this, variable.Span, variable.Name, out value))
							{
								return value;
							}
						}
					}
				}
				if (items[num].LocalObject.TryGetValue(this, variable.Span, variable.Name, out value))
				{
					return value;
				}
			}
			bool found = false;
			if (TryGetVariable != null && TryGetVariable(this, variable.Span, variable, out value))
			{
				found = true;
			}
			CheckVariableFound(variable, found);
			return value;
		}

		public ValueTask<object> GetValueAsync(ScriptVariableGlobal variable)
		{
			return new ValueTask<object>(GetValue(variable));
		}

		public ValueTask<object> GetValueAsync(ScriptVariable variable)
		{
			return new ValueTask<object>(GetValue(variable));
		}

		public ValueTask SetValueAsync(ScriptVariable variable, object value, bool asReadOnly = false)
		{
			SetValue(variable, value, asReadOnly);
			return default(ValueTask);
		}

		private IScriptObject GetStoreForWrite(ScriptVariable variable)
		{
			ScriptVariableScope scope = variable.Scope;
			IScriptObject scriptObject = null;
			switch (scope)
			{
			case ScriptVariableScope.Global:
			{
				string name = variable.Name;
				int num = _globalContexts.Count - 1;
				scriptObject = _globalContexts.Items[num].LocalObject;
				if (!scriptObject.CanWrite(name))
				{
					string arg = ((scriptObject == BuiltinObject) ? "builtin " : string.Empty);
					throw new ScriptRuntimeException(variable.Span, $"Cannot set the {arg}readonly variable `{variable}`");
				}
				break;
			}
			case ScriptVariableScope.Local:
				if (_currentLocalContext.LocalObject != null)
				{
					scriptObject = _currentLocalContext.LocalObject;
					break;
				}
				if (_globalContexts.Count > 0)
				{
					scriptObject = _globalContexts.Peek().LocalObject;
					break;
				}
				throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the local variable `{variable}` in the current context");
			}
			return scriptObject;
		}

		[IteratorStateMachine(typeof(<GetStoreForRead>d__306))]
		private IEnumerable<IScriptObject> GetStoreForRead(ScriptVariable variable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetStoreForRead>d__306(-2)
			{
				<>4__this = this,
				<>3__variable = variable
			};
		}

		private void CheckVariableFound(ScriptVariable variable, bool found)
		{
			if (StrictVariables && !found && variable != ScriptVariable.Arguments)
			{
				throw new ScriptRuntimeException(variable.Span, $"The variable or function `{variable}` was not found");
			}
		}

		private void PushVariableScope(VariableScope scope)
		{
			if (scope == VariableScope.Local)
			{
				ScriptObject locals = ((_availableStores.Count > 0) ? _availableStores.Pop() : new ScriptObject());
				PushLocalContext(locals);
				return;
			}
			ScriptObject item = ((_availableStores.Count > 0) ? _availableStores.Pop() : new ScriptObject());
			ScriptObject item2 = ((_availableStores.Count > 0) ? _availableStores.Pop() : new ScriptObject());
			_globalContexts.Peek().Loops.Push(item2);
			_currentLocalContext.Loops.Push(item);
		}

		private void PopVariableScope(VariableScope scope)
		{
			if (scope == VariableScope.Local)
			{
				ScriptObject scriptObject = PopLocalContext();
				scriptObject.Clear();
				_availableStores.Push(scriptObject);
				return;
			}
			if (_currentLocalContext.Loops.Count == 0)
			{
				throw new InvalidOperationException("Invalid number of matching push/pop VariableScope.");
			}
			ScriptObject scriptObject2 = _globalContexts.Peek().Loops.Pop();
			scriptObject2.Clear();
			_availableStores.Push(scriptObject2);
			ScriptObject scriptObject3 = _currentLocalContext.Loops.Pop();
			scriptObject3.Clear();
			_availableStores.Push(scriptObject3);
		}
	}
	public class ScriptPrinter
	{
		private readonly IScriptOutput _output;

		private readonly bool _isScriptOnly;

		private bool _isInCode;

		private bool _expectSpace;

		private bool _expectEndOfStatement;

		private bool _previousHasSpace;

		private bool _hasEndOfStatement;

		private bool _hasComma;

		private FastStack<bool> _isWhileLoop;

		public readonly ScriptPrinterOptions Options;

		public bool PreviousHasSpace => _previousHasSpace;

		public bool IsInWhileLoop
		{
			get
			{
				if (_isWhileLoop.Count > 0)
				{
					return _isWhileLoop.Peek();
				}
				return false;
			}
		}

		public ScriptPrinter(IScriptOutput output, ScriptPrinterOptions options = default(ScriptPrinterOptions))
		{
			_isWhileLoop = new FastStack<bool>(4);
			Options = options;
			if (options.Mode != 0 && options.Mode != ScriptMode.ScriptOnly)
			{
				throw new ArgumentException($"The rendering mode `{options.Mode}` is not supported. Only `ScriptMode.Default` or `ScriptMode.ScriptOnly` are currently supported");
			}
			_isScriptOnly = options.Mode == ScriptMode.ScriptOnly;
			_isInCode = _isScriptOnly || options.Mode == ScriptMode.FrontMatterOnly || options.Mode == ScriptMode.FrontMatterAndContent;
			_output = output;
			_hasEndOfStatement = true;
		}

		public ScriptPrinter Write(ScriptNode node)
		{
			if (node != null)
			{
				bool flag = false;
				if (node is ScriptLoopStatementBase)
				{
					_isWhileLoop.Push(node is ScriptWhileStatement);
					flag = true;
				}
				try
				{
					WriteBegin(node);
					if (node is IScriptTerminal)
					{
						_hasComma = false;
					}
					node.PrintTo(this);
					WriteEnd(node);
				}
				finally
				{
					if (flag)
					{
						_isWhileLoop.Pop();
					}
				}
			}
			return this;
		}

		public ScriptPrinter Write(string text)
		{
			_previousHasSpace = text.Length > 0 && char.IsWhiteSpace(text[text.Length - 1]);
			_output.Write(text);
			return this;
		}

		public ScriptPrinter Write(ScriptStringSlice slice)
		{
			_previousHasSpace = slice.Length > 0 && char.IsWhiteSpace(slice[slice.Length - 1]);
			_output.Write(slice);
			return this;
		}

		public ScriptPrinter ExpectEos()
		{
			if (!_hasEndOfStatement)
			{
				_expectEndOfStatement = true;
			}
			return this;
		}

		public ScriptPrinter ExpectSpace()
		{
			_expectSpace = true;
			return this;
		}

		public ScriptPrinter WriteListWithCommas<T>(IList<T> list) where T : ScriptNode
		{
			if (list == null)
			{
				return this;
			}
			for (int i = 0; i < list.Count; i++)
			{
				T node = list[i];
				if (i > 0 && !_hasComma)
				{
					Write(",");
					_hasComma = true;
				}
				Write(node);
			}
			return this;
		}

		public ScriptPrinter WriteEnterCode(int escape = 0)
		{
			Write("{");
			for (int i = 0; i < escape; i++)
			{
				Write("%");
			}
			Write("{");
			_expectEndOfStatement = false;
			_expectSpace = false;
			_hasEndOfStatement = true;
			_isInCode = true;
			return this;
		}

		public ScriptPrinter WriteExitCode(int escape = 0)
		{
			Write("}");
			for (int i = 0; i < escape; i++)
			{
				Write("%");
			}
			Write("}");
			_expectEndOfStatement = false;
			_expectSpace = false;
			_hasEndOfStatement = false;
			_isInCode = false;
			return this;
		}

		private void WriteBegin(ScriptNode node)
		{
			WriteTrivias(node, before: true);
			HandleEos(node);
			if (_hasEndOfStatement)
			{
				_hasEndOfStatement = false;
				_expectEndOfStatement = false;
			}
			if (node.CanHaveLeadingTrivia())
			{
				if (_expectSpace && !_previousHasSpace)
				{
					Write(" ");
				}
				_expectSpace = false;
			}
		}

		private void WriteEnd(ScriptNode node)
		{
			WriteTrivias(node, before: false);
			if (node is ScriptPage && _isInCode && !_isScriptOnly)
			{
				WriteExitCode();
			}
		}

		private static bool IsFrontMarker(ScriptNode node)
		{
			if (node is ScriptToken scriptToken)
			{
				return scriptToken.TokenType == TokenType.FrontMatterMarker;
			}
			return false;
		}

		private void HandleEos(ScriptNode node)
		{
			bool flag = IsFrontMarker(node);
			if ((node is ScriptStatement || flag) && !IsBlockOrPage(node) && _isInCode && _expectEndOfStatement)
			{
				if (!_hasEndOfStatement && !(node is ScriptEscapeStatement))
				{
					Write(flag ? "\n" : "; ");
				}
				_expectEndOfStatement = false;
				_hasEndOfStatement = false;
				_hasComma = false;
			}
		}

		private static bool IsBlockOrPage(ScriptNode node)
		{
			if (!(node is ScriptBlockStatement))
			{
				return node is ScriptPage;
			}
			return true;
		}

		private void WriteTrivias(ScriptNode node, bool before)
		{
			if (!(node is IScriptTerminal scriptTerminal))
			{
				return;
			}
			ScriptTrivias trivias = scriptTerminal.Trivias;
			if (trivias == null)
			{
				return;
			}
			foreach (ScriptTrivia item in before ? trivias.Before : trivias.After)
			{
				item.Write(this);
				if (item.Type == ScriptTriviaType.NewLine || item.Type == ScriptTriviaType.SemiColon)
				{
					_hasEndOfStatement = true;
					if (item.Type == ScriptTriviaType.SemiColon)
					{
						_hasComma = false;
					}
					if (_expectSpace)
					{
						_expectSpace = false;
					}
				}
				if (item.Type == ScriptTriviaType.Comma)
				{
					_hasComma = true;
				}
			}
		}
	}
	public struct ScriptPrinterOptions
	{
		public ScriptMode Mode;
	}
	public class LiquidTemplateContext : TemplateContext
	{
		public LiquidTemplateContext()
			: base(new LiquidBuiltinsFunctions())
		{
			base.Language = ScriptLang.Liquid;
			base.EnableBreakAndContinueAsReturnOutsideLoop = true;
			base.EnableRelaxedTargetAccess = true;
			base.TemplateLoaderLexerOptions = new LexerOptions
			{
				Lang = ScriptLang.Liquid
			};
			base.TemplateLoaderParserOptions = new ParserOptions
			{
				LiquidFunctionsToScriban = true
			};
			base.IsLiquid = true;
		}

		public override string GetTemplatePathFromName(string templateName, ScriptNode callerContext)
		{
			if (string.IsNullOrEmpty(templateName))
			{
				return null;
			}
			return ConvertTemplateNameToPath(templateName, callerContext);
		}
	}
}
namespace Scriban.Syntax
{
	internal class ScientificFunctionCallRewriter
	{
		[DebuggerDisplay("Count = {Count}, Current = {Index} : {Current}")]
		private class BinaryExpressionIterator : List<BinaryExpressionOrOperator>
		{
			public int Index { get; set; }

			public BinaryExpressionOrOperator Current
			{
				get
				{
					if (Index >= base.Count)
					{
						return default(BinaryExpressionOrOperator);
					}
					return base[Index];
				}
			}

			public bool HasCurrent => Index < base.Count;

			public bool HasNext => Index + 1 < base.Count;

			public bool MoveNext()
			{
				Index++;
				return HasCurrent;
			}

			public BinaryExpressionOrOperator PeekNext()
			{
				return base[Index + 1];
			}
		}

		[DebuggerDisplay("{ToDebuggerDisplay(),nq}")]
		private readonly struct BinaryExpressionOrOperator
		{
			public readonly ScriptExpression Expression;

			public readonly ScriptBinaryOperator Operator;

			public readonly ScriptToken OperatorToken;

			public readonly FunctionCallKind CallKind;

			public BinaryExpressionOrOperator(ScriptExpression expression, FunctionCallKind kind)
			{
				Expression = expression;
				Operator = ScriptBinaryOperator.None;
				OperatorToken = null;
				CallKind = kind;
			}

			public BinaryExpressionOrOperator(ScriptBinaryOperator @operator, ScriptToken operatorToken)
			{
				Expression = null;
				Operator = @operator;
				OperatorToken = operatorToken;
				CallKind = FunctionCallKind.None;
			}

			private string ToDebuggerDisplay()
			{
				object obj;
				if (Expression == null)
				{
					obj = OperatorToken?.ToString();
					if (obj == null)
					{
						return $"`{Operator.ToText()}` - CallKind = {CallKind}";
					}
				}
				else
				{
					obj = Expression.ToString();
				}
				return (string)obj;
			}
		}

		private enum FunctionCallKind
		{
			None,
			Regular,
			Expression
		}

		private const int ImplicitFunctionCallPrecedence = 101;

		private static async ValueTask FlattenBinaryExpressionsAsync(TemplateContext context, ScriptExpression expression, List<BinaryExpressionOrOperator> expressions)
		{
			while (expression is ScriptBinaryExpression binaryExpression)
			{
				ScriptExpression expression2 = (ScriptExpression)binaryExpression.Left.Clone();
				ScriptExpression right = (ScriptExpression)binaryExpression.Right.Clone();
				ScriptToken token = (ScriptToken)(binaryExpression.OperatorToken?.Clone());
				await FlattenBinaryExpressionsAsync(context, expression2, expressions).ConfigureAwait(continueOnCapturedContext: false);
				expressions.Add(new BinaryExpressionOrOperator(binaryExpression.Operator, token));
				expression = right;
			}
			ScriptExpression expression3 = expression;
			expressions.Add(new BinaryExpressionOrOperator(expression3, await GetFunctionCallKindAsync(context, expression).ConfigureAwait(continueOnCapturedContext: false)));
		}

		private static async ValueTask<FunctionCallKind> GetFunctionCallKindAsync(TemplateContext context, ScriptExpression expression)
		{
			bool restoreStrictVariables = context.StrictVariables;
			context.StrictVariables = false;
			object result = null;
			try
			{
				result = await context.EvaluateAsync(expression, aliasReturnedFunction: true).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (ScriptRuntimeException) when (context.IgnoreExceptionsWhileRewritingScientific)
			{
			}
			finally
			{
				context.StrictVariables = restoreStrictVariables;
			}
			if (result is IScriptCustomFunction scriptCustomFunction && ((scriptCustomFunction.RequiredParameterCount != 0) ? scriptCustomFunction.RequiredParameterCount : ((scriptCustomFunction.ParameterCount > 0) ? 1 : 0)) > 0)
			{
				return (!scriptCustomFunction.IsParameterType<ScriptExpression>(0)) ? FunctionCallKind.Regular : FunctionCallKind.Expression;
			}
			return FunctionCallKind.None;
		}

		public static async ValueTask<ScriptExpression> RewriteAsync(TemplateContext context, ScriptBinaryExpression binaryExpression)
		{
			if (!HasImplicitBinaryExpression(binaryExpression))
			{
				return binaryExpression;
			}
			BinaryExpressionIterator iterator = new BinaryExpressionIterator();
			await FlattenBinaryExpressionsAsync(context, binaryExpression, iterator).ConfigureAwait(continueOnCapturedContext: false);
			return ParseBinaryExpressionTree(iterator, 0, isExpectingExpression: false);
		}

		public static ScriptExpression Rewrite(TemplateContext context, ScriptBinaryExpression binaryExpression)
		{
			if (!HasImplicitBinaryExpression(binaryExpression))
			{
				return binaryExpression;
			}
			BinaryExpressionIterator binaryExpressionIterator = new BinaryExpressionIterator();
			FlattenBinaryExpressions(context, binaryExpression, binaryExpressionIterator);
			return ParseBinaryExpressionTree(binaryExpressionIterator, 0, isExpectingExpression: false);
		}

		private static bool HasImplicitBinaryExpression(ScriptExpression expression)
		{
			if (expression is ScriptBinaryExpression scriptBinaryExpression)
			{
				if (scriptBinaryExpression.OperatorToken == null && scriptBinaryExpression.Operator == ScriptBinaryOperator.Multiply)
				{
					return true;
				}
				if (!HasImplicitBinaryExpression(scriptBinaryExpression.Left))
				{
					return HasImplicitBinaryExpression(scriptBinaryExpression.Right);
				}
				return true;
			}
			return false;
		}

		private static void FlattenBinaryExpressions(TemplateContext context, ScriptExpression expression, List<BinaryExpressionOrOperator> expressions)
		{
			while (expression is ScriptBinaryExpression scriptBinaryExpression)
			{
				ScriptExpression expression2 = (ScriptExpression)scriptBinaryExpression.Left.Clone();
				ScriptExpression obj = (ScriptExpression)scriptBinaryExpression.Right.Clone();
				ScriptToken operatorToken = (ScriptToken)(scriptBinaryExpression.OperatorToken?.Clone());
				FlattenBinaryExpressions(context, expression2, expressions);
				expressions.Add(new BinaryExpressionOrOperator(scriptBinaryExpression.Operator, operatorToken));
				expression = obj;
			}
			expressions.Add(new BinaryExpressionOrOperator(expression, GetFunctionCallKind(context, expression)));
		}

		private static ScriptExpression ParseBinaryExpressionTree(BinaryExpressionIterator it, int precedence, bool isExpectingExpression)
		{
			ScriptExpression scriptExpression = null;
			while (it.HasCurrent)
			{
				BinaryExpressionOrOperator current = it.Current;
				ScriptExpression expression = current.Expression;
				if (expression == null)
				{
					int num = Parser.GetDefaultBinaryOperatorPrecedence(current.Operator);
					if (!isExpectingExpression && it.HasNext && it.PeekNext().CallKind != 0)
					{
						num = ((num < 101) ? num : 101);
					}
					if (num <= precedence)
					{
						break;
					}
					it.MoveNext();
					ScriptBinaryExpression scriptBinaryExpression = new ScriptBinaryExpression
					{
						Left = scriptExpression,
						Operator = current.Operator,
						OperatorToken = (current.OperatorToken ?? ScriptToken.Star()),
						Span = 
						{
							Start = scriptExpression.Span.Start
						}
					};
					scriptBinaryExpression.Right = ParseBinaryExpressionTree(it, num, isExpectingExpression);
					scriptBinaryExpression.Span.End = scriptBinaryExpression.Right.Span.End;
					scriptExpression = scriptBinaryExpression;
				}
				else if (!isExpectingExpression && current.CallKind != 0)
				{
					ScriptFunctionCall obj = new ScriptFunctionCall
					{
						Target = expression,
						ExplicitCall = true,
						Span = 
						{
							Start = expression.Span.Start
						}
					};
					if (!it.MoveNext())
					{
						throw new ScriptRuntimeException(expression.Span, "The function is expecting at least one argument");
					}
					if (it.Current.Expression == null && (it.Current.Operator != ScriptBinaryOperator.Multiply || it.Current.OperatorToken != null))
					{
						throw new ScriptRuntimeException(expression.Span, "The function expecting one argument cannot be followed by the operator " + (it.Current.OperatorToken?.ToString() ?? it.Current.Operator.ToText()));
					}
					if (!it.MoveNext())
					{
						throw new ScriptRuntimeException(expression.Span, "The function is expecting at least one argument");
					}
					ScriptExpression scriptExpression2 = ParseBinaryExpressionTree(it, 101, current.CallKind == FunctionCallKind.Expression);
					obj.Arguments.Add(scriptExpression2);
					obj.Span.End = scriptExpression2.Span.End;
					scriptExpression = obj;
				}
				else
				{
					scriptExpression = expression;
					it.MoveNext();
				}
			}
			return scriptExpression;
		}

		private static FunctionCallKind GetFunctionCallKind(TemplateContext context, ScriptExpression expression)
		{
			bool strictVariables = context.StrictVariables;
			context.StrictVariables = false;
			object obj = null;
			try
			{
				obj = context.Evaluate(expression, aliasReturnedFunction: true);
			}
			catch (ScriptRuntimeException) when (context.IgnoreExceptionsWhileRewritingScientific)
			{
			}
			finally
			{
				context.StrictVariables = strictVariables;
			}
			if (obj is IScriptCustomFunction scriptCustomFunction && ((scriptCustomFunction.RequiredParameterCount != 0) ? scriptCustomFunction.RequiredParameterCount : ((scriptCustomFunction.ParameterCount > 0) ? 1 : 0)) > 0)
			{
				if (!scriptCustomFunction.IsParameterType<ScriptExpression>(0))
				{
					return FunctionCallKind.Regular;
				}
				return FunctionCallKind.Expression;
			}
			return FunctionCallKind.None;
		}
	}
	[ScriptSyntax("array initializer", "[item1, item2,...]")]
	public class ScriptArrayInitializerExpression : ScriptExpression
	{
		private ScriptList<ScriptExpression> _values;

		private ScriptToken _openBracketToken;

		private ScriptToken _closeBracketToken;

		public override int ChildrenCount => 3;

		public ScriptToken OpenBracketToken
		{
			get
			{
				return _openBracketToken;
			}
			set
			{
				ParentToThis(ref _openBracketToken, value);
			}
		}

		public ScriptList<ScriptExpression> Values
		{
			get
			{
				return _values;
			}
			set
			{
				ParentToThis(ref _values, value);
			}
		}

		public ScriptToken CloseBracketToken
		{
			get
			{
				return _closeBracketToken;
			}
			set
			{
				ParentToThis(ref _closeBracketToken, value);
			}
		}

		public override async ValueTask<object> EvaluateAsync(TemplateContext context)
		{
			ScriptArray scriptArray = new ScriptArray();
			foreach (ScriptExpression value in Values)
			{
				scriptArray.Add(await context.EvaluateAsync(value).ConfigureAwait(continueOnCapturedContext: false));
			}
			return scriptArray;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => OpenBracketToken, 
				1 => Values, 
				2 => CloseBracketToken, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptArrayInitializerExpression()
		{
			OpenBracketToken = ScriptToken.OpenBracket();
			Values = new ScriptList<ScriptExpression>();
			CloseBracketToken = ScriptToken.CloseBracket();
		}

		public override object Evaluate(TemplateContext context)
		{
			ScriptArray scriptArray = new ScriptArray();
			foreach (ScriptExpression value in Values)
			{
				object item = context.Evaluate(value);
				scriptArray.Add(item);
			}
			return scriptArray;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(OpenBracketToken);
			printer.WriteListWithCommas(Values);
			printer.Write(CloseBracketToken);
		}
	}
	[ScriptSyntax("assign expression", "<target_expression> = <value_expression>")]
	public class ScriptAssignExpression : ScriptExpression
	{
		private ScriptExpression _target;

		private ScriptToken _equalToken;

		private ScriptExpression _value;

		public override int ChildrenCount => 3;

		public ScriptExpression Target
		{
			get
			{
				return _target;
			}
			set
			{
				ParentToThis(ref _target, value);
			}
		}

		public ScriptToken EqualToken
		{
			get
			{
				return _equalToken;
			}
			set
			{
				ParentToThis(ref _equalToken, value);
			}
		}

		public ScriptExpression Value
		{
			get
			{
				return _value;
			}
			set
			{
				ParentToThis(ref _value, value);
			}
		}

		public override async ValueTask<object> EvaluateAsync(TemplateContext context)
		{
			object obj = ((EqualToken.TokenType != TokenType.Equal) ? (await GetValueToSetAsync(context).ConfigureAwait(continueOnCapturedContext: false)) : (await context.EvaluateAsync(Value).ConfigureAwait(continueOnCapturedContext: false)));
			object value = obj;
			await context.SetValueAsync(Target, value).ConfigureAwait(continueOnCapturedContext: false);
			return null;
		}

		private async ValueTask<object> GetValueToSetAsync(TemplateContext context)
		{
			object right = await context.EvaluateAsync(Value).ConfigureAwait(continueOnCapturedContext: false);
			object leftValue = await context.EvaluateAsync(Target).ConfigureAwait(continueOnCapturedContext: false);
			ScriptBinaryOperator op = EqualToken.TokenType switch
			{
				TokenType.PlusEqual => ScriptBinaryOperator.Add, 
				TokenType.MinusEqual => ScriptBinaryOperator.Subtract, 
				TokenType.AsteriskEqual => ScriptBinaryOperator.Multiply, 
				TokenType.DivideEqual => ScriptBinaryOperator.Divide, 
				TokenType.DoubleDivideEqual => ScriptBinaryOperator.DivideRound, 
				TokenType.PercentEqual => ScriptBinaryOperator.Modulus, 
				_ => throw new ScriptRuntimeException(context.CurrentSpan, $"Operator {EqualToken} is not a valid compound assignment operator"), 
			};
			return ScriptBinaryExpression.Evaluate(context, Span, op, leftValue, right);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Target, 
				1 => EqualToken, 
				2 => Value, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptAssignExpression()
		{
			EqualToken = ScriptToken.Equal();
		}

		public override object Evaluate(TemplateContext context)
		{
			object value = ((EqualToken.TokenType == TokenType.Equal) ? context.Evaluate(Value) : GetValueToSet(context));
			context.SetValue(Target, value);
			return null;
		}

		private object GetValueToSet(TemplateContext context)
		{
			object rightValue = context.Evaluate(Value);
			object leftValue = context.Evaluate(Target);
			ScriptBinaryOperator op = EqualToken.TokenType switch
			{
				TokenType.PlusEqual => ScriptBinaryOperator.Add, 
				TokenType.MinusEqual => ScriptBinaryOperator.Subtract, 
				TokenType.AsteriskEqual => ScriptBinaryOperator.Multiply, 
				TokenType.DivideEqual => ScriptBinaryOperator.Divide, 
				TokenType.DoubleDivideEqual => ScriptBinaryOperator.DivideRound, 
				TokenType.PercentEqual => ScriptBinaryOperator.Modulus, 
				_ => throw new ScriptRuntimeException(context.CurrentSpan, $"Operator {EqualToken} is not a valid compound assignment operator"), 
			};
			return ScriptBinaryExpression.Evaluate(context, Span, op, leftValue, rightValue);
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(Target);
			printer.Write(EqualToken);
			printer.Write(Value);
		}
	}
	[ScriptSyntax("binary expression", "<expression> operator <expression>")]
	public class ScriptBinaryExpression : ScriptExpression
	{
		[CompilerGenerated]
		private sealed class <RangeExclude>d__32 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private int <>l__initialThreadId;

			private long left;

			public long <>3__left;

			private long right;

			public long <>3__right;

			private long <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RangeExclude>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (left < right)
					{
						<i>5__2 = left;
						goto IL_0070;
					}
					<i>5__2 = left;
					goto IL_00c0;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0070;
				case 2:
					{
						<>1__state = -1;
						<i>5__2--;
						goto IL_00c0;
					}
					IL_00c0:
					if (<i>5__2 > right)
					{
						<>2__current = FitToBestInteger(<i>5__2);
						<>1__state = 2;
						return true;
					}
					break;
					IL_0070:
					if (<i>5__2 < right)
					{
						<>2__current = FitToBestInteger(<i>5__2);
						<>1__state = 1;
						return true;
					}
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<object> IEnumerable<object>.GetEnumerator()
			{
				<RangeExclude>d__32 <RangeExclude>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<RangeExclude>d__ = this;
				}
				else
				{
					<RangeExclude>d__ = new <RangeExclude>d__32(0);
				}
				<RangeExclude>d__.left = <>3__left;
				<RangeExclude>d__.right = <>3__right;
				return <RangeExclude>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<object>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <RangeExclude>d__34 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private int <>l__initialThreadId;

			private BigInteger left;

			public BigInteger <>3__left;

			private BigInteger right;

			public BigInteger <>3__right;

			private BigInteger <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RangeExclude>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (left < right)
					{
						<i>5__2 = left;
						goto IL_0077;
					}
					<i>5__2 = left;
					goto IL_00ce;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0077;
				case 2:
					{
						<>1__state = -1;
						<i>5__2--;
						goto IL_00ce;
					}
					IL_00ce:
					if (<i>5__2 > right)
					{
						<>2__current = FitToBestInteger(<i>5__2);
						<>1__state = 2;
						return true;
					}
					break;
					IL_0077:
					if (<i>5__2 < right)
					{
						<>2__current = FitToBestInteger(<i>5__2);
						<>1__state = 1;
						return true;
					}
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<object> IEnumerable<object>.GetEnumerator()
			{
				<RangeExclude>d__34 <RangeExclude>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<RangeExclude>d__ = this;
				}
				else
				{
					<RangeExclude>d__ = new <RangeExclude>d__34(0);
				}
				<RangeExclude>d__.left = <>3__left;
				<RangeExclude>d__.right = <>3__right;
				return <RangeExclude>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<object>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <RangeInclude>d__31 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private int <>l__initialThreadId;

			private long left;

			public long <>3__left;

			private long right;

			public long <>3__right;

			private long <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RangeInclude>d__31(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (left < right)
					{
						<i>5__2 = left;
						goto IL_0070;
					}
					<i>5__2 = left;
					goto IL_00c0;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0070;
				case 2:
					{
						<>1__state = -1;
						<i>5__2--;
						goto IL_00c0;
					}
					IL_00c0:
					if (<i>5__2 >= right)
					{
						<>2__current = FitToBestInteger(<i>5__2);
						<>1__state = 2;
						return true;
					}
					break;
					IL_0070:
					if (<i>5__2 <= right)
					{
						<>2__current = FitToBestInteger(<i>5__2);
						<>1__state = 1;
						return true;
					}
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<object> IEnumerable<object>.GetEnumerator()
			{
				<RangeInclude>d__31 <RangeInclude>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<RangeInclude>d__ = this;
				}
				else
				{
					<RangeInclude>d__ = new <RangeInclude>d__31(0);
				}
				<RangeInclude>d__.left = <>3__left;
				<RangeInclude>d__.right = <>3__right;
				return <RangeInclude>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<object>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <RangeInclude>d__33 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private int <>l__initialThreadId;

			private BigInteger left;

			public BigInteger <>3__left;

			private BigInteger right;

			public BigInteger <>3__right;

			private BigInteger <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RangeInclude>d__33(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (left < right)
					{
						<i>5__2 = left;
						goto IL_0077;
					}
					<i>5__2 = left;
					goto IL_00ce;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0077;
				case 2:
					{
						<>1__state = -1;
						<i>5__2--;
						goto IL_00ce;
					}
					IL_00ce:
					if (<i>5__2 >= right