// Generated from /Users/sdiemert/workspace/certus/typescript/src/antlr/Certus.g4 by ANTLR 4.13.1
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class CertusParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final 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, ARROW=15, ASSIGN=16, 
		HAS=17, CONTAIN=18, OVERLAP=19, EXACTLY=20, UNION=21, INTERSECT=22, WITH=23, 
		GLOBAL=24, END=25, AS=26, NOT=27, INVERT=28, COMP=29, AND=30, OR=31, NEQ=32, 
		EQ=33, GT=34, LT=35, GEQ=36, LEQ=37, MACRO_PREFIX=38, INDICATOR_PREFIX=39, 
		ARTIFACT_PREFIX=40, CASES=41, OTHERWISE=42, FLOAT=43, ARG_SEP=44, STMT_SEP=45, 
		ID=46, WS=47;
	public static final int
		RULE_start = 0, RULE_localBind = 1, RULE_globalBind = 2, RULE_assignment = 3, 
		RULE_definition = 4, RULE_opDef = 5, RULE_opTypedParam = 6, RULE_nodeType = 7, 
		RULE_booleanExpr = 8, RULE_indicator = 9, RULE_indicatorCategory = 10, 
		RULE_indicatorExpr = 11, RULE_artifact = 12, RULE_artifactExpr = 13, RULE_casesExpr = 14, 
		RULE_case = 15, RULE_macroExpr = 16, RULE_fuzzyExpr = 17, RULE_invokedOp = 18, 
		RULE_fuzzySym = 19, RULE_builtInOp = 20, RULE_minOp = 21, RULE_maxOp = 22, 
		RULE_invertOp = 23, RULE_compOp = 24, RULE_defineSet = 25, RULE_setTrap = 26, 
		RULE_setTri = 27, RULE_setUp = 28, RULE_setDown = 29, RULE_setConst = 30, 
		RULE_setCrisp = 31;
	private static String[] makeRuleNames() {
		return new String[] {
			"start", "localBind", "globalBind", "assignment", "definition", "opDef", 
			"opTypedParam", "nodeType", "booleanExpr", "indicator", "indicatorCategory", 
			"indicatorExpr", "artifact", "artifactExpr", "casesExpr", "case", "macroExpr", 
			"fuzzyExpr", "invokedOp", "fuzzySym", "builtInOp", "minOp", "maxOp", 
			"invertOp", "compOp", "defineSet", "setTrap", "setTri", "setUp", "setDown", 
			"setConst", "setCrisp"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'('", "')'", "':'", "'\"'", "'min'", "'max'", "'trap'", "'tri'", 
			"'up'", "'down'", "'const'", "'['", "']'", "'crisp'", "'->'", 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, "','", "';'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, "ARROW", "ASSIGN", "HAS", "CONTAIN", "OVERLAP", "EXACTLY", 
			"UNION", "INTERSECT", "WITH", "GLOBAL", "END", "AS", "NOT", "INVERT", 
			"COMP", "AND", "OR", "NEQ", "EQ", "GT", "LT", "GEQ", "LEQ", "MACRO_PREFIX", 
			"INDICATOR_PREFIX", "ARTIFACT_PREFIX", "CASES", "OTHERWISE", "FLOAT", 
			"ARG_SEP", "STMT_SEP", "ID", "WS"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "Certus.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public CertusParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StartContext extends ParserRuleContext {
		public GlobalBindContext globalBind() {
			return getRuleContext(GlobalBindContext.class,0);
		}
		public TerminalNode EOF() { return getToken(CertusParser.EOF, 0); }
		public LocalBindContext localBind() {
			return getRuleContext(LocalBindContext.class,0);
		}
		public AssignmentContext assignment() {
			return getRuleContext(AssignmentContext.class,0);
		}
		public StartContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_start; }
	}

	public final StartContext start() throws RecognitionException {
		StartContext _localctx = new StartContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_start);
		try {
			setState(74);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case GLOBAL:
				enterOuterAlt(_localctx, 1);
				{
				setState(64);
				globalBind();
				setState(65);
				match(EOF);
				}
				break;
			case WITH:
				enterOuterAlt(_localctx, 2);
				{
				setState(67);
				localBind();
				setState(68);
				assignment();
				setState(69);
				match(EOF);
				}
				break;
			case ID:
				enterOuterAlt(_localctx, 3);
				{
				setState(71);
				assignment();
				setState(72);
				match(EOF);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LocalBindContext extends ParserRuleContext {
		public TerminalNode WITH() { return getToken(CertusParser.WITH, 0); }
		public List<DefinitionContext> definition() {
			return getRuleContexts(DefinitionContext.class);
		}
		public DefinitionContext definition(int i) {
			return getRuleContext(DefinitionContext.class,i);
		}
		public TerminalNode END() { return getToken(CertusParser.END, 0); }
		public List<TerminalNode> STMT_SEP() { return getTokens(CertusParser.STMT_SEP); }
		public TerminalNode STMT_SEP(int i) {
			return getToken(CertusParser.STMT_SEP, i);
		}
		public LocalBindContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_localBind; }
	}

	public final LocalBindContext localBind() throws RecognitionException {
		LocalBindContext _localctx = new LocalBindContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_localBind);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(76);
			match(WITH);
			setState(77);
			definition();
			setState(82);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(78);
					match(STMT_SEP);
					setState(79);
					definition();
					}
					} 
				}
				setState(84);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
			}
			setState(86);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STMT_SEP) {
				{
				setState(85);
				match(STMT_SEP);
				}
			}

			setState(88);
			match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class GlobalBindContext extends ParserRuleContext {
		public TerminalNode GLOBAL() { return getToken(CertusParser.GLOBAL, 0); }
		public List<DefinitionContext> definition() {
			return getRuleContexts(DefinitionContext.class);
		}
		public DefinitionContext definition(int i) {
			return getRuleContext(DefinitionContext.class,i);
		}
		public TerminalNode END() { return getToken(CertusParser.END, 0); }
		public List<TerminalNode> STMT_SEP() { return getTokens(CertusParser.STMT_SEP); }
		public TerminalNode STMT_SEP(int i) {
			return getToken(CertusParser.STMT_SEP, i);
		}
		public GlobalBindContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_globalBind; }
	}

	public final GlobalBindContext globalBind() throws RecognitionException {
		GlobalBindContext _localctx = new GlobalBindContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_globalBind);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(90);
			match(GLOBAL);
			setState(91);
			definition();
			setState(96);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(92);
					match(STMT_SEP);
					setState(93);
					definition();
					}
					} 
				}
				setState(98);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			}
			setState(100);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STMT_SEP) {
				{
				setState(99);
				match(STMT_SEP);
				}
			}

			setState(102);
			match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AssignmentContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public TerminalNode ASSIGN() { return getToken(CertusParser.ASSIGN, 0); }
		public FuzzyExprContext fuzzyExpr() {
			return getRuleContext(FuzzyExprContext.class,0);
		}
		public MacroExprContext macroExpr() {
			return getRuleContext(MacroExprContext.class,0);
		}
		public AssignmentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignment; }
	}

	public final AssignmentContext assignment() throws RecognitionException {
		AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_assignment);
		try {
			setState(110);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(104);
				match(ID);
				setState(105);
				match(ASSIGN);
				setState(106);
				fuzzyExpr(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(107);
				match(ID);
				setState(108);
				match(ASSIGN);
				setState(109);
				macroExpr();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DefinitionContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public TerminalNode AS() { return getToken(CertusParser.AS, 0); }
		public FuzzyExprContext fuzzyExpr() {
			return getRuleContext(FuzzyExprContext.class,0);
		}
		public OpDefContext opDef() {
			return getRuleContext(OpDefContext.class,0);
		}
		public DefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_definition; }
	}

	public final DefinitionContext definition() throws RecognitionException {
		DefinitionContext _localctx = new DefinitionContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_definition);
		try {
			setState(119);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(112);
				match(ID);
				setState(113);
				match(AS);
				setState(114);
				fuzzyExpr(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(115);
				opDef();
				setState(116);
				match(AS);
				setState(117);
				fuzzyExpr(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OpDefContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public List<OpTypedParamContext> opTypedParam() {
			return getRuleContexts(OpTypedParamContext.class);
		}
		public OpTypedParamContext opTypedParam(int i) {
			return getRuleContext(OpTypedParamContext.class,i);
		}
		public List<TerminalNode> ARG_SEP() { return getTokens(CertusParser.ARG_SEP); }
		public TerminalNode ARG_SEP(int i) {
			return getToken(CertusParser.ARG_SEP, i);
		}
		public OpDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opDef; }
	}

	public final OpDefContext opDef() throws RecognitionException {
		OpDefContext _localctx = new OpDefContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_opDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(121);
			match(ID);
			setState(122);
			match(T__0);
			setState(123);
			opTypedParam();
			setState(128);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==ARG_SEP) {
				{
				{
				setState(124);
				match(ARG_SEP);
				setState(125);
				opTypedParam();
				}
				}
				setState(130);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(131);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OpTypedParamContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public NodeTypeContext nodeType() {
			return getRuleContext(NodeTypeContext.class,0);
		}
		public OpTypedParamContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opTypedParam; }
	}

	public final OpTypedParamContext opTypedParam() throws RecognitionException {
		OpTypedParamContext _localctx = new OpTypedParamContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_opTypedParam);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(133);
			match(ID);
			setState(134);
			match(T__2);
			setState(135);
			nodeType();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NodeTypeContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public NodeTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nodeType; }
	}

	public final NodeTypeContext nodeType() throws RecognitionException {
		NodeTypeContext _localctx = new NodeTypeContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_nodeType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(137);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BooleanExprContext extends ParserRuleContext {
		public List<BooleanExprContext> booleanExpr() {
			return getRuleContexts(BooleanExprContext.class);
		}
		public BooleanExprContext booleanExpr(int i) {
			return getRuleContext(BooleanExprContext.class,i);
		}
		public IndicatorExprContext indicatorExpr() {
			return getRuleContext(IndicatorExprContext.class,0);
		}
		public ArtifactExprContext artifactExpr() {
			return getRuleContext(ArtifactExprContext.class,0);
		}
		public TerminalNode NOT() { return getToken(CertusParser.NOT, 0); }
		public List<FuzzyExprContext> fuzzyExpr() {
			return getRuleContexts(FuzzyExprContext.class);
		}
		public FuzzyExprContext fuzzyExpr(int i) {
			return getRuleContext(FuzzyExprContext.class,i);
		}
		public TerminalNode LT() { return getToken(CertusParser.LT, 0); }
		public TerminalNode LEQ() { return getToken(CertusParser.LEQ, 0); }
		public TerminalNode GT() { return getToken(CertusParser.GT, 0); }
		public TerminalNode GEQ() { return getToken(CertusParser.GEQ, 0); }
		public TerminalNode EQ() { return getToken(CertusParser.EQ, 0); }
		public TerminalNode NEQ() { return getToken(CertusParser.NEQ, 0); }
		public TerminalNode EXACTLY() { return getToken(CertusParser.EXACTLY, 0); }
		public TerminalNode ASSIGN() { return getToken(CertusParser.ASSIGN, 0); }
		public TerminalNode CONTAIN() { return getToken(CertusParser.CONTAIN, 0); }
		public TerminalNode OVERLAP() { return getToken(CertusParser.OVERLAP, 0); }
		public TerminalNode AND() { return getToken(CertusParser.AND, 0); }
		public TerminalNode OR() { return getToken(CertusParser.OR, 0); }
		public BooleanExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_booleanExpr; }
	}

	public final BooleanExprContext booleanExpr() throws RecognitionException {
		return booleanExpr(0);
	}

	private BooleanExprContext booleanExpr(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		BooleanExprContext _localctx = new BooleanExprContext(_ctx, _parentState);
		BooleanExprContext _prevctx = _localctx;
		int _startState = 16;
		enterRecursionRule(_localctx, 16, RULE_booleanExpr, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(188);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
			case 1:
				{
				setState(140);
				match(T__0);
				setState(141);
				booleanExpr(0);
				setState(142);
				match(T__1);
				}
				break;
			case 2:
				{
				setState(144);
				indicatorExpr();
				}
				break;
			case 3:
				{
				setState(145);
				artifactExpr();
				}
				break;
			case 4:
				{
				setState(146);
				match(NOT);
				setState(147);
				booleanExpr(13);
				}
				break;
			case 5:
				{
				setState(148);
				fuzzyExpr(0);
				setState(149);
				match(LT);
				setState(150);
				fuzzyExpr(0);
				}
				break;
			case 6:
				{
				setState(152);
				fuzzyExpr(0);
				setState(153);
				match(LEQ);
				setState(154);
				fuzzyExpr(0);
				}
				break;
			case 7:
				{
				setState(156);
				fuzzyExpr(0);
				setState(157);
				match(GT);
				setState(158);
				fuzzyExpr(0);
				}
				break;
			case 8:
				{
				setState(160);
				fuzzyExpr(0);
				setState(161);
				match(GEQ);
				setState(162);
				fuzzyExpr(0);
				}
				break;
			case 9:
				{
				setState(164);
				fuzzyExpr(0);
				setState(165);
				match(EQ);
				setState(166);
				fuzzyExpr(0);
				}
				break;
			case 10:
				{
				setState(168);
				fuzzyExpr(0);
				setState(169);
				match(NEQ);
				setState(170);
				fuzzyExpr(0);
				}
				break;
			case 11:
				{
				setState(172);
				fuzzyExpr(0);
				setState(173);
				match(EXACTLY);
				setState(174);
				fuzzyExpr(0);
				}
				break;
			case 12:
				{
				setState(176);
				fuzzyExpr(0);
				setState(177);
				match(ASSIGN);
				setState(178);
				fuzzyExpr(0);
				}
				break;
			case 13:
				{
				setState(180);
				fuzzyExpr(0);
				setState(181);
				match(CONTAIN);
				setState(182);
				fuzzyExpr(0);
				}
				break;
			case 14:
				{
				setState(184);
				fuzzyExpr(0);
				setState(185);
				match(OVERLAP);
				setState(186);
				fuzzyExpr(0);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(198);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(196);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
					case 1:
						{
						_localctx = new BooleanExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_booleanExpr);
						setState(190);
						if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
						setState(191);
						match(AND);
						setState(192);
						booleanExpr(13);
						}
						break;
					case 2:
						{
						_localctx = new BooleanExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_booleanExpr);
						setState(193);
						if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
						setState(194);
						match(OR);
						setState(195);
						booleanExpr(12);
						}
						break;
					}
					} 
				}
				setState(200);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IndicatorContext extends ParserRuleContext {
		public TerminalNode INDICATOR_PREFIX() { return getToken(CertusParser.INDICATOR_PREFIX, 0); }
		public List<TerminalNode> ID() { return getTokens(CertusParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(CertusParser.ID, i);
		}
		public List<TerminalNode> WS() { return getTokens(CertusParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CertusParser.WS, i);
		}
		public IndicatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indicator; }
	}

	public final IndicatorContext indicator() throws RecognitionException {
		IndicatorContext _localctx = new IndicatorContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_indicator);
		int _la;
		try {
			setState(214);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(201);
				match(INDICATOR_PREFIX);
				setState(202);
				match(T__3);
				setState(207); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(203);
					match(ID);
					setState(205);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==WS) {
						{
						setState(204);
						match(WS);
						}
					}

					}
					}
					setState(209); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==ID );
				setState(211);
				match(T__3);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(212);
				match(INDICATOR_PREFIX);
				setState(213);
				match(ID);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IndicatorCategoryContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public IndicatorCategoryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indicatorCategory; }
	}

	public final IndicatorCategoryContext indicatorCategory() throws RecognitionException {
		IndicatorCategoryContext _localctx = new IndicatorCategoryContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_indicatorCategory);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(216);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IndicatorExprContext extends ParserRuleContext {
		public List<IndicatorContext> indicator() {
			return getRuleContexts(IndicatorContext.class);
		}
		public IndicatorContext indicator(int i) {
			return getRuleContext(IndicatorContext.class,i);
		}
		public TerminalNode ASSIGN() { return getToken(CertusParser.ASSIGN, 0); }
		public IndicatorCategoryContext indicatorCategory() {
			return getRuleContext(IndicatorCategoryContext.class,0);
		}
		public TerminalNode EQ() { return getToken(CertusParser.EQ, 0); }
		public TerminalNode EXACTLY() { return getToken(CertusParser.EXACTLY, 0); }
		public TerminalNode LT() { return getToken(CertusParser.LT, 0); }
		public TerminalNode LEQ() { return getToken(CertusParser.LEQ, 0); }
		public TerminalNode GT() { return getToken(CertusParser.GT, 0); }
		public TerminalNode GEQ() { return getToken(CertusParser.GEQ, 0); }
		public TerminalNode NEQ() { return getToken(CertusParser.NEQ, 0); }
		public TerminalNode FLOAT() { return getToken(CertusParser.FLOAT, 0); }
		public IndicatorExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indicatorExpr; }
	}

	public final IndicatorExprContext indicatorExpr() throws RecognitionException {
		IndicatorExprContext _localctx = new IndicatorExprContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_indicatorExpr);
		int _la;
		try {
			setState(274);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(218);
				indicator();
				setState(219);
				match(ASSIGN);
				setState(220);
				indicatorCategory();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(222);
				indicator();
				setState(223);
				_la = _input.LA(1);
				if ( !(_la==EXACTLY || _la==EQ) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(224);
				indicator();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(226);
				indicator();
				setState(227);
				match(LT);
				setState(228);
				indicator();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(230);
				indicator();
				setState(231);
				match(LEQ);
				setState(232);
				indicator();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(234);
				indicator();
				setState(235);
				match(GT);
				setState(236);
				indicator();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(238);
				indicator();
				setState(239);
				match(GEQ);
				setState(240);
				indicator();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(242);
				indicator();
				setState(243);
				match(NEQ);
				setState(244);
				indicator();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(246);
				indicator();
				setState(247);
				match(LT);
				setState(248);
				indicator();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(250);
				indicator();
				setState(251);
				_la = _input.LA(1);
				if ( !(_la==EXACTLY || _la==EQ) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(252);
				match(FLOAT);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(254);
				indicator();
				setState(255);
				match(LT);
				setState(256);
				match(FLOAT);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(258);
				indicator();
				setState(259);
				match(LEQ);
				setState(260);
				match(FLOAT);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(262);
				indicator();
				setState(263);
				match(GT);
				setState(264);
				match(FLOAT);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(266);
				indicator();
				setState(267);
				match(GEQ);
				setState(268);
				match(FLOAT);
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(270);
				indicator();
				setState(271);
				match(NEQ);
				setState(272);
				match(FLOAT);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ArtifactContext extends ParserRuleContext {
		public TerminalNode ARTIFACT_PREFIX() { return getToken(CertusParser.ARTIFACT_PREFIX, 0); }
		public List<TerminalNode> ID() { return getTokens(CertusParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(CertusParser.ID, i);
		}
		public List<TerminalNode> WS() { return getTokens(CertusParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(CertusParser.WS, i);
		}
		public ArtifactContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_artifact; }
	}

	public final ArtifactContext artifact() throws RecognitionException {
		ArtifactContext _localctx = new ArtifactContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_artifact);
		int _la;
		try {
			setState(289);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(276);
				match(ARTIFACT_PREFIX);
				setState(277);
				match(T__3);
				setState(282); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(278);
					match(ID);
					setState(280);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==WS) {
						{
						setState(279);
						match(WS);
						}
					}

					}
					}
					setState(284); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==ID );
				setState(286);
				match(T__3);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(287);
				match(ARTIFACT_PREFIX);
				setState(288);
				match(ID);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ArtifactExprContext extends ParserRuleContext {
		public TerminalNode HAS() { return getToken(CertusParser.HAS, 0); }
		public ArtifactContext artifact() {
			return getRuleContext(ArtifactContext.class,0);
		}
		public ArtifactExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_artifactExpr; }
	}

	public final ArtifactExprContext artifactExpr() throws RecognitionException {
		ArtifactExprContext _localctx = new ArtifactExprContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_artifactExpr);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(291);
			match(HAS);
			setState(292);
			artifact();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CasesExprContext extends ParserRuleContext {
		public TerminalNode CASES() { return getToken(CertusParser.CASES, 0); }
		public TerminalNode OTHERWISE() { return getToken(CertusParser.OTHERWISE, 0); }
		public FuzzyExprContext fuzzyExpr() {
			return getRuleContext(FuzzyExprContext.class,0);
		}
		public List<CaseContext> case_() {
			return getRuleContexts(CaseContext.class);
		}
		public CaseContext case_(int i) {
			return getRuleContext(CaseContext.class,i);
		}
		public List<TerminalNode> ARG_SEP() { return getTokens(CertusParser.ARG_SEP); }
		public TerminalNode ARG_SEP(int i) {
			return getToken(CertusParser.ARG_SEP, i);
		}
		public CasesExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_casesExpr; }
	}

	public final CasesExprContext casesExpr() throws RecognitionException {
		CasesExprContext _localctx = new CasesExprContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_casesExpr);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(294);
			match(CASES);
			setState(298); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(295);
				case_();
				setState(296);
				match(ARG_SEP);
				}
				}
				setState(300); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 73118462926818L) != 0) );
			setState(302);
			match(OTHERWISE);
			setState(303);
			fuzzyExpr(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CaseContext extends ParserRuleContext {
		public BooleanExprContext booleanExpr() {
			return getRuleContext(BooleanExprContext.class,0);
		}
		public TerminalNode ARROW() { return getToken(CertusParser.ARROW, 0); }
		public FuzzyExprContext fuzzyExpr() {
			return getRuleContext(FuzzyExprContext.class,0);
		}
		public CaseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_case; }
	}

	public final CaseContext case_() throws RecognitionException {
		CaseContext _localctx = new CaseContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_case);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(305);
			booleanExpr(0);
			setState(306);
			match(ARROW);
			setState(307);
			fuzzyExpr(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MacroExprContext extends ParserRuleContext {
		public TerminalNode MACRO_PREFIX() { return getToken(CertusParser.MACRO_PREFIX, 0); }
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public MacroExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_macroExpr; }
	}

	public final MacroExprContext macroExpr() throws RecognitionException {
		MacroExprContext _localctx = new MacroExprContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_macroExpr);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(309);
			match(MACRO_PREFIX);
			setState(310);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FuzzyExprContext extends ParserRuleContext {
		public CasesExprContext casesExpr() {
			return getRuleContext(CasesExprContext.class,0);
		}
		public DefineSetContext defineSet() {
			return getRuleContext(DefineSetContext.class,0);
		}
		public BuiltInOpContext builtInOp() {
			return getRuleContext(BuiltInOpContext.class,0);
		}
		public InvokedOpContext invokedOp() {
			return getRuleContext(InvokedOpContext.class,0);
		}
		public FuzzySymContext fuzzySym() {
			return getRuleContext(FuzzySymContext.class,0);
		}
		public List<FuzzyExprContext> fuzzyExpr() {
			return getRuleContexts(FuzzyExprContext.class);
		}
		public FuzzyExprContext fuzzyExpr(int i) {
			return getRuleContext(FuzzyExprContext.class,i);
		}
		public TerminalNode INTERSECT() { return getToken(CertusParser.INTERSECT, 0); }
		public TerminalNode UNION() { return getToken(CertusParser.UNION, 0); }
		public FuzzyExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fuzzyExpr; }
	}

	public final FuzzyExprContext fuzzyExpr() throws RecognitionException {
		return fuzzyExpr(0);
	}

	private FuzzyExprContext fuzzyExpr(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		FuzzyExprContext _localctx = new FuzzyExprContext(_ctx, _parentState);
		FuzzyExprContext _prevctx = _localctx;
		int _startState = 34;
		enterRecursionRule(_localctx, 34, RULE_fuzzyExpr, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(318);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				{
				setState(313);
				casesExpr();
				}
				break;
			case 2:
				{
				setState(314);
				defineSet();
				}
				break;
			case 3:
				{
				setState(315);
				builtInOp();
				}
				break;
			case 4:
				{
				setState(316);
				invokedOp();
				}
				break;
			case 5:
				{
				setState(317);
				fuzzySym();
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(328);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(326);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
					case 1:
						{
						_localctx = new FuzzyExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_fuzzyExpr);
						setState(320);
						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
						setState(321);
						match(INTERSECT);
						setState(322);
						fuzzyExpr(8);
						}
						break;
					case 2:
						{
						_localctx = new FuzzyExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_fuzzyExpr);
						setState(323);
						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
						setState(324);
						match(UNION);
						setState(325);
						fuzzyExpr(7);
						}
						break;
					}
					} 
				}
				setState(330);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InvokedOpContext extends ParserRuleContext {
		public List<TerminalNode> ID() { return getTokens(CertusParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(CertusParser.ID, i);
		}
		public List<TerminalNode> ARG_SEP() { return getTokens(CertusParser.ARG_SEP); }
		public TerminalNode ARG_SEP(int i) {
			return getToken(CertusParser.ARG_SEP, i);
		}
		public InvokedOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_invokedOp; }
	}

	public final InvokedOpContext invokedOp() throws RecognitionException {
		InvokedOpContext _localctx = new InvokedOpContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_invokedOp);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(331);
			match(ID);
			setState(332);
			match(T__0);
			setState(333);
			match(ID);
			setState(338);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==ARG_SEP) {
				{
				{
				setState(334);
				match(ARG_SEP);
				setState(335);
				match(ID);
				}
				}
				setState(340);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(341);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FuzzySymContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(CertusParser.ID, 0); }
		public FuzzySymContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fuzzySym; }
	}

	public final FuzzySymContext fuzzySym() throws RecognitionException {
		FuzzySymContext _localctx = new FuzzySymContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_fuzzySym);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(343);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BuiltInOpContext extends ParserRuleContext {
		public MinOpContext minOp() {
			return getRuleContext(MinOpContext.class,0);
		}
		public MaxOpContext maxOp() {
			return getRuleContext(MaxOpContext.class,0);
		}
		public InvertOpContext invertOp() {
			return getRuleContext(InvertOpContext.class,0);
		}
		public CompOpContext compOp() {
			return getRuleContext(CompOpContext.class,0);
		}
		public BuiltInOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_builtInOp; }
	}

	public final BuiltInOpContext builtInOp() throws RecognitionException {
		BuiltInOpContext _localctx = new BuiltInOpContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_builtInOp);
		try {
			setState(349);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__4:
				enterOuterAlt(_localctx, 1);
				{
				setState(345);
				minOp();
				}
				break;
			case T__5:
				enterOuterAlt(_localctx, 2);
				{
				setState(346);
				maxOp();
				}
				break;
			case INVERT:
				enterOuterAlt(_localctx, 3);
				{
				setState(347);
				invertOp();
				}
				break;
			case COMP:
				enterOuterAlt(_localctx, 4);
				{
				setState(348);
				compOp();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MinOpContext extends ParserRuleContext {
		public List<FuzzyExprContext> fuzzyExpr() {
			return getRuleContexts(FuzzyExprContext.class);
		}
		public FuzzyExprContext fuzzyExpr(int i) {
			return getRuleContext(FuzzyExprContext.class,i);
		}
		public List<TerminalNode> ARG_SEP() { return getTokens(CertusParser.ARG_SEP); }
		public TerminalNode ARG_SEP(int i) {
			return getToken(CertusParser.ARG_SEP, i);
		}
		public MinOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_minOp; }
	}

	public final MinOpContext minOp() throws RecognitionException {
		MinOpContext _localctx = new MinOpContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_minOp);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(351);
			match(T__4);
			setState(352);
			match(T__0);
			setState(353);
			fuzzyExpr(0);
			setState(358);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==ARG_SEP) {
				{
				{
				setState(354);
				match(ARG_SEP);
				setState(355);
				fuzzyExpr(0);
				}
				}
				setState(360);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(361);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MaxOpContext extends ParserRuleContext {
		public List<FuzzyExprContext> fuzzyExpr() {
			return getRuleContexts(FuzzyExprContext.class);
		}
		public FuzzyExprContext fuzzyExpr(int i) {
			return getRuleContext(FuzzyExprContext.class,i);
		}
		public List<TerminalNode> ARG_SEP() { return getTokens(CertusParser.ARG_SEP); }
		public TerminalNode ARG_SEP(int i) {
			return getToken(CertusParser.ARG_SEP, i);
		}
		public MaxOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_maxOp; }
	}

	public final MaxOpContext maxOp() throws RecognitionException {
		MaxOpContext _localctx = new MaxOpContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_maxOp);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(363);
			match(T__5);
			setState(364);
			match(T__0);
			setState(365);
			fuzzyExpr(0);
			setState(370);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==ARG_SEP) {
				{
				{
				setState(366);
				match(ARG_SEP);
				setState(367);
				fuzzyExpr(0);
				}
				}
				setState(372);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(373);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InvertOpContext extends ParserRuleContext {
		public TerminalNode INVERT() { return getToken(CertusParser.INVERT, 0); }
		public FuzzyExprContext fuzzyExpr() {
			return getRuleContext(FuzzyExprContext.class,0);
		}
		public InvertOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_invertOp; }
	}

	public final InvertOpContext invertOp() throws RecognitionException {
		InvertOpContext _localctx = new InvertOpContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_invertOp);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(375);
			match(INVERT);
			setState(376);
			match(T__0);
			setState(377);
			fuzzyExpr(0);
			setState(378);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CompOpContext extends ParserRuleContext {
		public TerminalNode COMP() { return getToken(CertusParser.COMP, 0); }
		public FuzzyExprContext fuzzyExpr() {
			return getRuleContext(FuzzyExprContext.class,0);
		}
		public CompOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compOp; }
	}

	public final CompOpContext compOp() throws RecognitionException {
		CompOpContext _localctx = new CompOpContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_compOp);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(380);
			match(COMP);
			setState(381);
			match(T__0);
			setState(382);
			fuzzyExpr(0);
			setState(383);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DefineSetContext extends ParserRuleContext {
		public SetTrapContext setTrap() {
			return getRuleContext(SetTrapContext.class,0);
		}
		public SetTriContext setTri() {
			return getRuleContext(SetTriContext.class,0);
		}
		public SetUpContext setUp() {
			return getRuleContext(SetUpContext.class,0);
		}
		public SetDownContext setDown() {
			return getRuleContext(SetDownContext.class,0);
		}
		public SetConstContext setConst() {
			return getRuleContext(SetConstContext.class,0);
		}
		public SetCrispContext setCrisp() {
			return getRuleContext(SetCrispContext.class,0);
		}
		public DefineSetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_defineSet; }
	}

	public final DefineSetContext defineSet() throws RecognitionException {
		DefineSetContext _localctx = new DefineSetContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_defineSet);
		try {
			setState(391);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__6:
				enterOuterAlt(_localctx, 1);
				{
				setState(385);
				setTrap();
				}
				break;
			case T__7:
				enterOuterAlt(_localctx, 2);
				{
				setState(386);
				setTri();
				}
				break;
			case T__8:
				enterOuterAlt(_localctx, 3);
				{
				setState(387);
				setUp();
				}
				break;
			case T__9:
				enterOuterAlt(_localctx, 4);
				{
				setState(388);
				setDown();
				}
				break;
			case T__10:
				enterOuterAlt(_localctx, 5);
				{
				setState(389);
				setConst();
				}
				break;
			case T__11:
			case T__13:
				enterOuterAlt(_localctx, 6);
				{
				setState(390);
				setCrisp();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SetTrapContext extends ParserRuleContext {
		public List<TerminalNode> FLOAT() { return getTokens(CertusParser.FLOAT); }
		public TerminalNode FLOAT(int i) {
			return getToken(CertusParser.FLOAT, i);
		}
		public List<TerminalNode> ARG_SEP() { return getTokens(CertusParser.ARG_SEP); }
		public TerminalNode ARG_SEP(int i) {
			return getToken(CertusParser.ARG_SEP, i);
		}
		public SetTrapContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setTrap; }
	}

	public final SetTrapContext setTrap() throws RecognitionException {
		SetTrapContext _localctx = new SetTrapContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_setTrap);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(393);
			match(T__6);
			setState(394);
			match(T__0);
			setState(395);
			match(FLOAT);
			setState(396);
			match(ARG_SEP);
			setState(397);
			match(FLOAT);
			setState(398);
			match(ARG_SEP);
			setState(399);
			match(FLOAT);
			setState(400);
			match(ARG_SEP);
			setState(401);
			match(FLOAT);
			setState(402);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SetTriContext extends ParserRuleContext {
		public List<TerminalNode> FLOAT() { return getTokens(CertusParser.FLOAT); }
		public TerminalNode FLOAT(int i) {
			return getToken(CertusParser.FLOAT, i);
		}
		public List<TerminalNode> ARG_SEP() { return getTokens(CertusParser.ARG_SEP); }
		public TerminalNode ARG_SEP(int i) {
			return getToken(CertusParser.ARG_SEP, i);
		}
		public SetTriContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setTri; }
	}

	public final SetTriContext setTri() throws RecognitionException {
		SetTriContext _localctx = new SetTriContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_setTri);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(404);
			match(T__7);
			setState(405);
			match(T__0);
			setState(406);
			match(FLOAT);
			setState(407);
			match(ARG_SEP);
			setState(408);
			match(FLOAT);
			setState(409);
			match(ARG_SEP);
			setState(410);
			match(FLOAT);
			setState(411);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SetUpContext extends ParserRuleContext {
		public List<TerminalNode> FLOAT() { return getTokens(CertusParser.FLOAT); }
		public TerminalNode FLOAT(int i) {
			return getToken(CertusParser.FLOAT, i);
		}
		public TerminalNode ARG_SEP() { return getToken(CertusParser.ARG_SEP, 0); }
		public SetUpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setUp; }
	}

	public final SetUpContext setUp() throws RecognitionException {
		SetUpContext _localctx = new SetUpContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_setUp);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(413);
			match(T__8);
			setState(414);
			match(T__0);
			setState(415);
			match(FLOAT);
			setState(416);
			match(ARG_SEP);
			setState(417);
			match(FLOAT);
			setState(418);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SetDownContext extends ParserRuleContext {
		public List<TerminalNode> FLOAT() { return getTokens(CertusParser.FLOAT); }
		public TerminalNode FLOAT(int i) {
			return getToken(CertusParser.FLOAT, i);
		}
		public TerminalNode ARG_SEP() { return getToken(CertusParser.ARG_SEP, 0); }
		public SetDownContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setDown; }
	}

	public final SetDownContext setDown() throws RecognitionException {
		SetDownContext _localctx = new SetDownContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_setDown);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(420);
			match(T__9);
			setState(421);
			match(T__0);
			setState(422);
			match(FLOAT);
			setState(423);
			match(ARG_SEP);
			setState(424);
			match(FLOAT);
			setState(425);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SetConstContext extends ParserRuleContext {
		public TerminalNode FLOAT() { return getToken(CertusParser.FLOAT, 0); }
		public SetConstContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setConst; }
	}

	public final SetConstContext setConst() throws RecognitionException {
		SetConstContext _localctx = new SetConstContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_setConst);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(427);
			match(T__10);
			setState(428);
			match(T__0);
			setState(429);
			match(FLOAT);
			setState(430);
			match(T__1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SetCrispContext extends ParserRuleContext {
		public List<TerminalNode> FLOAT() { return getTokens(CertusParser.FLOAT); }
		public TerminalNode FLOAT(int i) {
			return getToken(CertusParser.FLOAT, i);
		}
		public TerminalNode ARG_SEP() { return getToken(CertusParser.ARG_SEP, 0); }
		public SetCrispContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setCrisp; }
	}

	public final SetCrispContext setCrisp() throws RecognitionException {
		SetCrispContext _localctx = new SetCrispContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_setCrisp);
		try {
			setState(443);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__11:
				enterOuterAlt(_localctx, 1);
				{
				setState(432);
				match(T__11);
				setState(433);
				match(FLOAT);
				setState(434);
				match(ARG_SEP);
				setState(435);
				match(FLOAT);
				setState(436);
				match(T__12);
				}
				break;
			case T__13:
				enterOuterAlt(_localctx, 2);
				{
				setState(437);
				match(T__13);
				setState(438);
				match(T__0);
				setState(439);
				match(FLOAT);
				setState(440);
				match(ARG_SEP);
				setState(441);
				match(FLOAT);
				setState(442);
				match(T__1);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 8:
			return booleanExpr_sempred((BooleanExprContext)_localctx, predIndex);
		case 17:
			return fuzzyExpr_sempred((FuzzyExprContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean booleanExpr_sempred(BooleanExprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 12);
		case 1:
			return precpred(_ctx, 11);
		}
		return true;
	}
	private boolean fuzzyExpr_sempred(FuzzyExprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 2:
			return precpred(_ctx, 7);
		case 3:
			return precpred(_ctx, 6);
		}
		return true;
	}

	public static final String _serializedATN =
		"\u0004\u0001/\u01be\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
		"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
		"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
		"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
		"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
		"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
		"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
		"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
		"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
		"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
		"\u0002\u001f\u0007\u001f\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+
		"\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+
		"\u0003\u0000K\b\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
		"\u0005\u0001Q\b\u0001\n\u0001\f\u0001T\t\u0001\u0001\u0001\u0003\u0001"+
		"W\b\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0005\u0002_\b\u0002\n\u0002\f\u0002b\t\u0002\u0001\u0002"+
		"\u0003\u0002e\b\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003o\b\u0003"+
		"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
		"\u0001\u0004\u0003\u0004x\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005"+
		"\u0001\u0005\u0001\u0005\u0005\u0005\u007f\b\u0005\n\u0005\f\u0005\u0082"+
		"\t\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
		"\u0006\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b"+
		"\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003"+
		"\b\u00bd\b\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0005\b\u00c5"+
		"\b\b\n\b\f\b\u00c8\t\b\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u00ce\b"+
		"\t\u0004\t\u00d0\b\t\u000b\t\f\t\u00d1\u0001\t\u0001\t\u0001\t\u0003\t"+
		"\u00d7\b\t\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0113\b\u000b"+
		"\u0001\f\u0001\f\u0001\f\u0001\f\u0003\f\u0119\b\f\u0004\f\u011b\b\f\u000b"+
		"\f\f\f\u011c\u0001\f\u0001\f\u0001\f\u0003\f\u0122\b\f\u0001\r\u0001\r"+
		"\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0004\u000e\u012b"+
		"\b\u000e\u000b\u000e\f\u000e\u012c\u0001\u000e\u0001\u000e\u0001\u000e"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010"+
		"\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+
		"\u0001\u0011\u0003\u0011\u013f\b\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+
		"\u0001\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u0147\b\u0011\n\u0011"+
		"\f\u0011\u014a\t\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+
		"\u0001\u0012\u0005\u0012\u0151\b\u0012\n\u0012\f\u0012\u0154\t\u0012\u0001"+
		"\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0003\u0014\u015e\b\u0014\u0001\u0015\u0001\u0015\u0001"+
		"\u0015\u0001\u0015\u0001\u0015\u0005\u0015\u0165\b\u0015\n\u0015\f\u0015"+
		"\u0168\t\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0005\u0016\u0171\b\u0016\n\u0016\f\u0016\u0174"+
		"\t\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+
		"\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+
		"\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
		"\u0019\u0003\u0019\u0188\b\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+
		"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+
		"\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
		"\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001"+
		"\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+
		"\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+
		"\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+
		"\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+
		"\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0003\u001f\u01bc"+
		"\b\u001f\u0001\u001f\u0000\u0002\u0010\" \u0000\u0002\u0004\u0006\b\n"+
		"\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.0246"+
		"8:<>\u0000\u0001\u0002\u0000\u0014\u0014!!\u01db\u0000J\u0001\u0000\u0000"+
		"\u0000\u0002L\u0001\u0000\u0000\u0000\u0004Z\u0001\u0000\u0000\u0000\u0006"+
		"n\u0001\u0000\u0000\u0000\bw\u0001\u0000\u0000\u0000\ny\u0001\u0000\u0000"+
		"\u0000\f\u0085\u0001\u0000\u0000\u0000\u000e\u0089\u0001\u0000\u0000\u0000"+
		"\u0010\u00bc\u0001\u0000\u0000\u0000\u0012\u00d6\u0001\u0000\u0000\u0000"+
		"\u0014\u00d8\u0001\u0000\u0000\u0000\u0016\u0112\u0001\u0000\u0000\u0000"+
		"\u0018\u0121\u0001\u0000\u0000\u0000\u001a\u0123\u0001\u0000\u0000\u0000"+
		"\u001c\u0126\u0001\u0000\u0000\u0000\u001e\u0131\u0001\u0000\u0000\u0000"+
		" \u0135\u0001\u0000\u0000\u0000\"\u013e\u0001\u0000\u0000\u0000$\u014b"+
		"\u0001\u0000\u0000\u0000&\u0157\u0001\u0000\u0000\u0000(\u015d\u0001\u0000"+
		"\u0000\u0000*\u015f\u0001\u0000\u0000\u0000,\u016b\u0001\u0000\u0000\u0000"+
		".\u0177\u0001\u0000\u0000\u00000\u017c\u0001\u0000\u0000\u00002\u0187"+
		"\u0001\u0000\u0000\u00004\u0189\u0001\u0000\u0000\u00006\u0194\u0001\u0000"+
		"\u0000\u00008\u019d\u0001\u0000\u0000\u0000:\u01a4\u0001\u0000\u0000\u0000"+
		"<\u01ab\u0001\u0000\u0000\u0000>\u01bb\u0001\u0000\u0000\u0000@A\u0003"+
		"\u0004\u0002\u0000AB\u0005\u0000\u0000\u0001BK\u0001\u0000\u0000\u0000"+
		"CD\u0003\u0002\u0001\u0000DE\u0003\u0006\u0003\u0000EF\u0005\u0000\u0000"+
		"\u0001FK\u0001\u0000\u0000\u0000GH\u0003\u0006\u0003\u0000HI\u0005\u0000"+
		"\u0000\u0001IK\u0001\u0000\u0000\u0000J@\u0001\u0000\u0000\u0000JC\u0001"+
		"\u0000\u0000\u0000JG\u0001\u0000\u0000\u0000K\u0001\u0001\u0000\u0000"+
		"\u0000LM\u0005\u0017\u0000\u0000MR\u0003\b\u0004\u0000NO\u0005-\u0000"+
		"\u0000OQ\u0003\b\u0004\u0000PN\u0001\u0000\u0000\u0000QT\u0001\u0000\u0000"+
		"\u0000RP\u0001\u0000\u0000\u0000RS\u0001\u0000\u0000\u0000SV\u0001\u0000"+
		"\u0000\u0000TR\u0001\u0000\u0000\u0000UW\u0005-\u0000\u0000VU\u0001\u0000"+
		"\u0000\u0000VW\u0001\u0000\u0000\u0000WX\u0001\u0000\u0000\u0000XY\u0005"+
		"\u0019\u0000\u0000Y\u0003\u0001\u0000\u0000\u0000Z[\u0005\u0018\u0000"+
		"\u0000[`\u0003\b\u0004\u0000\\]\u0005-\u0000\u0000]_\u0003\b\u0004\u0000"+
		"^\\\u0001\u0000\u0000\u0000_b\u0001\u0000\u0000\u0000`^\u0001\u0000\u0000"+
		"\u0000`a\u0001\u0000\u0000\u0000ad\u0001\u0000\u0000\u0000b`\u0001\u0000"+
		"\u0000\u0000ce\u0005-\u0000\u0000dc\u0001\u0000\u0000\u0000de\u0001\u0000"+
		"\u0000\u0000ef\u0001\u0000\u0000\u0000fg\u0005\u0019\u0000\u0000g\u0005"+
		"\u0001\u0000\u0000\u0000hi\u0005.\u0000\u0000ij\u0005\u0010\u0000\u0000"+
		"jo\u0003\"\u0011\u0000kl\u0005.\u0000\u0000lm\u0005\u0010\u0000\u0000"+
		"mo\u0003 \u0010\u0000nh\u0001\u0000\u0000\u0000nk\u0001\u0000\u0000\u0000"+
		"o\u0007\u0001\u0000\u0000\u0000pq\u0005.\u0000\u0000qr\u0005\u001a\u0000"+
		"\u0000rx\u0003\"\u0011\u0000st\u0003\n\u0005\u0000tu\u0005\u001a\u0000"+
		"\u0000uv\u0003\"\u0011\u0000vx\u0001\u0000\u0000\u0000wp\u0001\u0000\u0000"+
		"\u0000ws\u0001\u0000\u0000\u0000x\t\u0001\u0000\u0000\u0000yz\u0005.\u0000"+
		"\u0000z{\u0005\u0001\u0000\u0000{\u0080\u0003\f\u0006\u0000|}\u0005,\u0000"+
		"\u0000}\u007f\u0003\f\u0006\u0000~|\u0001\u0000\u0000\u0000\u007f\u0082"+
		"\u0001\u0000\u0000\u0000\u0080~\u0001\u0000\u0000\u0000\u0080\u0081\u0001"+
		"\u0000\u0000\u0000\u0081\u0083\u0001\u0000\u0000\u0000\u0082\u0080\u0001"+
		"\u0000\u0000\u0000\u0083\u0084\u0005\u0002\u0000\u0000\u0084\u000b\u0001"+
		"\u0000\u0000\u0000\u0085\u0086\u0005.\u0000\u0000\u0086\u0087\u0005\u0003"+
		"\u0000\u0000\u0087\u0088\u0003\u000e\u0007\u0000\u0088\r\u0001\u0000\u0000"+
		"\u0000\u0089\u008a\u0005.\u0000\u0000\u008a\u000f\u0001\u0000\u0000\u0000"+
		"\u008b\u008c\u0006\b\uffff\uffff\u0000\u008c\u008d\u0005\u0001\u0000\u0000"+
		"\u008d\u008e\u0003\u0010\b\u0000\u008e\u008f\u0005\u0002\u0000\u0000\u008f"+
		"\u00bd\u0001\u0000\u0000\u0000\u0090\u00bd\u0003\u0016\u000b\u0000\u0091"+
		"\u00bd\u0003\u001a\r\u0000\u0092\u0093\u0005\u001b\u0000\u0000\u0093\u00bd"+
		"\u0003\u0010\b\r\u0094\u0095\u0003\"\u0011\u0000\u0095\u0096\u0005#\u0000"+
		"\u0000\u0096\u0097\u0003\"\u0011\u0000\u0097\u00bd\u0001\u0000\u0000\u0000"+
		"\u0098\u0099\u0003\"\u0011\u0000\u0099\u009a\u0005%\u0000\u0000\u009a"+
		"\u009b\u0003\"\u0011\u0000\u009b\u00bd\u0001\u0000\u0000\u0000\u009c\u009d"+
		"\u0003\"\u0011\u0000\u009d\u009e\u0005\"\u0000\u0000\u009e\u009f\u0003"+
		"\"\u0011\u0000\u009f\u00bd\u0001\u0000\u0000\u0000\u00a0\u00a1\u0003\""+
		"\u0011\u0000\u00a1\u00a2\u0005$\u0000\u0000\u00a2\u00a3\u0003\"\u0011"+
		"\u0000\u00a3\u00bd\u0001\u0000\u0000\u0000\u00a4\u00a5\u0003\"\u0011\u0000"+
		"\u00a5\u00a6\u0005!\u0000\u0000\u00a6\u00a7\u0003\"\u0011\u0000\u00a7"+
		"\u00bd\u0001\u0000\u0000\u0000\u00a8\u00a9\u0003\"\u0011\u0000\u00a9\u00aa"+
		"\u0005 \u0000\u0000\u00aa\u00ab\u0003\"\u0011\u0000\u00ab\u00bd\u0001"+
		"\u0000\u0000\u0000\u00ac\u00ad\u0003\"\u0011\u0000\u00ad\u00ae\u0005\u0014"+
		"\u0000\u0000\u00ae\u00af\u0003\"\u0011\u0000\u00af\u00bd\u0001\u0000\u0000"+
		"\u0000\u00b0\u00b1\u0003\"\u0011\u0000\u00b1\u00b2\u0005\u0010\u0000\u0000"+
		"\u00b2\u00b3\u0003\"\u0011\u0000\u00b3\u00bd\u0001\u0000\u0000\u0000\u00b4"+
		"\u00b5\u0003\"\u0011\u0000\u00b5\u00b6\u0005\u0012\u0000\u0000\u00b6\u00b7"+
		"\u0003\"\u0011\u0000\u00b7\u00bd\u0001\u0000\u0000\u0000\u00b8\u00b9\u0003"+
		"\"\u0011\u0000\u00b9\u00ba\u0005\u0013\u0000\u0000\u00ba\u00bb\u0003\""+
		"\u0011\u0000\u00bb\u00bd\u0001\u0000\u0000\u0000\u00bc\u008b\u0001\u0000"+
		"\u0000\u0000\u00bc\u0090\u0001\u0000\u0000\u0000\u00bc\u0091\u0001\u0000"+
		"\u0000\u0000\u00bc\u0092\u0001\u0000\u0000\u0000\u00bc\u0094\u0001\u0000"+
		"\u0000\u0000\u00bc\u0098\u0001\u0000\u0000\u0000\u00bc\u009c\u0001\u0000"+
		"\u0000\u0000\u00bc\u00a0\u0001\u0000\u0000\u0000\u00bc\u00a4\u0001\u0000"+
		"\u0000\u0000\u00bc\u00a8\u0001\u0000\u0000\u0000\u00bc\u00ac\u0001\u0000"+
		"\u0000\u0000\u00bc\u00b0\u0001\u0000\u0000\u0000\u00bc\u00b4\u0001\u0000"+
		"\u0000\u0000\u00bc\u00b8\u0001\u0000\u0000\u0000\u00bd\u00c6\u0001\u0000"+
		"\u0000\u0000\u00be\u00bf\n\f\u0000\u0000\u00bf\u00c0\u0005\u001e\u0000"+
		"\u0000\u00c0\u00c5\u0003\u0010\b\r\u00c1\u00c2\n\u000b\u0000\u0000\u00c2"+
		"\u00c3\u0005\u001f\u0000\u0000\u00c3\u00c5\u0003\u0010\b\f\u00c4\u00be"+
		"\u0001\u0000\u0000\u0000\u00c4\u00c1\u0001\u0000\u0000\u0000\u00c5\u00c8"+
		"\u0001\u0000\u0000\u0000\u00c6\u00c4\u0001\u0000\u0000\u0000\u00c6\u00c7"+
		"\u0001\u0000\u0000\u0000\u00c7\u0011\u0001\u0000\u0000\u0000\u00c8\u00c6"+
		"\u0001\u0000\u0000\u0000\u00c9\u00ca\u0005\'\u0000\u0000\u00ca\u00cf\u0005"+
		"\u0004\u0000\u0000\u00cb\u00cd\u0005.\u0000\u0000\u00cc\u00ce\u0005/\u0000"+
		"\u0000\u00cd\u00cc\u0001\u0000\u0000\u0000\u00cd\u00ce\u0001\u0000\u0000"+
		"\u0000\u00ce\u00d0\u0001\u0000\u0000\u0000\u00cf\u00cb\u0001\u0000\u0000"+
		"\u0000\u00d0\u00d1\u0001\u0000\u0000\u0000\u00d1\u00cf\u0001\u0000\u0000"+
		"\u0000\u00d1\u00d2\u0001\u0000\u0000\u0000\u00d2\u00d3\u0001\u0000\u0000"+
		"\u0000\u00d3\u00d7\u0005\u0004\u0000\u0000\u00d4\u00d5\u0005\'\u0000\u0000"+
		"\u00d5\u00d7\u0005.\u0000\u0000\u00d6\u00c9\u0001\u0000\u0000\u0000\u00d6"+
		"\u00d4\u0001\u0000\u0000\u0000\u00d7\u0013\u0001\u0000\u0000\u0000\u00d8"+
		"\u00d9\u0005.\u0000\u0000\u00d9\u0015\u0001\u0000\u0000\u0000\u00da\u00db"+
		"\u0003\u0012\t\u0000\u00db\u00dc\u0005\u0010\u0000\u0000\u00dc\u00dd\u0003"+
		"\u0014\n\u0000\u00dd\u0113\u0001\u0000\u0000\u0000\u00de\u00df\u0003\u0012"+
		"\t\u0000\u00df\u00e0\u0007\u0000\u0000\u0000\u00e0\u00e1\u0003\u0012\t"+
		"\u0000\u00e1\u0113\u0001\u0000\u0000\u0000\u00e2\u00e3\u0003\u0012\t\u0000"+
		"\u00e3\u00e4\u0005#\u0000\u0000\u00e4\u00e5\u0003\u0012\t\u0000\u00e5"+
		"\u0113\u0001\u0000\u0000\u0000\u00e6\u00e7\u0003\u0012\t\u0000\u00e7\u00e8"+
		"\u0005%\u0000\u0000\u00e8\u00e9\u0003\u0012\t\u0000\u00e9\u0113\u0001"+
		"\u0000\u0000\u0000\u00ea\u00eb\u0003\u0012\t\u0000\u00eb\u00ec\u0005\""+
		"\u0000\u0000\u00ec\u00ed\u0003\u0012\t\u0000\u00ed\u0113\u0001\u0000\u0000"+
		"\u0000\u00ee\u00ef\u0003\u0012\t\u0000\u00ef\u00f0\u0005$\u0000\u0000"+
		"\u00f0\u00f1\u0003\u0012\t\u0000\u00f1\u0113\u0001\u0000\u0000\u0000\u00f2"+
		"\u00f3\u0003\u0012\t\u0000\u00f3\u00f4\u0005 \u0000\u0000\u00f4\u00f5"+
		"\u0003\u0012\t\u0000\u00f5\u0113\u0001\u0000\u0000\u0000\u00f6\u00f7\u0003"+
		"\u0012\t\u0000\u00f7\u00f8\u0005#\u0000\u0000\u00f8\u00f9\u0003\u0012"+
		"\t\u0000\u00f9\u0113\u0001\u0000\u0000\u0000\u00fa\u00fb\u0003\u0012\t"+
		"\u0000\u00fb\u00fc\u0007\u0000\u0000\u0000\u00fc\u00fd\u0005+\u0000\u0000"+
		"\u00fd\u0113\u0001\u0000\u0000\u0000\u00fe\u00ff\u0003\u0012\t\u0000\u00ff"+
		"\u0100\u0005#\u0000\u0000\u0100\u0101\u0005+\u0000\u0000\u0101\u0113\u0001"+
		"\u0000\u0000\u0000\u0102\u0103\u0003\u0012\t\u0000\u0103\u0104\u0005%"+
		"\u0000\u0000\u0104\u0105\u0005+\u0000\u0000\u0105\u0113\u0001\u0000\u0000"+
		"\u0000\u0106\u0107\u0003\u0012\t\u0000\u0107\u0108\u0005\"\u0000\u0000"+
		"\u0108\u0109\u0005+\u0000\u0000\u0109\u0113\u0001\u0000\u0000\u0000\u010a"+
		"\u010b\u0003\u0012\t\u0000\u010b\u010c\u0005$\u0000\u0000\u010c\u010d"+
		"\u0005+\u0000\u0000\u010d\u0113\u0001\u0000\u0000\u0000\u010e\u010f\u0003"+
		"\u0012\t\u0000\u010f\u0110\u0005 \u0000\u0000\u0110\u0111\u0005+\u0000"+
		"\u0000\u0111\u0113\u0001\u0000\u0000\u0000\u0112\u00da\u0001\u0000\u0000"+
		"\u0000\u0112\u00de\u0001\u0000\u0000\u0000\u0112\u00e2\u0001\u0000\u0000"+
		"\u0000\u0112\u00e6\u0001\u0000\u0000\u0000\u0112\u00ea\u0001\u0000\u0000"+
		"\u0000\u0112\u00ee\u0001\u0000\u0000\u0000\u0112\u00f2\u0001\u0000\u0000"+
		"\u0000\u0112\u00f6\u0001\u0000\u0000\u0000\u0112\u00fa\u0001\u0000\u0000"+
		"\u0000\u0112\u00fe\u0001\u0000\u0000\u0000\u0112\u0102\u0001\u0000\u0000"+
		"\u0000\u0112\u0106\u0001\u0000\u0000\u0000\u0112\u010a\u0001\u0000\u0000"+
		"\u0000\u0112\u010e\u0001\u0000\u0000\u0000\u0113\u0017\u0001\u0000\u0000"+
		"\u0000\u0114\u0115\u0005(\u0000\u0000\u0115\u011a\u0005\u0004\u0000\u0000"+
		"\u0116\u0118\u0005.\u0000\u0000\u0117\u0119\u0005/\u0000\u0000\u0118\u0117"+
		"\u0001\u0000\u0000\u0000\u0118\u0119\u0001\u0000\u0000\u0000\u0119\u011b"+
		"\u0001\u0000\u0000\u0000\u011a\u0116\u0001\u0000\u0000\u0000\u011b\u011c"+
		"\u0001\u0000\u0000\u0000\u011c\u011a\u0001\u0000\u0000\u0000\u011c\u011d"+
		"\u0001\u0000\u0000\u0000\u011d\u011e\u0001\u0000\u0000\u0000\u011e\u0122"+
		"\u0005\u0004\u0000\u0000\u011f\u0120\u0005(\u0000\u0000\u0120\u0122\u0005"+
		".\u0000\u0000\u0121\u0114\u0001\u0000\u0000\u0000\u0121\u011f\u0001\u0000"+
		"\u0000\u0000\u0122\u0019\u0001\u0000\u0000\u0000\u0123\u0124\u0005\u0011"+
		"\u0000\u0000\u0124\u0125\u0003\u0018\f\u0000\u0125\u001b\u0001\u0000\u0000"+
		"\u0000\u0126\u012a\u0005)\u0000\u0000\u0127\u0128\u0003\u001e\u000f\u0000"+
		"\u0128\u0129\u0005,\u0000\u0000\u0129\u012b\u0001\u0000\u0000\u0000\u012a"+
		"\u0127\u0001\u0000\u0000\u0000\u012b\u012c\u0001\u0000\u0000\u0000\u012c"+
		"\u012a\u0001\u0000\u0000\u0000\u012c\u012d\u0001\u0000\u0000\u0000\u012d"+
		"\u012e\u0001\u0000\u0000\u0000\u012e\u012f\u0005*\u0000\u0000\u012f\u0130"+
		"\u0003\"\u0011\u0000\u0130\u001d\u0001\u0000\u0000\u0000\u0131\u0132\u0003"+
		"\u0010\b\u0000\u0132\u0133\u0005\u000f\u0000\u0000\u0133\u0134\u0003\""+
		"\u0011\u0000\u0134\u001f\u0001\u0000\u0000\u0000\u0135\u0136\u0005&\u0000"+
		"\u0000\u0136\u0137\u0005.\u0000\u0000\u0137!\u0001\u0000\u0000\u0000\u0138"+
		"\u0139\u0006\u0011\uffff\uffff\u0000\u0139\u013f\u0003\u001c\u000e\u0000"+
		"\u013a\u013f\u00032\u0019\u0000\u013b\u013f\u0003(\u0014\u0000\u013c\u013f"+
		"\u0003$\u0012\u0000\u013d\u013f\u0003&\u0013\u0000\u013e\u0138\u0001\u0000"+
		"\u0000\u0000\u013e\u013a\u0001\u0000\u0000\u0000\u013e\u013b\u0001\u0000"+
		"\u0000\u0000\u013e\u013c\u0001\u0000\u0000\u0000\u013e\u013d\u0001\u0000"+
		"\u0000\u0000\u013f\u0148\u0001\u0000\u0000\u0000\u0140\u0141\n\u0007\u0000"+
		"\u0000\u0141\u0142\u0005\u0016\u0000\u0000\u0142\u0147\u0003\"\u0011\b"+
		"\u0143\u0144\n\u0006\u0000\u0000\u0144\u0145\u0005\u0015\u0000\u0000\u0145"+
		"\u0147\u0003\"\u0011\u0007\u0146\u0140\u0001\u0000\u0000\u0000\u0146\u0143"+
		"\u0001\u0000\u0000\u0000\u0147\u014a\u0001\u0000\u0000\u0000\u0148\u0146"+
		"\u0001\u0000\u0000\u0000\u0148\u0149\u0001\u0000\u0000\u0000\u0149#\u0001"+
		"\u0000\u0000\u0000\u014a\u0148\u0001\u0000\u0000\u0000\u014b\u014c\u0005"+
		".\u0000\u0000\u014c\u014d\u0005\u0001\u0000\u0000\u014d\u0152\u0005.\u0000"+
		"\u0000\u014e\u014f\u0005,\u0000\u0000\u014f\u0151\u0005.\u0000\u0000\u0150"+
		"\u014e\u0001\u0000\u0000\u0000\u0151\u0154\u0001\u0000\u0000\u0000\u0152"+
		"\u0150\u0001\u0000\u0000\u0000\u0152\u0153\u0001\u0000\u0000\u0000\u0153"+
		"\u0155\u0001\u0000\u0000\u0000\u0154\u0152\u0001\u0000\u0000\u0000\u0155"+
		"\u0156\u0005\u0002\u0000\u0000\u0156%\u0001\u0000\u0000\u0000\u0157\u0158"+
		"\u0005.\u0000\u0000\u0158\'\u0001\u0000\u0000\u0000\u0159\u015e\u0003"+
		"*\u0015\u0000\u015a\u015e\u0003,\u0016\u0000\u015b\u015e\u0003.\u0017"+
		"\u0000\u015c\u015e\u00030\u0018\u0000\u015d\u0159\u0001\u0000\u0000\u0000"+
		"\u015d\u015a\u0001\u0000\u0000\u0000\u015d\u015b\u0001\u0000\u0000\u0000"+
		"\u015d\u015c\u0001\u0000\u0000\u0000\u015e)\u0001\u0000\u0000\u0000\u015f"+
		"\u0160\u0005\u0005\u0000\u0000\u0160\u0161\u0005\u0001\u0000\u0000\u0161"+
		"\u0166\u0003\"\u0011\u0000\u0162\u0163\u0005,\u0000\u0000\u0163\u0165"+
		"\u0003\"\u0011\u0000\u0164\u0162\u0001\u0000\u0000\u0000\u0165\u0168\u0001"+
		"\u0000\u0000\u0000\u0166\u0164\u0001\u0000\u0000\u0000\u0166\u0167\u0001"+
		"\u0000\u0000\u0000\u0167\u0169\u0001\u0000\u0000\u0000\u0168\u0166\u0001"+
		"\u0000\u0000\u0000\u0169\u016a\u0005\u0002\u0000\u0000\u016a+\u0001\u0000"+
		"\u0000\u0000\u016b\u016c\u0005\u0006\u0000\u0000\u016c\u016d\u0005\u0001"+
		"\u0000\u0000\u016d\u0172\u0003\"\u0011\u0000\u016e\u016f\u0005,\u0000"+
		"\u0000\u016f\u0171\u0003\"\u0011\u0000\u0170\u016e\u0001\u0000\u0000\u0000"+
		"\u0171\u0174\u0001\u0000\u0000\u0000\u0172\u0170\u0001\u0000\u0000\u0000"+
		"\u0172\u0173\u0001\u0000\u0000\u0000\u0173\u0175\u0001\u0000\u0000\u0000"+
		"\u0174\u0172\u0001\u0000\u0000\u0000\u0175\u0176\u0005\u0002\u0000\u0000"+
		"\u0176-\u0001\u0000\u0000\u0000\u0177\u0178\u0005\u001c\u0000\u0000\u0178"+
		"\u0179\u0005\u0001\u0000\u0000\u0179\u017a\u0003\"\u0011\u0000\u017a\u017b"+
		"\u0005\u0002\u0000\u0000\u017b/\u0001\u0000\u0000\u0000\u017c\u017d\u0005"+
		"\u001d\u0000\u0000\u017d\u017e\u0005\u0001\u0000\u0000\u017e\u017f\u0003"+
		"\"\u0011\u0000\u017f\u0180\u0005\u0002\u0000\u0000\u01801\u0001\u0000"+
		"\u0000\u0000\u0181\u0188\u00034\u001a\u0000\u0182\u0188\u00036\u001b\u0000"+
		"\u0183\u0188\u00038\u001c\u0000\u0184\u0188\u0003:\u001d\u0000\u0185\u0188"+
		"\u0003<\u001e\u0000\u0186\u0188\u0003>\u001f\u0000\u0187\u0181\u0001\u0000"+
		"\u0000\u0000\u0187\u0182\u0001\u0000\u0000\u0000\u0187\u0183\u0001\u0000"+
		"\u0000\u0000\u0187\u0184\u0001\u0000\u0000\u0000\u0187\u0185\u0001\u0000"+
		"\u0000\u0000\u0187\u0186\u0001\u0000\u0000\u0000\u01883\u0001\u0000\u0000"+
		"\u0000\u0189\u018a\u0005\u0007\u0000\u0000\u018a\u018b\u0005\u0001\u0000"+
		"\u0000\u018b\u018c\u0005+\u0000\u0000\u018c\u018d\u0005,\u0000\u0000\u018d"+
		"\u018e\u0005+\u0000\u0000\u018e\u018f\u0005,\u0000\u0000\u018f\u0190\u0005"+
		"+\u0000\u0000\u0190\u0191\u0005,\u0000\u0000\u0191\u0192\u0005+\u0000"+
		"\u0000\u0192\u0193\u0005\u0002\u0000\u0000\u01935\u0001\u0000\u0000\u0000"+
		"\u0194\u0195\u0005\b\u0000\u0000\u0195\u0196\u0005\u0001\u0000\u0000\u0196"+
		"\u0197\u0005+\u0000\u0000\u0197\u0198\u0005,\u0000\u0000\u0198\u0199\u0005"+
		"+\u0000\u0000\u0199\u019a\u0005,\u0000\u0000\u019a\u019b\u0005+\u0000"+
		"\u0000\u019b\u019c\u0005\u0002\u0000\u0000\u019c7\u0001\u0000\u0000\u0000"+
		"\u019d\u019e\u0005\t\u0000\u0000\u019e\u019f\u0005\u0001\u0000\u0000\u019f"+
		"\u01a0\u0005+\u0000\u0000\u01a0\u01a1\u0005,\u0000\u0000\u01a1\u01a2\u0005"+
		"+\u0000\u0000\u01a2\u01a3\u0005\u0002\u0000\u0000\u01a39\u0001\u0000\u0000"+
		"\u0000\u01a4\u01a5\u0005\n\u0000\u0000\u01a5\u01a6\u0005\u0001\u0000\u0000"+
		"\u01a6\u01a7\u0005+\u0000\u0000\u01a7\u01a8\u0005,\u0000\u0000\u01a8\u01a9"+
		"\u0005+\u0000\u0000\u01a9\u01aa\u0005\u0002\u0000\u0000\u01aa;\u0001\u0000"+
		"\u0000\u0000\u01ab\u01ac\u0005\u000b\u0000\u0000\u01ac\u01ad\u0005\u0001"+
		"\u0000\u0000\u01ad\u01ae\u0005+\u0000\u0000\u01ae\u01af\u0005\u0002\u0000"+
		"\u0000\u01af=\u0001\u0000\u0000\u0000\u01b0\u01b1\u0005\f\u0000\u0000"+
		"\u01b1\u01b2\u0005+\u0000\u0000\u01b2\u01b3\u0005,\u0000\u0000\u01b3\u01b4"+
		"\u0005+\u0000\u0000\u01b4\u01bc\u0005\r\u0000\u0000\u01b5\u01b6\u0005"+
		"\u000e\u0000\u0000\u01b6\u01b7\u0005\u0001\u0000\u0000\u01b7\u01b8\u0005"+
		"+\u0000\u0000\u01b8\u01b9\u0005,\u0000\u0000\u01b9\u01ba\u0005+\u0000"+
		"\u0000\u01ba\u01bc\u0005\u0002\u0000\u0000\u01bb\u01b0\u0001\u0000\u0000"+
		"\u0000\u01bb\u01b5\u0001\u0000\u0000\u0000\u01bc?\u0001\u0000\u0000\u0000"+
		"\u001cJRV`dnw\u0080\u00bc\u00c4\u00c6\u00cd\u00d1\u00d6\u0112\u0118\u011c"+
		"\u0121\u012c\u013e\u0146\u0148\u0152\u015d\u0166\u0172\u0187\u01bb";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}