using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using Antlr.Runtime;
using Antlr.Runtime.Debug;
using Antlr.Runtime.Misc;
using Antlr.Runtime.Tree;
using Antlr3.Runtime.PCL.Output;
using NCalc.Domain;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Antlr3.Runtime.PCL")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: NeutralResourcesLanguage("")]
[assembly: AssemblyFileVersion("3.5.0.2")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyInformationalVersion("2.2.0")]
[assembly: AssemblyVersion("3.5.0.2")]
[CLSCompliant(false)]
public class NCalcLexer : Lexer
{
	private class DFA7 : DFA
	{
		private const string DFA7_eotS = "\u0004\uffff";

		private const string DFA7_eofS = "\u0004\uffff";

		private const string DFA7_minS = "\u0002.\u0002\uffff";

		private const string DFA7_maxS = "\u00019\u0001e\u0002\uffff";

		private const string DFA7_acceptS = "\u0002\uffff\u0001\u0001\u0001\u0002";

		private const string DFA7_specialS = "\u0004\uffff}>";

		private static readonly string[] DFA7_transitionS;

		private static readonly short[] DFA7_eot;

		private static readonly short[] DFA7_eof;

		private static readonly char[] DFA7_min;

		private static readonly char[] DFA7_max;

		private static readonly short[] DFA7_accept;

		private static readonly short[] DFA7_special;

		private static readonly short[][] DFA7_transition;

		public override string Description => "252:1: FLOAT : ( ( DIGIT )* '.' ( DIGIT )+ ( E )? | ( DIGIT )+ E );";

		static DFA7()
		{
			DFA7_transitionS = new string[4] { "\u0001\u0002\u0001\uffff\n\u0001", "\u0001\u0002\u0001\uffff\n\u0001\v\uffff\u0001\u0003\u001f\uffff\u0001\u0003", "", "" };
			DFA7_eot = DFA.UnpackEncodedString("\u0004\uffff");
			DFA7_eof = DFA.UnpackEncodedString("\u0004\uffff");
			DFA7_min = DFA.UnpackEncodedStringToUnsignedChars("\u0002.\u0002\uffff");
			DFA7_max = DFA.UnpackEncodedStringToUnsignedChars("\u00019\u0001e\u0002\uffff");
			DFA7_accept = DFA.UnpackEncodedString("\u0002\uffff\u0001\u0001\u0001\u0002");
			DFA7_special = DFA.UnpackEncodedString("\u0004\uffff}>");
			int num = DFA7_transitionS.Length;
			DFA7_transition = new short[num][];
			for (int i = 0; i < num; i++)
			{
				DFA7_transition[i] = DFA.UnpackEncodedString(DFA7_transitionS[i]);
			}
		}

		public DFA7(BaseRecognizer recognizer)
		{
			base.recognizer = recognizer;
			decisionNumber = 7;
			eot = DFA7_eot;
			eof = DFA7_eof;
			min = DFA7_min;
			max = DFA7_max;
			accept = DFA7_accept;
			special = DFA7_special;
			transition = DFA7_transition;
		}

		public override void Error(NoViableAltException nvae)
		{
		}
	}

	private class DFA14 : DFA
	{
		private const string DFA14_eotS = "\u0001\uffff\u0001!\u0001\uffff\u0001#\b\uffff\u0001'\u0001)\u0001,\u0002\uffff\u0003\u001e\u00011\u0001\uffff\u0003\u001e\u00016\u0013\uffff\u0002\u001e\u00019\u0002\uffff\u0003\u001e\u0002\uffff\u0001<\u0001=\u0001\uffff\u0002\u001e\u0002\uffff\u0001@\u0001\u001e\u0001\uffff\u0001B\u0001\uffff";

		private const string DFA14_eofS = "C\uffff";

		private const string DFA14_minS = "\u0001\t\u0001=\u0001\uffff\u0001&\b\uffff\u0001<\u0002=\u0002\uffff\u0001n\u0001o\u0001r\u0001|\u0001\uffff\u0001r\u0001a\u0001+\u0001.\u0013\uffff\u0001d\u0001t\u00010\u0002\uffff\u0001u\u0001l\u00010\u0002\uffff\u00020\u0001\uffff\u0001e\u0001s\u0002\uffff\u00010\u0001e\u0001\uffff\u00010\u0001\uffff";

		private const string DFA14_maxS = "\u0001~\u0001=\u0001\uffff\u0001&\b\uffff\u0001>\u0001=\u0001>\u0002\uffff\u0001n\u0001o\u0001r\u0001|\u0001\uffff\u0001r\u0001a\u00019\u0001e\u0013\uffff\u0001d\u0001t\u0001z\u0002\uffff\u0001u\u0001l\u00019\u0002\uffff\u0002z\u0001\uffff\u0001e\u0001s\u0002\uffff\u0001z\u0001e\u0001\uffff\u0001z\u0001\uffff";

		private const string DFA14_acceptS = "\u0002\uffff\u0001\u0003\u0001\uffff\u0001\u0006\u0001\a\u0001\b\u0001\t\u0001\n\u0001\v\u0001\f\u0001\r\u0003\uffff\u0001\u0017\u0001\u0018\u0004\uffff\u0001\u001e\u0004\uffff\u0001#\u0001$\u0001%\u0001&\u0001!\u0001(\u0001\u0002\u0001\u0001\u0001\u0004\u0001\u0005\u0001\u000f\u0001\u0010\u0001\u0011\u0001\u000e\u0001\u0013\u0001\u0012\u0001\u0015\u0001\u0016\u0001\u0014\u0003\uffff\u0001\u001d\u0001\u001c\u0003\uffff\u0001'\u0001\"\u0002\uffff\u0001\u001b\u0002\uffff\u0001\u0019\u0001\u001a\u0002\uffff\u0001\u001f\u0001\uffff\u0001 ";

		private const string DFA14_specialS = "C\uffff}>";

		private static readonly string[] DFA14_transitionS;

		private static readonly short[] DFA14_eot;

		private static readonly short[] DFA14_eof;

		private static readonly char[] DFA14_min;

		private static readonly char[] DFA14_max;

		private static readonly short[] DFA14_accept;

		private static readonly short[] DFA14_special;

		private static readonly short[][] DFA14_transition;

		public override string Description => "1:1: Tokens : ( T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | TRUE | FALSE | ID | INTEGER | FLOAT | STRING | DATETIME | NAME | E | WS );";

		static DFA14()
		{
			DFA14_transitionS = new string[67]
			{
				"\u0002\u001f\u0001\uffff\u0002\u001f\u0012\uffff\u0001\u001f\u0001\u0001\u0001\uffff\u0001\u001c\u0001\uffff\u0001\u0002\u0001\u0003\u0001\u001b\u0001\u0004\u0001\u0005\u0001\u0006\u0001\a\u0001\b\u0001\t\u0001\u001a\u0001\n\n\u0019\u0001\v\u0001\uffff\u0001\f\u0001\r\u0001\u000e\u0001\u000f\u0001\uffff\u0004\u001e\u0001\u0018\u0015\u001e\u0001\u001d\u0002\uffff\u0001\u0010\u0001\u001e\u0001\uffff\u0001\u0011\u0003\u001e\u0001\u0018\u0001\u0017\a\u001e\u0001\u0012\u0001\u0013\u0004\u001e\u0001\u0016\u0006\u001e\u0001\uffff\u0001\u0014\u0001\uffff\u0001\u0015", "\u0001 ", "", "\u0001\"", "", "", "", "", "", "",
				"", "", "\u0001$\u0001%\u0001&", "\u0001(", "\u0001*\u0001+", "", "", "\u0001-", "\u0001.", "\u0001/",
				"\u00010", "", "\u00012", "\u00013", "\u00015\u0001\uffff\u00015\u0002\uffff\n4", "\u0001\u001a\u0001\uffff\n\u0019\v\uffff\u0001\u001a\u001f\uffff\u0001\u001a", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "\u00017", "\u00018", "\n\u001e\a\uffff\u001a\u001e\u0004\uffff\u0001\u001e\u0001\uffff\u001a\u001e", "", "",
				"\u0001:", "\u0001;", "\n4", "", "", "\n\u001e\a\uffff\u001a\u001e\u0004\uffff\u0001\u001e\u0001\uffff\u001a\u001e", "\n\u001e\a\uffff\u001a\u001e\u0004\uffff\u0001\u001e\u0001\uffff\u001a\u001e", "", "\u0001>", "\u0001?",
				"", "", "\n\u001e\a\uffff\u001a\u001e\u0004\uffff\u0001\u001e\u0001\uffff\u001a\u001e", "\u0001A", "", "\n\u001e\a\uffff\u001a\u001e\u0004\uffff\u0001\u001e\u0001\uffff\u001a\u001e", ""
			};
			DFA14_eot = DFA.UnpackEncodedString("\u0001\uffff\u0001!\u0001\uffff\u0001#\b\uffff\u0001'\u0001)\u0001,\u0002\uffff\u0003\u001e\u00011\u0001\uffff\u0003\u001e\u00016\u0013\uffff\u0002\u001e\u00019\u0002\uffff\u0003\u001e\u0002\uffff\u0001<\u0001=\u0001\uffff\u0002\u001e\u0002\uffff\u0001@\u0001\u001e\u0001\uffff\u0001B\u0001\uffff");
			DFA14_eof = DFA.UnpackEncodedString("C\uffff");
			DFA14_min = DFA.UnpackEncodedStringToUnsignedChars("\u0001\t\u0001=\u0001\uffff\u0001&\b\uffff\u0001<\u0002=\u0002\uffff\u0001n\u0001o\u0001r\u0001|\u0001\uffff\u0001r\u0001a\u0001+\u0001.\u0013\uffff\u0001d\u0001t\u00010\u0002\uffff\u0001u\u0001l\u00010\u0002\uffff\u00020\u0001\uffff\u0001e\u0001s\u0002\uffff\u00010\u0001e\u0001\uffff\u00010\u0001\uffff");
			DFA14_max = DFA.UnpackEncodedStringToUnsignedChars("\u0001~\u0001=\u0001\uffff\u0001&\b\uffff\u0001>\u0001=\u0001>\u0002\uffff\u0001n\u0001o\u0001r\u0001|\u0001\uffff\u0001r\u0001a\u00019\u0001e\u0013\uffff\u0001d\u0001t\u0001z\u0002\uffff\u0001u\u0001l\u00019\u0002\uffff\u0002z\u0001\uffff\u0001e\u0001s\u0002\uffff\u0001z\u0001e\u0001\uffff\u0001z\u0001\uffff");
			DFA14_accept = DFA.UnpackEncodedString("\u0002\uffff\u0001\u0003\u0001\uffff\u0001\u0006\u0001\a\u0001\b\u0001\t\u0001\n\u0001\v\u0001\f\u0001\r\u0003\uffff\u0001\u0017\u0001\u0018\u0004\uffff\u0001\u001e\u0004\uffff\u0001#\u0001$\u0001%\u0001&\u0001!\u0001(\u0001\u0002\u0001\u0001\u0001\u0004\u0001\u0005\u0001\u000f\u0001\u0010\u0001\u0011\u0001\u000e\u0001\u0013\u0001\u0012\u0001\u0015\u0001\u0016\u0001\u0014\u0003\uffff\u0001\u001d\u0001\u001c\u0003\uffff\u0001'\u0001\"\u0002\uffff\u0001\u001b\u0002\uffff\u0001\u0019\u0001\u001a\u0002\uffff\u0001\u001f\u0001\uffff\u0001 ");
			DFA14_special = DFA.UnpackEncodedString("C\uffff}>");
			int num = DFA14_transitionS.Length;
			DFA14_transition = new short[num][];
			for (int i = 0; i < num; i++)
			{
				DFA14_transition[i] = DFA.UnpackEncodedString(DFA14_transitionS[i]);
			}
		}

		public DFA14(BaseRecognizer recognizer)
		{
			base.recognizer = recognizer;
			decisionNumber = 14;
			eot = DFA14_eot;
			eof = DFA14_eof;
			min = DFA14_min;
			max = DFA14_max;
			accept = DFA14_accept;
			special = DFA14_special;
			transition = DFA14_transition;
		}

		public override void Error(NoViableAltException nvae)
		{
		}
	}

	public const int EOF = -1;

	public const int DATETIME = 4;

	public const int DIGIT = 5;

	public const int E = 6;

	public const int EscapeSequence = 7;

	public const int FALSE = 8;

	public const int FLOAT = 9;

	public const int HexDigit = 10;

	public const int ID = 11;

	public const int INTEGER = 12;

	public const int LETTER = 13;

	public const int NAME = 14;

	public const int STRING = 15;

	public const int TRUE = 16;

	public const int UnicodeEscape = 17;

	public const int WS = 18;

	public const int T__19 = 19;

	public const int T__20 = 20;

	public const int T__21 = 21;

	public const int T__22 = 22;

	public const int T__23 = 23;

	public const int T__24 = 24;

	public const int T__25 = 25;

	public const int T__26 = 26;

	public const int T__27 = 27;

	public const int T__28 = 28;

	public const int T__29 = 29;

	public const int T__30 = 30;

	public const int T__31 = 31;

	public const int T__32 = 32;

	public const int T__33 = 33;

	public const int T__34 = 34;

	public const int T__35 = 35;

	public const int T__36 = 36;

	public const int T__37 = 37;

	public const int T__38 = 38;

	public const int T__39 = 39;

	public const int T__40 = 40;

	public const int T__41 = 41;

	public const int T__42 = 42;

	public const int T__43 = 43;

	public const int T__44 = 44;

	public const int T__45 = 45;

	public const int T__46 = 46;

	public const int T__47 = 47;

	public const int T__48 = 48;

	private static readonly bool[] decisionCanBacktrack = new bool[0];

	private DFA7 dfa7;

	private DFA14 dfa14;

	public override string GrammarFileName => "C:\\Users\\sebros\\My Projects\\NCalc\\Grammar\\NCalc.g";

	public NCalcLexer()
	{
	}

	public NCalcLexer(ICharStream input)
		: this(input, new RecognizerSharedState())
	{
	}

	public NCalcLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state)
	{
	}

	[GrammarRule("T__19")]
	private void mT__19()
	{
		try
		{
			int type = 19;
			int channel = 0;
			Match(33);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__20")]
	private void mT__20()
	{
		try
		{
			int type = 20;
			int channel = 0;
			Match("!=");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__21")]
	private void mT__21()
	{
		try
		{
			int type = 21;
			int channel = 0;
			Match(37);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__22")]
	private void mT__22()
	{
		try
		{
			int type = 22;
			int channel = 0;
			Match("&&");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__23")]
	private void mT__23()
	{
		try
		{
			int type = 23;
			int channel = 0;
			Match(38);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__24")]
	private void mT__24()
	{
		try
		{
			int type = 24;
			int channel = 0;
			Match(40);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__25")]
	private void mT__25()
	{
		try
		{
			int type = 25;
			int channel = 0;
			Match(41);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__26")]
	private void mT__26()
	{
		try
		{
			int type = 26;
			int channel = 0;
			Match(42);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__27")]
	private void mT__27()
	{
		try
		{
			int type = 27;
			int channel = 0;
			Match(43);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__28")]
	private void mT__28()
	{
		try
		{
			int type = 28;
			int channel = 0;
			Match(44);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__29")]
	private void mT__29()
	{
		try
		{
			int type = 29;
			int channel = 0;
			Match(45);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__30")]
	private void mT__30()
	{
		try
		{
			int type = 30;
			int channel = 0;
			Match(47);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__31")]
	private void mT__31()
	{
		try
		{
			int type = 31;
			int channel = 0;
			Match(58);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__32")]
	private void mT__32()
	{
		try
		{
			int type = 32;
			int channel = 0;
			Match(60);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__33")]
	private void mT__33()
	{
		try
		{
			int type = 33;
			int channel = 0;
			Match("<<");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__34")]
	private void mT__34()
	{
		try
		{
			int type = 34;
			int channel = 0;
			Match("<=");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__35")]
	private void mT__35()
	{
		try
		{
			int type = 35;
			int channel = 0;
			Match("<>");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__36")]
	private void mT__36()
	{
		try
		{
			int type = 36;
			int channel = 0;
			Match(61);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__37")]
	private void mT__37()
	{
		try
		{
			int type = 37;
			int channel = 0;
			Match("==");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__38")]
	private void mT__38()
	{
		try
		{
			int type = 38;
			int channel = 0;
			Match(62);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__39")]
	private void mT__39()
	{
		try
		{
			int type = 39;
			int channel = 0;
			Match(">=");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__40")]
	private void mT__40()
	{
		try
		{
			int type = 40;
			int channel = 0;
			Match(">>");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__41")]
	private void mT__41()
	{
		try
		{
			int type = 41;
			int channel = 0;
			Match(63);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__42")]
	private void mT__42()
	{
		try
		{
			int type = 42;
			int channel = 0;
			Match(94);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__43")]
	private void mT__43()
	{
		try
		{
			int type = 43;
			int channel = 0;
			Match("and");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__44")]
	private void mT__44()
	{
		try
		{
			int type = 44;
			int channel = 0;
			Match("not");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__45")]
	private void mT__45()
	{
		try
		{
			int type = 45;
			int channel = 0;
			Match("or");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__46")]
	private void mT__46()
	{
		try
		{
			int type = 46;
			int channel = 0;
			Match(124);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__47")]
	private void mT__47()
	{
		try
		{
			int type = 47;
			int channel = 0;
			Match("||");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("T__48")]
	private void mT__48()
	{
		try
		{
			int type = 48;
			int channel = 0;
			Match(126);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("TRUE")]
	private void mTRUE()
	{
		try
		{
			int type = 16;
			int channel = 0;
			Match("true");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("FALSE")]
	private void mFALSE()
	{
		try
		{
			int type = 8;
			int channel = 0;
			Match("false");
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("ID")]
	private void mID()
	{
		try
		{
			int type = 11;
			int channel = 0;
			mLETTER();
			try
			{
				while (true)
				{
					int num = 2;
					try
					{
						int num2 = input.LA(1);
						if ((num2 < 48 || num2 > 57) && (num2 < 65 || num2 > 90))
						{
							switch (num2)
							{
							case 95:
							case 97:
							case 98:
							case 99:
							case 100:
							case 101:
							case 102:
							case 103:
							case 104:
							case 105:
							case 106:
							case 107:
							case 108:
							case 109:
							case 110:
							case 111:
							case 112:
							case 113:
							case 114:
							case 115:
							case 116:
							case 117:
							case 118:
							case 119:
							case 120:
							case 121:
							case 122:
								break;
							default:
								goto end_IL_000d;
							}
						}
						num = 1;
						end_IL_000d:;
					}
					finally
					{
					}
					if (num != 1)
					{
						break;
					}
					input.Consume();
				}
			}
			finally
			{
			}
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("INTEGER")]
	private void mINTEGER()
	{
		try
		{
			int type = 12;
			int channel = 0;
			int num = 0;
			try
			{
				while (true)
				{
					int num2 = 2;
					try
					{
						int num3 = input.LA(1);
						if (num3 >= 48 && num3 <= 57)
						{
							num2 = 1;
						}
					}
					finally
					{
					}
					if (num2 != 1)
					{
						break;
					}
					input.Consume();
					num++;
				}
				if (num < 1)
				{
					throw new EarlyExitException(2, input);
				}
			}
			finally
			{
			}
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("FLOAT")]
	private void mFLOAT()
	{
		try
		{
			int type = 9;
			int channel = 0;
			int num = 2;
			try
			{
				num = dfa7.Predict(input);
			}
			catch (NoViableAltException)
			{
				throw;
			}
			finally
			{
			}
			switch (num)
			{
			case 1:
			{
				try
				{
					while (true)
					{
						int num5 = 2;
						try
						{
							int num6 = input.LA(1);
							if (num6 >= 48 && num6 <= 57)
							{
								num5 = 1;
							}
						}
						finally
						{
						}
						if (num5 != 1)
						{
							break;
						}
						input.Consume();
					}
				}
				finally
				{
				}
				Match(46);
				int num7 = 0;
				try
				{
					while (true)
					{
						int num8 = 2;
						try
						{
							int num9 = input.LA(1);
							if (num9 >= 48 && num9 <= 57)
							{
								num8 = 1;
							}
						}
						finally
						{
						}
						if (num8 != 1)
						{
							break;
						}
						input.Consume();
						num7++;
					}
					if (num7 < 1)
					{
						throw new EarlyExitException(4, input);
					}
				}
				finally
				{
				}
				int num10 = 2;
				try
				{
					try
					{
						int num11 = input.LA(1);
						if (num11 == 69 || num11 == 101)
						{
							num10 = 1;
						}
					}
					finally
					{
					}
					if (num10 == 1)
					{
						mE();
					}
				}
				finally
				{
				}
				break;
			}
			case 2:
			{
				int num2 = 0;
				try
				{
					while (true)
					{
						int num3 = 2;
						try
						{
							int num4 = input.LA(1);
							if (num4 >= 48 && num4 <= 57)
							{
								num3 = 1;
							}
						}
						finally
						{
						}
						if (num3 != 1)
						{
							break;
						}
						input.Consume();
						num2++;
					}
					if (num2 < 1)
					{
						throw new EarlyExitException(6, input);
					}
				}
				finally
				{
				}
				mE();
				break;
			}
			}
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("STRING")]
	private void mSTRING()
	{
		try
		{
			int type = 15;
			int channel = 0;
			Match(39);
			try
			{
				while (true)
				{
					int num = 3;
					try
					{
						int num2 = input.LA(1);
						switch (num2)
						{
						case 92:
							num = 1;
							goto end_IL_000f;
						default:
							if ((num2 >= 40 && num2 <= 91) || (num2 >= 93 && num2 <= 65535))
							{
								break;
							}
							goto end_IL_000f;
						case 32:
						case 33:
						case 34:
						case 35:
						case 36:
						case 37:
						case 38:
							break;
						}
						num = 2;
						end_IL_000f:;
					}
					finally
					{
					}
					switch (num)
					{
					case 1:
						mEscapeSequence();
						continue;
					case 2:
						input.Consume();
						continue;
					}
					break;
				}
			}
			finally
			{
			}
			Match(39);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("DATETIME")]
	private void mDATETIME()
	{
		try
		{
			int type = 4;
			int channel = 0;
			Match(35);
			try
			{
				while (true)
				{
					int num = 2;
					try
					{
						int num2 = input.LA(1);
						if ((num2 >= 0 && num2 <= 34) || (num2 >= 36 && num2 <= 65535))
						{
							num = 1;
						}
					}
					finally
					{
					}
					if (num != 1)
					{
						break;
					}
					input.Consume();
				}
			}
			finally
			{
			}
			Match(35);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("NAME")]
	private void mNAME()
	{
		try
		{
			int type = 14;
			int channel = 0;
			Match(91);
			try
			{
				while (true)
				{
					int num = 2;
					try
					{
						int num2 = input.LA(1);
						if ((num2 >= 0 && num2 <= 92) || (num2 >= 94 && num2 <= 65535))
						{
							num = 1;
						}
					}
					finally
					{
					}
					if (num != 1)
					{
						break;
					}
					input.Consume();
				}
			}
			finally
			{
			}
			Match(93);
			state.type = type;
			state.channel = channel;
		}
		finally
		{
		}
	}

	[GrammarRule("E")]
	private void mE()
	{
		try
		{
			int type = 6;
			int channel = 0;
			if (input.LA(1) == 69 || input.LA(1) == 101)
			{
				input.Consume();
				int num = 2;
				try
				{
					try
					{
						int num2 = input.LA(1);
						if (num2 == 43 || num2 == 45)
						{
							num = 1;
						}
					}
					finally
					{
					}
					if (num == 1)
					{
						input.Consume();
					}
				}
				finally
				{
				}
				int num3 = 0;
				try
				{
					while (true)
					{
						int num4 = 2;
						try
						{
							int num5 = input.LA(1);
							if (num5 >= 48 && num5 <= 57)
							{
								num4 = 1;
							}
						}
						finally
						{
						}
						if (num4 != 1)
						{
							break;
						}
						input.Consume();
						num3++;
					}
					if (num3 < 1)
					{
						throw new EarlyExitException(12, input);
					}
				}
				finally
				{
				}
				state.type = type;
				state.channel = channel;
				return;
			}
			MismatchedSetException ex = new MismatchedSetException(null, input);
			Recover(ex);
			throw ex;
		}
		finally
		{
		}
	}

	[GrammarRule("LETTER")]
	private void mLETTER()
	{
		try
		{
			if ((input.LA(1) >= 65 && input.LA(1) <= 90) || input.LA(1) == 95 || (input.LA(1) >= 97 && input.LA(1) <= 122))
			{
				input.Consume();
				return;
			}
			MismatchedSetException ex = new MismatchedSetException(null, input);
			Recover(ex);
			throw ex;
		}
		finally
		{
		}
	}

	[GrammarRule("DIGIT")]
	private void mDIGIT()
	{
		try
		{
			if (input.LA(1) >= 48 && input.LA(1) <= 57)
			{
				input.Consume();
				return;
			}
			MismatchedSetException ex = new MismatchedSetException(null, input);
			Recover(ex);
			throw ex;
		}
		finally
		{
		}
	}

	[GrammarRule("EscapeSequence")]
	private void mEscapeSequence()
	{
		try
		{
			Match(92);
			int num = 6;
			try
			{
				try
				{
					num = input.LA(1) switch
					{
						110 => 1, 
						114 => 2, 
						116 => 3, 
						39 => 4, 
						92 => 5, 
						117 => 6, 
						_ => throw new NoViableAltException("", 13, 0, input), 
					};
				}
				finally
				{
				}
				switch (num)
				{
				case 1:
					Match(110);
					break;
				case 2:
					Match(114);
					break;
				case 3:
					Match(116);
					break;
				case 4:
					Match(39);
					break;
				case 5:
					Match(92);
					break;
				case 6:
					mUnicodeEscape();
					break;
				}
			}
			finally
			{
			}
		}
		finally
		{
		}
	}

	[GrammarRule("HexDigit")]
	private void mHexDigit()
	{
		try
		{
			if ((input.LA(1) >= 48 && input.LA(1) <= 57) || (input.LA(1) >= 65 && input.LA(1) <= 70) || (input.LA(1) >= 97 && input.LA(1) <= 102))
			{
				input.Consume();
				return;
			}
			MismatchedSetException ex = new MismatchedSetException(null, input);
			Recover(ex);
			throw ex;
		}
		finally
		{
		}
	}

	[GrammarRule("UnicodeEscape")]
	private void mUnicodeEscape()
	{
		try
		{
			Match(117);
			mHexDigit();
			mHexDigit();
			mHexDigit();
			mHexDigit();
		}
		finally
		{
		}
	}

	[GrammarRule("WS")]
	private void mWS()
	{
		try
		{
			int type = 18;
			int num = 0;
			if ((input.LA(1) >= 9 && input.LA(1) <= 10) || (input.LA(1) >= 12 && input.LA(1) <= 13) || input.LA(1) == 32)
			{
				input.Consume();
				num = 99;
				state.type = type;
				state.channel = num;
				return;
			}
			MismatchedSetException ex = new MismatchedSetException(null, input);
			Recover(ex);
			throw ex;
		}
		finally
		{
		}
	}

	public override void mTokens()
	{
		int num = 40;
		try
		{
			num = dfa14.Predict(input);
		}
		catch (NoViableAltException)
		{
			throw;
		}
		finally
		{
		}
		switch (num)
		{
		case 1:
			mT__19();
			break;
		case 2:
			mT__20();
			break;
		case 3:
			mT__21();
			break;
		case 4:
			mT__22();
			break;
		case 5:
			mT__23();
			break;
		case 6:
			mT__24();
			break;
		case 7:
			mT__25();
			break;
		case 8:
			mT__26();
			break;
		case 9:
			mT__27();
			break;
		case 10:
			mT__28();
			break;
		case 11:
			mT__29();
			break;
		case 12:
			mT__30();
			break;
		case 13:
			mT__31();
			break;
		case 14:
			mT__32();
			break;
		case 15:
			mT__33();
			break;
		case 16:
			mT__34();
			break;
		case 17:
			mT__35();
			break;
		case 18:
			mT__36();
			break;
		case 19:
			mT__37();
			break;
		case 20:
			mT__38();
			break;
		case 21:
			mT__39();
			break;
		case 22:
			mT__40();
			break;
		case 23:
			mT__41();
			break;
		case 24:
			mT__42();
			break;
		case 25:
			mT__43();
			break;
		case 26:
			mT__44();
			break;
		case 27:
			mT__45();
			break;
		case 28:
			mT__46();
			break;
		case 29:
			mT__47();
			break;
		case 30:
			mT__48();
			break;
		case 31:
			mTRUE();
			break;
		case 32:
			mFALSE();
			break;
		case 33:
			mID();
			break;
		case 34:
			mINTEGER();
			break;
		case 35:
			mFLOAT();
			break;
		case 36:
			mSTRING();
			break;
		case 37:
			mDATETIME();
			break;
		case 38:
			mNAME();
			break;
		case 39:
			mE();
			break;
		case 40:
			mWS();
			break;
		}
	}

	protected override void InitDFAs()
	{
		base.InitDFAs();
		dfa7 = new DFA7(this);
		dfa14 = new DFA14(this);
	}
}
[CLSCompliant(false)]
public class NCalcParser : Parser
{
	public class ncalcExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class logicalExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class conditionalExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class booleanAndExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class bitwiseOrExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class bitwiseXOrExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class bitwiseAndExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class equalityExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class relationalExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class shiftExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class additiveExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class multiplicativeExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class unaryExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class primaryExpression_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public LogicalExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class value_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public ValueExpression value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class identifier_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public Identifier value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class expressionList_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public List<LogicalExpression> value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	public class arguments_return : ParserRuleReturnScope<IToken>, IAstRuleReturnScope<CommonTree>, IAstRuleReturnScope, IRuleReturnScope
	{
		public List<LogicalExpression> value;

		private CommonTree _tree;

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

		object IAstRuleReturnScope.Tree => _tree;
	}

	private static class Follow
	{
		public static readonly BitSet _logicalExpression_in_ncalcExpression56 = new BitSet(new ulong[1]);

		public static readonly BitSet _EOF_in_ncalcExpression58 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _conditionalExpression_in_logicalExpression78 = new BitSet(new ulong[1] { 2199023255554uL });

		public static readonly BitSet _41_in_logicalExpression84 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _conditionalExpression_in_logicalExpression88 = new BitSet(new ulong[1] { 2147483648uL });

		public static readonly BitSet _31_in_logicalExpression90 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _conditionalExpression_in_logicalExpression94 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _booleanAndExpression_in_conditionalExpression121 = new BitSet(new ulong[1] { 175921860444162uL });

		public static readonly BitSet _set_in_conditionalExpression130 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _conditionalExpression_in_conditionalExpression146 = new BitSet(new ulong[1] { 175921860444162uL });

		public static readonly BitSet _bitwiseOrExpression_in_booleanAndExpression180 = new BitSet(new ulong[1] { 8796097216514uL });

		public static readonly BitSet _set_in_booleanAndExpression189 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _bitwiseOrExpression_in_booleanAndExpression205 = new BitSet(new ulong[1] { 8796097216514uL });

		public static readonly BitSet _bitwiseXOrExpression_in_bitwiseOrExpression237 = new BitSet(new ulong[1] { 70368744177666uL });

		public static readonly BitSet _46_in_bitwiseOrExpression246 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _bitwiseOrExpression_in_bitwiseOrExpression256 = new BitSet(new ulong[1] { 70368744177666uL });

		public static readonly BitSet _bitwiseAndExpression_in_bitwiseXOrExpression290 = new BitSet(new ulong[1] { 4398046511106uL });

		public static readonly BitSet _42_in_bitwiseXOrExpression299 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _bitwiseAndExpression_in_bitwiseXOrExpression309 = new BitSet(new ulong[1] { 4398046511106uL });

		public static readonly BitSet _equalityExpression_in_bitwiseAndExpression341 = new BitSet(new ulong[1] { 8388610uL });

		public static readonly BitSet _23_in_bitwiseAndExpression350 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _equalityExpression_in_bitwiseAndExpression360 = new BitSet(new ulong[1] { 8388610uL });

		public static readonly BitSet _relationalExpression_in_equalityExpression394 = new BitSet(new ulong[1] { 240519217154uL });

		public static readonly BitSet _set_in_equalityExpression405 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _set_in_equalityExpression422 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _relationalExpression_in_equalityExpression441 = new BitSet(new ulong[1] { 240519217154uL });

		public static readonly BitSet _shiftExpression_in_relationalExpression474 = new BitSet(new ulong[1] { 846108557314uL });

		public static readonly BitSet _32_in_relationalExpression485 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _34_in_relationalExpression495 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _38_in_relationalExpression506 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _39_in_relationalExpression516 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _shiftExpression_in_relationalExpression528 = new BitSet(new ulong[1] { 846108557314uL });

		public static readonly BitSet _additiveExpression_in_shiftExpression560 = new BitSet(new ulong[1] { 1108101562370uL });

		public static readonly BitSet _33_in_shiftExpression571 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _40_in_shiftExpression581 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _additiveExpression_in_shiftExpression593 = new BitSet(new ulong[1] { 1108101562370uL });

		public static readonly BitSet _multiplicativeExpression_in_additiveExpression625 = new BitSet(new ulong[1] { 671088642uL });

		public static readonly BitSet _27_in_additiveExpression636 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _29_in_additiveExpression646 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _multiplicativeExpression_in_additiveExpression658 = new BitSet(new ulong[1] { 671088642uL });

		public static readonly BitSet _unaryExpression_in_multiplicativeExpression690 = new BitSet(new ulong[1] { 1142947842uL });

		public static readonly BitSet _26_in_multiplicativeExpression701 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _30_in_multiplicativeExpression711 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _21_in_multiplicativeExpression721 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _unaryExpression_in_multiplicativeExpression733 = new BitSet(new ulong[1] { 1142947842uL });

		public static readonly BitSet _primaryExpression_in_unaryExpression760 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _set_in_unaryExpression771 = new BitSet(new ulong[1] { 16898832uL });

		public static readonly BitSet _primaryExpression_in_unaryExpression779 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _48_in_unaryExpression791 = new BitSet(new ulong[1] { 16898832uL });

		public static readonly BitSet _primaryExpression_in_unaryExpression794 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _29_in_unaryExpression805 = new BitSet(new ulong[1] { 16898832uL });

		public static readonly BitSet _primaryExpression_in_unaryExpression807 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _24_in_primaryExpression829 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _logicalExpression_in_primaryExpression831 = new BitSet(new ulong[1] { 33554432uL });

		public static readonly BitSet _25_in_primaryExpression833 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _value_in_primaryExpression843 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _identifier_in_primaryExpression851 = new BitSet(new ulong[1] { 16777218uL });

		public static readonly BitSet _arguments_in_primaryExpression856 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _INTEGER_in_value876 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _FLOAT_in_value884 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _STRING_in_value892 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _DATETIME_in_value901 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _TRUE_in_value908 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _FALSE_in_value916 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _ID_in_identifier934 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _NAME_in_identifier942 = new BitSet(new ulong[1] { 2uL });

		public static readonly BitSet _logicalExpression_in_expressionList966 = new BitSet(new ulong[1] { 268435458uL });

		public static readonly BitSet _28_in_expressionList973 = new BitSet(new ulong[1] { 299067717049104uL });

		public static readonly BitSet _logicalExpression_in_expressionList977 = new BitSet(new ulong[1] { 268435458uL });

		public static readonly BitSet _24_in_arguments1006 = new BitSet(new ulong[1] { 299067750603536uL });

		public static readonly BitSet _expressionList_in_arguments1010 = new BitSet(new ulong[1] { 33554432uL });

		public static readonly BitSet _25_in_arguments1017 = new BitSet(new ulong[1] { 2uL });
	}

	internal static readonly string[] tokenNames = new string[49]
	{
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "DATETIME", "DIGIT", "E", "EscapeSequence", "FALSE", "FLOAT",
		"HexDigit", "ID", "INTEGER", "LETTER", "NAME", "STRING", "TRUE", "UnicodeEscape", "WS", "'!'",
		"'!='", "'%'", "'&&'", "'&'", "'('", "')'", "'*'", "'+'", "','", "'-'",
		"'/'", "':'", "'<'", "'<<'", "'<='", "'<>'", "'='", "'=='", "'>'", "'>='",
		"'>>'", "'?'", "'^'", "'and'", "'not'", "'or'", "'|'", "'||'", "'~'"
	};

	public const int EOF = -1;

	public const int DATETIME = 4;

	public const int DIGIT = 5;

	public const int E = 6;

	public const int EscapeSequence = 7;

	public const int FALSE = 8;

	public const int FLOAT = 9;

	public const int HexDigit = 10;

	public const int ID = 11;

	public const int INTEGER = 12;

	public const int LETTER = 13;

	public const int NAME = 14;

	public const int STRING = 15;

	public const int TRUE = 16;

	public const int UnicodeEscape = 17;

	public const int WS = 18;

	public const int T__19 = 19;

	public const int T__20 = 20;

	public const int T__21 = 21;

	public const int T__22 = 22;

	public const int T__23 = 23;

	public const int T__24 = 24;

	public const int T__25 = 25;

	public const int T__26 = 26;

	public const int T__27 = 27;

	public const int T__28 = 28;

	public const int T__29 = 29;

	public const int T__30 = 30;

	public const int T__31 = 31;

	public const int T__32 = 32;

	public const int T__33 = 33;

	public const int T__34 = 34;

	public const int T__35 = 35;

	public const int T__36 = 36;

	public const int T__37 = 37;

	public const int T__38 = 38;

	public const int T__39 = 39;

	public const int T__40 = 40;

	public const int T__41 = 41;

	public const int T__42 = 42;

	public const int T__43 = 43;

	public const int T__44 = 44;

	public const int T__45 = 45;

	public const int T__46 = 46;

	public const int T__47 = 47;

	public const int T__48 = 48;

	private static readonly bool[] decisionCanBacktrack = new bool[0];

	private ITreeAdaptor adaptor;

	private const char BS = '\\';

	private static NumberFormatInfo numberFormatInfo = new NumberFormatInfo();

	public ITreeAdaptor TreeAdaptor
	{
		get
		{
			return adaptor;
		}
		set
		{
			adaptor = value;
		}
	}

	public override string[] TokenNames => tokenNames;

	public override string GrammarFileName => "C:\\Users\\sebros\\My Projects\\NCalc\\Grammar\\NCalc.g";

	public List<string> Errors { get; private set; }

	public NCalcParser(ITokenStream input)
		: this(input, new RecognizerSharedState())
	{
	}

	public NCalcParser(ITokenStream input, RecognizerSharedState state)
		: base(input, state)
	{
		ITreeAdaptor treeAdaptor = null;
		TreeAdaptor = treeAdaptor ?? new CommonTreeAdaptor();
	}

	private string extractString(string text)
	{
		StringBuilder stringBuilder = new StringBuilder(text);
		int startIndex = 1;
		int num = -1;
		while ((num = stringBuilder.ToString().IndexOf('\\', startIndex)) != -1)
		{
			char c = stringBuilder[num + 1];
			switch (c)
			{
			case 'u':
			{
				string text2 = string.Concat(stringBuilder[num + 4], stringBuilder[num + 5]);
				string text3 = string.Concat(stringBuilder[num + 2], stringBuilder[num + 3]);
				char c2 = Encoding.Unicode.GetChars(new byte[2]
				{
					Convert.ToByte(text2, 16),
					Convert.ToByte(text3, 16)
				})[0];
				stringBuilder.Remove(num, 6).Insert(num, c2);
				break;
			}
			case 'n':
				stringBuilder.Remove(num, 2).Insert(num, '\n');
				break;
			case 'r':
				stringBuilder.Remove(num, 2).Insert(num, '\r');
				break;
			case 't':
				stringBuilder.Remove(num, 2).Insert(num, '\t');
				break;
			case '\'':
				stringBuilder.Remove(num, 2).Insert(num, '\'');
				break;
			case '\\':
				stringBuilder.Remove(num, 2).Insert(num, '\\');
				break;
			default:
				throw new RecognitionException("Unvalid escape sequence: \\" + c);
			}
			startIndex = num + 1;
		}
		stringBuilder.Remove(0, 1);
		stringBuilder.Remove(stringBuilder.Length - 1, 1);
		return stringBuilder.ToString();
	}

	public override void DisplayRecognitionError(string[] tokenNames, RecognitionException e)
	{
		base.DisplayRecognitionError(tokenNames, e);
		if (Errors == null)
		{
			Errors = new List<string>();
		}
		string errorHeader = GetErrorHeader(e);
		string errorMessage = GetErrorMessage(e, tokenNames);
		Errors.Add(errorMessage + " at " + errorHeader);
	}

	[GrammarRule("ncalcExpression")]
	public ncalcExpression_return ncalcExpression()
	{
		ncalcExpression_return ncalcExpression_return = new ncalcExpression_return();
		ncalcExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		logicalExpression_return logicalExpression_return = null;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._logicalExpression_in_ncalcExpression56);
				logicalExpression_return = logicalExpression();
				PopFollow();
				adaptor.AddChild(commonTree, logicalExpression_return.Tree);
				_ = (IToken)Match(input, -1, Follow._EOF_in_ncalcExpression58);
				ncalcExpression_return.value = logicalExpression_return?.value;
				ncalcExpression_return.Stop = input.LT(-1);
				ncalcExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(ncalcExpression_return.Tree, ncalcExpression_return.Start, ncalcExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				ncalcExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, ncalcExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return ncalcExpression_return;
	}

	[GrammarRule("logicalExpression")]
	private logicalExpression_return logicalExpression()
	{
		logicalExpression_return logicalExpression_return = new logicalExpression_return();
		logicalExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		conditionalExpression_return conditionalExpression_return = null;
		conditionalExpression_return conditionalExpression_return2 = null;
		conditionalExpression_return conditionalExpression_return3 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._conditionalExpression_in_logicalExpression78);
				conditionalExpression_return = conditionalExpression();
				PopFollow();
				adaptor.AddChild(commonTree, conditionalExpression_return.Tree);
				logicalExpression_return.value = conditionalExpression_return?.value;
				int num = 2;
				try
				{
					try
					{
						if (input.LA(1) == 41)
						{
							num = 1;
						}
					}
					finally
					{
					}
					if (num == 1)
					{
						token = (IToken)Match(input, 41, Follow._41_in_logicalExpression84);
						commonTree2 = (CommonTree)adaptor.Create(token);
						adaptor.AddChild(commonTree, commonTree2);
						PushFollow(Follow._conditionalExpression_in_logicalExpression88);
						conditionalExpression_return2 = conditionalExpression();
						PopFollow();
						adaptor.AddChild(commonTree, conditionalExpression_return2.Tree);
						token2 = (IToken)Match(input, 31, Follow._31_in_logicalExpression90);
						commonTree3 = (CommonTree)adaptor.Create(token2);
						adaptor.AddChild(commonTree, commonTree3);
						PushFollow(Follow._conditionalExpression_in_logicalExpression94);
						conditionalExpression_return3 = conditionalExpression();
						PopFollow();
						adaptor.AddChild(commonTree, conditionalExpression_return3.Tree);
						logicalExpression_return.value = new TernaryExpression(conditionalExpression_return?.value, conditionalExpression_return2?.value, conditionalExpression_return3?.value);
					}
				}
				finally
				{
				}
				logicalExpression_return.Stop = input.LT(-1);
				logicalExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(logicalExpression_return.Tree, logicalExpression_return.Start, logicalExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				logicalExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, logicalExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return logicalExpression_return;
	}

	[GrammarRule("conditionalExpression")]
	private conditionalExpression_return conditionalExpression()
	{
		conditionalExpression_return conditionalExpression_return = new conditionalExpression_return();
		conditionalExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		booleanAndExpression_return booleanAndExpression_return = null;
		conditionalExpression_return conditionalExpression_return2 = null;
		BinaryExpressionType binaryExpressionType = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._booleanAndExpression_in_conditionalExpression121);
				booleanAndExpression_return = booleanAndExpression();
				PopFollow();
				adaptor.AddChild(commonTree, booleanAndExpression_return.Tree);
				conditionalExpression_return.value = booleanAndExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							int num2 = input.LA(1);
							if (num2 == 45 || num2 == 47)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num == 1)
						{
							token = input.LT(1);
							if (input.LA(1) == 45 || input.LA(1) == 47)
							{
								input.Consume();
								adaptor.AddChild(commonTree, (CommonTree)adaptor.Create(token));
								state.errorRecovery = false;
								binaryExpressionType = BinaryExpressionType.Or;
								PushFollow(Follow._conditionalExpression_in_conditionalExpression146);
								conditionalExpression_return2 = conditionalExpression();
								PopFollow();
								adaptor.AddChild(commonTree, conditionalExpression_return2.Tree);
								conditionalExpression_return.value = new NCalc.Domain.BinaryExpression(binaryExpressionType, conditionalExpression_return.value, conditionalExpression_return2?.value);
								continue;
							}
							throw new MismatchedSetException(null, input);
						}
						break;
					}
				}
				finally
				{
				}
				conditionalExpression_return.Stop = input.LT(-1);
				conditionalExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(conditionalExpression_return.Tree, conditionalExpression_return.Start, conditionalExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				conditionalExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, conditionalExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return conditionalExpression_return;
	}

	[GrammarRule("booleanAndExpression")]
	private booleanAndExpression_return booleanAndExpression()
	{
		booleanAndExpression_return booleanAndExpression_return = new booleanAndExpression_return();
		booleanAndExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		bitwiseOrExpression_return bitwiseOrExpression_return = null;
		bitwiseOrExpression_return bitwiseOrExpression_return2 = null;
		BinaryExpressionType binaryExpressionType = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._bitwiseOrExpression_in_booleanAndExpression180);
				bitwiseOrExpression_return = bitwiseOrExpression();
				PopFollow();
				adaptor.AddChild(commonTree, bitwiseOrExpression_return.Tree);
				booleanAndExpression_return.value = bitwiseOrExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							int num2 = input.LA(1);
							if (num2 == 22 || num2 == 43)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num == 1)
						{
							token = input.LT(1);
							if (input.LA(1) == 22 || input.LA(1) == 43)
							{
								input.Consume();
								adaptor.AddChild(commonTree, (CommonTree)adaptor.Create(token));
								state.errorRecovery = false;
								binaryExpressionType = BinaryExpressionType.And;
								PushFollow(Follow._bitwiseOrExpression_in_booleanAndExpression205);
								bitwiseOrExpression_return2 = bitwiseOrExpression();
								PopFollow();
								adaptor.AddChild(commonTree, bitwiseOrExpression_return2.Tree);
								booleanAndExpression_return.value = new NCalc.Domain.BinaryExpression(binaryExpressionType, booleanAndExpression_return.value, bitwiseOrExpression_return2?.value);
								continue;
							}
							throw new MismatchedSetException(null, input);
						}
						break;
					}
				}
				finally
				{
				}
				booleanAndExpression_return.Stop = input.LT(-1);
				booleanAndExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(booleanAndExpression_return.Tree, booleanAndExpression_return.Start, booleanAndExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				booleanAndExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, booleanAndExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return booleanAndExpression_return;
	}

	[GrammarRule("bitwiseOrExpression")]
	private bitwiseOrExpression_return bitwiseOrExpression()
	{
		bitwiseOrExpression_return bitwiseOrExpression_return = new bitwiseOrExpression_return();
		bitwiseOrExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		bitwiseXOrExpression_return bitwiseXOrExpression_return = null;
		bitwiseOrExpression_return bitwiseOrExpression_return2 = null;
		CommonTree commonTree2 = null;
		BinaryExpressionType binaryExpressionType = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._bitwiseXOrExpression_in_bitwiseOrExpression237);
				bitwiseXOrExpression_return = bitwiseXOrExpression();
				PopFollow();
				adaptor.AddChild(commonTree, bitwiseXOrExpression_return.Tree);
				bitwiseOrExpression_return.value = bitwiseXOrExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							if (input.LA(1) == 46)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num == 1)
						{
							token = (IToken)Match(input, 46, Follow._46_in_bitwiseOrExpression246);
							commonTree2 = (CommonTree)adaptor.Create(token);
							adaptor.AddChild(commonTree, commonTree2);
							binaryExpressionType = BinaryExpressionType.BitwiseOr;
							PushFollow(Follow._bitwiseOrExpression_in_bitwiseOrExpression256);
							bitwiseOrExpression_return2 = bitwiseOrExpression();
							PopFollow();
							adaptor.AddChild(commonTree, bitwiseOrExpression_return2.Tree);
							bitwiseOrExpression_return.value = new NCalc.Domain.BinaryExpression(binaryExpressionType, bitwiseOrExpression_return.value, bitwiseOrExpression_return2?.value);
							continue;
						}
						break;
					}
				}
				finally
				{
				}
				bitwiseOrExpression_return.Stop = input.LT(-1);
				bitwiseOrExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(bitwiseOrExpression_return.Tree, bitwiseOrExpression_return.Start, bitwiseOrExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				bitwiseOrExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, bitwiseOrExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return bitwiseOrExpression_return;
	}

	[GrammarRule("bitwiseXOrExpression")]
	private bitwiseXOrExpression_return bitwiseXOrExpression()
	{
		bitwiseXOrExpression_return bitwiseXOrExpression_return = new bitwiseXOrExpression_return();
		bitwiseXOrExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		bitwiseAndExpression_return bitwiseAndExpression_return = null;
		bitwiseAndExpression_return bitwiseAndExpression_return2 = null;
		CommonTree commonTree2 = null;
		BinaryExpressionType binaryExpressionType = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._bitwiseAndExpression_in_bitwiseXOrExpression290);
				bitwiseAndExpression_return = bitwiseAndExpression();
				PopFollow();
				adaptor.AddChild(commonTree, bitwiseAndExpression_return.Tree);
				bitwiseXOrExpression_return.value = bitwiseAndExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							if (input.LA(1) == 42)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num == 1)
						{
							token = (IToken)Match(input, 42, Follow._42_in_bitwiseXOrExpression299);
							commonTree2 = (CommonTree)adaptor.Create(token);
							adaptor.AddChild(commonTree, commonTree2);
							binaryExpressionType = BinaryExpressionType.BitwiseXOr;
							PushFollow(Follow._bitwiseAndExpression_in_bitwiseXOrExpression309);
							bitwiseAndExpression_return2 = bitwiseAndExpression();
							PopFollow();
							adaptor.AddChild(commonTree, bitwiseAndExpression_return2.Tree);
							bitwiseXOrExpression_return.value = new NCalc.Domain.BinaryExpression(binaryExpressionType, bitwiseXOrExpression_return.value, bitwiseAndExpression_return2?.value);
							continue;
						}
						break;
					}
				}
				finally
				{
				}
				bitwiseXOrExpression_return.Stop = input.LT(-1);
				bitwiseXOrExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(bitwiseXOrExpression_return.Tree, bitwiseXOrExpression_return.Start, bitwiseXOrExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				bitwiseXOrExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, bitwiseXOrExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return bitwiseXOrExpression_return;
	}

	[GrammarRule("bitwiseAndExpression")]
	private bitwiseAndExpression_return bitwiseAndExpression()
	{
		bitwiseAndExpression_return bitwiseAndExpression_return = new bitwiseAndExpression_return();
		bitwiseAndExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		equalityExpression_return equalityExpression_return = null;
		equalityExpression_return equalityExpression_return2 = null;
		CommonTree commonTree2 = null;
		BinaryExpressionType binaryExpressionType = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._equalityExpression_in_bitwiseAndExpression341);
				equalityExpression_return = equalityExpression();
				PopFollow();
				adaptor.AddChild(commonTree, equalityExpression_return.Tree);
				bitwiseAndExpression_return.value = equalityExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							if (input.LA(1) == 23)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num == 1)
						{
							token = (IToken)Match(input, 23, Follow._23_in_bitwiseAndExpression350);
							commonTree2 = (CommonTree)adaptor.Create(token);
							adaptor.AddChild(commonTree, commonTree2);
							binaryExpressionType = BinaryExpressionType.BitwiseAnd;
							PushFollow(Follow._equalityExpression_in_bitwiseAndExpression360);
							equalityExpression_return2 = equalityExpression();
							PopFollow();
							adaptor.AddChild(commonTree, equalityExpression_return2.Tree);
							bitwiseAndExpression_return.value = new NCalc.Domain.BinaryExpression(binaryExpressionType, bitwiseAndExpression_return.value, equalityExpression_return2?.value);
							continue;
						}
						break;
					}
				}
				finally
				{
				}
				bitwiseAndExpression_return.Stop = input.LT(-1);
				bitwiseAndExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(bitwiseAndExpression_return.Tree, bitwiseAndExpression_return.Start, bitwiseAndExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				bitwiseAndExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, bitwiseAndExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return bitwiseAndExpression_return;
	}

	[GrammarRule("equalityExpression")]
	private equalityExpression_return equalityExpression()
	{
		equalityExpression_return equalityExpression_return = new equalityExpression_return();
		equalityExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		relationalExpression_return relationalExpression_return = null;
		relationalExpression_return relationalExpression_return2 = null;
		BinaryExpressionType type = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._relationalExpression_in_equalityExpression394);
				relationalExpression_return = relationalExpression();
				PopFollow();
				adaptor.AddChild(commonTree, relationalExpression_return.Tree);
				equalityExpression_return.value = relationalExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							switch (input.LA(1))
							{
							case 20:
							case 35:
							case 36:
							case 37:
								num = 1;
								break;
							}
						}
						finally
						{
						}
						if (num != 1)
						{
							break;
						}
						int num2 = 2;
						try
						{
							try
							{
								int num3 = input.LA(1);
								if (num3 >= 36 && num3 <= 37)
								{
									num2 = 1;
								}
								else
								{
									if (num3 != 20 && num3 != 35)
									{
										throw new NoViableAltException("", 7, 0, input);
									}
									num2 = 2;
								}
							}
							finally
							{
							}
							switch (num2)
							{
							case 1:
								token = input.LT(1);
								if (input.LA(1) >= 36 && input.LA(1) <= 37)
								{
									input.Consume();
									adaptor.AddChild(commonTree, (CommonTree)adaptor.Create(token));
									state.errorRecovery = false;
									type = BinaryExpressionType.Equal;
									break;
								}
								throw new MismatchedSetException(null, input);
							case 2:
								token2 = input.LT(1);
								if (input.LA(1) == 20 || input.LA(1) == 35)
								{
									input.Consume();
									adaptor.AddChild(commonTree, (CommonTree)adaptor.Create(token2));
									state.errorRecovery = false;
									type = BinaryExpressionType.NotEqual;
									break;
								}
								throw new MismatchedSetException(null, input);
							}
						}
						finally
						{
						}
						PushFollow(Follow._relationalExpression_in_equalityExpression441);
						relationalExpression_return2 = relationalExpression();
						PopFollow();
						adaptor.AddChild(commonTree, relationalExpression_return2.Tree);
						equalityExpression_return.value = new NCalc.Domain.BinaryExpression(type, equalityExpression_return.value, relationalExpression_return2?.value);
					}
				}
				finally
				{
				}
				equalityExpression_return.Stop = input.LT(-1);
				equalityExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(equalityExpression_return.Tree, equalityExpression_return.Start, equalityExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				equalityExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, equalityExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return equalityExpression_return;
	}

	[GrammarRule("relationalExpression")]
	private relationalExpression_return relationalExpression()
	{
		relationalExpression_return relationalExpression_return = new relationalExpression_return();
		relationalExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		IToken token3 = null;
		IToken token4 = null;
		shiftExpression_return shiftExpression_return = null;
		shiftExpression_return shiftExpression_return2 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		CommonTree commonTree4 = null;
		CommonTree commonTree5 = null;
		BinaryExpressionType type = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._shiftExpression_in_relationalExpression474);
				shiftExpression_return = shiftExpression();
				PopFollow();
				adaptor.AddChild(commonTree, shiftExpression_return.Tree);
				relationalExpression_return.value = shiftExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							switch (input.LA(1))
							{
							case 32:
							case 34:
							case 38:
							case 39:
								num = 1;
								break;
							}
						}
						finally
						{
						}
						if (num != 1)
						{
							break;
						}
						int num2 = 4;
						try
						{
							try
							{
								num2 = input.LA(1) switch
								{
									32 => 1, 
									34 => 2, 
									38 => 3, 
									39 => 4, 
									_ => throw new NoViableAltException("", 9, 0, input), 
								};
							}
							finally
							{
							}
							switch (num2)
							{
							case 1:
								token = (IToken)Match(input, 32, Follow._32_in_relationalExpression485);
								commonTree2 = (CommonTree)adaptor.Create(token);
								adaptor.AddChild(commonTree, commonTree2);
								type = BinaryExpressionType.Lesser;
								break;
							case 2:
								token2 = (IToken)Match(input, 34, Follow._34_in_relationalExpression495);
								commonTree3 = (CommonTree)adaptor.Create(token2);
								adaptor.AddChild(commonTree, commonTree3);
								type = BinaryExpressionType.LesserOrEqual;
								break;
							case 3:
								token3 = (IToken)Match(input, 38, Follow._38_in_relationalExpression506);
								commonTree4 = (CommonTree)adaptor.Create(token3);
								adaptor.AddChild(commonTree, commonTree4);
								type = BinaryExpressionType.Greater;
								break;
							case 4:
								token4 = (IToken)Match(input, 39, Follow._39_in_relationalExpression516);
								commonTree5 = (CommonTree)adaptor.Create(token4);
								adaptor.AddChild(commonTree, commonTree5);
								type = BinaryExpressionType.GreaterOrEqual;
								break;
							}
						}
						finally
						{
						}
						PushFollow(Follow._shiftExpression_in_relationalExpression528);
						shiftExpression_return2 = shiftExpression();
						PopFollow();
						adaptor.AddChild(commonTree, shiftExpression_return2.Tree);
						relationalExpression_return.value = new NCalc.Domain.BinaryExpression(type, relationalExpression_return.value, shiftExpression_return2?.value);
					}
				}
				finally
				{
				}
				relationalExpression_return.Stop = input.LT(-1);
				relationalExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(relationalExpression_return.Tree, relationalExpression_return.Start, relationalExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				relationalExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, relationalExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return relationalExpression_return;
	}

	[GrammarRule("shiftExpression")]
	private shiftExpression_return shiftExpression()
	{
		shiftExpression_return shiftExpression_return = new shiftExpression_return();
		shiftExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		additiveExpression_return additiveExpression_return = null;
		additiveExpression_return additiveExpression_return2 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		BinaryExpressionType type = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._additiveExpression_in_shiftExpression560);
				additiveExpression_return = additiveExpression();
				PopFollow();
				adaptor.AddChild(commonTree, additiveExpression_return.Tree);
				shiftExpression_return.value = additiveExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							int num2 = input.LA(1);
							if (num2 == 33 || num2 == 40)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num != 1)
						{
							break;
						}
						int num3 = 2;
						try
						{
							try
							{
								num3 = input.LA(1) switch
								{
									33 => 1, 
									40 => 2, 
									_ => throw new NoViableAltException("", 11, 0, input), 
								};
							}
							finally
							{
							}
							switch (num3)
							{
							case 1:
								token = (IToken)Match(input, 33, Follow._33_in_shiftExpression571);
								commonTree2 = (CommonTree)adaptor.Create(token);
								adaptor.AddChild(commonTree, commonTree2);
								type = BinaryExpressionType.LeftShift;
								break;
							case 2:
								token2 = (IToken)Match(input, 40, Follow._40_in_shiftExpression581);
								commonTree3 = (CommonTree)adaptor.Create(token2);
								adaptor.AddChild(commonTree, commonTree3);
								type = BinaryExpressionType.RightShift;
								break;
							}
						}
						finally
						{
						}
						PushFollow(Follow._additiveExpression_in_shiftExpression593);
						additiveExpression_return2 = additiveExpression();
						PopFollow();
						adaptor.AddChild(commonTree, additiveExpression_return2.Tree);
						shiftExpression_return.value = new NCalc.Domain.BinaryExpression(type, shiftExpression_return.value, additiveExpression_return2?.value);
					}
				}
				finally
				{
				}
				shiftExpression_return.Stop = input.LT(-1);
				shiftExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(shiftExpression_return.Tree, shiftExpression_return.Start, shiftExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				shiftExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, shiftExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return shiftExpression_return;
	}

	[GrammarRule("additiveExpression")]
	private additiveExpression_return additiveExpression()
	{
		additiveExpression_return additiveExpression_return = new additiveExpression_return();
		additiveExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		multiplicativeExpression_return multiplicativeExpression_return = null;
		multiplicativeExpression_return multiplicativeExpression_return2 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		BinaryExpressionType type = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._multiplicativeExpression_in_additiveExpression625);
				multiplicativeExpression_return = multiplicativeExpression();
				PopFollow();
				adaptor.AddChild(commonTree, multiplicativeExpression_return.Tree);
				additiveExpression_return.value = multiplicativeExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							int num2 = input.LA(1);
							if (num2 == 27 || num2 == 29)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num != 1)
						{
							break;
						}
						int num3 = 2;
						try
						{
							try
							{
								num3 = input.LA(1) switch
								{
									27 => 1, 
									29 => 2, 
									_ => throw new NoViableAltException("", 13, 0, input), 
								};
							}
							finally
							{
							}
							switch (num3)
							{
							case 1:
								token = (IToken)Match(input, 27, Follow._27_in_additiveExpression636);
								commonTree2 = (CommonTree)adaptor.Create(token);
								adaptor.AddChild(commonTree, commonTree2);
								type = BinaryExpressionType.Plus;
								break;
							case 2:
								token2 = (IToken)Match(input, 29, Follow._29_in_additiveExpression646);
								commonTree3 = (CommonTree)adaptor.Create(token2);
								adaptor.AddChild(commonTree, commonTree3);
								type = BinaryExpressionType.Minus;
								break;
							}
						}
						finally
						{
						}
						PushFollow(Follow._multiplicativeExpression_in_additiveExpression658);
						multiplicativeExpression_return2 = multiplicativeExpression();
						PopFollow();
						adaptor.AddChild(commonTree, multiplicativeExpression_return2.Tree);
						additiveExpression_return.value = new NCalc.Domain.BinaryExpression(type, additiveExpression_return.value, multiplicativeExpression_return2?.value);
					}
				}
				finally
				{
				}
				additiveExpression_return.Stop = input.LT(-1);
				additiveExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(additiveExpression_return.Tree, additiveExpression_return.Start, additiveExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				additiveExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, additiveExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return additiveExpression_return;
	}

	[GrammarRule("multiplicativeExpression")]
	private multiplicativeExpression_return multiplicativeExpression()
	{
		multiplicativeExpression_return multiplicativeExpression_return = new multiplicativeExpression_return();
		multiplicativeExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		IToken token3 = null;
		unaryExpression_return unaryExpression_return = null;
		unaryExpression_return unaryExpression_return2 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		CommonTree commonTree4 = null;
		BinaryExpressionType type = BinaryExpressionType.Unknown;
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._unaryExpression_in_multiplicativeExpression690);
				unaryExpression_return = unaryExpression();
				PopFollow();
				adaptor.AddChild(commonTree, unaryExpression_return.Tree);
				multiplicativeExpression_return.value = unaryExpression_return?.value;
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							int num2 = input.LA(1);
							if (num2 == 21 || num2 == 26 || num2 == 30)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num != 1)
						{
							break;
						}
						int num3 = 3;
						try
						{
							try
							{
								num3 = input.LA(1) switch
								{
									26 => 1, 
									30 => 2, 
									21 => 3, 
									_ => throw new NoViableAltException("", 15, 0, input), 
								};
							}
							finally
							{
							}
							switch (num3)
							{
							case 1:
								token = (IToken)Match(input, 26, Follow._26_in_multiplicativeExpression701);
								commonTree2 = (CommonTree)adaptor.Create(token);
								adaptor.AddChild(commonTree, commonTree2);
								type = BinaryExpressionType.Times;
								break;
							case 2:
								token2 = (IToken)Match(input, 30, Follow._30_in_multiplicativeExpression711);
								commonTree3 = (CommonTree)adaptor.Create(token2);
								adaptor.AddChild(commonTree, commonTree3);
								type = BinaryExpressionType.Div;
								break;
							case 3:
								token3 = (IToken)Match(input, 21, Follow._21_in_multiplicativeExpression721);
								commonTree4 = (CommonTree)adaptor.Create(token3);
								adaptor.AddChild(commonTree, commonTree4);
								type = BinaryExpressionType.Modulo;
								break;
							}
						}
						finally
						{
						}
						PushFollow(Follow._unaryExpression_in_multiplicativeExpression733);
						unaryExpression_return2 = unaryExpression();
						PopFollow();
						adaptor.AddChild(commonTree, unaryExpression_return2.Tree);
						multiplicativeExpression_return.value = new NCalc.Domain.BinaryExpression(type, multiplicativeExpression_return.value, unaryExpression_return2?.value);
					}
				}
				finally
				{
				}
				multiplicativeExpression_return.Stop = input.LT(-1);
				multiplicativeExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(multiplicativeExpression_return.Tree, multiplicativeExpression_return.Start, multiplicativeExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				multiplicativeExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, multiplicativeExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return multiplicativeExpression_return;
	}

	[GrammarRule("unaryExpression")]
	private unaryExpression_return unaryExpression()
	{
		unaryExpression_return unaryExpression_return = new unaryExpression_return();
		unaryExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		IToken token3 = null;
		primaryExpression_return primaryExpression_return = null;
		primaryExpression_return primaryExpression_return2 = null;
		primaryExpression_return primaryExpression_return3 = null;
		primaryExpression_return primaryExpression_return4 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		try
		{
			try
			{
				int num = 4;
				try
				{
					switch (input.LA(1))
					{
					case 4:
					case 8:
					case 9:
					case 11:
					case 12:
					case 14:
					case 15:
					case 16:
					case 24:
						num = 1;
						break;
					case 19:
					case 44:
						num = 2;
						break;
					case 48:
						num = 3;
						break;
					case 29:
						num = 4;
						break;
					default:
						throw new NoViableAltException("", 17, 0, input);
					}
				}
				finally
				{
				}
				switch (num)
				{
				case 1:
					commonTree = (CommonTree)adaptor.Nil();
					PushFollow(Follow._primaryExpression_in_unaryExpression760);
					primaryExpression_return = primaryExpression();
					PopFollow();
					adaptor.AddChild(commonTree, primaryExpression_return.Tree);
					unaryExpression_return.value = primaryExpression_return?.value;
					break;
				case 2:
					commonTree = (CommonTree)adaptor.Nil();
					token = input.LT(1);
					if (input.LA(1) == 19 || input.LA(1) == 44)
					{
						input.Consume();
						adaptor.AddChild(commonTree, (CommonTree)adaptor.Create(token));
						state.errorRecovery = false;
						PushFollow(Follow._primaryExpression_in_unaryExpression779);
						primaryExpression_return2 = primaryExpression();
						PopFollow();
						adaptor.AddChild(commonTree, primaryExpression_return2.Tree);
						unaryExpression_return.value = new NCalc.Domain.UnaryExpression(UnaryExpressionType.Not, primaryExpression_return2?.value);
						break;
					}
					throw new MismatchedSetException(null, input);
				case 3:
					commonTree = (CommonTree)adaptor.Nil();
					token2 = (IToken)Match(input, 48, Follow._48_in_unaryExpression791);
					commonTree2 = (CommonTree)adaptor.Create(token2);
					adaptor.AddChild(commonTree, commonTree2);
					PushFollow(Follow._primaryExpression_in_unaryExpression794);
					primaryExpression_return3 = primaryExpression();
					PopFollow();
					adaptor.AddChild(commonTree, primaryExpression_return3.Tree);
					unaryExpression_return.value = new NCalc.Domain.UnaryExpression(UnaryExpressionType.BitwiseNot, primaryExpression_return3?.value);
					break;
				case 4:
					commonTree = (CommonTree)adaptor.Nil();
					token3 = (IToken)Match(input, 29, Follow._29_in_unaryExpression805);
					commonTree3 = (CommonTree)adaptor.Create(token3);
					adaptor.AddChild(commonTree, commonTree3);
					PushFollow(Follow._primaryExpression_in_unaryExpression807);
					primaryExpression_return4 = primaryExpression();
					PopFollow();
					adaptor.AddChild(commonTree, primaryExpression_return4.Tree);
					unaryExpression_return.value = new NCalc.Domain.UnaryExpression(UnaryExpressionType.Negate, primaryExpression_return4?.value);
					break;
				}
				unaryExpression_return.Stop = input.LT(-1);
				unaryExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(unaryExpression_return.Tree, unaryExpression_return.Start, unaryExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				unaryExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, unaryExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return unaryExpression_return;
	}

	[GrammarRule("primaryExpression")]
	private primaryExpression_return primaryExpression()
	{
		primaryExpression_return primaryExpression_return = new primaryExpression_return();
		primaryExpression_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		value_return value_return = null;
		logicalExpression_return logicalExpression_return = null;
		identifier_return identifier_return = null;
		arguments_return arguments_return = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		try
		{
			try
			{
				int num = 3;
				try
				{
					switch (input.LA(1))
					{
					case 24:
						num = 1;
						break;
					case 4:
					case 8:
					case 9:
					case 12:
					case 15:
					case 16:
						num = 2;
						break;
					case 11:
					case 14:
						num = 3;
						break;
					default:
						throw new NoViableAltException("", 19, 0, input);
					}
				}
				finally
				{
				}
				switch (num)
				{
				case 1:
					commonTree = (CommonTree)adaptor.Nil();
					token = (IToken)Match(input, 24, Follow._24_in_primaryExpression829);
					commonTree2 = (CommonTree)adaptor.Create(token);
					adaptor.AddChild(commonTree, commonTree2);
					PushFollow(Follow._logicalExpression_in_primaryExpression831);
					logicalExpression_return = logicalExpression();
					PopFollow();
					adaptor.AddChild(commonTree, logicalExpression_return.Tree);
					token2 = (IToken)Match(input, 25, Follow._25_in_primaryExpression833);
					commonTree3 = (CommonTree)adaptor.Create(token2);
					adaptor.AddChild(commonTree, commonTree3);
					primaryExpression_return.value = logicalExpression_return?.value;
					break;
				case 2:
					commonTree = (CommonTree)adaptor.Nil();
					PushFollow(Follow._value_in_primaryExpression843);
					value_return = value();
					PopFollow();
					adaptor.AddChild(commonTree, value_return.Tree);
					primaryExpression_return.value = value_return?.value;
					break;
				case 3:
				{
					commonTree = (CommonTree)adaptor.Nil();
					PushFollow(Follow._identifier_in_primaryExpression851);
					identifier_return = identifier();
					PopFollow();
					adaptor.AddChild(commonTree, identifier_return.Tree);
					primaryExpression_return.value = identifier_return?.value;
					int num2 = 2;
					try
					{
						try
						{
							if (input.LA(1) == 24)
							{
								num2 = 1;
							}
						}
						finally
						{
						}
						if (num2 == 1)
						{
							PushFollow(Follow._arguments_in_primaryExpression856);
							arguments_return = arguments();
							PopFollow();
							adaptor.AddChild(commonTree, arguments_return.Tree);
							primaryExpression_return.value = new Function(identifier_return?.value, (arguments_return?.value).ToArray());
						}
					}
					finally
					{
					}
					break;
				}
				}
				primaryExpression_return.Stop = input.LT(-1);
				primaryExpression_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(primaryExpression_return.Tree, primaryExpression_return.Start, primaryExpression_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				primaryExpression_return.Tree = (CommonTree)adaptor.ErrorNode(input, primaryExpression_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return primaryExpression_return;
	}

	[GrammarRule("value")]
	private value_return value()
	{
		value_return value_return = new value_return();
		value_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		IToken token3 = null;
		IToken token4 = null;
		IToken token5 = null;
		IToken token6 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		CommonTree commonTree4 = null;
		CommonTree commonTree5 = null;
		CommonTree commonTree6 = null;
		CommonTree commonTree7 = null;
		try
		{
			try
			{
				int num = 6;
				try
				{
					num = input.LA(1) switch
					{
						12 => 1, 
						9 => 2, 
						15 => 3, 
						4 => 4, 
						16 => 5, 
						8 => 6, 
						_ => throw new NoViableAltException("", 20, 0, input), 
					};
				}
				finally
				{
				}
				switch (num)
				{
				case 1:
					commonTree = (CommonTree)adaptor.Nil();
					token = (IToken)Match(input, 12, Follow._INTEGER_in_value876);
					commonTree2 = (CommonTree)adaptor.Create(token);
					adaptor.AddChild(commonTree, commonTree2);
					try
					{
						value_return.value = new ValueExpression(int.Parse(token?.Text));
					}
					catch (OverflowException)
					{
						value_return.value = new ValueExpression((object)long.Parse(token?.Text));
					}
					break;
				case 2:
					commonTree = (CommonTree)adaptor.Nil();
					token2 = (IToken)Match(input, 9, Follow._FLOAT_in_value884);
					commonTree3 = (CommonTree)adaptor.Create(token2);
					adaptor.AddChild(commonTree, commonTree3);
					value_return.value = new ValueExpression(double.Parse(token2?.Text, NumberStyles.Float, numberFormatInfo));
					break;
				case 3:
					commonTree = (CommonTree)adaptor.Nil();
					token3 = (IToken)Match(input, 15, Follow._STRING_in_value892);
					commonTree4 = (CommonTree)adaptor.Create(token3);
					adaptor.AddChild(commonTree, commonTree4);
					value_return.value = new ValueExpression(extractString(token3?.Text));
					break;
				case 4:
					commonTree = (CommonTree)adaptor.Nil();
					token4 = (IToken)Match(input, 4, Follow._DATETIME_in_value901);
					commonTree5 = (CommonTree)adaptor.Create(token4);
					adaptor.AddChild(commonTree, commonTree5);
					value_return.value = new ValueExpression(DateTime.Parse((token4?.Text).Substring(1, (token4?.Text).Length - 2)));
					break;
				case 5:
					commonTree = (CommonTree)adaptor.Nil();
					token5 = (IToken)Match(input, 16, Follow._TRUE_in_value908);
					commonTree6 = (CommonTree)adaptor.Create(token5);
					adaptor.AddChild(commonTree, commonTree6);
					value_return.value = new ValueExpression(value: true);
					break;
				case 6:
					commonTree = (CommonTree)adaptor.Nil();
					token6 = (IToken)Match(input, 8, Follow._FALSE_in_value916);
					commonTree7 = (CommonTree)adaptor.Create(token6);
					adaptor.AddChild(commonTree, commonTree7);
					value_return.value = new ValueExpression(value: false);
					break;
				}
				value_return.Stop = input.LT(-1);
				value_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(value_return.Tree, value_return.Start, value_return.Stop);
			}
			catch (RecognitionException ex2)
			{
				ReportError(ex2);
				Recover(input, ex2);
				value_return.Tree = (CommonTree)adaptor.ErrorNode(input, value_return.Start, input.LT(-1), ex2);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return value_return;
	}

	[GrammarRule("identifier")]
	private identifier_return identifier()
	{
		identifier_return identifier_return = new identifier_return();
		identifier_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		try
		{
			try
			{
				int num = 2;
				try
				{
					num = input.LA(1) switch
					{
						11 => 1, 
						14 => 2, 
						_ => throw new NoViableAltException("", 21, 0, input), 
					};
				}
				finally
				{
				}
				switch (num)
				{
				case 1:
					commonTree = (CommonTree)adaptor.Nil();
					token = (IToken)Match(input, 11, Follow._ID_in_identifier934);
					commonTree2 = (CommonTree)adaptor.Create(token);
					adaptor.AddChild(commonTree, commonTree2);
					identifier_return.value = new Identifier(token?.Text);
					break;
				case 2:
					commonTree = (CommonTree)adaptor.Nil();
					token2 = (IToken)Match(input, 14, Follow._NAME_in_identifier942);
					commonTree3 = (CommonTree)adaptor.Create(token2);
					adaptor.AddChild(commonTree, commonTree3);
					identifier_return.value = new Identifier((token2?.Text).Substring(1, (token2?.Text).Length - 2));
					break;
				}
				identifier_return.Stop = input.LT(-1);
				identifier_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(identifier_return.Tree, identifier_return.Start, identifier_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				identifier_return.Tree = (CommonTree)adaptor.ErrorNode(input, identifier_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return identifier_return;
	}

	[GrammarRule("expressionList")]
	private expressionList_return expressionList()
	{
		expressionList_return expressionList_return = new expressionList_return();
		expressionList_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		logicalExpression_return logicalExpression_return = null;
		logicalExpression_return logicalExpression_return2 = null;
		CommonTree commonTree2 = null;
		List<LogicalExpression> list = new List<LogicalExpression>();
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				PushFollow(Follow._logicalExpression_in_expressionList966);
				logicalExpression_return = logicalExpression();
				PopFollow();
				adaptor.AddChild(commonTree, logicalExpression_return.Tree);
				list.Add(logicalExpression_return?.value);
				try
				{
					while (true)
					{
						int num = 2;
						try
						{
							if (input.LA(1) == 28)
							{
								num = 1;
							}
						}
						finally
						{
						}
						if (num == 1)
						{
							token = (IToken)Match(input, 28, Follow._28_in_expressionList973);
							commonTree2 = (CommonTree)adaptor.Create(token);
							adaptor.AddChild(commonTree, commonTree2);
							PushFollow(Follow._logicalExpression_in_expressionList977);
							logicalExpression_return2 = logicalExpression();
							PopFollow();
							adaptor.AddChild(commonTree, logicalExpression_return2.Tree);
							list.Add(logicalExpression_return2?.value);
							continue;
						}
						break;
					}
				}
				finally
				{
				}
				expressionList_return.value = list;
				expressionList_return.Stop = input.LT(-1);
				expressionList_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(expressionList_return.Tree, expressionList_return.Start, expressionList_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				expressionList_return.Tree = (CommonTree)adaptor.ErrorNode(input, expressionList_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return expressionList_return;
	}

	[GrammarRule("arguments")]
	private arguments_return arguments()
	{
		arguments_return arguments_return = new arguments_return();
		arguments_return.Start = input.LT(1);
		CommonTree commonTree = null;
		IToken token = null;
		IToken token2 = null;
		expressionList_return expressionList_return = null;
		CommonTree commonTree2 = null;
		CommonTree commonTree3 = null;
		arguments_return.value = new List<LogicalExpression>();
		try
		{
			try
			{
				commonTree = (CommonTree)adaptor.Nil();
				token = (IToken)Match(input, 24, Follow._24_in_arguments1006);
				commonTree2 = (CommonTree)adaptor.Create(token);
				adaptor.AddChild(commonTree, commonTree2);
				int num = 2;
				try
				{
					try
					{
						int num2 = input.LA(1);
						switch (num2)
						{
						default:
							if ((num2 >= 11 && num2 <= 12) || (num2 >= 14 && num2 <= 16) || num2 == 19 || num2 == 24 || num2 == 29 || num2 == 44 || num2 == 48)
							{
								break;
							}
							goto end_IL_0080;
						case 4:
						case 8:
						case 9:
							break;
						}
						num = 1;
						end_IL_0080:;
					}
					finally
					{
					}
					if (num == 1)
					{
						PushFollow(Follow._expressionList_in_arguments1010);
						expressionList_return = expressionList();
						PopFollow();
						adaptor.AddChild(commonTree, expressionList_return.Tree);
						arguments_return.value = expressionList_return?.value;
					}
				}
				finally
				{
				}
				token2 = (IToken)Match(input, 25, Follow._25_in_arguments1017);
				commonTree3 = (CommonTree)adaptor.Create(token2);
				adaptor.AddChild(commonTree, commonTree3);
				arguments_return.Stop = input.LT(-1);
				arguments_return.Tree = (CommonTree)adaptor.RulePostProcessing(commonTree);
				adaptor.SetTokenBoundaries(arguments_return.Tree, arguments_return.Start, arguments_return.Stop);
			}
			catch (RecognitionException ex)
			{
				ReportError(ex);
				Recover(input, ex);
				arguments_return.Tree = (CommonTree)adaptor.ErrorNode(input, arguments_return.Start, input.LT(-1), ex);
			}
			finally
			{
			}
		}
		finally
		{
		}
		return arguments_return;
	}
}
namespace System
{
	public static class TypeExtensions
	{
		private static readonly Dictionary<Type, TypeCode> TypeCodeMap = new Dictionary<Type, TypeCode>
		{
			{
				typeof(bool),
				TypeCode.Boolean
			},
			{
				typeof(byte),
				TypeCode.Byte
			},
			{
				typeof(sbyte),
				TypeCode.SByte
			},
			{
				typeof(char),
				TypeCode.Char
			},
			{
				typeof(DateTime),
				TypeCode.DateTime
			},
			{
				typeof(decimal),
				TypeCode.Decimal
			},
			{
				typeof(double),
				TypeCode.Double
			},
			{
				typeof(float),
				TypeCode.Single
			},
			{
				typeof(short),
				TypeCode.Int16
			},
			{
				typeof(int),
				TypeCode.Int32
			},
			{
				typeof(long),
				TypeCode.Int64
			},
			{
				typeof(ushort),
				TypeCode.UInt16
			},
			{
				typeof(uint),
				TypeCode.UInt32
			},
			{
				typeof(ulong),
				TypeCode.UInt64
			},
			{
				typeof(string),
				TypeCode.String
			}
		};

		public static TypeCode GetTypeCode(this object obj)
		{
			return obj?.GetType().ToTypeCode() ?? TypeCode.Empty;
		}

		public static TypeCode ToTypeCode(this Type type)
		{
			if (type == null)
			{
				return TypeCode.Empty;
			}
			if (!TypeCodeMap.TryGetValue(type, out var value))
			{
				return TypeCode.Object;
			}
			return value;
		}
	}
}
namespace NCalc
{
	public delegate void EvaluateFunctionHandler(string name, FunctionArgs args);
	public delegate void EvaluateParameterHandler(string name, ParameterArgs args);
	public class EvaluationException : Exception
	{
		public EvaluationException(string message)
			: base(message)
		{
		}

		public EvaluationException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	[Flags]
	public enum EvaluateOptions
	{
		None = 1,
		IgnoreCase = 2,
		NoCache = 4,
		IterateParameters = 8,
		RoundAwayFromZero = 0x10,
		MatchStringsWithIgnoreCase = 0x20,
		MatchStringsOrdinal = 0x40,
		OverflowProtection = 0x80,
		BooleanCalculation = 0x100,
		UseDoubleForAbsFunction = 0x200,
		AllowNullParameter = 0x400
	}
	public class Expression
	{
		protected string OriginalExpression;

		private static bool _cacheEnabled = true;

		private static ConcurrentDictionary<string, WeakReference> _compiledExpressions = new ConcurrentDictionary<string, WeakReference>();

		protected Dictionary<string, IEnumerator> ParameterEnumerators;

		protected Dictionary<string, object> ParametersBackup;

		private Dictionary<string, object> _parameters;

		public EvaluateOptions Options { get; set; }

		public static bool CacheEnabled
		{
			get
			{
				return _cacheEnabled;
			}
			set
			{
				_cacheEnabled = value;
				if (!CacheEnabled)
				{
					_compiledExpressions = new ConcurrentDictionary<string, WeakReference>();
				}
			}
		}

		public string Error { get; private set; }

		public Exception ErrorException { get; private set; }

		public LogicalExpression ParsedExpression { get; private set; }

		public Dictionary<string, object> Parameters
		{
			get
			{
				return _parameters ?? (_parameters = new Dictionary<string, object>());
			}
			set
			{
				_parameters = value;
			}
		}

		public event EvaluateFunctionHandler EvaluateFunction;

		public event EvaluateParameterHandler EvaluateParameter;

		public Expression(string expression)
			: this(expression, EvaluateOptions.None)
		{
		}

		public Expression(string expression, EvaluateOptions options)
		{
			if (string.IsNullOrEmpty(expression))
			{
				throw new ArgumentException("Expression can't be empty", "expression");
			}
			OriginalExpression = expression;
			Options = options;
		}

		public Expression(LogicalExpression expression)
			: this(expression, EvaluateOptions.None)
		{
		}

		public Expression(LogicalExpression expression, EvaluateOptions options)
		{
			if (expression == null)
			{
				throw new ArgumentException("Expression can't be null", "expression");
			}
			ParsedExpression = expression;
			Options = options;
		}

		private static void CleanCache()
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, WeakReference> compiledExpression in _compiledExpressions)
			{
				if (!compiledExpression.Value.IsAlive)
				{
					list.Add(compiledExpression.Key);
				}
			}
			foreach (string item in list)
			{
				_compiledExpressions.TryRemove(item, out var _);
			}
		}

		public static LogicalExpression Compile(string expression, bool nocache)
		{
			LogicalExpression logicalExpression = null;
			if (_cacheEnabled && !nocache && _compiledExpressions.ContainsKey(expression) && _compiledExpressions.TryGetValue(expression, out var value))
			{
				logicalExpression = value.Target as LogicalExpression;
				if (value.IsAlive && logicalExpression != null)
				{
					return logicalExpression;
				}
			}
			if (logicalExpression == null)
			{
				NCalcParser nCalcParser = new NCalcParser(new CommonTokenStream(new NCalcLexer(new ANTLRStringStream(expression))));
				logicalExpression = nCalcParser.ncalcExpression().value;
				if (nCalcParser.Errors != null && nCalcParser.Errors.Count > 0)
				{
					throw new EvaluationException(string.Join(Environment.NewLine, nCalcParser.Errors.ToArray()));
				}
				if (_cacheEnabled && !nocache)
				{
					try
					{
						if (_compiledExpressions.TryGetValue(expression, out var value2))
						{
							_compiledExpressions.TryUpdate(expression, new WeakReference(logicalExpression), value2);
						}
						else
						{
							_compiledExpressions.TryAdd(expression, new WeakReference(logicalExpression));
						}
					}
					finally
					{
						CleanCache();
					}
				}
			}
			return logicalExpression