1// Generated from F7.g4 by ANTLR 4.7.2
   2package io.protobase.f7.antlr;
   3
   4import org.antlr.v4.runtime.FailedPredicateException;
   5import org.antlr.v4.runtime.NoViableAltException;
   6import org.antlr.v4.runtime.Parser;
   7import org.antlr.v4.runtime.ParserRuleContext;
   8import org.antlr.v4.runtime.RecognitionException;
   9import org.antlr.v4.runtime.RuleContext;
  10import org.antlr.v4.runtime.RuntimeMetaData;
  11import org.antlr.v4.runtime.Token;
  12import org.antlr.v4.runtime.TokenStream;
  13import org.antlr.v4.runtime.Vocabulary;
  14import org.antlr.v4.runtime.VocabularyImpl;
  15import org.antlr.v4.runtime.atn.ATN;
  16import org.antlr.v4.runtime.atn.ATNDeserializer;
  17import org.antlr.v4.runtime.atn.ParserATNSimulator;
  18import org.antlr.v4.runtime.atn.PredictionContextCache;
  19import org.antlr.v4.runtime.dfa.DFA;
  20import org.antlr.v4.runtime.tree.ParseTreeListener;
  21import org.antlr.v4.runtime.tree.ParseTreeVisitor;
  22import org.antlr.v4.runtime.tree.TerminalNode;
  23
  24import java.util.List;
  25
  26@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
  27public class F7Parser extends Parser {
  28  public static final int
  29      NCharacters = 1, Dot = 2, Int = 3, Number = 4, String = 5, Error = 6, LeftParen = 7,
  30      RightParen = 8, LeftBrace = 9, RightBrace = 10, Comma = 11, Colon = 12, SemiColon = 13,
  31      Bang = 14, Plus = 15, Minus = 16, Percent = 17, Power = 18, Divide = 19, Multiply = 20,
  32      GreaterThan = 21, GreaterThanOrEqualTo = 22, LessThan = 23, LessThanOrEqualTO = 24,
  33      Equal = 25, NotEqual = 26, Ampersand = 27, Dollar = 28, Underscore = 29, WS = 30;
  34  public static final int
  35      RULE_start = 0, RULE_block = 1, RULE_expression = 2, RULE_atom = 3, RULE_range = 4,
  36      RULE_arguments = 5, RULE_identifier = 6, RULE_comparisonOperator = 7;
  37  public static final String[] ruleNames = makeRuleNames();
  38  /**
  39   * @deprecated Use {@link #VOCABULARY} instead.
  40   */
  41  @Deprecated
  42  public static final String[] tokenNames;
  43  public static final String _serializedATN =
  44      "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3 \u00fb\4\2\t\2\4" +
  45          "\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\3\2\3\2\3\2\3\3" +
  46          "\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\6\4!\n\4\r\4\16\4\"\5\4%\n\4" +
  47          "\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3" +
  48          "\4\6\49\n\4\r\4\16\4:\7\4=\n\4\f\4\16\4@\13\4\3\5\3\5\3\5\3\5\3\5\3\5" +
  49          "\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\7\5T\n\5\f\5\16\5W\13" +
  50          "\5\5\5Y\n\5\3\5\3\5\5\5]\n\5\3\6\3\6\3\6\5\6b\n\6\3\6\5\6e\n\6\3\6\3\6" +
  51          "\5\6i\n\6\3\6\3\6\3\6\5\6n\n\6\3\6\3\6\5\6r\n\6\3\6\3\6\3\6\3\6\5\6x\n" +
  52          "\6\3\6\5\6{\n\6\3\6\3\6\5\6\177\n\6\3\6\3\6\3\6\3\6\5\6\u0085\n\6\3\6" +
  53          "\5\6\u0088\n\6\3\6\3\6\3\6\5\6\u008d\n\6\3\6\3\6\3\6\3\6\5\6\u0093\n\6" +
  54          "\3\6\5\6\u0096\n\6\3\6\3\6\5\6\u009a\n\6\3\6\3\6\3\6\5\6\u009f\n\6\3\6" +
  55          "\3\6\3\6\3\6\5\6\u00a5\n\6\3\6\5\6\u00a8\n\6\3\6\3\6\3\6\5\6\u00ad\n\6" +
  56          "\3\6\3\6\5\6\u00b1\n\6\3\6\3\6\3\6\3\6\5\6\u00b7\n\6\3\6\5\6\u00ba\n\6" +
  57          "\3\6\3\6\3\6\5\6\u00bf\n\6\3\6\3\6\3\6\3\6\5\6\u00c5\n\6\3\6\5\6\u00c8" +
  58          "\n\6\3\6\3\6\5\6\u00cc\n\6\3\6\3\6\3\6\5\6\u00d1\n\6\3\6\3\6\3\6\3\6\5" +
  59          "\6\u00d7\n\6\3\6\5\6\u00da\n\6\3\6\3\6\3\6\5\6\u00df\n\6\3\6\3\6\5\6\u00e3" +
  60          "\n\6\3\6\5\6\u00e6\n\6\3\7\3\7\3\7\7\7\u00eb\n\7\f\7\16\7\u00ee\13\7\5" +
  61          "\7\u00f0\n\7\3\b\3\b\7\b\u00f4\n\b\f\b\16\b\u00f7\13\b\3\t\3\t\3\t\2\3" +
  62          "\6\n\2\4\6\b\n\f\16\20\2\7\3\2\25\26\3\2\21\22\4\2\r\r\17\17\4\2\3\5\37" +
  63          "\37\3\2\27\34\2\u012f\2\22\3\2\2\2\4\25\3\2\2\2\6$\3\2\2\2\b\\\3\2\2\2" +
  64          "\n\u00e5\3\2\2\2\f\u00ef\3\2\2\2\16\u00f1\3\2\2\2\20\u00f8\3\2\2\2\22" +
  65          "\23\5\4\3\2\23\24\7\2\2\3\24\3\3\2\2\2\25\26\5\6\4\2\26\5\3\2\2\2\27\30" +
  66          "\b\4\1\2\30\31\7\22\2\2\31%\5\6\4\f\32\33\7\21\2\2\33%\5\6\4\13\34%\5" +
  67          "\b\5\2\35 \5\b\5\2\36\37\7\16\2\2\37!\5\b\5\2 \36\3\2\2\2!\"\3\2\2\2\"" +
  68          " \3\2\2\2\"#\3\2\2\2#%\3\2\2\2$\27\3\2\2\2$\32\3\2\2\2$\34\3\2\2\2$\35" +
  69          "\3\2\2\2%>\3\2\2\2&\'\f\t\2\2\'(\7\24\2\2(=\5\6\4\n)*\f\b\2\2*+\t\2\2" +
  70          "\2+=\5\6\4\t,-\f\7\2\2-.\t\3\2\2.=\5\6\4\b/\60\f\6\2\2\60\61\5\20\t\2" +
  71          "\61\62\5\6\4\7\62=\3\2\2\2\63\64\f\5\2\2\64\65\7\35\2\2\65=\5\6\4\6\66" +
  72          "8\f\n\2\2\679\7\23\2\28\67\3\2\2\29:\3\2\2\2:8\3\2\2\2:;\3\2\2\2;=\3\2" +
  73          "\2\2<&\3\2\2\2<)\3\2\2\2<,\3\2\2\2</\3\2\2\2<\63\3\2\2\2<\66\3\2\2\2=" +
  74          "@\3\2\2\2><\3\2\2\2>?\3\2\2\2?\7\3\2\2\2@>\3\2\2\2A]\5\n\6\2B]\7\7\2\2" +
  75          "C]\7\b\2\2D]\7\5\2\2E]\7\6\2\2FG\7\t\2\2GH\5\6\4\2HI\7\n\2\2I]\3\2\2\2" +
  76          "JK\5\16\b\2KL\7\t\2\2LM\5\f\7\2MN\7\n\2\2N]\3\2\2\2OX\7\13\2\2PU\5\6\4" +
  77          "\2QR\t\4\2\2RT\5\6\4\2SQ\3\2\2\2TW\3\2\2\2US\3\2\2\2UV\3\2\2\2VY\3\2\2" +
  78          "\2WU\3\2\2\2XP\3\2\2\2XY\3\2\2\2YZ\3\2\2\2Z]\7\f\2\2[]\5\16\b\2\\A\3\2" +
  79          "\2\2\\B\3\2\2\2\\C\3\2\2\2\\D\3\2\2\2\\E\3\2\2\2\\F\3\2\2\2\\J\3\2\2\2" +
  80          "\\O\3\2\2\2\\[\3\2\2\2]\t\3\2\2\2^_\5\16\b\2_`\7\20\2\2`b\3\2\2\2a^\3" +
  81          "\2\2\2ab\3\2\2\2bd\3\2\2\2ce\7\36\2\2dc\3\2\2\2de\3\2\2\2ef\3\2\2\2fh" +
  82          "\7\3\2\2gi\7\36\2\2hg\3\2\2\2hi\3\2\2\2ij\3\2\2\2jk\7\5\2\2km\7\16\2\2" +
  83          "ln\7\36\2\2ml\3\2\2\2mn\3\2\2\2no\3\2\2\2oq\7\3\2\2pr\7\36\2\2qp\3\2\2" +
  84          "\2qr\3\2\2\2rs\3\2\2\2s\u00e6\7\5\2\2tu\5\16\b\2uv\7\20\2\2vx\3\2\2\2" +
  85          "wt\3\2\2\2wx\3\2\2\2xz\3\2\2\2y{\7\36\2\2zy\3\2\2\2z{\3\2\2\2{|\3\2\2" +
  86          "\2|~\7\3\2\2}\177\7\36\2\2~}\3\2\2\2~\177\3\2\2\2\177\u0080\3\2\2\2\u0080" +
  87          "\u00e6\7\5\2\2\u0081\u0082\5\16\b\2\u0082\u0083\7\20\2\2\u0083\u0085\3" +
  88          "\2\2\2\u0084\u0081\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u0087\3\2\2\2\u0086" +
  89          "\u0088\7\36\2\2\u0087\u0086\3\2\2\2\u0087\u0088\3\2\2\2\u0088\u0089\3" +
  90          "\2\2\2\u0089\u008a\7\3\2\2\u008a\u008c\7\16\2\2\u008b\u008d\7\36\2\2\u008c" +
  91          "\u008b\3\2\2\2\u008c\u008d\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u00e6\7\3" +
  92          "\2\2\u008f\u0090\5\16\b\2\u0090\u0091\7\20\2\2\u0091\u0093\3\2\2\2\u0092" +
  93          "\u008f\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u0095\3\2\2\2\u0094\u0096\7\36" +
  94          "\2\2\u0095\u0094\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097" +
  95          "\u0099\7\3\2\2\u0098\u009a\7\36\2\2\u0099\u0098\3\2\2\2\u0099\u009a\3" +
  96          "\2\2\2\u009a\u009b\3\2\2\2\u009b\u009c\7\5\2\2\u009c\u009e\7\16\2\2\u009d" +
  97          "\u009f\7\36\2\2\u009e\u009d\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a0\3" +
  98          "\2\2\2\u00a0\u00e6\7\3\2\2\u00a1\u00a2\5\16\b\2\u00a2\u00a3\7\20\2\2\u00a3" +
  99          "\u00a5\3\2\2\2\u00a4\u00a1\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a7\3\2" +
 100          "\2\2\u00a6\u00a8\7\36\2\2\u00a7\u00a6\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8" +
 101          "\u00a9\3\2\2\2\u00a9\u00aa\7\3\2\2\u00aa\u00ac\7\16\2\2\u00ab\u00ad\7" +
 102          "\36\2\2\u00ac\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae" +
 103          "\u00b0\7\3\2\2\u00af\u00b1\7\36\2\2\u00b0\u00af\3\2\2\2\u00b0\u00b1\3" +
 104          "\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00e6\7\5\2\2\u00b3\u00b4\5\16\b\2\u00b4" +
 105          "\u00b5\7\20\2\2\u00b5\u00b7\3\2\2\2\u00b6\u00b3\3\2\2\2\u00b6\u00b7\3" +
 106          "\2\2\2\u00b7\u00b9\3\2\2\2\u00b8\u00ba\7\36\2\2\u00b9\u00b8\3\2\2\2\u00b9" +
 107          "\u00ba\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb\u00bc\7\5\2\2\u00bc\u00be\7\16" +
 108          "\2\2\u00bd\u00bf\7\36\2\2\u00be\u00bd\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf" +
 109          "\u00c0\3\2\2\2\u00c0\u00e6\7\5\2\2\u00c1\u00c2\5\16\b\2\u00c2\u00c3\7" +
 110          "\20\2\2\u00c3\u00c5\3\2\2\2\u00c4\u00c1\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5" +
 111          "\u00c7\3\2\2\2\u00c6\u00c8\7\36\2\2\u00c7\u00c6\3\2\2\2\u00c7\u00c8\3" +
 112          "\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00cb\7\3\2\2\u00ca\u00cc\7\36\2\2\u00cb" +
 113          "\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00ce\7\5" +
 114          "\2\2\u00ce\u00d0\7\16\2\2\u00cf\u00d1\7\36\2\2\u00d0\u00cf\3\2\2\2\u00d0" +
 115          "\u00d1\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00e6\7\5\2\2\u00d3\u00d4\5\16" +
 116          "\b\2\u00d4\u00d5\7\20\2\2\u00d5\u00d7\3\2\2\2\u00d6\u00d3\3\2\2\2\u00d6" +
 117          "\u00d7\3\2\2\2\u00d7\u00d9\3\2\2\2\u00d8\u00da\7\36\2\2\u00d9\u00d8\3" +
 118          "\2\2\2\u00d9\u00da\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\7\5\2\2\u00dc" +
 119          "\u00de\7\16\2\2\u00dd\u00df\7\36\2\2\u00de\u00dd\3\2\2\2\u00de\u00df\3" +
 120          "\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e2\7\3\2\2\u00e1\u00e3\7\36\2\2\u00e2" +
 121          "\u00e1\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00e6\7\5" +
 122          "\2\2\u00e5a\3\2\2\2\u00e5w\3\2\2\2\u00e5\u0084\3\2\2\2\u00e5\u0092\3\2" +
 123          "\2\2\u00e5\u00a4\3\2\2\2\u00e5\u00b6\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5" +
 124          "\u00d6\3\2\2\2\u00e6\13\3\2\2\2\u00e7\u00ec\5\6\4\2\u00e8\u00e9\7\r\2" +
 125          "\2\u00e9\u00eb\5\6\4\2\u00ea\u00e8\3\2\2\2\u00eb\u00ee\3\2\2\2\u00ec\u00ea" +
 126          "\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ef" +
 127          "\u00e7\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\r\3\2\2\2\u00f1\u00f5\7\3\2\2" +
 128          "\u00f2\u00f4\t\5\2\2\u00f3\u00f2\3\2\2\2\u00f4\u00f7\3\2\2\2\u00f5\u00f3" +
 129          "\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\17\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f8" +
 130          "\u00f9\t\6\2\2\u00f9\21\3\2\2\2,\"$:<>UX\\adhmqwz~\u0084\u0087\u008c\u0092" +
 131          "\u0095\u0099\u009e\u00a4\u00a7\u00ac\u00b0\u00b6\u00b9\u00be\u00c4\u00c7" +
 132          "\u00cb\u00d0\u00d6\u00d9\u00de\u00e2\u00e5\u00ec\u00ef\u00f5";
 133  public static final ATN _ATN =
 134      new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 135  protected static final DFA[] _decisionToDFA;
 136  protected static final PredictionContextCache _sharedContextCache =
 137      new PredictionContextCache();
 138  private static final String[] _LITERAL_NAMES = makeLiteralNames();
 139  private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
 140  public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
 141
 142  static {
 143    RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION);
 144  }
 145
 146  static {
 147    tokenNames = new String[_SYMBOLIC_NAMES.length];
 148    for (int i = 0; i < tokenNames.length; i++) {
 149      tokenNames[i] = VOCABULARY.getLiteralName(i);
 150      if (tokenNames[i] == null) {
 151        tokenNames[i] = VOCABULARY.getSymbolicName(i);
 152      }
 153
 154      if (tokenNames[i] == null) {
 155        tokenNames[i] = "<INVALID>";
 156      }
 157    }
 158  }
 159
 160  static {
 161    _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
 162    for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
 163      _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
 164    }
 165  }
 166
 167  public F7Parser(TokenStream input) {
 168    super(input);
 169    _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
 170  }
 171
 172  private static String[] makeRuleNames() {
 173    return new String[]{
 174        "start", "block", "expression", "atom", "range", "arguments", "identifier",
 175        "comparisonOperator"
 176    };
 177  }
 178
 179  private static String[] makeLiteralNames() {
 180    return new String[]{
 181        null, null, "'.'"
 182    };
 183  }
 184
 185  private static String[] makeSymbolicNames() {
 186    return new String[]{
 187        null, "NCharacters", "Dot", "Int", "Number", "String", "Error", "LeftParen",
 188        "RightParen", "LeftBrace", "RightBrace", "Comma", "Colon", "SemiColon",
 189        "Bang", "Plus", "Minus", "Percent", "Power", "Divide", "Multiply", "GreaterThan",
 190        "GreaterThanOrEqualTo", "LessThan", "LessThanOrEqualTO", "Equal", "NotEqual",
 191        "Ampersand", "Dollar", "Underscore", "WS"
 192    };
 193  }
 194
 195  @Override
 196  @Deprecated
 197  public String[] getTokenNames() {
 198    return tokenNames;
 199  }
 200
 201  @Override
 202
 203  public Vocabulary getVocabulary() {
 204    return VOCABULARY;
 205  }
 206
 207  @Override
 208  public String getGrammarFileName() {
 209    return "F7.g4";
 210  }
 211
 212  @Override
 213  public String[] getRuleNames() {
 214    return ruleNames;
 215  }
 216
 217  @Override
 218  public String getSerializedATN() {
 219    return _serializedATN;
 220  }
 221
 222  @Override
 223  public ATN getATN() {
 224    return _ATN;
 225  }
 226
 227  public final StartContext start() throws RecognitionException {
 228    StartContext _localctx = new StartContext(_ctx, getState());
 229    enterRule(_localctx, 0, RULE_start);
 230    try {
 231      enterOuterAlt(_localctx, 1);
 232      {
 233        setState(16);
 234        block();
 235        setState(17);
 236        match(EOF);
 237      }
 238    } catch (RecognitionException re) {
 239      _localctx.exception = re;
 240      _errHandler.reportError(this, re);
 241      _errHandler.recover(this, re);
 242    } finally {
 243      exitRule();
 244    }
 245    return _localctx;
 246  }
 247
 248  public final BlockContext block() throws RecognitionException {
 249    BlockContext _localctx = new BlockContext(_ctx, getState());
 250    enterRule(_localctx, 2, RULE_block);
 251    try {
 252      enterOuterAlt(_localctx, 1);
 253      {
 254        setState(19);
 255        expression(0);
 256      }
 257    } catch (RecognitionException re) {
 258      _localctx.exception = re;
 259      _errHandler.reportError(this, re);
 260      _errHandler.recover(this, re);
 261    } finally {
 262      exitRule();
 263    }
 264    return _localctx;
 265  }
 266
 267  public final ExpressionContext expression() throws RecognitionException {
 268    return expression(0);
 269  }
 270
 271  private ExpressionContext expression(int _p) throws RecognitionException {
 272    ParserRuleContext _parentctx = _ctx;
 273    int _parentState = getState();
 274    ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
 275    ExpressionContext _prevctx = _localctx;
 276    int _startState = 4;
 277    enterRecursionRule(_localctx, 4, RULE_expression, _p);
 278    int _la;
 279    try {
 280      int _alt;
 281      enterOuterAlt(_localctx, 1);
 282      {
 283        setState(34);
 284        _errHandler.sync(this);
 285        switch (getInterpreter().adaptivePredict(_input, 1, _ctx)) {
 286          case 1: {
 287            _localctx = new UnaryMinusExpressionContext(_localctx);
 288            _ctx = _localctx;
 289            _prevctx = _localctx;
 290
 291            setState(22);
 292            match(Minus);
 293            setState(23);
 294            expression(10);
 295          }
 296          break;
 297          case 2: {
 298            _localctx = new UnaryPlusExpressionContext(_localctx);
 299            _ctx = _localctx;
 300            _prevctx = _localctx;
 301            setState(24);
 302            match(Plus);
 303            setState(25);
 304            expression(9);
 305          }
 306          break;
 307          case 3: {
 308            _localctx = new AtomExpressionContext(_localctx);
 309            _ctx = _localctx;
 310            _prevctx = _localctx;
 311            setState(26);
 312            atom();
 313          }
 314          break;
 315          case 4: {
 316            _localctx = new RangeExpressionContext(_localctx);
 317            _ctx = _localctx;
 318            _prevctx = _localctx;
 319            setState(27);
 320            atom();
 321            setState(30);
 322            _errHandler.sync(this);
 323            _alt = 1;
 324            do {
 325              switch (_alt) {
 326                case 1: {
 327                  {
 328                    setState(28);
 329                    ((RangeExpressionContext) _localctx).separator = match(Colon);
 330                    setState(29);
 331                    atom();
 332                  }
 333                }
 334                break;
 335                default:
 336                  throw new NoViableAltException(this);
 337              }
 338              setState(32);
 339              _errHandler.sync(this);
 340              _alt = getInterpreter().adaptivePredict(_input, 0, _ctx);
 341            } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
 342          }
 343          break;
 344        }
 345        _ctx.stop = _input.LT(-1);
 346        setState(60);
 347        _errHandler.sync(this);
 348        _alt = getInterpreter().adaptivePredict(_input, 4, _ctx);
 349        while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
 350          if (_alt == 1) {
 351            if (_parseListeners != null) triggerExitRuleEvent();
 352            _prevctx = _localctx;
 353            {
 354              setState(58);
 355              _errHandler.sync(this);
 356              switch (getInterpreter().adaptivePredict(_input, 3, _ctx)) {
 357                case 1: {
 358                  _localctx = new PowerExpressionContext(new ExpressionContext(_parentctx, _parentState));
 359                  ((PowerExpressionContext) _localctx).left = _prevctx;
 360                  pushNewRecursionContext(_localctx, _startState, RULE_expression);
 361                  setState(36);
 362                  if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
 363                  setState(37);
 364                  ((PowerExpressionContext) _localctx).op = match(Power);
 365                  setState(38);
 366                  ((PowerExpressionContext) _localctx).right = expression(8);
 367                }
 368                break;
 369                case 2: {
 370                  _localctx = new MultiplicationExpressionContext(new ExpressionContext(_parentctx, _parentState));
 371                  ((MultiplicationExpressionContext) _localctx).left = _prevctx;
 372                  pushNewRecursionContext(_localctx, _startState, RULE_expression);
 373                  setState(39);
 374                  if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
 375                  setState(40);
 376                  ((MultiplicationExpressionContext) _localctx).op = _input.LT(1);
 377                  _la = _input.LA(1);
 378                  if (!(_la == Divide || _la == Multiply)) {
 379                    ((MultiplicationExpressionContext) _localctx).op = (Token) _errHandler.recoverInline(this);
 380                  } else {
 381                    if (_input.LA(1) == Token.EOF) matchedEOF = true;
 382                    _errHandler.reportMatch(this);
 383                    consume();
 384                  }
 385                  setState(41);
 386                  ((MultiplicationExpressionContext) _localctx).right = expression(7);
 387                }
 388                break;
 389                case 3: {
 390                  _localctx = new AdditiveExpressionContext(new ExpressionContext(_parentctx, _parentState));
 391                  ((AdditiveExpressionContext) _localctx).left = _prevctx;
 392                  pushNewRecursionContext(_localctx, _startState, RULE_expression);
 393                  setState(42);
 394                  if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
 395                  setState(43);
 396                  ((AdditiveExpressionContext) _localctx).op = _input.LT(1);
 397                  _la = _input.LA(1);
 398                  if (!(_la == Plus || _la == Minus)) {
 399                    ((AdditiveExpressionContext) _localctx).op = (Token) _errHandler.recoverInline(this);
 400                  } else {
 401                    if (_input.LA(1) == Token.EOF) matchedEOF = true;
 402                    _errHandler.reportMatch(this);
 403                    consume();
 404                  }
 405                  setState(44);
 406                  ((AdditiveExpressionContext) _localctx).right = expression(6);
 407                }
 408                break;
 409                case 4: {
 410                  _localctx = new RelationalExpressionContext(new ExpressionContext(_parentctx, _parentState));
 411                  ((RelationalExpressionContext) _localctx).left = _prevctx;
 412                  pushNewRecursionContext(_localctx, _startState, RULE_expression);
 413                  setState(45);
 414                  if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
 415                  setState(46);
 416                  ((RelationalExpressionContext) _localctx).op = comparisonOperator();
 417                  setState(47);
 418                  ((RelationalExpressionContext) _localctx).right = expression(5);
 419                }
 420                break;
 421                case 5: {
 422                  _localctx = new ConcatExpressionContext(new ExpressionContext(_parentctx, _parentState));
 423                  ((ConcatExpressionContext) _localctx).left = _prevctx;
 424                  pushNewRecursionContext(_localctx, _startState, RULE_expression);
 425                  setState(49);
 426                  if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
 427                  setState(50);
 428                  ((ConcatExpressionContext) _localctx).op = match(Ampersand);
 429                  setState(51);
 430                  ((ConcatExpressionContext) _localctx).right = expression(4);
 431                }
 432                break;
 433                case 6: {
 434                  _localctx = new UnaryPercentExpressionContext(new ExpressionContext(_parentctx, _parentState));
 435                  pushNewRecursionContext(_localctx, _startState, RULE_expression);
 436                  setState(52);
 437                  if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
 438                  setState(54);
 439                  _errHandler.sync(this);
 440                  _alt = 1;
 441                  do {
 442                    switch (_alt) {
 443                      case 1: {
 444                        {
 445                          setState(53);
 446                          match(Percent);
 447                        }
 448                      }
 449                      break;
 450                      default:
 451                        throw new NoViableAltException(this);
 452                    }
 453                    setState(56);
 454                    _errHandler.sync(this);
 455                    _alt = getInterpreter().adaptivePredict(_input, 2, _ctx);
 456                  } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
 457                }
 458                break;
 459              }
 460            }
 461          }
 462          setState(62);
 463          _errHandler.sync(this);
 464          _alt = getInterpreter().adaptivePredict(_input, 4, _ctx);
 465        }
 466      }
 467    } catch (RecognitionException re) {
 468      _localctx.exception = re;
 469      _errHandler.reportError(this, re);
 470      _errHandler.recover(this, re);
 471    } finally {
 472      unrollRecursionContexts(_parentctx);
 473    }
 474    return _localctx;
 475  }
 476
 477  public final AtomContext atom() throws RecognitionException {
 478    AtomContext _localctx = new AtomContext(_ctx, getState());
 479    enterRule(_localctx, 6, RULE_atom);
 480    int _la;
 481    try {
 482      setState(90);
 483      _errHandler.sync(this);
 484      switch (getInterpreter().adaptivePredict(_input, 7, _ctx)) {
 485        case 1:
 486          _localctx = new CellAtomContext(_localctx);
 487          enterOuterAlt(_localctx, 1);
 488        {
 489          setState(63);
 490          range();
 491        }
 492        break;
 493        case 2:
 494          _localctx = new StringAtomContext(_localctx);
 495          enterOuterAlt(_localctx, 2);
 496        {
 497          setState(64);
 498          match(String);
 499        }
 500        break;
 501        case 3:
 502          _localctx = new ErrorAtomContext(_localctx);
 503          enterOuterAlt(_localctx, 3);
 504        {
 505          setState(65);
 506          match(Error);
 507        }
 508        break;
 509        case 4:
 510          _localctx = new NumberAtomContext(_localctx);
 511          enterOuterAlt(_localctx, 4);
 512        {
 513          setState(66);
 514          match(Int);
 515        }
 516        break;
 517        case 5:
 518          _localctx = new NumberAtomContext(_localctx);
 519          enterOuterAlt(_localctx, 5);
 520        {
 521          setState(67);
 522          match(Number);
 523        }
 524        break;
 525        case 6:
 526          _localctx = new ParentheticalAtomContext(_localctx);
 527          enterOuterAlt(_localctx, 6);
 528        {
 529          setState(68);
 530          match(LeftParen);
 531          setState(69);
 532          expression(0);
 533          setState(70);
 534          match(RightParen);
 535        }
 536        break;
 537        case 7:
 538          _localctx = new FormulaAtomContext(_localctx);
 539          enterOuterAlt(_localctx, 7);
 540        {
 541          setState(72);
 542          ((FormulaAtomContext) _localctx).name = identifier();
 543          setState(73);
 544          match(LeftParen);
 545          setState(74);
 546          arguments();
 547          setState(75);
 548          match(RightParen);
 549        }
 550        break;
 551        case 8:
 552          _localctx = new ListAtomContext(_localctx);
 553          enterOuterAlt(_localctx, 8);
 554        {
 555          setState(77);
 556          match(LeftBrace);
 557          setState(86);
 558          _errHandler.sync(this);
 559          _la = _input.LA(1);
 560          if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NCharacters) | (1L << Int) | (1L << Number) | (1L << String) | (1L << Error) | (1L << LeftParen) | (1L << LeftBrace) | (1L << Plus) | (1L << Minus) | (1L << Dollar))) != 0)) {
 561            {
 562              setState(78);
 563              expression(0);
 564              setState(83);
 565              _errHandler.sync(this);
 566              _la = _input.LA(1);
 567              while (_la == Comma || _la == SemiColon) {
 568                {
 569                  {
 570                    setState(79);
 571                    ((ListAtomContext) _localctx).separator = _input.LT(1);
 572                    _la = _input.LA(1);
 573                    if (!(_la == Comma || _la == SemiColon)) {
 574                      ((ListAtomContext) _localctx).separator = (Token) _errHandler.recoverInline(this);
 575                    } else {
 576                      if (_input.LA(1) == Token.EOF) matchedEOF = true;
 577                      _errHandler.reportMatch(this);
 578                      consume();
 579                    }
 580                    setState(80);
 581                    expression(0);
 582                  }
 583                }
 584                setState(85);
 585                _errHandler.sync(this);
 586                _la = _input.LA(1);
 587              }
 588            }
 589          }
 590
 591          setState(88);
 592          match(RightBrace);
 593        }
 594        break;
 595        case 9:
 596          _localctx = new NamedAtomContext(_localctx);
 597          enterOuterAlt(_localctx, 9);
 598        {
 599          setState(89);
 600          identifier();
 601        }
 602        break;
 603      }
 604    } catch (RecognitionException re) {
 605      _localctx.exception = re;
 606      _errHandler.reportError(this, re);
 607      _errHandler.recover(this, re);
 608    } finally {
 609      exitRule();
 610    }
 611    return _localctx;
 612  }
 613
 614  public final RangeContext range() throws RecognitionException {
 615    RangeContext _localctx = new RangeContext(_ctx, getState());
 616    enterRule(_localctx, 8, RULE_range);
 617    int _la;
 618    try {
 619      setState(227);
 620      _errHandler.sync(this);
 621      switch (getInterpreter().adaptivePredict(_input, 38, _ctx)) {
 622        case 1:
 623          _localctx = new BiRangeContext(_localctx);
 624          enterOuterAlt(_localctx, 1);
 625        {
 626          setState(95);
 627          _errHandler.sync(this);
 628          switch (getInterpreter().adaptivePredict(_input, 8, _ctx)) {
 629            case 1: {
 630              setState(92);
 631              ((BiRangeContext) _localctx).grid = identifier();
 632              setState(93);
 633              match(Bang);
 634            }
 635            break;
 636          }
 637          setState(98);
 638          _errHandler.sync(this);
 639          _la = _input.LA(1);
 640          if (_la == Dollar) {
 641            {
 642              setState(97);
 643              ((BiRangeContext) _localctx).absoFirstColumn = match(Dollar);
 644            }
 645          }
 646
 647          setState(100);
 648          ((BiRangeContext) _localctx).firstColumn = match(NCharacters);
 649          setState(102);
 650          _errHandler.sync(this);
 651          _la = _input.LA(1);
 652          if (_la == Dollar) {
 653            {
 654              setState(101);
 655              ((BiRangeContext) _localctx).absoRow = match(Dollar);
 656            }
 657          }
 658
 659          setState(104);
 660          ((BiRangeContext) _localctx).firstRow = match(Int);
 661          setState(105);
 662          match(Colon);
 663          setState(107);
 664          _errHandler.sync(this);
 665          _la = _input.LA(1);
 666          if (_la == Dollar) {
 667            {
 668              setState(106);
 669              ((BiRangeContext) _localctx).absoLastColumn = match(Dollar);
 670            }
 671          }
 672
 673          setState(109);
 674          ((BiRangeContext) _localctx).lastColumn = match(NCharacters);
 675          setState(111);
 676          _errHandler.sync(this);
 677          _la = _input.LA(1);
 678          if (_la == Dollar) {
 679            {
 680              setState(110);
 681              ((BiRangeContext) _localctx).absoLastRow = match(Dollar);
 682            }
 683          }
 684
 685          setState(113);
 686          ((BiRangeContext) _localctx).lastRow = match(Int);
 687        }
 688        break;
 689        case 2:
 690          _localctx = new UniRangeContext(_localctx);
 691          enterOuterAlt(_localctx, 2);
 692        {
 693          setState(117);
 694          _errHandler.sync(this);
 695          switch (getInterpreter().adaptivePredict(_input, 13, _ctx)) {
 696            case 1: {
 697              setState(114);
 698              ((UniRangeContext) _localctx).grid = identifier();
 699              setState(115);
 700              match(Bang);
 701            }
 702            break;
 703          }
 704          setState(120);
 705          _errHandler.sync(this);
 706          _la = _input.LA(1);
 707          if (_la == Dollar) {
 708            {
 709              setState(119);
 710              ((UniRangeContext) _localctx).absoFirstColumn = match(Dollar);
 711            }
 712          }
 713
 714          setState(122);
 715          ((UniRangeContext) _localctx).firstColumn = match(NCharacters);
 716          setState(124);
 717          _errHandler.sync(this);
 718          _la = _input.LA(1);
 719          if (_la == Dollar) {
 720            {
 721              setState(123);
 722              ((UniRangeContext) _localctx).absoFirstRow = match(Dollar);
 723            }
 724          }
 725
 726          setState(126);
 727          ((UniRangeContext) _localctx).firstRow = match(Int);
 728        }
 729        break;
 730        case 3:
 731          _localctx = new ColumnWiseBiRangeContext(_localctx);
 732          enterOuterAlt(_localctx, 3);
 733        {
 734          setState(130);
 735          _errHandler.sync(this);
 736          switch (getInterpreter().adaptivePredict(_input, 16, _ctx)) {
 737            case 1: {
 738              setState(127);
 739              ((ColumnWiseBiRangeContext) _localctx).grid = identifier();
 740              setState(128);
 741              match(Bang);
 742            }
 743            break;
 744          }
 745          setState(133);
 746          _errHandler.sync(this);
 747          _la = _input.LA(1);
 748          if (_la == Dollar) {
 749            {
 750              setState(132);
 751              ((ColumnWiseBiRangeContext) _localctx).absoFirstColumn = match(Dollar);
 752            }
 753          }
 754
 755          setState(135);
 756          ((ColumnWiseBiRangeContext) _localctx).firstColumn = match(NCharacters);
 757          setState(136);
 758          match(Colon);
 759          setState(138);
 760          _errHandler.sync(this);
 761          _la = _input.LA(1);
 762          if (_la == Dollar) {
 763            {
 764              setState(137);
 765              ((ColumnWiseBiRangeContext) _localctx).absoLastColumn = match(Dollar);
 766            }
 767          }
 768
 769          setState(140);
 770          ((ColumnWiseBiRangeContext) _localctx).lastColumn = match(NCharacters);
 771        }
 772        break;
 773        case 4:
 774          _localctx = new ColumnWiseWithRowOffsetFirstBiRangeContext(_localctx);
 775          enterOuterAlt(_localctx, 4);
 776        {
 777          setState(144);
 778          _errHandler.sync(this);
 779          switch (getInterpreter().adaptivePredict(_input, 19, _ctx)) {
 780            case 1: {
 781              setState(141);
 782              ((ColumnWiseWithRowOffsetFirstBiRangeContext) _localctx).grid = identifier();
 783              setState(142);
 784              match(Bang);
 785            }
 786            break;
 787          }
 788          setState(147);
 789          _errHandler.sync(this);
 790          _la = _input.LA(1);
 791          if (_la == Dollar) {
 792            {
 793              setState(146);
 794              ((ColumnWiseWithRowOffsetFirstBiRangeContext) _localctx).absoFirstColumn = match(Dollar);
 795            }
 796          }
 797
 798          setState(149);
 799          ((ColumnWiseWithRowOffsetFirstBiRangeContext) _localctx).firstColumn = match(NCharacters);
 800          setState(151);
 801          _errHandler.sync(this);
 802          _la = _input.LA(1);
 803          if (_la == Dollar) {
 804            {
 805              setState(150);
 806              ((ColumnWiseWithRowOffsetFirstBiRangeContext) _localctx).absoFirstRow = match(Dollar);
 807            }
 808          }
 809
 810          setState(153);
 811          ((ColumnWiseWithRowOffsetFirstBiRangeContext) _localctx).firstRow = match(Int);
 812          setState(154);
 813          match(Colon);
 814          setState(156);
 815          _errHandler.sync(this);
 816          _la = _input.LA(1);
 817          if (_la == Dollar) {
 818            {
 819              setState(155);
 820              ((ColumnWiseWithRowOffsetFirstBiRangeContext) _localctx).absoLastColumn = match(Dollar);
 821            }
 822          }
 823
 824          setState(158);
 825          ((ColumnWiseWithRowOffsetFirstBiRangeContext) _localctx).lastColumn = match(NCharacters);
 826        }
 827        break;
 828        case 5:
 829          _localctx = new ColumnWiseWithRowOffsetLastBiRangeContext(_localctx);
 830          enterOuterAlt(_localctx, 5);
 831        {
 832          setState(162);
 833          _errHandler.sync(this);
 834          switch (getInterpreter().adaptivePredict(_input, 23, _ctx)) {
 835            case 1: {
 836              setState(159);
 837              ((ColumnWiseWithRowOffsetLastBiRangeContext) _localctx).grid = identifier();
 838              setState(160);
 839              match(Bang);
 840            }
 841            break;
 842          }
 843          setState(165);
 844          _errHandler.sync(this);
 845          _la = _input.LA(1);
 846          if (_la == Dollar) {
 847            {
 848              setState(164);
 849              ((ColumnWiseWithRowOffsetLastBiRangeContext) _localctx).absoFirstColumn = match(Dollar);
 850            }
 851          }
 852
 853          setState(167);
 854          ((ColumnWiseWithRowOffsetLastBiRangeContext) _localctx).firstColumn = match(NCharacters);
 855          setState(168);
 856          match(Colon);
 857          setState(170);
 858          _errHandler.sync(this);
 859          _la = _input.LA(1);
 860          if (_la == Dollar) {
 861            {
 862              setState(169);
 863              ((ColumnWiseWithRowOffsetLastBiRangeContext) _localctx).absoLastColumn = match(Dollar);
 864            }
 865          }
 866
 867          setState(172);
 868          ((ColumnWiseWithRowOffsetLastBiRangeContext) _localctx).lastColumn = match(NCharacters);
 869          setState(174);
 870          _errHandler.sync(this);
 871          _la = _input.LA(1);
 872          if (_la == Dollar) {
 873            {
 874              setState(173);
 875              ((ColumnWiseWithRowOffsetLastBiRangeContext) _localctx).absoLastRow = match(Dollar);
 876            }
 877          }
 878
 879          setState(176);
 880          ((ColumnWiseWithRowOffsetLastBiRangeContext) _localctx).lastRow = match(Int);
 881        }
 882        break;
 883        case 6:
 884          _localctx = new RowWiseBiRangeContext(_localctx);
 885          enterOuterAlt(_localctx, 6);
 886        {
 887          setState(180);
 888          _errHandler.sync(this);
 889          _la = _input.LA(1);
 890          if (_la == NCharacters) {
 891            {
 892              setState(177);
 893              ((RowWiseBiRangeContext) _localctx).grid = identifier();
 894              setState(178);
 895              match(Bang);
 896            }
 897          }
 898
 899          setState(183);
 900          _errHandler.sync(this);
 901          _la = _input.LA(1);
 902          if (_la == Dollar) {
 903            {
 904              setState(182);
 905              ((RowWiseBiRangeContext) _localctx).absoFirstRow = match(Dollar);
 906            }
 907          }
 908
 909          setState(185);
 910          ((RowWiseBiRangeContext) _localctx).firstRow = match(Int);
 911          setState(186);
 912          match(Colon);
 913          setState(188);
 914          _errHandler.sync(this);
 915          _la = _input.LA(1);
 916          if (_la == Dollar) {
 917            {
 918              setState(187);
 919              ((RowWiseBiRangeContext) _localctx).absoLastRow = match(Dollar);
 920            }
 921          }
 922
 923          setState(190);
 924          ((RowWiseBiRangeContext) _localctx).lastRow = match(Int);
 925        }
 926        break;
 927        case 7:
 928          _localctx = new RowWiseWithColumnOffsetFirstBiRangeContext(_localctx);
 929          enterOuterAlt(_localctx, 7);
 930        {
 931          setState(194);
 932          _errHandler.sync(this);
 933          switch (getInterpreter().adaptivePredict(_input, 30, _ctx)) {
 934            case 1: {
 935              setState(191);
 936              ((RowWiseWithColumnOffsetFirstBiRangeContext) _localctx).grid = identifier();
 937              setState(192);
 938              match(Bang);
 939            }
 940            break;
 941          }
 942          setState(197);
 943          _errHandler.sync(this);
 944          _la = _input.LA(1);
 945          if (_la == Dollar) {
 946            {
 947              setState(196);
 948              ((RowWiseWithColumnOffsetFirstBiRangeContext) _localctx).absoFirstColumn = match(Dollar);
 949            }
 950          }
 951
 952          setState(199);
 953          ((RowWiseWithColumnOffsetFirstBiRangeContext) _localctx).firstColumn = match(NCharacters);
 954          setState(201);
 955          _errHandler.sync(this);
 956          _la = _input.LA(1);
 957          if (_la == Dollar) {
 958            {
 959              setState(200);
 960              ((RowWiseWithColumnOffsetFirstBiRangeContext) _localctx).absoFirstRow = match(Dollar);
 961            }
 962          }
 963
 964          setState(203);
 965          ((RowWiseWithColumnOffsetFirstBiRangeContext) _localctx).firstRow = match(Int);
 966          setState(204);
 967          match(Colon);
 968          setState(206);
 969          _errHandler.sync(this);
 970          _la = _input.LA(1);
 971          if (_la == Dollar) {
 972            {
 973              setState(205);
 974              ((RowWiseWithColumnOffsetFirstBiRangeContext) _localctx).absoLastRow = match(Dollar);
 975            }
 976          }
 977
 978          setState(208);
 979          ((RowWiseWithColumnOffsetFirstBiRangeContext) _localctx).lastRow = match(Int);
 980        }
 981        break;
 982        case 8:
 983          _localctx = new RowWiseWithColumnOffsetLastBiRangeContext(_localctx);
 984          enterOuterAlt(_localctx, 8);
 985        {
 986          setState(212);
 987          _errHandler.sync(this);
 988          _la = _input.LA(1);
 989          if (_la == NCharacters) {
 990            {
 991              setState(209);
 992              ((RowWiseWithColumnOffsetLastBiRangeContext) _localctx).grid = identifier();
 993              setState(210);
 994              match(Bang);
 995            }
 996          }
 997
 998          setState(215);
 999          _errHandler.sync(this);
1000          _la = _input.LA(1);
1001          if (_la == Dollar) {
1002            {
1003              setState(214);
1004              ((RowWiseWithColumnOffsetLastBiRangeContext) _localctx).absoFirstRow = match(Dollar);
1005            }
1006          }
1007
1008          setState(217);
1009          ((RowWiseWithColumnOffsetLastBiRangeContext) _localctx).firstRow = match(Int);
1010          setState(218);
1011          match(Colon);
1012          setState(220);
1013          _errHandler.sync(this);
1014          _la = _input.LA(1);
1015          if (_la == Dollar) {
1016            {
1017              setState(219);
1018              ((RowWiseWithColumnOffsetLastBiRangeContext) _localctx).absLastColumn = match(Dollar);
1019            }
1020          }
1021
1022          setState(222);
1023          ((RowWiseWithColumnOffsetLastBiRangeContext) _localctx).lastColumn = match(NCharacters);
1024          setState(224);
1025          _errHandler.sync(this);
1026          _la = _input.LA(1);
1027          if (_la == Dollar) {
1028            {
1029              setState(223);
1030              ((RowWiseWithColumnOffsetLastBiRangeContext) _localctx).absoLastRow = match(Dollar);
1031            }
1032          }
1033
1034          setState(226);
1035          ((RowWiseWithColumnOffsetLastBiRangeContext) _localctx).lastRow = match(Int);
1036        }
1037        break;
1038      }
1039    } catch (RecognitionException re) {
1040      _localctx.exception = re;
1041      _errHandler.reportError(this, re);
1042      _errHandler.recover(this, re);
1043    } finally {
1044      exitRule();
1045    }
1046    return _localctx;
1047  }
1048
1049  public final ArgumentsContext arguments() throws RecognitionException {
1050    ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
1051    enterRule(_localctx, 10, RULE_arguments);
1052    int _la;
1053    try {
1054      enterOuterAlt(_localctx, 1);
1055      {
1056        setState(237);
1057        _errHandler.sync(this);
1058        _la = _input.LA(1);
1059        if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NCharacters) | (1L << Int) | (1L << Number) | (1L << String) | (1L << Error) | (1L << LeftParen) | (1L << LeftBrace) | (1L << Plus) | (1L << Minus) | (1L << Dollar))) != 0)) {
1060          {
1061            setState(229);
1062            expression(0);
1063            setState(234);
1064            _errHandler.sync(this);
1065            _la = _input.LA(1);
1066            while (_la == Comma) {
1067              {
1068                {
1069                  setState(230);
1070                  match(Comma);
1071                  setState(231);
1072                  expression(0);
1073                }
1074              }
1075              setState(236);
1076              _errHandler.sync(this);
1077              _la = _input.LA(1);
1078            }
1079          }
1080        }
1081
1082      }
1083    } catch (RecognitionException re) {
1084      _localctx.exception = re;
1085      _errHandler.reportError(this, re);
1086      _errHandler.recover(this, re);
1087    } finally {
1088      exitRule();
1089    }
1090    return _localctx;
1091  }
1092
1093  public final IdentifierContext identifier() throws RecognitionException {
1094    IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
1095    enterRule(_localctx, 12, RULE_identifier);
1096    int _la;
1097    try {
1098      int _alt;
1099      enterOuterAlt(_localctx, 1);
1100      {
1101        setState(239);
1102        match(NCharacters);
1103        setState(243);
1104        _errHandler.sync(this);
1105        _alt = getInterpreter().adaptivePredict(_input, 41, _ctx);
1106        while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
1107          if (_alt == 1) {
1108            {
1109              {
1110                setState(240);
1111                _la = _input.LA(1);
1112                if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NCharacters) | (1L << Dot) | (1L << Int) | (1L << Underscore))) != 0))) {
1113                  _errHandler.recoverInline(this);
1114                } else {
1115                  if (_input.LA(1) == Token.EOF) matchedEOF = true;
1116                  _errHandler.reportMatch(this);
1117                  consume();
1118                }
1119              }
1120            }
1121          }
1122          setState(245);
1123          _errHandler.sync(this);
1124          _alt = getInterpreter().adaptivePredict(_input, 41, _ctx);
1125        }
1126      }
1127    } catch (RecognitionException re) {
1128      _localctx.exception = re;
1129      _errHandler.reportError(this, re);
1130      _errHandler.recover(this, re);
1131    } finally {
1132      exitRule();
1133    }
1134    return _localctx;
1135  }
1136
1137  public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
1138    ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
1139    enterRule(_localctx, 14, RULE_comparisonOperator);
1140    int _la;
1141    try {
1142      enterOuterAlt(_localctx, 1);
1143      {
1144        setState(246);
1145        _la = _input.LA(1);
1146        if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GreaterThan) | (1L << GreaterThanOrEqualTo) | (1L << LessThan) | (1L << LessThanOrEqualTO) | (1L << Equal) | (1L << NotEqual))) != 0))) {
1147          _errHandler.recoverInline(this);
1148        } else {
1149          if (_input.LA(1) == Token.EOF) matchedEOF = true;
1150          _errHandler.reportMatch(this);
1151          consume();
1152        }
1153      }
1154    } catch (RecognitionException re) {
1155      _localctx.exception = re;
1156      _errHandler.reportError(this, re);
1157      _errHandler.recover(this, re);
1158    } finally {
1159      exitRule();
1160    }
1161    return _localctx;
1162  }
1163
1164  public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
1165    switch (ruleIndex) {
1166      case 2:
1167        return expression_sempred((ExpressionContext) _localctx, predIndex);
1168    }
1169    return true;
1170  }
1171
1172  private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
1173    switch (predIndex) {
1174      case 0:
1175        return precpred(_ctx, 7);
1176      case 1:
1177        return precpred(_ctx, 6);
1178      case 2:
1179        return precpred(_ctx, 5);
1180      case 3:
1181        return precpred(_ctx, 4);
1182      case 4:
1183        return precpred(_ctx, 3);
1184      case 5:
1185        return precpred(_ctx, 8);
1186    }
1187    return true;
1188  }
1189
1190  public static class StartContext extends ParserRuleContext {
1191    public StartContext(ParserRuleContext parent, int invokingState) {
1192      super(parent, invokingState);
1193    }
1194
1195    public BlockContext block() {
1196      return getRuleContext(BlockContext.class, 0);
1197    }
1198
1199    public TerminalNode EOF() {
1200      return getToken(F7Parser.EOF, 0);
1201    }
1202
1203    @Override public int getRuleIndex() {
1204      return RULE_start;
1205    }
1206
1207    @Override
1208    public void enterRule(ParseTreeListener listener) {
1209      if (listener instanceof F7Listener) ((F7Listener) listener).enterStart(this);
1210    }
1211
1212    @Override
1213    public void exitRule(ParseTreeListener listener) {
1214      if (listener instanceof F7Listener) ((F7Listener) listener).exitStart(this);
1215    }
1216
1217    @Override
1218    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1219      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitStart(this);
1220      else return visitor.visitChildren(this);
1221    }
1222  }
1223
1224  public static class BlockContext extends ParserRuleContext {
1225    public BlockContext(ParserRuleContext parent, int invokingState) {
1226      super(parent, invokingState);
1227    }
1228
1229    public ExpressionContext expression() {
1230      return getRuleContext(ExpressionContext.class, 0);
1231    }
1232
1233    @Override public int getRuleIndex() {
1234      return RULE_block;
1235    }
1236
1237    @Override
1238    public void enterRule(ParseTreeListener listener) {
1239      if (listener instanceof F7Listener) ((F7Listener) listener).enterBlock(this);
1240    }
1241
1242    @Override
1243    public void exitRule(ParseTreeListener listener) {
1244      if (listener instanceof F7Listener) ((F7Listener) listener).exitBlock(this);
1245    }
1246
1247    @Override
1248    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1249      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitBlock(this);
1250      else return visitor.visitChildren(this);
1251    }
1252  }
1253
1254  public static class ExpressionContext extends ParserRuleContext {
1255    public ExpressionContext(ParserRuleContext parent, int invokingState) {
1256      super(parent, invokingState);
1257    }
1258
1259    public ExpressionContext() {
1260    }
1261
1262    @Override public int getRuleIndex() {
1263      return RULE_expression;
1264    }
1265
1266    public void copyFrom(ExpressionContext ctx) {
1267      super.copyFrom(ctx);
1268    }
1269  }
1270
1271  public static class UnaryPercentExpressionContext extends ExpressionContext {
1272    public UnaryPercentExpressionContext(ExpressionContext ctx) {
1273      copyFrom(ctx);
1274    }
1275
1276    public ExpressionContext expression() {
1277      return getRuleContext(ExpressionContext.class, 0);
1278    }
1279
1280    public List<TerminalNode> Percent() {
1281      return getTokens(F7Parser.Percent);
1282    }
1283
1284    public TerminalNode Percent(int i) {
1285      return getToken(F7Parser.Percent, i);
1286    }
1287
1288    @Override
1289    public void enterRule(ParseTreeListener listener) {
1290      if (listener instanceof F7Listener) ((F7Listener) listener).enterUnaryPercentExpression(this);
1291    }
1292
1293    @Override
1294    public void exitRule(ParseTreeListener listener) {
1295      if (listener instanceof F7Listener) ((F7Listener) listener).exitUnaryPercentExpression(this);
1296    }
1297
1298    @Override
1299    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1300      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitUnaryPercentExpression(this);
1301      else return visitor.visitChildren(this);
1302    }
1303  }
1304
1305  public static class UnaryMinusExpressionContext extends ExpressionContext {
1306    public UnaryMinusExpressionContext(ExpressionContext ctx) {
1307      copyFrom(ctx);
1308    }
1309
1310    public TerminalNode Minus() {
1311      return getToken(F7Parser.Minus, 0);
1312    }
1313
1314    public ExpressionContext expression() {
1315      return getRuleContext(ExpressionContext.class, 0);
1316    }
1317
1318    @Override
1319    public void enterRule(ParseTreeListener listener) {
1320      if (listener instanceof F7Listener) ((F7Listener) listener).enterUnaryMinusExpression(this);
1321    }
1322
1323    @Override
1324    public void exitRule(ParseTreeListener listener) {
1325      if (listener instanceof F7Listener) ((F7Listener) listener).exitUnaryMinusExpression(this);
1326    }
1327
1328    @Override
1329    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1330      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitUnaryMinusExpression(this);
1331      else return visitor.visitChildren(this);
1332    }
1333  }
1334
1335  public static class PowerExpressionContext extends ExpressionContext {
1336    public ExpressionContext left;
1337    public Token op;
1338    public ExpressionContext right;
1339
1340    public PowerExpressionContext(ExpressionContext ctx) {
1341      copyFrom(ctx);
1342    }
1343
1344    public List<ExpressionContext> expression() {
1345      return getRuleContexts(ExpressionContext.class);
1346    }
1347
1348    public ExpressionContext expression(int i) {
1349      return getRuleContext(ExpressionContext.class, i);
1350    }
1351
1352    public TerminalNode Power() {
1353      return getToken(F7Parser.Power, 0);
1354    }
1355
1356    @Override
1357    public void enterRule(ParseTreeListener listener) {
1358      if (listener instanceof F7Listener) ((F7Listener) listener).enterPowerExpression(this);
1359    }
1360
1361    @Override
1362    public void exitRule(ParseTreeListener listener) {
1363      if (listener instanceof F7Listener) ((F7Listener) listener).exitPowerExpression(this);
1364    }
1365
1366    @Override
1367    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1368      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitPowerExpression(this);
1369      else return visitor.visitChildren(this);
1370    }
1371  }
1372
1373  public static class UnaryPlusExpressionContext extends ExpressionContext {
1374    public UnaryPlusExpressionContext(ExpressionContext ctx) {
1375      copyFrom(ctx);
1376    }
1377
1378    public TerminalNode Plus() {
1379      return getToken(F7Parser.Plus, 0);
1380    }
1381
1382    public ExpressionContext expression() {
1383      return getRuleContext(ExpressionContext.class, 0);
1384    }
1385
1386    @Override
1387    public void enterRule(ParseTreeListener listener) {
1388      if (listener instanceof F7Listener) ((F7Listener) listener).enterUnaryPlusExpression(this);
1389    }
1390
1391    @Override
1392    public void exitRule(ParseTreeListener listener) {
1393      if (listener instanceof F7Listener) ((F7Listener) listener).exitUnaryPlusExpression(this);
1394    }
1395
1396    @Override
1397    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1398      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitUnaryPlusExpression(this);
1399      else return visitor.visitChildren(this);
1400    }
1401  }
1402
1403  public static class AtomExpressionContext extends ExpressionContext {
1404    public AtomExpressionContext(ExpressionContext ctx) {
1405      copyFrom(ctx);
1406    }
1407
1408    public AtomContext atom() {
1409      return getRuleContext(AtomContext.class, 0);
1410    }
1411
1412    @Override
1413    public void enterRule(ParseTreeListener listener) {
1414      if (listener instanceof F7Listener) ((F7Listener) listener).enterAtomExpression(this);
1415    }
1416
1417    @Override
1418    public void exitRule(ParseTreeListener listener) {
1419      if (listener instanceof F7Listener) ((F7Listener) listener).exitAtomExpression(this);
1420    }
1421
1422    @Override
1423    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1424      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitAtomExpression(this);
1425      else return visitor.visitChildren(this);
1426    }
1427  }
1428
1429  public static class AdditiveExpressionContext extends ExpressionContext {
1430    public ExpressionContext left;
1431    public Token op;
1432    public ExpressionContext right;
1433
1434    public AdditiveExpressionContext(ExpressionContext ctx) {
1435      copyFrom(ctx);
1436    }
1437
1438    public List<ExpressionContext> expression() {
1439      return getRuleContexts(ExpressionContext.class);
1440    }
1441
1442    public ExpressionContext expression(int i) {
1443      return getRuleContext(ExpressionContext.class, i);
1444    }
1445
1446    public TerminalNode Plus() {
1447      return getToken(F7Parser.Plus, 0);
1448    }
1449
1450    public TerminalNode Minus() {
1451      return getToken(F7Parser.Minus, 0);
1452    }
1453
1454    @Override
1455    public void enterRule(ParseTreeListener listener) {
1456      if (listener instanceof F7Listener) ((F7Listener) listener).enterAdditiveExpression(this);
1457    }
1458
1459    @Override
1460    public void exitRule(ParseTreeListener listener) {
1461      if (listener instanceof F7Listener) ((F7Listener) listener).exitAdditiveExpression(this);
1462    }
1463
1464    @Override
1465    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1466      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitAdditiveExpression(this);
1467      else return visitor.visitChildren(this);
1468    }
1469  }
1470
1471  public static class RelationalExpressionContext extends ExpressionContext {
1472    public ExpressionContext left;
1473    public ComparisonOperatorContext op;
1474    public ExpressionContext right;
1475
1476    public RelationalExpressionContext(ExpressionContext ctx) {
1477      copyFrom(ctx);
1478    }
1479
1480    public List<ExpressionContext> expression() {
1481      return getRuleContexts(ExpressionContext.class);
1482    }
1483
1484    public ExpressionContext expression(int i) {
1485      return getRuleContext(ExpressionContext.class, i);
1486    }
1487
1488    public ComparisonOperatorContext comparisonOperator() {
1489      return getRuleContext(ComparisonOperatorContext.class, 0);
1490    }
1491
1492    @Override
1493    public void enterRule(ParseTreeListener listener) {
1494      if (listener instanceof F7Listener) ((F7Listener) listener).enterRelationalExpression(this);
1495    }
1496
1497    @Override
1498    public void exitRule(ParseTreeListener listener) {
1499      if (listener instanceof F7Listener) ((F7Listener) listener).exitRelationalExpression(this);
1500    }
1501
1502    @Override
1503    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1504      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitRelationalExpression(this);
1505      else return visitor.visitChildren(this);
1506    }
1507  }
1508
1509  public static class RangeExpressionContext extends ExpressionContext {
1510    public Token separator;
1511
1512    public RangeExpressionContext(ExpressionContext ctx) {
1513      copyFrom(ctx);
1514    }
1515
1516    public List<AtomContext> atom() {
1517      return getRuleContexts(AtomContext.class);
1518    }
1519
1520    public AtomContext atom(int i) {
1521      return getRuleContext(AtomContext.class, i);
1522    }
1523
1524    public List<TerminalNode> Colon() {
1525      return getTokens(F7Parser.Colon);
1526    }
1527
1528    public TerminalNode Colon(int i) {
1529      return getToken(F7Parser.Colon, i);
1530    }
1531
1532    @Override
1533    public void enterRule(ParseTreeListener listener) {
1534      if (listener instanceof F7Listener) ((F7Listener) listener).enterRangeExpression(this);
1535    }
1536
1537    @Override
1538    public void exitRule(ParseTreeListener listener) {
1539      if (listener instanceof F7Listener) ((F7Listener) listener).exitRangeExpression(this);
1540    }
1541
1542    @Override
1543    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1544      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitRangeExpression(this);
1545      else return visitor.visitChildren(this);
1546    }
1547  }
1548
1549  public static class MultiplicationExpressionContext extends ExpressionContext {
1550    public ExpressionContext left;
1551    public Token op;
1552    public ExpressionContext right;
1553
1554    public MultiplicationExpressionContext(ExpressionContext ctx) {
1555      copyFrom(ctx);
1556    }
1557
1558    public List<ExpressionContext> expression() {
1559      return getRuleContexts(ExpressionContext.class);
1560    }
1561
1562    public ExpressionContext expression(int i) {
1563      return getRuleContext(ExpressionContext.class, i);
1564    }
1565
1566    public TerminalNode Multiply() {
1567      return getToken(F7Parser.Multiply, 0);
1568    }
1569
1570    public TerminalNode Divide() {
1571      return getToken(F7Parser.Divide, 0);
1572    }
1573
1574    @Override
1575    public void enterRule(ParseTreeListener listener) {
1576      if (listener instanceof F7Listener) ((F7Listener) listener).enterMultiplicationExpression(this);
1577    }
1578
1579    @Override
1580    public void exitRule(ParseTreeListener listener) {
1581      if (listener instanceof F7Listener) ((F7Listener) listener).exitMultiplicationExpression(this);
1582    }
1583
1584    @Override
1585    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1586      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitMultiplicationExpression(this);
1587      else return visitor.visitChildren(this);
1588    }
1589  }
1590
1591  public static class ConcatExpressionContext extends ExpressionContext {
1592    public ExpressionContext left;
1593    public Token op;
1594    public ExpressionContext right;
1595
1596    public ConcatExpressionContext(ExpressionContext ctx) {
1597      copyFrom(ctx);
1598    }
1599
1600    public List<ExpressionContext> expression() {
1601      return getRuleContexts(ExpressionContext.class);
1602    }
1603
1604    public ExpressionContext expression(int i) {
1605      return getRuleContext(ExpressionContext.class, i);
1606    }
1607
1608    public TerminalNode Ampersand() {
1609      return getToken(F7Parser.Ampersand, 0);
1610    }
1611
1612    @Override
1613    public void enterRule(ParseTreeListener listener) {
1614      if (listener instanceof F7Listener) ((F7Listener) listener).enterConcatExpression(this);
1615    }
1616
1617    @Override
1618    public void exitRule(ParseTreeListener listener) {
1619      if (listener instanceof F7Listener) ((F7Listener) listener).exitConcatExpression(this);
1620    }
1621
1622    @Override
1623    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1624      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitConcatExpression(this);
1625      else return visitor.visitChildren(this);
1626    }
1627  }
1628
1629  public static class AtomContext extends ParserRuleContext {
1630    public AtomContext(ParserRuleContext parent, int invokingState) {
1631      super(parent, invokingState);
1632    }
1633
1634    public AtomContext() {
1635    }
1636
1637    @Override public int getRuleIndex() {
1638      return RULE_atom;
1639    }
1640
1641    public void copyFrom(AtomContext ctx) {
1642      super.copyFrom(ctx);
1643    }
1644  }
1645
1646  public static class NamedAtomContext extends AtomContext {
1647    public NamedAtomContext(AtomContext ctx) {
1648      copyFrom(ctx);
1649    }
1650
1651    public IdentifierContext identifier() {
1652      return getRuleContext(IdentifierContext.class, 0);
1653    }
1654
1655    @Override
1656    public void enterRule(ParseTreeListener listener) {
1657      if (listener instanceof F7Listener) ((F7Listener) listener).enterNamedAtom(this);
1658    }
1659
1660    @Override
1661    public void exitRule(ParseTreeListener listener) {
1662      if (listener instanceof F7Listener) ((F7Listener) listener).exitNamedAtom(this);
1663    }
1664
1665    @Override
1666    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1667      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitNamedAtom(this);
1668      else return visitor.visitChildren(this);
1669    }
1670  }
1671
1672  public static class ErrorAtomContext extends AtomContext {
1673    public ErrorAtomContext(AtomContext ctx) {
1674      copyFrom(ctx);
1675    }
1676
1677    public TerminalNode Error() {
1678      return getToken(F7Parser.Error, 0);
1679    }
1680
1681    @Override
1682    public void enterRule(ParseTreeListener listener) {
1683      if (listener instanceof F7Listener) ((F7Listener) listener).enterErrorAtom(this);
1684    }
1685
1686    @Override
1687    public void exitRule(ParseTreeListener listener) {
1688      if (listener instanceof F7Listener) ((F7Listener) listener).exitErrorAtom(this);
1689    }
1690
1691    @Override
1692    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1693      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitErrorAtom(this);
1694      else return visitor.visitChildren(this);
1695    }
1696  }
1697
1698  public static class ListAtomContext extends AtomContext {
1699    public Token separator;
1700
1701    public ListAtomContext(AtomContext ctx) {
1702      copyFrom(ctx);
1703    }
1704
1705    public TerminalNode LeftBrace() {
1706      return getToken(F7Parser.LeftBrace, 0);
1707    }
1708
1709    public TerminalNode RightBrace() {
1710      return getToken(F7Parser.RightBrace, 0);
1711    }
1712
1713    public List<ExpressionContext> expression() {
1714      return getRuleContexts(ExpressionContext.class);
1715    }
1716
1717    public ExpressionContext expression(int i) {
1718      return getRuleContext(ExpressionContext.class, i);
1719    }
1720
1721    public List<TerminalNode> Comma() {
1722      return getTokens(F7Parser.Comma);
1723    }
1724
1725    public TerminalNode Comma(int i) {
1726      return getToken(F7Parser.Comma, i);
1727    }
1728
1729    public List<TerminalNode> SemiColon() {
1730      return getTokens(F7Parser.SemiColon);
1731    }
1732
1733    public TerminalNode SemiColon(int i) {
1734      return getToken(F7Parser.SemiColon, i);
1735    }
1736
1737    @Override
1738    public void enterRule(ParseTreeListener listener) {
1739      if (listener instanceof F7Listener) ((F7Listener) listener).enterListAtom(this);
1740    }
1741
1742    @Override
1743    public void exitRule(ParseTreeListener listener) {
1744      if (listener instanceof F7Listener) ((F7Listener) listener).exitListAtom(this);
1745    }
1746
1747    @Override
1748    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1749      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitListAtom(this);
1750      else return visitor.visitChildren(this);
1751    }
1752  }
1753
1754  public static class ParentheticalAtomContext extends AtomContext {
1755    public ParentheticalAtomContext(AtomContext ctx) {
1756      copyFrom(ctx);
1757    }
1758
1759    public TerminalNode LeftParen() {
1760      return getToken(F7Parser.LeftParen, 0);
1761    }
1762
1763    public ExpressionContext expression() {
1764      return getRuleContext(ExpressionContext.class, 0);
1765    }
1766
1767    public TerminalNode RightParen() {
1768      return getToken(F7Parser.RightParen, 0);
1769    }
1770
1771    @Override
1772    public void enterRule(ParseTreeListener listener) {
1773      if (listener instanceof F7Listener) ((F7Listener) listener).enterParentheticalAtom(this);
1774    }
1775
1776    @Override
1777    public void exitRule(ParseTreeListener listener) {
1778      if (listener instanceof F7Listener) ((F7Listener) listener).exitParentheticalAtom(this);
1779    }
1780
1781    @Override
1782    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1783      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitParentheticalAtom(this);
1784      else return visitor.visitChildren(this);
1785    }
1786  }
1787
1788  public static class CellAtomContext extends AtomContext {
1789    public CellAtomContext(AtomContext ctx) {
1790      copyFrom(ctx);
1791    }
1792
1793    public RangeContext range() {
1794      return getRuleContext(RangeContext.class, 0);
1795    }
1796
1797    @Override
1798    public void enterRule(ParseTreeListener listener) {
1799      if (listener instanceof F7Listener) ((F7Listener) listener).enterCellAtom(this);
1800    }
1801
1802    @Override
1803    public void exitRule(ParseTreeListener listener) {
1804      if (listener instanceof F7Listener) ((F7Listener) listener).exitCellAtom(this);
1805    }
1806
1807    @Override
1808    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1809      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitCellAtom(this);
1810      else return visitor.visitChildren(this);
1811    }
1812  }
1813
1814  public static class StringAtomContext extends AtomContext {
1815    public StringAtomContext(AtomContext ctx) {
1816      copyFrom(ctx);
1817    }
1818
1819    public TerminalNode String() {
1820      return getToken(F7Parser.String, 0);
1821    }
1822
1823    @Override
1824    public void enterRule(ParseTreeListener listener) {
1825      if (listener instanceof F7Listener) ((F7Listener) listener).enterStringAtom(this);
1826    }
1827
1828    @Override
1829    public void exitRule(ParseTreeListener listener) {
1830      if (listener instanceof F7Listener) ((F7Listener) listener).exitStringAtom(this);
1831    }
1832
1833    @Override
1834    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1835      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitStringAtom(this);
1836      else return visitor.visitChildren(this);
1837    }
1838  }
1839
1840  public static class FormulaAtomContext extends AtomContext {
1841    public IdentifierContext name;
1842
1843    public FormulaAtomContext(AtomContext ctx) {
1844      copyFrom(ctx);
1845    }
1846
1847    public TerminalNode LeftParen() {
1848      return getToken(F7Parser.LeftParen, 0);
1849    }
1850
1851    public ArgumentsContext arguments() {
1852      return getRuleContext(ArgumentsContext.class, 0);
1853    }
1854
1855    public TerminalNode RightParen() {
1856      return getToken(F7Parser.RightParen, 0);
1857    }
1858
1859    public IdentifierContext identifier() {
1860      return getRuleContext(IdentifierContext.class, 0);
1861    }
1862
1863    @Override
1864    public void enterRule(ParseTreeListener listener) {
1865      if (listener instanceof F7Listener) ((F7Listener) listener).enterFormulaAtom(this);
1866    }
1867
1868    @Override
1869    public void exitRule(ParseTreeListener listener) {
1870      if (listener instanceof F7Listener) ((F7Listener) listener).exitFormulaAtom(this);
1871    }
1872
1873    @Override
1874    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1875      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitFormulaAtom(this);
1876      else return visitor.visitChildren(this);
1877    }
1878  }
1879
1880  public static class NumberAtomContext extends AtomContext {
1881    public NumberAtomContext(AtomContext ctx) {
1882      copyFrom(ctx);
1883    }
1884
1885    public TerminalNode Int() {
1886      return getToken(F7Parser.Int, 0);
1887    }
1888
1889    public TerminalNode Number() {
1890      return getToken(F7Parser.Number, 0);
1891    }
1892
1893    @Override
1894    public void enterRule(ParseTreeListener listener) {
1895      if (listener instanceof F7Listener) ((F7Listener) listener).enterNumberAtom(this);
1896    }
1897
1898    @Override
1899    public void exitRule(ParseTreeListener listener) {
1900      if (listener instanceof F7Listener) ((F7Listener) listener).exitNumberAtom(this);
1901    }
1902
1903    @Override
1904    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1905      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitNumberAtom(this);
1906      else return visitor.visitChildren(this);
1907    }
1908  }
1909
1910  public static class RangeContext extends ParserRuleContext {
1911    public RangeContext(ParserRuleContext parent, int invokingState) {
1912      super(parent, invokingState);
1913    }
1914
1915    public RangeContext() {
1916    }
1917
1918    @Override public int getRuleIndex() {
1919      return RULE_range;
1920    }
1921
1922    public void copyFrom(RangeContext ctx) {
1923      super.copyFrom(ctx);
1924    }
1925  }
1926
1927  public static class ColumnWiseWithRowOffsetFirstBiRangeContext extends RangeContext {
1928    public IdentifierContext grid;
1929    public Token absoFirstColumn;
1930    public Token firstColumn;
1931    public Token absoFirstRow;
1932    public Token firstRow;
1933    public Token absoLastColumn;
1934    public Token lastColumn;
1935
1936    public ColumnWiseWithRowOffsetFirstBiRangeContext(RangeContext ctx) {
1937      copyFrom(ctx);
1938    }
1939
1940    public TerminalNode Colon() {
1941      return getToken(F7Parser.Colon, 0);
1942    }
1943
1944    public List<TerminalNode> NCharacters() {
1945      return getTokens(F7Parser.NCharacters);
1946    }
1947
1948    public TerminalNode NCharacters(int i) {
1949      return getToken(F7Parser.NCharacters, i);
1950    }
1951
1952    public TerminalNode Int() {
1953      return getToken(F7Parser.Int, 0);
1954    }
1955
1956    public TerminalNode Bang() {
1957      return getToken(F7Parser.Bang, 0);
1958    }
1959
1960    public IdentifierContext identifier() {
1961      return getRuleContext(IdentifierContext.class, 0);
1962    }
1963
1964    public List<TerminalNode> Dollar() {
1965      return getTokens(F7Parser.Dollar);
1966    }
1967
1968    public TerminalNode Dollar(int i) {
1969      return getToken(F7Parser.Dollar, i);
1970    }
1971
1972    @Override
1973    public void enterRule(ParseTreeListener listener) {
1974      if (listener instanceof F7Listener) ((F7Listener) listener).enterColumnWiseWithRowOffsetFirstBiRange(this);
1975    }
1976
1977    @Override
1978    public void exitRule(ParseTreeListener listener) {
1979      if (listener instanceof F7Listener) ((F7Listener) listener).exitColumnWiseWithRowOffsetFirstBiRange(this);
1980    }
1981
1982    @Override
1983    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1984      if (visitor instanceof F7Visitor)
1985        return ((F7Visitor<? extends T>) visitor).visitColumnWiseWithRowOffsetFirstBiRange(this);
1986      else return visitor.visitChildren(this);
1987    }
1988  }
1989
1990  public static class ColumnWiseWithRowOffsetLastBiRangeContext extends RangeContext {
1991    public IdentifierContext grid;
1992    public Token absoFirstColumn;
1993    public Token firstColumn;
1994    public Token absoLastColumn;
1995    public Token lastColumn;
1996    public Token absoLastRow;
1997    public Token lastRow;
1998
1999    public ColumnWiseWithRowOffsetLastBiRangeContext(RangeContext ctx) {
2000      copyFrom(ctx);
2001    }
2002
2003    public TerminalNode Colon() {
2004      return getToken(F7Parser.Colon, 0);
2005    }
2006
2007    public List<TerminalNode> NCharacters() {
2008      return getTokens(F7Parser.NCharacters);
2009    }
2010
2011    public TerminalNode NCharacters(int i) {
2012      return getToken(F7Parser.NCharacters, i);
2013    }
2014
2015    public TerminalNode Int() {
2016      return getToken(F7Parser.Int, 0);
2017    }
2018
2019    public TerminalNode Bang() {
2020      return getToken(F7Parser.Bang, 0);
2021    }
2022
2023    public IdentifierContext identifier() {
2024      return getRuleContext(IdentifierContext.class, 0);
2025    }
2026
2027    public List<TerminalNode> Dollar() {
2028      return getTokens(F7Parser.Dollar);
2029    }
2030
2031    public TerminalNode Dollar(int i) {
2032      return getToken(F7Parser.Dollar, i);
2033    }
2034
2035    @Override
2036    public void enterRule(ParseTreeListener listener) {
2037      if (listener instanceof F7Listener) ((F7Listener) listener).enterColumnWiseWithRowOffsetLastBiRange(this);
2038    }
2039
2040    @Override
2041    public void exitRule(ParseTreeListener listener) {
2042      if (listener instanceof F7Listener) ((F7Listener) listener).exitColumnWiseWithRowOffsetLastBiRange(this);
2043    }
2044
2045    @Override
2046    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2047      if (visitor instanceof F7Visitor)
2048        return ((F7Visitor<? extends T>) visitor).visitColumnWiseWithRowOffsetLastBiRange(this);
2049      else return visitor.visitChildren(this);
2050    }
2051  }
2052
2053  public static class RowWiseBiRangeContext extends RangeContext {
2054    public IdentifierContext grid;
2055    public Token absoFirstRow;
2056    public Token firstRow;
2057    public Token absoLastRow;
2058    public Token lastRow;
2059
2060    public RowWiseBiRangeContext(RangeContext ctx) {
2061      copyFrom(ctx);
2062    }
2063
2064    public TerminalNode Colon() {
2065      return getToken(F7Parser.Colon, 0);
2066    }
2067
2068    public List<TerminalNode> Int() {
2069      return getTokens(F7Parser.Int);
2070    }
2071
2072    public TerminalNode Int(int i) {
2073      return getToken(F7Parser.Int, i);
2074    }
2075
2076    public TerminalNode Bang() {
2077      return getToken(F7Parser.Bang, 0);
2078    }
2079
2080    public IdentifierContext identifier() {
2081      return getRuleContext(IdentifierContext.class, 0);
2082    }
2083
2084    public List<TerminalNode> Dollar() {
2085      return getTokens(F7Parser.Dollar);
2086    }
2087
2088    public TerminalNode Dollar(int i) {
2089      return getToken(F7Parser.Dollar, i);
2090    }
2091
2092    @Override
2093    public void enterRule(ParseTreeListener listener) {
2094      if (listener instanceof F7Listener) ((F7Listener) listener).enterRowWiseBiRange(this);
2095    }
2096
2097    @Override
2098    public void exitRule(ParseTreeListener listener) {
2099      if (listener instanceof F7Listener) ((F7Listener) listener).exitRowWiseBiRange(this);
2100    }
2101
2102    @Override
2103    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2104      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitRowWiseBiRange(this);
2105      else return visitor.visitChildren(this);
2106    }
2107  }
2108
2109  public static class BiRangeContext extends RangeContext {
2110    public IdentifierContext grid;
2111    public Token absoFirstColumn;
2112    public Token firstColumn;
2113    public Token absoRow;
2114    public Token firstRow;
2115    public Token absoLastColumn;
2116    public Token lastColumn;
2117    public Token absoLastRow;
2118    public Token lastRow;
2119
2120    public BiRangeContext(RangeContext ctx) {
2121      copyFrom(ctx);
2122    }
2123
2124    public TerminalNode Colon() {
2125      return getToken(F7Parser.Colon, 0);
2126    }
2127
2128    public List<TerminalNode> NCharacters() {
2129      return getTokens(F7Parser.NCharacters);
2130    }
2131
2132    public TerminalNode NCharacters(int i) {
2133      return getToken(F7Parser.NCharacters, i);
2134    }
2135
2136    public List<TerminalNode> Int() {
2137      return getTokens(F7Parser.Int);
2138    }
2139
2140    public TerminalNode Int(int i) {
2141      return getToken(F7Parser.Int, i);
2142    }
2143
2144    public TerminalNode Bang() {
2145      return getToken(F7Parser.Bang, 0);
2146    }
2147
2148    public IdentifierContext identifier() {
2149      return getRuleContext(IdentifierContext.class, 0);
2150    }
2151
2152    public List<TerminalNode> Dollar() {
2153      return getTokens(F7Parser.Dollar);
2154    }
2155
2156    public TerminalNode Dollar(int i) {
2157      return getToken(F7Parser.Dollar, i);
2158    }
2159
2160    @Override
2161    public void enterRule(ParseTreeListener listener) {
2162      if (listener instanceof F7Listener) ((F7Listener) listener).enterBiRange(this);
2163    }
2164
2165    @Override
2166    public void exitRule(ParseTreeListener listener) {
2167      if (listener instanceof F7Listener) ((F7Listener) listener).exitBiRange(this);
2168    }
2169
2170    @Override
2171    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2172      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitBiRange(this);
2173      else return visitor.visitChildren(this);
2174    }
2175  }
2176
2177  public static class UniRangeContext extends RangeContext {
2178    public IdentifierContext grid;
2179    public Token absoFirstColumn;
2180    public Token firstColumn;
2181    public Token absoFirstRow;
2182    public Token firstRow;
2183
2184    public UniRangeContext(RangeContext ctx) {
2185      copyFrom(ctx);
2186    }
2187
2188    public TerminalNode NCharacters() {
2189      return getToken(F7Parser.NCharacters, 0);
2190    }
2191
2192    public TerminalNode Int() {
2193      return getToken(F7Parser.Int, 0);
2194    }
2195
2196    public TerminalNode Bang() {
2197      return getToken(F7Parser.Bang, 0);
2198    }
2199
2200    public IdentifierContext identifier() {
2201      return getRuleContext(IdentifierContext.class, 0);
2202    }
2203
2204    public List<TerminalNode> Dollar() {
2205      return getTokens(F7Parser.Dollar);
2206    }
2207
2208    public TerminalNode Dollar(int i) {
2209      return getToken(F7Parser.Dollar, i);
2210    }
2211
2212    @Override
2213    public void enterRule(ParseTreeListener listener) {
2214      if (listener instanceof F7Listener) ((F7Listener) listener).enterUniRange(this);
2215    }
2216
2217    @Override
2218    public void exitRule(ParseTreeListener listener) {
2219      if (listener instanceof F7Listener) ((F7Listener) listener).exitUniRange(this);
2220    }
2221
2222    @Override
2223    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2224      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitUniRange(this);
2225      else return visitor.visitChildren(this);
2226    }
2227  }
2228
2229  public static class ColumnWiseBiRangeContext extends RangeContext {
2230    public IdentifierContext grid;
2231    public Token absoFirstColumn;
2232    public Token firstColumn;
2233    public Token absoLastColumn;
2234    public Token lastColumn;
2235
2236    public ColumnWiseBiRangeContext(RangeContext ctx) {
2237      copyFrom(ctx);
2238    }
2239
2240    public TerminalNode Colon() {
2241      return getToken(F7Parser.Colon, 0);
2242    }
2243
2244    public List<TerminalNode> NCharacters() {
2245      return getTokens(F7Parser.NCharacters);
2246    }
2247
2248    public TerminalNode NCharacters(int i) {
2249      return getToken(F7Parser.NCharacters, i);
2250    }
2251
2252    public TerminalNode Bang() {
2253      return getToken(F7Parser.Bang, 0);
2254    }
2255
2256    public IdentifierContext identifier() {
2257      return getRuleContext(IdentifierContext.class, 0);
2258    }
2259
2260    public List<TerminalNode> Dollar() {
2261      return getTokens(F7Parser.Dollar);
2262    }
2263
2264    public TerminalNode Dollar(int i) {
2265      return getToken(F7Parser.Dollar, i);
2266    }
2267
2268    @Override
2269    public void enterRule(ParseTreeListener listener) {
2270      if (listener instanceof F7Listener) ((F7Listener) listener).enterColumnWiseBiRange(this);
2271    }
2272
2273    @Override
2274    public void exitRule(ParseTreeListener listener) {
2275      if (listener instanceof F7Listener) ((F7Listener) listener).exitColumnWiseBiRange(this);
2276    }
2277
2278    @Override
2279    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2280      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitColumnWiseBiRange(this);
2281      else return visitor.visitChildren(this);
2282    }
2283  }
2284
2285  public static class RowWiseWithColumnOffsetFirstBiRangeContext extends RangeContext {
2286    public IdentifierContext grid;
2287    public Token absoFirstColumn;
2288    public Token firstColumn;
2289    public Token absoFirstRow;
2290    public Token firstRow;
2291    public Token absoLastRow;
2292    public Token lastRow;
2293
2294    public RowWiseWithColumnOffsetFirstBiRangeContext(RangeContext ctx) {
2295      copyFrom(ctx);
2296    }
2297
2298    public TerminalNode Colon() {
2299      return getToken(F7Parser.Colon, 0);
2300    }
2301
2302    public TerminalNode NCharacters() {
2303      return getToken(F7Parser.NCharacters, 0);
2304    }
2305
2306    public List<TerminalNode> Int() {
2307      return getTokens(F7Parser.Int);
2308    }
2309
2310    public TerminalNode Int(int i) {
2311      return getToken(F7Parser.Int, i);
2312    }
2313
2314    public TerminalNode Bang() {
2315      return getToken(F7Parser.Bang, 0);
2316    }
2317
2318    public IdentifierContext identifier() {
2319      return getRuleContext(IdentifierContext.class, 0);
2320    }
2321
2322    public List<TerminalNode> Dollar() {
2323      return getTokens(F7Parser.Dollar);
2324    }
2325
2326    public TerminalNode Dollar(int i) {
2327      return getToken(F7Parser.Dollar, i);
2328    }
2329
2330    @Override
2331    public void enterRule(ParseTreeListener listener) {
2332      if (listener instanceof F7Listener) ((F7Listener) listener).enterRowWiseWithColumnOffsetFirstBiRange(this);
2333    }
2334
2335    @Override
2336    public void exitRule(ParseTreeListener listener) {
2337      if (listener instanceof F7Listener) ((F7Listener) listener).exitRowWiseWithColumnOffsetFirstBiRange(this);
2338    }
2339
2340    @Override
2341    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2342      if (visitor instanceof F7Visitor)
2343        return ((F7Visitor<? extends T>) visitor).visitRowWiseWithColumnOffsetFirstBiRange(this);
2344      else return visitor.visitChildren(this);
2345    }
2346  }
2347
2348  public static class RowWiseWithColumnOffsetLastBiRangeContext extends RangeContext {
2349    public IdentifierContext grid;
2350    public Token absoFirstRow;
2351    public Token firstRow;
2352    public Token absLastColumn;
2353    public Token lastColumn;
2354    public Token absoLastRow;
2355    public Token lastRow;
2356
2357    public RowWiseWithColumnOffsetLastBiRangeContext(RangeContext ctx) {
2358      copyFrom(ctx);
2359    }
2360
2361    public TerminalNode Colon() {
2362      return getToken(F7Parser.Colon, 0);
2363    }
2364
2365    public List<TerminalNode> Int() {
2366      return getTokens(F7Parser.Int);
2367    }
2368
2369    public TerminalNode Int(int i) {
2370      return getToken(F7Parser.Int, i);
2371    }
2372
2373    public TerminalNode NCharacters() {
2374      return getToken(F7Parser.NCharacters, 0);
2375    }
2376
2377    public TerminalNode Bang() {
2378      return getToken(F7Parser.Bang, 0);
2379    }
2380
2381    public IdentifierContext identifier() {
2382      return getRuleContext(IdentifierContext.class, 0);
2383    }
2384
2385    public List<TerminalNode> Dollar() {
2386      return getTokens(F7Parser.Dollar);
2387    }
2388
2389    public TerminalNode Dollar(int i) {
2390      return getToken(F7Parser.Dollar, i);
2391    }
2392
2393    @Override
2394    public void enterRule(ParseTreeListener listener) {
2395      if (listener instanceof F7Listener) ((F7Listener) listener).enterRowWiseWithColumnOffsetLastBiRange(this);
2396    }
2397
2398    @Override
2399    public void exitRule(ParseTreeListener listener) {
2400      if (listener instanceof F7Listener) ((F7Listener) listener).exitRowWiseWithColumnOffsetLastBiRange(this);
2401    }
2402
2403    @Override
2404    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2405      if (visitor instanceof F7Visitor)
2406        return ((F7Visitor<? extends T>) visitor).visitRowWiseWithColumnOffsetLastBiRange(this);
2407      else return visitor.visitChildren(this);
2408    }
2409  }
2410
2411  public static class ArgumentsContext extends ParserRuleContext {
2412    public ArgumentsContext(ParserRuleContext parent, int invokingState) {
2413      super(parent, invokingState);
2414    }
2415
2416    public List<ExpressionContext> expression() {
2417      return getRuleContexts(ExpressionContext.class);
2418    }
2419
2420    public ExpressionContext expression(int i) {
2421      return getRuleContext(ExpressionContext.class, i);
2422    }
2423
2424    public List<TerminalNode> Comma() {
2425      return getTokens(F7Parser.Comma);
2426    }
2427
2428    public TerminalNode Comma(int i) {
2429      return getToken(F7Parser.Comma, i);
2430    }
2431
2432    @Override public int getRuleIndex() {
2433      return RULE_arguments;
2434    }
2435
2436    @Override
2437    public void enterRule(ParseTreeListener listener) {
2438      if (listener instanceof F7Listener) ((F7Listener) listener).enterArguments(this);
2439    }
2440
2441    @Override
2442    public void exitRule(ParseTreeListener listener) {
2443      if (listener instanceof F7Listener) ((F7Listener) listener).exitArguments(this);
2444    }
2445
2446    @Override
2447    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2448      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitArguments(this);
2449      else return visitor.visitChildren(this);
2450    }
2451  }
2452
2453  public static class IdentifierContext extends ParserRuleContext {
2454    public IdentifierContext(ParserRuleContext parent, int invokingState) {
2455      super(parent, invokingState);
2456    }
2457
2458    public List<TerminalNode> NCharacters() {
2459      return getTokens(F7Parser.NCharacters);
2460    }
2461
2462    public TerminalNode NCharacters(int i) {
2463      return getToken(F7Parser.NCharacters, i);
2464    }
2465
2466    public List<TerminalNode> Dot() {
2467      return getTokens(F7Parser.Dot);
2468    }
2469
2470    public TerminalNode Dot(int i) {
2471      return getToken(F7Parser.Dot, i);
2472    }
2473
2474    public List<TerminalNode> Underscore() {
2475      return getTokens(F7Parser.Underscore);
2476    }
2477
2478    public TerminalNode Underscore(int i) {
2479      return getToken(F7Parser.Underscore, i);
2480    }
2481
2482    public List<TerminalNode> Int() {
2483      return getTokens(F7Parser.Int);
2484    }
2485
2486    public TerminalNode Int(int i) {
2487      return getToken(F7Parser.Int, i);
2488    }
2489
2490    @Override public int getRuleIndex() {
2491      return RULE_identifier;
2492    }
2493
2494    @Override
2495    public void enterRule(ParseTreeListener listener) {
2496      if (listener instanceof F7Listener) ((F7Listener) listener).enterIdentifier(this);
2497    }
2498
2499    @Override
2500    public void exitRule(ParseTreeListener listener) {
2501      if (listener instanceof F7Listener) ((F7Listener) listener).exitIdentifier(this);
2502    }
2503
2504    @Override
2505    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2506      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitIdentifier(this);
2507      else return visitor.visitChildren(this);
2508    }
2509  }
2510
2511  public static class ComparisonOperatorContext extends ParserRuleContext {
2512    public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) {
2513      super(parent, invokingState);
2514    }
2515
2516    public TerminalNode LessThanOrEqualTO() {
2517      return getToken(F7Parser.LessThanOrEqualTO, 0);
2518    }
2519
2520    public TerminalNode GreaterThanOrEqualTo() {
2521      return getToken(F7Parser.GreaterThanOrEqualTo, 0);
2522    }
2523
2524    public TerminalNode LessThan() {
2525      return getToken(F7Parser.LessThan, 0);
2526    }
2527
2528    public TerminalNode GreaterThan() {
2529      return getToken(F7Parser.GreaterThan, 0);
2530    }
2531
2532    public TerminalNode Equal() {
2533      return getToken(F7Parser.Equal, 0);
2534    }
2535
2536    public TerminalNode NotEqual() {
2537      return getToken(F7Parser.NotEqual, 0);
2538    }
2539
2540    @Override public int getRuleIndex() {
2541      return RULE_comparisonOperator;
2542    }
2543
2544    @Override
2545    public void enterRule(ParseTreeListener listener) {
2546      if (listener instanceof F7Listener) ((F7Listener) listener).enterComparisonOperator(this);
2547    }
2548
2549    @Override
2550    public void exitRule(ParseTreeListener listener) {
2551      if (listener instanceof F7Listener) ((F7Listener) listener).exitComparisonOperator(this);
2552    }
2553
2554    @Override
2555    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2556      if (visitor instanceof F7Visitor) return ((F7Visitor<? extends T>) visitor).visitComparisonOperator(this);
2557      else return visitor.visitChildren(this);
2558    }
2559  }
2560}