plc4net/tools/code-gen/src/generated/ExpressionParser.cs

//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 4.13.2
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// Generated from code-generation/protocol-base-mspec/src/main/antlr4/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/Expression.g4 by ANTLR 4.13.2

// Unreachable code detected
#pragma warning disable 0162
// The variable '...' is assigned but its value is never used
#pragma warning disable 0219
// Missing XML comment for publicly visible type or member '...'
#pragma warning disable 1591
// Ambiguous reference in cref attribute
#pragma warning disable 419

namespace org.apache.plc4net.tools.codegen.grammar {
using System;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Collections.Generic;
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Antlr4.Runtime.Tree;
using DFA = Antlr4.Runtime.Dfa.DFA;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.13.2")]
[System.CLSCompliant(false)]
public partial class ExpressionParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
		T__24=25, T__25=26, T__26=27, Null=28, Bool=29, Number=30, Identifier=31, 
		String=32, Space=33, HexExpression=34;
	public const int
		RULE_expressionString = 0, RULE_expression = 1, RULE_identifierSegment = 2, 
		RULE_identifierSegmentArguments = 3, RULE_identifierSegmentIndexes = 4, 
		RULE_identifierSegmentRest = 5, RULE_arguments = 6, RULE_indexes = 7;
	public static readonly string[] ruleNames = {
		"expressionString", "expression", "identifierSegment", "identifierSegmentArguments", 
		"identifierSegmentIndexes", "identifierSegmentRest", "arguments", "indexes"
	};

	private static readonly string[] _LiteralNames = {
		null, "'-'", "'!'", "'^'", "'*'", "'/'", "'%'", "'+'", "'>>'", "'<<'", 
		"'>='", "'<='", "'>'", "'<'", "'=='", "'!='", "'&&'", "'&'", "'||'", "'|'", 
		"'?'", "':'", "'('", "')'", "'.'", "','", "'['", "']'", "'null'"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, "Null", "Bool", "Number", "Identifier", "String", 
		"Space", "HexExpression"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

	[NotNull]
	public override IVocabulary Vocabulary
	{
		get
		{
			return DefaultVocabulary;
		}
	}

	public override string GrammarFileName { get { return "Expression.g4"; } }

	public override string[] RuleNames { get { return ruleNames; } }

	public override int[] SerializedAtn { get { return _serializedATN; } }

	static ExpressionParser() {
		decisionToDFA = new DFA[_ATN.NumberOfDecisions];
		for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
			decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
		}
	}

		public ExpressionParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }

		public ExpressionParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
		: base(input, output, errorOutput)
	{
		Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
	}

	public partial class ExpressionStringContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(ExpressionParser.Eof, 0); }
		public ExpressionStringContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expressionString; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterExpressionString(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitExpressionString(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionStringContext expressionString() {
		ExpressionStringContext _localctx = new ExpressionStringContext(Context, State);
		EnterRule(_localctx, 0, RULE_expressionString);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 16;
			expression(0);
			State = 17;
			Match(Eof);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExpressionContext : ParserRuleContext {
		public ExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expression; } }
	 
		public ExpressionContext() { }
		public virtual void CopyFrom(ExpressionContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class HexExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HexExpression() { return GetToken(ExpressionParser.HexExpression, 0); }
		public HexExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterHexExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitHexExpression(this);
		}
	}
	public partial class BitShiftExpressionContext : ExpressionContext {
		public IToken op;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitShiftExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterBitShiftExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitBitShiftExpression(this);
		}
	}
	public partial class BoolExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Bool() { return GetToken(ExpressionParser.Bool, 0); }
		public BoolExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterBoolExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitBoolExpression(this);
		}
	}
	public partial class BitOrExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitOrExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterBitOrExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitBitOrExpression(this);
		}
	}
	public partial class NumberExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Number() { return GetToken(ExpressionParser.Number, 0); }
		public NumberExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterNumberExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitNumberExpression(this);
		}
	}
	public partial class IdentifierExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public IdentifierSegmentContext identifierSegment() {
			return GetRuleContext<IdentifierSegmentContext>(0);
		}
		public IdentifierExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterIdentifierExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitIdentifierExpression(this);
		}
	}
	public partial class NotExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public NotExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterNotExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitNotExpression(this);
		}
	}
	public partial class OrExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public OrExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterOrExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitOrExpression(this);
		}
	}
	public partial class UnaryMinusExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public UnaryMinusExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterUnaryMinusExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitUnaryMinusExpression(this);
		}
	}
	public partial class PowerExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public PowerExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterPowerExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitPowerExpression(this);
		}
	}
	public partial class EqExpressionContext : ExpressionContext {
		public IToken op;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public EqExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterEqExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitEqExpression(this);
		}
	}
	public partial class AndExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public AndExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterAndExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitAndExpression(this);
		}
	}
	public partial class StringExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode String() { return GetToken(ExpressionParser.String, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IndexesContext indexes() {
			return GetRuleContext<IndexesContext>(0);
		}
		public StringExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterStringExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitStringExpression(this);
		}
	}
	public partial class BitAndExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitAndExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterBitAndExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitBitAndExpression(this);
		}
	}
	public partial class ExpressionExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IndexesContext indexes() {
			return GetRuleContext<IndexesContext>(0);
		}
		public ExpressionExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterExpressionExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitExpressionExpression(this);
		}
	}
	public partial class AddExpressionContext : ExpressionContext {
		public IToken op;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public AddExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterAddExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitAddExpression(this);
		}
	}
	public partial class CompExpressionContext : ExpressionContext {
		public IToken op;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public CompExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterCompExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitCompExpression(this);
		}
	}
	public partial class NullExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Null() { return GetToken(ExpressionParser.Null, 0); }
		public NullExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterNullExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitNullExpression(this);
		}
	}
	public partial class MultExpressionContext : ExpressionContext {
		public IToken op;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public MultExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterMultExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitMultExpression(this);
		}
	}
	public partial class IfExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public IfExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterIfExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitIfExpression(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionContext expression() {
		return expression(0);
	}

	private ExpressionContext expression(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		ExpressionContext _localctx = new ExpressionContext(Context, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 2;
		EnterRecursionRule(_localctx, 2, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 39;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
				{
				_localctx = new UnaryMinusExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;

				State = 20;
				Match(T__0);
				State = 21;
				expression(20);
				}
				break;
			case T__1:
				{
				_localctx = new NotExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 22;
				Match(T__1);
				State = 23;
				expression(19);
				}
				break;
			case Number:
				{
				_localctx = new NumberExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 24;
				Match(Number);
				}
				break;
			case HexExpression:
				{
				_localctx = new HexExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 25;
				Match(HexExpression);
				}
				break;
			case Bool:
				{
				_localctx = new BoolExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 26;
				Match(Bool);
				}
				break;
			case Null:
				{
				_localctx = new NullExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 27;
				Match(Null);
				}
				break;
			case Identifier:
				{
				_localctx = new IdentifierExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 28;
				identifierSegment();
				}
				break;
			case String:
				{
				_localctx = new StringExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 29;
				Match(String);
				State = 31;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,0,Context) ) {
				case 1:
					{
					State = 30;
					indexes();
					}
					break;
				}
				}
				break;
			case T__21:
				{
				_localctx = new ExpressionExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 33;
				Match(T__21);
				State = 34;
				expression(0);
				State = 35;
				Match(T__22);
				State = 37;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) {
				case 1:
					{
					State = 36;
					indexes();
					}
					break;
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			Context.Stop = TokenStream.LT(-1);
			State = 79;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,4,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 77;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,3,Context) ) {
					case 1:
						{
						_localctx = new PowerExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 41;
						if (!(Precpred(Context, 18))) throw new FailedPredicateException(this, "Precpred(Context, 18)");
						State = 42;
						Match(T__2);
						State = 43;
						expression(18);
						}
						break;
					case 2:
						{
						_localctx = new MultExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 44;
						if (!(Precpred(Context, 17))) throw new FailedPredicateException(this, "Precpred(Context, 17)");
						State = 45;
						((MultExpressionContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 112L) != 0)) ) {
							((MultExpressionContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 46;
						expression(18);
						}
						break;
					case 3:
						{
						_localctx = new AddExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 47;
						if (!(Precpred(Context, 16))) throw new FailedPredicateException(this, "Precpred(Context, 16)");
						State = 48;
						((AddExpressionContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !(_la==T__0 || _la==T__6) ) {
							((AddExpressionContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 49;
						expression(17);
						}
						break;
					case 4:
						{
						_localctx = new BitShiftExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 50;
						if (!(Precpred(Context, 15))) throw new FailedPredicateException(this, "Precpred(Context, 15)");
						State = 51;
						((BitShiftExpressionContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !(_la==T__7 || _la==T__8) ) {
							((BitShiftExpressionContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 52;
						expression(16);
						}
						break;
					case 5:
						{
						_localctx = new CompExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 53;
						if (!(Precpred(Context, 14))) throw new FailedPredicateException(this, "Precpred(Context, 14)");
						State = 54;
						((CompExpressionContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 15360L) != 0)) ) {
							((CompExpressionContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 55;
						expression(15);
						}
						break;
					case 6:
						{
						_localctx = new EqExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 56;
						if (!(Precpred(Context, 13))) throw new FailedPredicateException(this, "Precpred(Context, 13)");
						State = 57;
						((EqExpressionContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !(_la==T__13 || _la==T__14) ) {
							((EqExpressionContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 58;
						expression(14);
						}
						break;
					case 7:
						{
						_localctx = new AndExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 59;
						if (!(Precpred(Context, 12))) throw new FailedPredicateException(this, "Precpred(Context, 12)");
						State = 60;
						Match(T__15);
						State = 61;
						expression(13);
						}
						break;
					case 8:
						{
						_localctx = new BitAndExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 62;
						if (!(Precpred(Context, 11))) throw new FailedPredicateException(this, "Precpred(Context, 11)");
						State = 63;
						Match(T__16);
						State = 64;
						expression(12);
						}
						break;
					case 9:
						{
						_localctx = new OrExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 65;
						if (!(Precpred(Context, 10))) throw new FailedPredicateException(this, "Precpred(Context, 10)");
						State = 66;
						Match(T__17);
						State = 67;
						expression(11);
						}
						break;
					case 10:
						{
						_localctx = new BitOrExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 68;
						if (!(Precpred(Context, 9))) throw new FailedPredicateException(this, "Precpred(Context, 9)");
						State = 69;
						Match(T__18);
						State = 70;
						expression(10);
						}
						break;
					case 11:
						{
						_localctx = new IfExpressionContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 71;
						if (!(Precpred(Context, 8))) throw new FailedPredicateException(this, "Precpred(Context, 8)");
						State = 72;
						Match(T__19);
						State = 73;
						expression(0);
						State = 74;
						Match(T__20);
						State = 75;
						expression(9);
						}
						break;
					}
					} 
				}
				State = 81;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,4,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public partial class IdentifierSegmentContext : ParserRuleContext {
		public IToken name;
		public IdentifierSegmentArgumentsContext args;
		public IdentifierSegmentIndexesContext index;
		public IdentifierSegmentRestContext rest;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Identifier() { return GetToken(ExpressionParser.Identifier, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IdentifierSegmentArgumentsContext identifierSegmentArguments() {
			return GetRuleContext<IdentifierSegmentArgumentsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdentifierSegmentIndexesContext identifierSegmentIndexes() {
			return GetRuleContext<IdentifierSegmentIndexesContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdentifierSegmentRestContext identifierSegmentRest() {
			return GetRuleContext<IdentifierSegmentRestContext>(0);
		}
		public IdentifierSegmentContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_identifierSegment; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterIdentifierSegment(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitIdentifierSegment(this);
		}
	}

	[RuleVersion(0)]
	public IdentifierSegmentContext identifierSegment() {
		IdentifierSegmentContext _localctx = new IdentifierSegmentContext(Context, State);
		EnterRule(_localctx, 4, RULE_identifierSegment);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 82;
			_localctx.name = Match(Identifier);
			State = 84;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) {
			case 1:
				{
				State = 83;
				_localctx.args = identifierSegmentArguments();
				}
				break;
			}
			State = 87;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,6,Context) ) {
			case 1:
				{
				State = 86;
				_localctx.index = identifierSegmentIndexes();
				}
				break;
			}
			State = 91;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) {
			case 1:
				{
				State = 89;
				Match(T__23);
				State = 90;
				_localctx.rest = identifierSegmentRest();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IdentifierSegmentArgumentsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ArgumentsContext arguments() {
			return GetRuleContext<ArgumentsContext>(0);
		}
		public IdentifierSegmentArgumentsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_identifierSegmentArguments; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterIdentifierSegmentArguments(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitIdentifierSegmentArguments(this);
		}
	}

	[RuleVersion(0)]
	public IdentifierSegmentArgumentsContext identifierSegmentArguments() {
		IdentifierSegmentArgumentsContext _localctx = new IdentifierSegmentArgumentsContext(Context, State);
		EnterRule(_localctx, 6, RULE_identifierSegmentArguments);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 93;
			arguments();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IdentifierSegmentIndexesContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public IndexesContext indexes() {
			return GetRuleContext<IndexesContext>(0);
		}
		public IdentifierSegmentIndexesContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_identifierSegmentIndexes; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterIdentifierSegmentIndexes(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitIdentifierSegmentIndexes(this);
		}
	}

	[RuleVersion(0)]
	public IdentifierSegmentIndexesContext identifierSegmentIndexes() {
		IdentifierSegmentIndexesContext _localctx = new IdentifierSegmentIndexesContext(Context, State);
		EnterRule(_localctx, 8, RULE_identifierSegmentIndexes);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 95;
			indexes();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IdentifierSegmentRestContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public IdentifierSegmentContext identifierSegment() {
			return GetRuleContext<IdentifierSegmentContext>(0);
		}
		public IdentifierSegmentRestContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_identifierSegmentRest; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterIdentifierSegmentRest(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitIdentifierSegmentRest(this);
		}
	}

	[RuleVersion(0)]
	public IdentifierSegmentRestContext identifierSegmentRest() {
		IdentifierSegmentRestContext _localctx = new IdentifierSegmentRestContext(Context, State);
		EnterRule(_localctx, 10, RULE_identifierSegmentRest);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 97;
			identifierSegment();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ArgumentsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ArgumentsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_arguments; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterArguments(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitArguments(this);
		}
	}

	[RuleVersion(0)]
	public ArgumentsContext arguments() {
		ArgumentsContext _localctx = new ArgumentsContext(Context, State);
		EnterRule(_localctx, 12, RULE_arguments);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 99;
			Match(T__21);
			State = 108;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 25505562630L) != 0)) {
				{
				State = 100;
				expression(0);
				State = 105;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__24) {
					{
					{
					State = 101;
					Match(T__24);
					State = 102;
					expression(0);
					}
					}
					State = 107;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				}
			}

			State = 110;
			Match(T__22);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IndexesContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public IndexesContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_indexes; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.EnterIndexes(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IExpressionListener typedListener = listener as IExpressionListener;
			if (typedListener != null) typedListener.ExitIndexes(this);
		}
	}

	[RuleVersion(0)]
	public IndexesContext indexes() {
		IndexesContext _localctx = new IndexesContext(Context, State);
		EnterRule(_localctx, 14, RULE_indexes);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 116;
			ErrorHandler.Sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					State = 112;
					Match(T__25);
					State = 113;
					expression(0);
					State = 114;
					Match(T__26);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				State = 118;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,10,Context);
			} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 1: return expression_sempred((ExpressionContext)_localctx, predIndex);
		}
		return true;
	}
	private bool expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return Precpred(Context, 18);
		case 1: return Precpred(Context, 17);
		case 2: return Precpred(Context, 16);
		case 3: return Precpred(Context, 15);
		case 4: return Precpred(Context, 14);
		case 5: return Precpred(Context, 13);
		case 6: return Precpred(Context, 12);
		case 7: return Precpred(Context, 11);
		case 8: return Precpred(Context, 10);
		case 9: return Precpred(Context, 9);
		case 10: return Precpred(Context, 8);
		}
		return true;
	}

	private static int[] _serializedATN = {
		4,1,34,121,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7,
		7,7,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,32,
		8,1,1,1,1,1,1,1,1,1,3,1,38,8,1,3,1,40,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,78,8,1,10,1,12,1,81,
		9,1,1,2,1,2,3,2,85,8,2,1,2,3,2,88,8,2,1,2,1,2,3,2,92,8,2,1,3,1,3,1,4,1,
		4,1,5,1,5,1,6,1,6,1,6,1,6,5,6,104,8,6,10,6,12,6,107,9,6,3,6,109,8,6,1,
		6,1,6,1,7,1,7,1,7,1,7,4,7,117,8,7,11,7,12,7,118,1,7,0,1,2,8,0,2,4,6,8,
		10,12,14,0,5,1,0,4,6,2,0,1,1,7,7,1,0,8,9,1,0,10,13,1,0,14,15,139,0,16,
		1,0,0,0,2,39,1,0,0,0,4,82,1,0,0,0,6,93,1,0,0,0,8,95,1,0,0,0,10,97,1,0,
		0,0,12,99,1,0,0,0,14,116,1,0,0,0,16,17,3,2,1,0,17,18,5,0,0,1,18,1,1,0,
		0,0,19,20,6,1,-1,0,20,21,5,1,0,0,21,40,3,2,1,20,22,23,5,2,0,0,23,40,3,
		2,1,19,24,40,5,30,0,0,25,40,5,34,0,0,26,40,5,29,0,0,27,40,5,28,0,0,28,
		40,3,4,2,0,29,31,5,32,0,0,30,32,3,14,7,0,31,30,1,0,0,0,31,32,1,0,0,0,32,
		40,1,0,0,0,33,34,5,22,0,0,34,35,3,2,1,0,35,37,5,23,0,0,36,38,3,14,7,0,
		37,36,1,0,0,0,37,38,1,0,0,0,38,40,1,0,0,0,39,19,1,0,0,0,39,22,1,0,0,0,
		39,24,1,0,0,0,39,25,1,0,0,0,39,26,1,0,0,0,39,27,1,0,0,0,39,28,1,0,0,0,
		39,29,1,0,0,0,39,33,1,0,0,0,40,79,1,0,0,0,41,42,10,18,0,0,42,43,5,3,0,
		0,43,78,3,2,1,18,44,45,10,17,0,0,45,46,7,0,0,0,46,78,3,2,1,18,47,48,10,
		16,0,0,48,49,7,1,0,0,49,78,3,2,1,17,50,51,10,15,0,0,51,52,7,2,0,0,52,78,
		3,2,1,16,53,54,10,14,0,0,54,55,7,3,0,0,55,78,3,2,1,15,56,57,10,13,0,0,
		57,58,7,4,0,0,58,78,3,2,1,14,59,60,10,12,0,0,60,61,5,16,0,0,61,78,3,2,
		1,13,62,63,10,11,0,0,63,64,5,17,0,0,64,78,3,2,1,12,65,66,10,10,0,0,66,
		67,5,18,0,0,67,78,3,2,1,11,68,69,10,9,0,0,69,70,5,19,0,0,70,78,3,2,1,10,
		71,72,10,8,0,0,72,73,5,20,0,0,73,74,3,2,1,0,74,75,5,21,0,0,75,76,3,2,1,
		9,76,78,1,0,0,0,77,41,1,0,0,0,77,44,1,0,0,0,77,47,1,0,0,0,77,50,1,0,0,
		0,77,53,1,0,0,0,77,56,1,0,0,0,77,59,1,0,0,0,77,62,1,0,0,0,77,65,1,0,0,
		0,77,68,1,0,0,0,77,71,1,0,0,0,78,81,1,0,0,0,79,77,1,0,0,0,79,80,1,0,0,
		0,80,3,1,0,0,0,81,79,1,0,0,0,82,84,5,31,0,0,83,85,3,6,3,0,84,83,1,0,0,
		0,84,85,1,0,0,0,85,87,1,0,0,0,86,88,3,8,4,0,87,86,1,0,0,0,87,88,1,0,0,
		0,88,91,1,0,0,0,89,90,5,24,0,0,90,92,3,10,5,0,91,89,1,0,0,0,91,92,1,0,
		0,0,92,5,1,0,0,0,93,94,3,12,6,0,94,7,1,0,0,0,95,96,3,14,7,0,96,9,1,0,0,
		0,97,98,3,4,2,0,98,11,1,0,0,0,99,108,5,22,0,0,100,105,3,2,1,0,101,102,
		5,25,0,0,102,104,3,2,1,0,103,101,1,0,0,0,104,107,1,0,0,0,105,103,1,0,0,
		0,105,106,1,0,0,0,106,109,1,0,0,0,107,105,1,0,0,0,108,100,1,0,0,0,108,
		109,1,0,0,0,109,110,1,0,0,0,110,111,5,23,0,0,111,13,1,0,0,0,112,113,5,
		26,0,0,113,114,3,2,1,0,114,115,5,27,0,0,115,117,1,0,0,0,116,112,1,0,0,
		0,117,118,1,0,0,0,118,116,1,0,0,0,118,119,1,0,0,0,119,15,1,0,0,0,11,31,
		37,39,77,79,84,87,91,105,108,118
	};

	public static readonly ATN _ATN =
		new ATNDeserializer().Deserialize(_serializedATN);


}
} // namespace org.apache.plc4net.tools.codegen.grammar