PlanBundleParser.java

  1. // Generated from org/lightjason/agentspeak/grammar/PlanBundle.g4 by ANTLR 4.7.1
  2. package org.lightjason.agentspeak.grammar;
  3. import org.antlr.v4.runtime.atn.*;
  4. import org.antlr.v4.runtime.dfa.DFA;
  5. import org.antlr.v4.runtime.*;
  6. import org.antlr.v4.runtime.misc.*;
  7. import org.antlr.v4.runtime.tree.*;
  8. import java.util.List;
  9. import java.util.Iterator;
  10. import java.util.ArrayList;

  12. @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
  13. public class PlanBundleParser extends Parser {
  14.     static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }

  16.     protected static final DFA[] _decisionToDFA;
  17.     protected static final PredictionContextCache _sharedContextCache =
  18.         new PredictionContextCache();
  19.     public static final int
  20.         BINARYOPERATOR=1, UNARYOPERATOR=2, STRING=3, LOGICALVALUE=4, CONSTANTNUMBER=5, 
  21.         EXCLAMATIONMARK=6, STRONGNEGATION=7, COMMA=8, PLUS=9, MINUS=10, DOUBLEEXCLAMATIONMARK=11, 
  22.         QUESTIONMARK=12, DOLLAR=13, LEFTARROW=14, RIGHTARROW=15, RULEOPERATOR=16, 
  23.         AT=17, COLON=18, SEMICOLON=19, DOT=20, UNDERSCORE=21, SLASH=22, LEFTROUNDBRACKET=23, 
  24.         RIGHTROUNDBRACKET=24, LEFTANGULARBRACKET=25, RIGHTANGULARBRACKET=26, LEFTCURVEDBRACKET=27, 
  25.         RIGHTCURVEDBRACKET=28, LEFTSHIFT=29, RIGHTSHIFT=30, PARALLEL=31, ATOMIC=32, 
  26.         CONSTANT=33, VLINE=34, AND=35, OR=36, XOR=37, ASSIGN=38, DECONSTRUCT=39, 
  27.         LESS=40, LESSEQUAL=41, GREATER=42, GREATEREQUAL=43, EQUAL=44, NOTEQUAL=45, 
  28.         POW=46, MULTIPLY=47, MODULO=48, LOWERCASELETTER=49, UPPERCASELETTER=50, 
  29.         DIGIT=51, WHITESPACE=52, LINECOMMENT=53, BLOCKCOMMENT=54;
  30.     public static final int
  31.         RULE_planbundle = 0, RULE_belief = 1, RULE_plans = 2, RULE_logicrules = 3, 
  32.         RULE_plan = 4, RULE_plandefinition = 5, RULE_logicrule = 6, RULE_logicalruledefinition = 7, 
  33.         RULE_annotations = 8, RULE_annotation_atom = 9, RULE_annotation_literal = 10, 
  34.         RULE_annotation_value_literal = 11, RULE_plan_trigger = 12, RULE_plan_goal_trigger = 13, 
  35.         RULE_plan_belief_trigger = 14, RULE_body = 15, RULE_body_formula = 16, 
  36.         RULE_repair_formula = 17, RULE_belief_action = 18, RULE_test_action = 19, 
  37.         RULE_achievement_goal_action = 20, RULE_deconstruct_expression = 21, RULE_assignment_expression = 22, 
  38.         RULE_assignment_expression_singlevariable = 23, RULE_assignment_expression_multivariable = 24, 
  39.         RULE_unary_expression = 25, RULE_binary_expression = 26, RULE_block_formula = 27, 
  40.         RULE_lambda = 28, RULE_lambda_initialization = 29, RULE_lambda_return = 30, 
  41.         RULE_executable_term = 31, RULE_term = 32, RULE_unification = 33, RULE_unification_constraint = 34, 
  42.         RULE_ternary_operation = 35, RULE_ternary_operation_true = 36, RULE_ternary_operation_false = 37, 
  43.         RULE_expression = 38, RULE_expression_bracket = 39, RULE_expression_logical_and = 40, 
  44.         RULE_expression_logical_xor = 41, RULE_expression_logical_element = 42, 
  45.         RULE_expression_logical_negation = 43, RULE_expression_numeric = 44, RULE_expression_numeric_relation = 45, 
  46.         RULE_expression_numeric_additive = 46, RULE_expression_numeric_multiplicative = 47, 
  47.         RULE_expression_numeric_power = 48, RULE_expression_numeric_element = 49, 
  48.         RULE_executable_action = 50, RULE_executable_rule = 51, RULE_variable_evaluate = 52, 
  49.         RULE_literal = 53, RULE_termlist = 54, RULE_variablelist = 55, RULE_atom = 56, 
  50.         RULE_variable = 57, RULE_variableatom = 58, RULE_number = 59, RULE_digitsequence = 60;
  51.     public static final String[] ruleNames = {
  52.         "planbundle", "belief", "plans", "logicrules", "plan", "plandefinition", 
  53.         "logicrule", "logicalruledefinition", "annotations", "annotation_atom", 
  54.         "annotation_literal", "annotation_value_literal", "plan_trigger", "plan_goal_trigger", 
  55.         "plan_belief_trigger", "body", "body_formula", "repair_formula", "belief_action", 
  56.         "test_action", "achievement_goal_action", "deconstruct_expression", "assignment_expression", 
  57.         "assignment_expression_singlevariable", "assignment_expression_multivariable", 
  58.         "unary_expression", "binary_expression", "block_formula", "lambda", "lambda_initialization", 
  59.         "lambda_return", "executable_term", "term", "unification", "unification_constraint", 
  60.         "ternary_operation", "ternary_operation_true", "ternary_operation_false", 
  61.         "expression", "expression_bracket", "expression_logical_and", "expression_logical_xor", 
  62.         "expression_logical_element", "expression_logical_negation", "expression_numeric", 
  63.         "expression_numeric_relation", "expression_numeric_additive", "expression_numeric_multiplicative", 
  64.         "expression_numeric_power", "expression_numeric_element", "executable_action", 
  65.         "executable_rule", "variable_evaluate", "literal", "termlist", "variablelist", 
  66.         "atom", "variable", "variableatom", "number", "digitsequence"
  67.     };

  69.     private static final String[] _LITERAL_NAMES = {
  70.         null, null, null, null, null, null, "'!'", "'~'", "','", "'+'", "'-'", 
  71.         "'!!'", "'?'", "'$'", "'<-'", "'->'", "':-'", "'@'", "':'", "';'", "'.'", 
  72.         "'_'", "'/'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'<<'", "'>>'", 
  73.         "'parallel'", "'atomic'", "'constant'", "'|'", "'&&'", "'||'", "'^'", 
  74.         "'='", "'=..'", "'<'", "'<='", "'>'", "'>='", "'=='", null, "'**'", "'*'", 
  75.         "'%'"
  76.     };
  77.     private static final String[] _SYMBOLIC_NAMES = {
  78.         null, "BINARYOPERATOR", "UNARYOPERATOR", "STRING", "LOGICALVALUE", "CONSTANTNUMBER", 
  79.         "EXCLAMATIONMARK", "STRONGNEGATION", "COMMA", "PLUS", "MINUS", "DOUBLEEXCLAMATIONMARK", 
  80.         "QUESTIONMARK", "DOLLAR", "LEFTARROW", "RIGHTARROW", "RULEOPERATOR", "AT", 
  81.         "COLON", "SEMICOLON", "DOT", "UNDERSCORE", "SLASH", "LEFTROUNDBRACKET", 
  82.         "RIGHTROUNDBRACKET", "LEFTANGULARBRACKET", "RIGHTANGULARBRACKET", "LEFTCURVEDBRACKET", 
  83.         "RIGHTCURVEDBRACKET", "LEFTSHIFT", "RIGHTSHIFT", "PARALLEL", "ATOMIC", 
  84.         "CONSTANT", "VLINE", "AND", "OR", "XOR", "ASSIGN", "DECONSTRUCT", "LESS", 
  85.         "LESSEQUAL", "GREATER", "GREATEREQUAL", "EQUAL", "NOTEQUAL", "POW", "MULTIPLY", 
  86.         "MODULO", "LOWERCASELETTER", "UPPERCASELETTER", "DIGIT", "WHITESPACE", 
  87.         "LINECOMMENT", "BLOCKCOMMENT"
  88.     };
  89.     public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

  91.     /**
  92.      * @deprecated Use {@link #VOCABULARY} instead.
  93.      */
  94.     @Deprecated
  95.     public static final String[] tokenNames;
  96.     static {
  97.         tokenNames = new String[_SYMBOLIC_NAMES.length];
  98.         for (int i = 0; i < tokenNames.length; i++) {
  99.             tokenNames[i] = VOCABULARY.getLiteralName(i);
  100.             if (tokenNames[i] == null) {
  101.                 tokenNames[i] = VOCABULARY.getSymbolicName(i);
  102.             }

  104.             if (tokenNames[i] == null) {
  105.                 tokenNames[i] = "<INVALID>";
  106.             }
  107.         }
  108.     }

  110.     @Override
  111.     @Deprecated
  112.     public String[] getTokenNames() {
  113.         return tokenNames;
  114.     }

  116.     @Override

  118.     public Vocabulary getVocabulary() {
  119.         return VOCABULARY;
  120.     }

  122.     @Override
  123.     public String getGrammarFileName() { return "PlanBundle.g4"; }

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

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

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

  134.     public PlanBundleParser(TokenStream input) {
  135.         super(input);
  136.         _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
  137.     }
  138.     public static class PlanbundleContext extends ParserRuleContext {
  139.         public PlansContext plans() {
  140.             return getRuleContext(PlansContext.class,0);
  141.         }
  142.         public List<BeliefContext> belief() {
  143.             return getRuleContexts(BeliefContext.class);
  144.         }
  145.         public BeliefContext belief(int i) {
  146.             return getRuleContext(BeliefContext.class,i);
  147.         }
  148.         public LogicrulesContext logicrules() {
  149.             return getRuleContext(LogicrulesContext.class,0);
  150.         }
  151.         public PlanbundleContext(ParserRuleContext parent, int invokingState) {
  152.             super(parent, invokingState);
  153.         }
  154.         @Override public int getRuleIndex() { return RULE_planbundle; }
  155.         @Override
  156.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  157.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlanbundle(this);
  158.             else return visitor.visitChildren(this);
  159.         }
  160.     }

  162.     public final PlanbundleContext planbundle() throws RecognitionException {
  163.         PlanbundleContext _localctx = new PlanbundleContext(_ctx, getState());
  164.         enterRule(_localctx, 0, RULE_planbundle);
  165.         try {
  166.             int _alt;
  167.             enterOuterAlt(_localctx, 1);
  168.             {
  169.             setState(125);
  170.             _errHandler.sync(this);
  171.             _alt = getInterpreter().adaptivePredict(_input,0,_ctx);
  172.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  173.                 if ( _alt==1 ) {
  174.                     {
  175.                     {
  176.                     setState(122);
  177.                     belief();
  178.                     }
  179.                     } 
  180.                 }
  181.                 setState(127);
  182.                 _errHandler.sync(this);
  183.                 _alt = getInterpreter().adaptivePredict(_input,0,_ctx);
  184.             }
  185.             setState(129);
  186.             _errHandler.sync(this);
  187.             switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
  188.             case 1:
  189.                 {
  190.                 setState(128);
  191.                 logicrules();
  192.                 }
  193.                 break;
  194.             }
  195.             setState(131);
  196.             plans();
  197.             }
  198.         }
  199.         catch (RecognitionException re) {
  200.             _localctx.exception = re;
  201.             _errHandler.reportError(this, re);
  202.             _errHandler.recover(this, re);
  203.         }
  204.         finally {
  205.             exitRule();
  206.         }
  207.         return _localctx;
  208.     }

  210.     public static class BeliefContext extends ParserRuleContext {
  211.         public LiteralContext literal() {
  212.             return getRuleContext(LiteralContext.class,0);
  213.         }
  214.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  215.         public BeliefContext(ParserRuleContext parent, int invokingState) {
  216.             super(parent, invokingState);
  217.         }
  218.         @Override public int getRuleIndex() { return RULE_belief; }
  219.         @Override
  220.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  221.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBelief(this);
  222.             else return visitor.visitChildren(this);
  223.         }
  224.     }

  226.     public final BeliefContext belief() throws RecognitionException {
  227.         BeliefContext _localctx = new BeliefContext(_ctx, getState());
  228.         enterRule(_localctx, 2, RULE_belief);
  229.         try {
  230.             enterOuterAlt(_localctx, 1);
  231.             {
  232.             setState(133);
  233.             literal();
  234.             setState(134);
  235.             match(DOT);
  236.             }
  237.         }
  238.         catch (RecognitionException re) {
  239.             _localctx.exception = re;
  240.             _errHandler.reportError(this, re);
  241.             _errHandler.recover(this, re);
  242.         }
  243.         finally {
  244.             exitRule();
  245.         }
  246.         return _localctx;
  247.     }

  249.     public static class PlansContext extends ParserRuleContext {
  250.         public List<PlanContext> plan() {
  251.             return getRuleContexts(PlanContext.class);
  252.         }
  253.         public PlanContext plan(int i) {
  254.             return getRuleContext(PlanContext.class,i);
  255.         }
  256.         public PlansContext(ParserRuleContext parent, int invokingState) {
  257.             super(parent, invokingState);
  258.         }
  259.         @Override public int getRuleIndex() { return RULE_plans; }
  260.         @Override
  261.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  262.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlans(this);
  263.             else return visitor.visitChildren(this);
  264.         }
  265.     }

  267.     public final PlansContext plans() throws RecognitionException {
  268.         PlansContext _localctx = new PlansContext(_ctx, getState());
  269.         enterRule(_localctx, 4, RULE_plans);
  270.         int _la;
  271.         try {
  272.             enterOuterAlt(_localctx, 1);
  273.             {
  274.             setState(137); 
  275.             _errHandler.sync(this);
  276.             _la = _input.LA(1);
  277.             do {
  278.                 {
  279.                 {
  280.                 setState(136);
  281.                 plan();
  282.                 }
  283.                 }
  284.                 setState(139); 
  285.                 _errHandler.sync(this);
  286.                 _la = _input.LA(1);
  287.             } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << AT))) != 0) );
  288.             }
  289.         }
  290.         catch (RecognitionException re) {
  291.             _localctx.exception = re;
  292.             _errHandler.reportError(this, re);
  293.             _errHandler.recover(this, re);
  294.         }
  295.         finally {
  296.             exitRule();
  297.         }
  298.         return _localctx;
  299.     }

  301.     public static class LogicrulesContext extends ParserRuleContext {
  302.         public List<LogicruleContext> logicrule() {
  303.             return getRuleContexts(LogicruleContext.class);
  304.         }
  305.         public LogicruleContext logicrule(int i) {
  306.             return getRuleContext(LogicruleContext.class,i);
  307.         }
  308.         public LogicrulesContext(ParserRuleContext parent, int invokingState) {
  309.             super(parent, invokingState);
  310.         }
  311.         @Override public int getRuleIndex() { return RULE_logicrules; }
  312.         @Override
  313.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  314.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicrules(this);
  315.             else return visitor.visitChildren(this);
  316.         }
  317.     }

  319.     public final LogicrulesContext logicrules() throws RecognitionException {
  320.         LogicrulesContext _localctx = new LogicrulesContext(_ctx, getState());
  321.         enterRule(_localctx, 6, RULE_logicrules);
  322.         try {
  323.             int _alt;
  324.             enterOuterAlt(_localctx, 1);
  325.             {
  326.             setState(142); 
  327.             _errHandler.sync(this);
  328.             _alt = 1;
  329.             do {
  330.                 switch (_alt) {
  331.                 case 1:
  332.                     {
  333.                     {
  334.                     setState(141);
  335.                     logicrule();
  336.                     }
  337.                     }
  338.                     break;
  339.                 default:
  340.                     throw new NoViableAltException(this);
  341.                 }
  342.                 setState(144); 
  343.                 _errHandler.sync(this);
  344.                 _alt = getInterpreter().adaptivePredict(_input,3,_ctx);
  345.             } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
  346.             }
  347.         }
  348.         catch (RecognitionException re) {
  349.             _localctx.exception = re;
  350.             _errHandler.reportError(this, re);
  351.             _errHandler.recover(this, re);
  352.         }
  353.         finally {
  354.             exitRule();
  355.         }
  356.         return _localctx;
  357.     }

  359.     public static class PlanContext extends ParserRuleContext {
  360.         public Plan_triggerContext plan_trigger() {
  361.             return getRuleContext(Plan_triggerContext.class,0);
  362.         }
  363.         public LiteralContext literal() {
  364.             return getRuleContext(LiteralContext.class,0);
  365.         }
  366.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  367.         public AnnotationsContext annotations() {
  368.             return getRuleContext(AnnotationsContext.class,0);
  369.         }
  370.         public List<PlandefinitionContext> plandefinition() {
  371.             return getRuleContexts(PlandefinitionContext.class);
  372.         }
  373.         public PlandefinitionContext plandefinition(int i) {
  374.             return getRuleContext(PlandefinitionContext.class,i);
  375.         }
  376.         public PlanContext(ParserRuleContext parent, int invokingState) {
  377.             super(parent, invokingState);
  378.         }
  379.         @Override public int getRuleIndex() { return RULE_plan; }
  380.         @Override
  381.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  382.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan(this);
  383.             else return visitor.visitChildren(this);
  384.         }
  385.     }

  387.     public final PlanContext plan() throws RecognitionException {
  388.         PlanContext _localctx = new PlanContext(_ctx, getState());
  389.         enterRule(_localctx, 8, RULE_plan);
  390.         int _la;
  391.         try {
  392.             enterOuterAlt(_localctx, 1);
  393.             {
  394.             setState(147);
  395.             _errHandler.sync(this);
  396.             _la = _input.LA(1);
  397.             if (_la==AT) {
  398.                 {
  399.                 setState(146);
  400.                 annotations();
  401.                 }
  402.             }

  404.             setState(149);
  405.             plan_trigger();
  406.             setState(150);
  407.             literal();
  408.             setState(154);
  409.             _errHandler.sync(this);
  410.             _la = _input.LA(1);
  411.             while (_la==LEFTARROW || _la==COLON) {
  412.                 {
  413.                 {
  414.                 setState(151);
  415.                 plandefinition();
  416.                 }
  417.                 }
  418.                 setState(156);
  419.                 _errHandler.sync(this);
  420.                 _la = _input.LA(1);
  421.             }
  422.             setState(157);
  423.             match(DOT);
  424.             }
  425.         }
  426.         catch (RecognitionException re) {
  427.             _localctx.exception = re;
  428.             _errHandler.reportError(this, re);
  429.             _errHandler.recover(this, re);
  430.         }
  431.         finally {
  432.             exitRule();
  433.         }
  434.         return _localctx;
  435.     }

  437.     public static class PlandefinitionContext extends ParserRuleContext {
  438.         public TerminalNode LEFTARROW() { return getToken(PlanBundleParser.LEFTARROW, 0); }
  439.         public BodyContext body() {
  440.             return getRuleContext(BodyContext.class,0);
  441.         }
  442.         public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
  443.         public ExpressionContext expression() {
  444.             return getRuleContext(ExpressionContext.class,0);
  445.         }
  446.         public PlandefinitionContext(ParserRuleContext parent, int invokingState) {
  447.             super(parent, invokingState);
  448.         }
  449.         @Override public int getRuleIndex() { return RULE_plandefinition; }
  450.         @Override
  451.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  452.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlandefinition(this);
  453.             else return visitor.visitChildren(this);
  454.         }
  455.     }

  457.     public final PlandefinitionContext plandefinition() throws RecognitionException {
  458.         PlandefinitionContext _localctx = new PlandefinitionContext(_ctx, getState());
  459.         enterRule(_localctx, 10, RULE_plandefinition);
  460.         int _la;
  461.         try {
  462.             enterOuterAlt(_localctx, 1);
  463.             {
  464.             setState(161);
  465.             _errHandler.sync(this);
  466.             _la = _input.LA(1);
  467.             if (_la==COLON) {
  468.                 {
  469.                 setState(159);
  470.                 match(COLON);
  471.                 setState(160);
  472.                 expression();
  473.                 }
  474.             }

  476.             setState(163);
  477.             match(LEFTARROW);
  478.             setState(164);
  479.             body();
  480.             }
  481.         }
  482.         catch (RecognitionException re) {
  483.             _localctx.exception = re;
  484.             _errHandler.reportError(this, re);
  485.             _errHandler.recover(this, re);
  486.         }
  487.         finally {
  488.             exitRule();
  489.         }
  490.         return _localctx;
  491.     }

  493.     public static class LogicruleContext extends ParserRuleContext {
  494.         public LiteralContext literal() {
  495.             return getRuleContext(LiteralContext.class,0);
  496.         }
  497.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  498.         public AnnotationsContext annotations() {
  499.             return getRuleContext(AnnotationsContext.class,0);
  500.         }
  501.         public List<LogicalruledefinitionContext> logicalruledefinition() {
  502.             return getRuleContexts(LogicalruledefinitionContext.class);
  503.         }
  504.         public LogicalruledefinitionContext logicalruledefinition(int i) {
  505.             return getRuleContext(LogicalruledefinitionContext.class,i);
  506.         }
  507.         public LogicruleContext(ParserRuleContext parent, int invokingState) {
  508.             super(parent, invokingState);
  509.         }
  510.         @Override public int getRuleIndex() { return RULE_logicrule; }
  511.         @Override
  512.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  513.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicrule(this);
  514.             else return visitor.visitChildren(this);
  515.         }
  516.     }

  518.     public final LogicruleContext logicrule() throws RecognitionException {
  519.         LogicruleContext _localctx = new LogicruleContext(_ctx, getState());
  520.         enterRule(_localctx, 12, RULE_logicrule);
  521.         int _la;
  522.         try {
  523.             enterOuterAlt(_localctx, 1);
  524.             {
  525.             setState(167);
  526.             _errHandler.sync(this);
  527.             switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
  528.             case 1:
  529.                 {
  530.                 setState(166);
  531.                 annotations();
  532.                 }
  533.                 break;
  534.             }
  535.             setState(169);
  536.             literal();
  537.             setState(171); 
  538.             _errHandler.sync(this);
  539.             _la = _input.LA(1);
  540.             do {
  541.                 {
  542.                 {
  543.                 setState(170);
  544.                 logicalruledefinition();
  545.                 }
  546.                 }
  547.                 setState(173); 
  548.                 _errHandler.sync(this);
  549.                 _la = _input.LA(1);
  550.             } while ( _la==RULEOPERATOR );
  551.             setState(175);
  552.             match(DOT);
  553.             }
  554.         }
  555.         catch (RecognitionException re) {
  556.             _localctx.exception = re;
  557.             _errHandler.reportError(this, re);
  558.             _errHandler.recover(this, re);
  559.         }
  560.         finally {
  561.             exitRule();
  562.         }
  563.         return _localctx;
  564.     }

  566.     public static class LogicalruledefinitionContext extends ParserRuleContext {
  567.         public TerminalNode RULEOPERATOR() { return getToken(PlanBundleParser.RULEOPERATOR, 0); }
  568.         public BodyContext body() {
  569.             return getRuleContext(BodyContext.class,0);
  570.         }
  571.         public LogicalruledefinitionContext(ParserRuleContext parent, int invokingState) {
  572.             super(parent, invokingState);
  573.         }
  574.         @Override public int getRuleIndex() { return RULE_logicalruledefinition; }
  575.         @Override
  576.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  577.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicalruledefinition(this);
  578.             else return visitor.visitChildren(this);
  579.         }
  580.     }

  582.     public final LogicalruledefinitionContext logicalruledefinition() throws RecognitionException {
  583.         LogicalruledefinitionContext _localctx = new LogicalruledefinitionContext(_ctx, getState());
  584.         enterRule(_localctx, 14, RULE_logicalruledefinition);
  585.         try {
  586.             enterOuterAlt(_localctx, 1);
  587.             {
  588.             setState(177);
  589.             match(RULEOPERATOR);
  590.             setState(178);
  591.             body();
  592.             }
  593.         }
  594.         catch (RecognitionException re) {
  595.             _localctx.exception = re;
  596.             _errHandler.reportError(this, re);
  597.             _errHandler.recover(this, re);
  598.         }
  599.         finally {
  600.             exitRule();
  601.         }
  602.         return _localctx;
  603.     }

  605.     public static class AnnotationsContext extends ParserRuleContext {
  606.         public List<Annotation_atomContext> annotation_atom() {
  607.             return getRuleContexts(Annotation_atomContext.class);
  608.         }
  609.         public Annotation_atomContext annotation_atom(int i) {
  610.             return getRuleContext(Annotation_atomContext.class,i);
  611.         }
  612.         public List<Annotation_literalContext> annotation_literal() {
  613.             return getRuleContexts(Annotation_literalContext.class);
  614.         }
  615.         public Annotation_literalContext annotation_literal(int i) {
  616.             return getRuleContext(Annotation_literalContext.class,i);
  617.         }
  618.         public AnnotationsContext(ParserRuleContext parent, int invokingState) {
  619.             super(parent, invokingState);
  620.         }
  621.         @Override public int getRuleIndex() { return RULE_annotations; }
  622.         @Override
  623.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  624.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotations(this);
  625.             else return visitor.visitChildren(this);
  626.         }
  627.     }

  629.     public final AnnotationsContext annotations() throws RecognitionException {
  630.         AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState());
  631.         enterRule(_localctx, 16, RULE_annotations);
  632.         try {
  633.             int _alt;
  634.             enterOuterAlt(_localctx, 1);
  635.             {
  636.             setState(182); 
  637.             _errHandler.sync(this);
  638.             _alt = 1;
  639.             do {
  640.                 switch (_alt) {
  641.                 case 1:
  642.                     {
  643.                     setState(182);
  644.                     _errHandler.sync(this);
  645.                     switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
  646.                     case 1:
  647.                         {
  648.                         setState(180);
  649.                         annotation_atom();
  650.                         }
  651.                         break;
  652.                     case 2:
  653.                         {
  654.                         setState(181);
  655.                         annotation_literal();
  656.                         }
  657.                         break;
  658.                     }
  659.                     }
  660.                     break;
  661.                 default:
  662.                     throw new NoViableAltException(this);
  663.                 }
  664.                 setState(184); 
  665.                 _errHandler.sync(this);
  666.                 _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
  667.             } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
  668.             }
  669.         }
  670.         catch (RecognitionException re) {
  671.             _localctx.exception = re;
  672.             _errHandler.reportError(this, re);
  673.             _errHandler.recover(this, re);
  674.         }
  675.         finally {
  676.             exitRule();
  677.         }
  678.         return _localctx;
  679.     }

  681.     public static class Annotation_atomContext extends ParserRuleContext {
  682.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  683.         public TerminalNode ATOMIC() { return getToken(PlanBundleParser.ATOMIC, 0); }
  684.         public TerminalNode PARALLEL() { return getToken(PlanBundleParser.PARALLEL, 0); }
  685.         public Annotation_atomContext(ParserRuleContext parent, int invokingState) {
  686.             super(parent, invokingState);
  687.         }
  688.         @Override public int getRuleIndex() { return RULE_annotation_atom; }
  689.         @Override
  690.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  691.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_atom(this);
  692.             else return visitor.visitChildren(this);
  693.         }
  694.     }

  696.     public final Annotation_atomContext annotation_atom() throws RecognitionException {
  697.         Annotation_atomContext _localctx = new Annotation_atomContext(_ctx, getState());
  698.         enterRule(_localctx, 18, RULE_annotation_atom);
  699.         int _la;
  700.         try {
  701.             enterOuterAlt(_localctx, 1);
  702.             {
  703.             setState(186);
  704.             match(AT);
  705.             setState(187);
  706.             _la = _input.LA(1);
  707.             if ( !(_la==PARALLEL || _la==ATOMIC) ) {
  708.             _errHandler.recoverInline(this);
  709.             }
  710.             else {
  711.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  712.                 _errHandler.reportMatch(this);
  713.                 consume();
  714.             }
  715.             }
  716.         }
  717.         catch (RecognitionException re) {
  718.             _localctx.exception = re;
  719.             _errHandler.reportError(this, re);
  720.             _errHandler.recover(this, re);
  721.         }
  722.         finally {
  723.             exitRule();
  724.         }
  725.         return _localctx;
  726.     }

  728.     public static class Annotation_literalContext extends ParserRuleContext {
  729.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  730.         public Annotation_value_literalContext annotation_value_literal() {
  731.             return getRuleContext(Annotation_value_literalContext.class,0);
  732.         }
  733.         public Annotation_literalContext(ParserRuleContext parent, int invokingState) {
  734.             super(parent, invokingState);
  735.         }
  736.         @Override public int getRuleIndex() { return RULE_annotation_literal; }
  737.         @Override
  738.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  739.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_literal(this);
  740.             else return visitor.visitChildren(this);
  741.         }
  742.     }

  744.     public final Annotation_literalContext annotation_literal() throws RecognitionException {
  745.         Annotation_literalContext _localctx = new Annotation_literalContext(_ctx, getState());
  746.         enterRule(_localctx, 20, RULE_annotation_literal);
  747.         try {
  748.             enterOuterAlt(_localctx, 1);
  749.             {
  750.             setState(189);
  751.             match(AT);
  752.             setState(190);
  753.             annotation_value_literal();
  754.             }
  755.         }
  756.         catch (RecognitionException re) {
  757.             _localctx.exception = re;
  758.             _errHandler.reportError(this, re);
  759.             _errHandler.recover(this, re);
  760.         }
  761.         finally {
  762.             exitRule();
  763.         }
  764.         return _localctx;
  765.     }

  767.     public static class Annotation_value_literalContext extends ParserRuleContext {
  768.         public TerminalNode CONSTANT() { return getToken(PlanBundleParser.CONSTANT, 0); }
  769.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  770.         public VariableatomContext variableatom() {
  771.             return getRuleContext(VariableatomContext.class,0);
  772.         }
  773.         public TerminalNode COMMA() { return getToken(PlanBundleParser.COMMA, 0); }
  774.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  775.         public NumberContext number() {
  776.             return getRuleContext(NumberContext.class,0);
  777.         }
  778.         public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
  779.         public Annotation_value_literalContext(ParserRuleContext parent, int invokingState) {
  780.             super(parent, invokingState);
  781.         }
  782.         @Override public int getRuleIndex() { return RULE_annotation_value_literal; }
  783.         @Override
  784.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  785.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_value_literal(this);
  786.             else return visitor.visitChildren(this);
  787.         }
  788.     }

  790.     public final Annotation_value_literalContext annotation_value_literal() throws RecognitionException {
  791.         Annotation_value_literalContext _localctx = new Annotation_value_literalContext(_ctx, getState());
  792.         enterRule(_localctx, 22, RULE_annotation_value_literal);
  793.         try {
  794.             enterOuterAlt(_localctx, 1);
  795.             {
  796.             setState(192);
  797.             match(CONSTANT);
  798.             setState(193);
  799.             match(LEFTROUNDBRACKET);
  800.             setState(194);
  801.             variableatom();
  802.             setState(195);
  803.             match(COMMA);
  804.             setState(198);
  805.             _errHandler.sync(this);
  806.             switch (_input.LA(1)) {
  807.             case CONSTANTNUMBER:
  808.             case MINUS:
  809.             case DIGIT:
  810.                 {
  811.                 setState(196);
  812.                 number();
  813.                 }
  814.                 break;
  815.             case STRING:
  816.                 {
  817.                 setState(197);
  818.                 match(STRING);
  819.                 }
  820.                 break;
  821.             default:
  822.                 throw new NoViableAltException(this);
  823.             }
  824.             setState(200);
  825.             match(RIGHTROUNDBRACKET);
  826.             }
  827.         }
  828.         catch (RecognitionException re) {
  829.             _localctx.exception = re;
  830.             _errHandler.reportError(this, re);
  831.             _errHandler.recover(this, re);
  832.         }
  833.         finally {
  834.             exitRule();
  835.         }
  836.         return _localctx;
  837.     }

  839.     public static class Plan_triggerContext extends ParserRuleContext {
  840.         public Plan_belief_triggerContext plan_belief_trigger() {
  841.             return getRuleContext(Plan_belief_triggerContext.class,0);
  842.         }
  843.         public Plan_goal_triggerContext plan_goal_trigger() {
  844.             return getRuleContext(Plan_goal_triggerContext.class,0);
  845.         }
  846.         public Plan_triggerContext(ParserRuleContext parent, int invokingState) {
  847.             super(parent, invokingState);
  848.         }
  849.         @Override public int getRuleIndex() { return RULE_plan_trigger; }
  850.         @Override
  851.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  852.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_trigger(this);
  853.             else return visitor.visitChildren(this);
  854.         }
  855.     }

  857.     public final Plan_triggerContext plan_trigger() throws RecognitionException {
  858.         Plan_triggerContext _localctx = new Plan_triggerContext(_ctx, getState());
  859.         enterRule(_localctx, 24, RULE_plan_trigger);
  860.         try {
  861.             enterOuterAlt(_localctx, 1);
  862.             {
  863.             setState(204);
  864.             _errHandler.sync(this);
  865.             switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
  866.             case 1:
  867.                 {
  868.                 setState(202);
  869.                 plan_belief_trigger();
  870.                 }
  871.                 break;
  872.             case 2:
  873.                 {
  874.                 setState(203);
  875.                 plan_goal_trigger();
  876.                 }
  877.                 break;
  878.             }
  879.             }
  880.         }
  881.         catch (RecognitionException re) {
  882.             _localctx.exception = re;
  883.             _errHandler.reportError(this, re);
  884.             _errHandler.recover(this, re);
  885.         }
  886.         finally {
  887.             exitRule();
  888.         }
  889.         return _localctx;
  890.     }

  892.     public static class Plan_goal_triggerContext extends ParserRuleContext {
  893.         public TerminalNode EXCLAMATIONMARK() { return getToken(PlanBundleParser.EXCLAMATIONMARK, 0); }
  894.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  895.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  896.         public Plan_goal_triggerContext(ParserRuleContext parent, int invokingState) {
  897.             super(parent, invokingState);
  898.         }
  899.         @Override public int getRuleIndex() { return RULE_plan_goal_trigger; }
  900.         @Override
  901.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  902.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_goal_trigger(this);
  903.             else return visitor.visitChildren(this);
  904.         }
  905.     }

  907.     public final Plan_goal_triggerContext plan_goal_trigger() throws RecognitionException {
  908.         Plan_goal_triggerContext _localctx = new Plan_goal_triggerContext(_ctx, getState());
  909.         enterRule(_localctx, 26, RULE_plan_goal_trigger);
  910.         int _la;
  911.         try {
  912.             enterOuterAlt(_localctx, 1);
  913.             {
  914.             setState(206);
  915.             _la = _input.LA(1);
  916.             if ( !(_la==PLUS || _la==MINUS) ) {
  917.             _errHandler.recoverInline(this);
  918.             }
  919.             else {
  920.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  921.                 _errHandler.reportMatch(this);
  922.                 consume();
  923.             }
  924.             setState(207);
  925.             match(EXCLAMATIONMARK);
  926.             }
  927.         }
  928.         catch (RecognitionException re) {
  929.             _localctx.exception = re;
  930.             _errHandler.reportError(this, re);
  931.             _errHandler.recover(this, re);
  932.         }
  933.         finally {
  934.             exitRule();
  935.         }
  936.         return _localctx;
  937.     }

  939.     public static class Plan_belief_triggerContext extends ParserRuleContext {
  940.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  941.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  942.         public Plan_belief_triggerContext(ParserRuleContext parent, int invokingState) {
  943.             super(parent, invokingState);
  944.         }
  945.         @Override public int getRuleIndex() { return RULE_plan_belief_trigger; }
  946.         @Override
  947.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  948.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_belief_trigger(this);
  949.             else return visitor.visitChildren(this);
  950.         }
  951.     }

  953.     public final Plan_belief_triggerContext plan_belief_trigger() throws RecognitionException {
  954.         Plan_belief_triggerContext _localctx = new Plan_belief_triggerContext(_ctx, getState());
  955.         enterRule(_localctx, 28, RULE_plan_belief_trigger);
  956.         int _la;
  957.         try {
  958.             enterOuterAlt(_localctx, 1);
  959.             {
  960.             setState(209);
  961.             _la = _input.LA(1);
  962.             if ( !(_la==PLUS || _la==MINUS) ) {
  963.             _errHandler.recoverInline(this);
  964.             }
  965.             else {
  966.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  967.                 _errHandler.reportMatch(this);
  968.                 consume();
  969.             }
  970.             }
  971.         }
  972.         catch (RecognitionException re) {
  973.             _localctx.exception = re;
  974.             _errHandler.reportError(this, re);
  975.             _errHandler.recover(this, re);
  976.         }
  977.         finally {
  978.             exitRule();
  979.         }
  980.         return _localctx;
  981.     }

  983.     public static class BodyContext extends ParserRuleContext {
  984.         public List<Body_formulaContext> body_formula() {
  985.             return getRuleContexts(Body_formulaContext.class);
  986.         }
  987.         public Body_formulaContext body_formula(int i) {
  988.             return getRuleContext(Body_formulaContext.class,i);
  989.         }
  990.         public List<TerminalNode> SEMICOLON() { return getTokens(PlanBundleParser.SEMICOLON); }
  991.         public TerminalNode SEMICOLON(int i) {
  992.             return getToken(PlanBundleParser.SEMICOLON, i);
  993.         }
  994.         public BodyContext(ParserRuleContext parent, int invokingState) {
  995.             super(parent, invokingState);
  996.         }
  997.         @Override public int getRuleIndex() { return RULE_body; }
  998.         @Override
  999.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1000.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBody(this);
  1001.             else return visitor.visitChildren(this);
  1002.         }
  1003.     }

  1005.     public final BodyContext body() throws RecognitionException {
  1006.         BodyContext _localctx = new BodyContext(_ctx, getState());
  1007.         enterRule(_localctx, 30, RULE_body);
  1008.         int _la;
  1009.         try {
  1010.             enterOuterAlt(_localctx, 1);
  1011.             {
  1012.             setState(211);
  1013.             body_formula();
  1014.             setState(216);
  1015.             _errHandler.sync(this);
  1016.             _la = _input.LA(1);
  1017.             while (_la==SEMICOLON) {
  1018.                 {
  1019.                 {
  1020.                 setState(212);
  1021.                 match(SEMICOLON);
  1022.                 setState(213);
  1023.                 body_formula();
  1024.                 }
  1025.                 }
  1026.                 setState(218);
  1027.                 _errHandler.sync(this);
  1028.                 _la = _input.LA(1);
  1029.             }
  1030.             }
  1031.         }
  1032.         catch (RecognitionException re) {
  1033.             _localctx.exception = re;
  1034.             _errHandler.reportError(this, re);
  1035.             _errHandler.recover(this, re);
  1036.         }
  1037.         finally {
  1038.             exitRule();
  1039.         }
  1040.         return _localctx;
  1041.     }

  1043.     public static class Body_formulaContext extends ParserRuleContext {
  1044.         public Repair_formulaContext repair_formula() {
  1045.             return getRuleContext(Repair_formulaContext.class,0);
  1046.         }
  1047.         public Belief_actionContext belief_action() {
  1048.             return getRuleContext(Belief_actionContext.class,0);
  1049.         }
  1050.         public Deconstruct_expressionContext deconstruct_expression() {
  1051.             return getRuleContext(Deconstruct_expressionContext.class,0);
  1052.         }
  1053.         public Assignment_expressionContext assignment_expression() {
  1054.             return getRuleContext(Assignment_expressionContext.class,0);
  1055.         }
  1056.         public Unary_expressionContext unary_expression() {
  1057.             return getRuleContext(Unary_expressionContext.class,0);
  1058.         }
  1059.         public Binary_expressionContext binary_expression() {
  1060.             return getRuleContext(Binary_expressionContext.class,0);
  1061.         }
  1062.         public LambdaContext lambda() {
  1063.             return getRuleContext(LambdaContext.class,0);
  1064.         }
  1065.         public Body_formulaContext(ParserRuleContext parent, int invokingState) {
  1066.             super(parent, invokingState);
  1067.         }
  1068.         @Override public int getRuleIndex() { return RULE_body_formula; }
  1069.         @Override
  1070.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1071.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBody_formula(this);
  1072.             else return visitor.visitChildren(this);
  1073.         }
  1074.     }

  1076.     public final Body_formulaContext body_formula() throws RecognitionException {
  1077.         Body_formulaContext _localctx = new Body_formulaContext(_ctx, getState());
  1078.         enterRule(_localctx, 32, RULE_body_formula);
  1079.         try {
  1080.             setState(226);
  1081.             _errHandler.sync(this);
  1082.             switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
  1083.             case 1:
  1084.                 enterOuterAlt(_localctx, 1);
  1085.                 {
  1086.                 setState(219);
  1087.                 repair_formula();
  1088.                 }
  1089.                 break;
  1090.             case 2:
  1091.                 enterOuterAlt(_localctx, 2);
  1092.                 {
  1093.                 setState(220);
  1094.                 belief_action();
  1095.                 }
  1096.                 break;
  1097.             case 3:
  1098.                 enterOuterAlt(_localctx, 3);
  1099.                 {
  1100.                 setState(221);
  1101.                 deconstruct_expression();
  1102.                 }
  1103.                 break;
  1104.             case 4:
  1105.                 enterOuterAlt(_localctx, 4);
  1106.                 {
  1107.                 setState(222);
  1108.                 assignment_expression();
  1109.                 }
  1110.                 break;
  1111.             case 5:
  1112.                 enterOuterAlt(_localctx, 5);
  1113.                 {
  1114.                 setState(223);
  1115.                 unary_expression();
  1116.                 }
  1117.                 break;
  1118.             case 6:
  1119.                 enterOuterAlt(_localctx, 6);
  1120.                 {
  1121.                 setState(224);
  1122.                 binary_expression();
  1123.                 }
  1124.                 break;
  1125.             case 7:
  1126.                 enterOuterAlt(_localctx, 7);
  1127.                 {
  1128.                 setState(225);
  1129.                 lambda();
  1130.                 }
  1131.                 break;
  1132.             }
  1133.         }
  1134.         catch (RecognitionException re) {
  1135.             _localctx.exception = re;
  1136.             _errHandler.reportError(this, re);
  1137.             _errHandler.recover(this, re);
  1138.         }
  1139.         finally {
  1140.             exitRule();
  1141.         }
  1142.         return _localctx;
  1143.     }

  1145.     public static class Repair_formulaContext extends ParserRuleContext {
  1146.         public Executable_termContext executable_term() {
  1147.             return getRuleContext(Executable_termContext.class,0);
  1148.         }
  1149.         public Test_actionContext test_action() {
  1150.             return getRuleContext(Test_actionContext.class,0);
  1151.         }
  1152.         public Achievement_goal_actionContext achievement_goal_action() {
  1153.             return getRuleContext(Achievement_goal_actionContext.class,0);
  1154.         }
  1155.         public TerminalNode LEFTSHIFT() { return getToken(PlanBundleParser.LEFTSHIFT, 0); }
  1156.         public Repair_formulaContext repair_formula() {
  1157.             return getRuleContext(Repair_formulaContext.class,0);
  1158.         }
  1159.         public Repair_formulaContext(ParserRuleContext parent, int invokingState) {
  1160.             super(parent, invokingState);
  1161.         }
  1162.         @Override public int getRuleIndex() { return RULE_repair_formula; }
  1163.         @Override
  1164.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1165.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitRepair_formula(this);
  1166.             else return visitor.visitChildren(this);
  1167.         }
  1168.     }

  1170.     public final Repair_formulaContext repair_formula() throws RecognitionException {
  1171.         Repair_formulaContext _localctx = new Repair_formulaContext(_ctx, getState());
  1172.         enterRule(_localctx, 34, RULE_repair_formula);
  1173.         int _la;
  1174.         try {
  1175.             enterOuterAlt(_localctx, 1);
  1176.             {
  1177.             setState(231);
  1178.             _errHandler.sync(this);
  1179.             switch (_input.LA(1)) {
  1180.             case STRING:
  1181.             case LOGICALVALUE:
  1182.             case CONSTANTNUMBER:
  1183.             case STRONGNEGATION:
  1184.             case MINUS:
  1185.             case DOLLAR:
  1186.             case AT:
  1187.             case UNDERSCORE:
  1188.             case LEFTROUNDBRACKET:
  1189.             case RIGHTSHIFT:
  1190.             case LOWERCASELETTER:
  1191.             case UPPERCASELETTER:
  1192.             case DIGIT:
  1193.                 {
  1194.                 setState(228);
  1195.                 executable_term();
  1196.                 }
  1197.                 break;
  1198.             case QUESTIONMARK:
  1199.                 {
  1200.                 setState(229);
  1201.                 test_action();
  1202.                 }
  1203.                 break;
  1204.             case EXCLAMATIONMARK:
  1205.             case DOUBLEEXCLAMATIONMARK:
  1206.                 {
  1207.                 setState(230);
  1208.                 achievement_goal_action();
  1209.                 }
  1210.                 break;
  1211.             default:
  1212.                 throw new NoViableAltException(this);
  1213.             }
  1214.             setState(235);
  1215.             _errHandler.sync(this);
  1216.             _la = _input.LA(1);
  1217.             if (_la==LEFTSHIFT) {
  1218.                 {
  1219.                 setState(233);
  1220.                 match(LEFTSHIFT);
  1221.                 setState(234);
  1222.                 repair_formula();
  1223.                 }
  1224.             }

  1226.             }
  1227.         }
  1228.         catch (RecognitionException re) {
  1229.             _localctx.exception = re;
  1230.             _errHandler.reportError(this, re);
  1231.             _errHandler.recover(this, re);
  1232.         }
  1233.         finally {
  1234.             exitRule();
  1235.         }
  1236.         return _localctx;
  1237.     }

  1239.     public static class Belief_actionContext extends ParserRuleContext {
  1240.         public LiteralContext literal() {
  1241.             return getRuleContext(LiteralContext.class,0);
  1242.         }
  1243.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  1244.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  1245.         public Belief_actionContext(ParserRuleContext parent, int invokingState) {
  1246.             super(parent, invokingState);
  1247.         }
  1248.         @Override public int getRuleIndex() { return RULE_belief_action; }
  1249.         @Override
  1250.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1251.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBelief_action(this);
  1252.             else return visitor.visitChildren(this);
  1253.         }
  1254.     }

  1256.     public final Belief_actionContext belief_action() throws RecognitionException {
  1257.         Belief_actionContext _localctx = new Belief_actionContext(_ctx, getState());
  1258.         enterRule(_localctx, 36, RULE_belief_action);
  1259.         int _la;
  1260.         try {
  1261.             enterOuterAlt(_localctx, 1);
  1262.             {
  1263.             setState(237);
  1264.             _la = _input.LA(1);
  1265.             if ( !(_la==PLUS || _la==MINUS) ) {
  1266.             _errHandler.recoverInline(this);
  1267.             }
  1268.             else {
  1269.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  1270.                 _errHandler.reportMatch(this);
  1271.                 consume();
  1272.             }
  1273.             setState(238);
  1274.             literal();
  1275.             }
  1276.         }
  1277.         catch (RecognitionException re) {
  1278.             _localctx.exception = re;
  1279.             _errHandler.reportError(this, re);
  1280.             _errHandler.recover(this, re);
  1281.         }
  1282.         finally {
  1283.             exitRule();
  1284.         }
  1285.         return _localctx;
  1286.     }

  1288.     public static class Test_actionContext extends ParserRuleContext {
  1289.         public TerminalNode QUESTIONMARK() { return getToken(PlanBundleParser.QUESTIONMARK, 0); }
  1290.         public AtomContext atom() {
  1291.             return getRuleContext(AtomContext.class,0);
  1292.         }
  1293.         public TerminalNode DOLLAR() { return getToken(PlanBundleParser.DOLLAR, 0); }
  1294.         public Test_actionContext(ParserRuleContext parent, int invokingState) {
  1295.             super(parent, invokingState);
  1296.         }
  1297.         @Override public int getRuleIndex() { return RULE_test_action; }
  1298.         @Override
  1299.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1300.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTest_action(this);
  1301.             else return visitor.visitChildren(this);
  1302.         }
  1303.     }

  1305.     public final Test_actionContext test_action() throws RecognitionException {
  1306.         Test_actionContext _localctx = new Test_actionContext(_ctx, getState());
  1307.         enterRule(_localctx, 38, RULE_test_action);
  1308.         int _la;
  1309.         try {
  1310.             enterOuterAlt(_localctx, 1);
  1311.             {
  1312.             setState(240);
  1313.             match(QUESTIONMARK);
  1314.             setState(242);
  1315.             _errHandler.sync(this);
  1316.             _la = _input.LA(1);
  1317.             if (_la==DOLLAR) {
  1318.                 {
  1319.                 setState(241);
  1320.                 match(DOLLAR);
  1321.                 }
  1322.             }

  1324.             setState(244);
  1325.             atom();
  1326.             }
  1327.         }
  1328.         catch (RecognitionException re) {
  1329.             _localctx.exception = re;
  1330.             _errHandler.reportError(this, re);
  1331.             _errHandler.recover(this, re);
  1332.         }
  1333.         finally {
  1334.             exitRule();
  1335.         }
  1336.         return _localctx;
  1337.     }

  1339.     public static class Achievement_goal_actionContext extends ParserRuleContext {
  1340.         public TerminalNode EXCLAMATIONMARK() { return getToken(PlanBundleParser.EXCLAMATIONMARK, 0); }
  1341.         public TerminalNode DOUBLEEXCLAMATIONMARK() { return getToken(PlanBundleParser.DOUBLEEXCLAMATIONMARK, 0); }
  1342.         public LiteralContext literal() {
  1343.             return getRuleContext(LiteralContext.class,0);
  1344.         }
  1345.         public Variable_evaluateContext variable_evaluate() {
  1346.             return getRuleContext(Variable_evaluateContext.class,0);
  1347.         }
  1348.         public Achievement_goal_actionContext(ParserRuleContext parent, int invokingState) {
  1349.             super(parent, invokingState);
  1350.         }
  1351.         @Override public int getRuleIndex() { return RULE_achievement_goal_action; }
  1352.         @Override
  1353.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1354.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAchievement_goal_action(this);
  1355.             else return visitor.visitChildren(this);
  1356.         }
  1357.     }

  1359.     public final Achievement_goal_actionContext achievement_goal_action() throws RecognitionException {
  1360.         Achievement_goal_actionContext _localctx = new Achievement_goal_actionContext(_ctx, getState());
  1361.         enterRule(_localctx, 40, RULE_achievement_goal_action);
  1362.         int _la;
  1363.         try {
  1364.             enterOuterAlt(_localctx, 1);
  1365.             {
  1366.             setState(246);
  1367.             _la = _input.LA(1);
  1368.             if ( !(_la==EXCLAMATIONMARK || _la==DOUBLEEXCLAMATIONMARK) ) {
  1369.             _errHandler.recoverInline(this);
  1370.             }
  1371.             else {
  1372.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  1373.                 _errHandler.reportMatch(this);
  1374.                 consume();
  1375.             }
  1376.             setState(249);
  1377.             _errHandler.sync(this);
  1378.             switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
  1379.             case 1:
  1380.                 {
  1381.                 setState(247);
  1382.                 literal();
  1383.                 }
  1384.                 break;
  1385.             case 2:
  1386.                 {
  1387.                 setState(248);
  1388.                 variable_evaluate();
  1389.                 }
  1390.                 break;
  1391.             }
  1392.             }
  1393.         }
  1394.         catch (RecognitionException re) {
  1395.             _localctx.exception = re;
  1396.             _errHandler.reportError(this, re);
  1397.             _errHandler.recover(this, re);
  1398.         }
  1399.         finally {
  1400.             exitRule();
  1401.         }
  1402.         return _localctx;
  1403.     }

  1405.     public static class Deconstruct_expressionContext extends ParserRuleContext {
  1406.         public VariablelistContext variablelist() {
  1407.             return getRuleContext(VariablelistContext.class,0);
  1408.         }
  1409.         public TerminalNode DECONSTRUCT() { return getToken(PlanBundleParser.DECONSTRUCT, 0); }
  1410.         public LiteralContext literal() {
  1411.             return getRuleContext(LiteralContext.class,0);
  1412.         }
  1413.         public VariableContext variable() {
  1414.             return getRuleContext(VariableContext.class,0);
  1415.         }
  1416.         public Deconstruct_expressionContext(ParserRuleContext parent, int invokingState) {
  1417.             super(parent, invokingState);
  1418.         }
  1419.         @Override public int getRuleIndex() { return RULE_deconstruct_expression; }
  1420.         @Override
  1421.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1422.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitDeconstruct_expression(this);
  1423.             else return visitor.visitChildren(this);
  1424.         }
  1425.     }

  1427.     public final Deconstruct_expressionContext deconstruct_expression() throws RecognitionException {
  1428.         Deconstruct_expressionContext _localctx = new Deconstruct_expressionContext(_ctx, getState());
  1429.         enterRule(_localctx, 42, RULE_deconstruct_expression);
  1430.         try {
  1431.             enterOuterAlt(_localctx, 1);
  1432.             {
  1433.             setState(251);
  1434.             variablelist();
  1435.             setState(252);
  1436.             match(DECONSTRUCT);
  1437.             setState(255);
  1438.             _errHandler.sync(this);
  1439.             switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
  1440.             case 1:
  1441.                 {
  1442.                 setState(253);
  1443.                 literal();
  1444.                 }
  1445.                 break;
  1446.             case 2:
  1447.                 {
  1448.                 setState(254);
  1449.                 variable();
  1450.                 }
  1451.                 break;
  1452.             }
  1453.             }
  1454.         }
  1455.         catch (RecognitionException re) {
  1456.             _localctx.exception = re;
  1457.             _errHandler.reportError(this, re);
  1458.             _errHandler.recover(this, re);
  1459.         }
  1460.         finally {
  1461.             exitRule();
  1462.         }
  1463.         return _localctx;
  1464.     }

  1466.     public static class Assignment_expressionContext extends ParserRuleContext {
  1467.         public Assignment_expression_singlevariableContext assignment_expression_singlevariable() {
  1468.             return getRuleContext(Assignment_expression_singlevariableContext.class,0);
  1469.         }
  1470.         public Assignment_expression_multivariableContext assignment_expression_multivariable() {
  1471.             return getRuleContext(Assignment_expression_multivariableContext.class,0);
  1472.         }
  1473.         public Assignment_expressionContext(ParserRuleContext parent, int invokingState) {
  1474.             super(parent, invokingState);
  1475.         }
  1476.         @Override public int getRuleIndex() { return RULE_assignment_expression; }
  1477.         @Override
  1478.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1479.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression(this);
  1480.             else return visitor.visitChildren(this);
  1481.         }
  1482.     }

  1484.     public final Assignment_expressionContext assignment_expression() throws RecognitionException {
  1485.         Assignment_expressionContext _localctx = new Assignment_expressionContext(_ctx, getState());
  1486.         enterRule(_localctx, 44, RULE_assignment_expression);
  1487.         try {
  1488.             setState(259);
  1489.             _errHandler.sync(this);
  1490.             switch (_input.LA(1)) {
  1491.             case AT:
  1492.             case UNDERSCORE:
  1493.             case UPPERCASELETTER:
  1494.                 enterOuterAlt(_localctx, 1);
  1495.                 {
  1496.                 setState(257);
  1497.                 assignment_expression_singlevariable();
  1498.                 }
  1499.                 break;
  1500.             case LEFTANGULARBRACKET:
  1501.                 enterOuterAlt(_localctx, 2);
  1502.                 {
  1503.                 setState(258);
  1504.                 assignment_expression_multivariable();
  1505.                 }
  1506.                 break;
  1507.             default:
  1508.                 throw new NoViableAltException(this);
  1509.             }
  1510.         }
  1511.         catch (RecognitionException re) {
  1512.             _localctx.exception = re;
  1513.             _errHandler.reportError(this, re);
  1514.             _errHandler.recover(this, re);
  1515.         }
  1516.         finally {
  1517.             exitRule();
  1518.         }
  1519.         return _localctx;
  1520.     }

  1522.     public static class Assignment_expression_singlevariableContext extends ParserRuleContext {
  1523.         public VariableContext variable() {
  1524.             return getRuleContext(VariableContext.class,0);
  1525.         }
  1526.         public TerminalNode ASSIGN() { return getToken(PlanBundleParser.ASSIGN, 0); }
  1527.         public Executable_termContext executable_term() {
  1528.             return getRuleContext(Executable_termContext.class,0);
  1529.         }
  1530.         public Assignment_expression_singlevariableContext(ParserRuleContext parent, int invokingState) {
  1531.             super(parent, invokingState);
  1532.         }
  1533.         @Override public int getRuleIndex() { return RULE_assignment_expression_singlevariable; }
  1534.         @Override
  1535.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1536.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression_singlevariable(this);
  1537.             else return visitor.visitChildren(this);
  1538.         }
  1539.     }

  1541.     public final Assignment_expression_singlevariableContext assignment_expression_singlevariable() throws RecognitionException {
  1542.         Assignment_expression_singlevariableContext _localctx = new Assignment_expression_singlevariableContext(_ctx, getState());
  1543.         enterRule(_localctx, 46, RULE_assignment_expression_singlevariable);
  1544.         try {
  1545.             enterOuterAlt(_localctx, 1);
  1546.             {
  1547.             setState(261);
  1548.             variable();
  1549.             setState(262);
  1550.             match(ASSIGN);
  1551.             setState(263);
  1552.             executable_term();
  1553.             }
  1554.         }
  1555.         catch (RecognitionException re) {
  1556.             _localctx.exception = re;
  1557.             _errHandler.reportError(this, re);
  1558.             _errHandler.recover(this, re);
  1559.         }
  1560.         finally {
  1561.             exitRule();
  1562.         }
  1563.         return _localctx;
  1564.     }

  1566.     public static class Assignment_expression_multivariableContext extends ParserRuleContext {
  1567.         public VariablelistContext variablelist() {
  1568.             return getRuleContext(VariablelistContext.class,0);
  1569.         }
  1570.         public TerminalNode ASSIGN() { return getToken(PlanBundleParser.ASSIGN, 0); }
  1571.         public Executable_termContext executable_term() {
  1572.             return getRuleContext(Executable_termContext.class,0);
  1573.         }
  1574.         public Assignment_expression_multivariableContext(ParserRuleContext parent, int invokingState) {
  1575.             super(parent, invokingState);
  1576.         }
  1577.         @Override public int getRuleIndex() { return RULE_assignment_expression_multivariable; }
  1578.         @Override
  1579.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1580.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression_multivariable(this);
  1581.             else return visitor.visitChildren(this);
  1582.         }
  1583.     }

  1585.     public final Assignment_expression_multivariableContext assignment_expression_multivariable() throws RecognitionException {
  1586.         Assignment_expression_multivariableContext _localctx = new Assignment_expression_multivariableContext(_ctx, getState());
  1587.         enterRule(_localctx, 48, RULE_assignment_expression_multivariable);
  1588.         try {
  1589.             enterOuterAlt(_localctx, 1);
  1590.             {
  1591.             setState(265);
  1592.             variablelist();
  1593.             setState(266);
  1594.             match(ASSIGN);
  1595.             setState(267);
  1596.             executable_term();
  1597.             }
  1598.         }
  1599.         catch (RecognitionException re) {
  1600.             _localctx.exception = re;
  1601.             _errHandler.reportError(this, re);
  1602.             _errHandler.recover(this, re);
  1603.         }
  1604.         finally {
  1605.             exitRule();
  1606.         }
  1607.         return _localctx;
  1608.     }

  1610.     public static class Unary_expressionContext extends ParserRuleContext {
  1611.         public VariableContext variable() {
  1612.             return getRuleContext(VariableContext.class,0);
  1613.         }
  1614.         public TerminalNode UNARYOPERATOR() { return getToken(PlanBundleParser.UNARYOPERATOR, 0); }
  1615.         public Unary_expressionContext(ParserRuleContext parent, int invokingState) {
  1616.             super(parent, invokingState);
  1617.         }
  1618.         @Override public int getRuleIndex() { return RULE_unary_expression; }
  1619.         @Override
  1620.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1621.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnary_expression(this);
  1622.             else return visitor.visitChildren(this);
  1623.         }
  1624.     }

  1626.     public final Unary_expressionContext unary_expression() throws RecognitionException {
  1627.         Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState());
  1628.         enterRule(_localctx, 50, RULE_unary_expression);
  1629.         try {
  1630.             enterOuterAlt(_localctx, 1);
  1631.             {
  1632.             setState(269);
  1633.             variable();
  1634.             setState(270);
  1635.             match(UNARYOPERATOR);
  1636.             }
  1637.         }
  1638.         catch (RecognitionException re) {
  1639.             _localctx.exception = re;
  1640.             _errHandler.reportError(this, re);
  1641.             _errHandler.recover(this, re);
  1642.         }
  1643.         finally {
  1644.             exitRule();
  1645.         }
  1646.         return _localctx;
  1647.     }

  1649.     public static class Binary_expressionContext extends ParserRuleContext {
  1650.         public List<VariableContext> variable() {
  1651.             return getRuleContexts(VariableContext.class);
  1652.         }
  1653.         public VariableContext variable(int i) {
  1654.             return getRuleContext(VariableContext.class,i);
  1655.         }
  1656.         public TerminalNode BINARYOPERATOR() { return getToken(PlanBundleParser.BINARYOPERATOR, 0); }
  1657.         public NumberContext number() {
  1658.             return getRuleContext(NumberContext.class,0);
  1659.         }
  1660.         public Binary_expressionContext(ParserRuleContext parent, int invokingState) {
  1661.             super(parent, invokingState);
  1662.         }
  1663.         @Override public int getRuleIndex() { return RULE_binary_expression; }
  1664.         @Override
  1665.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1666.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBinary_expression(this);
  1667.             else return visitor.visitChildren(this);
  1668.         }
  1669.     }

  1671.     public final Binary_expressionContext binary_expression() throws RecognitionException {
  1672.         Binary_expressionContext _localctx = new Binary_expressionContext(_ctx, getState());
  1673.         enterRule(_localctx, 52, RULE_binary_expression);
  1674.         try {
  1675.             enterOuterAlt(_localctx, 1);
  1676.             {
  1677.             setState(272);
  1678.             variable();
  1679.             setState(273);
  1680.             match(BINARYOPERATOR);
  1681.             setState(276);
  1682.             _errHandler.sync(this);
  1683.             switch (_input.LA(1)) {
  1684.             case AT:
  1685.             case UNDERSCORE:
  1686.             case UPPERCASELETTER:
  1687.                 {
  1688.                 setState(274);
  1689.                 variable();
  1690.                 }
  1691.                 break;
  1692.             case CONSTANTNUMBER:
  1693.             case MINUS:
  1694.             case DIGIT:
  1695.                 {
  1696.                 setState(275);
  1697.                 number();
  1698.                 }
  1699.                 break;
  1700.             default:
  1701.                 throw new NoViableAltException(this);
  1702.             }
  1703.             }
  1704.         }
  1705.         catch (RecognitionException re) {
  1706.             _localctx.exception = re;
  1707.             _errHandler.reportError(this, re);
  1708.             _errHandler.recover(this, re);
  1709.         }
  1710.         finally {
  1711.             exitRule();
  1712.         }
  1713.         return _localctx;
  1714.     }

  1716.     public static class Block_formulaContext extends ParserRuleContext {
  1717.         public TerminalNode LEFTCURVEDBRACKET() { return getToken(PlanBundleParser.LEFTCURVEDBRACKET, 0); }
  1718.         public BodyContext body() {
  1719.             return getRuleContext(BodyContext.class,0);
  1720.         }
  1721.         public TerminalNode RIGHTCURVEDBRACKET() { return getToken(PlanBundleParser.RIGHTCURVEDBRACKET, 0); }
  1722.         public Body_formulaContext body_formula() {
  1723.             return getRuleContext(Body_formulaContext.class,0);
  1724.         }
  1725.         public Block_formulaContext(ParserRuleContext parent, int invokingState) {
  1726.             super(parent, invokingState);
  1727.         }
  1728.         @Override public int getRuleIndex() { return RULE_block_formula; }
  1729.         @Override
  1730.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1731.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBlock_formula(this);
  1732.             else return visitor.visitChildren(this);
  1733.         }
  1734.     }

  1736.     public final Block_formulaContext block_formula() throws RecognitionException {
  1737.         Block_formulaContext _localctx = new Block_formulaContext(_ctx, getState());
  1738.         enterRule(_localctx, 54, RULE_block_formula);
  1739.         try {
  1740.             setState(283);
  1741.             _errHandler.sync(this);
  1742.             switch (_input.LA(1)) {
  1743.             case LEFTCURVEDBRACKET:
  1744.                 enterOuterAlt(_localctx, 1);
  1745.                 {
  1746.                 setState(278);
  1747.                 match(LEFTCURVEDBRACKET);
  1748.                 setState(279);
  1749.                 body();
  1750.                 setState(280);
  1751.                 match(RIGHTCURVEDBRACKET);
  1752.                 }
  1753.                 break;
  1754.             case STRING:
  1755.             case LOGICALVALUE:
  1756.             case CONSTANTNUMBER:
  1757.             case EXCLAMATIONMARK:
  1758.             case STRONGNEGATION:
  1759.             case PLUS:
  1760.             case MINUS:
  1761.             case DOUBLEEXCLAMATIONMARK:
  1762.             case QUESTIONMARK:
  1763.             case DOLLAR:
  1764.             case AT:
  1765.             case UNDERSCORE:
  1766.             case LEFTROUNDBRACKET:
  1767.             case LEFTANGULARBRACKET:
  1768.             case RIGHTSHIFT:
  1769.             case LOWERCASELETTER:
  1770.             case UPPERCASELETTER:
  1771.             case DIGIT:
  1772.                 enterOuterAlt(_localctx, 2);
  1773.                 {
  1774.                 setState(282);
  1775.                 body_formula();
  1776.                 }
  1777.                 break;
  1778.             default:
  1779.                 throw new NoViableAltException(this);
  1780.             }
  1781.         }
  1782.         catch (RecognitionException re) {
  1783.             _localctx.exception = re;
  1784.             _errHandler.reportError(this, re);
  1785.             _errHandler.recover(this, re);
  1786.         }
  1787.         finally {
  1788.             exitRule();
  1789.         }
  1790.         return _localctx;
  1791.     }

  1793.     public static class LambdaContext extends ParserRuleContext {
  1794.         public Lambda_initializationContext lambda_initialization() {
  1795.             return getRuleContext(Lambda_initializationContext.class,0);
  1796.         }
  1797.         public TerminalNode RIGHTARROW() { return getToken(PlanBundleParser.RIGHTARROW, 0); }
  1798.         public VariableContext variable() {
  1799.             return getRuleContext(VariableContext.class,0);
  1800.         }
  1801.         public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
  1802.         public Block_formulaContext block_formula() {
  1803.             return getRuleContext(Block_formulaContext.class,0);
  1804.         }
  1805.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  1806.         public Lambda_returnContext lambda_return() {
  1807.             return getRuleContext(Lambda_returnContext.class,0);
  1808.         }
  1809.         public LambdaContext(ParserRuleContext parent, int invokingState) {
  1810.             super(parent, invokingState);
  1811.         }
  1812.         @Override public int getRuleIndex() { return RULE_lambda; }
  1813.         @Override
  1814.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1815.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda(this);
  1816.             else return visitor.visitChildren(this);
  1817.         }
  1818.     }

  1820.     public final LambdaContext lambda() throws RecognitionException {
  1821.         LambdaContext _localctx = new LambdaContext(_ctx, getState());
  1822.         enterRule(_localctx, 56, RULE_lambda);
  1823.         int _la;
  1824.         try {
  1825.             enterOuterAlt(_localctx, 1);
  1826.             {
  1827.             setState(286);
  1828.             _errHandler.sync(this);
  1829.             _la = _input.LA(1);
  1830.             if (_la==AT) {
  1831.                 {
  1832.                 setState(285);
  1833.                 match(AT);
  1834.                 }
  1835.             }

  1837.             setState(288);
  1838.             lambda_initialization();
  1839.             setState(289);
  1840.             match(RIGHTARROW);
  1841.             setState(290);
  1842.             variable();
  1843.             setState(292);
  1844.             _errHandler.sync(this);
  1845.             _la = _input.LA(1);
  1846.             if (_la==VLINE) {
  1847.                 {
  1848.                 setState(291);
  1849.                 lambda_return();
  1850.                 }
  1851.             }

  1853.             setState(294);
  1854.             match(COLON);
  1855.             setState(295);
  1856.             block_formula();
  1857.             }
  1858.         }
  1859.         catch (RecognitionException re) {
  1860.             _localctx.exception = re;
  1861.             _errHandler.reportError(this, re);
  1862.             _errHandler.recover(this, re);
  1863.         }
  1864.         finally {
  1865.             exitRule();
  1866.         }
  1867.         return _localctx;
  1868.     }

  1870.     public static class Lambda_initializationContext extends ParserRuleContext {
  1871.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  1872.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  1873.         public VariableContext variable() {
  1874.             return getRuleContext(VariableContext.class,0);
  1875.         }
  1876.         public LiteralContext literal() {
  1877.             return getRuleContext(LiteralContext.class,0);
  1878.         }
  1879.         public Lambda_initializationContext(ParserRuleContext parent, int invokingState) {
  1880.             super(parent, invokingState);
  1881.         }
  1882.         @Override public int getRuleIndex() { return RULE_lambda_initialization; }
  1883.         @Override
  1884.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1885.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda_initialization(this);
  1886.             else return visitor.visitChildren(this);
  1887.         }
  1888.     }

  1890.     public final Lambda_initializationContext lambda_initialization() throws RecognitionException {
  1891.         Lambda_initializationContext _localctx = new Lambda_initializationContext(_ctx, getState());
  1892.         enterRule(_localctx, 58, RULE_lambda_initialization);
  1893.         try {
  1894.             enterOuterAlt(_localctx, 1);
  1895.             {
  1896.             setState(297);
  1897.             match(LEFTROUNDBRACKET);
  1898.             setState(300);
  1899.             _errHandler.sync(this);
  1900.             switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
  1901.             case 1:
  1902.                 {
  1903.                 setState(298);
  1904.                 variable();
  1905.                 }
  1906.                 break;
  1907.             case 2:
  1908.                 {
  1909.                 setState(299);
  1910.                 literal();
  1911.                 }
  1912.                 break;
  1913.             }
  1914.             setState(302);
  1915.             match(RIGHTROUNDBRACKET);
  1916.             }
  1917.         }
  1918.         catch (RecognitionException re) {
  1919.             _localctx.exception = re;
  1920.             _errHandler.reportError(this, re);
  1921.             _errHandler.recover(this, re);
  1922.         }
  1923.         finally {
  1924.             exitRule();
  1925.         }
  1926.         return _localctx;
  1927.     }

  1929.     public static class Lambda_returnContext extends ParserRuleContext {
  1930.         public TerminalNode VLINE() { return getToken(PlanBundleParser.VLINE, 0); }
  1931.         public VariableContext variable() {
  1932.             return getRuleContext(VariableContext.class,0);
  1933.         }
  1934.         public Lambda_returnContext(ParserRuleContext parent, int invokingState) {
  1935.             super(parent, invokingState);
  1936.         }
  1937.         @Override public int getRuleIndex() { return RULE_lambda_return; }
  1938.         @Override
  1939.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1940.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda_return(this);
  1941.             else return visitor.visitChildren(this);
  1942.         }
  1943.     }

  1945.     public final Lambda_returnContext lambda_return() throws RecognitionException {
  1946.         Lambda_returnContext _localctx = new Lambda_returnContext(_ctx, getState());
  1947.         enterRule(_localctx, 60, RULE_lambda_return);
  1948.         try {
  1949.             enterOuterAlt(_localctx, 1);
  1950.             {
  1951.             setState(304);
  1952.             match(VLINE);
  1953.             setState(305);
  1954.             variable();
  1955.             }
  1956.         }
  1957.         catch (RecognitionException re) {
  1958.             _localctx.exception = re;
  1959.             _errHandler.reportError(this, re);
  1960.             _errHandler.recover(this, re);
  1961.         }
  1962.         finally {
  1963.             exitRule();
  1964.         }
  1965.         return _localctx;
  1966.     }

  1968.     public static class Executable_termContext extends ParserRuleContext {
  1969.         public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
  1970.         public NumberContext number() {
  1971.             return getRuleContext(NumberContext.class,0);
  1972.         }
  1973.         public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
  1974.         public Executable_actionContext executable_action() {
  1975.             return getRuleContext(Executable_actionContext.class,0);
  1976.         }
  1977.         public Executable_ruleContext executable_rule() {
  1978.             return getRuleContext(Executable_ruleContext.class,0);
  1979.         }
  1980.         public ExpressionContext expression() {
  1981.             return getRuleContext(ExpressionContext.class,0);
  1982.         }
  1983.         public Ternary_operationContext ternary_operation() {
  1984.             return getRuleContext(Ternary_operationContext.class,0);
  1985.         }
  1986.         public Executable_termContext(ParserRuleContext parent, int invokingState) {
  1987.             super(parent, invokingState);
  1988.         }
  1989.         @Override public int getRuleIndex() { return RULE_executable_term; }
  1990.         @Override
  1991.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1992.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_term(this);
  1993.             else return visitor.visitChildren(this);
  1994.         }
  1995.     }

  1997.     public final Executable_termContext executable_term() throws RecognitionException {
  1998.         Executable_termContext _localctx = new Executable_termContext(_ctx, getState());
  1999.         enterRule(_localctx, 62, RULE_executable_term);
  2000.         try {
  2001.             setState(314);
  2002.             _errHandler.sync(this);
  2003.             switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
  2004.             case 1:
  2005.                 enterOuterAlt(_localctx, 1);
  2006.                 {
  2007.                 setState(307);
  2008.                 match(STRING);
  2009.                 }
  2010.                 break;
  2011.             case 2:
  2012.                 enterOuterAlt(_localctx, 2);
  2013.                 {
  2014.                 setState(308);
  2015.                 number();
  2016.                 }
  2017.                 break;
  2018.             case 3:
  2019.                 enterOuterAlt(_localctx, 3);
  2020.                 {
  2021.                 setState(309);
  2022.                 match(LOGICALVALUE);
  2023.                 }
  2024.                 break;
  2025.             case 4:
  2026.                 enterOuterAlt(_localctx, 4);
  2027.                 {
  2028.                 setState(310);
  2029.                 executable_action();
  2030.                 }
  2031.                 break;
  2032.             case 5:
  2033.                 enterOuterAlt(_localctx, 5);
  2034.                 {
  2035.                 setState(311);
  2036.                 executable_rule();
  2037.                 }
  2038.                 break;
  2039.             case 6:
  2040.                 enterOuterAlt(_localctx, 6);
  2041.                 {
  2042.                 setState(312);
  2043.                 expression();
  2044.                 }
  2045.                 break;
  2046.             case 7:
  2047.                 enterOuterAlt(_localctx, 7);
  2048.                 {
  2049.                 setState(313);
  2050.                 ternary_operation();
  2051.                 }
  2052.                 break;
  2053.             }
  2054.         }
  2055.         catch (RecognitionException re) {
  2056.             _localctx.exception = re;
  2057.             _errHandler.reportError(this, re);
  2058.             _errHandler.recover(this, re);
  2059.         }
  2060.         finally {
  2061.             exitRule();
  2062.         }
  2063.         return _localctx;
  2064.     }

  2066.     public static class TermContext extends ParserRuleContext {
  2067.         public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
  2068.         public NumberContext number() {
  2069.             return getRuleContext(NumberContext.class,0);
  2070.         }
  2071.         public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
  2072.         public LiteralContext literal() {
  2073.             return getRuleContext(LiteralContext.class,0);
  2074.         }
  2075.         public VariableContext variable() {
  2076.             return getRuleContext(VariableContext.class,0);
  2077.         }
  2078.         public VariablelistContext variablelist() {
  2079.             return getRuleContext(VariablelistContext.class,0);
  2080.         }
  2081.         public TerminalNode LEFTANGULARBRACKET() { return getToken(PlanBundleParser.LEFTANGULARBRACKET, 0); }
  2082.         public TermlistContext termlist() {
  2083.             return getRuleContext(TermlistContext.class,0);
  2084.         }
  2085.         public TerminalNode RIGHTANGULARBRACKET() { return getToken(PlanBundleParser.RIGHTANGULARBRACKET, 0); }
  2086.         public ExpressionContext expression() {
  2087.             return getRuleContext(ExpressionContext.class,0);
  2088.         }
  2089.         public Ternary_operationContext ternary_operation() {
  2090.             return getRuleContext(Ternary_operationContext.class,0);
  2091.         }
  2092.         public TermContext(ParserRuleContext parent, int invokingState) {
  2093.             super(parent, invokingState);
  2094.         }
  2095.         @Override public int getRuleIndex() { return RULE_term; }
  2096.         @Override
  2097.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2098.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTerm(this);
  2099.             else return visitor.visitChildren(this);
  2100.         }
  2101.     }

  2103.     public final TermContext term() throws RecognitionException {
  2104.         TermContext _localctx = new TermContext(_ctx, getState());
  2105.         enterRule(_localctx, 64, RULE_term);
  2106.         try {
  2107.             setState(328);
  2108.             _errHandler.sync(this);
  2109.             switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
  2110.             case 1:
  2111.                 enterOuterAlt(_localctx, 1);
  2112.                 {
  2113.                 setState(316);
  2114.                 match(STRING);
  2115.                 }
  2116.                 break;
  2117.             case 2:
  2118.                 enterOuterAlt(_localctx, 2);
  2119.                 {
  2120.                 setState(317);
  2121.                 number();
  2122.                 }
  2123.                 break;
  2124.             case 3:
  2125.                 enterOuterAlt(_localctx, 3);
  2126.                 {
  2127.                 setState(318);
  2128.                 match(LOGICALVALUE);
  2129.                 }
  2130.                 break;
  2131.             case 4:
  2132.                 enterOuterAlt(_localctx, 4);
  2133.                 {
  2134.                 setState(319);
  2135.                 literal();
  2136.                 }
  2137.                 break;
  2138.             case 5:
  2139.                 enterOuterAlt(_localctx, 5);
  2140.                 {
  2141.                 setState(320);
  2142.                 variable();
  2143.                 }
  2144.                 break;
  2145.             case 6:
  2146.                 enterOuterAlt(_localctx, 6);
  2147.                 {
  2148.                 setState(321);
  2149.                 variablelist();
  2150.                 }
  2151.                 break;
  2152.             case 7:
  2153.                 enterOuterAlt(_localctx, 7);
  2154.                 {
  2155.                 setState(322);
  2156.                 match(LEFTANGULARBRACKET);
  2157.                 setState(323);
  2158.                 termlist();
  2159.                 setState(324);
  2160.                 match(RIGHTANGULARBRACKET);
  2161.                 }
  2162.                 break;
  2163.             case 8:
  2164.                 enterOuterAlt(_localctx, 8);
  2165.                 {
  2166.                 setState(326);
  2167.                 expression();
  2168.                 }
  2169.                 break;
  2170.             case 9:
  2171.                 enterOuterAlt(_localctx, 9);
  2172.                 {
  2173.                 setState(327);
  2174.                 ternary_operation();
  2175.                 }
  2176.                 break;
  2177.             }
  2178.         }
  2179.         catch (RecognitionException re) {
  2180.             _localctx.exception = re;
  2181.             _errHandler.reportError(this, re);
  2182.             _errHandler.recover(this, re);
  2183.         }
  2184.         finally {
  2185.             exitRule();
  2186.         }
  2187.         return _localctx;
  2188.     }

  2190.     public static class UnificationContext extends ParserRuleContext {
  2191.         public TerminalNode RIGHTSHIFT() { return getToken(PlanBundleParser.RIGHTSHIFT, 0); }
  2192.         public LiteralContext literal() {
  2193.             return getRuleContext(LiteralContext.class,0);
  2194.         }
  2195.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  2196.         public TerminalNode COMMA() { return getToken(PlanBundleParser.COMMA, 0); }
  2197.         public Unification_constraintContext unification_constraint() {
  2198.             return getRuleContext(Unification_constraintContext.class,0);
  2199.         }
  2200.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  2201.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  2202.         public UnificationContext(ParserRuleContext parent, int invokingState) {
  2203.             super(parent, invokingState);
  2204.         }
  2205.         @Override public int getRuleIndex() { return RULE_unification; }
  2206.         @Override
  2207.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2208.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnification(this);
  2209.             else return visitor.visitChildren(this);
  2210.         }
  2211.     }

  2213.     public final UnificationContext unification() throws RecognitionException {
  2214.         UnificationContext _localctx = new UnificationContext(_ctx, getState());
  2215.         enterRule(_localctx, 66, RULE_unification);
  2216.         int _la;
  2217.         try {
  2218.             enterOuterAlt(_localctx, 1);
  2219.             {
  2220.             setState(331);
  2221.             _errHandler.sync(this);
  2222.             _la = _input.LA(1);
  2223.             if (_la==AT) {
  2224.                 {
  2225.                 setState(330);
  2226.                 match(AT);
  2227.                 }
  2228.             }

  2230.             setState(333);
  2231.             match(RIGHTSHIFT);
  2232.             setState(341);
  2233.             _errHandler.sync(this);
  2234.             switch (_input.LA(1)) {
  2235.             case STRONGNEGATION:
  2236.             case AT:
  2237.             case LOWERCASELETTER:
  2238.                 {
  2239.                 setState(334);
  2240.                 literal();
  2241.                 }
  2242.                 break;
  2243.             case LEFTROUNDBRACKET:
  2244.                 {
  2245.                 setState(335);
  2246.                 match(LEFTROUNDBRACKET);
  2247.                 setState(336);
  2248.                 literal();
  2249.                 setState(337);
  2250.                 match(COMMA);
  2251.                 setState(338);
  2252.                 unification_constraint();
  2253.                 setState(339);
  2254.                 match(RIGHTROUNDBRACKET);
  2255.                 }
  2256.                 break;
  2257.             default:
  2258.                 throw new NoViableAltException(this);
  2259.             }
  2260.             }
  2261.         }
  2262.         catch (RecognitionException re) {
  2263.             _localctx.exception = re;
  2264.             _errHandler.reportError(this, re);
  2265.             _errHandler.recover(this, re);
  2266.         }
  2267.         finally {
  2268.             exitRule();
  2269.         }
  2270.         return _localctx;
  2271.     }

  2273.     public static class Unification_constraintContext extends ParserRuleContext {
  2274.         public VariableContext variable() {
  2275.             return getRuleContext(VariableContext.class,0);
  2276.         }
  2277.         public ExpressionContext expression() {
  2278.             return getRuleContext(ExpressionContext.class,0);
  2279.         }
  2280.         public Unification_constraintContext(ParserRuleContext parent, int invokingState) {
  2281.             super(parent, invokingState);
  2282.         }
  2283.         @Override public int getRuleIndex() { return RULE_unification_constraint; }
  2284.         @Override
  2285.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2286.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnification_constraint(this);
  2287.             else return visitor.visitChildren(this);
  2288.         }
  2289.     }

  2291.     public final Unification_constraintContext unification_constraint() throws RecognitionException {
  2292.         Unification_constraintContext _localctx = new Unification_constraintContext(_ctx, getState());
  2293.         enterRule(_localctx, 68, RULE_unification_constraint);
  2294.         try {
  2295.             setState(345);
  2296.             _errHandler.sync(this);
  2297.             switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
  2298.             case 1:
  2299.                 enterOuterAlt(_localctx, 1);
  2300.                 {
  2301.                 setState(343);
  2302.                 variable();
  2303.                 }
  2304.                 break;
  2305.             case 2:
  2306.                 enterOuterAlt(_localctx, 2);
  2307.                 {
  2308.                 setState(344);
  2309.                 expression();
  2310.                 }
  2311.                 break;
  2312.             }
  2313.         }
  2314.         catch (RecognitionException re) {
  2315.             _localctx.exception = re;
  2316.             _errHandler.reportError(this, re);
  2317.             _errHandler.recover(this, re);
  2318.         }
  2319.         finally {
  2320.             exitRule();
  2321.         }
  2322.         return _localctx;
  2323.     }

  2325.     public static class Ternary_operationContext extends ParserRuleContext {
  2326.         public ExpressionContext expression() {
  2327.             return getRuleContext(ExpressionContext.class,0);
  2328.         }
  2329.         public Ternary_operation_trueContext ternary_operation_true() {
  2330.             return getRuleContext(Ternary_operation_trueContext.class,0);
  2331.         }
  2332.         public Ternary_operation_falseContext ternary_operation_false() {
  2333.             return getRuleContext(Ternary_operation_falseContext.class,0);
  2334.         }
  2335.         public Ternary_operationContext(ParserRuleContext parent, int invokingState) {
  2336.             super(parent, invokingState);
  2337.         }
  2338.         @Override public int getRuleIndex() { return RULE_ternary_operation; }
  2339.         @Override
  2340.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2341.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation(this);
  2342.             else return visitor.visitChildren(this);
  2343.         }
  2344.     }

  2346.     public final Ternary_operationContext ternary_operation() throws RecognitionException {
  2347.         Ternary_operationContext _localctx = new Ternary_operationContext(_ctx, getState());
  2348.         enterRule(_localctx, 70, RULE_ternary_operation);
  2349.         try {
  2350.             enterOuterAlt(_localctx, 1);
  2351.             {
  2352.             setState(347);
  2353.             expression();
  2354.             setState(348);
  2355.             ternary_operation_true();
  2356.             setState(349);
  2357.             ternary_operation_false();
  2358.             }
  2359.         }
  2360.         catch (RecognitionException re) {
  2361.             _localctx.exception = re;
  2362.             _errHandler.reportError(this, re);
  2363.             _errHandler.recover(this, re);
  2364.         }
  2365.         finally {
  2366.             exitRule();
  2367.         }
  2368.         return _localctx;
  2369.     }

  2371.     public static class Ternary_operation_trueContext extends ParserRuleContext {
  2372.         public TerminalNode QUESTIONMARK() { return getToken(PlanBundleParser.QUESTIONMARK, 0); }
  2373.         public Executable_termContext executable_term() {
  2374.             return getRuleContext(Executable_termContext.class,0);
  2375.         }
  2376.         public Ternary_operation_trueContext(ParserRuleContext parent, int invokingState) {
  2377.             super(parent, invokingState);
  2378.         }
  2379.         @Override public int getRuleIndex() { return RULE_ternary_operation_true; }
  2380.         @Override
  2381.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2382.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation_true(this);
  2383.             else return visitor.visitChildren(this);
  2384.         }
  2385.     }

  2387.     public final Ternary_operation_trueContext ternary_operation_true() throws RecognitionException {
  2388.         Ternary_operation_trueContext _localctx = new Ternary_operation_trueContext(_ctx, getState());
  2389.         enterRule(_localctx, 72, RULE_ternary_operation_true);
  2390.         try {
  2391.             enterOuterAlt(_localctx, 1);
  2392.             {
  2393.             setState(351);
  2394.             match(QUESTIONMARK);
  2395.             setState(352);
  2396.             executable_term();
  2397.             }
  2398.         }
  2399.         catch (RecognitionException re) {
  2400.             _localctx.exception = re;
  2401.             _errHandler.reportError(this, re);
  2402.             _errHandler.recover(this, re);
  2403.         }
  2404.         finally {
  2405.             exitRule();
  2406.         }
  2407.         return _localctx;
  2408.     }

  2410.     public static class Ternary_operation_falseContext extends ParserRuleContext {
  2411.         public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
  2412.         public Executable_termContext executable_term() {
  2413.             return getRuleContext(Executable_termContext.class,0);
  2414.         }
  2415.         public Ternary_operation_falseContext(ParserRuleContext parent, int invokingState) {
  2416.             super(parent, invokingState);
  2417.         }
  2418.         @Override public int getRuleIndex() { return RULE_ternary_operation_false; }
  2419.         @Override
  2420.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2421.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation_false(this);
  2422.             else return visitor.visitChildren(this);
  2423.         }
  2424.     }

  2426.     public final Ternary_operation_falseContext ternary_operation_false() throws RecognitionException {
  2427.         Ternary_operation_falseContext _localctx = new Ternary_operation_falseContext(_ctx, getState());
  2428.         enterRule(_localctx, 74, RULE_ternary_operation_false);
  2429.         try {
  2430.             enterOuterAlt(_localctx, 1);
  2431.             {
  2432.             setState(354);
  2433.             match(COLON);
  2434.             setState(355);
  2435.             executable_term();
  2436.             }
  2437.         }
  2438.         catch (RecognitionException re) {
  2439.             _localctx.exception = re;
  2440.             _errHandler.reportError(this, re);
  2441.             _errHandler.recover(this, re);
  2442.         }
  2443.         finally {
  2444.             exitRule();
  2445.         }
  2446.         return _localctx;
  2447.     }

  2449.     public static class ExpressionContext extends ParserRuleContext {
  2450.         public Expression_bracketContext expression_bracket() {
  2451.             return getRuleContext(Expression_bracketContext.class,0);
  2452.         }
  2453.         public Expression_logical_andContext expression_logical_and() {
  2454.             return getRuleContext(Expression_logical_andContext.class,0);
  2455.         }
  2456.         public List<TerminalNode> OR() { return getTokens(PlanBundleParser.OR); }
  2457.         public TerminalNode OR(int i) {
  2458.             return getToken(PlanBundleParser.OR, i);
  2459.         }
  2460.         public List<ExpressionContext> expression() {
  2461.             return getRuleContexts(ExpressionContext.class);
  2462.         }
  2463.         public ExpressionContext expression(int i) {
  2464.             return getRuleContext(ExpressionContext.class,i);
  2465.         }
  2466.         public ExpressionContext(ParserRuleContext parent, int invokingState) {
  2467.             super(parent, invokingState);
  2468.         }
  2469.         @Override public int getRuleIndex() { return RULE_expression; }
  2470.         @Override
  2471.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2472.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression(this);
  2473.             else return visitor.visitChildren(this);
  2474.         }
  2475.     }

  2477.     public final ExpressionContext expression() throws RecognitionException {
  2478.         ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
  2479.         enterRule(_localctx, 76, RULE_expression);
  2480.         try {
  2481.             int _alt;
  2482.             setState(366);
  2483.             _errHandler.sync(this);
  2484.             switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
  2485.             case 1:
  2486.                 enterOuterAlt(_localctx, 1);
  2487.                 {
  2488.                 setState(357);
  2489.                 expression_bracket();
  2490.                 }
  2491.                 break;
  2492.             case 2:
  2493.                 enterOuterAlt(_localctx, 2);
  2494.                 {
  2495.                 setState(358);
  2496.                 expression_logical_and();
  2497.                 setState(363);
  2498.                 _errHandler.sync(this);
  2499.                 _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
  2500.                 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  2501.                     if ( _alt==1 ) {
  2502.                         {
  2503.                         {
  2504.                         setState(359);
  2505.                         match(OR);
  2506.                         setState(360);
  2507.                         expression();
  2508.                         }
  2509.                         } 
  2510.                     }
  2511.                     setState(365);
  2512.                     _errHandler.sync(this);
  2513.                     _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
  2514.                 }
  2515.                 }
  2516.                 break;
  2517.             }
  2518.         }
  2519.         catch (RecognitionException re) {
  2520.             _localctx.exception = re;
  2521.             _errHandler.reportError(this, re);
  2522.             _errHandler.recover(this, re);
  2523.         }
  2524.         finally {
  2525.             exitRule();
  2526.         }
  2527.         return _localctx;
  2528.     }

  2530.     public static class Expression_bracketContext extends ParserRuleContext {
  2531.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  2532.         public ExpressionContext expression() {
  2533.             return getRuleContext(ExpressionContext.class,0);
  2534.         }
  2535.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  2536.         public Expression_bracketContext(ParserRuleContext parent, int invokingState) {
  2537.             super(parent, invokingState);
  2538.         }
  2539.         @Override public int getRuleIndex() { return RULE_expression_bracket; }
  2540.         @Override
  2541.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2542.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_bracket(this);
  2543.             else return visitor.visitChildren(this);
  2544.         }
  2545.     }

  2547.     public final Expression_bracketContext expression_bracket() throws RecognitionException {
  2548.         Expression_bracketContext _localctx = new Expression_bracketContext(_ctx, getState());
  2549.         enterRule(_localctx, 78, RULE_expression_bracket);
  2550.         try {
  2551.             enterOuterAlt(_localctx, 1);
  2552.             {
  2553.             setState(368);
  2554.             match(LEFTROUNDBRACKET);
  2555.             setState(369);
  2556.             expression();
  2557.             setState(370);
  2558.             match(RIGHTROUNDBRACKET);
  2559.             }
  2560.         }
  2561.         catch (RecognitionException re) {
  2562.             _localctx.exception = re;
  2563.             _errHandler.reportError(this, re);
  2564.             _errHandler.recover(this, re);
  2565.         }
  2566.         finally {
  2567.             exitRule();
  2568.         }
  2569.         return _localctx;
  2570.     }

  2572.     public static class Expression_logical_andContext extends ParserRuleContext {
  2573.         public Expression_logical_xorContext expression_logical_xor() {
  2574.             return getRuleContext(Expression_logical_xorContext.class,0);
  2575.         }
  2576.         public List<TerminalNode> AND() { return getTokens(PlanBundleParser.AND); }
  2577.         public TerminalNode AND(int i) {
  2578.             return getToken(PlanBundleParser.AND, i);
  2579.         }
  2580.         public List<ExpressionContext> expression() {
  2581.             return getRuleContexts(ExpressionContext.class);
  2582.         }
  2583.         public ExpressionContext expression(int i) {
  2584.             return getRuleContext(ExpressionContext.class,i);
  2585.         }
  2586.         public Expression_logical_andContext(ParserRuleContext parent, int invokingState) {
  2587.             super(parent, invokingState);
  2588.         }
  2589.         @Override public int getRuleIndex() { return RULE_expression_logical_and; }
  2590.         @Override
  2591.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2592.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_and(this);
  2593.             else return visitor.visitChildren(this);
  2594.         }
  2595.     }

  2597.     public final Expression_logical_andContext expression_logical_and() throws RecognitionException {
  2598.         Expression_logical_andContext _localctx = new Expression_logical_andContext(_ctx, getState());
  2599.         enterRule(_localctx, 80, RULE_expression_logical_and);
  2600.         try {
  2601.             int _alt;
  2602.             enterOuterAlt(_localctx, 1);
  2603.             {
  2604.             setState(372);
  2605.             expression_logical_xor();
  2606.             setState(377);
  2607.             _errHandler.sync(this);
  2608.             _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
  2609.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  2610.                 if ( _alt==1 ) {
  2611.                     {
  2612.                     {
  2613.                     setState(373);
  2614.                     match(AND);
  2615.                     setState(374);
  2616.                     expression();
  2617.                     }
  2618.                     } 
  2619.                 }
  2620.                 setState(379);
  2621.                 _errHandler.sync(this);
  2622.                 _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
  2623.             }
  2624.             }
  2625.         }
  2626.         catch (RecognitionException re) {
  2627.             _localctx.exception = re;
  2628.             _errHandler.reportError(this, re);
  2629.             _errHandler.recover(this, re);
  2630.         }
  2631.         finally {
  2632.             exitRule();
  2633.         }
  2634.         return _localctx;
  2635.     }

  2637.     public static class Expression_logical_xorContext extends ParserRuleContext {
  2638.         public Expression_logical_negationContext expression_logical_negation() {
  2639.             return getRuleContext(Expression_logical_negationContext.class,0);
  2640.         }
  2641.         public Expression_logical_elementContext expression_logical_element() {
  2642.             return getRuleContext(Expression_logical_elementContext.class,0);
  2643.         }
  2644.         public Expression_numericContext expression_numeric() {
  2645.             return getRuleContext(Expression_numericContext.class,0);
  2646.         }
  2647.         public List<TerminalNode> XOR() { return getTokens(PlanBundleParser.XOR); }
  2648.         public TerminalNode XOR(int i) {
  2649.             return getToken(PlanBundleParser.XOR, i);
  2650.         }
  2651.         public List<ExpressionContext> expression() {
  2652.             return getRuleContexts(ExpressionContext.class);
  2653.         }
  2654.         public ExpressionContext expression(int i) {
  2655.             return getRuleContext(ExpressionContext.class,i);
  2656.         }
  2657.         public Expression_logical_xorContext(ParserRuleContext parent, int invokingState) {
  2658.             super(parent, invokingState);
  2659.         }
  2660.         @Override public int getRuleIndex() { return RULE_expression_logical_xor; }
  2661.         @Override
  2662.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2663.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_xor(this);
  2664.             else return visitor.visitChildren(this);
  2665.         }
  2666.     }

  2668.     public final Expression_logical_xorContext expression_logical_xor() throws RecognitionException {
  2669.         Expression_logical_xorContext _localctx = new Expression_logical_xorContext(_ctx, getState());
  2670.         enterRule(_localctx, 82, RULE_expression_logical_xor);
  2671.         try {
  2672.             int _alt;
  2673.             enterOuterAlt(_localctx, 1);
  2674.             {
  2675.             setState(383);
  2676.             _errHandler.sync(this);
  2677.             switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
  2678.             case 1:
  2679.                 {
  2680.                 setState(380);
  2681.                 expression_logical_negation();
  2682.                 }
  2683.                 break;
  2684.             case 2:
  2685.                 {
  2686.                 setState(381);
  2687.                 expression_logical_element();
  2688.                 }
  2689.                 break;
  2690.             case 3:
  2691.                 {
  2692.                 setState(382);
  2693.                 expression_numeric();
  2694.                 }
  2695.                 break;
  2696.             }
  2697.             setState(389);
  2698.             _errHandler.sync(this);
  2699.             _alt = getInterpreter().adaptivePredict(_input,35,_ctx);
  2700.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  2701.                 if ( _alt==1 ) {
  2702.                     {
  2703.                     {
  2704.                     setState(385);
  2705.                     match(XOR);
  2706.                     setState(386);
  2707.                     expression();
  2708.                     }
  2709.                     } 
  2710.                 }
  2711.                 setState(391);
  2712.                 _errHandler.sync(this);
  2713.                 _alt = getInterpreter().adaptivePredict(_input,35,_ctx);
  2714.             }
  2715.             }
  2716.         }
  2717.         catch (RecognitionException re) {
  2718.             _localctx.exception = re;
  2719.             _errHandler.reportError(this, re);
  2720.             _errHandler.recover(this, re);
  2721.         }
  2722.         finally {
  2723.             exitRule();
  2724.         }
  2725.         return _localctx;
  2726.     }

  2728.     public static class Expression_logical_elementContext extends ParserRuleContext {
  2729.         public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
  2730.         public VariableContext variable() {
  2731.             return getRuleContext(VariableContext.class,0);
  2732.         }
  2733.         public Executable_actionContext executable_action() {
  2734.             return getRuleContext(Executable_actionContext.class,0);
  2735.         }
  2736.         public Executable_ruleContext executable_rule() {
  2737.             return getRuleContext(Executable_ruleContext.class,0);
  2738.         }
  2739.         public UnificationContext unification() {
  2740.             return getRuleContext(UnificationContext.class,0);
  2741.         }
  2742.         public Expression_logical_elementContext(ParserRuleContext parent, int invokingState) {
  2743.             super(parent, invokingState);
  2744.         }
  2745.         @Override public int getRuleIndex() { return RULE_expression_logical_element; }
  2746.         @Override
  2747.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2748.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_element(this);
  2749.             else return visitor.visitChildren(this);
  2750.         }
  2751.     }

  2753.     public final Expression_logical_elementContext expression_logical_element() throws RecognitionException {
  2754.         Expression_logical_elementContext _localctx = new Expression_logical_elementContext(_ctx, getState());
  2755.         enterRule(_localctx, 84, RULE_expression_logical_element);
  2756.         try {
  2757.             setState(397);
  2758.             _errHandler.sync(this);
  2759.             switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
  2760.             case 1:
  2761.                 enterOuterAlt(_localctx, 1);
  2762.                 {
  2763.                 setState(392);
  2764.                 match(LOGICALVALUE);
  2765.                 }
  2766.                 break;
  2767.             case 2:
  2768.                 enterOuterAlt(_localctx, 2);
  2769.                 {
  2770.                 setState(393);
  2771.                 variable();
  2772.                 }
  2773.                 break;
  2774.             case 3:
  2775.                 enterOuterAlt(_localctx, 3);
  2776.                 {
  2777.                 setState(394);
  2778.                 executable_action();
  2779.                 }
  2780.                 break;
  2781.             case 4:
  2782.                 enterOuterAlt(_localctx, 4);
  2783.                 {
  2784.                 setState(395);
  2785.                 executable_rule();
  2786.                 }
  2787.                 break;
  2788.             case 5:
  2789.                 enterOuterAlt(_localctx, 5);
  2790.                 {
  2791.                 setState(396);
  2792.                 unification();
  2793.                 }
  2794.                 break;
  2795.             }
  2796.         }
  2797.         catch (RecognitionException re) {
  2798.             _localctx.exception = re;
  2799.             _errHandler.reportError(this, re);
  2800.             _errHandler.recover(this, re);
  2801.         }
  2802.         finally {
  2803.             exitRule();
  2804.         }
  2805.         return _localctx;
  2806.     }

  2808.     public static class Expression_logical_negationContext extends ParserRuleContext {
  2809.         public TerminalNode STRONGNEGATION() { return getToken(PlanBundleParser.STRONGNEGATION, 0); }
  2810.         public ExpressionContext expression() {
  2811.             return getRuleContext(ExpressionContext.class,0);
  2812.         }
  2813.         public Expression_logical_negationContext(ParserRuleContext parent, int invokingState) {
  2814.             super(parent, invokingState);
  2815.         }
  2816.         @Override public int getRuleIndex() { return RULE_expression_logical_negation; }
  2817.         @Override
  2818.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2819.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_negation(this);
  2820.             else return visitor.visitChildren(this);
  2821.         }
  2822.     }

  2824.     public final Expression_logical_negationContext expression_logical_negation() throws RecognitionException {
  2825.         Expression_logical_negationContext _localctx = new Expression_logical_negationContext(_ctx, getState());
  2826.         enterRule(_localctx, 86, RULE_expression_logical_negation);
  2827.         try {
  2828.             enterOuterAlt(_localctx, 1);
  2829.             {
  2830.             setState(399);
  2831.             match(STRONGNEGATION);
  2832.             setState(400);
  2833.             expression();
  2834.             }
  2835.         }
  2836.         catch (RecognitionException re) {
  2837.             _localctx.exception = re;
  2838.             _errHandler.reportError(this, re);
  2839.             _errHandler.recover(this, re);
  2840.         }
  2841.         finally {
  2842.             exitRule();
  2843.         }
  2844.         return _localctx;
  2845.     }

  2847.     public static class Expression_numericContext extends ParserRuleContext {
  2848.         public Expression_numeric_relationContext expression_numeric_relation() {
  2849.             return getRuleContext(Expression_numeric_relationContext.class,0);
  2850.         }
  2851.         public Expression_numericContext expression_numeric() {
  2852.             return getRuleContext(Expression_numericContext.class,0);
  2853.         }
  2854.         public TerminalNode EQUAL() { return getToken(PlanBundleParser.EQUAL, 0); }
  2855.         public TerminalNode NOTEQUAL() { return getToken(PlanBundleParser.NOTEQUAL, 0); }
  2856.         public Expression_numericContext(ParserRuleContext parent, int invokingState) {
  2857.             super(parent, invokingState);
  2858.         }
  2859.         @Override public int getRuleIndex() { return RULE_expression_numeric; }
  2860.         @Override
  2861.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2862.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric(this);
  2863.             else return visitor.visitChildren(this);
  2864.         }
  2865.     }

  2867.     public final Expression_numericContext expression_numeric() throws RecognitionException {
  2868.         Expression_numericContext _localctx = new Expression_numericContext(_ctx, getState());
  2869.         enterRule(_localctx, 88, RULE_expression_numeric);
  2870.         int _la;
  2871.         try {
  2872.             enterOuterAlt(_localctx, 1);
  2873.             {
  2874.             setState(402);
  2875.             expression_numeric_relation();
  2876.             setState(405);
  2877.             _errHandler.sync(this);
  2878.             switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
  2879.             case 1:
  2880.                 {
  2881.                 setState(403);
  2882.                 _la = _input.LA(1);
  2883.                 if ( !(_la==EQUAL || _la==NOTEQUAL) ) {
  2884.                 _errHandler.recoverInline(this);
  2885.                 }
  2886.                 else {
  2887.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  2888.                     _errHandler.reportMatch(this);
  2889.                     consume();
  2890.                 }
  2891.                 setState(404);
  2892.                 expression_numeric();
  2893.                 }
  2894.                 break;
  2895.             }
  2896.             }
  2897.         }
  2898.         catch (RecognitionException re) {
  2899.             _localctx.exception = re;
  2900.             _errHandler.reportError(this, re);
  2901.             _errHandler.recover(this, re);
  2902.         }
  2903.         finally {
  2904.             exitRule();
  2905.         }
  2906.         return _localctx;
  2907.     }

  2909.     public static class Expression_numeric_relationContext extends ParserRuleContext {
  2910.         public Expression_numeric_additiveContext expression_numeric_additive() {
  2911.             return getRuleContext(Expression_numeric_additiveContext.class,0);
  2912.         }
  2913.         public Expression_numericContext expression_numeric() {
  2914.             return getRuleContext(Expression_numericContext.class,0);
  2915.         }
  2916.         public TerminalNode LESS() { return getToken(PlanBundleParser.LESS, 0); }
  2917.         public TerminalNode LESSEQUAL() { return getToken(PlanBundleParser.LESSEQUAL, 0); }
  2918.         public TerminalNode GREATER() { return getToken(PlanBundleParser.GREATER, 0); }
  2919.         public TerminalNode GREATEREQUAL() { return getToken(PlanBundleParser.GREATEREQUAL, 0); }
  2920.         public Expression_numeric_relationContext(ParserRuleContext parent, int invokingState) {
  2921.             super(parent, invokingState);
  2922.         }
  2923.         @Override public int getRuleIndex() { return RULE_expression_numeric_relation; }
  2924.         @Override
  2925.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2926.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_relation(this);
  2927.             else return visitor.visitChildren(this);
  2928.         }
  2929.     }

  2931.     public final Expression_numeric_relationContext expression_numeric_relation() throws RecognitionException {
  2932.         Expression_numeric_relationContext _localctx = new Expression_numeric_relationContext(_ctx, getState());
  2933.         enterRule(_localctx, 90, RULE_expression_numeric_relation);
  2934.         int _la;
  2935.         try {
  2936.             enterOuterAlt(_localctx, 1);
  2937.             {
  2938.             setState(407);
  2939.             expression_numeric_additive();
  2940.             setState(410);
  2941.             _errHandler.sync(this);
  2942.             switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
  2943.             case 1:
  2944.                 {
  2945.                 setState(408);
  2946.                 _la = _input.LA(1);
  2947.                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LESS) | (1L << LESSEQUAL) | (1L << GREATER) | (1L << GREATEREQUAL))) != 0)) ) {
  2948.                 _errHandler.recoverInline(this);
  2949.                 }
  2950.                 else {
  2951.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  2952.                     _errHandler.reportMatch(this);
  2953.                     consume();
  2954.                 }
  2955.                 setState(409);
  2956.                 expression_numeric();
  2957.                 }
  2958.                 break;
  2959.             }
  2960.             }
  2961.         }
  2962.         catch (RecognitionException re) {
  2963.             _localctx.exception = re;
  2964.             _errHandler.reportError(this, re);
  2965.             _errHandler.recover(this, re);
  2966.         }
  2967.         finally {
  2968.             exitRule();
  2969.         }
  2970.         return _localctx;
  2971.     }

  2973.     public static class Expression_numeric_additiveContext extends ParserRuleContext {
  2974.         public Expression_numeric_multiplicativeContext expression_numeric_multiplicative() {
  2975.             return getRuleContext(Expression_numeric_multiplicativeContext.class,0);
  2976.         }
  2977.         public Expression_numericContext expression_numeric() {
  2978.             return getRuleContext(Expression_numericContext.class,0);
  2979.         }
  2980.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  2981.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  2982.         public Expression_numeric_additiveContext(ParserRuleContext parent, int invokingState) {
  2983.             super(parent, invokingState);
  2984.         }
  2985.         @Override public int getRuleIndex() { return RULE_expression_numeric_additive; }
  2986.         @Override
  2987.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2988.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_additive(this);
  2989.             else return visitor.visitChildren(this);
  2990.         }
  2991.     }

  2993.     public final Expression_numeric_additiveContext expression_numeric_additive() throws RecognitionException {
  2994.         Expression_numeric_additiveContext _localctx = new Expression_numeric_additiveContext(_ctx, getState());
  2995.         enterRule(_localctx, 92, RULE_expression_numeric_additive);
  2996.         int _la;
  2997.         try {
  2998.             enterOuterAlt(_localctx, 1);
  2999.             {
  3000.             setState(412);
  3001.             expression_numeric_multiplicative();
  3002.             setState(415);
  3003.             _errHandler.sync(this);
  3004.             switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
  3005.             case 1:
  3006.                 {
  3007.                 setState(413);
  3008.                 _la = _input.LA(1);
  3009.                 if ( !(_la==PLUS || _la==MINUS) ) {
  3010.                 _errHandler.recoverInline(this);
  3011.                 }
  3012.                 else {
  3013.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3014.                     _errHandler.reportMatch(this);
  3015.                     consume();
  3016.                 }
  3017.                 setState(414);
  3018.                 expression_numeric();
  3019.                 }
  3020.                 break;
  3021.             }
  3022.             }
  3023.         }
  3024.         catch (RecognitionException re) {
  3025.             _localctx.exception = re;
  3026.             _errHandler.reportError(this, re);
  3027.             _errHandler.recover(this, re);
  3028.         }
  3029.         finally {
  3030.             exitRule();
  3031.         }
  3032.         return _localctx;
  3033.     }

  3035.     public static class Expression_numeric_multiplicativeContext extends ParserRuleContext {
  3036.         public Expression_numeric_powerContext expression_numeric_power() {
  3037.             return getRuleContext(Expression_numeric_powerContext.class,0);
  3038.         }
  3039.         public Expression_numericContext expression_numeric() {
  3040.             return getRuleContext(Expression_numericContext.class,0);
  3041.         }
  3042.         public TerminalNode SLASH() { return getToken(PlanBundleParser.SLASH, 0); }
  3043.         public TerminalNode MODULO() { return getToken(PlanBundleParser.MODULO, 0); }
  3044.         public TerminalNode MULTIPLY() { return getToken(PlanBundleParser.MULTIPLY, 0); }
  3045.         public Expression_numeric_multiplicativeContext(ParserRuleContext parent, int invokingState) {
  3046.             super(parent, invokingState);
  3047.         }
  3048.         @Override public int getRuleIndex() { return RULE_expression_numeric_multiplicative; }
  3049.         @Override
  3050.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3051.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_multiplicative(this);
  3052.             else return visitor.visitChildren(this);
  3053.         }
  3054.     }

  3056.     public final Expression_numeric_multiplicativeContext expression_numeric_multiplicative() throws RecognitionException {
  3057.         Expression_numeric_multiplicativeContext _localctx = new Expression_numeric_multiplicativeContext(_ctx, getState());
  3058.         enterRule(_localctx, 94, RULE_expression_numeric_multiplicative);
  3059.         int _la;
  3060.         try {
  3061.             enterOuterAlt(_localctx, 1);
  3062.             {
  3063.             setState(417);
  3064.             expression_numeric_power();
  3065.             setState(420);
  3066.             _errHandler.sync(this);
  3067.             switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
  3068.             case 1:
  3069.                 {
  3070.                 setState(418);
  3071.                 _la = _input.LA(1);
  3072.                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SLASH) | (1L << MULTIPLY) | (1L << MODULO))) != 0)) ) {
  3073.                 _errHandler.recoverInline(this);
  3074.                 }
  3075.                 else {
  3076.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3077.                     _errHandler.reportMatch(this);
  3078.                     consume();
  3079.                 }
  3080.                 setState(419);
  3081.                 expression_numeric();
  3082.                 }
  3083.                 break;
  3084.             }
  3085.             }
  3086.         }
  3087.         catch (RecognitionException re) {
  3088.             _localctx.exception = re;
  3089.             _errHandler.reportError(this, re);
  3090.             _errHandler.recover(this, re);
  3091.         }
  3092.         finally {
  3093.             exitRule();
  3094.         }
  3095.         return _localctx;
  3096.     }

  3098.     public static class Expression_numeric_powerContext extends ParserRuleContext {
  3099.         public Expression_numeric_elementContext expression_numeric_element() {
  3100.             return getRuleContext(Expression_numeric_elementContext.class,0);
  3101.         }
  3102.         public TerminalNode POW() { return getToken(PlanBundleParser.POW, 0); }
  3103.         public Expression_numericContext expression_numeric() {
  3104.             return getRuleContext(Expression_numericContext.class,0);
  3105.         }
  3106.         public Expression_numeric_powerContext(ParserRuleContext parent, int invokingState) {
  3107.             super(parent, invokingState);
  3108.         }
  3109.         @Override public int getRuleIndex() { return RULE_expression_numeric_power; }
  3110.         @Override
  3111.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3112.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_power(this);
  3113.             else return visitor.visitChildren(this);
  3114.         }
  3115.     }

  3117.     public final Expression_numeric_powerContext expression_numeric_power() throws RecognitionException {
  3118.         Expression_numeric_powerContext _localctx = new Expression_numeric_powerContext(_ctx, getState());
  3119.         enterRule(_localctx, 96, RULE_expression_numeric_power);
  3120.         int _la;
  3121.         try {
  3122.             enterOuterAlt(_localctx, 1);
  3123.             {
  3124.             setState(422);
  3125.             expression_numeric_element();
  3126.             setState(425);
  3127.             _errHandler.sync(this);
  3128.             _la = _input.LA(1);
  3129.             if (_la==POW) {
  3130.                 {
  3131.                 setState(423);
  3132.                 match(POW);
  3133.                 setState(424);
  3134.                 expression_numeric();
  3135.                 }
  3136.             }

  3138.             }
  3139.         }
  3140.         catch (RecognitionException re) {
  3141.             _localctx.exception = re;
  3142.             _errHandler.reportError(this, re);
  3143.             _errHandler.recover(this, re);
  3144.         }
  3145.         finally {
  3146.             exitRule();
  3147.         }
  3148.         return _localctx;
  3149.     }

  3151.     public static class Expression_numeric_elementContext extends ParserRuleContext {
  3152.         public NumberContext number() {
  3153.             return getRuleContext(NumberContext.class,0);
  3154.         }
  3155.         public VariableContext variable() {
  3156.             return getRuleContext(VariableContext.class,0);
  3157.         }
  3158.         public Executable_actionContext executable_action() {
  3159.             return getRuleContext(Executable_actionContext.class,0);
  3160.         }
  3161.         public Executable_ruleContext executable_rule() {
  3162.             return getRuleContext(Executable_ruleContext.class,0);
  3163.         }
  3164.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  3165.         public Expression_numericContext expression_numeric() {
  3166.             return getRuleContext(Expression_numericContext.class,0);
  3167.         }
  3168.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  3169.         public Expression_numeric_elementContext(ParserRuleContext parent, int invokingState) {
  3170.             super(parent, invokingState);
  3171.         }
  3172.         @Override public int getRuleIndex() { return RULE_expression_numeric_element; }
  3173.         @Override
  3174.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3175.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_element(this);
  3176.             else return visitor.visitChildren(this);
  3177.         }
  3178.     }

  3180.     public final Expression_numeric_elementContext expression_numeric_element() throws RecognitionException {
  3181.         Expression_numeric_elementContext _localctx = new Expression_numeric_elementContext(_ctx, getState());
  3182.         enterRule(_localctx, 98, RULE_expression_numeric_element);
  3183.         try {
  3184.             setState(435);
  3185.             _errHandler.sync(this);
  3186.             switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
  3187.             case 1:
  3188.                 enterOuterAlt(_localctx, 1);
  3189.                 {
  3190.                 setState(427);
  3191.                 number();
  3192.                 }
  3193.                 break;
  3194.             case 2:
  3195.                 enterOuterAlt(_localctx, 2);
  3196.                 {
  3197.                 setState(428);
  3198.                 variable();
  3199.                 }
  3200.                 break;
  3201.             case 3:
  3202.                 enterOuterAlt(_localctx, 3);
  3203.                 {
  3204.                 setState(429);
  3205.                 executable_action();
  3206.                 }
  3207.                 break;
  3208.             case 4:
  3209.                 enterOuterAlt(_localctx, 4);
  3210.                 {
  3211.                 setState(430);
  3212.                 executable_rule();
  3213.                 }
  3214.                 break;
  3215.             case 5:
  3216.                 enterOuterAlt(_localctx, 5);
  3217.                 {
  3218.                 setState(431);
  3219.                 match(LEFTROUNDBRACKET);
  3220.                 setState(432);
  3221.                 expression_numeric();
  3222.                 setState(433);
  3223.                 match(RIGHTROUNDBRACKET);
  3224.                 }
  3225.                 break;
  3226.             }
  3227.         }
  3228.         catch (RecognitionException re) {
  3229.             _localctx.exception = re;
  3230.             _errHandler.reportError(this, re);
  3231.             _errHandler.recover(this, re);
  3232.         }
  3233.         finally {
  3234.             exitRule();
  3235.         }
  3236.         return _localctx;
  3237.     }

  3239.     public static class Executable_actionContext extends ParserRuleContext {
  3240.         public LiteralContext literal() {
  3241.             return getRuleContext(LiteralContext.class,0);
  3242.         }
  3243.         public Executable_actionContext(ParserRuleContext parent, int invokingState) {
  3244.             super(parent, invokingState);
  3245.         }
  3246.         @Override public int getRuleIndex() { return RULE_executable_action; }
  3247.         @Override
  3248.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3249.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_action(this);
  3250.             else return visitor.visitChildren(this);
  3251.         }
  3252.     }

  3254.     public final Executable_actionContext executable_action() throws RecognitionException {
  3255.         Executable_actionContext _localctx = new Executable_actionContext(_ctx, getState());
  3256.         enterRule(_localctx, 100, RULE_executable_action);
  3257.         try {
  3258.             enterOuterAlt(_localctx, 1);
  3259.             {
  3260.             setState(437);
  3261.             literal();
  3262.             }
  3263.         }
  3264.         catch (RecognitionException re) {
  3265.             _localctx.exception = re;
  3266.             _errHandler.reportError(this, re);
  3267.             _errHandler.recover(this, re);
  3268.         }
  3269.         finally {
  3270.             exitRule();
  3271.         }
  3272.         return _localctx;
  3273.     }

  3275.     public static class Executable_ruleContext extends ParserRuleContext {
  3276.         public TerminalNode DOLLAR() { return getToken(PlanBundleParser.DOLLAR, 0); }
  3277.         public LiteralContext literal() {
  3278.             return getRuleContext(LiteralContext.class,0);
  3279.         }
  3280.         public Variable_evaluateContext variable_evaluate() {
  3281.             return getRuleContext(Variable_evaluateContext.class,0);
  3282.         }
  3283.         public Executable_ruleContext(ParserRuleContext parent, int invokingState) {
  3284.             super(parent, invokingState);
  3285.         }
  3286.         @Override public int getRuleIndex() { return RULE_executable_rule; }
  3287.         @Override
  3288.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3289.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_rule(this);
  3290.             else return visitor.visitChildren(this);
  3291.         }
  3292.     }

  3294.     public final Executable_ruleContext executable_rule() throws RecognitionException {
  3295.         Executable_ruleContext _localctx = new Executable_ruleContext(_ctx, getState());
  3296.         enterRule(_localctx, 102, RULE_executable_rule);
  3297.         try {
  3298.             enterOuterAlt(_localctx, 1);
  3299.             {
  3300.             setState(439);
  3301.             match(DOLLAR);
  3302.             setState(442);
  3303.             _errHandler.sync(this);
  3304.             switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
  3305.             case 1:
  3306.                 {
  3307.                 setState(440);
  3308.                 literal();
  3309.                 }
  3310.                 break;
  3311.             case 2:
  3312.                 {
  3313.                 setState(441);
  3314.                 variable_evaluate();
  3315.                 }
  3316.                 break;
  3317.             }
  3318.             }
  3319.         }
  3320.         catch (RecognitionException re) {
  3321.             _localctx.exception = re;
  3322.             _errHandler.reportError(this, re);
  3323.             _errHandler.recover(this, re);
  3324.         }
  3325.         finally {
  3326.             exitRule();
  3327.         }
  3328.         return _localctx;
  3329.     }

  3331.     public static class Variable_evaluateContext extends ParserRuleContext {
  3332.         public VariableContext variable() {
  3333.             return getRuleContext(VariableContext.class,0);
  3334.         }
  3335.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  3336.         public TermlistContext termlist() {
  3337.             return getRuleContext(TermlistContext.class,0);
  3338.         }
  3339.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  3340.         public Variable_evaluateContext(ParserRuleContext parent, int invokingState) {
  3341.             super(parent, invokingState);
  3342.         }
  3343.         @Override public int getRuleIndex() { return RULE_variable_evaluate; }
  3344.         @Override
  3345.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3346.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariable_evaluate(this);
  3347.             else return visitor.visitChildren(this);
  3348.         }
  3349.     }

  3351.     public final Variable_evaluateContext variable_evaluate() throws RecognitionException {
  3352.         Variable_evaluateContext _localctx = new Variable_evaluateContext(_ctx, getState());
  3353.         enterRule(_localctx, 104, RULE_variable_evaluate);
  3354.         int _la;
  3355.         try {
  3356.             enterOuterAlt(_localctx, 1);
  3357.             {
  3358.             setState(444);
  3359.             variable();
  3360.             setState(449);
  3361.             _errHandler.sync(this);
  3362.             _la = _input.LA(1);
  3363.             if (_la==LEFTROUNDBRACKET) {
  3364.                 {
  3365.                 setState(445);
  3366.                 match(LEFTROUNDBRACKET);
  3367.                 setState(446);
  3368.                 termlist();
  3369.                 setState(447);
  3370.                 match(RIGHTROUNDBRACKET);
  3371.                 }
  3372.             }

  3374.             }
  3375.         }
  3376.         catch (RecognitionException re) {
  3377.             _localctx.exception = re;
  3378.             _errHandler.reportError(this, re);
  3379.             _errHandler.recover(this, re);
  3380.         }
  3381.         finally {
  3382.             exitRule();
  3383.         }
  3384.         return _localctx;
  3385.     }

  3387.     public static class LiteralContext extends ParserRuleContext {
  3388.         public AtomContext atom() {
  3389.             return getRuleContext(AtomContext.class,0);
  3390.         }
  3391.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  3392.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  3393.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  3394.         public TerminalNode STRONGNEGATION() { return getToken(PlanBundleParser.STRONGNEGATION, 0); }
  3395.         public TermlistContext termlist() {
  3396.             return getRuleContext(TermlistContext.class,0);
  3397.         }
  3398.         public LiteralContext(ParserRuleContext parent, int invokingState) {
  3399.             super(parent, invokingState);
  3400.         }
  3401.         @Override public int getRuleIndex() { return RULE_literal; }
  3402.         @Override
  3403.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3404.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLiteral(this);
  3405.             else return visitor.visitChildren(this);
  3406.         }
  3407.     }

  3409.     public final LiteralContext literal() throws RecognitionException {
  3410.         LiteralContext _localctx = new LiteralContext(_ctx, getState());
  3411.         enterRule(_localctx, 106, RULE_literal);
  3412.         int _la;
  3413.         try {
  3414.             enterOuterAlt(_localctx, 1);
  3415.             {
  3416.             setState(452);
  3417.             _errHandler.sync(this);
  3418.             _la = _input.LA(1);
  3419.             if (_la==STRONGNEGATION || _la==AT) {
  3420.                 {
  3421.                 setState(451);
  3422.                 _la = _input.LA(1);
  3423.                 if ( !(_la==STRONGNEGATION || _la==AT) ) {
  3424.                 _errHandler.recoverInline(this);
  3425.                 }
  3426.                 else {
  3427.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3428.                     _errHandler.reportMatch(this);
  3429.                     consume();
  3430.                 }
  3431.                 }
  3432.             }

  3434.             setState(454);
  3435.             atom();
  3436.             setState(460);
  3437.             _errHandler.sync(this);
  3438.             _la = _input.LA(1);
  3439.             if (_la==LEFTROUNDBRACKET) {
  3440.                 {
  3441.                 setState(455);
  3442.                 match(LEFTROUNDBRACKET);
  3443.                 setState(457);
  3444.                 _errHandler.sync(this);
  3445.                 _la = _input.LA(1);
  3446.                 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << LOGICALVALUE) | (1L << CONSTANTNUMBER) | (1L << STRONGNEGATION) | (1L << MINUS) | (1L << DOLLAR) | (1L << AT) | (1L << UNDERSCORE) | (1L << LEFTROUNDBRACKET) | (1L << LEFTANGULARBRACKET) | (1L << RIGHTSHIFT) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) {
  3447.                     {
  3448.                     setState(456);
  3449.                     termlist();
  3450.                     }
  3451.                 }

  3453.                 setState(459);
  3454.                 match(RIGHTROUNDBRACKET);
  3455.                 }
  3456.             }

  3458.             }
  3459.         }
  3460.         catch (RecognitionException re) {
  3461.             _localctx.exception = re;
  3462.             _errHandler.reportError(this, re);
  3463.             _errHandler.recover(this, re);
  3464.         }
  3465.         finally {
  3466.             exitRule();
  3467.         }
  3468.         return _localctx;
  3469.     }

  3471.     public static class TermlistContext extends ParserRuleContext {
  3472.         public List<TermContext> term() {
  3473.             return getRuleContexts(TermContext.class);
  3474.         }
  3475.         public TermContext term(int i) {
  3476.             return getRuleContext(TermContext.class,i);
  3477.         }
  3478.         public List<TerminalNode> COMMA() { return getTokens(PlanBundleParser.COMMA); }
  3479.         public TerminalNode COMMA(int i) {
  3480.             return getToken(PlanBundleParser.COMMA, i);
  3481.         }
  3482.         public TermlistContext(ParserRuleContext parent, int invokingState) {
  3483.             super(parent, invokingState);
  3484.         }
  3485.         @Override public int getRuleIndex() { return RULE_termlist; }
  3486.         @Override
  3487.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3488.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTermlist(this);
  3489.             else return visitor.visitChildren(this);
  3490.         }
  3491.     }

  3493.     public final TermlistContext termlist() throws RecognitionException {
  3494.         TermlistContext _localctx = new TermlistContext(_ctx, getState());
  3495.         enterRule(_localctx, 108, RULE_termlist);
  3496.         int _la;
  3497.         try {
  3498.             enterOuterAlt(_localctx, 1);
  3499.             {
  3500.             setState(462);
  3501.             term();
  3502.             setState(467);
  3503.             _errHandler.sync(this);
  3504.             _la = _input.LA(1);
  3505.             while (_la==COMMA) {
  3506.                 {
  3507.                 {
  3508.                 setState(463);
  3509.                 match(COMMA);
  3510.                 setState(464);
  3511.                 term();
  3512.                 }
  3513.                 }
  3514.                 setState(469);
  3515.                 _errHandler.sync(this);
  3516.                 _la = _input.LA(1);
  3517.             }
  3518.             }
  3519.         }
  3520.         catch (RecognitionException re) {
  3521.             _localctx.exception = re;
  3522.             _errHandler.reportError(this, re);
  3523.             _errHandler.recover(this, re);
  3524.         }
  3525.         finally {
  3526.             exitRule();
  3527.         }
  3528.         return _localctx;
  3529.     }

  3531.     public static class VariablelistContext extends ParserRuleContext {
  3532.         public TerminalNode LEFTANGULARBRACKET() { return getToken(PlanBundleParser.LEFTANGULARBRACKET, 0); }
  3533.         public List<VariableContext> variable() {
  3534.             return getRuleContexts(VariableContext.class);
  3535.         }
  3536.         public VariableContext variable(int i) {
  3537.             return getRuleContext(VariableContext.class,i);
  3538.         }
  3539.         public TerminalNode RIGHTANGULARBRACKET() { return getToken(PlanBundleParser.RIGHTANGULARBRACKET, 0); }
  3540.         public List<TerminalNode> VLINE() { return getTokens(PlanBundleParser.VLINE); }
  3541.         public TerminalNode VLINE(int i) {
  3542.             return getToken(PlanBundleParser.VLINE, i);
  3543.         }
  3544.         public VariablelistContext(ParserRuleContext parent, int invokingState) {
  3545.             super(parent, invokingState);
  3546.         }
  3547.         @Override public int getRuleIndex() { return RULE_variablelist; }
  3548.         @Override
  3549.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3550.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariablelist(this);
  3551.             else return visitor.visitChildren(this);
  3552.         }
  3553.     }

  3555.     public final VariablelistContext variablelist() throws RecognitionException {
  3556.         VariablelistContext _localctx = new VariablelistContext(_ctx, getState());
  3557.         enterRule(_localctx, 110, RULE_variablelist);
  3558.         int _la;
  3559.         try {
  3560.             enterOuterAlt(_localctx, 1);
  3561.             {
  3562.             setState(470);
  3563.             match(LEFTANGULARBRACKET);
  3564.             setState(471);
  3565.             variable();
  3566.             setState(476);
  3567.             _errHandler.sync(this);
  3568.             _la = _input.LA(1);
  3569.             while (_la==VLINE) {
  3570.                 {
  3571.                 {
  3572.                 setState(472);
  3573.                 match(VLINE);
  3574.                 setState(473);
  3575.                 variable();
  3576.                 }
  3577.                 }
  3578.                 setState(478);
  3579.                 _errHandler.sync(this);
  3580.                 _la = _input.LA(1);
  3581.             }
  3582.             setState(479);
  3583.             match(RIGHTANGULARBRACKET);
  3584.             }
  3585.         }
  3586.         catch (RecognitionException re) {
  3587.             _localctx.exception = re;
  3588.             _errHandler.reportError(this, re);
  3589.             _errHandler.recover(this, re);
  3590.         }
  3591.         finally {
  3592.             exitRule();
  3593.         }
  3594.         return _localctx;
  3595.     }

  3597.     public static class AtomContext extends ParserRuleContext {
  3598.         public List<TerminalNode> LOWERCASELETTER() { return getTokens(PlanBundleParser.LOWERCASELETTER); }
  3599.         public TerminalNode LOWERCASELETTER(int i) {
  3600.             return getToken(PlanBundleParser.LOWERCASELETTER, i);
  3601.         }
  3602.         public List<TerminalNode> UPPERCASELETTER() { return getTokens(PlanBundleParser.UPPERCASELETTER); }
  3603.         public TerminalNode UPPERCASELETTER(int i) {
  3604.             return getToken(PlanBundleParser.UPPERCASELETTER, i);
  3605.         }
  3606.         public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
  3607.         public TerminalNode DIGIT(int i) {
  3608.             return getToken(PlanBundleParser.DIGIT, i);
  3609.         }
  3610.         public List<TerminalNode> SLASH() { return getTokens(PlanBundleParser.SLASH); }
  3611.         public TerminalNode SLASH(int i) {
  3612.             return getToken(PlanBundleParser.SLASH, i);
  3613.         }
  3614.         public List<TerminalNode> MINUS() { return getTokens(PlanBundleParser.MINUS); }
  3615.         public TerminalNode MINUS(int i) {
  3616.             return getToken(PlanBundleParser.MINUS, i);
  3617.         }
  3618.         public AtomContext(ParserRuleContext parent, int invokingState) {
  3619.             super(parent, invokingState);
  3620.         }
  3621.         @Override public int getRuleIndex() { return RULE_atom; }
  3622.         @Override
  3623.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3624.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAtom(this);
  3625.             else return visitor.visitChildren(this);
  3626.         }
  3627.     }

  3629.     public final AtomContext atom() throws RecognitionException {
  3630.         AtomContext _localctx = new AtomContext(_ctx, getState());
  3631.         enterRule(_localctx, 112, RULE_atom);
  3632.         int _la;
  3633.         try {
  3634.             int _alt;
  3635.             enterOuterAlt(_localctx, 1);
  3636.             {
  3637.             setState(481);
  3638.             match(LOWERCASELETTER);
  3639.             setState(485);
  3640.             _errHandler.sync(this);
  3641.             _alt = getInterpreter().adaptivePredict(_input,50,_ctx);
  3642.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  3643.                 if ( _alt==1 ) {
  3644.                     {
  3645.                     {
  3646.                     setState(482);
  3647.                     _la = _input.LA(1);
  3648.                     if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MINUS) | (1L << SLASH) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) ) {
  3649.                     _errHandler.recoverInline(this);
  3650.                     }
  3651.                     else {
  3652.                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3653.                         _errHandler.reportMatch(this);
  3654.                         consume();
  3655.                     }
  3656.                     }
  3657.                     } 
  3658.                 }
  3659.                 setState(487);
  3660.                 _errHandler.sync(this);
  3661.                 _alt = getInterpreter().adaptivePredict(_input,50,_ctx);
  3662.             }
  3663.             }
  3664.         }
  3665.         catch (RecognitionException re) {
  3666.             _localctx.exception = re;
  3667.             _errHandler.reportError(this, re);
  3668.             _errHandler.recover(this, re);
  3669.         }
  3670.         finally {
  3671.             exitRule();
  3672.         }
  3673.         return _localctx;
  3674.     }

  3676.     public static class VariableContext extends ParserRuleContext {
  3677.         public VariableatomContext variableatom() {
  3678.             return getRuleContext(VariableatomContext.class,0);
  3679.         }
  3680.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  3681.         public VariableContext(ParserRuleContext parent, int invokingState) {
  3682.             super(parent, invokingState);
  3683.         }
  3684.         @Override public int getRuleIndex() { return RULE_variable; }
  3685.         @Override
  3686.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3687.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariable(this);
  3688.             else return visitor.visitChildren(this);
  3689.         }
  3690.     }

  3692.     public final VariableContext variable() throws RecognitionException {
  3693.         VariableContext _localctx = new VariableContext(_ctx, getState());
  3694.         enterRule(_localctx, 114, RULE_variable);
  3695.         int _la;
  3696.         try {
  3697.             enterOuterAlt(_localctx, 1);
  3698.             {
  3699.             setState(489);
  3700.             _errHandler.sync(this);
  3701.             _la = _input.LA(1);
  3702.             if (_la==AT) {
  3703.                 {
  3704.                 setState(488);
  3705.                 match(AT);
  3706.                 }
  3707.             }

  3709.             setState(491);
  3710.             variableatom();
  3711.             }
  3712.         }
  3713.         catch (RecognitionException re) {
  3714.             _localctx.exception = re;
  3715.             _errHandler.reportError(this, re);
  3716.             _errHandler.recover(this, re);
  3717.         }
  3718.         finally {
  3719.             exitRule();
  3720.         }
  3721.         return _localctx;
  3722.     }

  3724.     public static class VariableatomContext extends ParserRuleContext {
  3725.         public List<TerminalNode> UPPERCASELETTER() { return getTokens(PlanBundleParser.UPPERCASELETTER); }
  3726.         public TerminalNode UPPERCASELETTER(int i) {
  3727.             return getToken(PlanBundleParser.UPPERCASELETTER, i);
  3728.         }
  3729.         public TerminalNode UNDERSCORE() { return getToken(PlanBundleParser.UNDERSCORE, 0); }
  3730.         public List<TerminalNode> LOWERCASELETTER() { return getTokens(PlanBundleParser.LOWERCASELETTER); }
  3731.         public TerminalNode LOWERCASELETTER(int i) {
  3732.             return getToken(PlanBundleParser.LOWERCASELETTER, i);
  3733.         }
  3734.         public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
  3735.         public TerminalNode DIGIT(int i) {
  3736.             return getToken(PlanBundleParser.DIGIT, i);
  3737.         }
  3738.         public List<TerminalNode> SLASH() { return getTokens(PlanBundleParser.SLASH); }
  3739.         public TerminalNode SLASH(int i) {
  3740.             return getToken(PlanBundleParser.SLASH, i);
  3741.         }
  3742.         public VariableatomContext(ParserRuleContext parent, int invokingState) {
  3743.             super(parent, invokingState);
  3744.         }
  3745.         @Override public int getRuleIndex() { return RULE_variableatom; }
  3746.         @Override
  3747.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3748.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariableatom(this);
  3749.             else return visitor.visitChildren(this);
  3750.         }
  3751.     }

  3753.     public final VariableatomContext variableatom() throws RecognitionException {
  3754.         VariableatomContext _localctx = new VariableatomContext(_ctx, getState());
  3755.         enterRule(_localctx, 116, RULE_variableatom);
  3756.         int _la;
  3757.         try {
  3758.             int _alt;
  3759.             enterOuterAlt(_localctx, 1);
  3760.             {
  3761.             setState(493);
  3762.             _la = _input.LA(1);
  3763.             if ( !(_la==UNDERSCORE || _la==UPPERCASELETTER) ) {
  3764.             _errHandler.recoverInline(this);
  3765.             }
  3766.             else {
  3767.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3768.                 _errHandler.reportMatch(this);
  3769.                 consume();
  3770.             }
  3771.             setState(497);
  3772.             _errHandler.sync(this);
  3773.             _alt = getInterpreter().adaptivePredict(_input,52,_ctx);
  3774.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  3775.                 if ( _alt==1 ) {
  3776.                     {
  3777.                     {
  3778.                     setState(494);
  3779.                     _la = _input.LA(1);
  3780.                     if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SLASH) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) ) {
  3781.                     _errHandler.recoverInline(this);
  3782.                     }
  3783.                     else {
  3784.                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3785.                         _errHandler.reportMatch(this);
  3786.                         consume();
  3787.                     }
  3788.                     }
  3789.                     } 
  3790.                 }
  3791.                 setState(499);
  3792.                 _errHandler.sync(this);
  3793.                 _alt = getInterpreter().adaptivePredict(_input,52,_ctx);
  3794.             }
  3795.             }
  3796.         }
  3797.         catch (RecognitionException re) {
  3798.             _localctx.exception = re;
  3799.             _errHandler.reportError(this, re);
  3800.             _errHandler.recover(this, re);
  3801.         }
  3802.         finally {
  3803.             exitRule();
  3804.         }
  3805.         return _localctx;
  3806.     }

  3808.     public static class NumberContext extends ParserRuleContext {
  3809.         public TerminalNode CONSTANTNUMBER() { return getToken(PlanBundleParser.CONSTANTNUMBER, 0); }
  3810.         public DigitsequenceContext digitsequence() {
  3811.             return getRuleContext(DigitsequenceContext.class,0);
  3812.         }
  3813.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  3814.         public NumberContext(ParserRuleContext parent, int invokingState) {
  3815.             super(parent, invokingState);
  3816.         }
  3817.         @Override public int getRuleIndex() { return RULE_number; }
  3818.         @Override
  3819.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3820.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitNumber(this);
  3821.             else return visitor.visitChildren(this);
  3822.         }
  3823.     }

  3825.     public final NumberContext number() throws RecognitionException {
  3826.         NumberContext _localctx = new NumberContext(_ctx, getState());
  3827.         enterRule(_localctx, 118, RULE_number);
  3828.         int _la;
  3829.         try {
  3830.             enterOuterAlt(_localctx, 1);
  3831.             {
  3832.             setState(501);
  3833.             _errHandler.sync(this);
  3834.             _la = _input.LA(1);
  3835.             if (_la==MINUS) {
  3836.                 {
  3837.                 setState(500);
  3838.                 match(MINUS);
  3839.                 }
  3840.             }

  3842.             setState(505);
  3843.             _errHandler.sync(this);
  3844.             switch (_input.LA(1)) {
  3845.             case CONSTANTNUMBER:
  3846.                 {
  3847.                 setState(503);
  3848.                 match(CONSTANTNUMBER);
  3849.                 }
  3850.                 break;
  3851.             case DIGIT:
  3852.                 {
  3853.                 setState(504);
  3854.                 digitsequence();
  3855.                 }
  3856.                 break;
  3857.             default:
  3858.                 throw new NoViableAltException(this);
  3859.             }
  3860.             }
  3861.         }
  3862.         catch (RecognitionException re) {
  3863.             _localctx.exception = re;
  3864.             _errHandler.reportError(this, re);
  3865.             _errHandler.recover(this, re);
  3866.         }
  3867.         finally {
  3868.             exitRule();
  3869.         }
  3870.         return _localctx;
  3871.     }

  3873.     public static class DigitsequenceContext extends ParserRuleContext {
  3874.         public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
  3875.         public TerminalNode DIGIT(int i) {
  3876.             return getToken(PlanBundleParser.DIGIT, i);
  3877.         }
  3878.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  3879.         public DigitsequenceContext(ParserRuleContext parent, int invokingState) {
  3880.             super(parent, invokingState);
  3881.         }
  3882.         @Override public int getRuleIndex() { return RULE_digitsequence; }
  3883.         @Override
  3884.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3885.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitDigitsequence(this);
  3886.             else return visitor.visitChildren(this);
  3887.         }
  3888.     }

  3890.     public final DigitsequenceContext digitsequence() throws RecognitionException {
  3891.         DigitsequenceContext _localctx = new DigitsequenceContext(_ctx, getState());
  3892.         enterRule(_localctx, 120, RULE_digitsequence);
  3893.         int _la;
  3894.         try {
  3895.             enterOuterAlt(_localctx, 1);
  3896.             {
  3897.             setState(508); 
  3898.             _errHandler.sync(this);
  3899.             _la = _input.LA(1);
  3900.             do {
  3901.                 {
  3902.                 {
  3903.                 setState(507);
  3904.                 match(DIGIT);
  3905.                 }
  3906.                 }
  3907.                 setState(510); 
  3908.                 _errHandler.sync(this);
  3909.                 _la = _input.LA(1);
  3910.             } while ( _la==DIGIT );
  3911.             setState(518);
  3912.             _errHandler.sync(this);
  3913.             switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
  3914.             case 1:
  3915.                 {
  3916.                 setState(512);
  3917.                 match(DOT);
  3918.                 setState(514); 
  3919.                 _errHandler.sync(this);
  3920.                 _la = _input.LA(1);
  3921.                 do {
  3922.                     {
  3923.                     {
  3924.                     setState(513);
  3925.                     match(DIGIT);
  3926.                     }
  3927.                     }
  3928.                     setState(516); 
  3929.                     _errHandler.sync(this);
  3930.                     _la = _input.LA(1);
  3931.                 } while ( _la==DIGIT );
  3932.                 }
  3933.                 break;
  3934.             }
  3935.             }
  3936.         }
  3937.         catch (RecognitionException re) {
  3938.             _localctx.exception = re;
  3939.             _errHandler.reportError(this, re);
  3940.             _errHandler.recover(this, re);
  3941.         }
  3942.         finally {
  3943.             exitRule();
  3944.         }
  3945.         return _localctx;
  3946.     }

  3948.     public static final String _serializedATN =
  3949.         "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\38\u020b\4\2\t\2\4"+
  3950.         "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
  3951.         "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
  3952.         "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
  3953.         "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
  3954.         "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
  3955.         ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
  3956.         "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
  3957.         "\4>\t>\3\2\7\2~\n\2\f\2\16\2\u0081\13\2\3\2\5\2\u0084\n\2\3\2\3\2\3\3"+
  3958.         "\3\3\3\3\3\4\6\4\u008c\n\4\r\4\16\4\u008d\3\5\6\5\u0091\n\5\r\5\16\5\u0092"+
  3959.         "\3\6\5\6\u0096\n\6\3\6\3\6\3\6\7\6\u009b\n\6\f\6\16\6\u009e\13\6\3\6\3"+
  3960.         "\6\3\7\3\7\5\7\u00a4\n\7\3\7\3\7\3\7\3\b\5\b\u00aa\n\b\3\b\3\b\6\b\u00ae"+
  3961.         "\n\b\r\b\16\b\u00af\3\b\3\b\3\t\3\t\3\t\3\n\3\n\6\n\u00b9\n\n\r\n\16\n"+
  3962.         "\u00ba\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u00c9\n"+
  3963.         "\r\3\r\3\r\3\16\3\16\5\16\u00cf\n\16\3\17\3\17\3\17\3\20\3\20\3\21\3\21"+
  3964.         "\3\21\7\21\u00d9\n\21\f\21\16\21\u00dc\13\21\3\22\3\22\3\22\3\22\3\22"+
  3965.         "\3\22\3\22\5\22\u00e5\n\22\3\23\3\23\3\23\5\23\u00ea\n\23\3\23\3\23\5"+
  3966.         "\23\u00ee\n\23\3\24\3\24\3\24\3\25\3\25\5\25\u00f5\n\25\3\25\3\25\3\26"+
  3967.         "\3\26\3\26\5\26\u00fc\n\26\3\27\3\27\3\27\3\27\5\27\u0102\n\27\3\30\3"+
  3968.         "\30\5\30\u0106\n\30\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\33\3\33"+
  3969.         "\3\33\3\34\3\34\3\34\3\34\5\34\u0117\n\34\3\35\3\35\3\35\3\35\3\35\5\35"+
  3970.         "\u011e\n\35\3\36\5\36\u0121\n\36\3\36\3\36\3\36\3\36\5\36\u0127\n\36\3"+
  3971.         "\36\3\36\3\36\3\37\3\37\3\37\5\37\u012f\n\37\3\37\3\37\3 \3 \3 \3!\3!"+
  3972.         "\3!\3!\3!\3!\3!\5!\u013d\n!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
  3973.         "\"\3\"\5\"\u014b\n\"\3#\5#\u014e\n#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u0158\n"+
  3974.         "#\3$\3$\5$\u015c\n$\3%\3%\3%\3%\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3(\7(\u016c"+
  3975.         "\n(\f(\16(\u016f\13(\5(\u0171\n(\3)\3)\3)\3)\3*\3*\3*\7*\u017a\n*\f*\16"+
  3976.         "*\u017d\13*\3+\3+\3+\5+\u0182\n+\3+\3+\7+\u0186\n+\f+\16+\u0189\13+\3"+
  3977.         ",\3,\3,\3,\3,\5,\u0190\n,\3-\3-\3-\3.\3.\3.\5.\u0198\n.\3/\3/\3/\5/\u019d"+
  3978.         "\n/\3\60\3\60\3\60\5\60\u01a2\n\60\3\61\3\61\3\61\5\61\u01a7\n\61\3\62"+
  3979.         "\3\62\3\62\5\62\u01ac\n\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63"+
  3980.         "\u01b6\n\63\3\64\3\64\3\65\3\65\3\65\5\65\u01bd\n\65\3\66\3\66\3\66\3"+
  3981.         "\66\3\66\5\66\u01c4\n\66\3\67\5\67\u01c7\n\67\3\67\3\67\3\67\5\67\u01cc"+
  3982.         "\n\67\3\67\5\67\u01cf\n\67\38\38\38\78\u01d4\n8\f8\168\u01d7\138\39\3"+
  3983.         "9\39\39\79\u01dd\n9\f9\169\u01e0\139\39\39\3:\3:\7:\u01e6\n:\f:\16:\u01e9"+
  3984.         "\13:\3;\5;\u01ec\n;\3;\3;\3<\3<\7<\u01f2\n<\f<\16<\u01f5\13<\3=\5=\u01f8"+
  3985.         "\n=\3=\3=\5=\u01fc\n=\3>\6>\u01ff\n>\r>\16>\u0200\3>\3>\6>\u0205\n>\r"+
  3986.         ">\16>\u0206\5>\u0209\n>\3>\2\2?\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36"+
  3987.         " \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz\2\f\3\2!\"\3"+
  3988.         "\2\13\f\4\2\b\b\r\r\3\2./\3\2*-\4\2\30\30\61\62\4\2\t\t\23\23\5\2\f\f"+
  3989.         "\30\30\63\65\4\2\27\27\64\64\4\2\30\30\63\65\2\u0220\2\177\3\2\2\2\4\u0087"+
  3990.         "\3\2\2\2\6\u008b\3\2\2\2\b\u0090\3\2\2\2\n\u0095\3\2\2\2\f\u00a3\3\2\2"+
  3991.         "\2\16\u00a9\3\2\2\2\20\u00b3\3\2\2\2\22\u00b8\3\2\2\2\24\u00bc\3\2\2\2"+
  3992.         "\26\u00bf\3\2\2\2\30\u00c2\3\2\2\2\32\u00ce\3\2\2\2\34\u00d0\3\2\2\2\36"+
  3993.         "\u00d3\3\2\2\2 \u00d5\3\2\2\2\"\u00e4\3\2\2\2$\u00e9\3\2\2\2&\u00ef\3"+
  3994.         "\2\2\2(\u00f2\3\2\2\2*\u00f8\3\2\2\2,\u00fd\3\2\2\2.\u0105\3\2\2\2\60"+
  3995.         "\u0107\3\2\2\2\62\u010b\3\2\2\2\64\u010f\3\2\2\2\66\u0112\3\2\2\28\u011d"+
  3996.         "\3\2\2\2:\u0120\3\2\2\2<\u012b\3\2\2\2>\u0132\3\2\2\2@\u013c\3\2\2\2B"+
  3997.         "\u014a\3\2\2\2D\u014d\3\2\2\2F\u015b\3\2\2\2H\u015d\3\2\2\2J\u0161\3\2"+
  3998.         "\2\2L\u0164\3\2\2\2N\u0170\3\2\2\2P\u0172\3\2\2\2R\u0176\3\2\2\2T\u0181"+
  3999.         "\3\2\2\2V\u018f\3\2\2\2X\u0191\3\2\2\2Z\u0194\3\2\2\2\\\u0199\3\2\2\2"+
  4000.         "^\u019e\3\2\2\2`\u01a3\3\2\2\2b\u01a8\3\2\2\2d\u01b5\3\2\2\2f\u01b7\3"+
  4001.         "\2\2\2h\u01b9\3\2\2\2j\u01be\3\2\2\2l\u01c6\3\2\2\2n\u01d0\3\2\2\2p\u01d8"+
  4002.         "\3\2\2\2r\u01e3\3\2\2\2t\u01eb\3\2\2\2v\u01ef\3\2\2\2x\u01f7\3\2\2\2z"+
  4003.         "\u01fe\3\2\2\2|~\5\4\3\2}|\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\177\u0080"+
  4004.         "\3\2\2\2\u0080\u0083\3\2\2\2\u0081\177\3\2\2\2\u0082\u0084\5\b\5\2\u0083"+
  4005.         "\u0082\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u0086\5\6"+
  4006.         "\4\2\u0086\3\3\2\2\2\u0087\u0088\5l\67\2\u0088\u0089\7\26\2\2\u0089\5"+
  4007.         "\3\2\2\2\u008a\u008c\5\n\6\2\u008b\u008a\3\2\2\2\u008c\u008d\3\2\2\2\u008d"+
  4008.         "\u008b\3\2\2\2\u008d\u008e\3\2\2\2\u008e\7\3\2\2\2\u008f\u0091\5\16\b"+
  4009.         "\2\u0090\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0090\3\2\2\2\u0092\u0093"+
  4010.         "\3\2\2\2\u0093\t\3\2\2\2\u0094\u0096\5\22\n\2\u0095\u0094\3\2\2\2\u0095"+
  4011.         "\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u0098\5\32\16\2\u0098\u009c\5"+
  4012.         "l\67\2\u0099\u009b\5\f\7\2\u009a\u0099\3\2\2\2\u009b\u009e\3\2\2\2\u009c"+
  4013.         "\u009a\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009f\3\2\2\2\u009e\u009c\3\2"+
  4014.         "\2\2\u009f\u00a0\7\26\2\2\u00a0\13\3\2\2\2\u00a1\u00a2\7\24\2\2\u00a2"+
  4015.         "\u00a4\5N(\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a5\3\2\2"+
  4016.         "\2\u00a5\u00a6\7\20\2\2\u00a6\u00a7\5 \21\2\u00a7\r\3\2\2\2\u00a8\u00aa"+
  4017.         "\5\22\n\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2"+
  4018.         "\u00ab\u00ad\5l\67\2\u00ac\u00ae\5\20\t\2\u00ad\u00ac\3\2\2\2\u00ae\u00af"+
  4019.         "\3\2\2\2\u00af\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1"+
  4020.         "\u00b2\7\26\2\2\u00b2\17\3\2\2\2\u00b3\u00b4\7\22\2\2\u00b4\u00b5\5 \21"+
  4021.         "\2\u00b5\21\3\2\2\2\u00b6\u00b9\5\24\13\2\u00b7\u00b9\5\26\f\2\u00b8\u00b6"+
  4022.         "\3\2\2\2\u00b8\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba"+
  4023.         "\u00bb\3\2\2\2\u00bb\23\3\2\2\2\u00bc\u00bd\7\23\2\2\u00bd\u00be\t\2\2"+
  4024.         "\2\u00be\25\3\2\2\2\u00bf\u00c0\7\23\2\2\u00c0\u00c1\5\30\r\2\u00c1\27"+
  4025.         "\3\2\2\2\u00c2\u00c3\7#\2\2\u00c3\u00c4\7\31\2\2\u00c4\u00c5\5v<\2\u00c5"+
  4026.         "\u00c8\7\n\2\2\u00c6\u00c9\5x=\2\u00c7\u00c9\7\5\2\2\u00c8\u00c6\3\2\2"+
  4027.         "\2\u00c8\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\7\32\2\2\u00cb"+
  4028.         "\31\3\2\2\2\u00cc\u00cf\5\36\20\2\u00cd\u00cf\5\34\17\2\u00ce\u00cc\3"+
  4029.         "\2\2\2\u00ce\u00cd\3\2\2\2\u00cf\33\3\2\2\2\u00d0\u00d1\t\3\2\2\u00d1"+
  4030.         "\u00d2\7\b\2\2\u00d2\35\3\2\2\2\u00d3\u00d4\t\3\2\2\u00d4\37\3\2\2\2\u00d5"+
  4031.         "\u00da\5\"\22\2\u00d6\u00d7\7\25\2\2\u00d7\u00d9\5\"\22\2\u00d8\u00d6"+
  4032.         "\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db"+
  4033.         "!\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00e5\5$\23\2\u00de\u00e5\5&\24\2"+
  4034.         "\u00df\u00e5\5,\27\2\u00e0\u00e5\5.\30\2\u00e1\u00e5\5\64\33\2\u00e2\u00e5"+
  4035.         "\5\66\34\2\u00e3\u00e5\5:\36\2\u00e4\u00dd\3\2\2\2\u00e4\u00de\3\2\2\2"+
  4036.         "\u00e4\u00df\3\2\2\2\u00e4\u00e0\3\2\2\2\u00e4\u00e1\3\2\2\2\u00e4\u00e2"+
  4037.         "\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5#\3\2\2\2\u00e6\u00ea\5@!\2\u00e7\u00ea"+
  4038.         "\5(\25\2\u00e8\u00ea\5*\26\2\u00e9\u00e6\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9"+
  4039.         "\u00e8\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb\u00ec\7\37\2\2\u00ec\u00ee\5"+
  4040.         "$\23\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee%\3\2\2\2\u00ef\u00f0"+
  4041.         "\t\3\2\2\u00f0\u00f1\5l\67\2\u00f1\'\3\2\2\2\u00f2\u00f4\7\16\2\2\u00f3"+
  4042.         "\u00f5\7\17\2\2\u00f4\u00f3\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f6\3"+
  4043.         "\2\2\2\u00f6\u00f7\5r:\2\u00f7)\3\2\2\2\u00f8\u00fb\t\4\2\2\u00f9\u00fc"+
  4044.         "\5l\67\2\u00fa\u00fc\5j\66\2\u00fb\u00f9\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc"+
  4045.         "+\3\2\2\2\u00fd\u00fe\5p9\2\u00fe\u0101\7)\2\2\u00ff\u0102\5l\67\2\u0100"+
  4046.         "\u0102\5t;\2\u0101\u00ff\3\2\2\2\u0101\u0100\3\2\2\2\u0102-\3\2\2\2\u0103"+
  4047.         "\u0106\5\60\31\2\u0104\u0106\5\62\32\2\u0105\u0103\3\2\2\2\u0105\u0104"+
  4048.         "\3\2\2\2\u0106/\3\2\2\2\u0107\u0108\5t;\2\u0108\u0109\7(\2\2\u0109\u010a"+
  4049.         "\5@!\2\u010a\61\3\2\2\2\u010b\u010c\5p9\2\u010c\u010d\7(\2\2\u010d\u010e"+
  4050.         "\5@!\2\u010e\63\3\2\2\2\u010f\u0110\5t;\2\u0110\u0111\7\4\2\2\u0111\65"+
  4051.         "\3\2\2\2\u0112\u0113\5t;\2\u0113\u0116\7\3\2\2\u0114\u0117\5t;\2\u0115"+
  4052.         "\u0117\5x=\2\u0116\u0114\3\2\2\2\u0116\u0115\3\2\2\2\u0117\67\3\2\2\2"+
  4053.         "\u0118\u0119\7\35\2\2\u0119\u011a\5 \21\2\u011a\u011b\7\36\2\2\u011b\u011e"+
  4054.         "\3\2\2\2\u011c\u011e\5\"\22\2\u011d\u0118\3\2\2\2\u011d\u011c\3\2\2\2"+
  4055.         "\u011e9\3\2\2\2\u011f\u0121\7\23\2\2\u0120\u011f\3\2\2\2\u0120\u0121\3"+
  4056.         "\2\2\2\u0121\u0122\3\2\2\2\u0122\u0123\5<\37\2\u0123\u0124\7\21\2\2\u0124"+
  4057.         "\u0126\5t;\2\u0125\u0127\5> \2\u0126\u0125\3\2\2\2\u0126\u0127\3\2\2\2"+
  4058.         "\u0127\u0128\3\2\2\2\u0128\u0129\7\24\2\2\u0129\u012a\58\35\2\u012a;\3"+
  4059.         "\2\2\2\u012b\u012e\7\31\2\2\u012c\u012f\5t;\2\u012d\u012f\5l\67\2\u012e"+
  4060.         "\u012c\3\2\2\2\u012e\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\7\32"+
  4061.         "\2\2\u0131=\3\2\2\2\u0132\u0133\7$\2\2\u0133\u0134\5t;\2\u0134?\3\2\2"+
  4062.         "\2\u0135\u013d\7\5\2\2\u0136\u013d\5x=\2\u0137\u013d\7\6\2\2\u0138\u013d"+
  4063.         "\5f\64\2\u0139\u013d\5h\65\2\u013a\u013d\5N(\2\u013b\u013d\5H%\2\u013c"+
  4064.         "\u0135\3\2\2\2\u013c\u0136\3\2\2\2\u013c\u0137\3\2\2\2\u013c\u0138\3\2"+
  4065.         "\2\2\u013c\u0139\3\2\2\2\u013c\u013a\3\2\2\2\u013c\u013b\3\2\2\2\u013d"+
  4066.         "A\3\2\2\2\u013e\u014b\7\5\2\2\u013f\u014b\5x=\2\u0140\u014b\7\6\2\2\u0141"+
  4067.         "\u014b\5l\67\2\u0142\u014b\5t;\2\u0143\u014b\5p9\2\u0144\u0145\7\33\2"+
  4068.         "\2\u0145\u0146\5n8\2\u0146\u0147\7\34\2\2\u0147\u014b\3\2\2\2\u0148\u014b"+
  4069.         "\5N(\2\u0149\u014b\5H%\2\u014a\u013e\3\2\2\2\u014a\u013f\3\2\2\2\u014a"+
  4070.         "\u0140\3\2\2\2\u014a\u0141\3\2\2\2\u014a\u0142\3\2\2\2\u014a\u0143\3\2"+
  4071.         "\2\2\u014a\u0144\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u0149\3\2\2\2\u014b"+
  4072.         "C\3\2\2\2\u014c\u014e\7\23\2\2\u014d\u014c\3\2\2\2\u014d\u014e\3\2\2\2"+
  4073.         "\u014e\u014f\3\2\2\2\u014f\u0157\7 \2\2\u0150\u0158\5l\67\2\u0151\u0152"+
  4074.         "\7\31\2\2\u0152\u0153\5l\67\2\u0153\u0154\7\n\2\2\u0154\u0155\5F$\2\u0155"+
  4075.         "\u0156\7\32\2\2\u0156\u0158\3\2\2\2\u0157\u0150\3\2\2\2\u0157\u0151\3"+
  4076.         "\2\2\2\u0158E\3\2\2\2\u0159\u015c\5t;\2\u015a\u015c\5N(\2\u015b\u0159"+
  4077.         "\3\2\2\2\u015b\u015a\3\2\2\2\u015cG\3\2\2\2\u015d\u015e\5N(\2\u015e\u015f"+
  4078.         "\5J&\2\u015f\u0160\5L\'\2\u0160I\3\2\2\2\u0161\u0162\7\16\2\2\u0162\u0163"+
  4079.         "\5@!\2\u0163K\3\2\2\2\u0164\u0165\7\24\2\2\u0165\u0166\5@!\2\u0166M\3"+
  4080.         "\2\2\2\u0167\u0171\5P)\2\u0168\u016d\5R*\2\u0169\u016a\7&\2\2\u016a\u016c"+
  4081.         "\5N(\2\u016b\u0169\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d"+
  4082.         "\u016e\3\2\2\2\u016e\u0171\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0167\3\2"+
  4083.         "\2\2\u0170\u0168\3\2\2\2\u0171O\3\2\2\2\u0172\u0173\7\31\2\2\u0173\u0174"+
  4084.         "\5N(\2\u0174\u0175\7\32\2\2\u0175Q\3\2\2\2\u0176\u017b\5T+\2\u0177\u0178"+
  4085.         "\7%\2\2\u0178\u017a\5N(\2\u0179\u0177\3\2\2\2\u017a\u017d\3\2\2\2\u017b"+
  4086.         "\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017cS\3\2\2\2\u017d\u017b\3\2\2\2"+
  4087.         "\u017e\u0182\5X-\2\u017f\u0182\5V,\2\u0180\u0182\5Z.\2\u0181\u017e\3\2"+
  4088.         "\2\2\u0181\u017f\3\2\2\2\u0181\u0180\3\2\2\2\u0182\u0187\3\2\2\2\u0183"+
  4089.         "\u0184\7\'\2\2\u0184\u0186\5N(\2\u0185\u0183\3\2\2\2\u0186\u0189\3\2\2"+
  4090.         "\2\u0187\u0185\3\2\2\2\u0187\u0188\3\2\2\2\u0188U\3\2\2\2\u0189\u0187"+
  4091.         "\3\2\2\2\u018a\u0190\7\6\2\2\u018b\u0190\5t;\2\u018c\u0190\5f\64\2\u018d"+
  4092.         "\u0190\5h\65\2\u018e\u0190\5D#\2\u018f\u018a\3\2\2\2\u018f\u018b\3\2\2"+
  4093.         "\2\u018f\u018c\3\2\2\2\u018f\u018d\3\2\2\2\u018f\u018e\3\2\2\2\u0190W"+
  4094.         "\3\2\2\2\u0191\u0192\7\t\2\2\u0192\u0193\5N(\2\u0193Y\3\2\2\2\u0194\u0197"+
  4095.         "\5\\/\2\u0195\u0196\t\5\2\2\u0196\u0198\5Z.\2\u0197\u0195\3\2\2\2\u0197"+
  4096.         "\u0198\3\2\2\2\u0198[\3\2\2\2\u0199\u019c\5^\60\2\u019a\u019b\t\6\2\2"+
  4097.         "\u019b\u019d\5Z.\2\u019c\u019a\3\2\2\2\u019c\u019d\3\2\2\2\u019d]\3\2"+
  4098.         "\2\2\u019e\u01a1\5`\61\2\u019f\u01a0\t\3\2\2\u01a0\u01a2\5Z.\2\u01a1\u019f"+
  4099.         "\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2_\3\2\2\2\u01a3\u01a6\5b\62\2\u01a4"+
  4100.         "\u01a5\t\7\2\2\u01a5\u01a7\5Z.\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2"+
  4101.         "\2\u01a7a\3\2\2\2\u01a8\u01ab\5d\63\2\u01a9\u01aa\7\60\2\2\u01aa\u01ac"+
  4102.         "\5Z.\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01acc\3\2\2\2\u01ad\u01b6"+
  4103.         "\5x=\2\u01ae\u01b6\5t;\2\u01af\u01b6\5f\64\2\u01b0\u01b6\5h\65\2\u01b1"+
  4104.         "\u01b2\7\31\2\2\u01b2\u01b3\5Z.\2\u01b3\u01b4\7\32\2\2\u01b4\u01b6\3\2"+
  4105.         "\2\2\u01b5\u01ad\3\2\2\2\u01b5\u01ae\3\2\2\2\u01b5\u01af\3\2\2\2\u01b5"+
  4106.         "\u01b0\3\2\2\2\u01b5\u01b1\3\2\2\2\u01b6e\3\2\2\2\u01b7\u01b8\5l\67\2"+
  4107.         "\u01b8g\3\2\2\2\u01b9\u01bc\7\17\2\2\u01ba\u01bd\5l\67\2\u01bb\u01bd\5"+
  4108.         "j\66\2\u01bc\u01ba\3\2\2\2\u01bc\u01bb\3\2\2\2\u01bdi\3\2\2\2\u01be\u01c3"+
  4109.         "\5t;\2\u01bf\u01c0\7\31\2\2\u01c0\u01c1\5n8\2\u01c1\u01c2\7\32\2\2\u01c2"+
  4110.         "\u01c4\3\2\2\2\u01c3\u01bf\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4k\3\2\2\2"+
  4111.         "\u01c5\u01c7\t\b\2\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8"+
  4112.         "\3\2\2\2\u01c8\u01ce\5r:\2\u01c9\u01cb\7\31\2\2\u01ca\u01cc\5n8\2\u01cb"+
  4113.         "\u01ca\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01cf\7\32"+
  4114.         "\2\2\u01ce\u01c9\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cfm\3\2\2\2\u01d0\u01d5"+
  4115.         "\5B\"\2\u01d1\u01d2\7\n\2\2\u01d2\u01d4\5B\"\2\u01d3\u01d1\3\2\2\2\u01d4"+
  4116.         "\u01d7\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6o\3\2\2\2"+
  4117.         "\u01d7\u01d5\3\2\2\2\u01d8\u01d9\7\33\2\2\u01d9\u01de\5t;\2\u01da\u01db"+
  4118.         "\7$\2\2\u01db\u01dd\5t;\2\u01dc\u01da\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de"+
  4119.         "\u01dc\3\2\2\2\u01de\u01df\3\2\2\2\u01df\u01e1\3\2\2\2\u01e0\u01de\3\2"+
  4120.         "\2\2\u01e1\u01e2\7\34\2\2\u01e2q\3\2\2\2\u01e3\u01e7\7\63\2\2\u01e4\u01e6"+
  4121.         "\t\t\2\2\u01e5\u01e4\3\2\2\2\u01e6\u01e9\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e7"+
  4122.         "\u01e8\3\2\2\2\u01e8s\3\2\2\2\u01e9\u01e7\3\2\2\2\u01ea\u01ec\7\23\2\2"+
  4123.         "\u01eb\u01ea\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee"+
  4124.         "\5v<\2\u01eeu\3\2\2\2\u01ef\u01f3\t\n\2\2\u01f0\u01f2\t\13\2\2\u01f1\u01f0"+
  4125.         "\3\2\2\2\u01f2\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4"+
  4126.         "w\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01f8\7\f\2\2\u01f7\u01f6\3\2\2\2"+
  4127.         "\u01f7\u01f8\3\2\2\2\u01f8\u01fb\3\2\2\2\u01f9\u01fc\7\7\2\2\u01fa\u01fc"+
  4128.         "\5z>\2\u01fb\u01f9\3\2\2\2\u01fb\u01fa\3\2\2\2\u01fcy\3\2\2\2\u01fd\u01ff"+
  4129.         "\7\65\2\2\u01fe\u01fd\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u01fe\3\2\2\2"+
  4130.         "\u0200\u0201\3\2\2\2\u0201\u0208\3\2\2\2\u0202\u0204\7\26\2\2\u0203\u0205"+
  4131.         "\7\65\2\2\u0204\u0203\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0204\3\2\2\2"+
  4132.         "\u0206\u0207\3\2\2\2\u0207\u0209\3\2\2\2\u0208\u0202\3\2\2\2\u0208\u0209"+
  4133.         "\3\2\2\2\u0209{\3\2\2\2<\177\u0083\u008d\u0092\u0095\u009c\u00a3\u00a9"+
  4134.         "\u00af\u00b8\u00ba\u00c8\u00ce\u00da\u00e4\u00e9\u00ed\u00f4\u00fb\u0101"+
  4135.         "\u0105\u0116\u011d\u0120\u0126\u012e\u013c\u014a\u014d\u0157\u015b\u016d"+
  4136.         "\u0170\u017b\u0181\u0187\u018f\u0197\u019c\u01a1\u01a6\u01ab\u01b5\u01bc"+
  4137.         "\u01c3\u01c6\u01cb\u01ce\u01d5\u01de\u01e7\u01eb\u01f3\u01f7\u01fb\u0200"+
  4138.         "\u0206\u0208";
  4139.     public static final ATN _ATN =
  4140.         new ATNDeserializer().deserialize(_serializedATN.toCharArray());
  4141.     static {
  4142.         _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
  4143.         for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
  4144.             _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
  4145.         }
  4146.     }
  4147. }
Created with JaCoCo 0.8.0.201801022044