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;

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

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

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

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

  99.             if (tokenNames[i] == null) {
  100.                 tokenNames[i] = "<INVALID>";
  101.             }
  102.         }
  103.     }

  104.     @Override
  105.     @Deprecated
  106.     public String[] getTokenNames() {
  107.         return tokenNames;
  108.     }

  109.     @Override

  110.     public Vocabulary getVocabulary() {
  111.         return VOCABULARY;
  112.     }

  113.     @Override
  114.     public String getGrammarFileName() { return "PlanBundle.g4"; }

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

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

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

  121.     public PlanBundleParser(TokenStream input) {
  122.         super(input);
  123.         _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
  124.     }
  125.     public static class PlanbundleContext extends ParserRuleContext {
  126.         public PlansContext plans() {
  127.             return getRuleContext(PlansContext.class,0);
  128.         }
  129.         public List<BeliefContext> belief() {
  130.             return getRuleContexts(BeliefContext.class);
  131.         }
  132.         public BeliefContext belief(int i) {
  133.             return getRuleContext(BeliefContext.class,i);
  134.         }
  135.         public LogicrulesContext logicrules() {
  136.             return getRuleContext(LogicrulesContext.class,0);
  137.         }
  138.         public PlanbundleContext(ParserRuleContext parent, int invokingState) {
  139.             super(parent, invokingState);
  140.         }
  141.         @Override public int getRuleIndex() { return RULE_planbundle; }
  142.         @Override
  143.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  144.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlanbundle(this);
  145.             else return visitor.visitChildren(this);
  146.         }
  147.     }

  148.     public final PlanbundleContext planbundle() throws RecognitionException {
  149.         PlanbundleContext _localctx = new PlanbundleContext(_ctx, getState());
  150.         enterRule(_localctx, 0, RULE_planbundle);
  151.         try {
  152.             int _alt;
  153.             enterOuterAlt(_localctx, 1);
  154.             {
  155.             setState(125);
  156.             _errHandler.sync(this);
  157.             _alt = getInterpreter().adaptivePredict(_input,0,_ctx);
  158.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  159.                 if ( _alt==1 ) {
  160.                     {
  161.                     {
  162.                     setState(122);
  163.                     belief();
  164.                     }
  165.                     }
  166.                 }
  167.                 setState(127);
  168.                 _errHandler.sync(this);
  169.                 _alt = getInterpreter().adaptivePredict(_input,0,_ctx);
  170.             }
  171.             setState(129);
  172.             _errHandler.sync(this);
  173.             switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
  174.             case 1:
  175.                 {
  176.                 setState(128);
  177.                 logicrules();
  178.                 }
  179.                 break;
  180.             }
  181.             setState(131);
  182.             plans();
  183.             }
  184.         }
  185.         catch (RecognitionException re) {
  186.             _localctx.exception = re;
  187.             _errHandler.reportError(this, re);
  188.             _errHandler.recover(this, re);
  189.         }
  190.         finally {
  191.             exitRule();
  192.         }
  193.         return _localctx;
  194.     }

  195.     public static class BeliefContext extends ParserRuleContext {
  196.         public LiteralContext literal() {
  197.             return getRuleContext(LiteralContext.class,0);
  198.         }
  199.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  200.         public BeliefContext(ParserRuleContext parent, int invokingState) {
  201.             super(parent, invokingState);
  202.         }
  203.         @Override public int getRuleIndex() { return RULE_belief; }
  204.         @Override
  205.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  206.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBelief(this);
  207.             else return visitor.visitChildren(this);
  208.         }
  209.     }

  210.     public final BeliefContext belief() throws RecognitionException {
  211.         BeliefContext _localctx = new BeliefContext(_ctx, getState());
  212.         enterRule(_localctx, 2, RULE_belief);
  213.         try {
  214.             enterOuterAlt(_localctx, 1);
  215.             {
  216.             setState(133);
  217.             literal();
  218.             setState(134);
  219.             match(DOT);
  220.             }
  221.         }
  222.         catch (RecognitionException re) {
  223.             _localctx.exception = re;
  224.             _errHandler.reportError(this, re);
  225.             _errHandler.recover(this, re);
  226.         }
  227.         finally {
  228.             exitRule();
  229.         }
  230.         return _localctx;
  231.     }

  232.     public static class PlansContext extends ParserRuleContext {
  233.         public List<PlanContext> plan() {
  234.             return getRuleContexts(PlanContext.class);
  235.         }
  236.         public PlanContext plan(int i) {
  237.             return getRuleContext(PlanContext.class,i);
  238.         }
  239.         public PlansContext(ParserRuleContext parent, int invokingState) {
  240.             super(parent, invokingState);
  241.         }
  242.         @Override public int getRuleIndex() { return RULE_plans; }
  243.         @Override
  244.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  245.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlans(this);
  246.             else return visitor.visitChildren(this);
  247.         }
  248.     }

  249.     public final PlansContext plans() throws RecognitionException {
  250.         PlansContext _localctx = new PlansContext(_ctx, getState());
  251.         enterRule(_localctx, 4, RULE_plans);
  252.         int _la;
  253.         try {
  254.             enterOuterAlt(_localctx, 1);
  255.             {
  256.             setState(137);
  257.             _errHandler.sync(this);
  258.             _la = _input.LA(1);
  259.             do {
  260.                 {
  261.                 {
  262.                 setState(136);
  263.                 plan();
  264.                 }
  265.                 }
  266.                 setState(139);
  267.                 _errHandler.sync(this);
  268.                 _la = _input.LA(1);
  269.             } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << AT))) != 0) );
  270.             }
  271.         }
  272.         catch (RecognitionException re) {
  273.             _localctx.exception = re;
  274.             _errHandler.reportError(this, re);
  275.             _errHandler.recover(this, re);
  276.         }
  277.         finally {
  278.             exitRule();
  279.         }
  280.         return _localctx;
  281.     }

  282.     public static class LogicrulesContext extends ParserRuleContext {
  283.         public List<LogicruleContext> logicrule() {
  284.             return getRuleContexts(LogicruleContext.class);
  285.         }
  286.         public LogicruleContext logicrule(int i) {
  287.             return getRuleContext(LogicruleContext.class,i);
  288.         }
  289.         public LogicrulesContext(ParserRuleContext parent, int invokingState) {
  290.             super(parent, invokingState);
  291.         }
  292.         @Override public int getRuleIndex() { return RULE_logicrules; }
  293.         @Override
  294.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  295.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicrules(this);
  296.             else return visitor.visitChildren(this);
  297.         }
  298.     }

  299.     public final LogicrulesContext logicrules() throws RecognitionException {
  300.         LogicrulesContext _localctx = new LogicrulesContext(_ctx, getState());
  301.         enterRule(_localctx, 6, RULE_logicrules);
  302.         try {
  303.             int _alt;
  304.             enterOuterAlt(_localctx, 1);
  305.             {
  306.             setState(142);
  307.             _errHandler.sync(this);
  308.             _alt = 1;
  309.             do {
  310.                 switch (_alt) {
  311.                 case 1:
  312.                     {
  313.                     {
  314.                     setState(141);
  315.                     logicrule();
  316.                     }
  317.                     }
  318.                     break;
  319.                 default:
  320.                     throw new NoViableAltException(this);
  321.                 }
  322.                 setState(144);
  323.                 _errHandler.sync(this);
  324.                 _alt = getInterpreter().adaptivePredict(_input,3,_ctx);
  325.             } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
  326.             }
  327.         }
  328.         catch (RecognitionException re) {
  329.             _localctx.exception = re;
  330.             _errHandler.reportError(this, re);
  331.             _errHandler.recover(this, re);
  332.         }
  333.         finally {
  334.             exitRule();
  335.         }
  336.         return _localctx;
  337.     }

  338.     public static class PlanContext extends ParserRuleContext {
  339.         public Plan_triggerContext plan_trigger() {
  340.             return getRuleContext(Plan_triggerContext.class,0);
  341.         }
  342.         public LiteralContext literal() {
  343.             return getRuleContext(LiteralContext.class,0);
  344.         }
  345.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  346.         public AnnotationsContext annotations() {
  347.             return getRuleContext(AnnotationsContext.class,0);
  348.         }
  349.         public List<PlandefinitionContext> plandefinition() {
  350.             return getRuleContexts(PlandefinitionContext.class);
  351.         }
  352.         public PlandefinitionContext plandefinition(int i) {
  353.             return getRuleContext(PlandefinitionContext.class,i);
  354.         }
  355.         public PlanContext(ParserRuleContext parent, int invokingState) {
  356.             super(parent, invokingState);
  357.         }
  358.         @Override public int getRuleIndex() { return RULE_plan; }
  359.         @Override
  360.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  361.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan(this);
  362.             else return visitor.visitChildren(this);
  363.         }
  364.     }

  365.     public final PlanContext plan() throws RecognitionException {
  366.         PlanContext _localctx = new PlanContext(_ctx, getState());
  367.         enterRule(_localctx, 8, RULE_plan);
  368.         int _la;
  369.         try {
  370.             enterOuterAlt(_localctx, 1);
  371.             {
  372.             setState(147);
  373.             _errHandler.sync(this);
  374.             _la = _input.LA(1);
  375.             if (_la==AT) {
  376.                 {
  377.                 setState(146);
  378.                 annotations();
  379.                 }
  380.             }

  381.             setState(149);
  382.             plan_trigger();
  383.             setState(150);
  384.             literal();
  385.             setState(154);
  386.             _errHandler.sync(this);
  387.             _la = _input.LA(1);
  388.             while (_la==LEFTARROW || _la==COLON) {
  389.                 {
  390.                 {
  391.                 setState(151);
  392.                 plandefinition();
  393.                 }
  394.                 }
  395.                 setState(156);
  396.                 _errHandler.sync(this);
  397.                 _la = _input.LA(1);
  398.             }
  399.             setState(157);
  400.             match(DOT);
  401.             }
  402.         }
  403.         catch (RecognitionException re) {
  404.             _localctx.exception = re;
  405.             _errHandler.reportError(this, re);
  406.             _errHandler.recover(this, re);
  407.         }
  408.         finally {
  409.             exitRule();
  410.         }
  411.         return _localctx;
  412.     }

  413.     public static class PlandefinitionContext extends ParserRuleContext {
  414.         public TerminalNode LEFTARROW() { return getToken(PlanBundleParser.LEFTARROW, 0); }
  415.         public BodyContext body() {
  416.             return getRuleContext(BodyContext.class,0);
  417.         }
  418.         public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
  419.         public ExpressionContext expression() {
  420.             return getRuleContext(ExpressionContext.class,0);
  421.         }
  422.         public PlandefinitionContext(ParserRuleContext parent, int invokingState) {
  423.             super(parent, invokingState);
  424.         }
  425.         @Override public int getRuleIndex() { return RULE_plandefinition; }
  426.         @Override
  427.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  428.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlandefinition(this);
  429.             else return visitor.visitChildren(this);
  430.         }
  431.     }

  432.     public final PlandefinitionContext plandefinition() throws RecognitionException {
  433.         PlandefinitionContext _localctx = new PlandefinitionContext(_ctx, getState());
  434.         enterRule(_localctx, 10, RULE_plandefinition);
  435.         int _la;
  436.         try {
  437.             enterOuterAlt(_localctx, 1);
  438.             {
  439.             setState(161);
  440.             _errHandler.sync(this);
  441.             _la = _input.LA(1);
  442.             if (_la==COLON) {
  443.                 {
  444.                 setState(159);
  445.                 match(COLON);
  446.                 setState(160);
  447.                 expression();
  448.                 }
  449.             }

  450.             setState(163);
  451.             match(LEFTARROW);
  452.             setState(164);
  453.             body();
  454.             }
  455.         }
  456.         catch (RecognitionException re) {
  457.             _localctx.exception = re;
  458.             _errHandler.reportError(this, re);
  459.             _errHandler.recover(this, re);
  460.         }
  461.         finally {
  462.             exitRule();
  463.         }
  464.         return _localctx;
  465.     }

  466.     public static class LogicruleContext extends ParserRuleContext {
  467.         public LiteralContext literal() {
  468.             return getRuleContext(LiteralContext.class,0);
  469.         }
  470.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  471.         public AnnotationsContext annotations() {
  472.             return getRuleContext(AnnotationsContext.class,0);
  473.         }
  474.         public List<LogicalruledefinitionContext> logicalruledefinition() {
  475.             return getRuleContexts(LogicalruledefinitionContext.class);
  476.         }
  477.         public LogicalruledefinitionContext logicalruledefinition(int i) {
  478.             return getRuleContext(LogicalruledefinitionContext.class,i);
  479.         }
  480.         public LogicruleContext(ParserRuleContext parent, int invokingState) {
  481.             super(parent, invokingState);
  482.         }
  483.         @Override public int getRuleIndex() { return RULE_logicrule; }
  484.         @Override
  485.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  486.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicrule(this);
  487.             else return visitor.visitChildren(this);
  488.         }
  489.     }

  490.     public final LogicruleContext logicrule() throws RecognitionException {
  491.         LogicruleContext _localctx = new LogicruleContext(_ctx, getState());
  492.         enterRule(_localctx, 12, RULE_logicrule);
  493.         int _la;
  494.         try {
  495.             enterOuterAlt(_localctx, 1);
  496.             {
  497.             setState(167);
  498.             _errHandler.sync(this);
  499.             switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
  500.             case 1:
  501.                 {
  502.                 setState(166);
  503.                 annotations();
  504.                 }
  505.                 break;
  506.             }
  507.             setState(169);
  508.             literal();
  509.             setState(171);
  510.             _errHandler.sync(this);
  511.             _la = _input.LA(1);
  512.             do {
  513.                 {
  514.                 {
  515.                 setState(170);
  516.                 logicalruledefinition();
  517.                 }
  518.                 }
  519.                 setState(173);
  520.                 _errHandler.sync(this);
  521.                 _la = _input.LA(1);
  522.             } while ( _la==RULEOPERATOR );
  523.             setState(175);
  524.             match(DOT);
  525.             }
  526.         }
  527.         catch (RecognitionException re) {
  528.             _localctx.exception = re;
  529.             _errHandler.reportError(this, re);
  530.             _errHandler.recover(this, re);
  531.         }
  532.         finally {
  533.             exitRule();
  534.         }
  535.         return _localctx;
  536.     }

  537.     public static class LogicalruledefinitionContext extends ParserRuleContext {
  538.         public TerminalNode RULEOPERATOR() { return getToken(PlanBundleParser.RULEOPERATOR, 0); }
  539.         public BodyContext body() {
  540.             return getRuleContext(BodyContext.class,0);
  541.         }
  542.         public LogicalruledefinitionContext(ParserRuleContext parent, int invokingState) {
  543.             super(parent, invokingState);
  544.         }
  545.         @Override public int getRuleIndex() { return RULE_logicalruledefinition; }
  546.         @Override
  547.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  548.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicalruledefinition(this);
  549.             else return visitor.visitChildren(this);
  550.         }
  551.     }

  552.     public final LogicalruledefinitionContext logicalruledefinition() throws RecognitionException {
  553.         LogicalruledefinitionContext _localctx = new LogicalruledefinitionContext(_ctx, getState());
  554.         enterRule(_localctx, 14, RULE_logicalruledefinition);
  555.         try {
  556.             enterOuterAlt(_localctx, 1);
  557.             {
  558.             setState(177);
  559.             match(RULEOPERATOR);
  560.             setState(178);
  561.             body();
  562.             }
  563.         }
  564.         catch (RecognitionException re) {
  565.             _localctx.exception = re;
  566.             _errHandler.reportError(this, re);
  567.             _errHandler.recover(this, re);
  568.         }
  569.         finally {
  570.             exitRule();
  571.         }
  572.         return _localctx;
  573.     }

  574.     public static class AnnotationsContext extends ParserRuleContext {
  575.         public List<Annotation_atomContext> annotation_atom() {
  576.             return getRuleContexts(Annotation_atomContext.class);
  577.         }
  578.         public Annotation_atomContext annotation_atom(int i) {
  579.             return getRuleContext(Annotation_atomContext.class,i);
  580.         }
  581.         public List<Annotation_literalContext> annotation_literal() {
  582.             return getRuleContexts(Annotation_literalContext.class);
  583.         }
  584.         public Annotation_literalContext annotation_literal(int i) {
  585.             return getRuleContext(Annotation_literalContext.class,i);
  586.         }
  587.         public AnnotationsContext(ParserRuleContext parent, int invokingState) {
  588.             super(parent, invokingState);
  589.         }
  590.         @Override public int getRuleIndex() { return RULE_annotations; }
  591.         @Override
  592.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  593.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotations(this);
  594.             else return visitor.visitChildren(this);
  595.         }
  596.     }

  597.     public final AnnotationsContext annotations() throws RecognitionException {
  598.         AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState());
  599.         enterRule(_localctx, 16, RULE_annotations);
  600.         try {
  601.             int _alt;
  602.             enterOuterAlt(_localctx, 1);
  603.             {
  604.             setState(182);
  605.             _errHandler.sync(this);
  606.             _alt = 1;
  607.             do {
  608.                 switch (_alt) {
  609.                 case 1:
  610.                     {
  611.                     setState(182);
  612.                     _errHandler.sync(this);
  613.                     switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
  614.                     case 1:
  615.                         {
  616.                         setState(180);
  617.                         annotation_atom();
  618.                         }
  619.                         break;
  620.                     case 2:
  621.                         {
  622.                         setState(181);
  623.                         annotation_literal();
  624.                         }
  625.                         break;
  626.                     }
  627.                     }
  628.                     break;
  629.                 default:
  630.                     throw new NoViableAltException(this);
  631.                 }
  632.                 setState(184);
  633.                 _errHandler.sync(this);
  634.                 _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
  635.             } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
  636.             }
  637.         }
  638.         catch (RecognitionException re) {
  639.             _localctx.exception = re;
  640.             _errHandler.reportError(this, re);
  641.             _errHandler.recover(this, re);
  642.         }
  643.         finally {
  644.             exitRule();
  645.         }
  646.         return _localctx;
  647.     }

  648.     public static class Annotation_atomContext extends ParserRuleContext {
  649.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  650.         public TerminalNode ATOMIC() { return getToken(PlanBundleParser.ATOMIC, 0); }
  651.         public TerminalNode PARALLEL() { return getToken(PlanBundleParser.PARALLEL, 0); }
  652.         public Annotation_atomContext(ParserRuleContext parent, int invokingState) {
  653.             super(parent, invokingState);
  654.         }
  655.         @Override public int getRuleIndex() { return RULE_annotation_atom; }
  656.         @Override
  657.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  658.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_atom(this);
  659.             else return visitor.visitChildren(this);
  660.         }
  661.     }

  662.     public final Annotation_atomContext annotation_atom() throws RecognitionException {
  663.         Annotation_atomContext _localctx = new Annotation_atomContext(_ctx, getState());
  664.         enterRule(_localctx, 18, RULE_annotation_atom);
  665.         int _la;
  666.         try {
  667.             enterOuterAlt(_localctx, 1);
  668.             {
  669.             setState(186);
  670.             match(AT);
  671.             setState(187);
  672.             _la = _input.LA(1);
  673.             if ( !(_la==PARALLEL || _la==ATOMIC) ) {
  674.             _errHandler.recoverInline(this);
  675.             }
  676.             else {
  677.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  678.                 _errHandler.reportMatch(this);
  679.                 consume();
  680.             }
  681.             }
  682.         }
  683.         catch (RecognitionException re) {
  684.             _localctx.exception = re;
  685.             _errHandler.reportError(this, re);
  686.             _errHandler.recover(this, re);
  687.         }
  688.         finally {
  689.             exitRule();
  690.         }
  691.         return _localctx;
  692.     }

  693.     public static class Annotation_literalContext extends ParserRuleContext {
  694.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  695.         public Annotation_value_literalContext annotation_value_literal() {
  696.             return getRuleContext(Annotation_value_literalContext.class,0);
  697.         }
  698.         public Annotation_literalContext(ParserRuleContext parent, int invokingState) {
  699.             super(parent, invokingState);
  700.         }
  701.         @Override public int getRuleIndex() { return RULE_annotation_literal; }
  702.         @Override
  703.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  704.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_literal(this);
  705.             else return visitor.visitChildren(this);
  706.         }
  707.     }

  708.     public final Annotation_literalContext annotation_literal() throws RecognitionException {
  709.         Annotation_literalContext _localctx = new Annotation_literalContext(_ctx, getState());
  710.         enterRule(_localctx, 20, RULE_annotation_literal);
  711.         try {
  712.             enterOuterAlt(_localctx, 1);
  713.             {
  714.             setState(189);
  715.             match(AT);
  716.             setState(190);
  717.             annotation_value_literal();
  718.             }
  719.         }
  720.         catch (RecognitionException re) {
  721.             _localctx.exception = re;
  722.             _errHandler.reportError(this, re);
  723.             _errHandler.recover(this, re);
  724.         }
  725.         finally {
  726.             exitRule();
  727.         }
  728.         return _localctx;
  729.     }

  730.     public static class Annotation_value_literalContext extends ParserRuleContext {
  731.         public TerminalNode CONSTANT() { return getToken(PlanBundleParser.CONSTANT, 0); }
  732.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  733.         public VariableatomContext variableatom() {
  734.             return getRuleContext(VariableatomContext.class,0);
  735.         }
  736.         public TerminalNode COMMA() { return getToken(PlanBundleParser.COMMA, 0); }
  737.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  738.         public NumberContext number() {
  739.             return getRuleContext(NumberContext.class,0);
  740.         }
  741.         public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
  742.         public Annotation_value_literalContext(ParserRuleContext parent, int invokingState) {
  743.             super(parent, invokingState);
  744.         }
  745.         @Override public int getRuleIndex() { return RULE_annotation_value_literal; }
  746.         @Override
  747.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  748.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_value_literal(this);
  749.             else return visitor.visitChildren(this);
  750.         }
  751.     }

  752.     public final Annotation_value_literalContext annotation_value_literal() throws RecognitionException {
  753.         Annotation_value_literalContext _localctx = new Annotation_value_literalContext(_ctx, getState());
  754.         enterRule(_localctx, 22, RULE_annotation_value_literal);
  755.         try {
  756.             enterOuterAlt(_localctx, 1);
  757.             {
  758.             setState(192);
  759.             match(CONSTANT);
  760.             setState(193);
  761.             match(LEFTROUNDBRACKET);
  762.             setState(194);
  763.             variableatom();
  764.             setState(195);
  765.             match(COMMA);
  766.             setState(198);
  767.             _errHandler.sync(this);
  768.             switch (_input.LA(1)) {
  769.             case CONSTANTNUMBER:
  770.             case MINUS:
  771.             case DIGIT:
  772.                 {
  773.                 setState(196);
  774.                 number();
  775.                 }
  776.                 break;
  777.             case STRING:
  778.                 {
  779.                 setState(197);
  780.                 match(STRING);
  781.                 }
  782.                 break;
  783.             default:
  784.                 throw new NoViableAltException(this);
  785.             }
  786.             setState(200);
  787.             match(RIGHTROUNDBRACKET);
  788.             }
  789.         }
  790.         catch (RecognitionException re) {
  791.             _localctx.exception = re;
  792.             _errHandler.reportError(this, re);
  793.             _errHandler.recover(this, re);
  794.         }
  795.         finally {
  796.             exitRule();
  797.         }
  798.         return _localctx;
  799.     }

  800.     public static class Plan_triggerContext extends ParserRuleContext {
  801.         public Plan_belief_triggerContext plan_belief_trigger() {
  802.             return getRuleContext(Plan_belief_triggerContext.class,0);
  803.         }
  804.         public Plan_goal_triggerContext plan_goal_trigger() {
  805.             return getRuleContext(Plan_goal_triggerContext.class,0);
  806.         }
  807.         public Plan_triggerContext(ParserRuleContext parent, int invokingState) {
  808.             super(parent, invokingState);
  809.         }
  810.         @Override public int getRuleIndex() { return RULE_plan_trigger; }
  811.         @Override
  812.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  813.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_trigger(this);
  814.             else return visitor.visitChildren(this);
  815.         }
  816.     }

  817.     public final Plan_triggerContext plan_trigger() throws RecognitionException {
  818.         Plan_triggerContext _localctx = new Plan_triggerContext(_ctx, getState());
  819.         enterRule(_localctx, 24, RULE_plan_trigger);
  820.         try {
  821.             enterOuterAlt(_localctx, 1);
  822.             {
  823.             setState(204);
  824.             _errHandler.sync(this);
  825.             switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
  826.             case 1:
  827.                 {
  828.                 setState(202);
  829.                 plan_belief_trigger();
  830.                 }
  831.                 break;
  832.             case 2:
  833.                 {
  834.                 setState(203);
  835.                 plan_goal_trigger();
  836.                 }
  837.                 break;
  838.             }
  839.             }
  840.         }
  841.         catch (RecognitionException re) {
  842.             _localctx.exception = re;
  843.             _errHandler.reportError(this, re);
  844.             _errHandler.recover(this, re);
  845.         }
  846.         finally {
  847.             exitRule();
  848.         }
  849.         return _localctx;
  850.     }

  851.     public static class Plan_goal_triggerContext extends ParserRuleContext {
  852.         public TerminalNode EXCLAMATIONMARK() { return getToken(PlanBundleParser.EXCLAMATIONMARK, 0); }
  853.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  854.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  855.         public Plan_goal_triggerContext(ParserRuleContext parent, int invokingState) {
  856.             super(parent, invokingState);
  857.         }
  858.         @Override public int getRuleIndex() { return RULE_plan_goal_trigger; }
  859.         @Override
  860.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  861.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_goal_trigger(this);
  862.             else return visitor.visitChildren(this);
  863.         }
  864.     }

  865.     public final Plan_goal_triggerContext plan_goal_trigger() throws RecognitionException {
  866.         Plan_goal_triggerContext _localctx = new Plan_goal_triggerContext(_ctx, getState());
  867.         enterRule(_localctx, 26, RULE_plan_goal_trigger);
  868.         int _la;
  869.         try {
  870.             enterOuterAlt(_localctx, 1);
  871.             {
  872.             setState(206);
  873.             _la = _input.LA(1);
  874.             if ( !(_la==PLUS || _la==MINUS) ) {
  875.             _errHandler.recoverInline(this);
  876.             }
  877.             else {
  878.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  879.                 _errHandler.reportMatch(this);
  880.                 consume();
  881.             }
  882.             setState(207);
  883.             match(EXCLAMATIONMARK);
  884.             }
  885.         }
  886.         catch (RecognitionException re) {
  887.             _localctx.exception = re;
  888.             _errHandler.reportError(this, re);
  889.             _errHandler.recover(this, re);
  890.         }
  891.         finally {
  892.             exitRule();
  893.         }
  894.         return _localctx;
  895.     }

  896.     public static class Plan_belief_triggerContext extends ParserRuleContext {
  897.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  898.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  899.         public Plan_belief_triggerContext(ParserRuleContext parent, int invokingState) {
  900.             super(parent, invokingState);
  901.         }
  902.         @Override public int getRuleIndex() { return RULE_plan_belief_trigger; }
  903.         @Override
  904.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  905.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_belief_trigger(this);
  906.             else return visitor.visitChildren(this);
  907.         }
  908.     }

  909.     public final Plan_belief_triggerContext plan_belief_trigger() throws RecognitionException {
  910.         Plan_belief_triggerContext _localctx = new Plan_belief_triggerContext(_ctx, getState());
  911.         enterRule(_localctx, 28, RULE_plan_belief_trigger);
  912.         int _la;
  913.         try {
  914.             enterOuterAlt(_localctx, 1);
  915.             {
  916.             setState(209);
  917.             _la = _input.LA(1);
  918.             if ( !(_la==PLUS || _la==MINUS) ) {
  919.             _errHandler.recoverInline(this);
  920.             }
  921.             else {
  922.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  923.                 _errHandler.reportMatch(this);
  924.                 consume();
  925.             }
  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.     }

  938.     public static class BodyContext extends ParserRuleContext {
  939.         public List<Body_formulaContext> body_formula() {
  940.             return getRuleContexts(Body_formulaContext.class);
  941.         }
  942.         public Body_formulaContext body_formula(int i) {
  943.             return getRuleContext(Body_formulaContext.class,i);
  944.         }
  945.         public List<TerminalNode> SEMICOLON() { return getTokens(PlanBundleParser.SEMICOLON); }
  946.         public TerminalNode SEMICOLON(int i) {
  947.             return getToken(PlanBundleParser.SEMICOLON, i);
  948.         }
  949.         public BodyContext(ParserRuleContext parent, int invokingState) {
  950.             super(parent, invokingState);
  951.         }
  952.         @Override public int getRuleIndex() { return RULE_body; }
  953.         @Override
  954.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  955.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBody(this);
  956.             else return visitor.visitChildren(this);
  957.         }
  958.     }

  959.     public final BodyContext body() throws RecognitionException {
  960.         BodyContext _localctx = new BodyContext(_ctx, getState());
  961.         enterRule(_localctx, 30, RULE_body);
  962.         int _la;
  963.         try {
  964.             enterOuterAlt(_localctx, 1);
  965.             {
  966.             setState(211);
  967.             body_formula();
  968.             setState(216);
  969.             _errHandler.sync(this);
  970.             _la = _input.LA(1);
  971.             while (_la==SEMICOLON) {
  972.                 {
  973.                 {
  974.                 setState(212);
  975.                 match(SEMICOLON);
  976.                 setState(213);
  977.                 body_formula();
  978.                 }
  979.                 }
  980.                 setState(218);
  981.                 _errHandler.sync(this);
  982.                 _la = _input.LA(1);
  983.             }
  984.             }
  985.         }
  986.         catch (RecognitionException re) {
  987.             _localctx.exception = re;
  988.             _errHandler.reportError(this, re);
  989.             _errHandler.recover(this, re);
  990.         }
  991.         finally {
  992.             exitRule();
  993.         }
  994.         return _localctx;
  995.     }

  996.     public static class Body_formulaContext extends ParserRuleContext {
  997.         public Repair_formulaContext repair_formula() {
  998.             return getRuleContext(Repair_formulaContext.class,0);
  999.         }
  1000.         public Belief_actionContext belief_action() {
  1001.             return getRuleContext(Belief_actionContext.class,0);
  1002.         }
  1003.         public Deconstruct_expressionContext deconstruct_expression() {
  1004.             return getRuleContext(Deconstruct_expressionContext.class,0);
  1005.         }
  1006.         public Assignment_expressionContext assignment_expression() {
  1007.             return getRuleContext(Assignment_expressionContext.class,0);
  1008.         }
  1009.         public Unary_expressionContext unary_expression() {
  1010.             return getRuleContext(Unary_expressionContext.class,0);
  1011.         }
  1012.         public Binary_expressionContext binary_expression() {
  1013.             return getRuleContext(Binary_expressionContext.class,0);
  1014.         }
  1015.         public LambdaContext lambda() {
  1016.             return getRuleContext(LambdaContext.class,0);
  1017.         }
  1018.         public Body_formulaContext(ParserRuleContext parent, int invokingState) {
  1019.             super(parent, invokingState);
  1020.         }
  1021.         @Override public int getRuleIndex() { return RULE_body_formula; }
  1022.         @Override
  1023.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1024.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBody_formula(this);
  1025.             else return visitor.visitChildren(this);
  1026.         }
  1027.     }

  1028.     public final Body_formulaContext body_formula() throws RecognitionException {
  1029.         Body_formulaContext _localctx = new Body_formulaContext(_ctx, getState());
  1030.         enterRule(_localctx, 32, RULE_body_formula);
  1031.         try {
  1032.             setState(226);
  1033.             _errHandler.sync(this);
  1034.             switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
  1035.             case 1:
  1036.                 enterOuterAlt(_localctx, 1);
  1037.                 {
  1038.                 setState(219);
  1039.                 repair_formula();
  1040.                 }
  1041.                 break;
  1042.             case 2:
  1043.                 enterOuterAlt(_localctx, 2);
  1044.                 {
  1045.                 setState(220);
  1046.                 belief_action();
  1047.                 }
  1048.                 break;
  1049.             case 3:
  1050.                 enterOuterAlt(_localctx, 3);
  1051.                 {
  1052.                 setState(221);
  1053.                 deconstruct_expression();
  1054.                 }
  1055.                 break;
  1056.             case 4:
  1057.                 enterOuterAlt(_localctx, 4);
  1058.                 {
  1059.                 setState(222);
  1060.                 assignment_expression();
  1061.                 }
  1062.                 break;
  1063.             case 5:
  1064.                 enterOuterAlt(_localctx, 5);
  1065.                 {
  1066.                 setState(223);
  1067.                 unary_expression();
  1068.                 }
  1069.                 break;
  1070.             case 6:
  1071.                 enterOuterAlt(_localctx, 6);
  1072.                 {
  1073.                 setState(224);
  1074.                 binary_expression();
  1075.                 }
  1076.                 break;
  1077.             case 7:
  1078.                 enterOuterAlt(_localctx, 7);
  1079.                 {
  1080.                 setState(225);
  1081.                 lambda();
  1082.                 }
  1083.                 break;
  1084.             }
  1085.         }
  1086.         catch (RecognitionException re) {
  1087.             _localctx.exception = re;
  1088.             _errHandler.reportError(this, re);
  1089.             _errHandler.recover(this, re);
  1090.         }
  1091.         finally {
  1092.             exitRule();
  1093.         }
  1094.         return _localctx;
  1095.     }

  1096.     public static class Repair_formulaContext extends ParserRuleContext {
  1097.         public Executable_termContext executable_term() {
  1098.             return getRuleContext(Executable_termContext.class,0);
  1099.         }
  1100.         public Test_actionContext test_action() {
  1101.             return getRuleContext(Test_actionContext.class,0);
  1102.         }
  1103.         public Achievement_goal_actionContext achievement_goal_action() {
  1104.             return getRuleContext(Achievement_goal_actionContext.class,0);
  1105.         }
  1106.         public TerminalNode LEFTSHIFT() { return getToken(PlanBundleParser.LEFTSHIFT, 0); }
  1107.         public Repair_formulaContext repair_formula() {
  1108.             return getRuleContext(Repair_formulaContext.class,0);
  1109.         }
  1110.         public Repair_formulaContext(ParserRuleContext parent, int invokingState) {
  1111.             super(parent, invokingState);
  1112.         }
  1113.         @Override public int getRuleIndex() { return RULE_repair_formula; }
  1114.         @Override
  1115.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1116.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitRepair_formula(this);
  1117.             else return visitor.visitChildren(this);
  1118.         }
  1119.     }

  1120.     public final Repair_formulaContext repair_formula() throws RecognitionException {
  1121.         Repair_formulaContext _localctx = new Repair_formulaContext(_ctx, getState());
  1122.         enterRule(_localctx, 34, RULE_repair_formula);
  1123.         int _la;
  1124.         try {
  1125.             enterOuterAlt(_localctx, 1);
  1126.             {
  1127.             setState(231);
  1128.             _errHandler.sync(this);
  1129.             switch (_input.LA(1)) {
  1130.             case STRING:
  1131.             case LOGICALVALUE:
  1132.             case CONSTANTNUMBER:
  1133.             case STRONGNEGATION:
  1134.             case MINUS:
  1135.             case DOLLAR:
  1136.             case AT:
  1137.             case UNDERSCORE:
  1138.             case LEFTROUNDBRACKET:
  1139.             case RIGHTSHIFT:
  1140.             case LOWERCASELETTER:
  1141.             case UPPERCASELETTER:
  1142.             case DIGIT:
  1143.                 {
  1144.                 setState(228);
  1145.                 executable_term();
  1146.                 }
  1147.                 break;
  1148.             case QUESTIONMARK:
  1149.                 {
  1150.                 setState(229);
  1151.                 test_action();
  1152.                 }
  1153.                 break;
  1154.             case EXCLAMATIONMARK:
  1155.             case DOUBLEEXCLAMATIONMARK:
  1156.                 {
  1157.                 setState(230);
  1158.                 achievement_goal_action();
  1159.                 }
  1160.                 break;
  1161.             default:
  1162.                 throw new NoViableAltException(this);
  1163.             }
  1164.             setState(235);
  1165.             _errHandler.sync(this);
  1166.             _la = _input.LA(1);
  1167.             if (_la==LEFTSHIFT) {
  1168.                 {
  1169.                 setState(233);
  1170.                 match(LEFTSHIFT);
  1171.                 setState(234);
  1172.                 repair_formula();
  1173.                 }
  1174.             }

  1175.             }
  1176.         }
  1177.         catch (RecognitionException re) {
  1178.             _localctx.exception = re;
  1179.             _errHandler.reportError(this, re);
  1180.             _errHandler.recover(this, re);
  1181.         }
  1182.         finally {
  1183.             exitRule();
  1184.         }
  1185.         return _localctx;
  1186.     }

  1187.     public static class Belief_actionContext extends ParserRuleContext {
  1188.         public LiteralContext literal() {
  1189.             return getRuleContext(LiteralContext.class,0);
  1190.         }
  1191.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  1192.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  1193.         public Belief_actionContext(ParserRuleContext parent, int invokingState) {
  1194.             super(parent, invokingState);
  1195.         }
  1196.         @Override public int getRuleIndex() { return RULE_belief_action; }
  1197.         @Override
  1198.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1199.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBelief_action(this);
  1200.             else return visitor.visitChildren(this);
  1201.         }
  1202.     }

  1203.     public final Belief_actionContext belief_action() throws RecognitionException {
  1204.         Belief_actionContext _localctx = new Belief_actionContext(_ctx, getState());
  1205.         enterRule(_localctx, 36, RULE_belief_action);
  1206.         int _la;
  1207.         try {
  1208.             enterOuterAlt(_localctx, 1);
  1209.             {
  1210.             setState(237);
  1211.             _la = _input.LA(1);
  1212.             if ( !(_la==PLUS || _la==MINUS) ) {
  1213.             _errHandler.recoverInline(this);
  1214.             }
  1215.             else {
  1216.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  1217.                 _errHandler.reportMatch(this);
  1218.                 consume();
  1219.             }
  1220.             setState(238);
  1221.             literal();
  1222.             }
  1223.         }
  1224.         catch (RecognitionException re) {
  1225.             _localctx.exception = re;
  1226.             _errHandler.reportError(this, re);
  1227.             _errHandler.recover(this, re);
  1228.         }
  1229.         finally {
  1230.             exitRule();
  1231.         }
  1232.         return _localctx;
  1233.     }

  1234.     public static class Test_actionContext extends ParserRuleContext {
  1235.         public TerminalNode QUESTIONMARK() { return getToken(PlanBundleParser.QUESTIONMARK, 0); }
  1236.         public AtomContext atom() {
  1237.             return getRuleContext(AtomContext.class,0);
  1238.         }
  1239.         public TerminalNode DOLLAR() { return getToken(PlanBundleParser.DOLLAR, 0); }
  1240.         public Test_actionContext(ParserRuleContext parent, int invokingState) {
  1241.             super(parent, invokingState);
  1242.         }
  1243.         @Override public int getRuleIndex() { return RULE_test_action; }
  1244.         @Override
  1245.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1246.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTest_action(this);
  1247.             else return visitor.visitChildren(this);
  1248.         }
  1249.     }

  1250.     public final Test_actionContext test_action() throws RecognitionException {
  1251.         Test_actionContext _localctx = new Test_actionContext(_ctx, getState());
  1252.         enterRule(_localctx, 38, RULE_test_action);
  1253.         int _la;
  1254.         try {
  1255.             enterOuterAlt(_localctx, 1);
  1256.             {
  1257.             setState(240);
  1258.             match(QUESTIONMARK);
  1259.             setState(242);
  1260.             _errHandler.sync(this);
  1261.             _la = _input.LA(1);
  1262.             if (_la==DOLLAR) {
  1263.                 {
  1264.                 setState(241);
  1265.                 match(DOLLAR);
  1266.                 }
  1267.             }

  1268.             setState(244);
  1269.             atom();
  1270.             }
  1271.         }
  1272.         catch (RecognitionException re) {
  1273.             _localctx.exception = re;
  1274.             _errHandler.reportError(this, re);
  1275.             _errHandler.recover(this, re);
  1276.         }
  1277.         finally {
  1278.             exitRule();
  1279.         }
  1280.         return _localctx;
  1281.     }

  1282.     public static class Achievement_goal_actionContext extends ParserRuleContext {
  1283.         public TerminalNode EXCLAMATIONMARK() { return getToken(PlanBundleParser.EXCLAMATIONMARK, 0); }
  1284.         public TerminalNode DOUBLEEXCLAMATIONMARK() { return getToken(PlanBundleParser.DOUBLEEXCLAMATIONMARK, 0); }
  1285.         public LiteralContext literal() {
  1286.             return getRuleContext(LiteralContext.class,0);
  1287.         }
  1288.         public Variable_evaluateContext variable_evaluate() {
  1289.             return getRuleContext(Variable_evaluateContext.class,0);
  1290.         }
  1291.         public Achievement_goal_actionContext(ParserRuleContext parent, int invokingState) {
  1292.             super(parent, invokingState);
  1293.         }
  1294.         @Override public int getRuleIndex() { return RULE_achievement_goal_action; }
  1295.         @Override
  1296.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1297.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAchievement_goal_action(this);
  1298.             else return visitor.visitChildren(this);
  1299.         }
  1300.     }

  1301.     public final Achievement_goal_actionContext achievement_goal_action() throws RecognitionException {
  1302.         Achievement_goal_actionContext _localctx = new Achievement_goal_actionContext(_ctx, getState());
  1303.         enterRule(_localctx, 40, RULE_achievement_goal_action);
  1304.         int _la;
  1305.         try {
  1306.             enterOuterAlt(_localctx, 1);
  1307.             {
  1308.             setState(246);
  1309.             _la = _input.LA(1);
  1310.             if ( !(_la==EXCLAMATIONMARK || _la==DOUBLEEXCLAMATIONMARK) ) {
  1311.             _errHandler.recoverInline(this);
  1312.             }
  1313.             else {
  1314.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  1315.                 _errHandler.reportMatch(this);
  1316.                 consume();
  1317.             }
  1318.             setState(249);
  1319.             _errHandler.sync(this);
  1320.             switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
  1321.             case 1:
  1322.                 {
  1323.                 setState(247);
  1324.                 literal();
  1325.                 }
  1326.                 break;
  1327.             case 2:
  1328.                 {
  1329.                 setState(248);
  1330.                 variable_evaluate();
  1331.                 }
  1332.                 break;
  1333.             }
  1334.             }
  1335.         }
  1336.         catch (RecognitionException re) {
  1337.             _localctx.exception = re;
  1338.             _errHandler.reportError(this, re);
  1339.             _errHandler.recover(this, re);
  1340.         }
  1341.         finally {
  1342.             exitRule();
  1343.         }
  1344.         return _localctx;
  1345.     }

  1346.     public static class Deconstruct_expressionContext extends ParserRuleContext {
  1347.         public VariablelistContext variablelist() {
  1348.             return getRuleContext(VariablelistContext.class,0);
  1349.         }
  1350.         public TerminalNode DECONSTRUCT() { return getToken(PlanBundleParser.DECONSTRUCT, 0); }
  1351.         public LiteralContext literal() {
  1352.             return getRuleContext(LiteralContext.class,0);
  1353.         }
  1354.         public VariableContext variable() {
  1355.             return getRuleContext(VariableContext.class,0);
  1356.         }
  1357.         public Deconstruct_expressionContext(ParserRuleContext parent, int invokingState) {
  1358.             super(parent, invokingState);
  1359.         }
  1360.         @Override public int getRuleIndex() { return RULE_deconstruct_expression; }
  1361.         @Override
  1362.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1363.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitDeconstruct_expression(this);
  1364.             else return visitor.visitChildren(this);
  1365.         }
  1366.     }

  1367.     public final Deconstruct_expressionContext deconstruct_expression() throws RecognitionException {
  1368.         Deconstruct_expressionContext _localctx = new Deconstruct_expressionContext(_ctx, getState());
  1369.         enterRule(_localctx, 42, RULE_deconstruct_expression);
  1370.         try {
  1371.             enterOuterAlt(_localctx, 1);
  1372.             {
  1373.             setState(251);
  1374.             variablelist();
  1375.             setState(252);
  1376.             match(DECONSTRUCT);
  1377.             setState(255);
  1378.             _errHandler.sync(this);
  1379.             switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
  1380.             case 1:
  1381.                 {
  1382.                 setState(253);
  1383.                 literal();
  1384.                 }
  1385.                 break;
  1386.             case 2:
  1387.                 {
  1388.                 setState(254);
  1389.                 variable();
  1390.                 }
  1391.                 break;
  1392.             }
  1393.             }
  1394.         }
  1395.         catch (RecognitionException re) {
  1396.             _localctx.exception = re;
  1397.             _errHandler.reportError(this, re);
  1398.             _errHandler.recover(this, re);
  1399.         }
  1400.         finally {
  1401.             exitRule();
  1402.         }
  1403.         return _localctx;
  1404.     }

  1405.     public static class Assignment_expressionContext extends ParserRuleContext {
  1406.         public Assignment_expression_singlevariableContext assignment_expression_singlevariable() {
  1407.             return getRuleContext(Assignment_expression_singlevariableContext.class,0);
  1408.         }
  1409.         public Assignment_expression_multivariableContext assignment_expression_multivariable() {
  1410.             return getRuleContext(Assignment_expression_multivariableContext.class,0);
  1411.         }
  1412.         public Assignment_expressionContext(ParserRuleContext parent, int invokingState) {
  1413.             super(parent, invokingState);
  1414.         }
  1415.         @Override public int getRuleIndex() { return RULE_assignment_expression; }
  1416.         @Override
  1417.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1418.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression(this);
  1419.             else return visitor.visitChildren(this);
  1420.         }
  1421.     }

  1422.     public final Assignment_expressionContext assignment_expression() throws RecognitionException {
  1423.         Assignment_expressionContext _localctx = new Assignment_expressionContext(_ctx, getState());
  1424.         enterRule(_localctx, 44, RULE_assignment_expression);
  1425.         try {
  1426.             setState(259);
  1427.             _errHandler.sync(this);
  1428.             switch (_input.LA(1)) {
  1429.             case AT:
  1430.             case UNDERSCORE:
  1431.             case UPPERCASELETTER:
  1432.                 enterOuterAlt(_localctx, 1);
  1433.                 {
  1434.                 setState(257);
  1435.                 assignment_expression_singlevariable();
  1436.                 }
  1437.                 break;
  1438.             case LEFTANGULARBRACKET:
  1439.                 enterOuterAlt(_localctx, 2);
  1440.                 {
  1441.                 setState(258);
  1442.                 assignment_expression_multivariable();
  1443.                 }
  1444.                 break;
  1445.             default:
  1446.                 throw new NoViableAltException(this);
  1447.             }
  1448.         }
  1449.         catch (RecognitionException re) {
  1450.             _localctx.exception = re;
  1451.             _errHandler.reportError(this, re);
  1452.             _errHandler.recover(this, re);
  1453.         }
  1454.         finally {
  1455.             exitRule();
  1456.         }
  1457.         return _localctx;
  1458.     }

  1459.     public static class Assignment_expression_singlevariableContext extends ParserRuleContext {
  1460.         public VariableContext variable() {
  1461.             return getRuleContext(VariableContext.class,0);
  1462.         }
  1463.         public TerminalNode ASSIGN() { return getToken(PlanBundleParser.ASSIGN, 0); }
  1464.         public Executable_termContext executable_term() {
  1465.             return getRuleContext(Executable_termContext.class,0);
  1466.         }
  1467.         public Assignment_expression_singlevariableContext(ParserRuleContext parent, int invokingState) {
  1468.             super(parent, invokingState);
  1469.         }
  1470.         @Override public int getRuleIndex() { return RULE_assignment_expression_singlevariable; }
  1471.         @Override
  1472.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1473.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression_singlevariable(this);
  1474.             else return visitor.visitChildren(this);
  1475.         }
  1476.     }

  1477.     public final Assignment_expression_singlevariableContext assignment_expression_singlevariable() throws RecognitionException {
  1478.         Assignment_expression_singlevariableContext _localctx = new Assignment_expression_singlevariableContext(_ctx, getState());
  1479.         enterRule(_localctx, 46, RULE_assignment_expression_singlevariable);
  1480.         try {
  1481.             enterOuterAlt(_localctx, 1);
  1482.             {
  1483.             setState(261);
  1484.             variable();
  1485.             setState(262);
  1486.             match(ASSIGN);
  1487.             setState(263);
  1488.             executable_term();
  1489.             }
  1490.         }
  1491.         catch (RecognitionException re) {
  1492.             _localctx.exception = re;
  1493.             _errHandler.reportError(this, re);
  1494.             _errHandler.recover(this, re);
  1495.         }
  1496.         finally {
  1497.             exitRule();
  1498.         }
  1499.         return _localctx;
  1500.     }

  1501.     public static class Assignment_expression_multivariableContext extends ParserRuleContext {
  1502.         public VariablelistContext variablelist() {
  1503.             return getRuleContext(VariablelistContext.class,0);
  1504.         }
  1505.         public TerminalNode ASSIGN() { return getToken(PlanBundleParser.ASSIGN, 0); }
  1506.         public Executable_termContext executable_term() {
  1507.             return getRuleContext(Executable_termContext.class,0);
  1508.         }
  1509.         public Assignment_expression_multivariableContext(ParserRuleContext parent, int invokingState) {
  1510.             super(parent, invokingState);
  1511.         }
  1512.         @Override public int getRuleIndex() { return RULE_assignment_expression_multivariable; }
  1513.         @Override
  1514.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1515.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression_multivariable(this);
  1516.             else return visitor.visitChildren(this);
  1517.         }
  1518.     }

  1519.     public final Assignment_expression_multivariableContext assignment_expression_multivariable() throws RecognitionException {
  1520.         Assignment_expression_multivariableContext _localctx = new Assignment_expression_multivariableContext(_ctx, getState());
  1521.         enterRule(_localctx, 48, RULE_assignment_expression_multivariable);
  1522.         try {
  1523.             enterOuterAlt(_localctx, 1);
  1524.             {
  1525.             setState(265);
  1526.             variablelist();
  1527.             setState(266);
  1528.             match(ASSIGN);
  1529.             setState(267);
  1530.             executable_term();
  1531.             }
  1532.         }
  1533.         catch (RecognitionException re) {
  1534.             _localctx.exception = re;
  1535.             _errHandler.reportError(this, re);
  1536.             _errHandler.recover(this, re);
  1537.         }
  1538.         finally {
  1539.             exitRule();
  1540.         }
  1541.         return _localctx;
  1542.     }

  1543.     public static class Unary_expressionContext extends ParserRuleContext {
  1544.         public VariableContext variable() {
  1545.             return getRuleContext(VariableContext.class,0);
  1546.         }
  1547.         public TerminalNode UNARYOPERATOR() { return getToken(PlanBundleParser.UNARYOPERATOR, 0); }
  1548.         public Unary_expressionContext(ParserRuleContext parent, int invokingState) {
  1549.             super(parent, invokingState);
  1550.         }
  1551.         @Override public int getRuleIndex() { return RULE_unary_expression; }
  1552.         @Override
  1553.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1554.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnary_expression(this);
  1555.             else return visitor.visitChildren(this);
  1556.         }
  1557.     }

  1558.     public final Unary_expressionContext unary_expression() throws RecognitionException {
  1559.         Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState());
  1560.         enterRule(_localctx, 50, RULE_unary_expression);
  1561.         try {
  1562.             enterOuterAlt(_localctx, 1);
  1563.             {
  1564.             setState(269);
  1565.             variable();
  1566.             setState(270);
  1567.             match(UNARYOPERATOR);
  1568.             }
  1569.         }
  1570.         catch (RecognitionException re) {
  1571.             _localctx.exception = re;
  1572.             _errHandler.reportError(this, re);
  1573.             _errHandler.recover(this, re);
  1574.         }
  1575.         finally {
  1576.             exitRule();
  1577.         }
  1578.         return _localctx;
  1579.     }

  1580.     public static class Binary_expressionContext extends ParserRuleContext {
  1581.         public List<VariableContext> variable() {
  1582.             return getRuleContexts(VariableContext.class);
  1583.         }
  1584.         public VariableContext variable(int i) {
  1585.             return getRuleContext(VariableContext.class,i);
  1586.         }
  1587.         public TerminalNode BINARYOPERATOR() { return getToken(PlanBundleParser.BINARYOPERATOR, 0); }
  1588.         public NumberContext number() {
  1589.             return getRuleContext(NumberContext.class,0);
  1590.         }
  1591.         public Binary_expressionContext(ParserRuleContext parent, int invokingState) {
  1592.             super(parent, invokingState);
  1593.         }
  1594.         @Override public int getRuleIndex() { return RULE_binary_expression; }
  1595.         @Override
  1596.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1597.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBinary_expression(this);
  1598.             else return visitor.visitChildren(this);
  1599.         }
  1600.     }

  1601.     public final Binary_expressionContext binary_expression() throws RecognitionException {
  1602.         Binary_expressionContext _localctx = new Binary_expressionContext(_ctx, getState());
  1603.         enterRule(_localctx, 52, RULE_binary_expression);
  1604.         try {
  1605.             enterOuterAlt(_localctx, 1);
  1606.             {
  1607.             setState(272);
  1608.             variable();
  1609.             setState(273);
  1610.             match(BINARYOPERATOR);
  1611.             setState(276);
  1612.             _errHandler.sync(this);
  1613.             switch (_input.LA(1)) {
  1614.             case AT:
  1615.             case UNDERSCORE:
  1616.             case UPPERCASELETTER:
  1617.                 {
  1618.                 setState(274);
  1619.                 variable();
  1620.                 }
  1621.                 break;
  1622.             case CONSTANTNUMBER:
  1623.             case MINUS:
  1624.             case DIGIT:
  1625.                 {
  1626.                 setState(275);
  1627.                 number();
  1628.                 }
  1629.                 break;
  1630.             default:
  1631.                 throw new NoViableAltException(this);
  1632.             }
  1633.             }
  1634.         }
  1635.         catch (RecognitionException re) {
  1636.             _localctx.exception = re;
  1637.             _errHandler.reportError(this, re);
  1638.             _errHandler.recover(this, re);
  1639.         }
  1640.         finally {
  1641.             exitRule();
  1642.         }
  1643.         return _localctx;
  1644.     }

  1645.     public static class Block_formulaContext extends ParserRuleContext {
  1646.         public TerminalNode LEFTCURVEDBRACKET() { return getToken(PlanBundleParser.LEFTCURVEDBRACKET, 0); }
  1647.         public BodyContext body() {
  1648.             return getRuleContext(BodyContext.class,0);
  1649.         }
  1650.         public TerminalNode RIGHTCURVEDBRACKET() { return getToken(PlanBundleParser.RIGHTCURVEDBRACKET, 0); }
  1651.         public Body_formulaContext body_formula() {
  1652.             return getRuleContext(Body_formulaContext.class,0);
  1653.         }
  1654.         public Block_formulaContext(ParserRuleContext parent, int invokingState) {
  1655.             super(parent, invokingState);
  1656.         }
  1657.         @Override public int getRuleIndex() { return RULE_block_formula; }
  1658.         @Override
  1659.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1660.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBlock_formula(this);
  1661.             else return visitor.visitChildren(this);
  1662.         }
  1663.     }

  1664.     public final Block_formulaContext block_formula() throws RecognitionException {
  1665.         Block_formulaContext _localctx = new Block_formulaContext(_ctx, getState());
  1666.         enterRule(_localctx, 54, RULE_block_formula);
  1667.         try {
  1668.             setState(283);
  1669.             _errHandler.sync(this);
  1670.             switch (_input.LA(1)) {
  1671.             case LEFTCURVEDBRACKET:
  1672.                 enterOuterAlt(_localctx, 1);
  1673.                 {
  1674.                 setState(278);
  1675.                 match(LEFTCURVEDBRACKET);
  1676.                 setState(279);
  1677.                 body();
  1678.                 setState(280);
  1679.                 match(RIGHTCURVEDBRACKET);
  1680.                 }
  1681.                 break;
  1682.             case STRING:
  1683.             case LOGICALVALUE:
  1684.             case CONSTANTNUMBER:
  1685.             case EXCLAMATIONMARK:
  1686.             case STRONGNEGATION:
  1687.             case PLUS:
  1688.             case MINUS:
  1689.             case DOUBLEEXCLAMATIONMARK:
  1690.             case QUESTIONMARK:
  1691.             case DOLLAR:
  1692.             case AT:
  1693.             case UNDERSCORE:
  1694.             case LEFTROUNDBRACKET:
  1695.             case LEFTANGULARBRACKET:
  1696.             case RIGHTSHIFT:
  1697.             case LOWERCASELETTER:
  1698.             case UPPERCASELETTER:
  1699.             case DIGIT:
  1700.                 enterOuterAlt(_localctx, 2);
  1701.                 {
  1702.                 setState(282);
  1703.                 body_formula();
  1704.                 }
  1705.                 break;
  1706.             default:
  1707.                 throw new NoViableAltException(this);
  1708.             }
  1709.         }
  1710.         catch (RecognitionException re) {
  1711.             _localctx.exception = re;
  1712.             _errHandler.reportError(this, re);
  1713.             _errHandler.recover(this, re);
  1714.         }
  1715.         finally {
  1716.             exitRule();
  1717.         }
  1718.         return _localctx;
  1719.     }

  1720.     public static class LambdaContext extends ParserRuleContext {
  1721.         public Lambda_initializationContext lambda_initialization() {
  1722.             return getRuleContext(Lambda_initializationContext.class,0);
  1723.         }
  1724.         public TerminalNode RIGHTARROW() { return getToken(PlanBundleParser.RIGHTARROW, 0); }
  1725.         public VariableContext variable() {
  1726.             return getRuleContext(VariableContext.class,0);
  1727.         }
  1728.         public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
  1729.         public Block_formulaContext block_formula() {
  1730.             return getRuleContext(Block_formulaContext.class,0);
  1731.         }
  1732.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  1733.         public Lambda_returnContext lambda_return() {
  1734.             return getRuleContext(Lambda_returnContext.class,0);
  1735.         }
  1736.         public LambdaContext(ParserRuleContext parent, int invokingState) {
  1737.             super(parent, invokingState);
  1738.         }
  1739.         @Override public int getRuleIndex() { return RULE_lambda; }
  1740.         @Override
  1741.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1742.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda(this);
  1743.             else return visitor.visitChildren(this);
  1744.         }
  1745.     }

  1746.     public final LambdaContext lambda() throws RecognitionException {
  1747.         LambdaContext _localctx = new LambdaContext(_ctx, getState());
  1748.         enterRule(_localctx, 56, RULE_lambda);
  1749.         int _la;
  1750.         try {
  1751.             enterOuterAlt(_localctx, 1);
  1752.             {
  1753.             setState(286);
  1754.             _errHandler.sync(this);
  1755.             _la = _input.LA(1);
  1756.             if (_la==AT) {
  1757.                 {
  1758.                 setState(285);
  1759.                 match(AT);
  1760.                 }
  1761.             }

  1762.             setState(288);
  1763.             lambda_initialization();
  1764.             setState(289);
  1765.             match(RIGHTARROW);
  1766.             setState(290);
  1767.             variable();
  1768.             setState(292);
  1769.             _errHandler.sync(this);
  1770.             _la = _input.LA(1);
  1771.             if (_la==VLINE) {
  1772.                 {
  1773.                 setState(291);
  1774.                 lambda_return();
  1775.                 }
  1776.             }

  1777.             setState(294);
  1778.             match(COLON);
  1779.             setState(295);
  1780.             block_formula();
  1781.             }
  1782.         }
  1783.         catch (RecognitionException re) {
  1784.             _localctx.exception = re;
  1785.             _errHandler.reportError(this, re);
  1786.             _errHandler.recover(this, re);
  1787.         }
  1788.         finally {
  1789.             exitRule();
  1790.         }
  1791.         return _localctx;
  1792.     }

  1793.     public static class Lambda_initializationContext extends ParserRuleContext {
  1794.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  1795.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  1796.         public VariableContext variable() {
  1797.             return getRuleContext(VariableContext.class,0);
  1798.         }
  1799.         public LiteralContext literal() {
  1800.             return getRuleContext(LiteralContext.class,0);
  1801.         }
  1802.         public Lambda_initializationContext(ParserRuleContext parent, int invokingState) {
  1803.             super(parent, invokingState);
  1804.         }
  1805.         @Override public int getRuleIndex() { return RULE_lambda_initialization; }
  1806.         @Override
  1807.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1808.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda_initialization(this);
  1809.             else return visitor.visitChildren(this);
  1810.         }
  1811.     }

  1812.     public final Lambda_initializationContext lambda_initialization() throws RecognitionException {
  1813.         Lambda_initializationContext _localctx = new Lambda_initializationContext(_ctx, getState());
  1814.         enterRule(_localctx, 58, RULE_lambda_initialization);
  1815.         try {
  1816.             enterOuterAlt(_localctx, 1);
  1817.             {
  1818.             setState(297);
  1819.             match(LEFTROUNDBRACKET);
  1820.             setState(300);
  1821.             _errHandler.sync(this);
  1822.             switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
  1823.             case 1:
  1824.                 {
  1825.                 setState(298);
  1826.                 variable();
  1827.                 }
  1828.                 break;
  1829.             case 2:
  1830.                 {
  1831.                 setState(299);
  1832.                 literal();
  1833.                 }
  1834.                 break;
  1835.             }
  1836.             setState(302);
  1837.             match(RIGHTROUNDBRACKET);
  1838.             }
  1839.         }
  1840.         catch (RecognitionException re) {
  1841.             _localctx.exception = re;
  1842.             _errHandler.reportError(this, re);
  1843.             _errHandler.recover(this, re);
  1844.         }
  1845.         finally {
  1846.             exitRule();
  1847.         }
  1848.         return _localctx;
  1849.     }

  1850.     public static class Lambda_returnContext extends ParserRuleContext {
  1851.         public TerminalNode VLINE() { return getToken(PlanBundleParser.VLINE, 0); }
  1852.         public VariableContext variable() {
  1853.             return getRuleContext(VariableContext.class,0);
  1854.         }
  1855.         public Lambda_returnContext(ParserRuleContext parent, int invokingState) {
  1856.             super(parent, invokingState);
  1857.         }
  1858.         @Override public int getRuleIndex() { return RULE_lambda_return; }
  1859.         @Override
  1860.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1861.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda_return(this);
  1862.             else return visitor.visitChildren(this);
  1863.         }
  1864.     }

  1865.     public final Lambda_returnContext lambda_return() throws RecognitionException {
  1866.         Lambda_returnContext _localctx = new Lambda_returnContext(_ctx, getState());
  1867.         enterRule(_localctx, 60, RULE_lambda_return);
  1868.         try {
  1869.             enterOuterAlt(_localctx, 1);
  1870.             {
  1871.             setState(304);
  1872.             match(VLINE);
  1873.             setState(305);
  1874.             variable();
  1875.             }
  1876.         }
  1877.         catch (RecognitionException re) {
  1878.             _localctx.exception = re;
  1879.             _errHandler.reportError(this, re);
  1880.             _errHandler.recover(this, re);
  1881.         }
  1882.         finally {
  1883.             exitRule();
  1884.         }
  1885.         return _localctx;
  1886.     }

  1887.     public static class Executable_termContext extends ParserRuleContext {
  1888.         public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
  1889.         public NumberContext number() {
  1890.             return getRuleContext(NumberContext.class,0);
  1891.         }
  1892.         public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
  1893.         public Executable_actionContext executable_action() {
  1894.             return getRuleContext(Executable_actionContext.class,0);
  1895.         }
  1896.         public Executable_ruleContext executable_rule() {
  1897.             return getRuleContext(Executable_ruleContext.class,0);
  1898.         }
  1899.         public ExpressionContext expression() {
  1900.             return getRuleContext(ExpressionContext.class,0);
  1901.         }
  1902.         public Ternary_operationContext ternary_operation() {
  1903.             return getRuleContext(Ternary_operationContext.class,0);
  1904.         }
  1905.         public Executable_termContext(ParserRuleContext parent, int invokingState) {
  1906.             super(parent, invokingState);
  1907.         }
  1908.         @Override public int getRuleIndex() { return RULE_executable_term; }
  1909.         @Override
  1910.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  1911.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_term(this);
  1912.             else return visitor.visitChildren(this);
  1913.         }
  1914.     }

  1915.     public final Executable_termContext executable_term() throws RecognitionException {
  1916.         Executable_termContext _localctx = new Executable_termContext(_ctx, getState());
  1917.         enterRule(_localctx, 62, RULE_executable_term);
  1918.         try {
  1919.             setState(314);
  1920.             _errHandler.sync(this);
  1921.             switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
  1922.             case 1:
  1923.                 enterOuterAlt(_localctx, 1);
  1924.                 {
  1925.                 setState(307);
  1926.                 match(STRING);
  1927.                 }
  1928.                 break;
  1929.             case 2:
  1930.                 enterOuterAlt(_localctx, 2);
  1931.                 {
  1932.                 setState(308);
  1933.                 number();
  1934.                 }
  1935.                 break;
  1936.             case 3:
  1937.                 enterOuterAlt(_localctx, 3);
  1938.                 {
  1939.                 setState(309);
  1940.                 match(LOGICALVALUE);
  1941.                 }
  1942.                 break;
  1943.             case 4:
  1944.                 enterOuterAlt(_localctx, 4);
  1945.                 {
  1946.                 setState(310);
  1947.                 executable_action();
  1948.                 }
  1949.                 break;
  1950.             case 5:
  1951.                 enterOuterAlt(_localctx, 5);
  1952.                 {
  1953.                 setState(311);
  1954.                 executable_rule();
  1955.                 }
  1956.                 break;
  1957.             case 6:
  1958.                 enterOuterAlt(_localctx, 6);
  1959.                 {
  1960.                 setState(312);
  1961.                 expression();
  1962.                 }
  1963.                 break;
  1964.             case 7:
  1965.                 enterOuterAlt(_localctx, 7);
  1966.                 {
  1967.                 setState(313);
  1968.                 ternary_operation();
  1969.                 }
  1970.                 break;
  1971.             }
  1972.         }
  1973.         catch (RecognitionException re) {
  1974.             _localctx.exception = re;
  1975.             _errHandler.reportError(this, re);
  1976.             _errHandler.recover(this, re);
  1977.         }
  1978.         finally {
  1979.             exitRule();
  1980.         }
  1981.         return _localctx;
  1982.     }

  1983.     public static class TermContext extends ParserRuleContext {
  1984.         public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
  1985.         public NumberContext number() {
  1986.             return getRuleContext(NumberContext.class,0);
  1987.         }
  1988.         public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
  1989.         public LiteralContext literal() {
  1990.             return getRuleContext(LiteralContext.class,0);
  1991.         }
  1992.         public VariableContext variable() {
  1993.             return getRuleContext(VariableContext.class,0);
  1994.         }
  1995.         public VariablelistContext variablelist() {
  1996.             return getRuleContext(VariablelistContext.class,0);
  1997.         }
  1998.         public TerminalNode LEFTANGULARBRACKET() { return getToken(PlanBundleParser.LEFTANGULARBRACKET, 0); }
  1999.         public TermlistContext termlist() {
  2000.             return getRuleContext(TermlistContext.class,0);
  2001.         }
  2002.         public TerminalNode RIGHTANGULARBRACKET() { return getToken(PlanBundleParser.RIGHTANGULARBRACKET, 0); }
  2003.         public ExpressionContext expression() {
  2004.             return getRuleContext(ExpressionContext.class,0);
  2005.         }
  2006.         public Ternary_operationContext ternary_operation() {
  2007.             return getRuleContext(Ternary_operationContext.class,0);
  2008.         }
  2009.         public TermContext(ParserRuleContext parent, int invokingState) {
  2010.             super(parent, invokingState);
  2011.         }
  2012.         @Override public int getRuleIndex() { return RULE_term; }
  2013.         @Override
  2014.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2015.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTerm(this);
  2016.             else return visitor.visitChildren(this);
  2017.         }
  2018.     }

  2019.     public final TermContext term() throws RecognitionException {
  2020.         TermContext _localctx = new TermContext(_ctx, getState());
  2021.         enterRule(_localctx, 64, RULE_term);
  2022.         try {
  2023.             setState(328);
  2024.             _errHandler.sync(this);
  2025.             switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
  2026.             case 1:
  2027.                 enterOuterAlt(_localctx, 1);
  2028.                 {
  2029.                 setState(316);
  2030.                 match(STRING);
  2031.                 }
  2032.                 break;
  2033.             case 2:
  2034.                 enterOuterAlt(_localctx, 2);
  2035.                 {
  2036.                 setState(317);
  2037.                 number();
  2038.                 }
  2039.                 break;
  2040.             case 3:
  2041.                 enterOuterAlt(_localctx, 3);
  2042.                 {
  2043.                 setState(318);
  2044.                 match(LOGICALVALUE);
  2045.                 }
  2046.                 break;
  2047.             case 4:
  2048.                 enterOuterAlt(_localctx, 4);
  2049.                 {
  2050.                 setState(319);
  2051.                 literal();
  2052.                 }
  2053.                 break;
  2054.             case 5:
  2055.                 enterOuterAlt(_localctx, 5);
  2056.                 {
  2057.                 setState(320);
  2058.                 variable();
  2059.                 }
  2060.                 break;
  2061.             case 6:
  2062.                 enterOuterAlt(_localctx, 6);
  2063.                 {
  2064.                 setState(321);
  2065.                 variablelist();
  2066.                 }
  2067.                 break;
  2068.             case 7:
  2069.                 enterOuterAlt(_localctx, 7);
  2070.                 {
  2071.                 setState(322);
  2072.                 match(LEFTANGULARBRACKET);
  2073.                 setState(323);
  2074.                 termlist();
  2075.                 setState(324);
  2076.                 match(RIGHTANGULARBRACKET);
  2077.                 }
  2078.                 break;
  2079.             case 8:
  2080.                 enterOuterAlt(_localctx, 8);
  2081.                 {
  2082.                 setState(326);
  2083.                 expression();
  2084.                 }
  2085.                 break;
  2086.             case 9:
  2087.                 enterOuterAlt(_localctx, 9);
  2088.                 {
  2089.                 setState(327);
  2090.                 ternary_operation();
  2091.                 }
  2092.                 break;
  2093.             }
  2094.         }
  2095.         catch (RecognitionException re) {
  2096.             _localctx.exception = re;
  2097.             _errHandler.reportError(this, re);
  2098.             _errHandler.recover(this, re);
  2099.         }
  2100.         finally {
  2101.             exitRule();
  2102.         }
  2103.         return _localctx;
  2104.     }

  2105.     public static class UnificationContext extends ParserRuleContext {
  2106.         public TerminalNode RIGHTSHIFT() { return getToken(PlanBundleParser.RIGHTSHIFT, 0); }
  2107.         public LiteralContext literal() {
  2108.             return getRuleContext(LiteralContext.class,0);
  2109.         }
  2110.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  2111.         public TerminalNode COMMA() { return getToken(PlanBundleParser.COMMA, 0); }
  2112.         public Unification_constraintContext unification_constraint() {
  2113.             return getRuleContext(Unification_constraintContext.class,0);
  2114.         }
  2115.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  2116.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  2117.         public UnificationContext(ParserRuleContext parent, int invokingState) {
  2118.             super(parent, invokingState);
  2119.         }
  2120.         @Override public int getRuleIndex() { return RULE_unification; }
  2121.         @Override
  2122.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2123.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnification(this);
  2124.             else return visitor.visitChildren(this);
  2125.         }
  2126.     }

  2127.     public final UnificationContext unification() throws RecognitionException {
  2128.         UnificationContext _localctx = new UnificationContext(_ctx, getState());
  2129.         enterRule(_localctx, 66, RULE_unification);
  2130.         int _la;
  2131.         try {
  2132.             enterOuterAlt(_localctx, 1);
  2133.             {
  2134.             setState(331);
  2135.             _errHandler.sync(this);
  2136.             _la = _input.LA(1);
  2137.             if (_la==AT) {
  2138.                 {
  2139.                 setState(330);
  2140.                 match(AT);
  2141.                 }
  2142.             }

  2143.             setState(333);
  2144.             match(RIGHTSHIFT);
  2145.             setState(341);
  2146.             _errHandler.sync(this);
  2147.             switch (_input.LA(1)) {
  2148.             case STRONGNEGATION:
  2149.             case AT:
  2150.             case LOWERCASELETTER:
  2151.                 {
  2152.                 setState(334);
  2153.                 literal();
  2154.                 }
  2155.                 break;
  2156.             case LEFTROUNDBRACKET:
  2157.                 {
  2158.                 setState(335);
  2159.                 match(LEFTROUNDBRACKET);
  2160.                 setState(336);
  2161.                 literal();
  2162.                 setState(337);
  2163.                 match(COMMA);
  2164.                 setState(338);
  2165.                 unification_constraint();
  2166.                 setState(339);
  2167.                 match(RIGHTROUNDBRACKET);
  2168.                 }
  2169.                 break;
  2170.             default:
  2171.                 throw new NoViableAltException(this);
  2172.             }
  2173.             }
  2174.         }
  2175.         catch (RecognitionException re) {
  2176.             _localctx.exception = re;
  2177.             _errHandler.reportError(this, re);
  2178.             _errHandler.recover(this, re);
  2179.         }
  2180.         finally {
  2181.             exitRule();
  2182.         }
  2183.         return _localctx;
  2184.     }

  2185.     public static class Unification_constraintContext extends ParserRuleContext {
  2186.         public VariableContext variable() {
  2187.             return getRuleContext(VariableContext.class,0);
  2188.         }
  2189.         public ExpressionContext expression() {
  2190.             return getRuleContext(ExpressionContext.class,0);
  2191.         }
  2192.         public Unification_constraintContext(ParserRuleContext parent, int invokingState) {
  2193.             super(parent, invokingState);
  2194.         }
  2195.         @Override public int getRuleIndex() { return RULE_unification_constraint; }
  2196.         @Override
  2197.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2198.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnification_constraint(this);
  2199.             else return visitor.visitChildren(this);
  2200.         }
  2201.     }

  2202.     public final Unification_constraintContext unification_constraint() throws RecognitionException {
  2203.         Unification_constraintContext _localctx = new Unification_constraintContext(_ctx, getState());
  2204.         enterRule(_localctx, 68, RULE_unification_constraint);
  2205.         try {
  2206.             setState(345);
  2207.             _errHandler.sync(this);
  2208.             switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
  2209.             case 1:
  2210.                 enterOuterAlt(_localctx, 1);
  2211.                 {
  2212.                 setState(343);
  2213.                 variable();
  2214.                 }
  2215.                 break;
  2216.             case 2:
  2217.                 enterOuterAlt(_localctx, 2);
  2218.                 {
  2219.                 setState(344);
  2220.                 expression();
  2221.                 }
  2222.                 break;
  2223.             }
  2224.         }
  2225.         catch (RecognitionException re) {
  2226.             _localctx.exception = re;
  2227.             _errHandler.reportError(this, re);
  2228.             _errHandler.recover(this, re);
  2229.         }
  2230.         finally {
  2231.             exitRule();
  2232.         }
  2233.         return _localctx;
  2234.     }

  2235.     public static class Ternary_operationContext extends ParserRuleContext {
  2236.         public ExpressionContext expression() {
  2237.             return getRuleContext(ExpressionContext.class,0);
  2238.         }
  2239.         public Ternary_operation_trueContext ternary_operation_true() {
  2240.             return getRuleContext(Ternary_operation_trueContext.class,0);
  2241.         }
  2242.         public Ternary_operation_falseContext ternary_operation_false() {
  2243.             return getRuleContext(Ternary_operation_falseContext.class,0);
  2244.         }
  2245.         public Ternary_operationContext(ParserRuleContext parent, int invokingState) {
  2246.             super(parent, invokingState);
  2247.         }
  2248.         @Override public int getRuleIndex() { return RULE_ternary_operation; }
  2249.         @Override
  2250.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2251.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation(this);
  2252.             else return visitor.visitChildren(this);
  2253.         }
  2254.     }

  2255.     public final Ternary_operationContext ternary_operation() throws RecognitionException {
  2256.         Ternary_operationContext _localctx = new Ternary_operationContext(_ctx, getState());
  2257.         enterRule(_localctx, 70, RULE_ternary_operation);
  2258.         try {
  2259.             enterOuterAlt(_localctx, 1);
  2260.             {
  2261.             setState(347);
  2262.             expression();
  2263.             setState(348);
  2264.             ternary_operation_true();
  2265.             setState(349);
  2266.             ternary_operation_false();
  2267.             }
  2268.         }
  2269.         catch (RecognitionException re) {
  2270.             _localctx.exception = re;
  2271.             _errHandler.reportError(this, re);
  2272.             _errHandler.recover(this, re);
  2273.         }
  2274.         finally {
  2275.             exitRule();
  2276.         }
  2277.         return _localctx;
  2278.     }

  2279.     public static class Ternary_operation_trueContext extends ParserRuleContext {
  2280.         public TerminalNode QUESTIONMARK() { return getToken(PlanBundleParser.QUESTIONMARK, 0); }
  2281.         public Executable_termContext executable_term() {
  2282.             return getRuleContext(Executable_termContext.class,0);
  2283.         }
  2284.         public Ternary_operation_trueContext(ParserRuleContext parent, int invokingState) {
  2285.             super(parent, invokingState);
  2286.         }
  2287.         @Override public int getRuleIndex() { return RULE_ternary_operation_true; }
  2288.         @Override
  2289.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2290.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation_true(this);
  2291.             else return visitor.visitChildren(this);
  2292.         }
  2293.     }

  2294.     public final Ternary_operation_trueContext ternary_operation_true() throws RecognitionException {
  2295.         Ternary_operation_trueContext _localctx = new Ternary_operation_trueContext(_ctx, getState());
  2296.         enterRule(_localctx, 72, RULE_ternary_operation_true);
  2297.         try {
  2298.             enterOuterAlt(_localctx, 1);
  2299.             {
  2300.             setState(351);
  2301.             match(QUESTIONMARK);
  2302.             setState(352);
  2303.             executable_term();
  2304.             }
  2305.         }
  2306.         catch (RecognitionException re) {
  2307.             _localctx.exception = re;
  2308.             _errHandler.reportError(this, re);
  2309.             _errHandler.recover(this, re);
  2310.         }
  2311.         finally {
  2312.             exitRule();
  2313.         }
  2314.         return _localctx;
  2315.     }

  2316.     public static class Ternary_operation_falseContext extends ParserRuleContext {
  2317.         public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
  2318.         public Executable_termContext executable_term() {
  2319.             return getRuleContext(Executable_termContext.class,0);
  2320.         }
  2321.         public Ternary_operation_falseContext(ParserRuleContext parent, int invokingState) {
  2322.             super(parent, invokingState);
  2323.         }
  2324.         @Override public int getRuleIndex() { return RULE_ternary_operation_false; }
  2325.         @Override
  2326.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2327.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation_false(this);
  2328.             else return visitor.visitChildren(this);
  2329.         }
  2330.     }

  2331.     public final Ternary_operation_falseContext ternary_operation_false() throws RecognitionException {
  2332.         Ternary_operation_falseContext _localctx = new Ternary_operation_falseContext(_ctx, getState());
  2333.         enterRule(_localctx, 74, RULE_ternary_operation_false);
  2334.         try {
  2335.             enterOuterAlt(_localctx, 1);
  2336.             {
  2337.             setState(354);
  2338.             match(COLON);
  2339.             setState(355);
  2340.             executable_term();
  2341.             }
  2342.         }
  2343.         catch (RecognitionException re) {
  2344.             _localctx.exception = re;
  2345.             _errHandler.reportError(this, re);
  2346.             _errHandler.recover(this, re);
  2347.         }
  2348.         finally {
  2349.             exitRule();
  2350.         }
  2351.         return _localctx;
  2352.     }

  2353.     public static class ExpressionContext extends ParserRuleContext {
  2354.         public Expression_bracketContext expression_bracket() {
  2355.             return getRuleContext(Expression_bracketContext.class,0);
  2356.         }
  2357.         public Expression_logical_andContext expression_logical_and() {
  2358.             return getRuleContext(Expression_logical_andContext.class,0);
  2359.         }
  2360.         public List<TerminalNode> OR() { return getTokens(PlanBundleParser.OR); }
  2361.         public TerminalNode OR(int i) {
  2362.             return getToken(PlanBundleParser.OR, i);
  2363.         }
  2364.         public List<ExpressionContext> expression() {
  2365.             return getRuleContexts(ExpressionContext.class);
  2366.         }
  2367.         public ExpressionContext expression(int i) {
  2368.             return getRuleContext(ExpressionContext.class,i);
  2369.         }
  2370.         public ExpressionContext(ParserRuleContext parent, int invokingState) {
  2371.             super(parent, invokingState);
  2372.         }
  2373.         @Override public int getRuleIndex() { return RULE_expression; }
  2374.         @Override
  2375.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2376.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression(this);
  2377.             else return visitor.visitChildren(this);
  2378.         }
  2379.     }

  2380.     public final ExpressionContext expression() throws RecognitionException {
  2381.         ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
  2382.         enterRule(_localctx, 76, RULE_expression);
  2383.         try {
  2384.             int _alt;
  2385.             setState(366);
  2386.             _errHandler.sync(this);
  2387.             switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
  2388.             case 1:
  2389.                 enterOuterAlt(_localctx, 1);
  2390.                 {
  2391.                 setState(357);
  2392.                 expression_bracket();
  2393.                 }
  2394.                 break;
  2395.             case 2:
  2396.                 enterOuterAlt(_localctx, 2);
  2397.                 {
  2398.                 setState(358);
  2399.                 expression_logical_and();
  2400.                 setState(363);
  2401.                 _errHandler.sync(this);
  2402.                 _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
  2403.                 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  2404.                     if ( _alt==1 ) {
  2405.                         {
  2406.                         {
  2407.                         setState(359);
  2408.                         match(OR);
  2409.                         setState(360);
  2410.                         expression();
  2411.                         }
  2412.                         }
  2413.                     }
  2414.                     setState(365);
  2415.                     _errHandler.sync(this);
  2416.                     _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
  2417.                 }
  2418.                 }
  2419.                 break;
  2420.             }
  2421.         }
  2422.         catch (RecognitionException re) {
  2423.             _localctx.exception = re;
  2424.             _errHandler.reportError(this, re);
  2425.             _errHandler.recover(this, re);
  2426.         }
  2427.         finally {
  2428.             exitRule();
  2429.         }
  2430.         return _localctx;
  2431.     }

  2432.     public static class Expression_bracketContext extends ParserRuleContext {
  2433.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  2434.         public ExpressionContext expression() {
  2435.             return getRuleContext(ExpressionContext.class,0);
  2436.         }
  2437.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  2438.         public Expression_bracketContext(ParserRuleContext parent, int invokingState) {
  2439.             super(parent, invokingState);
  2440.         }
  2441.         @Override public int getRuleIndex() { return RULE_expression_bracket; }
  2442.         @Override
  2443.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2444.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_bracket(this);
  2445.             else return visitor.visitChildren(this);
  2446.         }
  2447.     }

  2448.     public final Expression_bracketContext expression_bracket() throws RecognitionException {
  2449.         Expression_bracketContext _localctx = new Expression_bracketContext(_ctx, getState());
  2450.         enterRule(_localctx, 78, RULE_expression_bracket);
  2451.         try {
  2452.             enterOuterAlt(_localctx, 1);
  2453.             {
  2454.             setState(368);
  2455.             match(LEFTROUNDBRACKET);
  2456.             setState(369);
  2457.             expression();
  2458.             setState(370);
  2459.             match(RIGHTROUNDBRACKET);
  2460.             }
  2461.         }
  2462.         catch (RecognitionException re) {
  2463.             _localctx.exception = re;
  2464.             _errHandler.reportError(this, re);
  2465.             _errHandler.recover(this, re);
  2466.         }
  2467.         finally {
  2468.             exitRule();
  2469.         }
  2470.         return _localctx;
  2471.     }

  2472.     public static class Expression_logical_andContext extends ParserRuleContext {
  2473.         public Expression_logical_xorContext expression_logical_xor() {
  2474.             return getRuleContext(Expression_logical_xorContext.class,0);
  2475.         }
  2476.         public List<TerminalNode> AND() { return getTokens(PlanBundleParser.AND); }
  2477.         public TerminalNode AND(int i) {
  2478.             return getToken(PlanBundleParser.AND, i);
  2479.         }
  2480.         public List<ExpressionContext> expression() {
  2481.             return getRuleContexts(ExpressionContext.class);
  2482.         }
  2483.         public ExpressionContext expression(int i) {
  2484.             return getRuleContext(ExpressionContext.class,i);
  2485.         }
  2486.         public Expression_logical_andContext(ParserRuleContext parent, int invokingState) {
  2487.             super(parent, invokingState);
  2488.         }
  2489.         @Override public int getRuleIndex() { return RULE_expression_logical_and; }
  2490.         @Override
  2491.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2492.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_and(this);
  2493.             else return visitor.visitChildren(this);
  2494.         }
  2495.     }

  2496.     public final Expression_logical_andContext expression_logical_and() throws RecognitionException {
  2497.         Expression_logical_andContext _localctx = new Expression_logical_andContext(_ctx, getState());
  2498.         enterRule(_localctx, 80, RULE_expression_logical_and);
  2499.         try {
  2500.             int _alt;
  2501.             enterOuterAlt(_localctx, 1);
  2502.             {
  2503.             setState(372);
  2504.             expression_logical_xor();
  2505.             setState(377);
  2506.             _errHandler.sync(this);
  2507.             _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
  2508.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  2509.                 if ( _alt==1 ) {
  2510.                     {
  2511.                     {
  2512.                     setState(373);
  2513.                     match(AND);
  2514.                     setState(374);
  2515.                     expression();
  2516.                     }
  2517.                     }
  2518.                 }
  2519.                 setState(379);
  2520.                 _errHandler.sync(this);
  2521.                 _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
  2522.             }
  2523.             }
  2524.         }
  2525.         catch (RecognitionException re) {
  2526.             _localctx.exception = re;
  2527.             _errHandler.reportError(this, re);
  2528.             _errHandler.recover(this, re);
  2529.         }
  2530.         finally {
  2531.             exitRule();
  2532.         }
  2533.         return _localctx;
  2534.     }

  2535.     public static class Expression_logical_xorContext extends ParserRuleContext {
  2536.         public Expression_logical_negationContext expression_logical_negation() {
  2537.             return getRuleContext(Expression_logical_negationContext.class,0);
  2538.         }
  2539.         public Expression_logical_elementContext expression_logical_element() {
  2540.             return getRuleContext(Expression_logical_elementContext.class,0);
  2541.         }
  2542.         public Expression_numericContext expression_numeric() {
  2543.             return getRuleContext(Expression_numericContext.class,0);
  2544.         }
  2545.         public List<TerminalNode> XOR() { return getTokens(PlanBundleParser.XOR); }
  2546.         public TerminalNode XOR(int i) {
  2547.             return getToken(PlanBundleParser.XOR, i);
  2548.         }
  2549.         public List<ExpressionContext> expression() {
  2550.             return getRuleContexts(ExpressionContext.class);
  2551.         }
  2552.         public ExpressionContext expression(int i) {
  2553.             return getRuleContext(ExpressionContext.class,i);
  2554.         }
  2555.         public Expression_logical_xorContext(ParserRuleContext parent, int invokingState) {
  2556.             super(parent, invokingState);
  2557.         }
  2558.         @Override public int getRuleIndex() { return RULE_expression_logical_xor; }
  2559.         @Override
  2560.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2561.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_xor(this);
  2562.             else return visitor.visitChildren(this);
  2563.         }
  2564.     }

  2565.     public final Expression_logical_xorContext expression_logical_xor() throws RecognitionException {
  2566.         Expression_logical_xorContext _localctx = new Expression_logical_xorContext(_ctx, getState());
  2567.         enterRule(_localctx, 82, RULE_expression_logical_xor);
  2568.         try {
  2569.             int _alt;
  2570.             enterOuterAlt(_localctx, 1);
  2571.             {
  2572.             setState(383);
  2573.             _errHandler.sync(this);
  2574.             switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
  2575.             case 1:
  2576.                 {
  2577.                 setState(380);
  2578.                 expression_logical_negation();
  2579.                 }
  2580.                 break;
  2581.             case 2:
  2582.                 {
  2583.                 setState(381);
  2584.                 expression_logical_element();
  2585.                 }
  2586.                 break;
  2587.             case 3:
  2588.                 {
  2589.                 setState(382);
  2590.                 expression_numeric();
  2591.                 }
  2592.                 break;
  2593.             }
  2594.             setState(389);
  2595.             _errHandler.sync(this);
  2596.             _alt = getInterpreter().adaptivePredict(_input,35,_ctx);
  2597.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  2598.                 if ( _alt==1 ) {
  2599.                     {
  2600.                     {
  2601.                     setState(385);
  2602.                     match(XOR);
  2603.                     setState(386);
  2604.                     expression();
  2605.                     }
  2606.                     }
  2607.                 }
  2608.                 setState(391);
  2609.                 _errHandler.sync(this);
  2610.                 _alt = getInterpreter().adaptivePredict(_input,35,_ctx);
  2611.             }
  2612.             }
  2613.         }
  2614.         catch (RecognitionException re) {
  2615.             _localctx.exception = re;
  2616.             _errHandler.reportError(this, re);
  2617.             _errHandler.recover(this, re);
  2618.         }
  2619.         finally {
  2620.             exitRule();
  2621.         }
  2622.         return _localctx;
  2623.     }

  2624.     public static class Expression_logical_elementContext extends ParserRuleContext {
  2625.         public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
  2626.         public VariableContext variable() {
  2627.             return getRuleContext(VariableContext.class,0);
  2628.         }
  2629.         public Executable_actionContext executable_action() {
  2630.             return getRuleContext(Executable_actionContext.class,0);
  2631.         }
  2632.         public Executable_ruleContext executable_rule() {
  2633.             return getRuleContext(Executable_ruleContext.class,0);
  2634.         }
  2635.         public UnificationContext unification() {
  2636.             return getRuleContext(UnificationContext.class,0);
  2637.         }
  2638.         public Expression_logical_elementContext(ParserRuleContext parent, int invokingState) {
  2639.             super(parent, invokingState);
  2640.         }
  2641.         @Override public int getRuleIndex() { return RULE_expression_logical_element; }
  2642.         @Override
  2643.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2644.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_element(this);
  2645.             else return visitor.visitChildren(this);
  2646.         }
  2647.     }

  2648.     public final Expression_logical_elementContext expression_logical_element() throws RecognitionException {
  2649.         Expression_logical_elementContext _localctx = new Expression_logical_elementContext(_ctx, getState());
  2650.         enterRule(_localctx, 84, RULE_expression_logical_element);
  2651.         try {
  2652.             setState(397);
  2653.             _errHandler.sync(this);
  2654.             switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
  2655.             case 1:
  2656.                 enterOuterAlt(_localctx, 1);
  2657.                 {
  2658.                 setState(392);
  2659.                 match(LOGICALVALUE);
  2660.                 }
  2661.                 break;
  2662.             case 2:
  2663.                 enterOuterAlt(_localctx, 2);
  2664.                 {
  2665.                 setState(393);
  2666.                 variable();
  2667.                 }
  2668.                 break;
  2669.             case 3:
  2670.                 enterOuterAlt(_localctx, 3);
  2671.                 {
  2672.                 setState(394);
  2673.                 executable_action();
  2674.                 }
  2675.                 break;
  2676.             case 4:
  2677.                 enterOuterAlt(_localctx, 4);
  2678.                 {
  2679.                 setState(395);
  2680.                 executable_rule();
  2681.                 }
  2682.                 break;
  2683.             case 5:
  2684.                 enterOuterAlt(_localctx, 5);
  2685.                 {
  2686.                 setState(396);
  2687.                 unification();
  2688.                 }
  2689.                 break;
  2690.             }
  2691.         }
  2692.         catch (RecognitionException re) {
  2693.             _localctx.exception = re;
  2694.             _errHandler.reportError(this, re);
  2695.             _errHandler.recover(this, re);
  2696.         }
  2697.         finally {
  2698.             exitRule();
  2699.         }
  2700.         return _localctx;
  2701.     }

  2702.     public static class Expression_logical_negationContext extends ParserRuleContext {
  2703.         public TerminalNode STRONGNEGATION() { return getToken(PlanBundleParser.STRONGNEGATION, 0); }
  2704.         public ExpressionContext expression() {
  2705.             return getRuleContext(ExpressionContext.class,0);
  2706.         }
  2707.         public Expression_logical_negationContext(ParserRuleContext parent, int invokingState) {
  2708.             super(parent, invokingState);
  2709.         }
  2710.         @Override public int getRuleIndex() { return RULE_expression_logical_negation; }
  2711.         @Override
  2712.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2713.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_negation(this);
  2714.             else return visitor.visitChildren(this);
  2715.         }
  2716.     }

  2717.     public final Expression_logical_negationContext expression_logical_negation() throws RecognitionException {
  2718.         Expression_logical_negationContext _localctx = new Expression_logical_negationContext(_ctx, getState());
  2719.         enterRule(_localctx, 86, RULE_expression_logical_negation);
  2720.         try {
  2721.             enterOuterAlt(_localctx, 1);
  2722.             {
  2723.             setState(399);
  2724.             match(STRONGNEGATION);
  2725.             setState(400);
  2726.             expression();
  2727.             }
  2728.         }
  2729.         catch (RecognitionException re) {
  2730.             _localctx.exception = re;
  2731.             _errHandler.reportError(this, re);
  2732.             _errHandler.recover(this, re);
  2733.         }
  2734.         finally {
  2735.             exitRule();
  2736.         }
  2737.         return _localctx;
  2738.     }

  2739.     public static class Expression_numericContext extends ParserRuleContext {
  2740.         public Expression_numeric_relationContext expression_numeric_relation() {
  2741.             return getRuleContext(Expression_numeric_relationContext.class,0);
  2742.         }
  2743.         public Expression_numericContext expression_numeric() {
  2744.             return getRuleContext(Expression_numericContext.class,0);
  2745.         }
  2746.         public TerminalNode EQUAL() { return getToken(PlanBundleParser.EQUAL, 0); }
  2747.         public TerminalNode NOTEQUAL() { return getToken(PlanBundleParser.NOTEQUAL, 0); }
  2748.         public Expression_numericContext(ParserRuleContext parent, int invokingState) {
  2749.             super(parent, invokingState);
  2750.         }
  2751.         @Override public int getRuleIndex() { return RULE_expression_numeric; }
  2752.         @Override
  2753.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2754.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric(this);
  2755.             else return visitor.visitChildren(this);
  2756.         }
  2757.     }

  2758.     public final Expression_numericContext expression_numeric() throws RecognitionException {
  2759.         Expression_numericContext _localctx = new Expression_numericContext(_ctx, getState());
  2760.         enterRule(_localctx, 88, RULE_expression_numeric);
  2761.         int _la;
  2762.         try {
  2763.             enterOuterAlt(_localctx, 1);
  2764.             {
  2765.             setState(402);
  2766.             expression_numeric_relation();
  2767.             setState(405);
  2768.             _errHandler.sync(this);
  2769.             switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
  2770.             case 1:
  2771.                 {
  2772.                 setState(403);
  2773.                 _la = _input.LA(1);
  2774.                 if ( !(_la==EQUAL || _la==NOTEQUAL) ) {
  2775.                 _errHandler.recoverInline(this);
  2776.                 }
  2777.                 else {
  2778.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  2779.                     _errHandler.reportMatch(this);
  2780.                     consume();
  2781.                 }
  2782.                 setState(404);
  2783.                 expression_numeric();
  2784.                 }
  2785.                 break;
  2786.             }
  2787.             }
  2788.         }
  2789.         catch (RecognitionException re) {
  2790.             _localctx.exception = re;
  2791.             _errHandler.reportError(this, re);
  2792.             _errHandler.recover(this, re);
  2793.         }
  2794.         finally {
  2795.             exitRule();
  2796.         }
  2797.         return _localctx;
  2798.     }

  2799.     public static class Expression_numeric_relationContext extends ParserRuleContext {
  2800.         public Expression_numeric_additiveContext expression_numeric_additive() {
  2801.             return getRuleContext(Expression_numeric_additiveContext.class,0);
  2802.         }
  2803.         public Expression_numericContext expression_numeric() {
  2804.             return getRuleContext(Expression_numericContext.class,0);
  2805.         }
  2806.         public TerminalNode LESS() { return getToken(PlanBundleParser.LESS, 0); }
  2807.         public TerminalNode LESSEQUAL() { return getToken(PlanBundleParser.LESSEQUAL, 0); }
  2808.         public TerminalNode GREATER() { return getToken(PlanBundleParser.GREATER, 0); }
  2809.         public TerminalNode GREATEREQUAL() { return getToken(PlanBundleParser.GREATEREQUAL, 0); }
  2810.         public Expression_numeric_relationContext(ParserRuleContext parent, int invokingState) {
  2811.             super(parent, invokingState);
  2812.         }
  2813.         @Override public int getRuleIndex() { return RULE_expression_numeric_relation; }
  2814.         @Override
  2815.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2816.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_relation(this);
  2817.             else return visitor.visitChildren(this);
  2818.         }
  2819.     }

  2820.     public final Expression_numeric_relationContext expression_numeric_relation() throws RecognitionException {
  2821.         Expression_numeric_relationContext _localctx = new Expression_numeric_relationContext(_ctx, getState());
  2822.         enterRule(_localctx, 90, RULE_expression_numeric_relation);
  2823.         int _la;
  2824.         try {
  2825.             enterOuterAlt(_localctx, 1);
  2826.             {
  2827.             setState(407);
  2828.             expression_numeric_additive();
  2829.             setState(410);
  2830.             _errHandler.sync(this);
  2831.             switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
  2832.             case 1:
  2833.                 {
  2834.                 setState(408);
  2835.                 _la = _input.LA(1);
  2836.                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LESS) | (1L << LESSEQUAL) | (1L << GREATER) | (1L << GREATEREQUAL))) != 0)) ) {
  2837.                 _errHandler.recoverInline(this);
  2838.                 }
  2839.                 else {
  2840.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  2841.                     _errHandler.reportMatch(this);
  2842.                     consume();
  2843.                 }
  2844.                 setState(409);
  2845.                 expression_numeric();
  2846.                 }
  2847.                 break;
  2848.             }
  2849.             }
  2850.         }
  2851.         catch (RecognitionException re) {
  2852.             _localctx.exception = re;
  2853.             _errHandler.reportError(this, re);
  2854.             _errHandler.recover(this, re);
  2855.         }
  2856.         finally {
  2857.             exitRule();
  2858.         }
  2859.         return _localctx;
  2860.     }

  2861.     public static class Expression_numeric_additiveContext extends ParserRuleContext {
  2862.         public Expression_numeric_multiplicativeContext expression_numeric_multiplicative() {
  2863.             return getRuleContext(Expression_numeric_multiplicativeContext.class,0);
  2864.         }
  2865.         public Expression_numericContext expression_numeric() {
  2866.             return getRuleContext(Expression_numericContext.class,0);
  2867.         }
  2868.         public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
  2869.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  2870.         public Expression_numeric_additiveContext(ParserRuleContext parent, int invokingState) {
  2871.             super(parent, invokingState);
  2872.         }
  2873.         @Override public int getRuleIndex() { return RULE_expression_numeric_additive; }
  2874.         @Override
  2875.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2876.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_additive(this);
  2877.             else return visitor.visitChildren(this);
  2878.         }
  2879.     }

  2880.     public final Expression_numeric_additiveContext expression_numeric_additive() throws RecognitionException {
  2881.         Expression_numeric_additiveContext _localctx = new Expression_numeric_additiveContext(_ctx, getState());
  2882.         enterRule(_localctx, 92, RULE_expression_numeric_additive);
  2883.         int _la;
  2884.         try {
  2885.             enterOuterAlt(_localctx, 1);
  2886.             {
  2887.             setState(412);
  2888.             expression_numeric_multiplicative();
  2889.             setState(415);
  2890.             _errHandler.sync(this);
  2891.             switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
  2892.             case 1:
  2893.                 {
  2894.                 setState(413);
  2895.                 _la = _input.LA(1);
  2896.                 if ( !(_la==PLUS || _la==MINUS) ) {
  2897.                 _errHandler.recoverInline(this);
  2898.                 }
  2899.                 else {
  2900.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  2901.                     _errHandler.reportMatch(this);
  2902.                     consume();
  2903.                 }
  2904.                 setState(414);
  2905.                 expression_numeric();
  2906.                 }
  2907.                 break;
  2908.             }
  2909.             }
  2910.         }
  2911.         catch (RecognitionException re) {
  2912.             _localctx.exception = re;
  2913.             _errHandler.reportError(this, re);
  2914.             _errHandler.recover(this, re);
  2915.         }
  2916.         finally {
  2917.             exitRule();
  2918.         }
  2919.         return _localctx;
  2920.     }

  2921.     public static class Expression_numeric_multiplicativeContext extends ParserRuleContext {
  2922.         public Expression_numeric_powerContext expression_numeric_power() {
  2923.             return getRuleContext(Expression_numeric_powerContext.class,0);
  2924.         }
  2925.         public Expression_numericContext expression_numeric() {
  2926.             return getRuleContext(Expression_numericContext.class,0);
  2927.         }
  2928.         public TerminalNode SLASH() { return getToken(PlanBundleParser.SLASH, 0); }
  2929.         public TerminalNode MODULO() { return getToken(PlanBundleParser.MODULO, 0); }
  2930.         public TerminalNode MULTIPLY() { return getToken(PlanBundleParser.MULTIPLY, 0); }
  2931.         public Expression_numeric_multiplicativeContext(ParserRuleContext parent, int invokingState) {
  2932.             super(parent, invokingState);
  2933.         }
  2934.         @Override public int getRuleIndex() { return RULE_expression_numeric_multiplicative; }
  2935.         @Override
  2936.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2937.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_multiplicative(this);
  2938.             else return visitor.visitChildren(this);
  2939.         }
  2940.     }

  2941.     public final Expression_numeric_multiplicativeContext expression_numeric_multiplicative() throws RecognitionException {
  2942.         Expression_numeric_multiplicativeContext _localctx = new Expression_numeric_multiplicativeContext(_ctx, getState());
  2943.         enterRule(_localctx, 94, RULE_expression_numeric_multiplicative);
  2944.         int _la;
  2945.         try {
  2946.             enterOuterAlt(_localctx, 1);
  2947.             {
  2948.             setState(417);
  2949.             expression_numeric_power();
  2950.             setState(420);
  2951.             _errHandler.sync(this);
  2952.             switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
  2953.             case 1:
  2954.                 {
  2955.                 setState(418);
  2956.                 _la = _input.LA(1);
  2957.                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SLASH) | (1L << MULTIPLY) | (1L << MODULO))) != 0)) ) {
  2958.                 _errHandler.recoverInline(this);
  2959.                 }
  2960.                 else {
  2961.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  2962.                     _errHandler.reportMatch(this);
  2963.                     consume();
  2964.                 }
  2965.                 setState(419);
  2966.                 expression_numeric();
  2967.                 }
  2968.                 break;
  2969.             }
  2970.             }
  2971.         }
  2972.         catch (RecognitionException re) {
  2973.             _localctx.exception = re;
  2974.             _errHandler.reportError(this, re);
  2975.             _errHandler.recover(this, re);
  2976.         }
  2977.         finally {
  2978.             exitRule();
  2979.         }
  2980.         return _localctx;
  2981.     }

  2982.     public static class Expression_numeric_powerContext extends ParserRuleContext {
  2983.         public Expression_numeric_elementContext expression_numeric_element() {
  2984.             return getRuleContext(Expression_numeric_elementContext.class,0);
  2985.         }
  2986.         public TerminalNode POW() { return getToken(PlanBundleParser.POW, 0); }
  2987.         public Expression_numericContext expression_numeric() {
  2988.             return getRuleContext(Expression_numericContext.class,0);
  2989.         }
  2990.         public Expression_numeric_powerContext(ParserRuleContext parent, int invokingState) {
  2991.             super(parent, invokingState);
  2992.         }
  2993.         @Override public int getRuleIndex() { return RULE_expression_numeric_power; }
  2994.         @Override
  2995.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  2996.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_power(this);
  2997.             else return visitor.visitChildren(this);
  2998.         }
  2999.     }

  3000.     public final Expression_numeric_powerContext expression_numeric_power() throws RecognitionException {
  3001.         Expression_numeric_powerContext _localctx = new Expression_numeric_powerContext(_ctx, getState());
  3002.         enterRule(_localctx, 96, RULE_expression_numeric_power);
  3003.         int _la;
  3004.         try {
  3005.             enterOuterAlt(_localctx, 1);
  3006.             {
  3007.             setState(422);
  3008.             expression_numeric_element();
  3009.             setState(425);
  3010.             _errHandler.sync(this);
  3011.             _la = _input.LA(1);
  3012.             if (_la==POW) {
  3013.                 {
  3014.                 setState(423);
  3015.                 match(POW);
  3016.                 setState(424);
  3017.                 expression_numeric();
  3018.                 }
  3019.             }

  3020.             }
  3021.         }
  3022.         catch (RecognitionException re) {
  3023.             _localctx.exception = re;
  3024.             _errHandler.reportError(this, re);
  3025.             _errHandler.recover(this, re);
  3026.         }
  3027.         finally {
  3028.             exitRule();
  3029.         }
  3030.         return _localctx;
  3031.     }

  3032.     public static class Expression_numeric_elementContext extends ParserRuleContext {
  3033.         public NumberContext number() {
  3034.             return getRuleContext(NumberContext.class,0);
  3035.         }
  3036.         public VariableContext variable() {
  3037.             return getRuleContext(VariableContext.class,0);
  3038.         }
  3039.         public Executable_actionContext executable_action() {
  3040.             return getRuleContext(Executable_actionContext.class,0);
  3041.         }
  3042.         public Executable_ruleContext executable_rule() {
  3043.             return getRuleContext(Executable_ruleContext.class,0);
  3044.         }
  3045.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  3046.         public Expression_numericContext expression_numeric() {
  3047.             return getRuleContext(Expression_numericContext.class,0);
  3048.         }
  3049.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  3050.         public Expression_numeric_elementContext(ParserRuleContext parent, int invokingState) {
  3051.             super(parent, invokingState);
  3052.         }
  3053.         @Override public int getRuleIndex() { return RULE_expression_numeric_element; }
  3054.         @Override
  3055.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3056.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_element(this);
  3057.             else return visitor.visitChildren(this);
  3058.         }
  3059.     }

  3060.     public final Expression_numeric_elementContext expression_numeric_element() throws RecognitionException {
  3061.         Expression_numeric_elementContext _localctx = new Expression_numeric_elementContext(_ctx, getState());
  3062.         enterRule(_localctx, 98, RULE_expression_numeric_element);
  3063.         try {
  3064.             setState(435);
  3065.             _errHandler.sync(this);
  3066.             switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
  3067.             case 1:
  3068.                 enterOuterAlt(_localctx, 1);
  3069.                 {
  3070.                 setState(427);
  3071.                 number();
  3072.                 }
  3073.                 break;
  3074.             case 2:
  3075.                 enterOuterAlt(_localctx, 2);
  3076.                 {
  3077.                 setState(428);
  3078.                 variable();
  3079.                 }
  3080.                 break;
  3081.             case 3:
  3082.                 enterOuterAlt(_localctx, 3);
  3083.                 {
  3084.                 setState(429);
  3085.                 executable_action();
  3086.                 }
  3087.                 break;
  3088.             case 4:
  3089.                 enterOuterAlt(_localctx, 4);
  3090.                 {
  3091.                 setState(430);
  3092.                 executable_rule();
  3093.                 }
  3094.                 break;
  3095.             case 5:
  3096.                 enterOuterAlt(_localctx, 5);
  3097.                 {
  3098.                 setState(431);
  3099.                 match(LEFTROUNDBRACKET);
  3100.                 setState(432);
  3101.                 expression_numeric();
  3102.                 setState(433);
  3103.                 match(RIGHTROUNDBRACKET);
  3104.                 }
  3105.                 break;
  3106.             }
  3107.         }
  3108.         catch (RecognitionException re) {
  3109.             _localctx.exception = re;
  3110.             _errHandler.reportError(this, re);
  3111.             _errHandler.recover(this, re);
  3112.         }
  3113.         finally {
  3114.             exitRule();
  3115.         }
  3116.         return _localctx;
  3117.     }

  3118.     public static class Executable_actionContext extends ParserRuleContext {
  3119.         public LiteralContext literal() {
  3120.             return getRuleContext(LiteralContext.class,0);
  3121.         }
  3122.         public Executable_actionContext(ParserRuleContext parent, int invokingState) {
  3123.             super(parent, invokingState);
  3124.         }
  3125.         @Override public int getRuleIndex() { return RULE_executable_action; }
  3126.         @Override
  3127.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3128.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_action(this);
  3129.             else return visitor.visitChildren(this);
  3130.         }
  3131.     }

  3132.     public final Executable_actionContext executable_action() throws RecognitionException {
  3133.         Executable_actionContext _localctx = new Executable_actionContext(_ctx, getState());
  3134.         enterRule(_localctx, 100, RULE_executable_action);
  3135.         try {
  3136.             enterOuterAlt(_localctx, 1);
  3137.             {
  3138.             setState(437);
  3139.             literal();
  3140.             }
  3141.         }
  3142.         catch (RecognitionException re) {
  3143.             _localctx.exception = re;
  3144.             _errHandler.reportError(this, re);
  3145.             _errHandler.recover(this, re);
  3146.         }
  3147.         finally {
  3148.             exitRule();
  3149.         }
  3150.         return _localctx;
  3151.     }

  3152.     public static class Executable_ruleContext extends ParserRuleContext {
  3153.         public TerminalNode DOLLAR() { return getToken(PlanBundleParser.DOLLAR, 0); }
  3154.         public LiteralContext literal() {
  3155.             return getRuleContext(LiteralContext.class,0);
  3156.         }
  3157.         public Variable_evaluateContext variable_evaluate() {
  3158.             return getRuleContext(Variable_evaluateContext.class,0);
  3159.         }
  3160.         public Executable_ruleContext(ParserRuleContext parent, int invokingState) {
  3161.             super(parent, invokingState);
  3162.         }
  3163.         @Override public int getRuleIndex() { return RULE_executable_rule; }
  3164.         @Override
  3165.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3166.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_rule(this);
  3167.             else return visitor.visitChildren(this);
  3168.         }
  3169.     }

  3170.     public final Executable_ruleContext executable_rule() throws RecognitionException {
  3171.         Executable_ruleContext _localctx = new Executable_ruleContext(_ctx, getState());
  3172.         enterRule(_localctx, 102, RULE_executable_rule);
  3173.         try {
  3174.             enterOuterAlt(_localctx, 1);
  3175.             {
  3176.             setState(439);
  3177.             match(DOLLAR);
  3178.             setState(442);
  3179.             _errHandler.sync(this);
  3180.             switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
  3181.             case 1:
  3182.                 {
  3183.                 setState(440);
  3184.                 literal();
  3185.                 }
  3186.                 break;
  3187.             case 2:
  3188.                 {
  3189.                 setState(441);
  3190.                 variable_evaluate();
  3191.                 }
  3192.                 break;
  3193.             }
  3194.             }
  3195.         }
  3196.         catch (RecognitionException re) {
  3197.             _localctx.exception = re;
  3198.             _errHandler.reportError(this, re);
  3199.             _errHandler.recover(this, re);
  3200.         }
  3201.         finally {
  3202.             exitRule();
  3203.         }
  3204.         return _localctx;
  3205.     }

  3206.     public static class Variable_evaluateContext extends ParserRuleContext {
  3207.         public VariableContext variable() {
  3208.             return getRuleContext(VariableContext.class,0);
  3209.         }
  3210.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  3211.         public TermlistContext termlist() {
  3212.             return getRuleContext(TermlistContext.class,0);
  3213.         }
  3214.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  3215.         public Variable_evaluateContext(ParserRuleContext parent, int invokingState) {
  3216.             super(parent, invokingState);
  3217.         }
  3218.         @Override public int getRuleIndex() { return RULE_variable_evaluate; }
  3219.         @Override
  3220.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3221.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariable_evaluate(this);
  3222.             else return visitor.visitChildren(this);
  3223.         }
  3224.     }

  3225.     public final Variable_evaluateContext variable_evaluate() throws RecognitionException {
  3226.         Variable_evaluateContext _localctx = new Variable_evaluateContext(_ctx, getState());
  3227.         enterRule(_localctx, 104, RULE_variable_evaluate);
  3228.         int _la;
  3229.         try {
  3230.             enterOuterAlt(_localctx, 1);
  3231.             {
  3232.             setState(444);
  3233.             variable();
  3234.             setState(449);
  3235.             _errHandler.sync(this);
  3236.             _la = _input.LA(1);
  3237.             if (_la==LEFTROUNDBRACKET) {
  3238.                 {
  3239.                 setState(445);
  3240.                 match(LEFTROUNDBRACKET);
  3241.                 setState(446);
  3242.                 termlist();
  3243.                 setState(447);
  3244.                 match(RIGHTROUNDBRACKET);
  3245.                 }
  3246.             }

  3247.             }
  3248.         }
  3249.         catch (RecognitionException re) {
  3250.             _localctx.exception = re;
  3251.             _errHandler.reportError(this, re);
  3252.             _errHandler.recover(this, re);
  3253.         }
  3254.         finally {
  3255.             exitRule();
  3256.         }
  3257.         return _localctx;
  3258.     }

  3259.     public static class LiteralContext extends ParserRuleContext {
  3260.         public AtomContext atom() {
  3261.             return getRuleContext(AtomContext.class,0);
  3262.         }
  3263.         public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
  3264.         public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
  3265.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  3266.         public TerminalNode STRONGNEGATION() { return getToken(PlanBundleParser.STRONGNEGATION, 0); }
  3267.         public TermlistContext termlist() {
  3268.             return getRuleContext(TermlistContext.class,0);
  3269.         }
  3270.         public LiteralContext(ParserRuleContext parent, int invokingState) {
  3271.             super(parent, invokingState);
  3272.         }
  3273.         @Override public int getRuleIndex() { return RULE_literal; }
  3274.         @Override
  3275.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3276.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLiteral(this);
  3277.             else return visitor.visitChildren(this);
  3278.         }
  3279.     }

  3280.     public final LiteralContext literal() throws RecognitionException {
  3281.         LiteralContext _localctx = new LiteralContext(_ctx, getState());
  3282.         enterRule(_localctx, 106, RULE_literal);
  3283.         int _la;
  3284.         try {
  3285.             enterOuterAlt(_localctx, 1);
  3286.             {
  3287.             setState(452);
  3288.             _errHandler.sync(this);
  3289.             _la = _input.LA(1);
  3290.             if (_la==STRONGNEGATION || _la==AT) {
  3291.                 {
  3292.                 setState(451);
  3293.                 _la = _input.LA(1);
  3294.                 if ( !(_la==STRONGNEGATION || _la==AT) ) {
  3295.                 _errHandler.recoverInline(this);
  3296.                 }
  3297.                 else {
  3298.                     if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3299.                     _errHandler.reportMatch(this);
  3300.                     consume();
  3301.                 }
  3302.                 }
  3303.             }

  3304.             setState(454);
  3305.             atom();
  3306.             setState(460);
  3307.             _errHandler.sync(this);
  3308.             _la = _input.LA(1);
  3309.             if (_la==LEFTROUNDBRACKET) {
  3310.                 {
  3311.                 setState(455);
  3312.                 match(LEFTROUNDBRACKET);
  3313.                 setState(457);
  3314.                 _errHandler.sync(this);
  3315.                 _la = _input.LA(1);
  3316.                 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)) {
  3317.                     {
  3318.                     setState(456);
  3319.                     termlist();
  3320.                     }
  3321.                 }

  3322.                 setState(459);
  3323.                 match(RIGHTROUNDBRACKET);
  3324.                 }
  3325.             }

  3326.             }
  3327.         }
  3328.         catch (RecognitionException re) {
  3329.             _localctx.exception = re;
  3330.             _errHandler.reportError(this, re);
  3331.             _errHandler.recover(this, re);
  3332.         }
  3333.         finally {
  3334.             exitRule();
  3335.         }
  3336.         return _localctx;
  3337.     }

  3338.     public static class TermlistContext extends ParserRuleContext {
  3339.         public List<TermContext> term() {
  3340.             return getRuleContexts(TermContext.class);
  3341.         }
  3342.         public TermContext term(int i) {
  3343.             return getRuleContext(TermContext.class,i);
  3344.         }
  3345.         public List<TerminalNode> COMMA() { return getTokens(PlanBundleParser.COMMA); }
  3346.         public TerminalNode COMMA(int i) {
  3347.             return getToken(PlanBundleParser.COMMA, i);
  3348.         }
  3349.         public TermlistContext(ParserRuleContext parent, int invokingState) {
  3350.             super(parent, invokingState);
  3351.         }
  3352.         @Override public int getRuleIndex() { return RULE_termlist; }
  3353.         @Override
  3354.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3355.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTermlist(this);
  3356.             else return visitor.visitChildren(this);
  3357.         }
  3358.     }

  3359.     public final TermlistContext termlist() throws RecognitionException {
  3360.         TermlistContext _localctx = new TermlistContext(_ctx, getState());
  3361.         enterRule(_localctx, 108, RULE_termlist);
  3362.         int _la;
  3363.         try {
  3364.             enterOuterAlt(_localctx, 1);
  3365.             {
  3366.             setState(462);
  3367.             term();
  3368.             setState(467);
  3369.             _errHandler.sync(this);
  3370.             _la = _input.LA(1);
  3371.             while (_la==COMMA) {
  3372.                 {
  3373.                 {
  3374.                 setState(463);
  3375.                 match(COMMA);
  3376.                 setState(464);
  3377.                 term();
  3378.                 }
  3379.                 }
  3380.                 setState(469);
  3381.                 _errHandler.sync(this);
  3382.                 _la = _input.LA(1);
  3383.             }
  3384.             }
  3385.         }
  3386.         catch (RecognitionException re) {
  3387.             _localctx.exception = re;
  3388.             _errHandler.reportError(this, re);
  3389.             _errHandler.recover(this, re);
  3390.         }
  3391.         finally {
  3392.             exitRule();
  3393.         }
  3394.         return _localctx;
  3395.     }

  3396.     public static class VariablelistContext extends ParserRuleContext {
  3397.         public TerminalNode LEFTANGULARBRACKET() { return getToken(PlanBundleParser.LEFTANGULARBRACKET, 0); }
  3398.         public List<VariableContext> variable() {
  3399.             return getRuleContexts(VariableContext.class);
  3400.         }
  3401.         public VariableContext variable(int i) {
  3402.             return getRuleContext(VariableContext.class,i);
  3403.         }
  3404.         public TerminalNode RIGHTANGULARBRACKET() { return getToken(PlanBundleParser.RIGHTANGULARBRACKET, 0); }
  3405.         public List<TerminalNode> VLINE() { return getTokens(PlanBundleParser.VLINE); }
  3406.         public TerminalNode VLINE(int i) {
  3407.             return getToken(PlanBundleParser.VLINE, i);
  3408.         }
  3409.         public VariablelistContext(ParserRuleContext parent, int invokingState) {
  3410.             super(parent, invokingState);
  3411.         }
  3412.         @Override public int getRuleIndex() { return RULE_variablelist; }
  3413.         @Override
  3414.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3415.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariablelist(this);
  3416.             else return visitor.visitChildren(this);
  3417.         }
  3418.     }

  3419.     public final VariablelistContext variablelist() throws RecognitionException {
  3420.         VariablelistContext _localctx = new VariablelistContext(_ctx, getState());
  3421.         enterRule(_localctx, 110, RULE_variablelist);
  3422.         int _la;
  3423.         try {
  3424.             enterOuterAlt(_localctx, 1);
  3425.             {
  3426.             setState(470);
  3427.             match(LEFTANGULARBRACKET);
  3428.             setState(471);
  3429.             variable();
  3430.             setState(476);
  3431.             _errHandler.sync(this);
  3432.             _la = _input.LA(1);
  3433.             while (_la==VLINE) {
  3434.                 {
  3435.                 {
  3436.                 setState(472);
  3437.                 match(VLINE);
  3438.                 setState(473);
  3439.                 variable();
  3440.                 }
  3441.                 }
  3442.                 setState(478);
  3443.                 _errHandler.sync(this);
  3444.                 _la = _input.LA(1);
  3445.             }
  3446.             setState(479);
  3447.             match(RIGHTANGULARBRACKET);
  3448.             }
  3449.         }
  3450.         catch (RecognitionException re) {
  3451.             _localctx.exception = re;
  3452.             _errHandler.reportError(this, re);
  3453.             _errHandler.recover(this, re);
  3454.         }
  3455.         finally {
  3456.             exitRule();
  3457.         }
  3458.         return _localctx;
  3459.     }

  3460.     public static class AtomContext extends ParserRuleContext {
  3461.         public List<TerminalNode> LOWERCASELETTER() { return getTokens(PlanBundleParser.LOWERCASELETTER); }
  3462.         public TerminalNode LOWERCASELETTER(int i) {
  3463.             return getToken(PlanBundleParser.LOWERCASELETTER, i);
  3464.         }
  3465.         public List<TerminalNode> UPPERCASELETTER() { return getTokens(PlanBundleParser.UPPERCASELETTER); }
  3466.         public TerminalNode UPPERCASELETTER(int i) {
  3467.             return getToken(PlanBundleParser.UPPERCASELETTER, i);
  3468.         }
  3469.         public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
  3470.         public TerminalNode DIGIT(int i) {
  3471.             return getToken(PlanBundleParser.DIGIT, i);
  3472.         }
  3473.         public List<TerminalNode> SLASH() { return getTokens(PlanBundleParser.SLASH); }
  3474.         public TerminalNode SLASH(int i) {
  3475.             return getToken(PlanBundleParser.SLASH, i);
  3476.         }
  3477.         public List<TerminalNode> MINUS() { return getTokens(PlanBundleParser.MINUS); }
  3478.         public TerminalNode MINUS(int i) {
  3479.             return getToken(PlanBundleParser.MINUS, i);
  3480.         }
  3481.         public AtomContext(ParserRuleContext parent, int invokingState) {
  3482.             super(parent, invokingState);
  3483.         }
  3484.         @Override public int getRuleIndex() { return RULE_atom; }
  3485.         @Override
  3486.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3487.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAtom(this);
  3488.             else return visitor.visitChildren(this);
  3489.         }
  3490.     }

  3491.     public final AtomContext atom() throws RecognitionException {
  3492.         AtomContext _localctx = new AtomContext(_ctx, getState());
  3493.         enterRule(_localctx, 112, RULE_atom);
  3494.         int _la;
  3495.         try {
  3496.             int _alt;
  3497.             enterOuterAlt(_localctx, 1);
  3498.             {
  3499.             setState(481);
  3500.             match(LOWERCASELETTER);
  3501.             setState(485);
  3502.             _errHandler.sync(this);
  3503.             _alt = getInterpreter().adaptivePredict(_input,50,_ctx);
  3504.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  3505.                 if ( _alt==1 ) {
  3506.                     {
  3507.                     {
  3508.                     setState(482);
  3509.                     _la = _input.LA(1);
  3510.                     if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MINUS) | (1L << SLASH) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) ) {
  3511.                     _errHandler.recoverInline(this);
  3512.                     }
  3513.                     else {
  3514.                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3515.                         _errHandler.reportMatch(this);
  3516.                         consume();
  3517.                     }
  3518.                     }
  3519.                     }
  3520.                 }
  3521.                 setState(487);
  3522.                 _errHandler.sync(this);
  3523.                 _alt = getInterpreter().adaptivePredict(_input,50,_ctx);
  3524.             }
  3525.             }
  3526.         }
  3527.         catch (RecognitionException re) {
  3528.             _localctx.exception = re;
  3529.             _errHandler.reportError(this, re);
  3530.             _errHandler.recover(this, re);
  3531.         }
  3532.         finally {
  3533.             exitRule();
  3534.         }
  3535.         return _localctx;
  3536.     }

  3537.     public static class VariableContext extends ParserRuleContext {
  3538.         public VariableatomContext variableatom() {
  3539.             return getRuleContext(VariableatomContext.class,0);
  3540.         }
  3541.         public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
  3542.         public VariableContext(ParserRuleContext parent, int invokingState) {
  3543.             super(parent, invokingState);
  3544.         }
  3545.         @Override public int getRuleIndex() { return RULE_variable; }
  3546.         @Override
  3547.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3548.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariable(this);
  3549.             else return visitor.visitChildren(this);
  3550.         }
  3551.     }

  3552.     public final VariableContext variable() throws RecognitionException {
  3553.         VariableContext _localctx = new VariableContext(_ctx, getState());
  3554.         enterRule(_localctx, 114, RULE_variable);
  3555.         int _la;
  3556.         try {
  3557.             enterOuterAlt(_localctx, 1);
  3558.             {
  3559.             setState(489);
  3560.             _errHandler.sync(this);
  3561.             _la = _input.LA(1);
  3562.             if (_la==AT) {
  3563.                 {
  3564.                 setState(488);
  3565.                 match(AT);
  3566.                 }
  3567.             }

  3568.             setState(491);
  3569.             variableatom();
  3570.             }
  3571.         }
  3572.         catch (RecognitionException re) {
  3573.             _localctx.exception = re;
  3574.             _errHandler.reportError(this, re);
  3575.             _errHandler.recover(this, re);
  3576.         }
  3577.         finally {
  3578.             exitRule();
  3579.         }
  3580.         return _localctx;
  3581.     }

  3582.     public static class VariableatomContext extends ParserRuleContext {
  3583.         public List<TerminalNode> UPPERCASELETTER() { return getTokens(PlanBundleParser.UPPERCASELETTER); }
  3584.         public TerminalNode UPPERCASELETTER(int i) {
  3585.             return getToken(PlanBundleParser.UPPERCASELETTER, i);
  3586.         }
  3587.         public TerminalNode UNDERSCORE() { return getToken(PlanBundleParser.UNDERSCORE, 0); }
  3588.         public List<TerminalNode> LOWERCASELETTER() { return getTokens(PlanBundleParser.LOWERCASELETTER); }
  3589.         public TerminalNode LOWERCASELETTER(int i) {
  3590.             return getToken(PlanBundleParser.LOWERCASELETTER, i);
  3591.         }
  3592.         public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
  3593.         public TerminalNode DIGIT(int i) {
  3594.             return getToken(PlanBundleParser.DIGIT, i);
  3595.         }
  3596.         public List<TerminalNode> SLASH() { return getTokens(PlanBundleParser.SLASH); }
  3597.         public TerminalNode SLASH(int i) {
  3598.             return getToken(PlanBundleParser.SLASH, i);
  3599.         }
  3600.         public VariableatomContext(ParserRuleContext parent, int invokingState) {
  3601.             super(parent, invokingState);
  3602.         }
  3603.         @Override public int getRuleIndex() { return RULE_variableatom; }
  3604.         @Override
  3605.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3606.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariableatom(this);
  3607.             else return visitor.visitChildren(this);
  3608.         }
  3609.     }

  3610.     public final VariableatomContext variableatom() throws RecognitionException {
  3611.         VariableatomContext _localctx = new VariableatomContext(_ctx, getState());
  3612.         enterRule(_localctx, 116, RULE_variableatom);
  3613.         int _la;
  3614.         try {
  3615.             int _alt;
  3616.             enterOuterAlt(_localctx, 1);
  3617.             {
  3618.             setState(493);
  3619.             _la = _input.LA(1);
  3620.             if ( !(_la==UNDERSCORE || _la==UPPERCASELETTER) ) {
  3621.             _errHandler.recoverInline(this);
  3622.             }
  3623.             else {
  3624.                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3625.                 _errHandler.reportMatch(this);
  3626.                 consume();
  3627.             }
  3628.             setState(497);
  3629.             _errHandler.sync(this);
  3630.             _alt = getInterpreter().adaptivePredict(_input,52,_ctx);
  3631.             while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
  3632.                 if ( _alt==1 ) {
  3633.                     {
  3634.                     {
  3635.                     setState(494);
  3636.                     _la = _input.LA(1);
  3637.                     if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SLASH) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) ) {
  3638.                     _errHandler.recoverInline(this);
  3639.                     }
  3640.                     else {
  3641.                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
  3642.                         _errHandler.reportMatch(this);
  3643.                         consume();
  3644.                     }
  3645.                     }
  3646.                     }
  3647.                 }
  3648.                 setState(499);
  3649.                 _errHandler.sync(this);
  3650.                 _alt = getInterpreter().adaptivePredict(_input,52,_ctx);
  3651.             }
  3652.             }
  3653.         }
  3654.         catch (RecognitionException re) {
  3655.             _localctx.exception = re;
  3656.             _errHandler.reportError(this, re);
  3657.             _errHandler.recover(this, re);
  3658.         }
  3659.         finally {
  3660.             exitRule();
  3661.         }
  3662.         return _localctx;
  3663.     }

  3664.     public static class NumberContext extends ParserRuleContext {
  3665.         public TerminalNode CONSTANTNUMBER() { return getToken(PlanBundleParser.CONSTANTNUMBER, 0); }
  3666.         public DigitsequenceContext digitsequence() {
  3667.             return getRuleContext(DigitsequenceContext.class,0);
  3668.         }
  3669.         public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
  3670.         public NumberContext(ParserRuleContext parent, int invokingState) {
  3671.             super(parent, invokingState);
  3672.         }
  3673.         @Override public int getRuleIndex() { return RULE_number; }
  3674.         @Override
  3675.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3676.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitNumber(this);
  3677.             else return visitor.visitChildren(this);
  3678.         }
  3679.     }

  3680.     public final NumberContext number() throws RecognitionException {
  3681.         NumberContext _localctx = new NumberContext(_ctx, getState());
  3682.         enterRule(_localctx, 118, RULE_number);
  3683.         int _la;
  3684.         try {
  3685.             enterOuterAlt(_localctx, 1);
  3686.             {
  3687.             setState(501);
  3688.             _errHandler.sync(this);
  3689.             _la = _input.LA(1);
  3690.             if (_la==MINUS) {
  3691.                 {
  3692.                 setState(500);
  3693.                 match(MINUS);
  3694.                 }
  3695.             }

  3696.             setState(505);
  3697.             _errHandler.sync(this);
  3698.             switch (_input.LA(1)) {
  3699.             case CONSTANTNUMBER:
  3700.                 {
  3701.                 setState(503);
  3702.                 match(CONSTANTNUMBER);
  3703.                 }
  3704.                 break;
  3705.             case DIGIT:
  3706.                 {
  3707.                 setState(504);
  3708.                 digitsequence();
  3709.                 }
  3710.                 break;
  3711.             default:
  3712.                 throw new NoViableAltException(this);
  3713.             }
  3714.             }
  3715.         }
  3716.         catch (RecognitionException re) {
  3717.             _localctx.exception = re;
  3718.             _errHandler.reportError(this, re);
  3719.             _errHandler.recover(this, re);
  3720.         }
  3721.         finally {
  3722.             exitRule();
  3723.         }
  3724.         return _localctx;
  3725.     }

  3726.     public static class DigitsequenceContext extends ParserRuleContext {
  3727.         public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
  3728.         public TerminalNode DIGIT(int i) {
  3729.             return getToken(PlanBundleParser.DIGIT, i);
  3730.         }
  3731.         public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
  3732.         public DigitsequenceContext(ParserRuleContext parent, int invokingState) {
  3733.             super(parent, invokingState);
  3734.         }
  3735.         @Override public int getRuleIndex() { return RULE_digitsequence; }
  3736.         @Override
  3737.         public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
  3738.             if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitDigitsequence(this);
  3739.             else return visitor.visitChildren(this);
  3740.         }
  3741.     }

  3742.     public final DigitsequenceContext digitsequence() throws RecognitionException {
  3743.         DigitsequenceContext _localctx = new DigitsequenceContext(_ctx, getState());
  3744.         enterRule(_localctx, 120, RULE_digitsequence);
  3745.         int _la;
  3746.         try {
  3747.             enterOuterAlt(_localctx, 1);
  3748.             {
  3749.             setState(508);
  3750.             _errHandler.sync(this);
  3751.             _la = _input.LA(1);
  3752.             do {
  3753.                 {
  3754.                 {
  3755.                 setState(507);
  3756.                 match(DIGIT);
  3757.                 }
  3758.                 }
  3759.                 setState(510);
  3760.                 _errHandler.sync(this);
  3761.                 _la = _input.LA(1);
  3762.             } while ( _la==DIGIT );
  3763.             setState(518);
  3764.             _errHandler.sync(this);
  3765.             switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
  3766.             case 1:
  3767.                 {
  3768.                 setState(512);
  3769.                 match(DOT);
  3770.                 setState(514);
  3771.                 _errHandler.sync(this);
  3772.                 _la = _input.LA(1);
  3773.                 do {
  3774.                     {
  3775.                     {
  3776.                     setState(513);
  3777.                     match(DIGIT);
  3778.                     }
  3779.                     }
  3780.                     setState(516);
  3781.                     _errHandler.sync(this);
  3782.                     _la = _input.LA(1);
  3783.                 } while ( _la==DIGIT );
  3784.                 }
  3785.                 break;
  3786.             }
  3787.             }
  3788.         }
  3789.         catch (RecognitionException re) {
  3790.             _localctx.exception = re;
  3791.             _errHandler.reportError(this, re);
  3792.             _errHandler.recover(this, re);
  3793.         }
  3794.         finally {
  3795.             exitRule();
  3796.         }
  3797.         return _localctx;
  3798.     }

  3799.     public static final String _serializedATN =
  3800.         "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\38\u020b\4\2\t\2\4"+
  3801.         "\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"+
  3802.         "\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"+
  3803.         "\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"+
  3804.         "\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!"+
  3805.         "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
  3806.         ",\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"+
  3807.         "\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="+
  3808.         "\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"+
  3809.         "\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"+
  3810.         "\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"+
  3811.         "\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"+
  3812.         "\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"+
  3813.         "\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"+
  3814.         "\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"+
  3815.         "\3\21\7\21\u00d9\n\21\f\21\16\21\u00dc\13\21\3\22\3\22\3\22\3\22\3\22"+
  3816.         "\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"+
  3817.         "\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"+
  3818.         "\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"+
  3819.         "\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"+
  3820.         "\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"+
  3821.         "\u011e\n\35\3\36\5\36\u0121\n\36\3\36\3\36\3\36\3\36\5\36\u0127\n\36\3"+
  3822.         "\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!"+
  3823.         "\3!\3!\3!\3!\3!\5!\u013d\n!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
  3824.         "\"\3\"\5\"\u014b\n\"\3#\5#\u014e\n#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u0158\n"+
  3825.         "#\3$\3$\5$\u015c\n$\3%\3%\3%\3%\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3(\7(\u016c"+
  3826.         "\n(\f(\16(\u016f\13(\5(\u0171\n(\3)\3)\3)\3)\3*\3*\3*\7*\u017a\n*\f*\16"+
  3827.         "*\u017d\13*\3+\3+\3+\5+\u0182\n+\3+\3+\7+\u0186\n+\f+\16+\u0189\13+\3"+
  3828.         ",\3,\3,\3,\3,\5,\u0190\n,\3-\3-\3-\3.\3.\3.\5.\u0198\n.\3/\3/\3/\5/\u019d"+
  3829.         "\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"+
  3830.         "\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"+
  3831.         "\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"+
  3832.         "\66\3\66\5\66\u01c4\n\66\3\67\5\67\u01c7\n\67\3\67\3\67\3\67\5\67\u01cc"+
  3833.         "\n\67\3\67\5\67\u01cf\n\67\38\38\38\78\u01d4\n8\f8\168\u01d7\138\39\3"+
  3834.         "9\39\39\79\u01dd\n9\f9\169\u01e0\139\39\39\3:\3:\7:\u01e6\n:\f:\16:\u01e9"+
  3835.         "\13:\3;\5;\u01ec\n;\3;\3;\3<\3<\7<\u01f2\n<\f<\16<\u01f5\13<\3=\5=\u01f8"+
  3836.         "\n=\3=\3=\5=\u01fc\n=\3>\6>\u01ff\n>\r>\16>\u0200\3>\3>\6>\u0205\n>\r"+
  3837.         ">\16>\u0206\5>\u0209\n>\3>\2\2?\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36"+
  3838.         " \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz\2\f\3\2!\"\3"+
  3839.         "\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"+
  3840.         "\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"+
  3841.         "\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"+
  3842.         "\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"+
  3843.         "\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"+
  3844.         "\u00d3\3\2\2\2 \u00d5\3\2\2\2\"\u00e4\3\2\2\2$\u00e9\3\2\2\2&\u00ef\3"+
  3845.         "\2\2\2(\u00f2\3\2\2\2*\u00f8\3\2\2\2,\u00fd\3\2\2\2.\u0105\3\2\2\2\60"+
  3846.         "\u0107\3\2\2\2\62\u010b\3\2\2\2\64\u010f\3\2\2\2\66\u0112\3\2\2\28\u011d"+
  3847.         "\3\2\2\2:\u0120\3\2\2\2<\u012b\3\2\2\2>\u0132\3\2\2\2@\u013c\3\2\2\2B"+
  3848.         "\u014a\3\2\2\2D\u014d\3\2\2\2F\u015b\3\2\2\2H\u015d\3\2\2\2J\u0161\3\2"+
  3849.         "\2\2L\u0164\3\2\2\2N\u0170\3\2\2\2P\u0172\3\2\2\2R\u0176\3\2\2\2T\u0181"+
  3850.         "\3\2\2\2V\u018f\3\2\2\2X\u0191\3\2\2\2Z\u0194\3\2\2\2\\\u0199\3\2\2\2"+
  3851.         "^\u019e\3\2\2\2`\u01a3\3\2\2\2b\u01a8\3\2\2\2d\u01b5\3\2\2\2f\u01b7\3"+
  3852.         "\2\2\2h\u01b9\3\2\2\2j\u01be\3\2\2\2l\u01c6\3\2\2\2n\u01d0\3\2\2\2p\u01d8"+
  3853.         "\3\2\2\2r\u01e3\3\2\2\2t\u01eb\3\2\2\2v\u01ef\3\2\2\2x\u01f7\3\2\2\2z"+
  3854.         "\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"+
  3855.         "\3\2\2\2\u0080\u0083\3\2\2\2\u0081\177\3\2\2\2\u0082\u0084\5\b\5\2\u0083"+
  3856.         "\u0082\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u0086\5\6"+
  3857.         "\4\2\u0086\3\3\2\2\2\u0087\u0088\5l\67\2\u0088\u0089\7\26\2\2\u0089\5"+
  3858.         "\3\2\2\2\u008a\u008c\5\n\6\2\u008b\u008a\3\2\2\2\u008c\u008d\3\2\2\2\u008d"+
  3859.         "\u008b\3\2\2\2\u008d\u008e\3\2\2\2\u008e\7\3\2\2\2\u008f\u0091\5\16\b"+
  3860.         "\2\u0090\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0090\3\2\2\2\u0092\u0093"+
  3861.         "\3\2\2\2\u0093\t\3\2\2\2\u0094\u0096\5\22\n\2\u0095\u0094\3\2\2\2\u0095"+
  3862.         "\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u0098\5\32\16\2\u0098\u009c\5"+
  3863.         "l\67\2\u0099\u009b\5\f\7\2\u009a\u0099\3\2\2\2\u009b\u009e\3\2\2\2\u009c"+
  3864.         "\u009a\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009f\3\2\2\2\u009e\u009c\3\2"+
  3865.         "\2\2\u009f\u00a0\7\26\2\2\u00a0\13\3\2\2\2\u00a1\u00a2\7\24\2\2\u00a2"+
  3866.         "\u00a4\5N(\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a5\3\2\2"+
  3867.         "\2\u00a5\u00a6\7\20\2\2\u00a6\u00a7\5 \21\2\u00a7\r\3\2\2\2\u00a8\u00aa"+
  3868.         "\5\22\n\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2"+
  3869.         "\u00ab\u00ad\5l\67\2\u00ac\u00ae\5\20\t\2\u00ad\u00ac\3\2\2\2\u00ae\u00af"+
  3870.         "\3\2\2\2\u00af\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1"+
  3871.         "\u00b2\7\26\2\2\u00b2\17\3\2\2\2\u00b3\u00b4\7\22\2\2\u00b4\u00b5\5 \21"+
  3872.         "\2\u00b5\21\3\2\2\2\u00b6\u00b9\5\24\13\2\u00b7\u00b9\5\26\f\2\u00b8\u00b6"+
  3873.         "\3\2\2\2\u00b8\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba"+
  3874.         "\u00bb\3\2\2\2\u00bb\23\3\2\2\2\u00bc\u00bd\7\23\2\2\u00bd\u00be\t\2\2"+
  3875.         "\2\u00be\25\3\2\2\2\u00bf\u00c0\7\23\2\2\u00c0\u00c1\5\30\r\2\u00c1\27"+
  3876.         "\3\2\2\2\u00c2\u00c3\7#\2\2\u00c3\u00c4\7\31\2\2\u00c4\u00c5\5v<\2\u00c5"+
  3877.         "\u00c8\7\n\2\2\u00c6\u00c9\5x=\2\u00c7\u00c9\7\5\2\2\u00c8\u00c6\3\2\2"+
  3878.         "\2\u00c8\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\7\32\2\2\u00cb"+
  3879.         "\31\3\2\2\2\u00cc\u00cf\5\36\20\2\u00cd\u00cf\5\34\17\2\u00ce\u00cc\3"+
  3880.         "\2\2\2\u00ce\u00cd\3\2\2\2\u00cf\33\3\2\2\2\u00d0\u00d1\t\3\2\2\u00d1"+
  3881.         "\u00d2\7\b\2\2\u00d2\35\3\2\2\2\u00d3\u00d4\t\3\2\2\u00d4\37\3\2\2\2\u00d5"+
  3882.         "\u00da\5\"\22\2\u00d6\u00d7\7\25\2\2\u00d7\u00d9\5\"\22\2\u00d8\u00d6"+
  3883.         "\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db"+
  3884.         "!\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00e5\5$\23\2\u00de\u00e5\5&\24\2"+
  3885.         "\u00df\u00e5\5,\27\2\u00e0\u00e5\5.\30\2\u00e1\u00e5\5\64\33\2\u00e2\u00e5"+
  3886.         "\5\66\34\2\u00e3\u00e5\5:\36\2\u00e4\u00dd\3\2\2\2\u00e4\u00de\3\2\2\2"+
  3887.         "\u00e4\u00df\3\2\2\2\u00e4\u00e0\3\2\2\2\u00e4\u00e1\3\2\2\2\u00e4\u00e2"+
  3888.         "\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5#\3\2\2\2\u00e6\u00ea\5@!\2\u00e7\u00ea"+
  3889.         "\5(\25\2\u00e8\u00ea\5*\26\2\u00e9\u00e6\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9"+
  3890.         "\u00e8\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb\u00ec\7\37\2\2\u00ec\u00ee\5"+
  3891.         "$\23\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee%\3\2\2\2\u00ef\u00f0"+
  3892.         "\t\3\2\2\u00f0\u00f1\5l\67\2\u00f1\'\3\2\2\2\u00f2\u00f4\7\16\2\2\u00f3"+
  3893.         "\u00f5\7\17\2\2\u00f4\u00f3\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f6\3"+
  3894.         "\2\2\2\u00f6\u00f7\5r:\2\u00f7)\3\2\2\2\u00f8\u00fb\t\4\2\2\u00f9\u00fc"+
  3895.         "\5l\67\2\u00fa\u00fc\5j\66\2\u00fb\u00f9\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc"+
  3896.         "+\3\2\2\2\u00fd\u00fe\5p9\2\u00fe\u0101\7)\2\2\u00ff\u0102\5l\67\2\u0100"+
  3897.         "\u0102\5t;\2\u0101\u00ff\3\2\2\2\u0101\u0100\3\2\2\2\u0102-\3\2\2\2\u0103"+
  3898.         "\u0106\5\60\31\2\u0104\u0106\5\62\32\2\u0105\u0103\3\2\2\2\u0105\u0104"+
  3899.         "\3\2\2\2\u0106/\3\2\2\2\u0107\u0108\5t;\2\u0108\u0109\7(\2\2\u0109\u010a"+
  3900.         "\5@!\2\u010a\61\3\2\2\2\u010b\u010c\5p9\2\u010c\u010d\7(\2\2\u010d\u010e"+
  3901.         "\5@!\2\u010e\63\3\2\2\2\u010f\u0110\5t;\2\u0110\u0111\7\4\2\2\u0111\65"+
  3902.         "\3\2\2\2\u0112\u0113\5t;\2\u0113\u0116\7\3\2\2\u0114\u0117\5t;\2\u0115"+
  3903.         "\u0117\5x=\2\u0116\u0114\3\2\2\2\u0116\u0115\3\2\2\2\u0117\67\3\2\2\2"+
  3904.         "\u0118\u0119\7\35\2\2\u0119\u011a\5 \21\2\u011a\u011b\7\36\2\2\u011b\u011e"+
  3905.         "\3\2\2\2\u011c\u011e\5\"\22\2\u011d\u0118\3\2\2\2\u011d\u011c\3\2\2\2"+
  3906.         "\u011e9\3\2\2\2\u011f\u0121\7\23\2\2\u0120\u011f\3\2\2\2\u0120\u0121\3"+
  3907.         "\2\2\2\u0121\u0122\3\2\2\2\u0122\u0123\5<\37\2\u0123\u0124\7\21\2\2\u0124"+
  3908.         "\u0126\5t;\2\u0125\u0127\5> \2\u0126\u0125\3\2\2\2\u0126\u0127\3\2\2\2"+
  3909.         "\u0127\u0128\3\2\2\2\u0128\u0129\7\24\2\2\u0129\u012a\58\35\2\u012a;\3"+
  3910.         "\2\2\2\u012b\u012e\7\31\2\2\u012c\u012f\5t;\2\u012d\u012f\5l\67\2\u012e"+
  3911.         "\u012c\3\2\2\2\u012e\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\7\32"+
  3912.         "\2\2\u0131=\3\2\2\2\u0132\u0133\7$\2\2\u0133\u0134\5t;\2\u0134?\3\2\2"+
  3913.         "\2\u0135\u013d\7\5\2\2\u0136\u013d\5x=\2\u0137\u013d\7\6\2\2\u0138\u013d"+
  3914.         "\5f\64\2\u0139\u013d\5h\65\2\u013a\u013d\5N(\2\u013b\u013d\5H%\2\u013c"+
  3915.         "\u0135\3\2\2\2\u013c\u0136\3\2\2\2\u013c\u0137\3\2\2\2\u013c\u0138\3\2"+
  3916.         "\2\2\u013c\u0139\3\2\2\2\u013c\u013a\3\2\2\2\u013c\u013b\3\2\2\2\u013d"+
  3917.         "A\3\2\2\2\u013e\u014b\7\5\2\2\u013f\u014b\5x=\2\u0140\u014b\7\6\2\2\u0141"+
  3918.         "\u014b\5l\67\2\u0142\u014b\5t;\2\u0143\u014b\5p9\2\u0144\u0145\7\33\2"+
  3919.         "\2\u0145\u0146\5n8\2\u0146\u0147\7\34\2\2\u0147\u014b\3\2\2\2\u0148\u014b"+
  3920.         "\5N(\2\u0149\u014b\5H%\2\u014a\u013e\3\2\2\2\u014a\u013f\3\2\2\2\u014a"+
  3921.         "\u0140\3\2\2\2\u014a\u0141\3\2\2\2\u014a\u0142\3\2\2\2\u014a\u0143\3\2"+
  3922.         "\2\2\u014a\u0144\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u0149\3\2\2\2\u014b"+
  3923.         "C\3\2\2\2\u014c\u014e\7\23\2\2\u014d\u014c\3\2\2\2\u014d\u014e\3\2\2\2"+
  3924.         "\u014e\u014f\3\2\2\2\u014f\u0157\7 \2\2\u0150\u0158\5l\67\2\u0151\u0152"+
  3925.         "\7\31\2\2\u0152\u0153\5l\67\2\u0153\u0154\7\n\2\2\u0154\u0155\5F$\2\u0155"+
  3926.         "\u0156\7\32\2\2\u0156\u0158\3\2\2\2\u0157\u0150\3\2\2\2\u0157\u0151\3"+
  3927.         "\2\2\2\u0158E\3\2\2\2\u0159\u015c\5t;\2\u015a\u015c\5N(\2\u015b\u0159"+
  3928.         "\3\2\2\2\u015b\u015a\3\2\2\2\u015cG\3\2\2\2\u015d\u015e\5N(\2\u015e\u015f"+
  3929.         "\5J&\2\u015f\u0160\5L\'\2\u0160I\3\2\2\2\u0161\u0162\7\16\2\2\u0162\u0163"+
  3930.         "\5@!\2\u0163K\3\2\2\2\u0164\u0165\7\24\2\2\u0165\u0166\5@!\2\u0166M\3"+
  3931.         "\2\2\2\u0167\u0171\5P)\2\u0168\u016d\5R*\2\u0169\u016a\7&\2\2\u016a\u016c"+
  3932.         "\5N(\2\u016b\u0169\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d"+
  3933.         "\u016e\3\2\2\2\u016e\u0171\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0167\3\2"+
  3934.         "\2\2\u0170\u0168\3\2\2\2\u0171O\3\2\2\2\u0172\u0173\7\31\2\2\u0173\u0174"+
  3935.         "\5N(\2\u0174\u0175\7\32\2\2\u0175Q\3\2\2\2\u0176\u017b\5T+\2\u0177\u0178"+
  3936.         "\7%\2\2\u0178\u017a\5N(\2\u0179\u0177\3\2\2\2\u017a\u017d\3\2\2\2\u017b"+
  3937.         "\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017cS\3\2\2\2\u017d\u017b\3\2\2\2"+
  3938.         "\u017e\u0182\5X-\2\u017f\u0182\5V,\2\u0180\u0182\5Z.\2\u0181\u017e\3\2"+
  3939.         "\2\2\u0181\u017f\3\2\2\2\u0181\u0180\3\2\2\2\u0182\u0187\3\2\2\2\u0183"+
  3940.         "\u0184\7\'\2\2\u0184\u0186\5N(\2\u0185\u0183\3\2\2\2\u0186\u0189\3\2\2"+
  3941.         "\2\u0187\u0185\3\2\2\2\u0187\u0188\3\2\2\2\u0188U\3\2\2\2\u0189\u0187"+
  3942.         "\3\2\2\2\u018a\u0190\7\6\2\2\u018b\u0190\5t;\2\u018c\u0190\5f\64\2\u018d"+
  3943.         "\u0190\5h\65\2\u018e\u0190\5D#\2\u018f\u018a\3\2\2\2\u018f\u018b\3\2\2"+
  3944.         "\2\u018f\u018c\3\2\2\2\u018f\u018d\3\2\2\2\u018f\u018e\3\2\2\2\u0190W"+
  3945.         "\3\2\2\2\u0191\u0192\7\t\2\2\u0192\u0193\5N(\2\u0193Y\3\2\2\2\u0194\u0197"+
  3946.         "\5\\/\2\u0195\u0196\t\5\2\2\u0196\u0198\5Z.\2\u0197\u0195\3\2\2\2\u0197"+
  3947.         "\u0198\3\2\2\2\u0198[\3\2\2\2\u0199\u019c\5^\60\2\u019a\u019b\t\6\2\2"+
  3948.         "\u019b\u019d\5Z.\2\u019c\u019a\3\2\2\2\u019c\u019d\3\2\2\2\u019d]\3\2"+
  3949.         "\2\2\u019e\u01a1\5`\61\2\u019f\u01a0\t\3\2\2\u01a0\u01a2\5Z.\2\u01a1\u019f"+
  3950.         "\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2_\3\2\2\2\u01a3\u01a6\5b\62\2\u01a4"+
  3951.         "\u01a5\t\7\2\2\u01a5\u01a7\5Z.\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2"+
  3952.         "\2\u01a7a\3\2\2\2\u01a8\u01ab\5d\63\2\u01a9\u01aa\7\60\2\2\u01aa\u01ac"+
  3953.         "\5Z.\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01acc\3\2\2\2\u01ad\u01b6"+
  3954.         "\5x=\2\u01ae\u01b6\5t;\2\u01af\u01b6\5f\64\2\u01b0\u01b6\5h\65\2\u01b1"+
  3955.         "\u01b2\7\31\2\2\u01b2\u01b3\5Z.\2\u01b3\u01b4\7\32\2\2\u01b4\u01b6\3\2"+
  3956.         "\2\2\u01b5\u01ad\3\2\2\2\u01b5\u01ae\3\2\2\2\u01b5\u01af\3\2\2\2\u01b5"+
  3957.         "\u01b0\3\2\2\2\u01b5\u01b1\3\2\2\2\u01b6e\3\2\2\2\u01b7\u01b8\5l\67\2"+
  3958.         "\u01b8g\3\2\2\2\u01b9\u01bc\7\17\2\2\u01ba\u01bd\5l\67\2\u01bb\u01bd\5"+
  3959.         "j\66\2\u01bc\u01ba\3\2\2\2\u01bc\u01bb\3\2\2\2\u01bdi\3\2\2\2\u01be\u01c3"+
  3960.         "\5t;\2\u01bf\u01c0\7\31\2\2\u01c0\u01c1\5n8\2\u01c1\u01c2\7\32\2\2\u01c2"+
  3961.         "\u01c4\3\2\2\2\u01c3\u01bf\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4k\3\2\2\2"+
  3962.         "\u01c5\u01c7\t\b\2\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8"+
  3963.         "\3\2\2\2\u01c8\u01ce\5r:\2\u01c9\u01cb\7\31\2\2\u01ca\u01cc\5n8\2\u01cb"+
  3964.         "\u01ca\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01cf\7\32"+
  3965.         "\2\2\u01ce\u01c9\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cfm\3\2\2\2\u01d0\u01d5"+
  3966.         "\5B\"\2\u01d1\u01d2\7\n\2\2\u01d2\u01d4\5B\"\2\u01d3\u01d1\3\2\2\2\u01d4"+
  3967.         "\u01d7\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6o\3\2\2\2"+
  3968.         "\u01d7\u01d5\3\2\2\2\u01d8\u01d9\7\33\2\2\u01d9\u01de\5t;\2\u01da\u01db"+
  3969.         "\7$\2\2\u01db\u01dd\5t;\2\u01dc\u01da\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de"+
  3970.         "\u01dc\3\2\2\2\u01de\u01df\3\2\2\2\u01df\u01e1\3\2\2\2\u01e0\u01de\3\2"+
  3971.         "\2\2\u01e1\u01e2\7\34\2\2\u01e2q\3\2\2\2\u01e3\u01e7\7\63\2\2\u01e4\u01e6"+
  3972.         "\t\t\2\2\u01e5\u01e4\3\2\2\2\u01e6\u01e9\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e7"+
  3973.         "\u01e8\3\2\2\2\u01e8s\3\2\2\2\u01e9\u01e7\3\2\2\2\u01ea\u01ec\7\23\2\2"+
  3974.         "\u01eb\u01ea\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee"+
  3975.         "\5v<\2\u01eeu\3\2\2\2\u01ef\u01f3\t\n\2\2\u01f0\u01f2\t\13\2\2\u01f1\u01f0"+
  3976.         "\3\2\2\2\u01f2\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4"+
  3977.         "w\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01f8\7\f\2\2\u01f7\u01f6\3\2\2\2"+
  3978.         "\u01f7\u01f8\3\2\2\2\u01f8\u01fb\3\2\2\2\u01f9\u01fc\7\7\2\2\u01fa\u01fc"+
  3979.         "\5z>\2\u01fb\u01f9\3\2\2\2\u01fb\u01fa\3\2\2\2\u01fcy\3\2\2\2\u01fd\u01ff"+
  3980.         "\7\65\2\2\u01fe\u01fd\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u01fe\3\2\2\2"+
  3981.         "\u0200\u0201\3\2\2\2\u0201\u0208\3\2\2\2\u0202\u0204\7\26\2\2\u0203\u0205"+
  3982.         "\7\65\2\2\u0204\u0203\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0204\3\2\2\2"+
  3983.         "\u0206\u0207\3\2\2\2\u0207\u0209\3\2\2\2\u0208\u0202\3\2\2\2\u0208\u0209"+
  3984.         "\3\2\2\2\u0209{\3\2\2\2<\177\u0083\u008d\u0092\u0095\u009c\u00a3\u00a9"+
  3985.         "\u00af\u00b8\u00ba\u00c8\u00ce\u00da\u00e4\u00e9\u00ed\u00f4\u00fb\u0101"+
  3986.         "\u0105\u0116\u011d\u0120\u0126\u012e\u013c\u014a\u014d\u0157\u015b\u016d"+
  3987.         "\u0170\u017b\u0181\u0187\u018f\u0197\u019c\u01a1\u01a6\u01ab\u01b5\u01bc"+
  3988.         "\u01c3\u01c6\u01cb\u01ce\u01d5\u01de\u01e7\u01eb\u01f3\u01f7\u01fb\u0200"+
  3989.         "\u0206\u0208";
  3990.     public static final ATN _ATN =
  3991.         new ATNDeserializer().deserialize(_serializedATN.toCharArray());
  3992.     static {
  3993.         _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
  3994.         for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
  3995.             _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
  3996.         }
  3997.     }
  3998. }