using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using Antlr.Runtime.Debug;
using Antlr.Runtime.Misc;
using Antlr.Runtime.Tree;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Antlr3.Runtime")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Tunnel Vision Laboratories, LLC")]
[assembly: AssemblyProduct("Antlr3.Runtime")]
[assembly: AssemblyCopyright("Copyright © Sam Harwell 2013")]
[assembly: AssemblyTrademark("")]
[assembly: CLSCompliant(true)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: ComVisible(false)]
[assembly: Guid("7a0b4db7-f127-4cf5-ac2c-e294957efcd6")]
[assembly: AssemblyFileVersion("3.5.1.0")]
[assembly: AssemblyInformationalVersion("3.5.1")]
[assembly: AssemblyVersion("3.5.0.2")]
namespace Antlr.Runtime
{
	[Serializable]
	[FileIOPermission(SecurityAction.Demand, Unrestricted = true)]
	public class ANTLRFileStream : ANTLRStringStream
	{
		protected string fileName;

		public override string SourceName => fileName;

		public ANTLRFileStream(string fileName)
			: this(fileName, null)
		{
		}

		public ANTLRFileStream(string fileName, Encoding encoding)
		{
			this.fileName = fileName;
			Load(fileName, encoding);
		}

		public virtual void Load(string fileName, Encoding encoding)
		{
			if (fileName != null)
			{
				string text = ((encoding != null) ? File.ReadAllText(fileName, encoding) : File.ReadAllText(fileName));
				data = text.ToCharArray();
				n = data.Length;
			}
		}
	}
	[Serializable]
	public class ANTLRInputStream : ANTLRReaderStream
	{
		public ANTLRInputStream(Stream input)
			: this(input, null)
		{
		}

		public ANTLRInputStream(Stream input, int size)
			: this(input, size, null)
		{
		}

		public ANTLRInputStream(Stream input, Encoding encoding)
			: this(input, 1024, encoding)
		{
		}

		public ANTLRInputStream(Stream input, int size, Encoding encoding)
			: this(input, size, 1024, encoding)
		{
		}

		public ANTLRInputStream(Stream input, int size, int readBufferSize, Encoding encoding)
			: base(GetStreamReader(input, encoding), size, readBufferSize)
		{
		}

		private static StreamReader GetStreamReader(Stream input, Encoding encoding)
		{
			if (encoding != null)
			{
				return new StreamReader(input, encoding);
			}
			return new StreamReader(input);
		}
	}
	[Serializable]
	public class ANTLRReaderStream : ANTLRStringStream
	{
		public const int ReadBufferSize = 1024;

		public const int InitialBufferSize = 1024;

		public ANTLRReaderStream(TextReader r)
			: this(r, 1024, 1024)
		{
		}

		public ANTLRReaderStream(TextReader r, int size)
			: this(r, size, 1024)
		{
		}

		public ANTLRReaderStream(TextReader r, int size, int readChunkSize)
		{
			Load(r, size, readChunkSize);
		}

		public virtual void Load(TextReader r, int size, int readChunkSize)
		{
			if (r == null)
			{
				return;
			}
			if (size <= 0)
			{
				size = 1024;
			}
			if (readChunkSize <= 0)
			{
				readChunkSize = 1024;
			}
			try
			{
				data = r.ReadToEnd().ToCharArray();
				n = data.Length;
			}
			finally
			{
				r.Dispose();
			}
		}
	}
	[Serializable]
	public class ANTLRStringStream : ICharStream, IIntStream
	{
		protected char[] data;

		protected int n;

		protected int p;

		private int line = 1;

		private int charPositionInLine;

		protected int markDepth;

		protected IList<CharStreamState> markers;

		protected int lastMarker;

		public string name;

		public virtual int Index => p;

		public virtual int Line
		{
			get
			{
				return line;
			}
			set
			{
				line = value;
			}
		}

		public virtual int CharPositionInLine
		{
			get
			{
				return charPositionInLine;
			}
			set
			{
				charPositionInLine = value;
			}
		}

		public virtual int Count => n;

		public virtual string SourceName => name;

		public ANTLRStringStream(string input)
			: this(input, null)
		{
		}

		public ANTLRStringStream(string input, string sourceName)
			: this(input.ToCharArray(), input.Length, sourceName)
		{
		}

		public ANTLRStringStream(char[] data, int numberOfActualCharsInArray)
			: this(data, numberOfActualCharsInArray, null)
		{
		}

		public ANTLRStringStream(char[] data, int numberOfActualCharsInArray, string sourceName)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			if (numberOfActualCharsInArray < 0)
			{
				throw new ArgumentOutOfRangeException();
			}
			if (numberOfActualCharsInArray > data.Length)
			{
				throw new ArgumentException();
			}
			this.data = data;
			n = numberOfActualCharsInArray;
			name = sourceName;
		}

		protected ANTLRStringStream()
		{
			data = new char[0];
		}

		public virtual void Reset()
		{
			p = 0;
			line = 1;
			charPositionInLine = 0;
			markDepth = 0;
		}

		public virtual void Consume()
		{
			if (p < n)
			{
				charPositionInLine++;
				if (data[p] == '\n')
				{
					line++;
					charPositionInLine = 0;
				}
				p++;
			}
		}

		public virtual int LA(int i)
		{
			if (i == 0)
			{
				return 0;
			}
			if (i < 0)
			{
				i++;
				if (p + i - 1 < 0)
				{
					return -1;
				}
			}
			if (p + i - 1 >= n)
			{
				return -1;
			}
			return data[p + i - 1];
		}

		public virtual int LT(int i)
		{
			return LA(i);
		}

		public virtual int Mark()
		{
			if (markers == null)
			{
				markers = new List<CharStreamState>();
				markers.Add(null);
			}
			markDepth++;
			CharStreamState charStreamState = null;
			if (markDepth >= markers.Count)
			{
				charStreamState = new CharStreamState();
				markers.Add(charStreamState);
			}
			else
			{
				charStreamState = markers[markDepth];
			}
			charStreamState.p = Index;
			charStreamState.line = Line;
			charStreamState.charPositionInLine = CharPositionInLine;
			lastMarker = markDepth;
			return markDepth;
		}

		public virtual void Rewind(int m)
		{
			if (m < 0)
			{
				throw new ArgumentOutOfRangeException();
			}
			CharStreamState charStreamState = markers[m];
			Seek(charStreamState.p);
			line = charStreamState.line;
			charPositionInLine = charStreamState.charPositionInLine;
			Release(m);
		}

		public virtual void Rewind()
		{
			Rewind(lastMarker);
		}

		public virtual void Release(int marker)
		{
			markDepth = marker;
			markDepth--;
		}

		public virtual void Seek(int index)
		{
			if (index <= p)
			{
				p = index;
				return;
			}
			while (p < index)
			{
				Consume();
			}
		}

		public virtual string Substring(int start, int length)
		{
			if (start < 0)
			{
				throw new ArgumentOutOfRangeException();
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException();
			}
			if (start + length > data.Length)
			{
				throw new ArgumentException();
			}
			if (length == 0)
			{
				return string.Empty;
			}
			return new string(data, start, length);
		}

		public override string ToString()
		{
			return new string(data);
		}
	}
	public class AstParserRuleReturnScope<TTree, TToken> : ParserRuleReturnScope<TToken>, IAstRuleReturnScope<TTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		private TTree _tree;

		public TTree Tree
		{
			get
			{
				return _tree;
			}
			set
			{
				_tree = value;
			}
		}

		object IAstRuleReturnScope.Tree => Tree;
	}
	public abstract class BaseRecognizer
	{
		public const int MemoRuleFailed = -2;

		public const int MemoRuleUnknown = -1;

		public const int InitialFollowStackSize = 100;

		public const int DefaultTokenChannel = 0;

		public const int Hidden = 99;

		public const string NextTokenRuleName = "nextToken";

		protected internal RecognizerSharedState state;

		public TextWriter TraceDestination { get; set; }

		public virtual int NumberOfSyntaxErrors => state.syntaxErrors;

		public virtual int BacktrackingLevel
		{
			get
			{
				return state.backtracking;
			}
			set
			{
				state.backtracking = value;
			}
		}

		public virtual bool Failed => state.failed;

		public virtual string[] TokenNames => null;

		public virtual string GrammarFileName => null;

		public abstract string SourceName { get; }

		public virtual IDebugEventListener DebugListener => null;

		public BaseRecognizer()
			: this(new RecognizerSharedState())
		{
		}

		public BaseRecognizer(RecognizerSharedState state)
		{
			if (state == null)
			{
				state = new RecognizerSharedState();
			}
			this.state = state;
			InitDFAs();
		}

		public virtual void SetState(RecognizerSharedState value)
		{
			state = value;
		}

		protected virtual void InitDFAs()
		{
		}

		public virtual void Reset()
		{
			if (state != null)
			{
				state._fsp = -1;
				state.errorRecovery = false;
				state.lastErrorIndex = -1;
				state.failed = false;
				state.syntaxErrors = 0;
				state.backtracking = 0;
				int num = 0;
				while (state.ruleMemo != null && num < state.ruleMemo.Length)
				{
					state.ruleMemo[num] = null;
					num++;
				}
			}
		}

		public virtual object Match(IIntStream input, int ttype, BitSet follow)
		{
			object currentInputSymbol = GetCurrentInputSymbol(input);
			if (input.LA(1) == ttype)
			{
				input.Consume();
				state.errorRecovery = false;
				state.failed = false;
				return currentInputSymbol;
			}
			if (state.backtracking > 0)
			{
				state.failed = true;
				return currentInputSymbol;
			}
			return RecoverFromMismatchedToken(input, ttype, follow);
		}

		public virtual void MatchAny(IIntStream input)
		{
			state.errorRecovery = false;
			state.failed = false;
			input.Consume();
		}

		public virtual bool MismatchIsUnwantedToken(IIntStream input, int ttype)
		{
			return input.LA(2) == ttype;
		}

		public virtual bool MismatchIsMissingToken(IIntStream input, BitSet follow)
		{
			if (follow == null)
			{
				return false;
			}
			if (follow.Member(1))
			{
				BitSet a = ComputeContextSensitiveRuleFOLLOW();
				follow = follow.Or(a);
				if (state._fsp >= 0)
				{
					follow.Remove(1);
				}
			}
			if (follow.Member(input.LA(1)) || follow.Member(1))
			{
				return true;
			}
			return false;
		}

		public virtual void ReportError(RecognitionException e)
		{
			if (!state.errorRecovery)
			{
				state.syntaxErrors++;
				state.errorRecovery = true;
				DisplayRecognitionError(TokenNames, e);
			}
		}

		public virtual void DisplayRecognitionError(string[] tokenNames, RecognitionException e)
		{
			string errorHeader = GetErrorHeader(e);
			string errorMessage = GetErrorMessage(e, tokenNames);
			EmitErrorMessage(errorHeader + " " + errorMessage);
		}

		public virtual string GetErrorMessage(RecognitionException e, string[] tokenNames)
		{
			string result = e.Message;
			if (e is UnwantedTokenException)
			{
				UnwantedTokenException ex = (UnwantedTokenException)e;
				string text = "<unknown>";
				result = string.Concat(str3: (ex.Expecting != -1) ? tokenNames[ex.Expecting] : "EndOfFile", str0: "extraneous input ", str1: GetTokenErrorDisplay(ex.UnexpectedToken), str2: " expecting ");
			}
			else if (e is MissingTokenException)
			{
				MissingTokenException ex2 = (MissingTokenException)e;
				string text2 = "<unknown>";
				text2 = ((ex2.Expecting != -1) ? tokenNames[ex2.Expecting] : "EndOfFile");
				result = "missing " + text2 + " at " + GetTokenErrorDisplay(e.Token);
			}
			else if (e is MismatchedTokenException)
			{
				MismatchedTokenException ex3 = (MismatchedTokenException)e;
				string text3 = "<unknown>";
				result = string.Concat(str3: (ex3.Expecting != -1) ? tokenNames[ex3.Expecting] : "EndOfFile", str0: "mismatched input ", str1: GetTokenErrorDisplay(e.Token), str2: " expecting ");
			}
			else if (e is MismatchedTreeNodeException)
			{
				MismatchedTreeNodeException ex4 = (MismatchedTreeNodeException)e;
				string text4 = "<unknown>";
				text4 = ((ex4.Expecting != -1) ? tokenNames[ex4.Expecting] : "EndOfFile");
				string text5 = ((ex4.Node != null) ? (ex4.Node.ToString() ?? string.Empty) : string.Empty);
				result = "mismatched tree node: " + text5 + " expecting " + text4;
			}
			else if (e is NoViableAltException)
			{
				result = "no viable alternative at input " + GetTokenErrorDisplay(e.Token);
			}
			else if (e is EarlyExitException)
			{
				result = "required (...)+ loop did not match anything at input " + GetTokenErrorDisplay(e.Token);
			}
			else if (e is MismatchedSetException)
			{
				MismatchedSetException ex5 = (MismatchedSetException)e;
				result = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting set " + ex5.Expecting;
			}
			else if (e is MismatchedNotSetException)
			{
				MismatchedNotSetException ex6 = (MismatchedNotSetException)e;
				result = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting set " + ex6.Expecting;
			}
			else if (e is FailedPredicateException)
			{
				FailedPredicateException ex7 = (FailedPredicateException)e;
				result = "rule " + ex7.RuleName + " failed predicate: {" + ex7.PredicateText + "}?";
			}
			return result;
		}

		public virtual string GetErrorHeader(RecognitionException e)
		{
			string text = SourceName ?? string.Empty;
			if (text.Length > 0)
			{
				text += " ";
			}
			return $"{text}line {e.Line}:{e.CharPositionInLine + 1}";
		}

		public virtual string GetTokenErrorDisplay(IToken t)
		{
			string text = t.Text;
			if (text == null)
			{
				text = ((t.Type != -1) ? ("<" + t.Type + ">") : "<EOF>");
			}
			text = Regex.Replace(text, "\n", "\\\\n");
			text = Regex.Replace(text, "\r", "\\\\r");
			text = Regex.Replace(text, "\t", "\\\\t");
			return "'" + text + "'";
		}

		public virtual void EmitErrorMessage(string msg)
		{
			if (TraceDestination != null)
			{
				TraceDestination.WriteLine(msg);
			}
		}

		public virtual void Recover(IIntStream input, RecognitionException re)
		{
			if (state.lastErrorIndex == input.Index)
			{
				input.Consume();
			}
			state.lastErrorIndex = input.Index;
			BitSet set = ComputeErrorRecoverySet();
			BeginResync();
			ConsumeUntil(input, set);
			EndResync();
		}

		public virtual void BeginResync()
		{
		}

		public virtual void EndResync()
		{
		}

		protected virtual BitSet ComputeErrorRecoverySet()
		{
			return CombineFollows(exact: false);
		}

		protected virtual BitSet ComputeContextSensitiveRuleFOLLOW()
		{
			return CombineFollows(exact: true);
		}

		protected virtual BitSet CombineFollows(bool exact)
		{
			int fsp = state._fsp;
			BitSet bitSet = new BitSet();
			for (int num = fsp; num >= 0; num--)
			{
				BitSet bitSet2 = state.following[num];
				bitSet.OrInPlace(bitSet2);
				if (exact)
				{
					if (!bitSet2.Member(1))
					{
						break;
					}
					if (num > 0)
					{
						bitSet.Remove(1);
					}
				}
			}
			return bitSet;
		}

		protected virtual object RecoverFromMismatchedToken(IIntStream input, int ttype, BitSet follow)
		{
			RecognitionException e = null;
			if (MismatchIsUnwantedToken(input, ttype))
			{
				e = new UnwantedTokenException(ttype, input, TokenNames);
				BeginResync();
				input.Consume();
				EndResync();
				ReportError(e);
				object currentInputSymbol = GetCurrentInputSymbol(input);
				input.Consume();
				return currentInputSymbol;
			}
			if (MismatchIsMissingToken(input, follow))
			{
				object missingSymbol = GetMissingSymbol(input, e, ttype, follow);
				e = new MissingTokenException(ttype, input, missingSymbol);
				ReportError(e);
				return missingSymbol;
			}
			e = new MismatchedTokenException(ttype, input, TokenNames);
			throw e;
		}

		public virtual object RecoverFromMismatchedSet(IIntStream input, RecognitionException e, BitSet follow)
		{
			if (MismatchIsMissingToken(input, follow))
			{
				ReportError(e);
				return GetMissingSymbol(input, e, 0, follow);
			}
			throw e;
		}

		protected virtual object GetCurrentInputSymbol(IIntStream input)
		{
			return null;
		}

		protected virtual object GetMissingSymbol(IIntStream input, RecognitionException e, int expectedTokenType, BitSet follow)
		{
			return null;
		}

		public virtual void ConsumeUntil(IIntStream input, int tokenType)
		{
			int num = input.LA(1);
			while (num != -1 && num != tokenType)
			{
				input.Consume();
				num = input.LA(1);
			}
		}

		public virtual void ConsumeUntil(IIntStream input, BitSet set)
		{
			int num = input.LA(1);
			while (num != -1 && !set.Member(num))
			{
				input.Consume();
				num = input.LA(1);
			}
		}

		protected void PushFollow(BitSet fset)
		{
			if (state._fsp + 1 >= state.following.Length)
			{
				Array.Resize(ref state.following, state.following.Length * 2);
			}
			state.following[++state._fsp] = fset;
		}

		protected void PopFollow()
		{
			state._fsp--;
		}

		public virtual IList<string> GetRuleInvocationStack()
		{
			return GetRuleInvocationStack(new StackTrace(fNeedFileInfo: true));
		}

		public static IList<string> GetRuleInvocationStack(StackTrace trace)
		{
			if (trace == null)
			{
				throw new ArgumentNullException("trace");
			}
			List<string> list = new List<string>();
			StackFrame[] array = trace.GetFrames() ?? new StackFrame[0];
			for (int num = array.Length - 1; num >= 0; num--)
			{
				GrammarRuleAttribute[] array2 = (GrammarRuleAttribute[])array[num].GetMethod().GetCustomAttributes(typeof(GrammarRuleAttribute), inherit: true);
				if (array2 != null && array2.Length != 0)
				{
					list.Add(array2[0].Name);
				}
			}
			return list;
		}

		public virtual List<string> ToStrings(ICollection<IToken> tokens)
		{
			if (tokens == null)
			{
				return null;
			}
			List<string> list = new List<string>(tokens.Count);
			foreach (IToken token in tokens)
			{
				list.Add(token.Text);
			}
			return list;
		}

		public virtual int GetRuleMemoization(int ruleIndex, int ruleStartIndex)
		{
			if (state.ruleMemo[ruleIndex] == null)
			{
				state.ruleMemo[ruleIndex] = new Dictionary<int, int>();
			}
			if (!state.ruleMemo[ruleIndex].TryGetValue(ruleStartIndex, out var value))
			{
				return -1;
			}
			return value;
		}

		public virtual bool AlreadyParsedRule(IIntStream input, int ruleIndex)
		{
			int ruleMemoization = GetRuleMemoization(ruleIndex, input.Index);
			switch (ruleMemoization)
			{
			case -1:
				return false;
			case -2:
				state.failed = true;
				break;
			default:
				input.Seek(ruleMemoization + 1);
				break;
			}
			return true;
		}

		public virtual void Memoize(IIntStream input, int ruleIndex, int ruleStartIndex)
		{
			int value = (state.failed ? (-2) : (input.Index - 1));
			if (state.ruleMemo == null && TraceDestination != null)
			{
				TraceDestination.WriteLine("!!!!!!!!! memo array is null for " + GrammarFileName);
			}
			if (ruleIndex >= state.ruleMemo.Length && TraceDestination != null)
			{
				TraceDestination.WriteLine("!!!!!!!!! memo size is " + state.ruleMemo.Length + ", but rule index is " + ruleIndex);
			}
			if (state.ruleMemo[ruleIndex] != null)
			{
				state.ruleMemo[ruleIndex][ruleStartIndex] = value;
			}
		}

		public virtual int GetRuleMemoizationCacheSize()
		{
			int num = 0;
			int num2 = 0;
			while (state.ruleMemo != null && num2 < state.ruleMemo.Length)
			{
				IDictionary<int, int> dictionary = state.ruleMemo[num2];
				if (dictionary != null)
				{
					num += dictionary.Count;
				}
				num2++;
			}
			return num;
		}

		public virtual void TraceIn(string ruleName, int ruleIndex, object inputSymbol)
		{
			if (TraceDestination != null)
			{
				TraceDestination.Write("enter " + ruleName + " " + inputSymbol);
				if (state.backtracking > 0)
				{
					TraceDestination.Write(" backtracking=" + state.backtracking);
				}
				TraceDestination.WriteLine();
			}
		}

		public virtual void TraceOut(string ruleName, int ruleIndex, object inputSymbol)
		{
			if (TraceDestination == null)
			{
				return;
			}
			TraceDestination.Write("exit " + ruleName + " " + inputSymbol);
			if (state.backtracking > 0)
			{
				TraceDestination.Write(" backtracking=" + state.backtracking);
				if (state.failed)
				{
					TraceDestination.Write(" failed");
				}
				else
				{
					TraceDestination.Write(" succeeded");
				}
			}
			TraceDestination.WriteLine();
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugEnterRule(string grammarFileName, string ruleName)
		{
			DebugListener?.EnterRule(grammarFileName, ruleName);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugExitRule(string grammarFileName, string ruleName)
		{
			DebugListener?.ExitRule(grammarFileName, ruleName);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugEnterSubRule(int decisionNumber)
		{
			DebugListener?.EnterSubRule(decisionNumber);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugExitSubRule(int decisionNumber)
		{
			DebugListener?.ExitSubRule(decisionNumber);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugEnterAlt(int alt)
		{
			DebugListener?.EnterAlt(alt);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugEnterDecision(int decisionNumber, bool couldBacktrack)
		{
			DebugListener?.EnterDecision(decisionNumber, couldBacktrack);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugExitDecision(int decisionNumber)
		{
			DebugListener?.ExitDecision(decisionNumber);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugLocation(int line, int charPositionInLine)
		{
			DebugListener?.Location(line, charPositionInLine);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugSemanticPredicate(bool result, string predicate)
		{
			DebugListener?.SemanticPredicate(result, predicate);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugBeginBacktrack(int level)
		{
			DebugListener?.BeginBacktrack(level);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugEndBacktrack(int level, bool successful)
		{
			DebugListener?.EndBacktrack(level, successful);
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugRecognitionException(RecognitionException ex)
		{
			DebugListener?.RecognitionException(ex);
		}
	}
	[Serializable]
	public sealed class BitSet : ICloneable
	{
		private const int BITS = 64;

		private const int LOG_BITS = 6;

		private const int MOD_MASK = 63;

		private ulong[] _bits;

		public BitSet()
			: this(64)
		{
		}

		[CLSCompliant(false)]
		public BitSet(ulong[] bits)
		{
			_bits = bits;
		}

		public BitSet(IEnumerable<int> items)
			: this()
		{
			foreach (int item in items)
			{
				Add(item);
			}
		}

		public BitSet(int nbits)
		{
			_bits = new ulong[(nbits - 1 >> 6) + 1];
		}

		public static BitSet Of(int el)
		{
			BitSet bitSet = new BitSet(el + 1);
			bitSet.Add(el);
			return bitSet;
		}

		public static BitSet Of(int a, int b)
		{
			BitSet bitSet = new BitSet(Math.Max(a, b) + 1);
			bitSet.Add(a);
			bitSet.Add(b);
			return bitSet;
		}

		public static BitSet Of(int a, int b, int c)
		{
			BitSet bitSet = new BitSet();
			bitSet.Add(a);
			bitSet.Add(b);
			bitSet.Add(c);
			return bitSet;
		}

		public static BitSet Of(int a, int b, int c, int d)
		{
			BitSet bitSet = new BitSet();
			bitSet.Add(a);
			bitSet.Add(b);
			bitSet.Add(c);
			bitSet.Add(d);
			return bitSet;
		}

		public BitSet Or(BitSet a)
		{
			if (a == null)
			{
				return this;
			}
			BitSet obj = (BitSet)Clone();
			obj.OrInPlace(a);
			return obj;
		}

		public void Add(int el)
		{
			int num = WordNumber(el);
			if (num >= _bits.Length)
			{
				GrowToInclude(el);
			}
			_bits[num] |= BitMask(el);
		}

		public void GrowToInclude(int bit)
		{
			int size = Math.Max(_bits.Length << 1, NumWordsToHold(bit));
			SetSize(size);
		}

		public void OrInPlace(BitSet a)
		{
			if (a != null)
			{
				if (a._bits.Length > _bits.Length)
				{
					SetSize(a._bits.Length);
				}
				for (int num = Math.Min(_bits.Length, a._bits.Length) - 1; num >= 0; num--)
				{
					_bits[num] |= a._bits[num];
				}
			}
		}

		private void SetSize(int nwords)
		{
			Array.Resize(ref _bits, nwords);
		}

		private static ulong BitMask(int bitNumber)
		{
			int num = bitNumber & 0x3F;
			return (ulong)(1L << num);
		}

		public object Clone()
		{
			return new BitSet((ulong[])_bits.Clone());
		}

		public int Size()
		{
			int num = 0;
			for (int num2 = _bits.Length - 1; num2 >= 0; num2--)
			{
				ulong num3 = _bits[num2];
				if (num3 != 0L)
				{
					for (int num4 = 63; num4 >= 0; num4--)
					{
						if ((num3 & (ulong)(1L << num4)) != 0L)
						{
							num++;
						}
					}
				}
			}
			return num;
		}

		public override int GetHashCode()
		{
			throw new NotImplementedException();
		}

		public override bool Equals(object other)
		{
			if (other == null || !(other is BitSet))
			{
				return false;
			}
			BitSet bitSet = (BitSet)other;
			int num = Math.Min(_bits.Length, bitSet._bits.Length);
			for (int i = 0; i < num; i++)
			{
				if (_bits[i] != bitSet._bits[i])
				{
					return false;
				}
			}
			if (_bits.Length > num)
			{
				for (int j = num + 1; j < _bits.Length; j++)
				{
					if (_bits[j] != 0L)
					{
						return false;
					}
				}
			}
			else if (bitSet._bits.Length > num)
			{
				for (int k = num + 1; k < bitSet._bits.Length; k++)
				{
					if (bitSet._bits[k] != 0L)
					{
						return false;
					}
				}
			}
			return true;
		}

		public bool Member(int el)
		{
			if (el < 0)
			{
				return false;
			}
			int num = WordNumber(el);
			if (num >= _bits.Length)
			{
				return false;
			}
			return (_bits[num] & BitMask(el)) != 0;
		}

		public void Remove(int el)
		{
			int num = WordNumber(el);
			if (num < _bits.Length)
			{
				_bits[num] &= ~BitMask(el);
			}
		}

		public bool IsNil()
		{
			for (int num = _bits.Length - 1; num >= 0; num--)
			{
				if (_bits[num] != 0L)
				{
					return false;
				}
			}
			return true;
		}

		private static int NumWordsToHold(int el)
		{
			return (el >> 6) + 1;
		}

		public int NumBits()
		{
			return _bits.Length << 6;
		}

		public int LengthInLongWords()
		{
			return _bits.Length;
		}

		public int[] ToArray()
		{
			int[] array = new int[Size()];
			int num = 0;
			for (int i = 0; i < _bits.Length << 6; i++)
			{
				if (Member(i))
				{
					array[num++] = i;
				}
			}
			return array;
		}

		private static int WordNumber(int bit)
		{
			return bit >> 6;
		}

		public override string ToString()
		{
			return ToString(null);
		}

		public string ToString(string[] tokenNames)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string value = ",";
			bool flag = false;
			stringBuilder.Append('{');
			for (int i = 0; i < _bits.Length << 6; i++)
			{
				if (Member(i))
				{
					if (i > 0 && flag)
					{
						stringBuilder.Append(value);
					}
					if (tokenNames != null)
					{
						stringBuilder.Append(tokenNames[i]);
					}
					else
					{
						stringBuilder.Append(i);
					}
					flag = true;
				}
			}
			stringBuilder.Append('}');
			return stringBuilder.ToString();
		}
	}
	[Serializable]
	public class BufferedTokenStream : ITokenStream, IIntStream, ITokenStreamInformation
	{
		private ITokenSource _tokenSource;

		[CLSCompliant(false)]
		protected List<IToken> _tokens = new List<IToken>(100);

		private int _lastMarker;

		[CLSCompliant(false)]
		protected int _p = -1;

		public virtual ITokenSource TokenSource
		{
			get
			{
				return _tokenSource;
			}
			set
			{
				_tokenSource = value;
				_tokens.Clear();
				_p = -1;
			}
		}

		public virtual int Index => _p;

		public virtual int Range { get; protected set; }

		public virtual int Count => _tokens.Count;

		public virtual string SourceName => _tokenSource.SourceName;

		public virtual IToken LastToken => LB(1);

		public virtual IToken LastRealToken
		{
			get
			{
				int num = 0;
				IToken token;
				do
				{
					num++;
					token = LB(num);
				}
				while (token != null && token.Line <= 0);
				return token;
			}
		}

		public virtual int MaxLookBehind => int.MaxValue;

		public BufferedTokenStream()
		{
		}

		public BufferedTokenStream(ITokenSource tokenSource)
		{
			_tokenSource = tokenSource;
		}

		public virtual int Mark()
		{
			if (_p == -1)
			{
				Setup();
			}
			_lastMarker = Index;
			return _lastMarker;
		}

		public virtual void Release(int marker)
		{
		}

		public virtual void Rewind(int marker)
		{
			Seek(marker);
		}

		public virtual void Rewind()
		{
			Seek(_lastMarker);
		}

		public virtual void Reset()
		{
			_p = 0;
			_lastMarker = 0;
		}

		public virtual void Seek(int index)
		{
			_p = index;
		}

		public virtual void Consume()
		{
			if (_p == -1)
			{
				Setup();
			}
			_p++;
			Sync(_p);
		}

		protected virtual void Sync(int i)
		{
			int num = i - _tokens.Count + 1;
			if (num > 0)
			{
				Fetch(num);
			}
		}

		protected virtual void Fetch(int n)
		{
			for (int i = 0; i < n; i++)
			{
				IToken token = TokenSource.NextToken();
				token.TokenIndex = _tokens.Count;
				_tokens.Add(token);
				if (token.Type == -1)
				{
					break;
				}
			}
		}

		public virtual IToken Get(int i)
		{
			if (i < 0 || i >= _tokens.Count)
			{
				throw new IndexOutOfRangeException("token index " + i + " out of range 0.." + (_tokens.Count - 1));
			}
			return _tokens[i];
		}

		public virtual int LA(int i)
		{
			return LT(i).Type;
		}

		protected virtual IToken LB(int k)
		{
			if (_p - k < 0)
			{
				return null;
			}
			return _tokens[_p - k];
		}

		public virtual IToken LT(int k)
		{
			if (_p == -1)
			{
				Setup();
			}
			if (k == 0)
			{
				return null;
			}
			if (k < 0)
			{
				return LB(-k);
			}
			int num = _p + k - 1;
			Sync(num);
			if (num >= _tokens.Count)
			{
				return _tokens[_tokens.Count - 1];
			}
			if (num > Range)
			{
				Range = num;
			}
			return _tokens[_p + k - 1];
		}

		protected virtual void Setup()
		{
			Sync(0);
			_p = 0;
		}

		public virtual List<IToken> GetTokens()
		{
			return _tokens;
		}

		public virtual List<IToken> GetTokens(int start, int stop)
		{
			return GetTokens(start, stop, (BitSet)null);
		}

		public virtual List<IToken> GetTokens(int start, int stop, BitSet types)
		{
			if (_p == -1)
			{
				Setup();
			}
			if (stop >= _tokens.Count)
			{
				stop = _tokens.Count - 1;
			}
			if (start < 0)
			{
				start = 0;
			}
			if (start > stop)
			{
				return null;
			}
			List<IToken> list = new List<IToken>();
			for (int i = start; i <= stop; i++)
			{
				IToken token = _tokens[i];
				if (types == null || types.Member(token.Type))
				{
					list.Add(token);
				}
			}
			if (list.Count == 0)
			{
				list = null;
			}
			return list;
		}

		public virtual List<IToken> GetTokens(int start, int stop, IEnumerable<int> types)
		{
			return GetTokens(start, stop, new BitSet(types));
		}

		public virtual List<IToken> GetTokens(int start, int stop, int ttype)
		{
			return GetTokens(start, stop, BitSet.Of(ttype));
		}

		public override string ToString()
		{
			if (_p == -1)
			{
				Setup();
			}
			Fill();
			return ToString(0, _tokens.Count - 1);
		}

		public virtual string ToString(int start, int stop)
		{
			if (start < 0 || stop < 0)
			{
				return null;
			}
			if (_p == -1)
			{
				Setup();
			}
			if (stop >= _tokens.Count)
			{
				stop = _tokens.Count - 1;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = start; i <= stop; i++)
			{
				IToken token = _tokens[i];
				if (token.Type == -1)
				{
					break;
				}
				stringBuilder.Append(token.Text);
			}
			return stringBuilder.ToString();
		}

		public virtual string ToString(IToken start, IToken stop)
		{
			if (start != null && stop != null)
			{
				return ToString(start.TokenIndex, stop.TokenIndex);
			}
			return null;
		}

		public virtual void Fill()
		{
			if (_p == -1)
			{
				Setup();
			}
			if (_tokens[_p].Type != -1)
			{
				int num = _p + 1;
				Sync(num);
				while (_tokens[num].Type != -1)
				{
					num++;
					Sync(num);
				}
			}
		}
	}
	public static class CharStreamConstants
	{
		public const int EndOfFile = -1;
	}
	[Serializable]
	public class CharStreamState
	{
		public int p;

		public int line;

		public int charPositionInLine;
	}
	[Serializable]
	public class ClassicToken : IToken
	{
		private string text;

		private int type;

		private int line;

		private int charPositionInLine;

		private int channel;

		private int index;

		public string Text
		{
			get
			{
				return text;
			}
			set
			{
				text = value;
			}
		}

		public int Type
		{
			get
			{
				return type;
			}
			set
			{
				type = value;
			}
		}

		public int Line
		{
			get
			{
				return line;
			}
			set
			{
				line = value;
			}
		}

		public int CharPositionInLine
		{
			get
			{
				return charPositionInLine;
			}
			set
			{
				charPositionInLine = value;
			}
		}

		public int Channel
		{
			get
			{
				return channel;
			}
			set
			{
				channel = value;
			}
		}

		public int StartIndex
		{
			get
			{
				return -1;
			}
			set
			{
			}
		}

		public int StopIndex
		{
			get
			{
				return -1;
			}
			set
			{
			}
		}

		public int TokenIndex
		{
			get
			{
				return index;
			}
			set
			{
				index = value;
			}
		}

		public ICharStream InputStream
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ClassicToken(int type)
		{
			this.type = type;
		}

		public ClassicToken(IToken oldToken)
		{
			text = oldToken.Text;
			type = oldToken.Type;
			line = oldToken.Line;
			charPositionInLine = oldToken.CharPositionInLine;
			channel = oldToken.Channel;
		}

		public ClassicToken(int type, string text)
		{
			this.type = type;
			this.text = text;
		}

		public ClassicToken(int type, string text, int channel)
		{
			this.type = type;
			this.text = text;
			this.channel = channel;
		}

		public override string ToString()
		{
			string text = "";
			if (channel > 0)
			{
				text = ",channel=" + channel;
			}
			string text2 = Text;
			if (text2 != null)
			{
				text2 = text2.Replace("\n", "\\\\n");
				text2 = text2.Replace("\r", "\\\\r");
				text2 = text2.Replace("\t", "\\\\t");
			}
			else
			{
				text2 = "<no text>";
			}
			return "[@" + TokenIndex + ",'" + text2 + "',<" + type + ">" + text + "," + line + ":" + CharPositionInLine + "]";
		}
	}
	[Serializable]
	public class CommonToken : IToken
	{
		private int type;

		private int line;

		private int charPositionInLine = -1;

		private int channel;

		[NonSerialized]
		private ICharStream input;

		private string text;

		private int index = -1;

		private int start;

		private int stop;

		public string Text
		{
			get
			{
				if (text != null)
				{
					return text;
				}
				if (input == null)
				{
					return null;
				}
				if (start <= stop && stop < input.Count)
				{
					return input.Substring(start, stop - start + 1);
				}
				return "<EOF>";
			}
			set
			{
				text = value;
			}
		}

		public int Type
		{
			get
			{
				return type;
			}
			set
			{
				type = value;
			}
		}

		public int Line
		{
			get
			{
				return line;
			}
			set
			{
				line = value;
			}
		}

		public int CharPositionInLine
		{
			get
			{
				return charPositionInLine;
			}
			set
			{
				charPositionInLine = value;
			}
		}

		public int Channel
		{
			get
			{
				return channel;
			}
			set
			{
				channel = value;
			}
		}

		public int StartIndex
		{
			get
			{
				return start;
			}
			set
			{
				start = value;
			}
		}

		public int StopIndex
		{
			get
			{
				return stop;
			}
			set
			{
				stop = value;
			}
		}

		public int TokenIndex
		{
			get
			{
				return index;
			}
			set
			{
				index = value;
			}
		}

		public ICharStream InputStream
		{
			get
			{
				return input;
			}
			set
			{
				input = value;
			}
		}

		public CommonToken()
		{
		}

		public CommonToken(int type)
		{
			this.type = type;
		}

		public CommonToken(ICharStream input, int type, int channel, int start, int stop)
		{
			this.input = input;
			this.type = type;
			this.channel = channel;
			this.start = start;
			this.stop = stop;
		}

		public CommonToken(int type, string text)
		{
			this.type = type;
			channel = 0;
			this.text = text;
		}

		public CommonToken(IToken oldToken)
		{
			text = oldToken.Text;
			type = oldToken.Type;
			line = oldToken.Line;
			index = oldToken.TokenIndex;
			charPositionInLine = oldToken.CharPositionInLine;
			channel = oldToken.Channel;
			input = oldToken.InputStream;
			if (oldToken is CommonToken)
			{
				start = ((CommonToken)oldToken).start;
				stop = ((CommonToken)oldToken).stop;
			}
		}

		public override string ToString()
		{
			string text = "";
			if (channel > 0)
			{
				text = ",channel=" + channel;
			}
			string text2 = Text;
			if (text2 != null)
			{
				text2 = Regex.Replace(text2, "\n", "\\\\n");
				text2 = Regex.Replace(text2, "\r", "\\\\r");
				text2 = Regex.Replace(text2, "\t", "\\\\t");
			}
			else
			{
				text2 = "<no text>";
			}
			return "[@" + TokenIndex + "," + start + ":" + stop + "='" + text2 + "',<" + type + ">" + text + "," + line + ":" + CharPositionInLine + "]";
		}

		[OnSerializing]
		internal void OnSerializing(StreamingContext context)
		{
			if (text == null)
			{
				text = Text;
			}
		}
	}
	[Serializable]
	public class CommonTokenStream : BufferedTokenStream
	{
		private int _channel;

		public int Channel => _channel;

		public override ITokenSource TokenSource
		{
			get
			{
				return base.TokenSource;
			}
			set
			{
				base.TokenSource = value;
				_channel = 0;
			}
		}

		public CommonTokenStream()
		{
		}

		public CommonTokenStream(ITokenSource tokenSource)
			: this(tokenSource, 0)
		{
		}

		public CommonTokenStream(ITokenSource tokenSource, int channel)
			: base(tokenSource)
		{
			_channel = channel;
		}

		public override void Consume()
		{
			if (_p == -1)
			{
				Setup();
			}
			_p++;
			_p = SkipOffTokenChannels(_p);
		}

		protected override IToken LB(int k)
		{
			if (k == 0 || _p - k < 0)
			{
				return null;
			}
			int num = _p;
			for (int i = 1; i <= k; i++)
			{
				num = SkipOffTokenChannelsReverse(num - 1);
			}
			if (num < 0)
			{
				return null;
			}
			return _tokens[num];
		}

		public override IToken LT(int k)
		{
			if (_p == -1)
			{
				Setup();
			}
			if (k == 0)
			{
				return null;
			}
			if (k < 0)
			{
				return LB(-k);
			}
			int num = _p;
			for (int i = 1; i < k; i++)
			{
				num = SkipOffTokenChannels(num + 1);
			}
			if (num > Range)
			{
				Range = num;
			}
			return _tokens[num];
		}

		protected virtual int SkipOffTokenChannels(int i)
		{
			Sync(i);
			while (_tokens[i].Channel != _channel)
			{
				i++;
				Sync(i);
			}
			return i;
		}

		protected virtual int SkipOffTokenChannelsReverse(int i)
		{
			while (i >= 0 && _tokens[i].Channel != _channel)
			{
				i--;
			}
			return i;
		}

		public override void Reset()
		{
			base.Reset();
			_p = SkipOffTokenChannels(0);
		}

		protected override void Setup()
		{
			_p = 0;
			_p = SkipOffTokenChannels(_p);
		}
	}
	public delegate int SpecialStateTransitionHandler(DFA dfa, int s, IIntStream input);
	public class DFA
	{
		protected short[] eot;

		protected short[] eof;

		protected char[] min;

		protected char[] max;

		protected short[] accept;

		protected short[] special;

		protected short[][] transition;

		protected int decisionNumber;

		protected BaseRecognizer recognizer;

		public bool debug;

		public virtual string Description => "n/a";

		public SpecialStateTransitionHandler SpecialStateTransition { get; private set; }

		public DFA()
			: this(SpecialStateTransitionDefault)
		{
		}

		public DFA(SpecialStateTransitionHandler specialStateTransition)
		{
			SpecialStateTransition = specialStateTransition ?? new SpecialStateTransitionHandler(SpecialStateTransitionDefault);
		}

		public virtual int Predict(IIntStream input)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			int marker = input.Mark();
			int num = 0;
			try
			{
				char c;
				while (true)
				{
					int num2 = special[num];
					if (num2 >= 0)
					{
						num = SpecialStateTransition(this, num2, input);
						if (num == -1)
						{
							NoViableAlt(num, input);
							return 0;
						}
						input.Consume();
						continue;
					}
					if (accept[num] >= 1)
					{
						return accept[num];
					}
					c = (char)input.LA(1);
					if (c >= min[num] && c <= max[num])
					{
						int num3 = transition[num][c - min[num]];
						if (num3 < 0)
						{
							if (eot[num] < 0)
							{
								NoViableAlt(num, input);
								return 0;
							}
							num = eot[num];
							input.Consume();
						}
						else
						{
							num = num3;
							input.Consume();
						}
					}
					else
					{
						if (eot[num] < 0)
						{
							break;
						}
						num = eot[num];
						input.Consume();
					}
				}
				if (c == '\uffff' && eof[num] >= 0)
				{
					return accept[eof[num]];
				}
				NoViableAlt(num, input);
				return 0;
			}
			finally
			{
				input.Rewind(marker);
			}
		}

		[Conditional("DEBUG_DFA")]
		private void DfaDebugMessage(string format, params object[] args)
		{
			Console.Error.WriteLine(format, args);
		}

		[Conditional("DEBUG_DFA")]
		private void DfaDebugInvalidSymbol(int s)
		{
			Console.Error.WriteLine("min[{0}]={1}", s, min[s]);
			Console.Error.WriteLine("max[{0}]={1}", s, max[s]);
			Console.Error.WriteLine("eot[{0}]={1}", s, eot[s]);
			Console.Error.WriteLine("eof[{0}]={1}", s, eof[s]);
			for (int i = 0; i < transition[s].Length; i++)
			{
				Console.Error.Write(transition[s][i] + " ");
			}
			Console.Error.WriteLine();
		}

		protected virtual void NoViableAlt(int s, IIntStream input)
		{
			if (recognizer.state.backtracking > 0)
			{
				recognizer.state.failed = true;
				return;
			}
			NoViableAltException ex = new NoViableAltException(Description, decisionNumber, s, input);
			Error(ex);
			throw ex;
		}

		public virtual void Error(NoViableAltException nvae)
		{
		}

		private static int SpecialStateTransitionDefault(DFA dfa, int s, IIntStream input)
		{
			return -1;
		}

		public static short[] UnpackEncodedString(string encodedString)
		{
			int num = 0;
			for (int i = 0; i < encodedString.Length; i += 2)
			{
				num += encodedString[i];
			}
			short[] array = new short[num];
			int num2 = 0;
			for (int j = 0; j < encodedString.Length; j += 2)
			{
				char c = encodedString[j];
				char c2 = encodedString[j + 1];
				for (int k = 1; k <= c; k++)
				{
					array[num2++] = (short)c2;
				}
			}
			return array;
		}

		public static char[] UnpackEncodedStringToUnsignedChars(string encodedString)
		{
			int num = 0;
			for (int i = 0; i < encodedString.Length; i += 2)
			{
				num += encodedString[i];
			}
			char[] array = new char[num];
			int num2 = 0;
			for (int j = 0; j < encodedString.Length; j += 2)
			{
				char c = encodedString[j];
				char c2 = encodedString[j + 1];
				for (int k = 1; k <= c; k++)
				{
					array[num2++] = c2;
				}
			}
			return array;
		}

		[Conditional("ANTLR_DEBUG")]
		protected virtual void DebugRecognitionException(RecognitionException ex)
		{
			recognizer.DebugListener?.RecognitionException(ex);
		}
	}
	[Serializable]
	public class EarlyExitException : RecognitionException
	{
		private readonly int _decisionNumber;

		public int DecisionNumber => _decisionNumber;

		public EarlyExitException()
		{
		}

		public EarlyExitException(string message)
			: base(message)
		{
		}

		public EarlyExitException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public EarlyExitException(int decisionNumber, IIntStream input)
			: base(input)
		{
			_decisionNumber = decisionNumber;
		}

		public EarlyExitException(string message, int decisionNumber, IIntStream input)
			: base(message, input)
		{
			_decisionNumber = decisionNumber;
		}

		public EarlyExitException(string message, int decisionNumber, IIntStream input, Exception innerException)
			: base(message, input, innerException)
		{
			_decisionNumber = decisionNumber;
		}

		protected EarlyExitException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_decisionNumber = info.GetInt32("DecisionNumber");
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("DecisionNumber", DecisionNumber);
		}
	}
	[Serializable]
	public class FailedPredicateException : RecognitionException
	{
		private readonly string _ruleName;

		private readonly string _predicateText;

		public string RuleName => _ruleName;

		public string PredicateText => _predicateText;

		public FailedPredicateException()
		{
		}

		public FailedPredicateException(string message)
			: base(message)
		{
		}

		public FailedPredicateException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public FailedPredicateException(IIntStream input, string ruleName, string predicateText)
			: base(input)
		{
			_ruleName = ruleName;
			_predicateText = predicateText;
		}

		public FailedPredicateException(string message, IIntStream input, string ruleName, string predicateText)
			: base(message, input)
		{
			_ruleName = ruleName;
			_predicateText = predicateText;
		}

		public FailedPredicateException(string message, IIntStream input, string ruleName, string predicateText, Exception innerException)
			: base(message, input, innerException)
		{
			_ruleName = ruleName;
			_predicateText = predicateText;
		}

		protected FailedPredicateException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_ruleName = info.GetString("RuleName");
			_predicateText = info.GetString("PredicateText");
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("RuleName", _ruleName);
			info.AddValue("PredicateText", _predicateText);
		}

		public override string ToString()
		{
			return "FailedPredicateException(" + RuleName + ",{" + PredicateText + "}?)";
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
	public sealed class GrammarRuleAttribute : Attribute
	{
		private readonly string _name;

		public string Name => _name;

		public GrammarRuleAttribute(string name)
		{
			_name = name;
		}
	}
	public interface IAstRuleReturnScope : IRuleReturnScope
	{
		object Tree { get; }
	}
	public interface IAstRuleReturnScope<TAstLabel> : IAstRuleReturnScope, IRuleReturnScope
	{
		new TAstLabel Tree { get; }
	}
	public interface ICharStream : IIntStream
	{
		int Line { get; set; }

		int CharPositionInLine { get; set; }

		string Substring(int start, int length);

		int LT(int i);
	}
	public interface IIntStream
	{
		int Index { get; }

		int Count { get; }

		string SourceName { get; }

		void Consume();

		int LA(int i);

		int Mark();

		void Rewind(int marker);

		void Rewind();

		void Release(int marker);

		void Seek(int index);
	}
	public interface IRuleReturnScope
	{
		object Start { get; }

		object Stop { get; }
	}
	public interface IRuleReturnScope<TLabel> : IRuleReturnScope
	{
		new TLabel Start { get; }

		new TLabel Stop { get; }
	}
	public interface ITemplateRuleReturnScope
	{
		object Template { get; }
	}
	public interface ITemplateRuleReturnScope<TTemplate> : ITemplateRuleReturnScope
	{
		new TTemplate Template { get; }
	}
	public interface IToken
	{
		string Text { get; set; }

		int Type { get; set; }

		int Line { get; set; }

		int CharPositionInLine { get; set; }

		int Channel { get; set; }

		int StartIndex { get; set; }

		int StopIndex { get; set; }

		int TokenIndex { get; set; }

		ICharStream InputStream { get; set; }
	}
	public interface ITokenSource
	{
		string SourceName { get; }

		string[] TokenNames { get; }

		IToken NextToken();
	}
	public interface ITokenStream : IIntStream
	{
		int Range { get; }

		ITokenSource TokenSource { get; }

		IToken LT(int k);

		IToken Get(int i);

		string ToString(int start, int stop);

		string ToString(IToken start, IToken stop);
	}
	public interface ITokenStreamInformation
	{
		IToken LastToken { get; }

		IToken LastRealToken { get; }

		int MaxLookBehind { get; }
	}
	[Serializable]
	public class LegacyCommonTokenStream : ITokenStream, IIntStream
	{
		[NonSerialized]
		private ITokenSource _tokenSource;

		protected List<IToken> tokens;

		protected IDictionary<int, int> channelOverrideMap;

		protected List<int> discardSet;

		protected int channel;

		protected bool discardOffChannelTokens;

		protected int lastMarker;

		protected int p = -1;

		public virtual int Index => p;

		public virtual int Range { get; protected set; }

		public virtual int Count => tokens.Count;

		public virtual ITokenSource TokenSource => _tokenSource;

		public virtual string SourceName => TokenSource.SourceName;

		public LegacyCommonTokenStream()
		{
			tokens = new List<IToken>(500);
		}

		public LegacyCommonTokenStream(ITokenSource tokenSource)
			: this()
		{
			_tokenSource = tokenSource;
		}

		public LegacyCommonTokenStream(ITokenSource tokenSource, int channel)
			: this(tokenSource)
		{
			this.channel = channel;
		}

		public virtual void SetTokenSource(ITokenSource tokenSource)
		{
			_tokenSource = tokenSource;
			tokens.Clear();
			p = -1;
			channel = 0;
		}

		public virtual void FillBuffer()
		{
			if (p != -1)
			{
				return;
			}
			int num = 0;
			IToken token = _tokenSource.NextToken();
			while (token != null && token.Type != -1)
			{
				bool flag = false;
				if (channelOverrideMap != null && channelOverrideMap.TryGetValue(token.Type, out var value))
				{
					token.Channel = value;
				}
				if (discardSet != null && discardSet.Contains(token.Type))
				{
					flag = true;
				}
				else if (discardOffChannelTokens && token.Channel != channel)
				{
					flag = true;
				}
				if (!flag)
				{
					token.TokenIndex = num;
					tokens.Add(token);
					num++;
				}
				token = _tokenSource.NextToken();
			}
			p = 0;
			p = SkipOffTokenChannels(p);
		}

		public virtual void Consume()
		{
			if (p < tokens.Count)
			{
				p++;
				p = SkipOffTokenChannels(p);
			}
		}

		protected virtual int SkipOffTokenChannels(int i)
		{
			int count = tokens.Count;
			while (i < count && tokens[i].Channel != channel)
			{
				i++;
			}
			return i;
		}

		protected virtual int SkipOffTokenChannelsReverse(int i)
		{
			while (i >= 0 && tokens[i].Channel != channel)
			{
				i--;
			}
			return i;
		}

		public virtual void SetTokenTypeChannel(int ttype, int channel)
		{
			if (channelOverrideMap == null)
			{
				channelOverrideMap = new Dictionary<int, int>();
			}
			channelOverrideMap[ttype] = channel;
		}

		public virtual void DiscardTokenType(int ttype)
		{
			if (discardSet == null)
			{
				discardSet = new List<int>();
			}
			discardSet.Add(ttype);
		}

		public virtual void SetDiscardOffChannelTokens(bool discardOffChannelTokens)
		{
			this.discardOffChannelTokens = discardOffChannelTokens;
		}

		public virtual IList<IToken> GetTokens()
		{
			if (p == -1)
			{
				FillBuffer();
			}
			return tokens;
		}

		public virtual IList<IToken> GetTokens(int start, int stop)
		{
			return GetTokens(start, stop, (BitSet)null);
		}

		public virtual IList<IToken> GetTokens(int start, int stop, BitSet types)
		{
			if (p == -1)
			{
				FillBuffer();
			}
			if (stop >= tokens.Count)
			{
				stop = tokens.Count - 1;
			}
			if (start < 0)
			{
				start = 0;
			}
			if (start > stop)
			{
				return null;
			}
			IList<IToken> list = new List<IToken>();
			for (int i = start; i <= stop; i++)
			{
				IToken token = tokens[i];
				if (types == null || types.Member(token.Type))
				{
					list.Add(token);
				}
			}
			if (list.Count == 0)
			{
				list = null;
			}
			return list;
		}

		public virtual IList<IToken> GetTokens(int start, int stop, IList<int> types)
		{
			return GetTokens(start, stop, new BitSet(types));
		}

		public virtual IList<IToken> GetTokens(int start, int stop, int ttype)
		{
			return GetTokens(start, stop, BitSet.Of(ttype));
		}

		public virtual IToken LT(int k)
		{
			if (p == -1)
			{
				FillBuffer();
			}
			if (k == 0)
			{
				return null;
			}
			if (k < 0)
			{
				return LB(-k);
			}
			if (p + k - 1 >= tokens.Count)
			{
				return tokens[tokens.Count - 1];
			}
			int num = p;
			for (int i = 1; i < k; i++)
			{
				num = SkipOffTokenChannels(num + 1);
			}
			if (num >= tokens.Count)
			{
				return tokens[tokens.Count - 1];
			}
			if (num > Range)
			{
				Range = num;
			}
			return tokens[num];
		}

		protected virtual IToken LB(int k)
		{
			if (p == -1)
			{
				FillBuffer();
			}
			if (k == 0)
			{
				return null;
			}
			if (p - k < 0)
			{
				return null;
			}
			int num = p;
			for (int i = 1; i <= k; i++)
			{
				num = SkipOffTokenChannelsReverse(num - 1);
			}
			if (num < 0)
			{
				return null;
			}
			return tokens[num];
		}

		public virtual IToken Get(int i)
		{
			return tokens[i];
		}

		public virtual int LA(int i)
		{
			return LT(i).Type;
		}

		public virtual int Mark()
		{
			if (p == -1)
			{
				FillBuffer();
			}
			lastMarker = Index;
			return lastMarker;
		}

		public virtual void Release(int marker)
		{
		}

		public virtual void Rewind(int marker)
		{
			Seek(marker);
		}

		public virtual void Rewind()
		{
			Seek(lastMarker);
		}

		public virtual void Reset()
		{
			p = 0;
			lastMarker = 0;
		}

		public virtual void Seek(int index)
		{
			p = index;
		}

		public override string ToString()
		{
			if (p == -1)
			{
				throw new InvalidOperationException("Buffer is not yet filled.");
			}
			return ToString(0, tokens.Count - 1);
		}

		public virtual string ToString(int start, int stop)
		{
			if (start < 0 || stop < 0)
			{
				return null;
			}
			if (p == -1)
			{
				throw new InvalidOperationException("Buffer is not yet filled.");
			}
			if (stop >= tokens.Count)
			{
				stop = tokens.Count - 1;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = start; i <= stop; i++)
			{
				IToken token = tokens[i];
				stringBuilder.Append(token.Text);
			}
			return stringBuilder.ToString();
		}

		public virtual string ToString(IToken start, IToken stop)
		{
			if (start != null && stop != null)
			{
				return ToString(start.TokenIndex, stop.TokenIndex);
			}
			return null;
		}
	}
	public abstract class Lexer : BaseRecognizer, ITokenSource
	{
		protected ICharStream input;

		public string Text
		{
			get
			{
				if (state.text != null)
				{
					return state.text;
				}
				return input.Substring(state.tokenStartCharIndex, CharIndex - state.tokenStartCharIndex);
			}
			set
			{
				state.text = value;
			}
		}

		public int Line
		{
			get
			{
				return input.Line;
			}
			set
			{
				input.Line = value;
			}
		}

		public int CharPositionInLine
		{
			get
			{
				return input.CharPositionInLine;
			}
			set
			{
				input.CharPositionInLine = value;
			}
		}

		public virtual ICharStream CharStream
		{
			get
			{
				return input;
			}
			set
			{
				input = null;
				Reset();
				input = value;
			}
		}

		public override string SourceName => input.SourceName;

		public virtual int CharIndex => input.Index;

		public Lexer()
		{
		}

		public Lexer(ICharStream input)
		{
			this.input = input;
		}

		public Lexer(ICharStream input, RecognizerSharedState state)
			: base(state)
		{
			this.input = input;
		}

		public override void Reset()
		{
			base.Reset();
			if (input != null)
			{
				input.Seek(0);
			}
			if (state != null)
			{
				state.token = null;
				state.type = 0;
				state.channel = 0;
				state.tokenStartCharIndex = -1;
				state.tokenStartCharPositionInLine = -1;
				state.tokenStartLine = -1;
				state.text = null;
			}
		}

		public virtual IToken NextToken()
		{
			while (true)
			{
				state.token = null;
				state.channel = 0;
				state.tokenStartCharIndex = input.Index;
				state.tokenStartCharPositionInLine = input.CharPositionInLine;
				state.tokenStartLine = input.Line;
				state.text = null;
				if (input.LA(1) == -1)
				{
					break;
				}
				try
				{
					ParseNextToken();
					if (state.token == null)
					{
						Emit();
						goto IL_00b0;
					}
					if (state.token != Tokens.Skip)
					{
						goto IL_00b0;
					}
					goto end_IL_007d;
					IL_00b0:
					return state.token;
					end_IL_007d:;
				}
				catch (MismatchedRangeException e)
				{
					ReportError(e);
				}
				catch (MismatchedTokenException e2)
				{
					ReportError(e2);
				}
				catch (RecognitionException ex)
				{
					ReportError(ex);
					Recover(ex);
				}
			}
			return GetEndOfFileToken();
		}

		public virtual IToken GetEndOfFileToken()
		{
			return new CommonToken(input, -1, 0, input.Index, input.Index)
			{
				Line = Line,
				CharPositionInLine = CharPositionInLine
			};
		}

		public virtual void Skip()
		{
			state.token = Tokens.Skip;
		}

		public abstract void mTokens();

		public virtual void Emit(IToken token)
		{
			state.token = token;
		}

		public virtual IToken Emit()
		{
			IToken token = new CommonToken(input, state.type, state.channel, state.tokenStartCharIndex, CharIndex - 1);
			token.Line = state.tokenStartLine;
			token.Text = state.text;
			token.CharPositionInLine = state.tokenStartCharPositionInLine;
			Emit(token);
			return token;
		}

		public virtual void Match(string s)
		{
			int num = 0;
			while (num < s.Length)
			{
				if (input.LA(1) != s[num])
				{
					if (state.backtracking > 0)
					{
						state.failed = true;
						break;
					}
					MismatchedTokenException ex = new MismatchedTokenException(s[num], input, TokenNames);
					Recover(ex);
					throw ex;
				}
				num++;
				input.Consume();
				state.failed = false;
			}
		}

		public virtual void MatchAny()
		{
			input.Consume();
		}

		public virtual void Match(int c)
		{
			if (input.LA(1) != c)
			{
				if (state.backtracking <= 0)
				{
					MismatchedTokenException ex = new MismatchedTokenException(c, input, TokenNames);
					Recover(ex);
					throw ex;
				}
				state.failed = true;
			}
			else
			{
				input.Consume();
				state.failed = false;
			}
		}

		public virtual void MatchRange(int a, int b)
		{
			if (input.LA(1) < a || input.LA(1) > b)
			{
				if (state.backtracking <= 0)
				{
					MismatchedRangeException ex = new MismatchedRangeException(a, b, input);
					Recover(ex);
					throw ex;
				}
				state.failed = true;
			}
			else
			{
				input.Consume();
				state.failed = false;
			}
		}

		public override void ReportError(RecognitionException e)
		{
			DisplayRecognitionError(TokenNames, e);
		}

		public override string GetErrorMessage(RecognitionException e, string[] tokenNames)
		{
			string text = null;
			if (e is MismatchedTokenException)
			{
				MismatchedTokenException ex = (MismatchedTokenException)e;
				return "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting " + GetCharErrorDisplay(ex.Expecting);
			}
			if (e is NoViableAltException)
			{
				_ = (NoViableAltException)e;
				return "no viable alternative at character " + GetCharErrorDisplay(e.Character);
			}
			if (e is EarlyExitException)
			{
				_ = (EarlyExitException)e;
				return "required (...)+ loop did not match anything at character " + GetCharErrorDisplay(e.Character);
			}
			if (e is MismatchedNotSetException)
			{
				MismatchedNotSetException ex2 = (MismatchedNotSetException)e;
				return "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + ex2.Expecting;
			}
			if (e is MismatchedSetException)
			{
				MismatchedSetException ex3 = (MismatchedSetException)e;
				return "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + ex3.Expecting;
			}
			if (e is MismatchedRangeException)
			{
				MismatchedRangeException ex4 = (MismatchedRangeException)e;
				return "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + GetCharErrorDisplay(ex4.A) + ".." + GetCharErrorDisplay(ex4.B);
			}
			return base.GetErrorMessage(e, tokenNames);
		}

		public virtual string GetCharErrorDisplay(int c)
		{
			string text = ((char)c).ToString();
			switch (c)
			{
			case -1:
				text = "<EOF>";
				break;
			case 10:
				text = "\\n";
				break;
			case 9:
				text = "\\t";
				break;
			case 13:
				text = "\\r";
				break;
			}
			return "'" + text + "'";
		}

		public virtual void Recover(RecognitionException re)
		{
			input.Consume();
		}

		[Conditional("ANTLR_TRACE")]
		public virtual void TraceIn(string ruleName, int ruleIndex)
		{
			string inputSymbol = ((char)input.LT(1)).ToString() + " line=" + Line + ":" + CharPositionInLine;
			base.TraceIn(ruleName, ruleIndex, inputSymbol);
		}

		[Conditional("ANTLR_TRACE")]
		public virtual void TraceOut(string ruleName, int ruleIndex)
		{
			string inputSymbol = ((char)input.LT(1)).ToString() + " line=" + Line + ":" + CharPositionInLine;
			base.TraceOut(ruleName, ruleIndex, inputSymbol);
		}

		protected virtual void ParseNextToken()
		{
			mTokens();
		}
	}
	[Serializable]
	public class MismatchedNotSetException : MismatchedSetException
	{
		public MismatchedNotSetException()
		{
		}

		public MismatchedNotSetException(string message)
			: base(message)
		{
		}

		public MismatchedNotSetException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public MismatchedNotSetException(BitSet expecting, IIntStream input)
			: base(expecting, input)
		{
		}

		public MismatchedNotSetException(string message, BitSet expecting, IIntStream input)
			: base(message, expecting, input)
		{
		}

		public MismatchedNotSetException(string message, BitSet expecting, IIntStream input, Exception innerException)
			: base(message, expecting, input, innerException)
		{
		}

		protected MismatchedNotSetException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public override string ToString()
		{
			return string.Concat("MismatchedNotSetException(", UnexpectedType, "!=", base.Expecting, ")");
		}
	}
	[Serializable]
	public class MismatchedRangeException : RecognitionException
	{
		private readonly int _a;

		private readonly int _b;

		public int A => _a;

		public int B => _b;

		public MismatchedRangeException()
		{
		}

		public MismatchedRangeException(string message)
			: base(message)
		{
		}

		public MismatchedRangeException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public MismatchedRangeException(int a, int b, IIntStream input)
			: base(input)
		{
			_a = a;
			_b = b;
		}

		public MismatchedRangeException(string message, int a, int b, IIntStream input)
			: base(message, input)
		{
			_a = a;
			_b = b;
		}

		public MismatchedRangeException(string message, int a, int b, IIntStream input, Exception innerException)
			: base(message, input, innerException)
		{
			_a = a;
			_b = b;
		}

		protected MismatchedRangeException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_a = info.GetInt32("A");
			_b = info.GetInt32("B");
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("A", _a);
			info.AddValue("B", _b);
		}

		public override string ToString()
		{
			return "MismatchedRangeException(" + UnexpectedType + " not in [" + A + "," + B + "])";
		}
	}
	[Serializable]
	public class MismatchedSetException : RecognitionException
	{
		private readonly BitSet _expecting;

		public BitSet Expecting => _expecting;

		public MismatchedSetException()
		{
		}

		public MismatchedSetException(string message)
			: base(message)
		{
		}

		public MismatchedSetException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public MismatchedSetException(BitSet expecting, IIntStream input)
			: base(input)
		{
			_expecting = expecting;
		}

		public MismatchedSetException(string message, BitSet expecting, IIntStream input)
			: base(message, input)
		{
			_expecting = expecting;
		}

		public MismatchedSetException(string message, BitSet expecting, IIntStream input, Exception innerException)
			: base(message, input, innerException)
		{
			_expecting = expecting;
		}

		protected MismatchedSetException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_expecting = (BitSet)info.GetValue("Expecting", typeof(BitSet));
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("Expecting", _expecting);
		}

		public override string ToString()
		{
			return string.Concat("MismatchedSetException(", UnexpectedType, "!=", Expecting, ")");
		}
	}
	[Serializable]
	public class MismatchedTokenException : RecognitionException
	{
		private readonly int _expecting;

		private readonly ReadOnlyCollection<string> _tokenNames;

		public int Expecting => _expecting;

		public ReadOnlyCollection<string> TokenNames => _tokenNames;

		public MismatchedTokenException()
		{
		}

		public MismatchedTokenException(string message)
			: base(message)
		{
		}

		public MismatchedTokenException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public MismatchedTokenException(int expecting, IIntStream input)
			: this(expecting, input, null)
		{
		}

		public MismatchedTokenException(int expecting, IIntStream input, IList<string> tokenNames)
			: base(input)
		{
			_expecting = expecting;
			if (tokenNames != null)
			{
				_tokenNames = new ReadOnlyCollection<string>(new List<string>(tokenNames));
			}
		}

		public MismatchedTokenException(string message, int expecting, IIntStream input, IList<string> tokenNames)
			: base(message, input)
		{
			_expecting = expecting;
			if (tokenNames != null)
			{
				_tokenNames = new ReadOnlyCollection<string>(new List<string>(tokenNames));
			}
		}

		public MismatchedTokenException(string message, int expecting, IIntStream input, IList<string> tokenNames, Exception innerException)
			: base(message, input, innerException)
		{
			_expecting = expecting;
			if (tokenNames != null)
			{
				_tokenNames = new ReadOnlyCollection<string>(new List<string>(tokenNames));
			}
		}

		protected MismatchedTokenException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_expecting = info.GetInt32("Expecting");
			_tokenNames = new ReadOnlyCollection<string>((string[])info.GetValue("TokenNames", typeof(string[])));
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("Expecting", _expecting);
			info.AddValue("TokenNames", (_tokenNames != null) ? new List<string>(_tokenNames).ToArray() : null);
		}

		public override string ToString()
		{
			int unexpectedType = UnexpectedType;
			string text = ((TokenNames != null && unexpectedType >= 0 && unexpectedType < TokenNames.Count) ? TokenNames[unexpectedType] : unexpectedType.ToString());
			string text2 = ((TokenNames != null && Expecting >= 0 && Expecting < TokenNames.Count) ? TokenNames[Expecting] : Expecting.ToString());
			return "MismatchedTokenException(" + text + "!=" + text2 + ")";
		}
	}
	[Serializable]
	public class MismatchedTreeNodeException : RecognitionException
	{
		private readonly int _expecting;

		public int Expecting => _expecting;

		public MismatchedTreeNodeException()
		{
		}

		public MismatchedTreeNodeException(string message)
			: base(message)
		{
		}

		public MismatchedTreeNodeException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public MismatchedTreeNodeException(int expecting, ITreeNodeStream input)
			: base(input)
		{
			_expecting = expecting;
		}

		public MismatchedTreeNodeException(string message, int expecting, ITreeNodeStream input)
			: base(message, input)
		{
			_expecting = expecting;
		}

		public MismatchedTreeNodeException(string message, int expecting, ITreeNodeStream input, Exception innerException)
			: base(message, input, innerException)
		{
			_expecting = expecting;
		}

		protected MismatchedTreeNodeException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_expecting = info.GetInt32("Expecting");
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("Expecting", _expecting);
		}

		public override string ToString()
		{
			return "MismatchedTreeNodeException(" + UnexpectedType + "!=" + Expecting + ")";
		}
	}
	[Serializable]
	public class MissingTokenException : MismatchedTokenException
	{
		private readonly object _inserted;

		public virtual int MissingType => base.Expecting;

		public MissingTokenException()
		{
		}

		public MissingTokenException(string message)
			: base(message)
		{
		}

		public MissingTokenException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public MissingTokenException(int expecting, IIntStream input, object inserted)
			: this(expecting, input, inserted, null)
		{
		}

		public MissingTokenException(int expecting, IIntStream input, object inserted, IList<string> tokenNames)
			: base(expecting, input, tokenNames)
		{
			_inserted = inserted;
		}

		public MissingTokenException(string message, int expecting, IIntStream input, object inserted, IList<string> tokenNames)
			: base(message, expecting, input, tokenNames)
		{
			_inserted = inserted;
		}

		public MissingTokenException(string message, int expecting, IIntStream input, object inserted, IList<string> tokenNames, Exception innerException)
			: base(message, expecting, input, tokenNames, innerException)
		{
			_inserted = inserted;
		}

		protected MissingTokenException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public override string ToString()
		{
			if (_inserted != null && base.Token != null)
			{
				return string.Concat("MissingTokenException(inserted ", _inserted, " at ", base.Token.Text, ")");
			}
			if (base.Token != null)
			{
				return "MissingTokenException(at " + base.Token.Text + ")";
			}
			return "MissingTokenException";
		}
	}
	[Serializable]
	public class NoViableAltException : RecognitionException
	{
		private readonly string _grammarDecisionDescription;

		private readonly int _decisionNumber;

		private readonly int _stateNumber;

		public int DecisionNumber => _decisionNumber;

		public string GrammarDecisionDescription => _grammarDecisionDescription;

		public int StateNumber => _stateNumber;

		public NoViableAltException()
		{
		}

		public NoViableAltException(string grammarDecisionDescription)
		{
			_grammarDecisionDescription = grammarDecisionDescription;
		}

		public NoViableAltException(string message, string grammarDecisionDescription)
			: base(message)
		{
			_grammarDecisionDescription = grammarDecisionDescription;
		}

		public NoViableAltException(string message, string grammarDecisionDescription, Exception innerException)
			: base(message, innerException)
		{
			_grammarDecisionDescription = grammarDecisionDescription;
		}

		public NoViableAltException(string grammarDecisionDescription, int decisionNumber, int stateNumber, IIntStream input)
			: this(grammarDecisionDescription, decisionNumber, stateNumber, input, 1)
		{
		}

		public NoViableAltException(string grammarDecisionDescription, int decisionNumber, int stateNumber, IIntStream input, int k)
			: base(input, k)
		{
			_grammarDecisionDescription = grammarDecisionDescription;
			_decisionNumber = decisionNumber;
			_stateNumber = stateNumber;
		}

		public NoViableAltException(string message, string grammarDecisionDescription, int decisionNumber, int stateNumber, IIntStream input)
			: this(message, grammarDecisionDescription, decisionNumber, stateNumber, input, 1)
		{
		}

		public NoViableAltException(string message, string grammarDecisionDescription, int decisionNumber, int stateNumber, IIntStream input, int k)
			: base(message, input, k)
		{
			_grammarDecisionDescription = grammarDecisionDescription;
			_decisionNumber = decisionNumber;
			_stateNumber = stateNumber;
		}

		public NoViableAltException(string message, string grammarDecisionDescription, int decisionNumber, int stateNumber, IIntStream input, Exception innerException)
			: this(message, grammarDecisionDescription, decisionNumber, stateNumber, input, 1, innerException)
		{
		}

		public NoViableAltException(string message, string grammarDecisionDescription, int decisionNumber, int stateNumber, IIntStream input, int k, Exception innerException)
			: base(message, input, k, innerException)
		{
			_grammarDecisionDescription = grammarDecisionDescription;
			_decisionNumber = decisionNumber;
			_stateNumber = stateNumber;
		}

		protected NoViableAltException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_grammarDecisionDescription = info.GetString("GrammarDecisionDescription");
			_decisionNumber = info.GetInt32("DecisionNumber");
			_stateNumber = info.GetInt32("StateNumber");
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("GrammarDecisionDescription", _grammarDecisionDescription);
			info.AddValue("DecisionNumber", _decisionNumber);
			info.AddValue("StateNumber", _stateNumber);
		}

		public override string ToString()
		{
			if (base.Input is ICharStream)
			{
				return "NoViableAltException('" + (char)UnexpectedType + "'@[" + GrammarDecisionDescription + "])";
			}
			return "NoViableAltException(" + UnexpectedType + "@[" + GrammarDecisionDescription + "])";
		}
	}
	public class Parser : BaseRecognizer
	{
		public ITokenStream input;

		public virtual ITokenStream TokenStream
		{
			get
			{
				return input;
			}
			set
			{
				input = null;
				Reset();
				input = value;
			}
		}

		public override string SourceName => input.SourceName;

		public Parser(ITokenStream input)
		{
			TokenStream = input;
		}

		public Parser(ITokenStream input, RecognizerSharedState state)
			: base(state)
		{
			this.input = input;
		}

		public override void Reset()
		{
			base.Reset();
			if (input != null)
			{
				input.Seek(0);
			}
		}

		protected override object GetCurrentInputSymbol(IIntStream input)
		{
			return ((ITokenStream)input).LT(1);
		}

		protected override object GetMissingSymbol(IIntStream input, RecognitionException e, int expectedTokenType, BitSet follow)
		{
			string text = null;
			text = ((expectedTokenType != -1) ? ("<missing " + TokenNames[expectedTokenType] + ">") : "<missing EOF>");
			CommonToken commonToken = new CommonToken(expectedTokenType, text);
			IToken token = ((ITokenStream)input).LT(1);
			if (token.Type == -1)
			{
				token = ((ITokenStream)input).LT(-1);
			}
			commonToken.Line = token.Line;
			commonToken.CharPositionInLine = token.CharPositionInLine;
			commonToken.Channel = 0;
			commonToken.InputStream = token.InputStream;
			return commonToken;
		}

		[Conditional("ANTLR_TRACE")]
		public virtual void TraceIn(string ruleName, int ruleIndex)
		{
			base.TraceIn(ruleName, ruleIndex, input.LT(1));
		}

		[Conditional("ANTLR_TRACE")]
		public virtual void TraceOut(string ruleName, int ruleIndex)
		{
			base.TraceOut(ruleName, ruleIndex, input.LT(1));
		}
	}
	public class ParserRuleReturnScope<TToken> : IRuleReturnScope<TToken>, IRuleReturnScope
	{
		private TToken _start;

		private TToken _stop;

		public TToken Start
		{
			get
			{
				return _start;
			}
			set
			{
				_start = value;
			}
		}

		public TToken Stop
		{
			get
			{
				return _stop;
			}
			set
			{
				_stop = value;
			}
		}

		object IRuleReturnScope.Start => Start;

		object IRuleReturnScope.Stop => Stop;
	}
	[Serializable]
	public class RecognitionException : Exception
	{
		private IIntStream _input;

		private int _k;

		private int _index;

		private IToken _token;

		private object _node;

		private int _c;

		private int _line;

		private int _charPositionInLine;

		private bool _approximateLineInfo;

		public virtual int UnexpectedType
		{
			get
			{
				if (_input is ITokenStream)
				{
					return _token.Type;
				}
				if (_input is ITreeNodeStream treeNodeStream)
				{
					return treeNodeStream.TreeAdaptor.GetType(_node);
				}
				return _c;
			}
		}

		public bool ApproximateLineInfo
		{
			get
			{
				return _approximateLineInfo;
			}
			protected set
			{
				_approximateLineInfo = value;
			}
		}

		public IIntStream Input
		{
			get
			{
				return _input;
			}
			protected set
			{
				_input = value;
			}
		}

		public int Lookahead => _k;

		public IToken Token
		{
			get
			{
				return _token;
			}
			set
			{
				_token = value;
			}
		}

		public object Node
		{
			get
			{
				return _node;
			}
			protected set
			{
				_node = value;
			}
		}

		public int Character
		{
			get
			{
				return _c;
			}
			protected set
			{
				_c = value;
			}
		}

		public int Index
		{
			get
			{
				return _index;
			}
			protected set
			{
				_index = value;
			}
		}

		public int Line
		{
			get
			{
				return _line;
			}
			set
			{
				_line = value;
			}
		}

		public int CharPositionInLine
		{
			get
			{
				return _charPositionInLine;
			}
			set
			{
				_charPositionInLine = value;
			}
		}

		public RecognitionException()
			: this("A recognition error occurred.", null, null)
		{
		}

		public RecognitionException(IIntStream input)
			: this("A recognition error occurred.", input, 1, null)
		{
		}

		public RecognitionException(IIntStream input, int k)
			: this("A recognition error occurred.", input, k, null)
		{
		}

		public RecognitionException(string message)
			: this(message, null, null)
		{
		}

		public RecognitionException(string message, IIntStream input)
			: this(message, input, 1, null)
		{
		}

		public RecognitionException(string message, IIntStream input, int k)
			: this(message, input, k, null)
		{
		}

		public RecognitionException(string message, Exception innerException)
			: this(message, null, innerException)
		{
		}

		public RecognitionException(string message, IIntStream input, Exception innerException)
			: this(message, input, 1, innerException)
		{
		}

		public RecognitionException(string message, IIntStream input, int k, Exception innerException)
			: base(message, innerException)
		{
			_input = input;
			_k = k;
			if (input == null)
			{
				return;
			}
			_index = input.Index + k - 1;
			if (input is ITokenStream)
			{
				_token = ((ITokenStream)input).LT(k);
				_line = _token.Line;
				_charPositionInLine = _token.CharPositionInLine;
			}
			if (input is ITreeNodeStream input2)
			{
				ExtractInformationFromTreeNodeStream(input2, k);
				return;
			}
			if (input is ICharStream)
			{
				int marker = input.Mark();
				try
				{
					for (int i = 0; i < k - 1; i++)
					{
						input.Consume();
					}
					_c = input.LA(1);
					_line = ((ICharStream)input).Line;
					_charPositionInLine = ((ICharStream)input).CharPositionInLine;
					return;
				}
				finally
				{
					input.Rewind(marker);
				}
			}
			_c = input.LA(k);
		}

		protected RecognitionException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_index = info.GetInt32("Index");
			_c = info.GetInt32("C");
			_line = info.GetInt32("Line");
			_charPositionInLine = info.GetInt32("CharPositionInLine");
			_approximateLineInfo = info.GetBoolean("ApproximateLineInfo");
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			info.AddValue("Index", _index);
			info.AddValue("C", _c);
			info.AddValue("Line", _line);
			info.AddValue("CharPositionInLine", _charPositionInLine);
			info.AddValue("ApproximateLineInfo", _approximateLineInfo);
		}

		protected virtual void ExtractInformationFromTreeNodeStream(ITreeNodeStream input)
		{
			_node = input.LT(1);
			object obj = null;
			if (input is IPositionTrackingStream positionTrackingStream)
			{
				obj = positionTrackingStream.GetKnownPositionElement(allowApproximateLocation: false);
				if (obj == null)
				{
					obj = positionTrackingStream.GetKnownPositionElement(allowApproximateLocation: true);
					_approximateLineInfo = obj != null;
				}
			}
			if (input is ITokenStreamInformation tokenStreamInformation)
			{
				IToken lastToken = tokenStreamInformation.LastToken;
				IToken lastRealToken = tokenStreamInformation.LastRealToken;
				if (lastRealToken != null)
				{
					_token = lastRealToken;
					_line = lastRealToken.Line;
					_charPositionInLine = lastRealToken.CharPositionInLine;
					_approximateLineInfo = lastRealToken.Equals(lastToken);
				}
				return;
			}
			ITreeAdaptor treeAdaptor = input.TreeAdaptor;
			IToken token = treeAdaptor.GetToken(obj ?? _node);
			if (token != null)
			{
				_token = token;
				if (token.Line <= 0)
				{
					int num = -1;
					object obj2 = input.LT(num);
					while (obj2 != null)
					{
						IToken token2 = treeAdaptor.GetToken(obj2);
						if (token2 != null && token2.Line > 0)
						{
							_line = token2.Line;
							_charPositionInLine = token2.CharPositionInLine;
							_approximateLineInfo = true;
							break;
						}
						num--;
						try
						{
							obj2 = input.LT(num);
						}
						catch (NotSupportedException)
						{
							obj2 = null;
						}
					}
				}
				else
				{
					_line = token.Line;
					_charPositionInLine = token.CharPositionInLine;
				}
			}
			else if (_node is ITree)
			{
				_line = ((ITree)_node).Line;
				_charPositionInLine = ((ITree)_node).CharPositionInLine;
				if (_node is CommonTree)
				{
					_token = ((CommonTree)_node).Token;
				}
			}
			else
			{
				int type = treeAdaptor.GetType(_node);
				string text = treeAdaptor.GetText(_node);
				_token = new CommonToken(type, text);
			}
		}

		protected virtual void ExtractInformationFromTreeNodeStream(ITreeNodeStream input, int k)
		{
			int marker = input.Mark();
			try
			{
				for (int i = 0; i < k - 1; i++)
				{
					input.Consume();
				}
				ExtractInformationFromTreeNodeStream(input);
			}
			finally
			{
				input.Rewind(marker);
			}
		}
	}
	public class RecognizerSharedState
	{
		public BitSet[] following;

		[CLSCompliant(false)]
		public int _fsp;

		public bool errorRecovery;

		public int lastErrorIndex;

		public bool failed;

		public int syntaxErrors;

		public int backtracking;

		public IDictionary<int, int>[] ruleMemo;

		public IToken token;

		public int tokenStartCharIndex;

		public int tokenStartLine;

		public int tokenStartCharPositionInLine;

		public int channel;

		public int type;

		public string text;

		public RecognizerSharedState()
		{
			following = new BitSet[100];
			_fsp = -1;
			lastErrorIndex = -1;
			tokenStartCharIndex = -1;
		}

		public RecognizerSharedState(RecognizerSharedState state)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			following = (BitSet[])state.following.Clone();
			_fsp = state._fsp;
			errorRecovery = state.errorRecovery;
			lastErrorIndex = state.lastErrorIndex;
			failed = state.failed;
			syntaxErrors = state.syntaxErrors;
			backtracking = state.backtracking;
			if (state.ruleMemo != null)
			{
				ruleMemo = (IDictionary<int, int>[])state.ruleMemo.Clone();
			}
			token = state.token;
			tokenStartCharIndex = state.tokenStartCharIndex;
			tokenStartCharPositionInLine = state.tokenStartCharPositionInLine;
			channel = state.channel;
			type = state.type;
			text = state.text;
		}
	}
	public class TemplateParserRuleReturnScope<TTemplate, TToken> : ParserRuleReturnScope<TToken>, ITemplateRuleReturnScope<TTemplate>, ITemplateRuleReturnScope
	{
		private TTemplate _template;

		public TTemplate Template
		{
			get
			{
				return _template;
			}
			set
			{
				_template = value;
			}
		}

		object ITemplateRuleReturnScope.Template => Template;
	}
	public static class TokenChannels
	{
		public const int Default = 0;

		public const int Hidden = 99;
	}
	[Serializable]
	[DebuggerDisplay("TODO: TokenRewriteStream debugger display")]
	public class TokenRewriteStream : CommonTokenStream
	{
		protected class RewriteOperation
		{
			public int instructionIndex;

			public int index;

			public object text;

			protected TokenRewriteStream stream;

			protected RewriteOperation(TokenRewriteStream stream, int index)
			{
				this.stream = stream;
				this.index = index;
			}

			protected RewriteOperation(TokenRewriteStream stream, int index, object text)
			{
				this.index = index;
				this.text = text;
				this.stream = stream;
			}

			public virtual int Execute(StringBuilder buf)
			{
				return index;
			}

			public override string ToString()
			{
				string name = GetType().Name;
				int num = name.IndexOf('$');
				name = name.Substring(num + 1);
				return $"<{name}@{stream._tokens[index]}:\"{text}\">";
			}
		}

		private class InsertBeforeOp : RewriteOperation
		{
			public InsertBeforeOp(TokenRewriteStream stream, int index, object text)
				: base(stream, index, text)
			{
			}

			public override int Execute(StringBuilder buf)
			{
				buf.Append(text);
				if (stream._tokens[index].Type != -1)
				{
					buf.Append(stream._tokens[index].Text);
				}
				return index + 1;
			}
		}

		private class ReplaceOp : RewriteOperation
		{
			public int lastIndex;

			public ReplaceOp(TokenRewriteStream stream, int from, int to, object text)
				: base(stream, from, text)
			{
				lastIndex = to;
			}

			public override int Execute(StringBuilder buf)
			{
				if (text != null)
				{
					buf.Append(text);
				}
				return lastIndex + 1;
			}

			public override string ToString()
			{
				if (text == null)
				{
					return $"<DeleteOp@{stream._tokens[index]}..{stream._tokens[lastIndex]}>";
				}
				return $"<ReplaceOp@{stream._tokens[index]}..{stream._tokens[lastIndex]}:\"{text}\">";
			}
		}

		public const string DEFAULT_PROGRAM_NAME = "default";

		public const int PROGRAM_INIT_SIZE = 100;

		public const int MIN_TOKEN_INDEX = 0;

		protected IDictionary<string, IList<RewriteOperation>> programs;

		protected IDictionary<string, int> lastRewriteTokenIndexes;

		public TokenRewriteStream()
		{
			Init();
		}

		protected void Init()
		{
			programs = new Dictionary<string, IList<RewriteOperation>>();
			programs["default"] = new List<RewriteOperation>(100);
			lastRewriteTokenIndexes = new Dictionary<string, int>();
		}

		public TokenRewriteStream(ITokenSource tokenSource)
			: base(tokenSource)
		{
			Init();
		}

		public TokenRewriteStream(ITokenSource tokenSource, int channel)
			: base(tokenSource, channel)
		{
			Init();
		}

		public virtual void Rollback(int instructionIndex)
		{
			Rollback("default", instructionIndex);
		}

		public virtual void Rollback(string programName, int instructionIndex)
		{
			if (programs.TryGetValue(programName, out var value) && value != null)
			{
				List<RewriteOperation> list = new List<RewriteOperation>();
				for (int i = 0; i <= instructionIndex; i++)
				{
					list.Add(value[i]);
				}
				programs[programName] = list;
			}
		}

		public virtual void DeleteProgram()
		{
			DeleteProgram("default");
		}

		public virtual void DeleteProgram(string programName)
		{
			Rollback(programName, 0);
		}

		public virtual void InsertAfter(IToken t, object text)
		{
			InsertAfter("default", t, text);
		}

		public virtual void InsertAfter(int index, object text)
		{
			InsertAfter("default", index, text);
		}

		public virtual void InsertAfter(string programName, IToken t, object text)
		{
			InsertAfter(programName, t.TokenIndex, text);
		}

		public virtual void InsertAfter(string programName, int index, object text)
		{
			InsertBefore(programName, index + 1, text);
		}

		public virtual void InsertBefore(IToken t, object text)
		{
			InsertBefore("default", t, text);
		}

		public virtual void InsertBefore(int index, object text)
		{
			InsertBefore("default", index, text);
		}

		public virtual void InsertBefore(string programName, IToken t, object text)
		{
			InsertBefore(programName, t.TokenIndex, text);
		}

		public virtual void InsertBefore(string programName, int index, object text)
		{
			RewriteOperation rewriteOperation = new InsertBeforeOp(this, index, text);
			IList<RewriteOperation> program = GetProgram(programName);
			rewriteOperation.instructionIndex = program.Count;
			program.Add(rewriteOperation);
		}

		public virtual void Replace(int index, object text)
		{
			Replace("default", index, index, text);
		}

		public virtual void Replace(int from, int to, object text)
		{
			Replace("default", from, to, text);
		}

		public virtual void Replace(IToken indexT, object text)
		{
			Replace("default", indexT, indexT, text);
		}

		public virtual void Replace(IToken from, IToken to, object text)
		{
			Replace("default", from, to, text);
		}

		public virtual void Replace(string programName, int from, int to, object text)
		{
			if (from > to || from < 0 || to < 0 || to >= _tokens.Count)
			{
				throw new ArgumentException("replace: range invalid: " + from + ".." + to + "(size=" + _tokens.Count + ")");
			}
			RewriteOperation rewriteOperation = new ReplaceOp(this, from, to, text);
			IList<RewriteOperation> program = GetProgram(programName);
			rewriteOperation.instructionIndex = program.Count;
			program.Add(rewriteOperation);
		}

		public virtual void Replace(string programName, IToken from, IToken to, object text)
		{
			Replace(programName, from.TokenIndex, to.TokenIndex, text);
		}

		public virtual void Delete(int index)
		{
			Delete("default", index, index);
		}

		public virtual void Delete(int from, int to)
		{
			Delete("default", from, to);
		}

		public virtual void Delete(IToken indexT)
		{
			Delete("default", indexT, indexT);
		}

		public virtual void Delete(IToken from, IToken to)
		{
			Delete("default", from, to);
		}

		public virtual void Delete(string programName, int from, int to)
		{
			Replace(programName, from, to, null);
		}

		public virtual void Delete(string programName, IToken from, IToken to)
		{
			Replace(programName, from, to, null);
		}

		public virtual int GetLastRewriteTokenIndex()
		{
			return GetLastRewriteTokenIndex("default");
		}

		protected virtual int GetLastRewriteTokenIndex(string programName)
		{
			if (lastRewriteTokenIndexes.TryGetValue(programName, out var value))
			{
				return value;
			}
			return -1;
		}

		protected virtual void SetLastRewriteTokenIndex(string programName, int i)
		{
			lastRewriteTokenIndexes[programName] = i;
		}

		protected virtual IList<RewriteOperation> GetProgram(string name)
		{
			if (!programs.TryGetValue(name, out var value) || value == null)
			{
				return InitializeProgram(name);
			}
			return value;
		}

		private IList<RewriteOperation> InitializeProgram(string name)
		{
			IList<RewriteOperation> list = new List<RewriteOperation>(100);
			programs[name] = list;
			return list;
		}

		public virtual string ToOriginalString()
		{
			Fill();
			return ToOriginalString(0, Count - 1);
		}

		public virtual string ToOriginalString(int start, int end)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = start; i >= 0 && i <= end && i < _tokens.Count; i++)
			{
				if (Get(i).Type != -1)
				{
					stringBuilder.Append(Get(i).Text);
				}
			}
			return stringBuilder.ToString();
		}

		public override string ToString()
		{
			Fill();
			return ToString(0, Count - 1);
		}

		public virtual string ToString(string programName)
		{
			Fill();
			return ToString(programName, 0, Count - 1);
		}

		public override string ToString(int start, int end)
		{
			return ToString("default", start, end);
		}

		public virtual string ToString(string programName, int start, int end)
		{
			if (!programs.TryGetValue(programName, out var value))
			{
				value = null;
			}
			if (end > _tokens.Count - 1)
			{
				end = _tokens.Count - 1;
			}
			if (start < 0)
			{
				start = 0;
			}
			if (value == null || value.Count == 0)
			{
				return ToOriginalString(start, end);
			}
			StringBuilder stringBuilder = new StringBuilder();
			IDictionary<int, RewriteOperation> dictionary = ReduceToSingleOperationPerIndex(value);
			int num = start;
			while (num <= end && num < _tokens.Count)
			{
				RewriteOperation value2;
				bool num2 = dictionary.TryGetValue(num, out value2);
				if (num2)
				{
					dictionary.Remove(num);
				}
				if (!num2 || value2 == null)
				{
					IToken token = _tokens[num];
					if (token.Type != -1)
					{
						stringBuilder.Append(token.Text);
					}
					num++;
				}
				else
				{
					num = value2.Execute(stringBuilder);
				}
			}
			if (end == _tokens.Count - 1)
			{
				foreach (RewriteOperation value3 in dictionary.Values)
				{
					if (value3.index >= _tokens.Count - 1)
					{
						stringBuilder.Append(value3.text);
					}
				}
			}
			return stringBuilder.ToString();
		}

		protected virtual IDictionary<int, RewriteOperation> ReduceToSingleOperationPerIndex(IList<RewriteOperation> rewrites)
		{
			for (int i = 0; i < rewrites.Count; i++)
			{
				RewriteOperation rewriteOperation = rewrites[i];
				if (rewriteOperation == null || !(rewriteOperation is ReplaceOp))
				{
					continue;
				}
				ReplaceOp replaceOp = (ReplaceOp)rewrites[i];
				IList<RewriteOperation> kindOfOps = GetKindOfOps(rewrites, typeof(InsertBeforeOp), i);
				for (int j = 0; j < kindOfOps.Count; j++)
				{
					InsertBeforeOp insertBeforeOp = (InsertBeforeOp)kindOfOps[j];
					if (insertBeforeOp.index == replaceOp.index)
					{
						rewrites[insertBeforeOp.instructionIndex] = null;
						replaceOp.text = insertBeforeOp.text.ToString() + ((replaceOp.text != null) ? replaceOp.text.ToString() : string.Empty);
					}
					else if (insertBeforeOp.index > replaceOp.index && insertBeforeOp.index <= replaceOp.lastIndex)
					{
						rewrites[insertBeforeOp.instructionIndex] = null;
					}
				}
				IList<RewriteOperation> kindOfOps2 = GetKindOfOps(rewrites, typeof(ReplaceOp), i);
				for (int k = 0; k < kindOfOps2.Count; k++)
				{
					ReplaceOp replaceOp2 = (ReplaceOp)kindOfOps2[k];
					if (replaceOp2.index >= replaceOp.index && replaceOp2.lastIndex <= replaceOp.lastIndex)
					{
						rewrites[replaceOp2.instructionIndex] = null;
						continue;
					}
					bool flag = replaceOp2.lastIndex < replaceOp.index || replaceOp2.index > replaceOp.lastIndex;
					bool flag2 = replaceOp2.index == replaceOp.index && replaceOp2.lastIndex == replaceOp.lastIndex;
					if (replaceOp2.text == null && replaceOp.text == null && !flag)
					{
						rewrites[replaceOp2.instructionIndex] = null;
						replaceOp.index = Math.Min(replaceOp2.index, replaceOp.index);
						replaceOp.lastIndex = Math.Max(replaceOp2.lastIndex, replaceOp.lastIndex);
						Console.WriteLine("new rop " + replaceOp);
					}
					else if (!flag && !flag2)
					{
						throw new ArgumentException(string.Concat("replace op boundaries of ", replaceOp, " overlap with previous ", replaceOp2));
					}
				}
			}
			for (int l = 0; l < rewrites.Count; l++)
			{
				RewriteOperation rewriteOperation2 = rewrites[l];
				if (rewriteOperation2 == null || !(rewriteOperation2 is InsertBeforeOp))
				{
					continue;
				}
				InsertBeforeOp insertBeforeOp2 = (InsertBeforeOp)rewrites[l];
				IList<RewriteOperation> kindOfOps3 = GetKindOfOps(rewrites, typeof(InsertBeforeOp), l);
				for (int m = 0; m < kindOfOps3.Count; m++)
				{
					InsertBeforeOp insertBeforeOp3 = (InsertBeforeOp)kindOfOps3[m];
					if (insertBeforeOp3.index == insertBeforeOp2.index)
					{
						insertBeforeOp2.text = CatOpText(insertBeforeOp2.text, insertBeforeOp3.text);
						rewrites[insertBeforeOp3.instructionIndex] = null;
					}
				}
				IList<RewriteOperation> kindOfOps4 = GetKindOfOps(rewrites, typeof(ReplaceOp), l);
				for (int n = 0; n < kindOfOps4.Count; n++)
				{
					ReplaceOp replaceOp3 = (ReplaceOp)kindOfOps4[n];
					if (insertBeforeOp2.index == replaceOp3.index)
					{
						replaceOp3.text = CatOpText(insertBeforeOp2.text, replaceOp3.text);
						rewrites[l] = null;
					}
					else if (insertBeforeOp2.index >= replaceOp3.index && insertBeforeOp2.index <= replaceOp3.lastIndex)
					{
						throw new ArgumentException(string.Concat("insert op ", insertBeforeOp2, " within boundaries of previous ", replaceOp3));
					}
				}
			}
			IDictionary<int, RewriteOperation> dictionary = new Dictionary<int, RewriteOperation>();
			for (int num = 0; num < rewrites.Count; num++)
			{
				RewriteOperation rewriteOperation3 = rewrites[num];
				if (rewriteOperation3 != null)
				{
					if (dictionary.TryGetValue(rewriteOperation3.index, out var value) && value != null)
					{
						throw new Exception("should only be one op per index");
					}
					dictionary[rewriteOperation3.index] = rewriteOperation3;
				}
			}
			return dictionary;
		}

		protected virtual string CatOpText(object a, object b)
		{
			return string.Concat(a, b);
		}

		protected virtual IList<RewriteOperation> GetKindOfOps(IList<RewriteOperation> rewrites, Type kind)
		{
			return GetKindOfOps(rewrites, kind, rewrites.Count);
		}

		protected virtual IList<RewriteOperation> GetKindOfOps(IList<RewriteOperation> rewrites, Type kind, int before)
		{
			IList<RewriteOperation> list = new List<RewriteOperation>();
			for (int i = 0; i < before && i < rewrites.Count; i++)
			{
				RewriteOperation rewriteOperation = rewrites[i];
				if (rewriteOperation != null && (object)rewriteOperation.GetType() == kind)
				{
					list.Add(rewriteOperation);
				}
			}
			return list;
		}

		public virtual string ToDebugString()
		{
			return ToDebugString(0, Count - 1);
		}

		public virtual string ToDebugString(int start, int end)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = start; i >= 0 && i <= end && i < _tokens.Count; i++)
			{
				stringBuilder.Append(Get(i));
			}
			return stringBuilder.ToString();
		}
	}
	public static class Tokens
	{
		public static readonly IToken Skip = new CommonToken(0);
	}
	public static class TokenTypes
	{
		public const int EndOfFile = -1;

		public const int Invalid = 0;

		public const int EndOfRule = 1;

		public const int Down = 2;

		public const int Up = 3;

		public const int Min = 4;
	}
	public class UnbufferedTokenStream : LookaheadStream<IToken>, ITokenStream, IIntStream, ITokenStreamInformation
	{
		[CLSCompliant(false)]
		protected ITokenSource tokenSource;

		protected int tokenIndex;

		protected int channel;

		private readonly ListStack<IToken> _realTokens = new ListStack<IToken> { null };

		public ITokenSource TokenSource => tokenSource;

		public string SourceName => TokenSource.SourceName;

		public IToken LastToken => LB(1);

		public IToken LastRealToken => _realTokens.Peek();

		public int MaxLookBehind => 1;

		public UnbufferedTokenStream(ITokenSource tokenSource)
		{
			this.tokenSource = tokenSource;
		}

		public override int Mark()
		{
			_realTokens.Push(_realTokens.Peek());
			return base.Mark();
		}

		public override void Release(int marker)
		{
			base.Release(marker);
			_realTokens.Pop();
		}

		public override void Clear()
		{
			_realTokens.Clear();
			_realTokens.Push(null);
		}

		public override void Consume()
		{
			base.Consume();
			if (base.PreviousElement != null && base.PreviousElement.Line > 0)
			{
				_realTokens[_realTokens.Count - 1] = base.PreviousElement;
			}
		}

		public override IToken NextElement()
		{
			IToken token = tokenSource.NextToken();
			token.TokenIndex = tokenIndex++;
			return token;
		}

		public override bool IsEndOfFile(IToken o)
		{
			return o.Type == -1;
		}

		public IToken Get(int i)
		{
			throw new NotSupportedException("Absolute token indexes are meaningless in an unbuffered stream");
		}

		public int LA(int i)
		{
			return LT(i).Type;
		}

		public string ToString(int start, int stop)
		{
			return "n/a";
		}

		public string ToString(IToken start, IToken stop)
		{
			return "n/a";
		}
	}
	[Serializable]
	public class UnwantedTokenException : MismatchedTokenException
	{
		public virtual IToken UnexpectedToken => base.Token;

		public UnwantedTokenException()
		{
		}

		public UnwantedTokenException(string message)
			: base(message)
		{
		}

		public UnwantedTokenException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public UnwantedTokenException(int expecting, IIntStream input)
			: base(expecting, input)
		{
		}

		public UnwantedTokenException(int expecting, IIntStream input, IList<string> tokenNames)
			: base(expecting, input, tokenNames)
		{
		}

		public UnwantedTokenException(string message, int expecting, IIntStream input, IList<string> tokenNames)
			: base(message, expecting, input, tokenNames)
		{
		}

		public UnwantedTokenException(string message, int expecting, IIntStream input, IList<string> tokenNames, Exception innerException)
			: base(message, expecting, input, tokenNames, innerE