
// Generated from language/FandangoParser.g4 by ANTLR 4.13.2


#include "FandangoParserVisitor.h"

#include "FandangoParser.h"


using namespace antlrcpp;

using namespace antlr4;

namespace {

struct FandangoParserStaticData final {
  FandangoParserStaticData(std::vector<std::string> ruleNames,
                        std::vector<std::string> literalNames,
                        std::vector<std::string> symbolicNames)
      : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
        symbolicNames(std::move(symbolicNames)),
        vocabulary(this->literalNames, this->symbolicNames) {}

  FandangoParserStaticData(const FandangoParserStaticData&) = delete;
  FandangoParserStaticData(FandangoParserStaticData&&) = delete;
  FandangoParserStaticData& operator=(const FandangoParserStaticData&) = delete;
  FandangoParserStaticData& operator=(FandangoParserStaticData&&) = delete;

  std::vector<antlr4::dfa::DFA> decisionToDFA;
  antlr4::atn::PredictionContextCache sharedContextCache;
  const std::vector<std::string> ruleNames;
  const std::vector<std::string> literalNames;
  const std::vector<std::string> symbolicNames;
  const antlr4::dfa::Vocabulary vocabulary;
  antlr4::atn::SerializedATNView serializedATN;
  std::unique_ptr<antlr4::atn::ATN> atn;
};

::antlr4::internal::OnceFlag fandangoparserParserOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
std::unique_ptr<FandangoParserStaticData> fandangoparserParserStaticData = nullptr;

void fandangoparserParserInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  if (fandangoparserParserStaticData != nullptr) {
    return;
  }
#else
  assert(fandangoparserParserStaticData == nullptr);
#endif
  auto staticData = std::make_unique<FandangoParserStaticData>(
    std::vector<std::string>{
      "fandango", "program", "statement", "production", "alternative", "concatenation", 
      "operator", "kleene", "plus", "option", "repeat", "symbol", "nonterminal_right", 
      "nonterminal", "generator_call", "char_set", "constraint", "implies", 
      "quantifier", "quantifier_in_line", "formula_disjunction", "formula_conjunction", 
      "formula_atom", "formula_comparison", "expr", "selector_length", "star_selection_or_dot_selection", 
      "star_selection", "dot_selection", "selection", "base_selection", 
      "rs_pairs", "rs_pair", "rs_slices", "rs_slice", "python", "python_tag", 
      "include", "grammar_setting", "grammar_setting_content", "grammar_selector", 
      "grammar_rule", "grammar_setting_key", "grammar_setting_value", "python_file", 
      "interactive", "eval", "func_type", "statements", "stmt", "statement_newline", 
      "simple_stmts", "simple_stmt", "compound_stmt", "assignment", "annotated_rhs", 
      "augassign", "return_stmt", "raise_stmt", "global_stmt", "nonlocal_stmt", 
      "del_stmt", "yield_stmt", "assert_stmt", "import_stmt", "import_name", 
      "import_from", "import_from_targets", "import_from_as_names", "import_from_as_name", 
      "dotted_as_names", "dotted_as_name", "dotted_name", "block", "decorators", 
      "class_def", "class_def_raw", "function_def", "function_def_raw", 
      "params", "parameters", "slash_no_default", "slash_with_default", 
      "star_etc", "kwds", "param_no_default", "param_no_default_star_annotation", 
      "param_with_default", "param_maybe_default", "param", "param_star_annotation", 
      "annotation", "star_annotation", "default", "if_stmt", "elif_stmt", 
      "else_block", "while_stmt", "for_stmt", "with_stmt", "with_item", 
      "try_stmt", "except_block", "except_star_block", "finally_block", 
      "match_stmt", "subject_expr", "case_block", "guard", "patterns", "pattern", 
      "as_pattern", "or_pattern", "closed_pattern", "literal_pattern", "literal_expr", 
      "complex_number", "signed_number", "signed_real_number", "real_number", 
      "imaginary_number", "capture_pattern", "pattern_capture_target", "wildcard_pattern", 
      "value_pattern", "attr", "name_or_attr", "group_pattern", "sequence_pattern", 
      "open_sequence_pattern", "maybe_sequence_pattern", "maybe_star_pattern", 
      "star_pattern", "mapping_pattern", "items_pattern", "key_value_pattern", 
      "double_star_pattern", "class_pattern", "positional_patterns", "keyword_patterns", 
      "keyword_pattern", "type_alias", "type_params", "type_param_seq", 
      "type_param", "type_param_bound", "expressions", "expression", "yield_expr", 
      "star_expressions", "star_expression", "star_named_expressions", "star_named_expression", 
      "assignment_expression", "named_expression", "disjunction", "conjunction", 
      "inversion", "comparison", "compare_op_bitwise_or_pair", "eq_bitwise_or", 
      "noteq_bitwise_or", "lte_bitwise_or", "lt_bitwise_or", "gte_bitwise_or", 
      "gt_bitwise_or", "notin_bitwise_or", "in_bitwise_or", "isnot_bitwise_or", 
      "is_bitwise_or", "bitwise_or", "bitwise_xor", "bitwise_and", "shift_expr", 
      "sum", "term", "factor", "power", "await_primary", "primary", "slices", 
      "slice", "atom", "group", "lambdef", "lambda_params", "lambda_parameters", 
      "lambda_slash_no_default", "lambda_slash_with_default", "lambda_star_etc", 
      "lambda_kwds", "lambda_param_no_default", "lambda_param_with_default", 
      "lambda_param_maybe_default", "lambda_param", "fstring_middle_no_quote", 
      "fstring_middle_no_single_quote", "fstring_middle_breaks_no_triple_quote", 
      "fstring_middle_breaks_no_triple_single_quote", "fstring_any_no_quote", 
      "fstring_any_no_single_quote", "fstring_middle", "fstring_any_breaks_no_triple_quote", 
      "fstring_any_breaks_no_triple_single_quote", "fstring_any", "fstring_replacement_field", 
      "fstring_conversion", "fstring_full_format_spec", "fstring_format_spec", 
      "fstring", "string", "strings", "list", "tuple", "set", "dict", "double_starred_kvpairs", 
      "double_starred_kvpair", "kvpair", "for_if_clauses", "for_if_clause", 
      "listcomp", "setcomp", "genexp", "dictcomp", "arguments", "args", 
      "arg", "kwargs", "starred_expression", "kwarg_or_starred", "kwarg_or_double_starred", 
      "star_targets", "star_targets_list_seq", "star_targets_tuple_seq", 
      "star_target", "target_with_star_atom", "star_atom", "single_target", 
      "single_subscript_attribute_target", "t_primary", "del_targets", "del_target", 
      "del_t_atom", "type_expressions", "func_type_comment", "identifier"
    },
    std::vector<std::string>{
      "", "", "", "", "", "", "", "", "", "", "'<py>'", "'</py>'", "'and'", 
      "'as'", "'assert'", "'async'", "'await'", "'break'", "'case'", "'class'", 
      "'continue'", "'def'", "'del'", "'elif'", "'else'", "'except'", "'False'", 
      "'finally'", "'for'", "'from'", "'global'", "'if'", "'import'", "'in'", 
      "'include'", "'is'", "'lambda'", "'match'", "'None'", "'nonlocal'", 
      "'not'", "'or'", "'pass'", "'raise'", "'return'", "'True'", "'try'", 
      "'type'", "'while'", "'where'", "'with'", "'yield'", "'forall'", "'exists'", 
      "'maximizing'", "'minimizing'", "'any'", "'all'", "'len'", "'setting'", 
      "'all_with_type'", "", "", "", "'\"\"\"'", "'''''", "'\"'", "'''", 
      "", "", "", "", "", "", "", "'::='", "'\\u003F'", "'\\'", "'...'", 
      "'..'", "'.'", "'*'", "'('", "')'", "','", "':'", "';'", "'**'", "'='", 
      "'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", "'-'", "'/'", 
      "'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='", 
      "'<='", "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", "'*='", "'@='", 
      "'/='", "'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", 
      "'//='", "':='", "'!'", "", "", "", "'_'"
    },
    std::vector<std::string>{
      "", "INDENT", "DEDENT", "FSTRING_START_QUOTE", "FSTRING_START_SINGLE_QUOTE", 
      "FSTRING_START_TRIPLE_QUOTE", "FSTRING_START_TRIPLE_SINGLE_QUOTE", 
      "STRING", "NUMBER", "INTEGER", "PYTHON_START", "PYTHON_END", "AND", 
      "AS", "ASSERT", "ASYNC", "AWAIT", "BREAK", "CASE", "CLASS", "CONTINUE", 
      "DEF", "DEL", "ELIF", "ELSE", "EXCEPT", "FALSE", "FINALLY", "FOR", 
      "FROM", "GLOBAL", "IF", "IMPORT", "IN", "INCLUDE", "IS", "LAMBDA", 
      "MATCH", "NONE", "NONLOCAL", "NOT", "OR", "PASS", "RAISE", "RETURN", 
      "TRUE", "TRY", "TYPE", "WHILE", "WHERE", "WITH", "YIELD", "FORALL", 
      "EXISTS", "MAXIMIZING", "MINIMIZING", "ANY", "ALL", "LEN", "SETTING", 
      "ALL_WITH_TYPE", "NODE_TYPES", "NAME", "STRING_LITERAL", "FSTRING_END_TRIPLE_QUOTE", 
      "FSTRING_END_TRIPLE_SINGLE_QUOTE", "FSTRING_END_QUOTE", "FSTRING_END_SINGLE_QUOTE", 
      "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", 
      "BIN_INTEGER", "FLOAT_NUMBER", "IMAG_NUMBER", "GRAMMAR_ASSIGN", "QUESTION", 
      "BACKSLASH", "ELLIPSIS", "DOTDOT", "DOT", "STAR", "OPEN_PAREN", "CLOSE_PAREN", 
      "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", "CLOSE_BRACK", 
      "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS", 
      "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", "LESS_THAN", 
      "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", "NOT_EQ_2", 
      "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", 
      "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", 
      "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", 
      "EXPR_ASSIGN", "EXCL", "NEWLINE", "SKIP_", "SPACES", "UNDERSCORE", 
      "UNKNOWN_CHAR"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,132,3382,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
  	2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
  	7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
  	7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
  	7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
  	7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
  	7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
  	7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
  	7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
  	7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
  	7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
  	7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
  	7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,
  	7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,
  	7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104,
  	7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110,
  	7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116,
  	7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122,
  	7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128,
  	7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134,
  	7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,
  	7,140,2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,
  	7,146,2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,
  	7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,
  	7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
  	7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170,
  	7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,7,175,2,176,
  	7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,2,181,7,181,2,182,
  	7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,7,186,2,187,7,187,2,188,
  	7,188,2,189,7,189,2,190,7,190,2,191,7,191,2,192,7,192,2,193,7,193,2,194,
  	7,194,2,195,7,195,2,196,7,196,2,197,7,197,2,198,7,198,2,199,7,199,2,200,
  	7,200,2,201,7,201,2,202,7,202,2,203,7,203,2,204,7,204,2,205,7,205,2,206,
  	7,206,2,207,7,207,2,208,7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,
  	7,212,2,213,7,213,2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,
  	7,218,2,219,7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224,
  	7,224,2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229,2,230,
  	7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235,7,235,2,236,
  	7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240,2,241,7,241,2,242,
  	7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246,7,246,1,0,1,0,1,0,1,1,
  	5,1,499,8,1,10,1,12,1,502,9,1,1,1,1,1,5,1,506,8,1,10,1,12,1,509,9,1,5,
  	1,511,8,1,10,1,12,1,514,9,1,1,2,1,2,1,2,1,2,1,2,3,2,521,8,2,1,3,5,3,524,
  	8,3,10,3,12,3,527,9,3,1,3,1,3,1,3,1,3,1,3,3,3,534,8,3,1,3,1,3,4,3,538,
  	8,3,11,3,12,3,539,1,3,3,3,543,8,3,1,3,5,3,546,8,3,10,3,12,3,549,9,3,1,
  	3,5,3,552,8,3,10,3,12,3,555,9,3,1,3,1,3,1,3,1,3,1,3,3,3,562,8,3,1,3,1,
  	3,4,3,566,8,3,11,3,12,3,567,1,3,3,3,571,8,3,1,3,5,3,574,8,3,10,3,12,3,
  	577,9,3,1,3,5,3,580,8,3,10,3,12,3,583,9,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,
  	591,8,3,1,3,1,3,4,3,595,8,3,11,3,12,3,596,1,3,3,3,600,8,3,1,3,5,3,603,
  	8,3,10,3,12,3,606,9,3,3,3,608,8,3,1,4,1,4,1,4,5,4,613,8,4,10,4,12,4,616,
  	9,4,1,5,1,5,5,5,620,8,5,10,5,12,5,623,9,5,1,6,1,6,1,6,1,6,1,6,3,6,630,
  	8,6,1,7,1,7,1,7,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,
  	1,10,1,10,3,10,649,8,10,1,10,1,10,3,10,653,8,10,1,10,1,10,3,10,657,8,
  	10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,3,11,668,8,11,1,12,1,
  	12,1,12,1,12,3,12,674,8,12,1,12,1,12,1,12,3,12,679,8,12,1,12,1,12,1,12,
  	1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,
  	1,14,1,14,1,14,1,14,1,14,1,14,3,14,704,8,14,1,14,5,14,707,8,14,10,14,
  	12,14,710,9,14,1,15,1,15,3,15,714,8,15,1,15,1,15,1,15,1,16,5,16,720,8,
  	16,10,16,12,16,723,9,16,1,16,1,16,1,16,5,16,728,8,16,10,16,12,16,731,
  	9,16,1,16,5,16,734,8,16,10,16,12,16,737,9,16,1,16,1,16,1,16,1,16,4,16,
  	743,8,16,11,16,12,16,744,1,16,3,16,748,8,16,1,16,5,16,751,8,16,10,16,
  	12,16,754,9,16,1,16,5,16,757,8,16,10,16,12,16,760,9,16,1,16,1,16,1,16,
  	1,16,4,16,766,8,16,11,16,12,16,767,1,16,3,16,771,8,16,1,16,5,16,774,8,
  	16,10,16,12,16,777,9,16,1,16,1,16,1,16,3,16,782,8,16,1,17,1,17,1,17,1,
  	17,1,17,1,17,3,17,790,8,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
  	18,1,18,1,18,3,18,803,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
  	18,1,18,1,18,3,18,816,8,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,824,8,18,
  	1,18,1,18,1,18,1,18,1,18,4,18,831,8,18,11,18,12,18,832,1,18,3,18,836,
  	8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,845,8,18,1,18,1,18,1,18,
  	1,18,1,18,1,18,4,18,853,8,18,11,18,12,18,854,1,18,3,18,858,8,18,1,18,
  	1,18,1,18,1,18,1,18,1,18,1,18,3,18,867,8,18,1,18,1,18,1,18,1,18,1,18,
  	1,18,4,18,875,8,18,11,18,12,18,876,1,18,3,18,880,8,18,1,18,1,18,1,18,
  	1,18,1,18,1,18,1,18,3,18,889,8,18,1,18,1,18,1,18,1,18,1,18,1,18,4,18,
  	897,8,18,11,18,12,18,898,1,18,3,18,902,8,18,1,18,1,18,1,18,1,18,1,18,
  	1,18,3,18,910,8,18,1,18,1,18,1,18,1,18,1,18,4,18,917,8,18,11,18,12,18,
  	918,1,18,3,18,922,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,931,8,
  	18,1,18,1,18,1,18,1,18,1,18,1,18,4,18,939,8,18,11,18,12,18,940,1,18,3,
  	18,944,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,953,8,18,1,18,1,18,
  	1,18,1,18,1,18,1,18,4,18,961,8,18,11,18,12,18,962,1,18,3,18,966,8,18,
  	1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,975,8,18,1,18,1,18,1,18,1,18,
  	1,18,1,18,4,18,983,8,18,11,18,12,18,984,1,18,3,18,988,8,18,1,18,1,18,
  	1,18,4,18,993,8,18,11,18,12,18,994,1,18,3,18,998,8,18,3,18,1000,8,18,
  	1,19,1,19,1,19,1,19,1,19,1,19,3,19,1008,8,19,1,19,1,19,1,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,3,19,1021,8,19,1,19,1,19,1,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,1035,8,19,1,19,1,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,1049,8,19,1,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,1062,8,19,1,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,1075,8,19,1,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,1089,8,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,1103,8,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,3,19,1111,8,19,1,20,1,20,1,20,5,20,1116,8,20,
  	10,20,12,20,1119,9,20,1,21,1,21,1,21,5,21,1124,8,21,10,21,12,21,1127,
  	9,21,1,22,1,22,1,22,1,22,1,22,1,22,3,22,1135,8,22,1,23,1,23,1,23,1,23,
  	1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,3,24,1149,8,24,1,25,1,25,1,25,
  	1,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,1161,8,25,1,26,1,26,3,26,1165,
  	8,26,1,27,1,27,1,27,1,27,3,27,1171,8,27,1,28,1,28,1,28,1,28,1,28,1,28,
  	1,28,1,28,1,28,5,28,1182,8,28,10,28,12,28,1185,9,28,1,29,1,29,1,29,1,
  	29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,1198,8,29,1,30,1,30,1,30,1,
  	30,1,30,3,30,1205,8,30,1,31,1,31,1,31,5,31,1210,8,31,10,31,12,31,1213,
  	9,31,1,31,3,31,1216,8,31,1,32,1,32,1,32,1,32,3,32,1222,8,32,1,33,1,33,
  	1,33,5,33,1227,8,33,10,33,12,33,1230,9,33,1,33,3,33,1233,8,33,1,34,1,
  	34,3,34,1237,8,34,1,34,1,34,3,34,1241,8,34,1,34,3,34,1244,8,34,1,34,1,
  	34,3,34,1248,8,34,1,34,1,34,3,34,1252,8,34,3,34,1254,8,34,1,35,1,35,3,
  	35,1258,8,35,1,36,5,36,1261,8,36,10,36,12,36,1264,9,36,1,36,1,36,5,36,
  	1268,8,36,10,36,12,36,1271,9,36,1,37,1,37,1,37,1,37,1,37,1,37,1,38,5,
  	38,1280,8,38,10,38,12,38,1283,9,38,1,38,1,38,1,38,5,38,1288,8,38,10,38,
  	12,38,1291,9,38,1,39,1,39,5,39,1295,8,39,10,39,12,39,1298,9,39,1,40,1,
  	40,1,40,1,40,1,40,1,40,3,40,1306,8,40,1,41,1,41,3,41,1310,8,41,1,41,3,
  	41,1313,8,41,1,41,3,41,1316,8,41,1,41,1,41,3,41,1320,8,41,1,42,1,42,1,
  	43,1,43,1,44,3,44,1327,8,44,1,44,3,44,1330,8,44,1,45,1,45,1,46,1,46,5,
  	46,1336,8,46,10,46,12,46,1339,9,46,1,46,3,46,1342,8,46,1,47,1,47,3,47,
  	1346,8,47,1,47,1,47,1,47,1,47,5,47,1352,8,47,10,47,12,47,1355,9,47,1,
  	47,3,47,1358,8,47,1,48,1,48,4,48,1362,8,48,11,48,12,48,1363,1,49,1,49,
  	3,49,1368,8,49,1,50,1,50,1,50,1,50,1,50,3,50,1375,8,50,1,51,1,51,1,51,
  	5,51,1380,8,51,10,51,12,51,1383,9,51,1,51,3,51,1386,8,51,1,51,4,51,1389,
  	8,51,11,51,12,51,1390,1,51,5,51,1394,8,51,10,51,12,51,1397,9,51,1,51,
  	3,51,1400,8,51,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,
  	1,52,1,52,1,52,3,52,1416,8,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,
  	3,53,1426,8,53,1,54,1,54,1,54,1,54,1,54,3,54,1433,8,54,1,54,1,54,1,54,
  	1,54,1,54,3,54,1440,8,54,1,54,1,54,1,54,1,54,3,54,1446,8,54,1,54,1,54,
  	1,54,4,54,1451,8,54,11,54,12,54,1452,1,54,1,54,3,54,1457,8,54,1,54,1,
  	54,1,54,1,54,3,54,1463,8,54,3,54,1465,8,54,1,55,1,55,3,55,1469,8,55,1,
  	56,1,56,1,57,1,57,3,57,1475,8,57,1,58,1,58,1,58,1,58,3,58,1481,8,58,1,
  	58,3,58,1484,8,58,1,59,1,59,1,59,1,59,5,59,1490,8,59,10,59,12,59,1493,
  	9,59,1,60,1,60,1,60,1,60,5,60,1499,8,60,10,60,12,60,1502,9,60,1,61,1,
  	61,1,61,1,62,1,62,1,63,1,63,1,63,1,63,3,63,1513,8,63,1,64,1,64,3,64,1517,
  	8,64,1,65,1,65,1,65,1,66,1,66,5,66,1524,8,66,10,66,12,66,1527,9,66,1,
  	66,1,66,1,66,1,66,1,66,1,66,4,66,1535,8,66,11,66,12,66,1536,1,66,1,66,
  	3,66,1541,8,66,1,67,1,67,1,67,3,67,1546,8,67,1,67,1,67,1,67,1,67,3,67,
  	1552,8,67,1,68,1,68,1,68,5,68,1557,8,68,10,68,12,68,1560,9,68,1,69,1,
  	69,1,69,3,69,1565,8,69,1,70,1,70,1,70,5,70,1570,8,70,10,70,12,70,1573,
  	9,70,1,71,1,71,1,71,3,71,1578,8,71,1,72,1,72,1,72,1,72,1,72,1,72,5,72,
  	1586,8,72,10,72,12,72,1589,9,72,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1597,
  	8,73,1,74,1,74,1,74,1,74,4,74,1603,8,74,11,74,12,74,1604,1,75,3,75,1608,
  	8,75,1,75,1,75,1,76,1,76,1,76,3,76,1615,8,76,1,76,1,76,3,76,1619,8,76,
  	1,76,3,76,1622,8,76,1,76,1,76,1,76,1,77,3,77,1628,8,77,1,77,1,77,1,78,
  	3,78,1633,8,78,1,78,1,78,1,78,3,78,1638,8,78,1,78,1,78,3,78,1642,8,78,
  	1,78,1,78,1,78,3,78,1647,8,78,1,78,1,78,3,78,1651,8,78,1,78,1,78,1,79,
  	1,79,1,80,1,80,5,80,1659,8,80,10,80,12,80,1662,9,80,1,80,5,80,1665,8,
  	80,10,80,12,80,1668,9,80,1,80,3,80,1671,8,80,1,80,1,80,5,80,1675,8,80,
  	10,80,12,80,1678,9,80,1,80,3,80,1681,8,80,1,80,4,80,1684,8,80,11,80,12,
  	80,1685,1,80,5,80,1689,8,80,10,80,12,80,1692,9,80,1,80,3,80,1695,8,80,
  	1,80,4,80,1698,8,80,11,80,12,80,1699,1,80,3,80,1703,8,80,1,80,3,80,1706,
  	8,80,1,81,4,81,1709,8,81,11,81,12,81,1710,1,81,1,81,3,81,1715,8,81,1,
  	82,5,82,1718,8,82,10,82,12,82,1721,9,82,1,82,4,82,1724,8,82,11,82,12,
  	82,1725,1,82,1,82,3,82,1730,8,82,1,83,1,83,1,83,5,83,1735,8,83,10,83,
  	12,83,1738,9,83,1,83,3,83,1741,8,83,1,83,1,83,1,83,5,83,1746,8,83,10,
  	83,12,83,1749,9,83,1,83,3,83,1752,8,83,1,83,1,83,1,83,4,83,1757,8,83,
  	11,83,12,83,1758,1,83,3,83,1762,8,83,1,83,3,83,1765,8,83,1,84,1,84,1,
  	84,1,85,1,85,1,85,1,85,3,85,1774,8,85,1,86,1,86,1,86,1,86,3,86,1780,8,
  	86,1,87,1,87,1,87,1,87,1,87,1,87,1,87,3,87,1789,8,87,1,88,1,88,3,88,1793,
  	8,88,1,88,1,88,1,88,1,88,3,88,1799,8,88,3,88,1801,8,88,1,89,1,89,3,89,
  	1805,8,89,1,90,1,90,1,90,1,91,1,91,1,91,1,92,1,92,1,92,1,93,1,93,1,93,
  	1,94,1,94,1,94,1,94,1,94,1,94,1,94,1,94,1,94,1,94,1,94,3,94,1830,8,94,
  	3,94,1832,8,94,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,
  	3,95,1845,8,95,3,95,1847,8,95,1,96,1,96,1,96,1,96,1,97,1,97,1,97,1,97,
  	1,97,3,97,1858,8,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,3,98,1867,8,98,
  	1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,3,98,1877,8,98,3,98,1879,8,98,
  	1,99,1,99,1,99,1,99,1,99,5,99,1886,8,99,10,99,12,99,1889,9,99,1,99,3,
  	99,1892,8,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1902,8,99,10,
  	99,12,99,1905,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,
  	1916,8,99,10,99,12,99,1919,9,99,1,99,3,99,1922,8,99,1,99,1,99,1,99,1,
  	99,1,99,1,99,1,99,1,99,1,99,5,99,1933,8,99,10,99,12,99,1936,9,99,1,99,
  	1,99,1,99,3,99,1941,8,99,1,100,1,100,1,100,1,100,1,100,3,100,1948,8,100,
  	1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,4,101,1959,8,101,
  	11,101,12,101,1960,1,101,3,101,1964,8,101,1,101,3,101,1967,8,101,1,101,
  	1,101,1,101,1,101,4,101,1973,8,101,11,101,12,101,1974,1,101,3,101,1978,
  	8,101,1,101,3,101,1981,8,101,3,101,1983,8,101,1,102,1,102,1,102,1,102,
  	3,102,1989,8,102,1,102,1,102,1,102,1,102,1,102,1,102,3,102,1997,8,102,
  	1,103,1,103,1,103,1,103,1,103,3,103,2004,8,103,1,103,1,103,1,103,1,104,
  	1,104,1,104,1,104,1,105,1,105,1,105,1,105,1,105,1,105,4,105,2019,8,105,
  	11,105,12,105,2020,1,105,1,105,1,106,1,106,1,106,3,106,2028,8,106,1,106,
  	3,106,2031,8,106,1,107,1,107,1,107,3,107,2036,8,107,1,107,1,107,1,107,
  	1,108,1,108,1,108,1,109,1,109,3,109,2046,8,109,1,110,1,110,3,110,2050,
  	8,110,1,111,1,111,1,111,1,111,1,112,1,112,1,112,5,112,2059,8,112,10,112,
  	12,112,2062,9,112,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,
  	2072,8,113,1,114,1,114,1,114,1,114,1,114,1,114,3,114,2080,8,114,1,115,
  	1,115,1,115,1,115,1,115,1,115,3,115,2088,8,115,1,116,1,116,1,116,1,116,
  	1,116,1,116,1,116,1,116,3,116,2098,8,116,1,117,1,117,1,117,3,117,2103,
  	8,117,1,118,1,118,1,118,3,118,2108,8,118,1,119,1,119,1,120,1,120,1,121,
  	1,121,1,122,1,122,1,123,1,123,1,124,1,124,1,125,1,125,1,125,1,125,1,126,
  	1,126,1,126,1,126,1,126,1,126,5,126,2132,8,126,10,126,12,126,2135,9,126,
  	1,127,1,127,1,127,1,127,1,128,1,128,3,128,2143,8,128,1,128,1,128,1,128,
  	3,128,2148,8,128,1,128,3,128,2151,8,128,1,129,1,129,1,129,3,129,2156,
  	8,129,1,130,1,130,1,130,5,130,2161,8,130,10,130,12,130,2164,9,130,1,130,
  	3,130,2167,8,130,1,131,1,131,3,131,2171,8,131,1,132,1,132,1,132,1,132,
  	3,132,2177,8,132,1,133,1,133,1,133,1,133,1,133,3,133,2184,8,133,1,133,
  	1,133,1,133,1,133,1,133,1,133,1,133,3,133,2193,8,133,1,133,1,133,1,133,
  	1,133,1,133,3,133,2200,8,133,1,133,1,133,3,133,2204,8,133,1,134,1,134,
  	1,134,5,134,2209,8,134,10,134,12,134,2212,9,134,1,135,1,135,3,135,2216,
  	8,135,1,135,1,135,1,135,1,136,1,136,1,136,1,137,1,137,1,137,1,137,1,137,
  	1,137,1,137,1,137,3,137,2232,8,137,1,137,1,137,1,137,1,137,1,137,1,137,
  	3,137,2240,8,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,
  	2250,8,137,1,137,1,137,3,137,2254,8,137,1,138,1,138,1,138,5,138,2259,
  	8,138,10,138,12,138,2262,9,138,1,139,1,139,1,139,5,139,2267,8,139,10,
  	139,12,139,2270,9,139,1,140,1,140,1,140,1,140,1,141,1,141,1,141,3,141,
  	2279,8,141,1,141,1,141,1,141,1,142,1,142,1,142,1,142,1,143,1,143,1,143,
  	5,143,2291,8,143,10,143,12,143,2294,9,143,1,143,3,143,2297,8,143,1,144,
  	1,144,3,144,2301,8,144,1,144,1,144,1,144,1,144,3,144,2307,8,144,1,145,
  	1,145,1,145,1,146,1,146,1,146,5,146,2315,8,146,10,146,12,146,2318,9,146,
  	1,146,3,146,2321,8,146,1,147,1,147,1,147,1,147,1,147,1,147,1,147,1,147,
  	3,147,2331,8,147,1,148,1,148,1,148,1,148,1,148,3,148,2338,8,148,3,148,
  	2340,8,148,1,149,1,149,1,149,5,149,2345,8,149,10,149,12,149,2348,9,149,
  	1,149,3,149,2351,8,149,1,150,1,150,1,150,1,150,3,150,2357,8,150,1,151,
  	1,151,1,151,5,151,2362,8,151,10,151,12,151,2365,9,151,1,151,3,151,2368,
  	8,151,1,152,1,152,1,152,3,152,2373,8,152,1,153,1,153,1,153,1,153,1,154,
  	1,154,3,154,2381,8,154,1,155,1,155,1,155,5,155,2386,8,155,10,155,12,155,
  	2389,9,155,1,156,1,156,1,156,5,156,2394,8,156,10,156,12,156,2397,9,156,
  	1,157,1,157,1,157,3,157,2402,8,157,1,158,1,158,5,158,2406,8,158,10,158,
  	12,158,2409,9,158,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
  	1,159,3,159,2421,8,159,1,160,1,160,1,160,1,161,1,161,1,161,1,161,3,161,
  	2430,8,161,1,162,1,162,1,162,1,163,1,163,1,163,1,164,1,164,1,164,1,165,
  	1,165,1,165,1,166,1,166,1,166,1,166,1,167,1,167,1,167,1,168,1,168,1,168,
  	1,168,1,169,1,169,1,169,1,170,1,170,1,170,1,170,1,170,1,170,5,170,2464,
  	8,170,10,170,12,170,2467,9,170,1,171,1,171,1,171,1,171,1,171,1,171,5,
  	171,2475,8,171,10,171,12,171,2478,9,171,1,172,1,172,1,172,1,172,1,172,
  	1,172,5,172,2486,8,172,10,172,12,172,2489,9,172,1,173,1,173,1,173,1,173,
  	1,173,1,173,1,173,1,173,1,173,5,173,2500,8,173,10,173,12,173,2503,9,173,
  	1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,5,174,2514,8,174,
  	10,174,12,174,2517,9,174,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,
  	175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,5,175,
  	2537,8,175,10,175,12,175,2540,9,175,1,176,1,176,1,176,1,176,1,176,1,176,
  	1,176,3,176,2549,8,176,1,177,1,177,1,177,1,177,1,177,3,177,2556,8,177,
  	1,178,1,178,1,178,3,178,2561,8,178,1,179,1,179,1,179,1,179,1,179,1,179,
  	1,179,1,179,1,179,1,179,1,179,3,179,2574,8,179,1,179,1,179,1,179,1,179,
  	1,179,1,179,5,179,2582,8,179,10,179,12,179,2585,9,179,1,180,1,180,3,180,
  	2589,8,180,1,180,1,180,1,180,3,180,2594,8,180,5,180,2596,8,180,10,180,
  	12,180,2599,9,180,1,180,3,180,2602,8,180,1,181,3,181,2605,8,181,1,181,
  	1,181,3,181,2609,8,181,1,181,1,181,3,181,2613,8,181,3,181,2615,8,181,
  	1,181,3,181,2618,8,181,1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,182,
  	1,182,1,182,3,182,2630,8,182,1,182,1,182,3,182,2634,8,182,1,182,1,182,
  	1,182,1,182,3,182,2640,8,182,1,182,3,182,2643,8,182,1,183,1,183,1,183,
  	3,183,2648,8,183,1,183,1,183,1,184,1,184,3,184,2654,8,184,1,184,1,184,
  	1,184,1,185,1,185,1,186,1,186,5,186,2663,8,186,10,186,12,186,2666,9,186,
  	1,186,5,186,2669,8,186,10,186,12,186,2672,9,186,1,186,3,186,2675,8,186,
  	1,186,1,186,5,186,2679,8,186,10,186,12,186,2682,9,186,1,186,3,186,2685,
  	8,186,1,186,4,186,2688,8,186,11,186,12,186,2689,1,186,5,186,2693,8,186,
  	10,186,12,186,2696,9,186,1,186,3,186,2699,8,186,1,186,4,186,2702,8,186,
  	11,186,12,186,2703,1,186,3,186,2707,8,186,1,186,3,186,2710,8,186,1,187,
  	4,187,2713,8,187,11,187,12,187,2714,1,187,1,187,3,187,2719,8,187,1,188,
  	5,188,2722,8,188,10,188,12,188,2725,9,188,1,188,4,188,2728,8,188,11,188,
  	12,188,2729,1,188,1,188,3,188,2734,8,188,1,189,1,189,1,189,5,189,2739,
  	8,189,10,189,12,189,2742,9,189,1,189,3,189,2745,8,189,1,189,1,189,1,189,
  	4,189,2750,8,189,11,189,12,189,2751,1,189,3,189,2755,8,189,1,189,3,189,
  	2758,8,189,1,190,1,190,1,190,1,191,1,191,3,191,2765,8,191,1,192,1,192,
  	1,192,3,192,2770,8,192,1,193,1,193,3,193,2774,8,193,1,193,3,193,2777,
  	8,193,1,194,1,194,1,195,1,195,3,195,2783,8,195,1,196,1,196,3,196,2787,
  	8,196,1,197,1,197,3,197,2791,8,197,1,198,1,198,3,198,2795,8,198,1,199,
  	1,199,1,199,3,199,2800,8,199,1,200,1,200,1,200,3,200,2805,8,200,1,201,
  	1,201,1,201,3,201,2810,8,201,1,202,1,202,1,202,3,202,2815,8,202,1,203,
  	1,203,1,203,3,203,2820,8,203,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,
  	1,204,1,204,1,204,4,204,2928,8,204,11,204,12,204,2929,1,205,1,205,1,205,
  	3,205,2935,8,205,1,205,3,205,2938,8,205,1,205,3,205,2941,8,205,1,205,
  	3,205,2944,8,205,1,205,1,205,1,206,1,206,1,206,1,207,1,207,5,207,2953,
  	8,207,10,207,12,207,2956,9,207,1,208,1,208,3,208,2960,8,208,1,209,1,209,
  	5,209,2964,8,209,10,209,12,209,2967,9,209,1,209,1,209,1,209,5,209,2972,
  	8,209,10,209,12,209,2975,9,209,1,209,1,209,1,209,5,209,2980,8,209,10,
  	209,12,209,2983,9,209,1,209,1,209,1,209,5,209,2988,8,209,10,209,12,209,
  	2991,9,209,1,209,3,209,2994,8,209,1,210,1,210,1,211,1,211,4,211,3000,
  	8,211,11,211,12,211,3001,1,212,1,212,3,212,3006,8,212,1,212,1,212,1,213,
  	1,213,1,213,1,213,1,213,3,213,3015,8,213,1,213,1,213,1,214,1,214,1,214,
  	1,214,1,215,1,215,3,215,3025,8,215,1,215,1,215,1,216,1,216,1,216,5,216,
  	3032,8,216,10,216,12,216,3035,9,216,1,216,3,216,3038,8,216,1,217,1,217,
  	1,217,3,217,3043,8,217,1,218,1,218,1,218,1,218,1,219,4,219,3050,8,219,
  	11,219,12,219,3051,1,220,3,220,3055,8,220,1,220,1,220,1,220,1,220,1,220,
  	1,220,5,220,3063,8,220,10,220,12,220,3066,9,220,1,221,1,221,1,221,1,221,
  	1,221,1,222,1,222,1,222,1,222,1,222,1,223,1,223,1,223,3,223,3081,8,223,
  	1,223,1,223,1,223,1,224,1,224,1,224,1,224,1,224,1,225,1,225,3,225,3093,
  	8,225,1,226,1,226,1,226,5,226,3098,8,226,10,226,12,226,3101,9,226,1,226,
  	1,226,3,226,3105,8,226,1,226,3,226,3108,8,226,1,227,1,227,1,227,1,227,
  	3,227,3114,8,227,1,228,1,228,1,228,5,228,3119,8,228,10,228,12,228,3122,
  	9,228,1,228,1,228,1,228,1,228,5,228,3128,8,228,10,228,12,228,3131,9,228,
  	1,228,1,228,1,228,5,228,3136,8,228,10,228,12,228,3139,9,228,1,228,1,228,
  	1,228,5,228,3144,8,228,10,228,12,228,3147,9,228,3,228,3149,8,228,1,229,
  	1,229,1,229,1,230,1,230,1,230,1,230,1,230,3,230,3159,8,230,1,231,1,231,
  	1,231,1,231,1,231,1,231,3,231,3167,8,231,1,232,1,232,1,232,5,232,3172,
  	8,232,10,232,12,232,3175,9,232,1,232,3,232,3178,8,232,1,233,1,233,1,233,
  	5,233,3183,8,233,10,233,12,233,3186,9,233,1,233,3,233,3189,8,233,1,234,
  	1,234,1,234,4,234,3194,8,234,11,234,12,234,3195,1,234,3,234,3199,8,234,
  	1,234,1,234,1,234,3,234,3204,8,234,1,235,1,235,1,235,3,235,3209,8,235,
  	1,236,1,236,1,236,1,236,1,236,1,236,1,236,1,236,1,236,1,236,3,236,3221,
  	8,236,1,237,1,237,1,237,1,237,1,237,1,237,1,237,3,237,3230,8,237,1,237,
  	1,237,1,237,3,237,3235,8,237,1,237,3,237,3238,8,237,1,238,1,238,1,238,
  	1,238,1,238,1,238,3,238,3246,8,238,1,239,1,239,1,239,1,239,1,239,1,239,
  	1,239,1,239,1,239,3,239,3257,8,239,1,240,1,240,1,240,1,240,1,240,1,240,
  	1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,3,240,3275,
  	8,240,1,240,5,240,3278,8,240,10,240,12,240,3281,9,240,1,241,1,241,1,241,
  	5,241,3286,8,241,10,241,12,241,3289,9,241,1,241,3,241,3292,8,241,1,242,
  	1,242,1,242,1,242,1,242,1,242,1,242,1,242,1,242,1,242,3,242,3304,8,242,
  	1,243,1,243,1,243,3,243,3309,8,243,1,243,1,243,1,243,3,243,3314,8,243,
  	1,243,3,243,3317,8,243,1,244,1,244,1,244,5,244,3322,8,244,10,244,12,244,
  	3325,9,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,
  	5,244,3337,8,244,10,244,12,244,3340,9,244,1,244,1,244,1,244,1,244,1,244,
  	1,244,1,244,5,244,3349,8,244,10,244,12,244,3352,9,244,1,244,1,244,1,244,
  	1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,
  	1,244,1,244,5,244,3371,8,244,10,244,12,244,3374,9,244,3,244,3376,8,244,
  	1,245,1,245,1,246,1,246,1,246,0,12,28,56,144,252,340,342,344,346,348,
  	350,358,480,247,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,
  	40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,
  	86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,
  	124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,
  	160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,
  	196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,
  	232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,264,266,
  	268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,300,302,
  	304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,338,
  	340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,372,374,
  	376,378,380,382,384,386,388,390,392,394,396,398,400,402,404,406,408,410,
  	412,414,416,418,420,422,424,426,428,430,432,434,436,438,440,442,444,446,
  	448,450,452,454,456,458,460,462,464,466,468,470,472,474,476,478,480,482,
  	484,486,488,490,492,0,5,2,1,86,86,128,128,1,0,104,110,1,0,113,125,2,0,
  	78,78,80,80,2,0,56,58,62,62,3805,0,494,1,0,0,0,2,500,1,0,0,0,4,520,1,
  	0,0,0,6,607,1,0,0,0,8,609,1,0,0,0,10,617,1,0,0,0,12,629,1,0,0,0,14,631,
  	1,0,0,0,16,634,1,0,0,0,18,637,1,0,0,0,20,656,1,0,0,0,22,667,1,0,0,0,24,
  	669,1,0,0,0,26,683,1,0,0,0,28,687,1,0,0,0,30,711,1,0,0,0,32,781,1,0,0,
  	0,34,789,1,0,0,0,36,999,1,0,0,0,38,1110,1,0,0,0,40,1112,1,0,0,0,42,1120,
  	1,0,0,0,44,1134,1,0,0,0,46,1136,1,0,0,0,48,1148,1,0,0,0,50,1160,1,0,0,
  	0,52,1164,1,0,0,0,54,1170,1,0,0,0,56,1172,1,0,0,0,58,1197,1,0,0,0,60,
  	1204,1,0,0,0,62,1206,1,0,0,0,64,1217,1,0,0,0,66,1223,1,0,0,0,68,1253,
  	1,0,0,0,70,1257,1,0,0,0,72,1262,1,0,0,0,74,1272,1,0,0,0,76,1281,1,0,0,
  	0,78,1292,1,0,0,0,80,1305,1,0,0,0,82,1307,1,0,0,0,84,1321,1,0,0,0,86,
  	1323,1,0,0,0,88,1326,1,0,0,0,90,1331,1,0,0,0,92,1333,1,0,0,0,94,1343,
  	1,0,0,0,96,1361,1,0,0,0,98,1367,1,0,0,0,100,1374,1,0,0,0,102,1376,1,0,
  	0,0,104,1415,1,0,0,0,106,1425,1,0,0,0,108,1464,1,0,0,0,110,1468,1,0,0,
  	0,112,1470,1,0,0,0,114,1472,1,0,0,0,116,1483,1,0,0,0,118,1485,1,0,0,0,
  	120,1494,1,0,0,0,122,1503,1,0,0,0,124,1506,1,0,0,0,126,1508,1,0,0,0,128,
  	1516,1,0,0,0,130,1518,1,0,0,0,132,1540,1,0,0,0,134,1551,1,0,0,0,136,1553,
  	1,0,0,0,138,1561,1,0,0,0,140,1566,1,0,0,0,142,1574,1,0,0,0,144,1579,1,
  	0,0,0,146,1596,1,0,0,0,148,1602,1,0,0,0,150,1607,1,0,0,0,152,1611,1,0,
  	0,0,154,1627,1,0,0,0,156,1632,1,0,0,0,158,1654,1,0,0,0,160,1705,1,0,0,
  	0,162,1708,1,0,0,0,164,1719,1,0,0,0,166,1764,1,0,0,0,168,1766,1,0,0,0,
  	170,1773,1,0,0,0,172,1779,1,0,0,0,174,1788,1,0,0,0,176,1800,1,0,0,0,178,
  	1802,1,0,0,0,180,1806,1,0,0,0,182,1809,1,0,0,0,184,1812,1,0,0,0,186,1815,
  	1,0,0,0,188,1831,1,0,0,0,190,1846,1,0,0,0,192,1848,1,0,0,0,194,1852,1,
  	0,0,0,196,1878,1,0,0,0,198,1940,1,0,0,0,200,1947,1,0,0,0,202,1982,1,0,
  	0,0,204,1996,1,0,0,0,206,1998,1,0,0,0,208,2008,1,0,0,0,210,2012,1,0,0,
  	0,212,2030,1,0,0,0,214,2032,1,0,0,0,216,2040,1,0,0,0,218,2045,1,0,0,0,
  	220,2049,1,0,0,0,222,2051,1,0,0,0,224,2055,1,0,0,0,226,2071,1,0,0,0,228,
  	2079,1,0,0,0,230,2087,1,0,0,0,232,2097,1,0,0,0,234,2102,1,0,0,0,236,2107,
  	1,0,0,0,238,2109,1,0,0,0,240,2111,1,0,0,0,242,2113,1,0,0,0,244,2115,1,
  	0,0,0,246,2117,1,0,0,0,248,2119,1,0,0,0,250,2121,1,0,0,0,252,2125,1,0,
  	0,0,254,2136,1,0,0,0,256,2150,1,0,0,0,258,2152,1,0,0,0,260,2157,1,0,0,
  	0,262,2170,1,0,0,0,264,2176,1,0,0,0,266,2203,1,0,0,0,268,2205,1,0,0,0,
  	270,2215,1,0,0,0,272,2220,1,0,0,0,274,2253,1,0,0,0,276,2255,1,0,0,0,278,
  	2263,1,0,0,0,280,2271,1,0,0,0,282,2275,1,0,0,0,284,2283,1,0,0,0,286,2287,
  	1,0,0,0,288,2306,1,0,0,0,290,2308,1,0,0,0,292,2311,1,0,0,0,294,2330,1,
  	0,0,0,296,2339,1,0,0,0,298,2341,1,0,0,0,300,2356,1,0,0,0,302,2358,1,0,
  	0,0,304,2372,1,0,0,0,306,2374,1,0,0,0,308,2380,1,0,0,0,310,2382,1,0,0,
  	0,312,2390,1,0,0,0,314,2401,1,0,0,0,316,2403,1,0,0,0,318,2420,1,0,0,0,
  	320,2422,1,0,0,0,322,2429,1,0,0,0,324,2431,1,0,0,0,326,2434,1,0,0,0,328,
  	2437,1,0,0,0,330,2440,1,0,0,0,332,2443,1,0,0,0,334,2447,1,0,0,0,336,2450,
  	1,0,0,0,338,2454,1,0,0,0,340,2457,1,0,0,0,342,2468,1,0,0,0,344,2479,1,
  	0,0,0,346,2490,1,0,0,0,348,2504,1,0,0,0,350,2518,1,0,0,0,352,2548,1,0,
  	0,0,354,2555,1,0,0,0,356,2560,1,0,0,0,358,2562,1,0,0,0,360,2588,1,0,0,
  	0,362,2617,1,0,0,0,364,2642,1,0,0,0,366,2644,1,0,0,0,368,2651,1,0,0,0,
  	370,2658,1,0,0,0,372,2709,1,0,0,0,374,2712,1,0,0,0,376,2723,1,0,0,0,378,
  	2757,1,0,0,0,380,2759,1,0,0,0,382,2762,1,0,0,0,384,2766,1,0,0,0,386,2771,
  	1,0,0,0,388,2778,1,0,0,0,390,2782,1,0,0,0,392,2786,1,0,0,0,394,2790,1,
  	0,0,0,396,2794,1,0,0,0,398,2799,1,0,0,0,400,2804,1,0,0,0,402,2809,1,0,
  	0,0,404,2814,1,0,0,0,406,2819,1,0,0,0,408,2927,1,0,0,0,410,2931,1,0,0,
  	0,412,2947,1,0,0,0,414,2950,1,0,0,0,416,2959,1,0,0,0,418,2993,1,0,0,0,
  	420,2995,1,0,0,0,422,2999,1,0,0,0,424,3003,1,0,0,0,426,3009,1,0,0,0,428,
  	3018,1,0,0,0,430,3022,1,0,0,0,432,3028,1,0,0,0,434,3042,1,0,0,0,436,3044,
  	1,0,0,0,438,3049,1,0,0,0,440,3054,1,0,0,0,442,3067,1,0,0,0,444,3072,1,
  	0,0,0,446,3077,1,0,0,0,448,3085,1,0,0,0,450,3090,1,0,0,0,452,3107,1,0,
  	0,0,454,3113,1,0,0,0,456,3148,1,0,0,0,458,3150,1,0,0,0,460,3158,1,0,0,
  	0,462,3166,1,0,0,0,464,3168,1,0,0,0,466,3179,1,0,0,0,468,3203,1,0,0,0,
  	470,3208,1,0,0,0,472,3220,1,0,0,0,474,3237,1,0,0,0,476,3245,1,0,0,0,478,
  	3256,1,0,0,0,480,3258,1,0,0,0,482,3282,1,0,0,0,484,3303,1,0,0,0,486,3316,
  	1,0,0,0,488,3375,1,0,0,0,490,3377,1,0,0,0,492,3379,1,0,0,0,494,495,3,
  	2,1,0,495,496,5,0,0,1,496,1,1,0,0,0,497,499,5,128,0,0,498,497,1,0,0,0,
  	499,502,1,0,0,0,500,498,1,0,0,0,500,501,1,0,0,0,501,512,1,0,0,0,502,500,
  	1,0,0,0,503,507,3,4,2,0,504,506,5,128,0,0,505,504,1,0,0,0,506,509,1,0,
  	0,0,507,505,1,0,0,0,507,508,1,0,0,0,508,511,1,0,0,0,509,507,1,0,0,0,510,
  	503,1,0,0,0,511,514,1,0,0,0,512,510,1,0,0,0,512,513,1,0,0,0,513,3,1,0,
  	0,0,514,512,1,0,0,0,515,521,3,6,3,0,516,521,3,32,16,0,517,521,3,74,37,
  	0,518,521,3,76,38,0,519,521,3,70,35,0,520,515,1,0,0,0,520,516,1,0,0,0,
  	520,517,1,0,0,0,520,518,1,0,0,0,520,519,1,0,0,0,521,5,1,0,0,0,522,524,
  	5,1,0,0,523,522,1,0,0,0,524,527,1,0,0,0,525,523,1,0,0,0,525,526,1,0,0,
  	0,526,528,1,0,0,0,527,525,1,0,0,0,528,529,3,26,13,0,529,530,5,75,0,0,
  	530,533,3,8,4,0,531,532,5,126,0,0,532,534,3,294,147,0,533,531,1,0,0,0,
  	533,534,1,0,0,0,534,542,1,0,0,0,535,543,5,86,0,0,536,538,5,128,0,0,537,
  	536,1,0,0,0,538,539,1,0,0,0,539,537,1,0,0,0,539,540,1,0,0,0,540,543,1,
  	0,0,0,541,543,5,0,0,1,542,535,1,0,0,0,542,537,1,0,0,0,542,541,1,0,0,0,
  	543,547,1,0,0,0,544,546,5,2,0,0,545,544,1,0,0,0,546,549,1,0,0,0,547,545,
  	1,0,0,0,547,548,1,0,0,0,548,608,1,0,0,0,549,547,1,0,0,0,550,552,5,1,0,
  	0,551,550,1,0,0,0,552,555,1,0,0,0,553,551,1,0,0,0,553,554,1,0,0,0,554,
  	556,1,0,0,0,555,553,1,0,0,0,556,557,3,26,13,0,557,558,5,75,0,0,558,561,
  	3,8,4,0,559,560,5,88,0,0,560,562,3,294,147,0,561,559,1,0,0,0,561,562,
  	1,0,0,0,562,570,1,0,0,0,563,571,5,86,0,0,564,566,5,128,0,0,565,564,1,
  	0,0,0,566,567,1,0,0,0,567,565,1,0,0,0,567,568,1,0,0,0,568,571,1,0,0,0,
  	569,571,5,0,0,1,570,563,1,0,0,0,570,565,1,0,0,0,570,569,1,0,0,0,571,575,
  	1,0,0,0,572,574,5,2,0,0,573,572,1,0,0,0,574,577,1,0,0,0,575,573,1,0,0,
  	0,575,576,1,0,0,0,576,608,1,0,0,0,577,575,1,0,0,0,578,580,5,1,0,0,579,
  	578,1,0,0,0,580,583,1,0,0,0,581,579,1,0,0,0,581,582,1,0,0,0,582,584,1,
  	0,0,0,583,581,1,0,0,0,584,585,3,26,13,0,585,586,5,75,0,0,586,590,3,8,
  	4,0,587,588,5,85,0,0,588,589,5,85,0,0,589,591,3,294,147,0,590,587,1,0,
  	0,0,590,591,1,0,0,0,591,599,1,0,0,0,592,600,5,86,0,0,593,595,5,128,0,
  	0,594,593,1,0,0,0,595,596,1,0,0,0,596,594,1,0,0,0,596,597,1,0,0,0,597,
  	600,1,0,0,0,598,600,5,0,0,1,599,592,1,0,0,0,599,594,1,0,0,0,599,598,1,
  	0,0,0,600,604,1,0,0,0,601,603,5,2,0,0,602,601,1,0,0,0,603,606,1,0,0,0,
  	604,602,1,0,0,0,604,605,1,0,0,0,605,608,1,0,0,0,606,604,1,0,0,0,607,525,
  	1,0,0,0,607,553,1,0,0,0,607,581,1,0,0,0,608,7,1,0,0,0,609,614,3,10,5,
  	0,610,611,5,91,0,0,611,613,3,10,5,0,612,610,1,0,0,0,613,616,1,0,0,0,614,
  	612,1,0,0,0,614,615,1,0,0,0,615,9,1,0,0,0,616,614,1,0,0,0,617,621,3,12,
  	6,0,618,620,3,12,6,0,619,618,1,0,0,0,620,623,1,0,0,0,621,619,1,0,0,0,
  	621,622,1,0,0,0,622,11,1,0,0,0,623,621,1,0,0,0,624,630,3,22,11,0,625,
  	630,3,14,7,0,626,630,3,16,8,0,627,630,3,18,9,0,628,630,3,20,10,0,629,
  	624,1,0,0,0,629,625,1,0,0,0,629,626,1,0,0,0,629,627,1,0,0,0,629,628,1,
  	0,0,0,630,13,1,0,0,0,631,632,3,22,11,0,632,633,5,81,0,0,633,15,1,0,0,
  	0,634,635,3,22,11,0,635,636,5,96,0,0,636,17,1,0,0,0,637,638,3,22,11,0,
  	638,639,5,76,0,0,639,19,1,0,0,0,640,641,3,22,11,0,641,642,5,102,0,0,642,
  	643,3,294,147,0,643,644,5,103,0,0,644,657,1,0,0,0,645,646,3,22,11,0,646,
  	648,5,102,0,0,647,649,3,294,147,0,648,647,1,0,0,0,648,649,1,0,0,0,649,
  	650,1,0,0,0,650,652,5,84,0,0,651,653,3,294,147,0,652,651,1,0,0,0,652,
  	653,1,0,0,0,653,654,1,0,0,0,654,655,5,103,0,0,655,657,1,0,0,0,656,640,
  	1,0,0,0,656,645,1,0,0,0,657,21,1,0,0,0,658,668,3,24,12,0,659,668,3,420,
  	210,0,660,668,5,8,0,0,661,668,3,28,14,0,662,668,3,30,15,0,663,664,5,82,
  	0,0,664,665,3,8,4,0,665,666,5,83,0,0,666,668,1,0,0,0,667,658,1,0,0,0,
  	667,659,1,0,0,0,667,660,1,0,0,0,667,661,1,0,0,0,667,662,1,0,0,0,667,663,
  	1,0,0,0,668,23,1,0,0,0,669,678,5,104,0,0,670,671,3,492,246,0,671,672,
  	5,85,0,0,672,674,1,0,0,0,673,670,1,0,0,0,673,674,1,0,0,0,674,675,1,0,
  	0,0,675,676,3,492,246,0,676,677,5,85,0,0,677,679,1,0,0,0,678,673,1,0,
  	0,0,678,679,1,0,0,0,679,680,1,0,0,0,680,681,3,492,246,0,681,682,5,105,
  	0,0,682,25,1,0,0,0,683,684,5,104,0,0,684,685,3,492,246,0,685,686,5,105,
  	0,0,686,27,1,0,0,0,687,688,6,14,-1,0,688,689,3,492,246,0,689,708,1,0,
  	0,0,690,691,10,4,0,0,691,692,5,80,0,0,692,707,3,492,246,0,693,694,10,
  	3,0,0,694,695,5,89,0,0,695,696,3,360,180,0,696,697,5,90,0,0,697,707,1,
  	0,0,0,698,699,10,2,0,0,699,707,3,446,223,0,700,701,10,1,0,0,701,703,5,
  	82,0,0,702,704,3,450,225,0,703,702,1,0,0,0,703,704,1,0,0,0,704,705,1,
  	0,0,0,705,707,5,83,0,0,706,690,1,0,0,0,706,693,1,0,0,0,706,698,1,0,0,
  	0,706,700,1,0,0,0,707,710,1,0,0,0,708,706,1,0,0,0,708,709,1,0,0,0,709,
  	29,1,0,0,0,710,708,1,0,0,0,711,713,5,89,0,0,712,714,5,92,0,0,713,712,
  	1,0,0,0,713,714,1,0,0,0,714,715,1,0,0,0,715,716,3,420,210,0,716,717,5,
  	90,0,0,717,31,1,0,0,0,718,720,5,1,0,0,719,718,1,0,0,0,720,723,1,0,0,0,
  	721,719,1,0,0,0,721,722,1,0,0,0,722,724,1,0,0,0,723,721,1,0,0,0,724,725,
  	5,49,0,0,725,729,3,34,17,0,726,728,5,2,0,0,727,726,1,0,0,0,728,731,1,
  	0,0,0,729,727,1,0,0,0,729,730,1,0,0,0,730,782,1,0,0,0,731,729,1,0,0,0,
  	732,734,5,1,0,0,733,732,1,0,0,0,734,737,1,0,0,0,735,733,1,0,0,0,735,736,
  	1,0,0,0,736,738,1,0,0,0,737,735,1,0,0,0,738,739,5,55,0,0,739,747,3,48,
  	24,0,740,748,5,86,0,0,741,743,5,128,0,0,742,741,1,0,0,0,743,744,1,0,0,
  	0,744,742,1,0,0,0,744,745,1,0,0,0,745,748,1,0,0,0,746,748,5,0,0,1,747,
  	740,1,0,0,0,747,742,1,0,0,0,747,746,1,0,0,0,748,752,1,0,0,0,749,751,5,
  	2,0,0,750,749,1,0,0,0,751,754,1,0,0,0,752,750,1,0,0,0,752,753,1,0,0,0,
  	753,782,1,0,0,0,754,752,1,0,0,0,755,757,5,1,0,0,756,755,1,0,0,0,757,760,
  	1,0,0,0,758,756,1,0,0,0,758,759,1,0,0,0,759,761,1,0,0,0,760,758,1,0,0,
  	0,761,762,5,54,0,0,762,770,3,48,24,0,763,771,5,86,0,0,764,766,5,128,0,
  	0,765,764,1,0,0,0,766,767,1,0,0,0,767,765,1,0,0,0,767,768,1,0,0,0,768,
  	771,1,0,0,0,769,771,5,0,0,1,770,763,1,0,0,0,770,765,1,0,0,0,770,769,1,
  	0,0,0,771,775,1,0,0,0,772,774,5,2,0,0,773,772,1,0,0,0,774,777,1,0,0,0,
  	775,773,1,0,0,0,775,776,1,0,0,0,776,782,1,0,0,0,777,775,1,0,0,0,778,779,
  	3,34,17,0,779,780,5,86,0,0,780,782,1,0,0,0,781,721,1,0,0,0,781,735,1,
  	0,0,0,781,758,1,0,0,0,781,778,1,0,0,0,782,33,1,0,0,0,783,784,3,40,20,
  	0,784,785,5,112,0,0,785,786,3,40,20,0,786,787,7,0,0,0,787,790,1,0,0,0,
  	788,790,3,36,18,0,789,783,1,0,0,0,789,788,1,0,0,0,790,35,1,0,0,0,791,
  	792,5,52,0,0,792,793,3,26,13,0,793,794,5,33,0,0,794,795,3,56,28,0,795,
  	802,5,85,0,0,796,797,5,128,0,0,797,798,5,1,0,0,798,799,3,36,18,0,799,
  	800,5,2,0,0,800,803,1,0,0,0,801,803,3,36,18,0,802,796,1,0,0,0,802,801,
  	1,0,0,0,803,1000,1,0,0,0,804,805,5,53,0,0,805,806,3,26,13,0,806,807,5,
  	33,0,0,807,808,3,56,28,0,808,815,5,85,0,0,809,810,5,128,0,0,810,811,5,
  	1,0,0,811,812,3,36,18,0,812,813,5,2,0,0,813,816,1,0,0,0,814,816,3,36,
  	18,0,815,809,1,0,0,0,815,814,1,0,0,0,816,1000,1,0,0,0,817,818,5,56,0,
  	0,818,819,5,82,0,0,819,820,3,38,19,0,820,823,5,28,0,0,821,824,3,26,13,
  	0,822,824,3,492,246,0,823,821,1,0,0,0,823,822,1,0,0,0,824,825,1,0,0,0,
  	825,826,5,33,0,0,826,827,3,54,27,0,827,835,5,83,0,0,828,836,5,86,0,0,
  	829,831,5,128,0,0,830,829,1,0,0,0,831,832,1,0,0,0,832,830,1,0,0,0,832,
  	833,1,0,0,0,833,836,1,0,0,0,834,836,5,0,0,1,835,828,1,0,0,0,835,830,1,
  	0,0,0,835,834,1,0,0,0,836,1000,1,0,0,0,837,838,5,56,0,0,838,839,5,82,
  	0,0,839,840,5,89,0,0,840,841,3,38,19,0,841,844,5,28,0,0,842,845,3,26,
  	13,0,843,845,3,492,246,0,844,842,1,0,0,0,844,843,1,0,0,0,845,846,1,0,
  	0,0,846,847,5,33,0,0,847,848,3,54,27,0,848,849,5,90,0,0,849,857,5,83,
  	0,0,850,858,5,86,0,0,851,853,5,128,0,0,852,851,1,0,0,0,853,854,1,0,0,
  	0,854,852,1,0,0,0,854,855,1,0,0,0,855,858,1,0,0,0,856,858,5,0,0,1,857,
  	850,1,0,0,0,857,852,1,0,0,0,857,856,1,0,0,0,858,1000,1,0,0,0,859,860,
  	5,56,0,0,860,861,5,82,0,0,861,862,5,82,0,0,862,863,3,38,19,0,863,866,
  	5,28,0,0,864,867,3,26,13,0,865,867,3,492,246,0,866,864,1,0,0,0,866,865,
  	1,0,0,0,867,868,1,0,0,0,868,869,5,33,0,0,869,870,3,54,27,0,870,871,5,
  	90,0,0,871,879,5,83,0,0,872,880,5,86,0,0,873,875,5,128,0,0,874,873,1,
  	0,0,0,875,876,1,0,0,0,876,874,1,0,0,0,876,877,1,0,0,0,877,880,1,0,0,0,
  	878,880,5,0,0,1,879,872,1,0,0,0,879,874,1,0,0,0,879,878,1,0,0,0,880,1000,
  	1,0,0,0,881,882,5,56,0,0,882,883,5,82,0,0,883,884,5,102,0,0,884,885,3,
  	38,19,0,885,888,5,28,0,0,886,889,3,26,13,0,887,889,3,492,246,0,888,886,
  	1,0,0,0,888,887,1,0,0,0,889,890,1,0,0,0,890,891,5,33,0,0,891,892,3,54,
  	27,0,892,893,5,103,0,0,893,901,5,83,0,0,894,902,5,86,0,0,895,897,5,128,
  	0,0,896,895,1,0,0,0,897,898,1,0,0,0,898,896,1,0,0,0,898,899,1,0,0,0,899,
  	902,1,0,0,0,900,902,5,0,0,1,901,894,1,0,0,0,901,896,1,0,0,0,901,900,1,
  	0,0,0,902,1000,1,0,0,0,903,904,5,57,0,0,904,905,5,82,0,0,905,906,3,38,
  	19,0,906,909,5,28,0,0,907,910,3,26,13,0,908,910,3,492,246,0,909,907,1,
  	0,0,0,909,908,1,0,0,0,910,911,1,0,0,0,911,912,5,33,0,0,912,913,3,54,27,
  	0,913,921,5,83,0,0,914,922,5,86,0,0,915,917,5,128,0,0,916,915,1,0,0,0,
  	917,918,1,0,0,0,918,916,1,0,0,0,918,919,1,0,0,0,919,922,1,0,0,0,920,922,
  	5,0,0,1,921,914,1,0,0,0,921,916,1,0,0,0,921,920,1,0,0,0,922,1000,1,0,
  	0,0,923,924,5,57,0,0,924,925,5,82,0,0,925,926,5,82,0,0,926,927,3,38,19,
  	0,927,930,5,28,0,0,928,931,3,26,13,0,929,931,3,492,246,0,930,928,1,0,
  	0,0,930,929,1,0,0,0,931,932,1,0,0,0,932,933,5,33,0,0,933,934,3,54,27,
  	0,934,935,5,83,0,0,935,943,5,83,0,0,936,944,5,86,0,0,937,939,5,128,0,
  	0,938,937,1,0,0,0,939,940,1,0,0,0,940,938,1,0,0,0,940,941,1,0,0,0,941,
  	944,1,0,0,0,942,944,5,0,0,1,943,936,1,0,0,0,943,938,1,0,0,0,943,942,1,
  	0,0,0,944,1000,1,0,0,0,945,946,5,57,0,0,946,947,5,82,0,0,947,948,5,89,
  	0,0,948,949,3,38,19,0,949,952,5,28,0,0,950,953,3,26,13,0,951,953,3,492,
  	246,0,952,950,1,0,0,0,952,951,1,0,0,0,953,954,1,0,0,0,954,955,5,33,0,
  	0,955,956,3,54,27,0,956,957,5,90,0,0,957,965,5,83,0,0,958,966,5,86,0,
  	0,959,961,5,128,0,0,960,959,1,0,0,0,961,962,1,0,0,0,962,960,1,0,0,0,962,
  	963,1,0,0,0,963,966,1,0,0,0,964,966,5,0,0,1,965,958,1,0,0,0,965,960,1,
  	0,0,0,965,964,1,0,0,0,966,1000,1,0,0,0,967,968,5,57,0,0,968,969,5,82,
  	0,0,969,970,5,102,0,0,970,971,3,38,19,0,971,974,5,28,0,0,972,975,3,26,
  	13,0,973,975,3,492,246,0,974,972,1,0,0,0,974,973,1,0,0,0,975,976,1,0,
  	0,0,976,977,5,33,0,0,977,978,3,54,27,0,978,979,5,103,0,0,979,987,5,83,
  	0,0,980,988,5,86,0,0,981,983,5,128,0,0,982,981,1,0,0,0,983,984,1,0,0,
  	0,984,982,1,0,0,0,984,985,1,0,0,0,985,988,1,0,0,0,986,988,5,0,0,1,987,
  	980,1,0,0,0,987,982,1,0,0,0,987,986,1,0,0,0,988,1000,1,0,0,0,989,997,
  	3,40,20,0,990,998,5,86,0,0,991,993,5,128,0,0,992,991,1,0,0,0,993,994,
  	1,0,0,0,994,992,1,0,0,0,994,995,1,0,0,0,995,998,1,0,0,0,996,998,5,0,0,
  	1,997,990,1,0,0,0,997,992,1,0,0,0,997,996,1,0,0,0,998,1000,1,0,0,0,999,
  	791,1,0,0,0,999,804,1,0,0,0,999,817,1,0,0,0,999,837,1,0,0,0,999,859,1,
  	0,0,0,999,881,1,0,0,0,999,903,1,0,0,0,999,923,1,0,0,0,999,945,1,0,0,0,
  	999,967,1,0,0,0,999,989,1,0,0,0,1000,37,1,0,0,0,1001,1002,5,56,0,0,1002,
  	1003,5,82,0,0,1003,1004,3,38,19,0,1004,1007,5,28,0,0,1005,1008,3,26,13,
  	0,1006,1008,3,492,246,0,1007,1005,1,0,0,0,1007,1006,1,0,0,0,1008,1009,
  	1,0,0,0,1009,1010,5,33,0,0,1010,1011,3,54,27,0,1011,1012,5,83,0,0,1012,
  	1111,1,0,0,0,1013,1014,5,56,0,0,1014,1015,5,82,0,0,1015,1016,5,89,0,0,
  	1016,1017,3,38,19,0,1017,1020,5,28,0,0,1018,1021,3,26,13,0,1019,1021,
  	3,492,246,0,1020,1018,1,0,0,0,1020,1019,1,0,0,0,1021,1022,1,0,0,0,1022,
  	1023,5,33,0,0,1023,1024,3,54,27,0,1024,1025,5,90,0,0,1025,1026,5,83,0,
  	0,1026,1111,1,0,0,0,1027,1028,5,56,0,0,1028,1029,5,82,0,0,1029,1030,5,
  	82,0,0,1030,1031,3,38,19,0,1031,1034,5,28,0,0,1032,1035,3,26,13,0,1033,
  	1035,3,492,246,0,1034,1032,1,0,0,0,1034,1033,1,0,0,0,1035,1036,1,0,0,
  	0,1036,1037,5,33,0,0,1037,1038,3,54,27,0,1038,1039,5,90,0,0,1039,1040,
  	5,83,0,0,1040,1111,1,0,0,0,1041,1042,5,56,0,0,1042,1043,5,82,0,0,1043,
  	1044,5,102,0,0,1044,1045,3,38,19,0,1045,1048,5,28,0,0,1046,1049,3,26,
  	13,0,1047,1049,3,492,246,0,1048,1046,1,0,0,0,1048,1047,1,0,0,0,1049,1050,
  	1,0,0,0,1050,1051,5,33,0,0,1051,1052,3,54,27,0,1052,1053,5,103,0,0,1053,
  	1054,5,83,0,0,1054,1111,1,0,0,0,1055,1056,5,57,0,0,1056,1057,5,82,0,0,
  	1057,1058,3,38,19,0,1058,1061,5,28,0,0,1059,1062,3,26,13,0,1060,1062,
  	3,492,246,0,1061,1059,1,0,0,0,1061,1060,1,0,0,0,1062,1063,1,0,0,0,1063,
  	1064,5,33,0,0,1064,1065,3,54,27,0,1065,1066,5,83,0,0,1066,1111,1,0,0,
  	0,1067,1068,5,57,0,0,1068,1069,5,82,0,0,1069,1070,5,82,0,0,1070,1071,
  	3,38,19,0,1071,1074,5,28,0,0,1072,1075,3,26,13,0,1073,1075,3,492,246,
  	0,1074,1072,1,0,0,0,1074,1073,1,0,0,0,1075,1076,1,0,0,0,1076,1077,5,33,
  	0,0,1077,1078,3,54,27,0,1078,1079,5,83,0,0,1079,1080,5,83,0,0,1080,1111,
  	1,0,0,0,1081,1082,5,57,0,0,1082,1083,5,82,0,0,1083,1084,5,89,0,0,1084,
  	1085,3,38,19,0,1085,1088,5,28,0,0,1086,1089,3,26,13,0,1087,1089,3,492,
  	246,0,1088,1086,1,0,0,0,1088,1087,1,0,0,0,1089,1090,1,0,0,0,1090,1091,
  	5,33,0,0,1091,1092,3,54,27,0,1092,1093,5,90,0,0,1093,1094,5,83,0,0,1094,
  	1111,1,0,0,0,1095,1096,5,57,0,0,1096,1097,5,82,0,0,1097,1098,5,102,0,
  	0,1098,1099,3,38,19,0,1099,1102,5,28,0,0,1100,1103,3,26,13,0,1101,1103,
  	3,492,246,0,1102,1100,1,0,0,0,1102,1101,1,0,0,0,1103,1104,1,0,0,0,1104,
  	1105,5,33,0,0,1105,1106,3,54,27,0,1106,1107,5,103,0,0,1107,1108,5,83,
  	0,0,1108,1111,1,0,0,0,1109,1111,3,40,20,0,1110,1001,1,0,0,0,1110,1013,
  	1,0,0,0,1110,1027,1,0,0,0,1110,1041,1,0,0,0,1110,1055,1,0,0,0,1110,1067,
  	1,0,0,0,1110,1081,1,0,0,0,1110,1095,1,0,0,0,1110,1109,1,0,0,0,1111,39,
  	1,0,0,0,1112,1117,3,42,21,0,1113,1114,5,41,0,0,1114,1116,3,42,21,0,1115,
  	1113,1,0,0,0,1116,1119,1,0,0,0,1117,1115,1,0,0,0,1117,1118,1,0,0,0,1118,
  	41,1,0,0,0,1119,1117,1,0,0,0,1120,1125,3,44,22,0,1121,1122,5,12,0,0,1122,
  	1124,3,44,22,0,1123,1121,1,0,0,0,1124,1127,1,0,0,0,1125,1123,1,0,0,0,
  	1125,1126,1,0,0,0,1126,43,1,0,0,0,1127,1125,1,0,0,0,1128,1135,3,46,23,
  	0,1129,1130,5,82,0,0,1130,1131,3,34,17,0,1131,1132,5,83,0,0,1132,1135,
  	1,0,0,0,1133,1135,3,48,24,0,1134,1128,1,0,0,0,1134,1129,1,0,0,0,1134,
  	1133,1,0,0,0,1135,45,1,0,0,0,1136,1137,3,48,24,0,1137,1138,7,1,0,0,1138,
  	1139,3,48,24,0,1139,47,1,0,0,0,1140,1149,3,50,25,0,1141,1149,3,314,157,
  	0,1142,1143,3,314,157,0,1143,1144,5,31,0,0,1144,1145,3,314,157,0,1145,
  	1146,5,24,0,0,1146,1147,3,314,157,0,1147,1149,1,0,0,0,1148,1140,1,0,0,
  	0,1148,1141,1,0,0,0,1148,1142,1,0,0,0,1149,49,1,0,0,0,1150,1151,5,91,
  	0,0,1151,1152,3,56,28,0,1152,1153,5,91,0,0,1153,1161,1,0,0,0,1154,1155,
  	5,58,0,0,1155,1156,5,82,0,0,1156,1157,3,54,27,0,1157,1158,5,83,0,0,1158,
  	1161,1,0,0,0,1159,1161,3,52,26,0,1160,1150,1,0,0,0,1160,1154,1,0,0,0,
  	1160,1159,1,0,0,0,1161,51,1,0,0,0,1162,1165,3,54,27,0,1163,1165,3,56,
  	28,0,1164,1162,1,0,0,0,1164,1163,1,0,0,0,1165,53,1,0,0,0,1166,1167,5,
  	81,0,0,1167,1171,3,56,28,0,1168,1169,5,87,0,0,1169,1171,3,56,28,0,1170,
  	1166,1,0,0,0,1170,1168,1,0,0,0,1171,55,1,0,0,0,1172,1173,6,28,-1,0,1173,
  	1174,3,58,29,0,1174,1183,1,0,0,0,1175,1176,10,2,0,0,1176,1177,5,80,0,
  	0,1177,1182,3,58,29,0,1178,1179,10,1,0,0,1179,1180,5,79,0,0,1180,1182,
  	3,58,29,0,1181,1175,1,0,0,0,1181,1178,1,0,0,0,1182,1185,1,0,0,0,1183,
  	1181,1,0,0,0,1183,1184,1,0,0,0,1184,57,1,0,0,0,1185,1183,1,0,0,0,1186,
  	1187,3,60,30,0,1187,1188,5,89,0,0,1188,1189,3,66,33,0,1189,1190,5,90,
  	0,0,1190,1198,1,0,0,0,1191,1192,3,60,30,0,1192,1193,5,102,0,0,1193,1194,
  	3,62,31,0,1194,1195,5,103,0,0,1195,1198,1,0,0,0,1196,1198,3,60,30,0,1197,
  	1186,1,0,0,0,1197,1191,1,0,0,0,1197,1196,1,0,0,0,1198,59,1,0,0,0,1199,
  	1205,3,26,13,0,1200,1201,5,82,0,0,1201,1202,3,56,28,0,1202,1203,5,83,
  	0,0,1203,1205,1,0,0,0,1204,1199,1,0,0,0,1204,1200,1,0,0,0,1205,61,1,0,
  	0,0,1206,1211,3,64,32,0,1207,1208,5,84,0,0,1208,1210,3,64,32,0,1209,1207,
  	1,0,0,0,1210,1213,1,0,0,0,1211,1209,1,0,0,0,1211,1212,1,0,0,0,1212,1215,
  	1,0,0,0,1213,1211,1,0,0,0,1214,1216,5,84,0,0,1215,1214,1,0,0,0,1215,1216,
  	1,0,0,0,1216,63,1,0,0,0,1217,1218,5,81,0,0,1218,1221,3,26,13,0,1219,1220,
  	5,85,0,0,1220,1222,3,68,34,0,1221,1219,1,0,0,0,1221,1222,1,0,0,0,1222,
  	65,1,0,0,0,1223,1228,3,68,34,0,1224,1225,5,84,0,0,1225,1227,3,68,34,0,
  	1226,1224,1,0,0,0,1227,1230,1,0,0,0,1228,1226,1,0,0,0,1228,1229,1,0,0,
  	0,1229,1232,1,0,0,0,1230,1228,1,0,0,0,1231,1233,5,84,0,0,1232,1231,1,
  	0,0,0,1232,1233,1,0,0,0,1233,67,1,0,0,0,1234,1254,5,8,0,0,1235,1237,5,
  	8,0,0,1236,1235,1,0,0,0,1236,1237,1,0,0,0,1237,1238,1,0,0,0,1238,1240,
  	5,85,0,0,1239,1241,5,8,0,0,1240,1239,1,0,0,0,1240,1241,1,0,0,0,1241,1254,
  	1,0,0,0,1242,1244,5,8,0,0,1243,1242,1,0,0,0,1243,1244,1,0,0,0,1244,1245,
  	1,0,0,0,1245,1247,5,85,0,0,1246,1248,5,8,0,0,1247,1246,1,0,0,0,1247,1248,
  	1,0,0,0,1248,1249,1,0,0,0,1249,1251,5,85,0,0,1250,1252,5,8,0,0,1251,1250,
  	1,0,0,0,1251,1252,1,0,0,0,1252,1254,1,0,0,0,1253,1234,1,0,0,0,1253,1236,
  	1,0,0,0,1253,1243,1,0,0,0,1254,69,1,0,0,0,1255,1258,3,106,53,0,1256,1258,
  	3,104,52,0,1257,1255,1,0,0,0,1257,1256,1,0,0,0,1258,71,1,0,0,0,1259,1261,
  	5,128,0,0,1260,1259,1,0,0,0,1261,1264,1,0,0,0,1262,1260,1,0,0,0,1262,
  	1263,1,0,0,0,1263,1265,1,0,0,0,1264,1262,1,0,0,0,1265,1269,3,98,49,0,
  	1266,1268,5,128,0,0,1267,1266,1,0,0,0,1268,1271,1,0,0,0,1269,1267,1,0,
  	0,0,1269,1270,1,0,0,0,1270,73,1,0,0,0,1271,1269,1,0,0,0,1272,1273,5,34,
  	0,0,1273,1274,5,82,0,0,1274,1275,5,7,0,0,1275,1276,5,83,0,0,1276,1277,
  	5,128,0,0,1277,75,1,0,0,0,1278,1280,5,1,0,0,1279,1278,1,0,0,0,1280,1283,
  	1,0,0,0,1281,1279,1,0,0,0,1281,1282,1,0,0,0,1282,1284,1,0,0,0,1283,1281,
  	1,0,0,0,1284,1285,5,59,0,0,1285,1289,3,78,39,0,1286,1288,5,2,0,0,1287,
  	1286,1,0,0,0,1288,1291,1,0,0,0,1289,1287,1,0,0,0,1289,1290,1,0,0,0,1290,
  	77,1,0,0,0,1291,1289,1,0,0,0,1292,1296,3,80,40,0,1293,1295,3,82,41,0,
  	1294,1293,1,0,0,0,1295,1298,1,0,0,0,1296,1294,1,0,0,0,1296,1297,1,0,0,
  	0,1297,79,1,0,0,0,1298,1296,1,0,0,0,1299,1306,3,26,13,0,1300,1301,5,60,
  	0,0,1301,1302,5,82,0,0,1302,1303,5,61,0,0,1303,1306,5,83,0,0,1304,1306,
  	5,81,0,0,1305,1299,1,0,0,0,1305,1300,1,0,0,0,1305,1304,1,0,0,0,1306,81,
  	1,0,0,0,1307,1309,3,84,42,0,1308,1310,5,130,0,0,1309,1308,1,0,0,0,1309,
  	1310,1,0,0,0,1310,1312,1,0,0,0,1311,1313,5,88,0,0,1312,1311,1,0,0,0,1312,
  	1313,1,0,0,0,1313,1315,1,0,0,0,1314,1316,5,130,0,0,1315,1314,1,0,0,0,
  	1315,1316,1,0,0,0,1316,1317,1,0,0,0,1317,1319,3,86,43,0,1318,1320,5,130,
  	0,0,1319,1318,1,0,0,0,1319,1320,1,0,0,0,1320,83,1,0,0,0,1321,1322,5,62,
  	0,0,1322,85,1,0,0,0,1323,1324,3,230,115,0,1324,87,1,0,0,0,1325,1327,3,
  	96,48,0,1326,1325,1,0,0,0,1326,1327,1,0,0,0,1327,1329,1,0,0,0,1328,1330,
  	5,0,0,1,1329,1328,1,0,0,0,1329,1330,1,0,0,0,1330,89,1,0,0,0,1331,1332,
  	3,100,50,0,1332,91,1,0,0,0,1333,1337,3,292,146,0,1334,1336,5,128,0,0,
  	1335,1334,1,0,0,0,1336,1339,1,0,0,0,1337,1335,1,0,0,0,1337,1338,1,0,0,
  	0,1338,1341,1,0,0,0,1339,1337,1,0,0,0,1340,1342,5,0,0,1,1341,1340,1,0,
  	0,0,1341,1342,1,0,0,0,1342,93,1,0,0,0,1343,1345,5,82,0,0,1344,1346,3,
  	488,244,0,1345,1344,1,0,0,0,1345,1346,1,0,0,0,1346,1347,1,0,0,0,1347,
  	1348,5,83,0,0,1348,1349,5,112,0,0,1349,1353,3,294,147,0,1350,1352,5,128,
  	0,0,1351,1350,1,0,0,0,1352,1355,1,0,0,0,1353,1351,1,0,0,0,1353,1354,1,
  	0,0,0,1354,1357,1,0,0,0,1355,1353,1,0,0,0,1356,1358,5,0,0,1,1357,1356,
  	1,0,0,0,1357,1358,1,0,0,0,1358,95,1,0,0,0,1359,1362,3,98,49,0,1360,1362,
  	5,128,0,0,1361,1359,1,0,0,0,1361,1360,1,0,0,0,1362,1363,1,0,0,0,1363,
  	1361,1,0,0,0,1363,1364,1,0,0,0,1364,97,1,0,0,0,1365,1368,3,106,53,0,1366,
  	1368,3,102,51,0,1367,1365,1,0,0,0,1367,1366,1,0,0,0,1368,99,1,0,0,0,1369,
  	1370,3,106,53,0,1370,1371,5,128,0,0,1371,1375,1,0,0,0,1372,1375,3,102,
  	51,0,1373,1375,5,128,0,0,1374,1369,1,0,0,0,1374,1372,1,0,0,0,1374,1373,
  	1,0,0,0,1375,101,1,0,0,0,1376,1381,3,104,52,0,1377,1378,5,86,0,0,1378,
  	1380,3,104,52,0,1379,1377,1,0,0,0,1380,1383,1,0,0,0,1381,1379,1,0,0,0,
  	1381,1382,1,0,0,0,1382,1385,1,0,0,0,1383,1381,1,0,0,0,1384,1386,5,86,
  	0,0,1385,1384,1,0,0,0,1385,1386,1,0,0,0,1386,1399,1,0,0,0,1387,1389,5,
  	128,0,0,1388,1387,1,0,0,0,1389,1390,1,0,0,0,1390,1388,1,0,0,0,1390,1391,
  	1,0,0,0,1391,1400,1,0,0,0,1392,1394,5,128,0,0,1393,1392,1,0,0,0,1394,
  	1397,1,0,0,0,1395,1393,1,0,0,0,1395,1396,1,0,0,0,1396,1398,1,0,0,0,1397,
  	1395,1,0,0,0,1398,1400,5,0,0,1,1399,1388,1,0,0,0,1399,1395,1,0,0,0,1400,
  	103,1,0,0,0,1401,1416,3,108,54,0,1402,1416,3,282,141,0,1403,1416,3,298,
  	149,0,1404,1416,3,114,57,0,1405,1416,3,128,64,0,1406,1416,3,116,58,0,
  	1407,1416,5,42,0,0,1408,1416,3,122,61,0,1409,1416,3,124,62,0,1410,1416,
  	3,126,63,0,1411,1416,5,17,0,0,1412,1416,5,20,0,0,1413,1416,3,118,59,0,
  	1414,1416,3,120,60,0,1415,1401,1,0,0,0,1415,1402,1,0,0,0,1415,1403,1,
  	0,0,0,1415,1404,1,0,0,0,1415,1405,1,0,0,0,1415,1406,1,0,0,0,1415,1407,
  	1,0,0,0,1415,1408,1,0,0,0,1415,1409,1,0,0,0,1415,1410,1,0,0,0,1415,1411,
  	1,0,0,0,1415,1412,1,0,0,0,1415,1413,1,0,0,0,1415,1414,1,0,0,0,1416,105,
  	1,0,0,0,1417,1426,3,154,77,0,1418,1426,3,188,94,0,1419,1426,3,150,75,
  	0,1420,1426,3,198,99,0,1421,1426,3,196,98,0,1422,1426,3,202,101,0,1423,
  	1426,3,194,97,0,1424,1426,3,210,105,0,1425,1417,1,0,0,0,1425,1418,1,0,
  	0,0,1425,1419,1,0,0,0,1425,1420,1,0,0,0,1425,1421,1,0,0,0,1425,1422,1,
  	0,0,0,1425,1423,1,0,0,0,1425,1424,1,0,0,0,1426,107,1,0,0,0,1427,1428,
  	3,492,246,0,1428,1429,5,85,0,0,1429,1432,3,294,147,0,1430,1431,5,88,0,
  	0,1431,1433,3,110,55,0,1432,1430,1,0,0,0,1432,1433,1,0,0,0,1433,1465,
  	1,0,0,0,1434,1435,5,82,0,0,1435,1436,3,476,238,0,1436,1437,5,83,0,0,1437,
  	1440,1,0,0,0,1438,1440,3,478,239,0,1439,1434,1,0,0,0,1439,1438,1,0,0,
  	0,1440,1441,1,0,0,0,1441,1442,5,85,0,0,1442,1445,3,294,147,0,1443,1444,
  	5,88,0,0,1444,1446,3,110,55,0,1445,1443,1,0,0,0,1445,1446,1,0,0,0,1446,
  	1465,1,0,0,0,1447,1448,3,464,232,0,1448,1449,5,88,0,0,1449,1451,1,0,0,
  	0,1450,1447,1,0,0,0,1451,1452,1,0,0,0,1452,1450,1,0,0,0,1452,1453,1,0,
  	0,0,1453,1456,1,0,0,0,1454,1457,3,296,148,0,1455,1457,3,298,149,0,1456,
  	1454,1,0,0,0,1456,1455,1,0,0,0,1457,1465,1,0,0,0,1458,1459,3,476,238,
  	0,1459,1462,3,112,56,0,1460,1463,3,296,148,0,1461,1463,3,298,149,0,1462,
  	1460,1,0,0,0,1462,1461,1,0,0,0,1463,1465,1,0,0,0,1464,1427,1,0,0,0,1464,
  	1439,1,0,0,0,1464,1450,1,0,0,0,1464,1458,1,0,0,0,1465,109,1,0,0,0,1466,
  	1469,3,296,148,0,1467,1469,3,298,149,0,1468,1466,1,0,0,0,1468,1467,1,
  	0,0,0,1469,111,1,0,0,0,1470,1471,7,2,0,0,1471,113,1,0,0,0,1472,1474,5,
  	44,0,0,1473,1475,3,298,149,0,1474,1473,1,0,0,0,1474,1475,1,0,0,0,1475,
  	115,1,0,0,0,1476,1477,5,43,0,0,1477,1480,3,294,147,0,1478,1479,5,29,0,
  	0,1479,1481,3,294,147,0,1480,1478,1,0,0,0,1480,1481,1,0,0,0,1481,1484,
  	1,0,0,0,1482,1484,5,43,0,0,1483,1476,1,0,0,0,1483,1482,1,0,0,0,1484,117,
  	1,0,0,0,1485,1486,5,30,0,0,1486,1491,3,492,246,0,1487,1488,5,84,0,0,1488,
  	1490,3,492,246,0,1489,1487,1,0,0,0,1490,1493,1,0,0,0,1491,1489,1,0,0,
  	0,1491,1492,1,0,0,0,1492,119,1,0,0,0,1493,1491,1,0,0,0,1494,1495,5,39,
  	0,0,1495,1500,3,492,246,0,1496,1497,5,84,0,0,1497,1499,3,492,246,0,1498,
  	1496,1,0,0,0,1499,1502,1,0,0,0,1500,1498,1,0,0,0,1500,1501,1,0,0,0,1501,
  	121,1,0,0,0,1502,1500,1,0,0,0,1503,1504,5,22,0,0,1504,1505,3,482,241,
  	0,1505,123,1,0,0,0,1506,1507,3,296,148,0,1507,125,1,0,0,0,1508,1509,5,
  	14,0,0,1509,1512,3,294,147,0,1510,1511,5,84,0,0,1511,1513,3,294,147,0,
  	1512,1510,1,0,0,0,1512,1513,1,0,0,0,1513,127,1,0,0,0,1514,1517,3,130,
  	65,0,1515,1517,3,132,66,0,1516,1514,1,0,0,0,1516,1515,1,0,0,0,1517,129,
  	1,0,0,0,1518,1519,5,32,0,0,1519,1520,3,140,70,0,1520,131,1,0,0,0,1521,
  	1525,5,29,0,0,1522,1524,7,3,0,0,1523,1522,1,0,0,0,1524,1527,1,0,0,0,1525,
  	1523,1,0,0,0,1525,1526,1,0,0,0,1526,1528,1,0,0,0,1527,1525,1,0,0,0,1528,
  	1529,3,144,72,0,1529,1530,5,32,0,0,1530,1531,3,134,67,0,1531,1541,1,0,
  	0,0,1532,1534,5,29,0,0,1533,1535,7,3,0,0,1534,1533,1,0,0,0,1535,1536,
  	1,0,0,0,1536,1534,1,0,0,0,1536,1537,1,0,0,0,1537,1538,1,0,0,0,1538,1539,
  	5,32,0,0,1539,1541,3,134,67,0,1540,1521,1,0,0,0,1540,1532,1,0,0,0,1541,
  	133,1,0,0,0,1542,1543,5,82,0,0,1543,1545,3,136,68,0,1544,1546,5,84,0,
  	0,1545,1544,1,0,0,0,1545,1546,1,0,0,0,1546,1547,1,0,0,0,1547,1548,5,83,
  	0,0,1548,1552,1,0,0,0,1549,1552,3,136,68,0,1550,1552,5,81,0,0,1551,1542,
  	1,0,0,0,1551,1549,1,0,0,0,1551,1550,1,0,0,0,1552,135,1,0,0,0,1553,1558,
  	3,138,69,0,1554,1555,5,84,0,0,1555,1557,3,138,69,0,1556,1554,1,0,0,0,
  	1557,1560,1,0,0,0,1558,1556,1,0,0,0,1558,1559,1,0,0,0,1559,137,1,0,0,
  	0,1560,1558,1,0,0,0,1561,1564,3,492,246,0,1562,1563,5,13,0,0,1563,1565,
  	3,492,246,0,1564,1562,1,0,0,0,1564,1565,1,0,0,0,1565,139,1,0,0,0,1566,
  	1571,3,142,71,0,1567,1568,5,84,0,0,1568,1570,3,142,71,0,1569,1567,1,0,
  	0,0,1570,1573,1,0,0,0,1571,1569,1,0,0,0,1571,1572,1,0,0,0,1572,141,1,
  	0,0,0,1573,1571,1,0,0,0,1574,1577,3,144,72,0,1575,1576,5,13,0,0,1576,
  	1578,3,492,246,0,1577,1575,1,0,0,0,1577,1578,1,0,0,0,1578,143,1,0,0,0,
  	1579,1580,6,72,-1,0,1580,1581,3,492,246,0,1581,1587,1,0,0,0,1582,1583,
  	10,2,0,0,1583,1584,5,80,0,0,1584,1586,3,492,246,0,1585,1582,1,0,0,0,1586,
  	1589,1,0,0,0,1587,1585,1,0,0,0,1587,1588,1,0,0,0,1588,145,1,0,0,0,1589,
  	1587,1,0,0,0,1590,1591,5,128,0,0,1591,1592,5,1,0,0,1592,1593,3,96,48,
  	0,1593,1594,5,2,0,0,1594,1597,1,0,0,0,1595,1597,3,102,51,0,1596,1590,
  	1,0,0,0,1596,1595,1,0,0,0,1597,147,1,0,0,0,1598,1599,5,111,0,0,1599,1600,
  	3,308,154,0,1600,1601,5,128,0,0,1601,1603,1,0,0,0,1602,1598,1,0,0,0,1603,
  	1604,1,0,0,0,1604,1602,1,0,0,0,1604,1605,1,0,0,0,1605,149,1,0,0,0,1606,
  	1608,3,148,74,0,1607,1606,1,0,0,0,1607,1608,1,0,0,0,1608,1609,1,0,0,0,
  	1609,1610,3,152,76,0,1610,151,1,0,0,0,1611,1612,5,19,0,0,1612,1614,3,
  	492,246,0,1613,1615,3,284,142,0,1614,1613,1,0,0,0,1614,1615,1,0,0,0,1615,
  	1621,1,0,0,0,1616,1618,5,82,0,0,1617,1619,3,450,225,0,1618,1617,1,0,0,
  	0,1618,1619,1,0,0,0,1619,1620,1,0,0,0,1620,1622,5,83,0,0,1621,1616,1,
  	0,0,0,1621,1622,1,0,0,0,1622,1623,1,0,0,0,1623,1624,5,85,0,0,1624,1625,
  	3,146,73,0,1625,153,1,0,0,0,1626,1628,3,148,74,0,1627,1626,1,0,0,0,1627,
  	1628,1,0,0,0,1628,1629,1,0,0,0,1629,1630,3,156,78,0,1630,155,1,0,0,0,
  	1631,1633,5,15,0,0,1632,1631,1,0,0,0,1632,1633,1,0,0,0,1633,1634,1,0,
  	0,0,1634,1635,5,21,0,0,1635,1637,3,492,246,0,1636,1638,3,284,142,0,1637,
  	1636,1,0,0,0,1637,1638,1,0,0,0,1638,1639,1,0,0,0,1639,1641,5,82,0,0,1640,
  	1642,3,158,79,0,1641,1640,1,0,0,0,1641,1642,1,0,0,0,1642,1643,1,0,0,0,
  	1643,1646,5,83,0,0,1644,1645,5,112,0,0,1645,1647,3,294,147,0,1646,1644,
  	1,0,0,0,1646,1647,1,0,0,0,1647,1648,1,0,0,0,1648,1650,5,85,0,0,1649,1651,
  	3,490,245,0,1650,1649,1,0,0,0,1650,1651,1,0,0,0,1651,1652,1,0,0,0,1652,
  	1653,3,146,73,0,1653,157,1,0,0,0,1654,1655,3,160,80,0,1655,159,1,0,0,
  	0,1656,1660,3,162,81,0,1657,1659,3,170,85,0,1658,1657,1,0,0,0,1659,1662,
  	1,0,0,0,1660,1658,1,0,0,0,1660,1661,1,0,0,0,1661,1666,1,0,0,0,1662,1660,
  	1,0,0,0,1663,1665,3,174,87,0,1664,1663,1,0,0,0,1665,1668,1,0,0,0,1666,
  	1664,1,0,0,0,1666,1667,1,0,0,0,1667,1670,1,0,0,0,1668,1666,1,0,0,0,1669,
  	1671,3,166,83,0,1670,1669,1,0,0,0,1670,1671,1,0,0,0,1671,1706,1,0,0,0,
  	1672,1676,3,164,82,0,1673,1675,3,174,87,0,1674,1673,1,0,0,0,1675,1678,
  	1,0,0,0,1676,1674,1,0,0,0,1676,1677,1,0,0,0,1677,1680,1,0,0,0,1678,1676,
  	1,0,0,0,1679,1681,3,166,83,0,1680,1679,1,0,0,0,1680,1681,1,0,0,0,1681,
  	1706,1,0,0,0,1682,1684,3,170,85,0,1683,1682,1,0,0,0,1684,1685,1,0,0,0,
  	1685,1683,1,0,0,0,1685,1686,1,0,0,0,1686,1690,1,0,0,0,1687,1689,3,174,
  	87,0,1688,1687,1,0,0,0,1689,1692,1,0,0,0,1690,1688,1,0,0,0,1690,1691,
  	1,0,0,0,1691,1694,1,0,0,0,1692,1690,1,0,0,0,1693,1695,3,166,83,0,1694,
  	1693,1,0,0,0,1694,1695,1,0,0,0,1695,1706,1,0,0,0,1696,1698,3,174,87,0,
  	1697,1696,1,0,0,0,1698,1699,1,0,0,0,1699,1697,1,0,0,0,1699,1700,1,0,0,
  	0,1700,1702,1,0,0,0,1701,1703,3,166,83,0,1702,1701,1,0,0,0,1702,1703,
  	1,0,0,0,1703,1706,1,0,0,0,1704,1706,3,166,83,0,1705,1656,1,0,0,0,1705,
  	1672,1,0,0,0,1705,1683,1,0,0,0,1705,1697,1,0,0,0,1705,1704,1,0,0,0,1706,
  	161,1,0,0,0,1707,1709,3,170,85,0,1708,1707,1,0,0,0,1709,1710,1,0,0,0,
  	1710,1708,1,0,0,0,1710,1711,1,0,0,0,1711,1712,1,0,0,0,1712,1714,5,98,
  	0,0,1713,1715,5,84,0,0,1714,1713,1,0,0,0,1714,1715,1,0,0,0,1715,163,1,
  	0,0,0,1716,1718,3,170,85,0,1717,1716,1,0,0,0,1718,1721,1,0,0,0,1719,1717,
  	1,0,0,0,1719,1720,1,0,0,0,1720,1723,1,0,0,0,1721,1719,1,0,0,0,1722,1724,
  	3,174,87,0,1723,1722,1,0,0,0,1724,1725,1,0,0,0,1725,1723,1,0,0,0,1725,
  	1726,1,0,0,0,1726,1727,1,0,0,0,1727,1729,5,98,0,0,1728,1730,5,84,0,0,
  	1729,1728,1,0,0,0,1729,1730,1,0,0,0,1730,165,1,0,0,0,1731,1732,5,81,0,
  	0,1732,1736,3,170,85,0,1733,1735,3,176,88,0,1734,1733,1,0,0,0,1735,1738,
  	1,0,0,0,1736,1734,1,0,0,0,1736,1737,1,0,0,0,1737,1740,1,0,0,0,1738,1736,
  	1,0,0,0,1739,1741,3,168,84,0,1740,1739,1,0,0,0,1740,1741,1,0,0,0,1741,
  	1765,1,0,0,0,1742,1743,5,81,0,0,1743,1747,3,172,86,0,1744,1746,3,176,
  	88,0,1745,1744,1,0,0,0,1746,1749,1,0,0,0,1747,1745,1,0,0,0,1747,1748,
  	1,0,0,0,1748,1751,1,0,0,0,1749,1747,1,0,0,0,1750,1752,3,168,84,0,1751,
  	1750,1,0,0,0,1751,1752,1,0,0,0,1752,1765,1,0,0,0,1753,1754,5,81,0,0,1754,
  	1756,5,84,0,0,1755,1757,3,176,88,0,1756,1755,1,0,0,0,1757,1758,1,0,0,
  	0,1758,1756,1,0,0,0,1758,1759,1,0,0,0,1759,1761,1,0,0,0,1760,1762,3,168,
  	84,0,1761,1760,1,0,0,0,1761,1762,1,0,0,0,1762,1765,1,0,0,0,1763,1765,
  	3,168,84,0,1764,1731,1,0,0,0,1764,1742,1,0,0,0,1764,1753,1,0,0,0,1764,
  	1763,1,0,0,0,1765,167,1,0,0,0,1766,1767,5,87,0,0,1767,1768,3,170,85,0,
  	1768,169,1,0,0,0,1769,1770,3,178,89,0,1770,1771,5,84,0,0,1771,1774,1,
  	0,0,0,1772,1774,3,178,89,0,1773,1769,1,0,0,0,1773,1772,1,0,0,0,1774,171,
  	1,0,0,0,1775,1776,3,180,90,0,1776,1777,5,84,0,0,1777,1780,1,0,0,0,1778,
  	1780,3,180,90,0,1779,1775,1,0,0,0,1779,1778,1,0,0,0,1780,173,1,0,0,0,
  	1781,1782,3,178,89,0,1782,1783,3,186,93,0,1783,1784,5,84,0,0,1784,1789,
  	1,0,0,0,1785,1786,3,178,89,0,1786,1787,3,186,93,0,1787,1789,1,0,0,0,1788,
  	1781,1,0,0,0,1788,1785,1,0,0,0,1789,175,1,0,0,0,1790,1792,3,178,89,0,
  	1791,1793,3,186,93,0,1792,1791,1,0,0,0,1792,1793,1,0,0,0,1793,1794,1,
  	0,0,0,1794,1795,5,84,0,0,1795,1801,1,0,0,0,1796,1798,3,178,89,0,1797,
  	1799,3,186,93,0,1798,1797,1,0,0,0,1798,1799,1,0,0,0,1799,1801,1,0,0,0,
  	1800,1790,1,0,0,0,1800,1796,1,0,0,0,1801,177,1,0,0,0,1802,1804,3,492,
  	246,0,1803,1805,3,182,91,0,1804,1803,1,0,0,0,1804,1805,1,0,0,0,1805,179,
  	1,0,0,0,1806,1807,3,492,246,0,1807,1808,3,184,92,0,1808,181,1,0,0,0,1809,
  	1810,5,85,0,0,1810,1811,3,294,147,0,1811,183,1,0,0,0,1812,1813,5,85,0,
  	0,1813,1814,3,300,150,0,1814,185,1,0,0,0,1815,1816,5,88,0,0,1816,1817,
  	3,294,147,0,1817,187,1,0,0,0,1818,1819,5,31,0,0,1819,1820,3,308,154,0,
  	1820,1821,5,85,0,0,1821,1822,3,146,73,0,1822,1823,3,190,95,0,1823,1832,
  	1,0,0,0,1824,1825,5,31,0,0,1825,1826,3,308,154,0,1826,1827,5,85,0,0,1827,
  	1829,3,146,73,0,1828,1830,3,192,96,0,1829,1828,1,0,0,0,1829,1830,1,0,
  	0,0,1830,1832,1,0,0,0,1831,1818,1,0,0,0,1831,1824,1,0,0,0,1832,189,1,
  	0,0,0,1833,1834,5,23,0,0,1834,1835,3,308,154,0,1835,1836,5,85,0,0,1836,
  	1837,3,146,73,0,1837,1838,3,190,95,0,1838,1847,1,0,0,0,1839,1840,5,23,
  	0,0,1840,1841,3,308,154,0,1841,1842,5,85,0,0,1842,1844,3,146,73,0,1843,
  	1845,3,192,96,0,1844,1843,1,0,0,0,1844,1845,1,0,0,0,1845,1847,1,0,0,0,
  	1846,1833,1,0,0,0,1846,1839,1,0,0,0,1847,191,1,0,0,0,1848,1849,5,24,0,
  	0,1849,1850,5,85,0,0,1850,1851,3,146,73,0,1851,193,1,0,0,0,1852,1853,
  	5,48,0,0,1853,1854,3,308,154,0,1854,1855,5,85,0,0,1855,1857,3,146,73,
  	0,1856,1858,3,192,96,0,1857,1856,1,0,0,0,1857,1858,1,0,0,0,1858,195,1,
  	0,0,0,1859,1860,5,28,0,0,1860,1861,3,464,232,0,1861,1862,5,33,0,0,1862,
  	1863,3,298,149,0,1863,1864,5,85,0,0,1864,1866,3,146,73,0,1865,1867,3,
  	192,96,0,1866,1865,1,0,0,0,1866,1867,1,0,0,0,1867,1879,1,0,0,0,1868,1869,
  	5,15,0,0,1869,1870,5,28,0,0,1870,1871,3,464,232,0,1871,1872,5,33,0,0,
  	1872,1873,3,298,149,0,1873,1874,5,85,0,0,1874,1876,3,146,73,0,1875,1877,
  	3,192,96,0,1876,1875,1,0,0,0,1876,1877,1,0,0,0,1877,1879,1,0,0,0,1878,
  	1859,1,0,0,0,1878,1868,1,0,0,0,1879,197,1,0,0,0,1880,1881,5,50,0,0,1881,
  	1882,5,82,0,0,1882,1887,3,200,100,0,1883,1884,5,84,0,0,1884,1886,3,200,
  	100,0,1885,1883,1,0,0,0,1886,1889,1,0,0,0,1887,1885,1,0,0,0,1887,1888,
  	1,0,0,0,1888,1891,1,0,0,0,1889,1887,1,0,0,0,1890,1892,5,84,0,0,1891,1890,
  	1,0,0,0,1891,1892,1,0,0,0,1892,1893,1,0,0,0,1893,1894,5,83,0,0,1894,1895,
  	5,85,0,0,1895,1896,3,146,73,0,1896,1941,1,0,0,0,1897,1898,5,50,0,0,1898,
  	1903,3,200,100,0,1899,1900,5,84,0,0,1900,1902,3,200,100,0,1901,1899,1,
  	0,0,0,1902,1905,1,0,0,0,1903,1901,1,0,0,0,1903,1904,1,0,0,0,1904,1906,
  	1,0,0,0,1905,1903,1,0,0,0,1906,1907,5,85,0,0,1907,1908,3,146,73,0,1908,
  	1941,1,0,0,0,1909,1910,5,15,0,0,1910,1911,5,50,0,0,1911,1912,5,82,0,0,
  	1912,1917,3,200,100,0,1913,1914,5,84,0,0,1914,1916,3,200,100,0,1915,1913,
  	1,0,0,0,1916,1919,1,0,0,0,1917,1915,1,0,0,0,1917,1918,1,0,0,0,1918,1921,
  	1,0,0,0,1919,1917,1,0,0,0,1920,1922,5,84,0,0,1921,1920,1,0,0,0,1921,1922,
  	1,0,0,0,1922,1923,1,0,0,0,1923,1924,5,83,0,0,1924,1925,5,85,0,0,1925,
  	1926,3,146,73,0,1926,1941,1,0,0,0,1927,1928,5,15,0,0,1928,1929,5,50,0,
  	0,1929,1934,3,200,100,0,1930,1931,5,84,0,0,1931,1933,3,200,100,0,1932,
  	1930,1,0,0,0,1933,1936,1,0,0,0,1934,1932,1,0,0,0,1934,1935,1,0,0,0,1935,
  	1937,1,0,0,0,1936,1934,1,0,0,0,1937,1938,5,85,0,0,1938,1939,3,146,73,
  	0,1939,1941,1,0,0,0,1940,1880,1,0,0,0,1940,1897,1,0,0,0,1940,1909,1,0,
  	0,0,1940,1927,1,0,0,0,1941,199,1,0,0,0,1942,1943,3,294,147,0,1943,1944,
  	5,13,0,0,1944,1945,3,470,235,0,1945,1948,1,0,0,0,1946,1948,3,294,147,
  	0,1947,1942,1,0,0,0,1947,1946,1,0,0,0,1948,201,1,0,0,0,1949,1950,5,46,
  	0,0,1950,1951,5,85,0,0,1951,1952,3,146,73,0,1952,1953,3,208,104,0,1953,
  	1983,1,0,0,0,1954,1955,5,46,0,0,1955,1956,5,85,0,0,1956,1958,3,146,73,
  	0,1957,1959,3,204,102,0,1958,1957,1,0,0,0,1959,1960,1,0,0,0,1960,1958,
  	1,0,0,0,1960,1961,1,0,0,0,1961,1963,1,0,0,0,1962,1964,3,192,96,0,1963,
  	1962,1,0,0,0,1963,1964,1,0,0,0,1964,1966,1,0,0,0,1965,1967,3,208,104,
  	0,1966,1965,1,0,0,0,1966,1967,1,0,0,0,1967,1983,1,0,0,0,1968,1969,5,46,
  	0,0,1969,1970,5,85,0,0,1970,1972,3,146,73,0,1971,1973,3,206,103,0,1972,
  	1971,1,0,0,0,1973,1974,1,0,0,0,1974,1972,1,0,0,0,1974,1975,1,0,0,0,1975,
  	1977,1,0,0,0,1976,1978,3,192,96,0,1977,1976,1,0,0,0,1977,1978,1,0,0,0,
  	1978,1980,1,0,0,0,1979,1981,3,208,104,0,1980,1979,1,0,0,0,1980,1981,1,
  	0,0,0,1981,1983,1,0,0,0,1982,1949,1,0,0,0,1982,1954,1,0,0,0,1982,1968,
  	1,0,0,0,1983,203,1,0,0,0,1984,1985,5,25,0,0,1985,1988,3,294,147,0,1986,
  	1987,5,13,0,0,1987,1989,3,492,246,0,1988,1986,1,0,0,0,1988,1989,1,0,0,
  	0,1989,1990,1,0,0,0,1990,1991,5,85,0,0,1991,1992,3,146,73,0,1992,1997,
  	1,0,0,0,1993,1994,5,25,0,0,1994,1995,5,85,0,0,1995,1997,3,146,73,0,1996,
  	1984,1,0,0,0,1996,1993,1,0,0,0,1997,205,1,0,0,0,1998,1999,5,25,0,0,1999,
  	2000,5,81,0,0,2000,2003,3,294,147,0,2001,2002,5,13,0,0,2002,2004,3,492,
  	246,0,2003,2001,1,0,0,0,2003,2004,1,0,0,0,2004,2005,1,0,0,0,2005,2006,
  	5,85,0,0,2006,2007,3,146,73,0,2007,207,1,0,0,0,2008,2009,5,27,0,0,2009,
  	2010,5,85,0,0,2010,2011,3,146,73,0,2011,209,1,0,0,0,2012,2013,5,37,0,
  	0,2013,2014,3,212,106,0,2014,2015,5,85,0,0,2015,2016,5,128,0,0,2016,2018,
  	5,1,0,0,2017,2019,3,214,107,0,2018,2017,1,0,0,0,2019,2020,1,0,0,0,2020,
  	2018,1,0,0,0,2020,2021,1,0,0,0,2021,2022,1,0,0,0,2022,2023,5,2,0,0,2023,
  	211,1,0,0,0,2024,2025,3,304,152,0,2025,2027,5,84,0,0,2026,2028,3,302,
  	151,0,2027,2026,1,0,0,0,2027,2028,1,0,0,0,2028,2031,1,0,0,0,2029,2031,
  	3,308,154,0,2030,2024,1,0,0,0,2030,2029,1,0,0,0,2031,213,1,0,0,0,2032,
  	2033,5,18,0,0,2033,2035,3,218,109,0,2034,2036,3,216,108,0,2035,2034,1,
  	0,0,0,2035,2036,1,0,0,0,2036,2037,1,0,0,0,2037,2038,5,85,0,0,2038,2039,
  	3,146,73,0,2039,215,1,0,0,0,2040,2041,5,31,0,0,2041,2042,3,308,154,0,
  	2042,217,1,0,0,0,2043,2046,3,258,129,0,2044,2046,3,220,110,0,2045,2043,
  	1,0,0,0,2045,2044,1,0,0,0,2046,219,1,0,0,0,2047,2050,3,222,111,0,2048,
  	2050,3,224,112,0,2049,2047,1,0,0,0,2049,2048,1,0,0,0,2050,221,1,0,0,0,
  	2051,2052,3,224,112,0,2052,2053,5,13,0,0,2053,2054,3,244,122,0,2054,223,
  	1,0,0,0,2055,2060,3,226,113,0,2056,2057,5,91,0,0,2057,2059,3,226,113,
  	0,2058,2056,1,0,0,0,2059,2062,1,0,0,0,2060,2058,1,0,0,0,2060,2061,1,0,
  	0,0,2061,225,1,0,0,0,2062,2060,1,0,0,0,2063,2072,3,228,114,0,2064,2072,
  	3,242,121,0,2065,2072,3,246,123,0,2066,2072,3,248,124,0,2067,2072,3,254,
  	127,0,2068,2072,3,256,128,0,2069,2072,3,266,133,0,2070,2072,3,274,137,
  	0,2071,2063,1,0,0,0,2071,2064,1,0,0,0,2071,2065,1,0,0,0,2071,2066,1,0,
  	0,0,2071,2067,1,0,0,0,2071,2068,1,0,0,0,2071,2069,1,0,0,0,2071,2070,1,
  	0,0,0,2072,227,1,0,0,0,2073,2080,3,234,117,0,2074,2080,3,232,116,0,2075,
  	2080,3,422,211,0,2076,2080,5,38,0,0,2077,2080,5,45,0,0,2078,2080,5,26,
  	0,0,2079,2073,1,0,0,0,2079,2074,1,0,0,0,2079,2075,1,0,0,0,2079,2076,1,
  	0,0,0,2079,2077,1,0,0,0,2079,2078,1,0,0,0,2080,229,1,0,0,0,2081,2088,
  	3,234,117,0,2082,2088,3,232,116,0,2083,2088,3,422,211,0,2084,2088,5,38,
  	0,0,2085,2088,5,45,0,0,2086,2088,5,26,0,0,2087,2081,1,0,0,0,2087,2082,
  	1,0,0,0,2087,2083,1,0,0,0,2087,2084,1,0,0,0,2087,2085,1,0,0,0,2087,2086,
  	1,0,0,0,2088,231,1,0,0,0,2089,2090,3,236,118,0,2090,2091,5,96,0,0,2091,
  	2092,3,240,120,0,2092,2098,1,0,0,0,2093,2094,3,236,118,0,2094,2095,5,
  	97,0,0,2095,2096,3,240,120,0,2096,2098,1,0,0,0,2097,2089,1,0,0,0,2097,
  	2093,1,0,0,0,2098,233,1,0,0,0,2099,2103,5,8,0,0,2100,2101,5,97,0,0,2101,
  	2103,5,8,0,0,2102,2099,1,0,0,0,2102,2100,1,0,0,0,2103,235,1,0,0,0,2104,
  	2108,3,238,119,0,2105,2106,5,97,0,0,2106,2108,3,238,119,0,2107,2104,1,
  	0,0,0,2107,2105,1,0,0,0,2108,237,1,0,0,0,2109,2110,5,8,0,0,2110,239,1,
  	0,0,0,2111,2112,5,8,0,0,2112,241,1,0,0,0,2113,2114,3,244,122,0,2114,243,
  	1,0,0,0,2115,2116,3,492,246,0,2116,245,1,0,0,0,2117,2118,5,131,0,0,2118,
  	247,1,0,0,0,2119,2120,3,250,125,0,2120,249,1,0,0,0,2121,2122,3,252,126,
  	0,2122,2123,5,80,0,0,2123,2124,3,492,246,0,2124,251,1,0,0,0,2125,2126,
  	6,126,-1,0,2126,2127,3,492,246,0,2127,2133,1,0,0,0,2128,2129,10,2,0,0,
  	2129,2130,5,80,0,0,2130,2132,3,492,246,0,2131,2128,1,0,0,0,2132,2135,
  	1,0,0,0,2133,2131,1,0,0,0,2133,2134,1,0,0,0,2134,253,1,0,0,0,2135,2133,
  	1,0,0,0,2136,2137,5,82,0,0,2137,2138,3,220,110,0,2138,2139,5,83,0,0,2139,
  	255,1,0,0,0,2140,2142,5,89,0,0,2141,2143,3,260,130,0,2142,2141,1,0,0,
  	0,2142,2143,1,0,0,0,2143,2144,1,0,0,0,2144,2151,5,90,0,0,2145,2147,5,
  	82,0,0,2146,2148,3,258,129,0,2147,2146,1,0,0,0,2147,2148,1,0,0,0,2148,
  	2149,1,0,0,0,2149,2151,5,83,0,0,2150,2140,1,0,0,0,2150,2145,1,0,0,0,2151,
  	257,1,0,0,0,2152,2153,3,262,131,0,2153,2155,5,84,0,0,2154,2156,3,260,
  	130,0,2155,2154,1,0,0,0,2155,2156,1,0,0,0,2156,259,1,0,0,0,2157,2162,
  	3,262,131,0,2158,2159,5,84,0,0,2159,2161,3,262,131,0,2160,2158,1,0,0,
  	0,2161,2164,1,0,0,0,2162,2160,1,0,0,0,2162,2163,1,0,0,0,2163,2166,1,0,
  	0,0,2164,2162,1,0,0,0,2165,2167,5,84,0,0,2166,2165,1,0,0,0,2166,2167,
  	1,0,0,0,2167,261,1,0,0,0,2168,2171,3,264,132,0,2169,2171,3,220,110,0,
  	2170,2168,1,0,0,0,2170,2169,1,0,0,0,2171,263,1,0,0,0,2172,2173,5,81,0,
  	0,2173,2177,3,244,122,0,2174,2175,5,81,0,0,2175,2177,3,246,123,0,2176,
  	2172,1,0,0,0,2176,2174,1,0,0,0,2177,265,1,0,0,0,2178,2179,5,102,0,0,2179,
  	2204,5,103,0,0,2180,2181,5,102,0,0,2181,2183,3,272,136,0,2182,2184,5,
  	84,0,0,2183,2182,1,0,0,0,2183,2184,1,0,0,0,2184,2185,1,0,0,0,2185,2186,
  	5,103,0,0,2186,2204,1,0,0,0,2187,2188,5,102,0,0,2188,2189,3,268,134,0,
  	2189,2190,5,84,0,0,2190,2192,3,272,136,0,2191,2193,5,84,0,0,2192,2191,
  	1,0,0,0,2192,2193,1,0,0,0,2193,2194,1,0,0,0,2194,2195,5,103,0,0,2195,
  	2204,1,0,0,0,2196,2197,5,102,0,0,2197,2199,3,268,134,0,2198,2200,5,84,
  	0,0,2199,2198,1,0,0,0,2199,2200,1,0,0,0,2200,2201,1,0,0,0,2201,2202,5,
  	103,0,0,2202,2204,1,0,0,0,2203,2178,1,0,0,0,2203,2180,1,0,0,0,2203,2187,
  	1,0,0,0,2203,2196,1,0,0,0,2204,267,1,0,0,0,2205,2210,3,270,135,0,2206,
  	2207,5,84,0,0,2207,2209,3,270,135,0,2208,2206,1,0,0,0,2209,2212,1,0,0,
  	0,2210,2208,1,0,0,0,2210,2211,1,0,0,0,2211,269,1,0,0,0,2212,2210,1,0,
  	0,0,2213,2216,3,230,115,0,2214,2216,3,250,125,0,2215,2213,1,0,0,0,2215,
  	2214,1,0,0,0,2216,2217,1,0,0,0,2217,2218,5,85,0,0,2218,2219,3,220,110,
  	0,2219,271,1,0,0,0,2220,2221,5,87,0,0,2221,2222,3,244,122,0,2222,273,
  	1,0,0,0,2223,2224,3,252,126,0,2224,2225,5,82,0,0,2225,2226,5,83,0,0,2226,
  	2254,1,0,0,0,2227,2228,3,252,126,0,2228,2229,5,82,0,0,2229,2231,3,276,
  	138,0,2230,2232,5,84,0,0,2231,2230,1,0,0,0,2231,2232,1,0,0,0,2232,2233,
  	1,0,0,0,2233,2234,5,83,0,0,2234,2254,1,0,0,0,2235,2236,3,252,126,0,2236,
  	2237,5,82,0,0,2237,2239,3,278,139,0,2238,2240,5,84,0,0,2239,2238,1,0,
  	0,0,2239,2240,1,0,0,0,2240,2241,1,0,0,0,2241,2242,5,83,0,0,2242,2254,
  	1,0,0,0,2243,2244,3,252,126,0,2244,2245,5,82,0,0,2245,2246,3,276,138,
  	0,2246,2247,5,84,0,0,2247,2249,3,278,139,0,2248,2250,5,84,0,0,2249,2248,
  	1,0,0,0,2249,2250,1,0,0,0,2250,2251,1,0,0,0,2251,2252,5,83,0,0,2252,2254,
  	1,0,0,0,2253,2223,1,0,0,0,2253,2227,1,0,0,0,2253,2235,1,0,0,0,2253,2243,
  	1,0,0,0,2254,275,1,0,0,0,2255,2260,3,220,110,0,2256,2257,5,84,0,0,2257,
  	2259,3,220,110,0,2258,2256,1,0,0,0,2259,2262,1,0,0,0,2260,2258,1,0,0,
  	0,2260,2261,1,0,0,0,2261,277,1,0,0,0,2262,2260,1,0,0,0,2263,2268,3,280,
  	140,0,2264,2265,5,84,0,0,2265,2267,3,280,140,0,2266,2264,1,0,0,0,2267,
  	2270,1,0,0,0,2268,2266,1,0,0,0,2268,2269,1,0,0,0,2269,279,1,0,0,0,2270,
  	2268,1,0,0,0,2271,2272,3,492,246,0,2272,2273,5,88,0,0,2273,2274,3,220,
  	110,0,2274,281,1,0,0,0,2275,2276,5,47,0,0,2276,2278,3,492,246,0,2277,
  	2279,3,284,142,0,2278,2277,1,0,0,0,2278,2279,1,0,0,0,2279,2280,1,0,0,
  	0,2280,2281,5,88,0,0,2281,2282,3,294,147,0,2282,283,1,0,0,0,2283,2284,
  	5,89,0,0,2284,2285,3,286,143,0,2285,2286,5,90,0,0,2286,285,1,0,0,0,2287,
  	2292,3,288,144,0,2288,2289,5,84,0,0,2289,2291,3,288,144,0,2290,2288,1,
  	0,0,0,2291,2294,1,0,0,0,2292,2290,1,0,0,0,2292,2293,1,0,0,0,2293,2296,
  	1,0,0,0,2294,2292,1,0,0,0,2295,2297,5,84,0,0,2296,2295,1,0,0,0,2296,2297,
  	1,0,0,0,2297,287,1,0,0,0,2298,2300,3,492,246,0,2299,2301,3,290,145,0,
  	2300,2299,1,0,0,0,2300,2301,1,0,0,0,2301,2307,1,0,0,0,2302,2303,5,81,
  	0,0,2303,2307,3,492,246,0,2304,2305,5,87,0,0,2305,2307,3,492,246,0,2306,
  	2298,1,0,0,0,2306,2302,1,0,0,0,2306,2304,1,0,0,0,2307,289,1,0,0,0,2308,
  	2309,5,85,0,0,2309,2310,3,294,147,0,2310,291,1,0,0,0,2311,2316,3,294,
  	147,0,2312,2313,5,84,0,0,2313,2315,3,294,147,0,2314,2312,1,0,0,0,2315,
  	2318,1,0,0,0,2316,2314,1,0,0,0,2316,2317,1,0,0,0,2317,2320,1,0,0,0,2318,
  	2316,1,0,0,0,2319,2321,5,84,0,0,2320,2319,1,0,0,0,2320,2321,1,0,0,0,2321,
  	293,1,0,0,0,2322,2323,3,310,155,0,2323,2324,5,31,0,0,2324,2325,3,310,
  	155,0,2325,2326,5,24,0,0,2326,2327,3,294,147,0,2327,2331,1,0,0,0,2328,
  	2331,3,310,155,0,2329,2331,3,368,184,0,2330,2322,1,0,0,0,2330,2328,1,
  	0,0,0,2330,2329,1,0,0,0,2331,295,1,0,0,0,2332,2333,5,51,0,0,2333,2334,
  	5,29,0,0,2334,2340,3,294,147,0,2335,2337,5,51,0,0,2336,2338,3,298,149,
  	0,2337,2336,1,0,0,0,2337,2338,1,0,0,0,2338,2340,1,0,0,0,2339,2332,1,0,
  	0,0,2339,2335,1,0,0,0,2340,297,1,0,0,0,2341,2346,3,300,150,0,2342,2343,
  	5,84,0,0,2343,2345,3,300,150,0,2344,2342,1,0,0,0,2345,2348,1,0,0,0,2346,
  	2344,1,0,0,0,2346,2347,1,0,0,0,2347,2350,1,0,0,0,2348,2346,1,0,0,0,2349,
  	2351,5,84,0,0,2350,2349,1,0,0,0,2350,2351,1,0,0,0,2351,299,1,0,0,0,2352,
  	2357,3,54,27,0,2353,2354,5,81,0,0,2354,2357,3,340,170,0,2355,2357,3,294,
  	147,0,2356,2352,1,0,0,0,2356,2353,1,0,0,0,2356,2355,1,0,0,0,2357,301,
  	1,0,0,0,2358,2363,3,304,152,0,2359,2360,5,84,0,0,2360,2362,3,304,152,
  	0,2361,2359,1,0,0,0,2362,2365,1,0,0,0,2363,2361,1,0,0,0,2363,2364,1,0,
  	0,0,2364,2367,1,0,0,0,2365,2363,1,0,0,0,2366,2368,5,84,0,0,2367,2366,
  	1,0,0,0,2367,2368,1,0,0,0,2368,303,1,0,0,0,2369,2370,5,81,0,0,2370,2373,
  	3,340,170,0,2371,2373,3,308,154,0,2372,2369,1,0,0,0,2372,2371,1,0,0,0,
  	2373,305,1,0,0,0,2374,2375,3,492,246,0,2375,2376,5,126,0,0,2376,2377,
  	3,294,147,0,2377,307,1,0,0,0,2378,2381,3,306,153,0,2379,2381,3,294,147,
  	0,2380,2378,1,0,0,0,2380,2379,1,0,0,0,2381,309,1,0,0,0,2382,2387,3,312,
  	156,0,2383,2384,5,41,0,0,2384,2386,3,312,156,0,2385,2383,1,0,0,0,2386,
  	2389,1,0,0,0,2387,2385,1,0,0,0,2387,2388,1,0,0,0,2388,311,1,0,0,0,2389,
  	2387,1,0,0,0,2390,2395,3,314,157,0,2391,2392,5,12,0,0,2392,2394,3,314,
  	157,0,2393,2391,1,0,0,0,2394,2397,1,0,0,0,2395,2393,1,0,0,0,2395,2396,
  	1,0,0,0,2396,313,1,0,0,0,2397,2395,1,0,0,0,2398,2399,5,40,0,0,2399,2402,
  	3,314,157,0,2400,2402,3,316,158,0,2401,2398,1,0,0,0,2401,2400,1,0,0,0,
  	2402,315,1,0,0,0,2403,2407,3,340,170,0,2404,2406,3,318,159,0,2405,2404,
  	1,0,0,0,2406,2409,1,0,0,0,2407,2405,1,0,0,0,2407,2408,1,0,0,0,2408,317,
  	1,0,0,0,2409,2407,1,0,0,0,2410,2421,3,320,160,0,2411,2421,3,322,161,0,
  	2412,2421,3,324,162,0,2413,2421,3,326,163,0,2414,2421,3,328,164,0,2415,
  	2421,3,330,165,0,2416,2421,3,332,166,0,2417,2421,3,334,167,0,2418,2421,
  	3,336,168,0,2419,2421,3,338,169,0,2420,2410,1,0,0,0,2420,2411,1,0,0,0,
  	2420,2412,1,0,0,0,2420,2413,1,0,0,0,2420,2414,1,0,0,0,2420,2415,1,0,0,
  	0,2420,2416,1,0,0,0,2420,2417,1,0,0,0,2420,2418,1,0,0,0,2420,2419,1,0,
  	0,0,2421,319,1,0,0,0,2422,2423,5,106,0,0,2423,2424,3,340,170,0,2424,321,
  	1,0,0,0,2425,2426,5,110,0,0,2426,2430,3,340,170,0,2427,2428,5,109,0,0,
  	2428,2430,3,340,170,0,2429,2425,1,0,0,0,2429,2427,1,0,0,0,2430,323,1,
  	0,0,0,2431,2432,5,108,0,0,2432,2433,3,340,170,0,2433,325,1,0,0,0,2434,
  	2435,5,104,0,0,2435,2436,3,340,170,0,2436,327,1,0,0,0,2437,2438,5,107,
  	0,0,2438,2439,3,340,170,0,2439,329,1,0,0,0,2440,2441,5,105,0,0,2441,2442,
  	3,340,170,0,2442,331,1,0,0,0,2443,2444,5,40,0,0,2444,2445,5,33,0,0,2445,
  	2446,3,340,170,0,2446,333,1,0,0,0,2447,2448,5,33,0,0,2448,2449,3,340,
  	170,0,2449,335,1,0,0,0,2450,2451,5,35,0,0,2451,2452,5,40,0,0,2452,2453,
  	3,340,170,0,2453,337,1,0,0,0,2454,2455,5,35,0,0,2455,2456,3,340,170,0,
  	2456,339,1,0,0,0,2457,2458,6,170,-1,0,2458,2459,3,342,171,0,2459,2465,
  	1,0,0,0,2460,2461,10,2,0,0,2461,2462,5,91,0,0,2462,2464,3,342,171,0,2463,
  	2460,1,0,0,0,2464,2467,1,0,0,0,2465,2463,1,0,0,0,2465,2466,1,0,0,0,2466,
  	341,1,0,0,0,2467,2465,1,0,0,0,2468,2469,6,171,-1,0,2469,2470,3,344,172,
  	0,2470,2476,1,0,0,0,2471,2472,10,2,0,0,2472,2473,5,92,0,0,2473,2475,3,
  	344,172,0,2474,2471,1,0,0,0,2475,2478,1,0,0,0,2476,2474,1,0,0,0,2476,
  	2477,1,0,0,0,2477,343,1,0,0,0,2478,2476,1,0,0,0,2479,2480,6,172,-1,0,
  	2480,2481,3,346,173,0,2481,2487,1,0,0,0,2482,2483,10,2,0,0,2483,2484,
  	5,93,0,0,2484,2486,3,346,173,0,2485,2482,1,0,0,0,2486,2489,1,0,0,0,2487,
  	2485,1,0,0,0,2487,2488,1,0,0,0,2488,345,1,0,0,0,2489,2487,1,0,0,0,2490,
  	2491,6,173,-1,0,2491,2492,3,348,174,0,2492,2501,1,0,0,0,2493,2494,10,
  	3,0,0,2494,2495,5,94,0,0,2495,2500,3,348,174,0,2496,2497,10,2,0,0,2497,
  	2498,5,95,0,0,2498,2500,3,348,174,0,2499,2493,1,0,0,0,2499,2496,1,0,0,
  	0,2500,2503,1,0,0,0,2501,2499,1,0,0,0,2501,2502,1,0,0,0,2502,347,1,0,
  	0,0,2503,2501,1,0,0,0,2504,2505,6,174,-1,0,2505,2506,3,350,175,0,2506,
  	2515,1,0,0,0,2507,2508,10,3,0,0,2508,2509,5,96,0,0,2509,2514,3,350,175,
  	0,2510,2511,10,2,0,0,2511,2512,5,97,0,0,2512,2514,3,350,175,0,2513,2507,
  	1,0,0,0,2513,2510,1,0,0,0,2514,2517,1,0,0,0,2515,2513,1,0,0,0,2515,2516,
  	1,0,0,0,2516,349,1,0,0,0,2517,2515,1,0,0,0,2518,2519,6,175,-1,0,2519,
  	2520,3,352,176,0,2520,2538,1,0,0,0,2521,2522,10,6,0,0,2522,2523,5,81,
  	0,0,2523,2537,3,352,176,0,2524,2525,10,5,0,0,2525,2526,5,98,0,0,2526,
  	2537,3,352,176,0,2527,2528,10,4,0,0,2528,2529,5,100,0,0,2529,2537,3,352,
  	176,0,2530,2531,10,3,0,0,2531,2532,5,99,0,0,2532,2537,3,352,176,0,2533,
  	2534,10,2,0,0,2534,2535,5,111,0,0,2535,2537,3,352,176,0,2536,2521,1,0,
  	0,0,2536,2524,1,0,0,0,2536,2527,1,0,0,0,2536,2530,1,0,0,0,2536,2533,1,
  	0,0,0,2537,2540,1,0,0,0,2538,2536,1,0,0,0,2538,2539,1,0,0,0,2539,351,
  	1,0,0,0,2540,2538,1,0,0,0,2541,2542,5,96,0,0,2542,2549,3,352,176,0,2543,
  	2544,5,97,0,0,2544,2549,3,352,176,0,2545,2546,5,101,0,0,2546,2549,3,352,
  	176,0,2547,2549,3,354,177,0,2548,2541,1,0,0,0,2548,2543,1,0,0,0,2548,
  	2545,1,0,0,0,2548,2547,1,0,0,0,2549,353,1,0,0,0,2550,2551,3,356,178,0,
  	2551,2552,5,87,0,0,2552,2553,3,352,176,0,2553,2556,1,0,0,0,2554,2556,
  	3,356,178,0,2555,2550,1,0,0,0,2555,2554,1,0,0,0,2556,355,1,0,0,0,2557,
  	2558,5,16,0,0,2558,2561,3,358,179,0,2559,2561,3,358,179,0,2560,2557,1,
  	0,0,0,2560,2559,1,0,0,0,2561,357,1,0,0,0,2562,2563,6,179,-1,0,2563,2564,
  	3,364,182,0,2564,2583,1,0,0,0,2565,2566,10,5,0,0,2566,2567,5,80,0,0,2567,
  	2582,3,492,246,0,2568,2569,10,4,0,0,2569,2582,3,446,223,0,2570,2571,10,
  	3,0,0,2571,2573,5,82,0,0,2572,2574,3,450,225,0,2573,2572,1,0,0,0,2573,
  	2574,1,0,0,0,2574,2575,1,0,0,0,2575,2582,5,83,0,0,2576,2577,10,2,0,0,
  	2577,2578,5,89,0,0,2578,2579,3,360,180,0,2579,2580,5,90,0,0,2580,2582,
  	1,0,0,0,2581,2565,1,0,0,0,2581,2568,1,0,0,0,2581,2570,1,0,0,0,2581,2576,
  	1,0,0,0,2582,2585,1,0,0,0,2583,2581,1,0,0,0,2583,2584,1,0,0,0,2584,359,
  	1,0,0,0,2585,2583,1,0,0,0,2586,2589,3,362,181,0,2587,2589,3,458,229,0,
  	2588,2586,1,0,0,0,2588,2587,1,0,0,0,2589,2597,1,0,0,0,2590,2593,5,84,
  	0,0,2591,2594,3,362,181,0,2592,2594,3,458,229,0,2593,2591,1,0,0,0,2593,
  	2592,1,0,0,0,2594,2596,1,0,0,0,2595,2590,1,0,0,0,2596,2599,1,0,0,0,2597,
  	2595,1,0,0,0,2597,2598,1,0,0,0,2598,2601,1,0,0,0,2599,2597,1,0,0,0,2600,
  	2602,5,84,0,0,2601,2600,1,0,0,0,2601,2602,1,0,0,0,2602,361,1,0,0,0,2603,
  	2605,3,294,147,0,2604,2603,1,0,0,0,2604,2605,1,0,0,0,2605,2606,1,0,0,
  	0,2606,2608,5,85,0,0,2607,2609,3,294,147,0,2608,2607,1,0,0,0,2608,2609,
  	1,0,0,0,2609,2614,1,0,0,0,2610,2612,5,85,0,0,2611,2613,3,294,147,0,2612,
  	2611,1,0,0,0,2612,2613,1,0,0,0,2613,2615,1,0,0,0,2614,2610,1,0,0,0,2614,
  	2615,1,0,0,0,2615,2618,1,0,0,0,2616,2618,3,308,154,0,2617,2604,1,0,0,
  	0,2617,2616,1,0,0,0,2618,363,1,0,0,0,2619,2643,3,50,25,0,2620,2643,3,
  	492,246,0,2621,2643,5,45,0,0,2622,2643,5,26,0,0,2623,2643,5,38,0,0,2624,
  	2643,3,422,211,0,2625,2643,5,8,0,0,2626,2630,3,426,213,0,2627,2630,3,
  	366,183,0,2628,2630,3,446,223,0,2629,2626,1,0,0,0,2629,2627,1,0,0,0,2629,
  	2628,1,0,0,0,2630,2643,1,0,0,0,2631,2634,3,424,212,0,2632,2634,3,442,
  	221,0,2633,2631,1,0,0,0,2633,2632,1,0,0,0,2634,2643,1,0,0,0,2635,2640,
  	3,430,215,0,2636,2640,3,428,214,0,2637,2640,3,448,224,0,2638,2640,3,444,
  	222,0,2639,2635,1,0,0,0,2639,2636,1,0,0,0,2639,2637,1,0,0,0,2639,2638,
  	1,0,0,0,2640,2643,1,0,0,0,2641,2643,5,78,0,0,2642,2619,1,0,0,0,2642,2620,
  	1,0,0,0,2642,2621,1,0,0,0,2642,2622,1,0,0,0,2642,2623,1,0,0,0,2642,2624,
  	1,0,0,0,2642,2625,1,0,0,0,2642,2629,1,0,0,0,2642,2633,1,0,0,0,2642,2639,
  	1,0,0,0,2642,2641,1,0,0,0,2643,365,1,0,0,0,2644,2647,5,82,0,0,2645,2648,
  	3,296,148,0,2646,2648,3,308,154,0,2647,2645,1,0,0,0,2647,2646,1,0,0,0,
  	2648,2649,1,0,0,0,2649,2650,5,83,0,0,2650,367,1,0,0,0,2651,2653,5,36,
  	0,0,2652,2654,3,370,185,0,2653,2652,1,0,0,0,2653,2654,1,0,0,0,2654,2655,
  	1,0,0,0,2655,2656,5,85,0,0,2656,2657,3,294,147,0,2657,369,1,0,0,0,2658,
  	2659,3,372,186,0,2659,371,1,0,0,0,2660,2664,3,374,187,0,2661,2663,3,382,
  	191,0,2662,2661,1,0,0,0,2663,2666,1,0,0,0,2664,2662,1,0,0,0,2664,2665,
  	1,0,0,0,2665,2670,1,0,0,0,2666,2664,1,0,0,0,2667,2669,3,384,192,0,2668,
  	2667,1,0,0,0,2669,2672,1,0,0,0,2670,2668,1,0,0,0,2670,2671,1,0,0,0,2671,
  	2674,1,0,0,0,2672,2670,1,0,0,0,2673,2675,3,378,189,0,2674,2673,1,0,0,
  	0,2674,2675,1,0,0,0,2675,2710,1,0,0,0,2676,2680,3,376,188,0,2677,2679,
  	3,384,192,0,2678,2677,1,0,0,0,2679,2682,1,0,0,0,2680,2678,1,0,0,0,2680,
  	2681,1,0,0,0,2681,2684,1,0,0,0,2682,2680,1,0,0,0,2683,2685,3,378,189,
  	0,2684,2683,1,0,0,0,2684,2685,1,0,0,0,2685,2710,1,0,0,0,2686,2688,3,382,
  	191,0,2687,2686,1,0,0,0,2688,2689,1,0,0,0,2689,2687,1,0,0,0,2689,2690,
  	1,0,0,0,2690,2694,1,0,0,0,2691,2693,3,384,192,0,2692,2691,1,0,0,0,2693,
  	2696,1,0,0,0,2694,2692,1,0,0,0,2694,2695,1,0,0,0,2695,2698,1,0,0,0,2696,
  	2694,1,0,0,0,2697,2699,3,378,189,0,2698,2697,1,0,0,0,2698,2699,1,0,0,
  	0,2699,2710,1,0,0,0,2700,2702,3,384,192,0,2701,2700,1,0,0,0,2702,2703,
  	1,0,0,0,2703,2701,1,0,0,0,2703,2704,1,0,0,0,2704,2706,1,0,0,0,2705,2707,
  	3,378,189,0,2706,2705,1,0,0,0,2706,2707,1,0,0,0,2707,2710,1,0,0,0,2708,
  	2710,3,378,189,0,2709,2660,1,0,0,0,2709,2676,1,0,0,0,2709,2687,1,0,0,
  	0,2709,2701,1,0,0,0,2709,2708,1,0,0,0,2710,373,1,0,0,0,2711,2713,3,382,
  	191,0,2712,2711,1,0,0,0,2713,2714,1,0,0,0,2714,2712,1,0,0,0,2714,2715,
  	1,0,0,0,2715,2716,1,0,0,0,2716,2718,5,98,0,0,2717,2719,5,84,0,0,2718,
  	2717,1,0,0,0,2718,2719,1,0,0,0,2719,375,1,0,0,0,2720,2722,3,382,191,0,
  	2721,2720,1,0,0,0,2722,2725,1,0,0,0,2723,2721,1,0,0,0,2723,2724,1,0,0,
  	0,2724,2727,1,0,0,0,2725,2723,1,0,0,0,2726,2728,3,384,192,0,2727,2726,
  	1,0,0,0,2728,2729,1,0,0,0,2729,2727,1,0,0,0,2729,2730,1,0,0,0,2730,2731,
  	1,0,0,0,2731,2733,5,98,0,0,2732,2734,5,84,0,0,2733,2732,1,0,0,0,2733,
  	2734,1,0,0,0,2734,377,1,0,0,0,2735,2736,5,81,0,0,2736,2740,3,382,191,
  	0,2737,2739,3,386,193,0,2738,2737,1,0,0,0,2739,2742,1,0,0,0,2740,2738,
  	1,0,0,0,2740,2741,1,0,0,0,2741,2744,1,0,0,0,2742,2740,1,0,0,0,2743,2745,
  	3,380,190,0,2744,2743,1,0,0,0,2744,2745,1,0,0,0,2745,2758,1,0,0,0,2746,
  	2747,5,81,0,0,2747,2749,5,84,0,0,2748,2750,3,386,193,0,2749,2748,1,0,
  	0,0,2750,2751,1,0,0,0,2751,2749,1,0,0,0,2751,2752,1,0,0,0,2752,2754,1,
  	0,0,0,2753,2755,3,380,190,0,2754,2753,1,0,0,0,2754,2755,1,0,0,0,2755,
  	2758,1,0,0,0,2756,2758,3,380,190,0,2757,2735,1,0,0,0,2757,2746,1,0,0,
  	0,2757,2756,1,0,0,0,2758,379,1,0,0,0,2759,2760,5,87,0,0,2760,2761,3,382,
  	191,0,2761,381,1,0,0,0,2762,2764,3,388,194,0,2763,2765,5,84,0,0,2764,
  	2763,1,0,0,0,2764,2765,1,0,0,0,2765,383,1,0,0,0,2766,2767,3,388,194,0,
  	2767,2769,3,186,93,0,2768,2770,5,84,0,0,2769,2768,1,0,0,0,2769,2770,1,
  	0,0,0,2770,385,1,0,0,0,2771,2773,3,388,194,0,2772,2774,3,186,93,0,2773,
  	2772,1,0,0,0,2773,2774,1,0,0,0,2774,2776,1,0,0,0,2775,2777,5,84,0,0,2776,
  	2775,1,0,0,0,2776,2777,1,0,0,0,2777,387,1,0,0,0,2778,2779,3,492,246,0,
  	2779,389,1,0,0,0,2780,2783,3,410,205,0,2781,2783,3,398,199,0,2782,2780,
  	1,0,0,0,2782,2781,1,0,0,0,2783,391,1,0,0,0,2784,2787,3,410,205,0,2785,
  	2787,3,400,200,0,2786,2784,1,0,0,0,2786,2785,1,0,0,0,2787,393,1,0,0,0,
  	2788,2791,3,410,205,0,2789,2791,3,404,202,0,2790,2788,1,0,0,0,2790,2789,
  	1,0,0,0,2791,395,1,0,0,0,2792,2795,3,410,205,0,2793,2795,3,406,203,0,
  	2794,2792,1,0,0,0,2794,2793,1,0,0,0,2795,397,1,0,0,0,2796,2800,3,408,
  	204,0,2797,2800,5,67,0,0,2798,2800,5,65,0,0,2799,2796,1,0,0,0,2799,2797,
  	1,0,0,0,2799,2798,1,0,0,0,2800,399,1,0,0,0,2801,2805,3,408,204,0,2802,
  	2805,5,66,0,0,2803,2805,5,64,0,0,2804,2801,1,0,0,0,2804,2802,1,0,0,0,
  	2804,2803,1,0,0,0,2805,401,1,0,0,0,2806,2810,3,408,204,0,2807,2810,5,
  	67,0,0,2808,2810,5,66,0,0,2809,2806,1,0,0,0,2809,2807,1,0,0,0,2809,2808,
  	1,0,0,0,2810,403,1,0,0,0,2811,2815,3,408,204,0,2812,2815,5,128,0,0,2813,
  	2815,5,67,0,0,2814,2811,1,0,0,0,2814,2812,1,0,0,0,2814,2813,1,0,0,0,2815,
  	405,1,0,0,0,2816,2820,3,408,204,0,2817,2820,5,128,0,0,2818,2820,5,66,
  	0,0,2819,2816,1,0,0,0,2819,2817,1,0,0,0,2819,2818,1,0,0,0,2820,407,1,
  	0,0,0,2821,2928,5,8,0,0,2822,2928,5,10,0,0,2823,2928,5,11,0,0,2824,2928,
  	5,12,0,0,2825,2928,5,13,0,0,2826,2928,5,14,0,0,2827,2928,5,15,0,0,2828,
  	2928,5,16,0,0,2829,2928,5,17,0,0,2830,2928,5,18,0,0,2831,2928,5,19,0,
  	0,2832,2928,5,20,0,0,2833,2928,5,21,0,0,2834,2928,5,22,0,0,2835,2928,
  	5,23,0,0,2836,2928,5,24,0,0,2837,2928,5,25,0,0,2838,2928,5,26,0,0,2839,
  	2928,5,27,0,0,2840,2928,5,28,0,0,2841,2928,5,29,0,0,2842,2928,5,30,0,
  	0,2843,2928,5,31,0,0,2844,2928,5,32,0,0,2845,2928,5,33,0,0,2846,2928,
  	5,35,0,0,2847,2928,5,36,0,0,2848,2928,5,37,0,0,2849,2928,5,38,0,0,2850,
  	2928,5,39,0,0,2851,2928,5,40,0,0,2852,2928,5,41,0,0,2853,2928,5,42,0,
  	0,2854,2928,5,43,0,0,2855,2928,5,44,0,0,2856,2928,5,45,0,0,2857,2928,
  	5,46,0,0,2858,2928,5,47,0,0,2859,2928,5,48,0,0,2860,2928,5,49,0,0,2861,
  	2928,5,50,0,0,2862,2928,5,51,0,0,2863,2928,5,52,0,0,2864,2928,5,53,0,
  	0,2865,2928,5,54,0,0,2866,2928,5,55,0,0,2867,2928,5,56,0,0,2868,2928,
  	5,57,0,0,2869,2928,5,58,0,0,2870,2928,5,62,0,0,2871,2928,5,75,0,0,2872,
  	2928,5,76,0,0,2873,2928,5,80,0,0,2874,2928,5,79,0,0,2875,2928,5,78,0,
  	0,2876,2928,5,81,0,0,2877,2928,5,82,0,0,2878,2928,5,83,0,0,2879,2928,
  	5,84,0,0,2880,2928,5,85,0,0,2881,2928,5,86,0,0,2882,2928,5,87,0,0,2883,
  	2928,5,88,0,0,2884,2928,5,89,0,0,2885,2928,5,90,0,0,2886,2928,5,91,0,
  	0,2887,2928,5,92,0,0,2888,2928,5,93,0,0,2889,2928,5,94,0,0,2890,2928,
  	5,95,0,0,2891,2928,5,96,0,0,2892,2928,5,97,0,0,2893,2928,5,98,0,0,2894,
  	2928,5,99,0,0,2895,2928,5,100,0,0,2896,2928,5,101,0,0,2897,2898,5,102,
  	0,0,2898,2928,5,102,0,0,2899,2900,5,103,0,0,2900,2928,5,103,0,0,2901,
  	2928,5,104,0,0,2902,2928,5,105,0,0,2903,2928,5,106,0,0,2904,2928,5,107,
  	0,0,2905,2928,5,108,0,0,2906,2928,5,109,0,0,2907,2928,5,110,0,0,2908,
  	2928,5,111,0,0,2909,2928,5,112,0,0,2910,2928,5,113,0,0,2911,2928,5,114,
  	0,0,2912,2928,5,115,0,0,2913,2928,5,116,0,0,2914,2928,5,117,0,0,2915,
  	2928,5,118,0,0,2916,2928,5,119,0,0,2917,2928,5,120,0,0,2918,2928,5,121,
  	0,0,2919,2928,5,122,0,0,2920,2928,5,123,0,0,2921,2928,5,124,0,0,2922,
  	2928,5,125,0,0,2923,2928,5,126,0,0,2924,2928,5,127,0,0,2925,2928,5,129,
  	0,0,2926,2928,5,132,0,0,2927,2821,1,0,0,0,2927,2822,1,0,0,0,2927,2823,
  	1,0,0,0,2927,2824,1,0,0,0,2927,2825,1,0,0,0,2927,2826,1,0,0,0,2927,2827,
  	1,0,0,0,2927,2828,1,0,0,0,2927,2829,1,0,0,0,2927,2830,1,0,0,0,2927,2831,
  	1,0,0,0,2927,2832,1,0,0,0,2927,2833,1,0,0,0,2927,2834,1,0,0,0,2927,2835,
  	1,0,0,0,2927,2836,1,0,0,0,2927,2837,1,0,0,0,2927,2838,1,0,0,0,2927,2839,
  	1,0,0,0,2927,2840,1,0,0,0,2927,2841,1,0,0,0,2927,2842,1,0,0,0,2927,2843,
  	1,0,0,0,2927,2844,1,0,0,0,2927,2845,1,0,0,0,2927,2846,1,0,0,0,2927,2847,
  	1,0,0,0,2927,2848,1,0,0,0,2927,2849,1,0,0,0,2927,2850,1,0,0,0,2927,2851,
  	1,0,0,0,2927,2852,1,0,0,0,2927,2853,1,0,0,0,2927,2854,1,0,0,0,2927,2855,
  	1,0,0,0,2927,2856,1,0,0,0,2927,2857,1,0,0,0,2927,2858,1,0,0,0,2927,2859,
  	1,0,0,0,2927,2860,1,0,0,0,2927,2861,1,0,0,0,2927,2862,1,0,0,0,2927,2863,
  	1,0,0,0,2927,2864,1,0,0,0,2927,2865,1,0,0,0,2927,2866,1,0,0,0,2927,2867,
  	1,0,0,0,2927,2868,1,0,0,0,2927,2869,1,0,0,0,2927,2870,1,0,0,0,2927,2871,
  	1,0,0,0,2927,2872,1,0,0,0,2927,2873,1,0,0,0,2927,2874,1,0,0,0,2927,2875,
  	1,0,0,0,2927,2876,1,0,0,0,2927,2877,1,0,0,0,2927,2878,1,0,0,0,2927,2879,
  	1,0,0,0,2927,2880,1,0,0,0,2927,2881,1,0,0,0,2927,2882,1,0,0,0,2927,2883,
  	1,0,0,0,2927,2884,1,0,0,0,2927,2885,1,0,0,0,2927,2886,1,0,0,0,2927,2887,
  	1,0,0,0,2927,2888,1,0,0,0,2927,2889,1,0,0,0,2927,2890,1,0,0,0,2927,2891,
  	1,0,0,0,2927,2892,1,0,0,0,2927,2893,1,0,0,0,2927,2894,1,0,0,0,2927,2895,
  	1,0,0,0,2927,2896,1,0,0,0,2927,2897,1,0,0,0,2927,2899,1,0,0,0,2927,2901,
  	1,0,0,0,2927,2902,1,0,0,0,2927,2903,1,0,0,0,2927,2904,1,0,0,0,2927,2905,
  	1,0,0,0,2927,2906,1,0,0,0,2927,2907,1,0,0,0,2927,2908,1,0,0,0,2927,2909,
  	1,0,0,0,2927,2910,1,0,0,0,2927,2911,1,0,0,0,2927,2912,1,0,0,0,2927,2913,
  	1,0,0,0,2927,2914,1,0,0,0,2927,2915,1,0,0,0,2927,2916,1,0,0,0,2927,2917,
  	1,0,0,0,2927,2918,1,0,0,0,2927,2919,1,0,0,0,2927,2920,1,0,0,0,2927,2921,
  	1,0,0,0,2927,2922,1,0,0,0,2927,2923,1,0,0,0,2927,2924,1,0,0,0,2927,2925,
  	1,0,0,0,2927,2926,1,0,0,0,2928,2929,1,0,0,0,2929,2927,1,0,0,0,2929,2930,
  	1,0,0,0,2930,409,1,0,0,0,2931,2934,5,102,0,0,2932,2935,3,296,148,0,2933,
  	2935,3,298,149,0,2934,2932,1,0,0,0,2934,2933,1,0,0,0,2935,2937,1,0,0,
  	0,2936,2938,5,88,0,0,2937,2936,1,0,0,0,2937,2938,1,0,0,0,2938,2940,1,
  	0,0,0,2939,2941,3,412,206,0,2940,2939,1,0,0,0,2940,2941,1,0,0,0,2941,
  	2943,1,0,0,0,2942,2944,3,414,207,0,2943,2942,1,0,0,0,2943,2944,1,0,0,
  	0,2944,2945,1,0,0,0,2945,2946,5,103,0,0,2946,411,1,0,0,0,2947,2948,5,
  	127,0,0,2948,2949,3,492,246,0,2949,413,1,0,0,0,2950,2954,5,85,0,0,2951,
  	2953,3,416,208,0,2952,2951,1,0,0,0,2953,2956,1,0,0,0,2954,2952,1,0,0,
  	0,2954,2955,1,0,0,0,2955,415,1,0,0,0,2956,2954,1,0,0,0,2957,2960,3,410,
  	205,0,2958,2960,3,402,201,0,2959,2957,1,0,0,0,2959,2958,1,0,0,0,2960,
  	417,1,0,0,0,2961,2965,5,3,0,0,2962,2964,3,390,195,0,2963,2962,1,0,0,0,
  	2964,2967,1,0,0,0,2965,2963,1,0,0,0,2965,2966,1,0,0,0,2966,2968,1,0,0,
  	0,2967,2965,1,0,0,0,2968,2994,5,66,0,0,2969,2973,5,4,0,0,2970,2972,3,
  	392,196,0,2971,2970,1,0,0,0,2972,2975,1,0,0,0,2973,2971,1,0,0,0,2973,
  	2974,1,0,0,0,2974,2976,1,0,0,0,2975,2973,1,0,0,0,2976,2994,5,67,0,0,2977,
  	2981,5,5,0,0,2978,2980,3,394,197,0,2979,2978,1,0,0,0,2980,2983,1,0,0,
  	0,2981,2979,1,0,0,0,2981,2982,1,0,0,0,2982,2984,1,0,0,0,2983,2981,1,0,
  	0,0,2984,2994,5,64,0,0,2985,2989,5,6,0,0,2986,2988,3,396,198,0,2987,2986,
  	1,0,0,0,2988,2991,1,0,0,0,2989,2987,1,0,0,0,2989,2990,1,0,0,0,2990,2992,
  	1,0,0,0,2991,2989,1,0,0,0,2992,2994,5,65,0,0,2993,2961,1,0,0,0,2993,2969,
  	1,0,0,0,2993,2977,1,0,0,0,2993,2985,1,0,0,0,2994,419,1,0,0,0,2995,2996,
  	5,7,0,0,2996,421,1,0,0,0,2997,3000,3,418,209,0,2998,3000,3,420,210,0,
  	2999,2997,1,0,0,0,2999,2998,1,0,0,0,3000,3001,1,0,0,0,3001,2999,1,0,0,
  	0,3001,3002,1,0,0,0,3002,423,1,0,0,0,3003,3005,5,89,0,0,3004,3006,3,302,
  	151,0,3005,3004,1,0,0,0,3005,3006,1,0,0,0,3006,3007,1,0,0,0,3007,3008,
  	5,90,0,0,3008,425,1,0,0,0,3009,3014,5,82,0,0,3010,3011,3,304,152,0,3011,
  	3012,5,84,0,0,3012,3013,3,302,151,0,3013,3015,1,0,0,0,3014,3010,1,0,0,
  	0,3014,3015,1,0,0,0,3015,3016,1,0,0,0,3016,3017,5,83,0,0,3017,427,1,0,
  	0,0,3018,3019,5,102,0,0,3019,3020,3,302,151,0,3020,3021,5,103,0,0,3021,
  	429,1,0,0,0,3022,3024,5,102,0,0,3023,3025,3,432,216,0,3024,3023,1,0,0,
  	0,3024,3025,1,0,0,0,3025,3026,1,0,0,0,3026,3027,5,103,0,0,3027,431,1,
  	0,0,0,3028,3033,3,434,217,0,3029,3030,5,84,0,0,3030,3032,3,434,217,0,
  	3031,3029,1,0,0,0,3032,3035,1,0,0,0,3033,3031,1,0,0,0,3033,3034,1,0,0,
  	0,3034,3037,1,0,0,0,3035,3033,1,0,0,0,3036,3038,5,84,0,0,3037,3036,1,
  	0,0,0,3037,3038,1,0,0,0,3038,433,1,0,0,0,3039,3040,5,87,0,0,3040,3043,
  	3,340,170,0,3041,3043,3,436,218,0,3042,3039,1,0,0,0,3042,3041,1,0,0,0,
  	3043,435,1,0,0,0,3044,3045,3,294,147,0,3045,3046,5,85,0,0,3046,3047,3,
  	294,147,0,3047,437,1,0,0,0,3048,3050,3,440,220,0,3049,3048,1,0,0,0,3050,
  	3051,1,0,0,0,3051,3049,1,0,0,0,3051,3052,1,0,0,0,3052,439,1,0,0,0,3053,
  	3055,5,15,0,0,3054,3053,1,0,0,0,3054,3055,1,0,0,0,3055,3056,1,0,0,0,3056,
  	3057,5,28,0,0,3057,3058,3,464,232,0,3058,3059,5,33,0,0,3059,3064,3,310,
  	155,0,3060,3061,5,31,0,0,3061,3063,3,310,155,0,3062,3060,1,0,0,0,3063,
  	3066,1,0,0,0,3064,3062,1,0,0,0,3064,3065,1,0,0,0,3065,441,1,0,0,0,3066,
  	3064,1,0,0,0,3067,3068,5,89,0,0,3068,3069,3,308,154,0,3069,3070,3,438,
  	219,0,3070,3071,5,90,0,0,3071,443,1,0,0,0,3072,3073,5,102,0,0,3073,3074,
  	3,308,154,0,3074,3075,3,438,219,0,3075,3076,5,103,0,0,3076,445,1,0,0,
  	0,3077,3080,5,82,0,0,3078,3081,3,306,153,0,3079,3081,3,294,147,0,3080,
  	3078,1,0,0,0,3080,3079,1,0,0,0,3081,3082,1,0,0,0,3082,3083,3,438,219,
  	0,3083,3084,5,83,0,0,3084,447,1,0,0,0,3085,3086,5,102,0,0,3086,3087,3,
  	436,218,0,3087,3088,3,438,219,0,3088,3089,5,103,0,0,3089,449,1,0,0,0,
  	3090,3092,3,452,226,0,3091,3093,5,84,0,0,3092,3091,1,0,0,0,3092,3093,
  	1,0,0,0,3093,451,1,0,0,0,3094,3099,3,454,227,0,3095,3096,5,84,0,0,3096,
  	3098,3,454,227,0,3097,3095,1,0,0,0,3098,3101,1,0,0,0,3099,3097,1,0,0,
  	0,3099,3100,1,0,0,0,3100,3104,1,0,0,0,3101,3099,1,0,0,0,3102,3103,5,84,
  	0,0,3103,3105,3,456,228,0,3104,3102,1,0,0,0,3104,3105,1,0,0,0,3105,3108,
  	1,0,0,0,3106,3108,3,456,228,0,3107,3094,1,0,0,0,3107,3106,1,0,0,0,3108,
  	453,1,0,0,0,3109,3114,3,54,27,0,3110,3114,3,458,229,0,3111,3114,3,306,
  	153,0,3112,3114,3,294,147,0,3113,3109,1,0,0,0,3113,3110,1,0,0,0,3113,
  	3111,1,0,0,0,3113,3112,1,0,0,0,3114,455,1,0,0,0,3115,3120,3,460,230,0,
  	3116,3117,5,84,0,0,3117,3119,3,460,230,0,3118,3116,1,0,0,0,3119,3122,
  	1,0,0,0,3120,3118,1,0,0,0,3120,3121,1,0,0,0,3121,3123,1,0,0,0,3122,3120,
  	1,0,0,0,3123,3124,5,84,0,0,3124,3129,3,462,231,0,3125,3126,5,84,0,0,3126,
  	3128,3,462,231,0,3127,3125,1,0,0,0,3128,3131,1,0,0,0,3129,3127,1,0,0,
  	0,3129,3130,1,0,0,0,3130,3149,1,0,0,0,3131,3129,1,0,0,0,3132,3137,3,460,
  	230,0,3133,3134,5,84,0,0,3134,3136,3,460,230,0,3135,3133,1,0,0,0,3136,
  	3139,1,0,0,0,3137,3135,1,0,0,0,3137,3138,1,0,0,0,3138,3149,1,0,0,0,3139,
  	3137,1,0,0,0,3140,3145,3,462,231,0,3141,3142,5,84,0,0,3142,3144,3,462,
  	231,0,3143,3141,1,0,0,0,3144,3147,1,0,0,0,3145,3143,1,0,0,0,3145,3146,
  	1,0,0,0,3146,3149,1,0,0,0,3147,3145,1,0,0,0,3148,3115,1,0,0,0,3148,3132,
  	1,0,0,0,3148,3140,1,0,0,0,3149,457,1,0,0,0,3150,3151,5,81,0,0,3151,3152,
  	3,294,147,0,3152,459,1,0,0,0,3153,3154,3,492,246,0,3154,3155,5,88,0,0,
  	3155,3156,3,294,147,0,3156,3159,1,0,0,0,3157,3159,3,458,229,0,3158,3153,
  	1,0,0,0,3158,3157,1,0,0,0,3159,461,1,0,0,0,3160,3161,3,492,246,0,3161,
  	3162,5,88,0,0,3162,3163,3,294,147,0,3163,3167,1,0,0,0,3164,3165,5,87,
  	0,0,3165,3167,3,294,147,0,3166,3160,1,0,0,0,3166,3164,1,0,0,0,3167,463,
  	1,0,0,0,3168,3173,3,470,235,0,3169,3170,5,84,0,0,3170,3172,3,470,235,
  	0,3171,3169,1,0,0,0,3172,3175,1,0,0,0,3173,3171,1,0,0,0,3173,3174,1,0,
  	0,0,3174,3177,1,0,0,0,3175,3173,1,0,0,0,3176,3178,5,84,0,0,3177,3176,
  	1,0,0,0,3177,3178,1,0,0,0,3178,465,1,0,0,0,3179,3184,3,470,235,0,3180,
  	3181,5,84,0,0,3181,3183,3,470,235,0,3182,3180,1,0,0,0,3183,3186,1,0,0,
  	0,3184,3182,1,0,0,0,3184,3185,1,0,0,0,3185,3188,1,0,0,0,3186,3184,1,0,
  	0,0,3187,3189,5,84,0,0,3188,3187,1,0,0,0,3188,3189,1,0,0,0,3189,467,1,
  	0,0,0,3190,3193,3,470,235,0,3191,3192,5,84,0,0,3192,3194,3,470,235,0,
  	3193,3191,1,0,0,0,3194,3195,1,0,0,0,3195,3193,1,0,0,0,3195,3196,1,0,0,
  	0,3196,3198,1,0,0,0,3197,3199,5,84,0,0,3198,3197,1,0,0,0,3198,3199,1,
  	0,0,0,3199,3204,1,0,0,0,3200,3201,3,470,235,0,3201,3202,5,84,0,0,3202,
  	3204,1,0,0,0,3203,3190,1,0,0,0,3203,3200,1,0,0,0,3204,469,1,0,0,0,3205,
  	3206,5,81,0,0,3206,3209,3,470,235,0,3207,3209,3,472,236,0,3208,3205,1,
  	0,0,0,3208,3207,1,0,0,0,3209,471,1,0,0,0,3210,3211,3,480,240,0,3211,3212,
  	5,80,0,0,3212,3213,3,492,246,0,3213,3221,1,0,0,0,3214,3215,3,480,240,
  	0,3215,3216,5,89,0,0,3216,3217,3,360,180,0,3217,3218,5,90,0,0,3218,3221,
  	1,0,0,0,3219,3221,3,474,237,0,3220,3210,1,0,0,0,3220,3214,1,0,0,0,3220,
  	3219,1,0,0,0,3221,473,1,0,0,0,3222,3238,3,492,246,0,3223,3224,5,82,0,
  	0,3224,3225,3,472,236,0,3225,3226,5,83,0,0,3226,3238,1,0,0,0,3227,3229,
  	5,82,0,0,3228,3230,3,468,234,0,3229,3228,1,0,0,0,3229,3230,1,0,0,0,3230,
  	3231,1,0,0,0,3231,3238,5,83,0,0,3232,3234,5,89,0,0,3233,3235,3,466,233,
  	0,3234,3233,1,0,0,0,3234,3235,1,0,0,0,3235,3236,1,0,0,0,3236,3238,5,90,
  	0,0,3237,3222,1,0,0,0,3237,3223,1,0,0,0,3237,3227,1,0,0,0,3237,3232,1,
  	0,0,0,3238,475,1,0,0,0,3239,3246,3,478,239,0,3240,3246,3,492,246,0,3241,
  	3242,5,82,0,0,3242,3243,3,476,238,0,3243,3244,5,83,0,0,3244,3246,1,0,
  	0,0,3245,3239,1,0,0,0,3245,3240,1,0,0,0,3245,3241,1,0,0,0,3246,477,1,
  	0,0,0,3247,3248,3,480,240,0,3248,3249,5,80,0,0,3249,3250,3,492,246,0,
  	3250,3257,1,0,0,0,3251,3252,3,480,240,0,3252,3253,5,89,0,0,3253,3254,
  	3,360,180,0,3254,3255,5,90,0,0,3255,3257,1,0,0,0,3256,3247,1,0,0,0,3256,
  	3251,1,0,0,0,3257,479,1,0,0,0,3258,3259,6,240,-1,0,3259,3260,3,364,182,
  	0,3260,3279,1,0,0,0,3261,3262,10,5,0,0,3262,3263,5,80,0,0,3263,3278,3,
  	492,246,0,3264,3265,10,4,0,0,3265,3266,5,89,0,0,3266,3267,3,360,180,0,
  	3267,3268,5,90,0,0,3268,3278,1,0,0,0,3269,3270,10,3,0,0,3270,3278,3,446,
  	223,0,3271,3272,10,2,0,0,3272,3274,5,82,0,0,3273,3275,3,450,225,0,3274,
  	3273,1,0,0,0,3274,3275,1,0,0,0,3275,3276,1,0,0,0,3276,3278,5,83,0,0,3277,
  	3261,1,0,0,0,3277,3264,1,0,0,0,3277,3269,1,0,0,0,3277,3271,1,0,0,0,3278,
  	3281,1,0,0,0,3279,3277,1,0,0,0,3279,3280,1,0,0,0,3280,481,1,0,0,0,3281,
  	3279,1,0,0,0,3282,3287,3,484,242,0,3283,3284,5,84,0,0,3284,3286,3,484,
  	242,0,3285,3283,1,0,0,0,3286,3289,1,0,0,0,3287,3285,1,0,0,0,3287,3288,
  	1,0,0,0,3288,3291,1,0,0,0,3289,3287,1,0,0,0,3290,3292,5,84,0,0,3291,3290,
  	1,0,0,0,3291,3292,1,0,0,0,3292,483,1,0,0,0,3293,3294,3,480,240,0,3294,
  	3295,5,80,0,0,3295,3296,3,492,246,0,3296,3304,1,0,0,0,3297,3298,3,480,
  	240,0,3298,3299,5,89,0,0,3299,3300,3,360,180,0,3300,3301,5,90,0,0,3301,
  	3304,1,0,0,0,3302,3304,3,486,243,0,3303,3293,1,0,0,0,3303,3297,1,0,0,
  	0,3303,3302,1,0,0,0,3304,485,1,0,0,0,3305,3317,3,492,246,0,3306,3308,
  	5,82,0,0,3307,3309,3,482,241,0,3308,3307,1,0,0,0,3308,3309,1,0,0,0,3309,
  	3310,1,0,0,0,3310,3317,5,83,0,0,3311,3313,5,89,0,0,3312,3314,3,482,241,
  	0,3313,3312,1,0,0,0,3313,3314,1,0,0,0,3314,3315,1,0,0,0,3315,3317,5,90,
  	0,0,3316,3305,1,0,0,0,3316,3306,1,0,0,0,3316,3311,1,0,0,0,3317,487,1,
  	0,0,0,3318,3323,3,294,147,0,3319,3320,5,84,0,0,3320,3322,3,294,147,0,
  	3321,3319,1,0,0,0,3322,3325,1,0,0,0,3323,3321,1,0,0,0,3323,3324,1,0,0,
  	0,3324,3326,1,0,0,0,3325,3323,1,0,0,0,3326,3327,5,84,0,0,3327,3328,5,
  	81,0,0,3328,3329,3,294,147,0,3329,3330,5,84,0,0,3330,3331,5,87,0,0,3331,
  	3332,3,294,147,0,3332,3376,1,0,0,0,3333,3338,3,294,147,0,3334,3335,5,
  	84,0,0,3335,3337,3,294,147,0,3336,3334,1,0,0,0,3337,3340,1,0,0,0,3338,
  	3336,1,0,0,0,3338,3339,1,0,0,0,3339,3341,1,0,0,0,3340,3338,1,0,0,0,3341,
  	3342,5,84,0,0,3342,3343,5,81,0,0,3343,3344,3,294,147,0,3344,3376,1,0,
  	0,0,3345,3350,3,294,147,0,3346,3347,5,84,0,0,3347,3349,3,294,147,0,3348,
  	3346,1,0,0,0,3349,3352,1,0,0,0,3350,3348,1,0,0,0,3350,3351,1,0,0,0,3351,
  	3353,1,0,0,0,3352,3350,1,0,0,0,3353,3354,5,84,0,0,3354,3355,5,87,0,0,
  	3355,3356,3,294,147,0,3356,3376,1,0,0,0,3357,3358,5,81,0,0,3358,3359,
  	3,294,147,0,3359,3360,5,84,0,0,3360,3361,5,87,0,0,3361,3362,3,294,147,
  	0,3362,3376,1,0,0,0,3363,3364,5,81,0,0,3364,3376,3,294,147,0,3365,3366,
  	5,87,0,0,3366,3376,3,294,147,0,3367,3372,3,294,147,0,3368,3369,5,84,0,
  	0,3369,3371,3,294,147,0,3370,3368,1,0,0,0,3371,3374,1,0,0,0,3372,3370,
  	1,0,0,0,3372,3373,1,0,0,0,3373,3376,1,0,0,0,3374,3372,1,0,0,0,3375,3318,
  	1,0,0,0,3375,3333,1,0,0,0,3375,3345,1,0,0,0,3375,3357,1,0,0,0,3375,3363,
  	1,0,0,0,3375,3365,1,0,0,0,3375,3367,1,0,0,0,3376,489,1,0,0,0,3377,3378,
  	5,128,0,0,3378,491,1,0,0,0,3379,3380,7,4,0,0,3380,493,1,0,0,0,413,500,
  	507,512,520,525,533,539,542,547,553,561,567,570,575,581,590,596,599,604,
  	607,614,621,629,648,652,656,667,673,678,703,706,708,713,721,729,735,744,
  	747,752,758,767,770,775,781,789,802,815,823,832,835,844,854,857,866,876,
  	879,888,898,901,909,918,921,930,940,943,952,962,965,974,984,987,994,997,
  	999,1007,1020,1034,1048,1061,1074,1088,1102,1110,1117,1125,1134,1148,
  	1160,1164,1170,1181,1183,1197,1204,1211,1215,1221,1228,1232,1236,1240,
  	1243,1247,1251,1253,1257,1262,1269,1281,1289,1296,1305,1309,1312,1315,
  	1319,1326,1329,1337,1341,1345,1353,1357,1361,1363,1367,1374,1381,1385,
  	1390,1395,1399,1415,1425,1432,1439,1445,1452,1456,1462,1464,1468,1474,
  	1480,1483,1491,1500,1512,1516,1525,1536,1540,1545,1551,1558,1564,1571,
  	1577,1587,1596,1604,1607,1614,1618,1621,1627,1632,1637,1641,1646,1650,
  	1660,1666,1670,1676,1680,1685,1690,1694,1699,1702,1705,1710,1714,1719,
  	1725,1729,1736,1740,1747,1751,1758,1761,1764,1773,1779,1788,1792,1798,
  	1800,1804,1829,1831,1844,1846,1857,1866,1876,1878,1887,1891,1903,1917,
  	1921,1934,1940,1947,1960,1963,1966,1974,1977,1980,1982,1988,1996,2003,
  	2020,2027,2030,2035,2045,2049,2060,2071,2079,2087,2097,2102,2107,2133,
  	2142,2147,2150,2155,2162,2166,2170,2176,2183,2192,2199,2203,2210,2215,
  	2231,2239,2249,2253,2260,2268,2278,2292,2296,2300,2306,2316,2320,2330,
  	2337,2339,2346,2350,2356,2363,2367,2372,2380,2387,2395,2401,2407,2420,
  	2429,2465,2476,2487,2499,2501,2513,2515,2536,2538,2548,2555,2560,2573,
  	2581,2583,2588,2593,2597,2601,2604,2608,2612,2614,2617,2629,2633,2639,
  	2642,2647,2653,2664,2670,2674,2680,2684,2689,2694,2698,2703,2706,2709,
  	2714,2718,2723,2729,2733,2740,2744,2751,2754,2757,2764,2769,2773,2776,
  	2782,2786,2790,2794,2799,2804,2809,2814,2819,2927,2929,2934,2937,2940,
  	2943,2954,2959,2965,2973,2981,2989,2993,2999,3001,3005,3014,3024,3033,
  	3037,3042,3051,3054,3064,3080,3092,3099,3104,3107,3113,3120,3129,3137,
  	3145,3148,3158,3166,3173,3177,3184,3188,3195,3198,3203,3208,3220,3229,
  	3234,3237,3245,3256,3274,3277,3279,3287,3291,3303,3308,3313,3316,3323,
  	3338,3350,3372,3375
  };
  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));

  antlr4::atn::ATNDeserializer deserializer;
  staticData->atn = deserializer.deserialize(staticData->serializedATN);

  const size_t count = staticData->atn->getNumberOfDecisions();
  staticData->decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
  }
  fandangoparserParserStaticData = std::move(staticData);
}

}

FandangoParser::FandangoParser(TokenStream *input) : FandangoParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}

FandangoParser::FandangoParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
  FandangoParser::initialize();
  _interpreter = new atn::ParserATNSimulator(this, *fandangoparserParserStaticData->atn, fandangoparserParserStaticData->decisionToDFA, fandangoparserParserStaticData->sharedContextCache, options);
}

FandangoParser::~FandangoParser() {
  delete _interpreter;
}

const atn::ATN& FandangoParser::getATN() const {
  return *fandangoparserParserStaticData->atn;
}

std::string FandangoParser::getGrammarFileName() const {
  return "FandangoParser.g4";
}

const std::vector<std::string>& FandangoParser::getRuleNames() const {
  return fandangoparserParserStaticData->ruleNames;
}

const dfa::Vocabulary& FandangoParser::getVocabulary() const {
  return fandangoparserParserStaticData->vocabulary;
}

antlr4::atn::SerializedATNView FandangoParser::getSerializedATN() const {
  return fandangoparserParserStaticData->serializedATN;
}


//----------------- FandangoContext ------------------------------------------------------------------

FandangoParser::FandangoContext::FandangoContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ProgramContext* FandangoParser::FandangoContext::program() {
  return getRuleContext<FandangoParser::ProgramContext>(0);
}

tree::TerminalNode* FandangoParser::FandangoContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}


size_t FandangoParser::FandangoContext::getRuleIndex() const {
  return FandangoParser::RuleFandango;
}


std::any FandangoParser::FandangoContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFandango(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::FandangoContext* FandangoParser::fandango() {
  FandangoContext *_localctx = _tracker.createInstance<FandangoContext>(_ctx, getState());
  enterRule(_localctx, 0, FandangoParser::RuleFandango);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(494);
    program();
    setState(495);
    match(FandangoParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProgramContext ------------------------------------------------------------------

FandangoParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FandangoParser::ProgramContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::ProgramContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}

std::vector<FandangoParser::StatementContext *> FandangoParser::ProgramContext::statement() {
  return getRuleContexts<FandangoParser::StatementContext>();
}

FandangoParser::StatementContext* FandangoParser::ProgramContext::statement(size_t i) {
  return getRuleContext<FandangoParser::StatementContext>(i);
}


size_t FandangoParser::ProgramContext::getRuleIndex() const {
  return FandangoParser::RuleProgram;
}


std::any FandangoParser::ProgramContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitProgram(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ProgramContext* FandangoParser::program() {
  ProgramContext *_localctx = _tracker.createInstance<ProgramContext>(_ctx, getState());
  enterRule(_localctx, 2, FandangoParser::RuleProgram);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(500);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::NEWLINE) {
      setState(497);
      match(FandangoParser::NEWLINE);
      setState(502);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(512);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5764605280868090362) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 8683006489) != 0)) {
      setState(503);
      statement();
      setState(507);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::NEWLINE) {
        setState(504);
        match(FandangoParser::NEWLINE);
        setState(509);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(514);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementContext ------------------------------------------------------------------

FandangoParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ProductionContext* FandangoParser::StatementContext::production() {
  return getRuleContext<FandangoParser::ProductionContext>(0);
}

FandangoParser::ConstraintContext* FandangoParser::StatementContext::constraint() {
  return getRuleContext<FandangoParser::ConstraintContext>(0);
}

FandangoParser::IncludeContext* FandangoParser::StatementContext::include() {
  return getRuleContext<FandangoParser::IncludeContext>(0);
}

FandangoParser::Grammar_settingContext* FandangoParser::StatementContext::grammar_setting() {
  return getRuleContext<FandangoParser::Grammar_settingContext>(0);
}

FandangoParser::PythonContext* FandangoParser::StatementContext::python() {
  return getRuleContext<FandangoParser::PythonContext>(0);
}


size_t FandangoParser::StatementContext::getRuleIndex() const {
  return FandangoParser::RuleStatement;
}


std::any FandangoParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStatement(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::StatementContext* FandangoParser::statement() {
  StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
  enterRule(_localctx, 4, FandangoParser::RuleStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(520);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(515);
      production();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(516);
      constraint();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(517);
      include();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(518);
      grammar_setting();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(519);
      python();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProductionContext ------------------------------------------------------------------

FandangoParser::ProductionContext::ProductionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::NonterminalContext* FandangoParser::ProductionContext::nonterminal() {
  return getRuleContext<FandangoParser::NonterminalContext>(0);
}

tree::TerminalNode* FandangoParser::ProductionContext::GRAMMAR_ASSIGN() {
  return getToken(FandangoParser::GRAMMAR_ASSIGN, 0);
}

FandangoParser::AlternativeContext* FandangoParser::ProductionContext::alternative() {
  return getRuleContext<FandangoParser::AlternativeContext>(0);
}

tree::TerminalNode* FandangoParser::ProductionContext::SEMI_COLON() {
  return getToken(FandangoParser::SEMI_COLON, 0);
}

tree::TerminalNode* FandangoParser::ProductionContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::ProductionContext::INDENT() {
  return getTokens(FandangoParser::INDENT);
}

tree::TerminalNode* FandangoParser::ProductionContext::INDENT(size_t i) {
  return getToken(FandangoParser::INDENT, i);
}

tree::TerminalNode* FandangoParser::ProductionContext::EXPR_ASSIGN() {
  return getToken(FandangoParser::EXPR_ASSIGN, 0);
}

FandangoParser::ExpressionContext* FandangoParser::ProductionContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::ProductionContext::DEDENT() {
  return getTokens(FandangoParser::DEDENT);
}

tree::TerminalNode* FandangoParser::ProductionContext::DEDENT(size_t i) {
  return getToken(FandangoParser::DEDENT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::ProductionContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::ProductionContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}

tree::TerminalNode* FandangoParser::ProductionContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::ProductionContext::COLON() {
  return getTokens(FandangoParser::COLON);
}

tree::TerminalNode* FandangoParser::ProductionContext::COLON(size_t i) {
  return getToken(FandangoParser::COLON, i);
}


size_t FandangoParser::ProductionContext::getRuleIndex() const {
  return FandangoParser::RuleProduction;
}


std::any FandangoParser::ProductionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitProduction(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ProductionContext* FandangoParser::production() {
  ProductionContext *_localctx = _tracker.createInstance<ProductionContext>(_ctx, getState());
  enterRule(_localctx, 6, FandangoParser::RuleProduction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(607);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(525);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::INDENT) {
        setState(522);
        match(FandangoParser::INDENT);
        setState(527);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(528);
      nonterminal();
      setState(529);
      match(FandangoParser::GRAMMAR_ASSIGN);
      setState(530);
      alternative();
      setState(533);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::EXPR_ASSIGN) {
        setState(531);
        match(FandangoParser::EXPR_ASSIGN);
        setState(532);
        expression();
      }
      setState(542);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(535);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(537); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(536);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(539); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(541);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(547);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::DEDENT) {
        setState(544);
        match(FandangoParser::DEDENT);
        setState(549);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(553);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::INDENT) {
        setState(550);
        match(FandangoParser::INDENT);
        setState(555);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(556);
      nonterminal();
      setState(557);
      match(FandangoParser::GRAMMAR_ASSIGN);
      setState(558);
      alternative();
      setState(561);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ASSIGN) {
        setState(559);
        match(FandangoParser::ASSIGN);
        setState(560);
        expression();
      }
      setState(570);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(563);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(565); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(564);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(567); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(569);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(575);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::DEDENT) {
        setState(572);
        match(FandangoParser::DEDENT);
        setState(577);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(581);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::INDENT) {
        setState(578);
        match(FandangoParser::INDENT);
        setState(583);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(584);
      nonterminal();
      setState(585);
      match(FandangoParser::GRAMMAR_ASSIGN);
      setState(586);
      alternative();
      setState(590);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COLON) {
        setState(587);
        match(FandangoParser::COLON);
        setState(588);
        match(FandangoParser::COLON);
        setState(589);
        expression();
      }
      setState(599);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(592);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(594); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(593);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(596); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 16, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(598);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(604);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::DEDENT) {
        setState(601);
        match(FandangoParser::DEDENT);
        setState(606);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlternativeContext ------------------------------------------------------------------

FandangoParser::AlternativeContext::AlternativeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::ConcatenationContext *> FandangoParser::AlternativeContext::concatenation() {
  return getRuleContexts<FandangoParser::ConcatenationContext>();
}

FandangoParser::ConcatenationContext* FandangoParser::AlternativeContext::concatenation(size_t i) {
  return getRuleContext<FandangoParser::ConcatenationContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::AlternativeContext::OR_OP() {
  return getTokens(FandangoParser::OR_OP);
}

tree::TerminalNode* FandangoParser::AlternativeContext::OR_OP(size_t i) {
  return getToken(FandangoParser::OR_OP, i);
}


size_t FandangoParser::AlternativeContext::getRuleIndex() const {
  return FandangoParser::RuleAlternative;
}


std::any FandangoParser::AlternativeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAlternative(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::AlternativeContext* FandangoParser::alternative() {
  AlternativeContext *_localctx = _tracker.createInstance<AlternativeContext>(_ctx, getState());
  enterRule(_localctx, 8, FandangoParser::RuleAlternative);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(609);
    concatenation();
    setState(614);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::OR_OP) {
      setState(610);
      match(FandangoParser::OR_OP);
      setState(611);
      concatenation();
      setState(616);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConcatenationContext ------------------------------------------------------------------

FandangoParser::ConcatenationContext::ConcatenationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::OperatorContext *> FandangoParser::ConcatenationContext::operator_() {
  return getRuleContexts<FandangoParser::OperatorContext>();
}

FandangoParser::OperatorContext* FandangoParser::ConcatenationContext::operator_(size_t i) {
  return getRuleContext<FandangoParser::OperatorContext>(i);
}


size_t FandangoParser::ConcatenationContext::getRuleIndex() const {
  return FandangoParser::RuleConcatenation;
}


std::any FandangoParser::ConcatenationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitConcatenation(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ConcatenationContext* FandangoParser::concatenation() {
  ConcatenationContext *_localctx = _tracker.createInstance<ConcatenationContext>(_ctx, getState());
  enterRule(_localctx, 10, FandangoParser::RuleConcatenation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(617);
    operator_();
    setState(621);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116089176692883840) != 0) || ((((_la - 82) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 82)) & 4194433) != 0)) {
      setState(618);
      operator_();
      setState(623);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OperatorContext ------------------------------------------------------------------

FandangoParser::OperatorContext::OperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::SymbolContext* FandangoParser::OperatorContext::symbol() {
  return getRuleContext<FandangoParser::SymbolContext>(0);
}

FandangoParser::KleeneContext* FandangoParser::OperatorContext::kleene() {
  return getRuleContext<FandangoParser::KleeneContext>(0);
}

FandangoParser::PlusContext* FandangoParser::OperatorContext::plus() {
  return getRuleContext<FandangoParser::PlusContext>(0);
}

FandangoParser::OptionContext* FandangoParser::OperatorContext::option() {
  return getRuleContext<FandangoParser::OptionContext>(0);
}

FandangoParser::RepeatContext* FandangoParser::OperatorContext::repeat() {
  return getRuleContext<FandangoParser::RepeatContext>(0);
}


size_t FandangoParser::OperatorContext::getRuleIndex() const {
  return FandangoParser::RuleOperator;
}


std::any FandangoParser::OperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitOperator(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::OperatorContext* FandangoParser::operator_() {
  OperatorContext *_localctx = _tracker.createInstance<OperatorContext>(_ctx, getState());
  enterRule(_localctx, 12, FandangoParser::RuleOperator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(629);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(624);
      symbol();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(625);
      kleene();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(626);
      plus();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(627);
      option();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(628);
      repeat();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KleeneContext ------------------------------------------------------------------

FandangoParser::KleeneContext::KleeneContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::SymbolContext* FandangoParser::KleeneContext::symbol() {
  return getRuleContext<FandangoParser::SymbolContext>(0);
}

tree::TerminalNode* FandangoParser::KleeneContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}


size_t FandangoParser::KleeneContext::getRuleIndex() const {
  return FandangoParser::RuleKleene;
}


std::any FandangoParser::KleeneContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKleene(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::KleeneContext* FandangoParser::kleene() {
  KleeneContext *_localctx = _tracker.createInstance<KleeneContext>(_ctx, getState());
  enterRule(_localctx, 14, FandangoParser::RuleKleene);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(631);
    symbol();
    setState(632);
    match(FandangoParser::STAR);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PlusContext ------------------------------------------------------------------

FandangoParser::PlusContext::PlusContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::SymbolContext* FandangoParser::PlusContext::symbol() {
  return getRuleContext<FandangoParser::SymbolContext>(0);
}

tree::TerminalNode* FandangoParser::PlusContext::ADD() {
  return getToken(FandangoParser::ADD, 0);
}


size_t FandangoParser::PlusContext::getRuleIndex() const {
  return FandangoParser::RulePlus;
}


std::any FandangoParser::PlusContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPlus(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::PlusContext* FandangoParser::plus() {
  PlusContext *_localctx = _tracker.createInstance<PlusContext>(_ctx, getState());
  enterRule(_localctx, 16, FandangoParser::RulePlus);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(634);
    symbol();
    setState(635);
    match(FandangoParser::ADD);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionContext ------------------------------------------------------------------

FandangoParser::OptionContext::OptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::SymbolContext* FandangoParser::OptionContext::symbol() {
  return getRuleContext<FandangoParser::SymbolContext>(0);
}

tree::TerminalNode* FandangoParser::OptionContext::QUESTION() {
  return getToken(FandangoParser::QUESTION, 0);
}


size_t FandangoParser::OptionContext::getRuleIndex() const {
  return FandangoParser::RuleOption;
}


std::any FandangoParser::OptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitOption(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::OptionContext* FandangoParser::option() {
  OptionContext *_localctx = _tracker.createInstance<OptionContext>(_ctx, getState());
  enterRule(_localctx, 18, FandangoParser::RuleOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(637);
    symbol();
    setState(638);
    match(FandangoParser::QUESTION);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RepeatContext ------------------------------------------------------------------

FandangoParser::RepeatContext::RepeatContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::SymbolContext* FandangoParser::RepeatContext::symbol() {
  return getRuleContext<FandangoParser::SymbolContext>(0);
}

tree::TerminalNode* FandangoParser::RepeatContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

tree::TerminalNode* FandangoParser::RepeatContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}

std::vector<FandangoParser::ExpressionContext *> FandangoParser::RepeatContext::expression() {
  return getRuleContexts<FandangoParser::ExpressionContext>();
}

FandangoParser::ExpressionContext* FandangoParser::RepeatContext::expression(size_t i) {
  return getRuleContext<FandangoParser::ExpressionContext>(i);
}

tree::TerminalNode* FandangoParser::RepeatContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::RepeatContext::getRuleIndex() const {
  return FandangoParser::RuleRepeat;
}


std::any FandangoParser::RepeatContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitRepeat(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::RepeatContext* FandangoParser::repeat() {
  RepeatContext *_localctx = _tracker.createInstance<RepeatContext>(_ctx, getState());
  enterRule(_localctx, 20, FandangoParser::RuleRepeat);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(656);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(640);
      symbol();
      setState(641);
      match(FandangoParser::OPEN_BRACE);

      setState(642);
      expression();
      setState(643);
      match(FandangoParser::CLOSE_BRACE);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(645);
      symbol();
      setState(646);
      match(FandangoParser::OPEN_BRACE);
      setState(648);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 93071897) != 0)) {
        setState(647);
        expression();
      }
      setState(650);
      match(FandangoParser::COMMA);
      setState(652);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 93071897) != 0)) {
        setState(651);
        expression();
      }
      setState(654);
      match(FandangoParser::CLOSE_BRACE);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SymbolContext ------------------------------------------------------------------

FandangoParser::SymbolContext::SymbolContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Nonterminal_rightContext* FandangoParser::SymbolContext::nonterminal_right() {
  return getRuleContext<FandangoParser::Nonterminal_rightContext>(0);
}

FandangoParser::StringContext* FandangoParser::SymbolContext::string() {
  return getRuleContext<FandangoParser::StringContext>(0);
}

tree::TerminalNode* FandangoParser::SymbolContext::NUMBER() {
  return getToken(FandangoParser::NUMBER, 0);
}

FandangoParser::Generator_callContext* FandangoParser::SymbolContext::generator_call() {
  return getRuleContext<FandangoParser::Generator_callContext>(0);
}

FandangoParser::Char_setContext* FandangoParser::SymbolContext::char_set() {
  return getRuleContext<FandangoParser::Char_setContext>(0);
}

tree::TerminalNode* FandangoParser::SymbolContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::AlternativeContext* FandangoParser::SymbolContext::alternative() {
  return getRuleContext<FandangoParser::AlternativeContext>(0);
}

tree::TerminalNode* FandangoParser::SymbolContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}


size_t FandangoParser::SymbolContext::getRuleIndex() const {
  return FandangoParser::RuleSymbol;
}


std::any FandangoParser::SymbolContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSymbol(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::SymbolContext* FandangoParser::symbol() {
  SymbolContext *_localctx = _tracker.createInstance<SymbolContext>(_ctx, getState());
  enterRule(_localctx, 22, FandangoParser::RuleSymbol);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(667);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 1);
        setState(658);
        nonterminal_right();
        break;
      }

      case FandangoParser::STRING: {
        enterOuterAlt(_localctx, 2);
        setState(659);
        string();
        break;
      }

      case FandangoParser::NUMBER: {
        enterOuterAlt(_localctx, 3);
        setState(660);
        match(FandangoParser::NUMBER);
        break;
      }

      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME: {
        enterOuterAlt(_localctx, 4);
        setState(661);
        generator_call(0);
        break;
      }

      case FandangoParser::OPEN_BRACK: {
        enterOuterAlt(_localctx, 5);
        setState(662);
        char_set();
        break;
      }

      case FandangoParser::OPEN_PAREN: {
        enterOuterAlt(_localctx, 6);
        setState(663);
        match(FandangoParser::OPEN_PAREN);
        setState(664);
        alternative();
        setState(665);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Nonterminal_rightContext ------------------------------------------------------------------

FandangoParser::Nonterminal_rightContext::Nonterminal_rightContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Nonterminal_rightContext::LESS_THAN() {
  return getToken(FandangoParser::LESS_THAN, 0);
}

std::vector<FandangoParser::IdentifierContext *> FandangoParser::Nonterminal_rightContext::identifier() {
  return getRuleContexts<FandangoParser::IdentifierContext>();
}

FandangoParser::IdentifierContext* FandangoParser::Nonterminal_rightContext::identifier(size_t i) {
  return getRuleContext<FandangoParser::IdentifierContext>(i);
}

tree::TerminalNode* FandangoParser::Nonterminal_rightContext::GREATER_THAN() {
  return getToken(FandangoParser::GREATER_THAN, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::Nonterminal_rightContext::COLON() {
  return getTokens(FandangoParser::COLON);
}

tree::TerminalNode* FandangoParser::Nonterminal_rightContext::COLON(size_t i) {
  return getToken(FandangoParser::COLON, i);
}


size_t FandangoParser::Nonterminal_rightContext::getRuleIndex() const {
  return FandangoParser::RuleNonterminal_right;
}


std::any FandangoParser::Nonterminal_rightContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitNonterminal_right(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Nonterminal_rightContext* FandangoParser::nonterminal_right() {
  Nonterminal_rightContext *_localctx = _tracker.createInstance<Nonterminal_rightContext>(_ctx, getState());
  enterRule(_localctx, 24, FandangoParser::RuleNonterminal_right);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(669);
    match(FandangoParser::LESS_THAN);
    setState(678);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
    case 1: {
      setState(673);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
      case 1: {
        setState(670);
        identifier();
        setState(671);
        match(FandangoParser::COLON);
        break;
      }

      default:
        break;
      }
      setState(675);
      identifier();
      setState(676);
      match(FandangoParser::COLON);
      break;
    }

    default:
      break;
    }
    setState(680);
    identifier();
    setState(681);
    match(FandangoParser::GREATER_THAN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NonterminalContext ------------------------------------------------------------------

FandangoParser::NonterminalContext::NonterminalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::NonterminalContext::LESS_THAN() {
  return getToken(FandangoParser::LESS_THAN, 0);
}

FandangoParser::IdentifierContext* FandangoParser::NonterminalContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::NonterminalContext::GREATER_THAN() {
  return getToken(FandangoParser::GREATER_THAN, 0);
}


size_t FandangoParser::NonterminalContext::getRuleIndex() const {
  return FandangoParser::RuleNonterminal;
}


std::any FandangoParser::NonterminalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitNonterminal(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::NonterminalContext* FandangoParser::nonterminal() {
  NonterminalContext *_localctx = _tracker.createInstance<NonterminalContext>(_ctx, getState());
  enterRule(_localctx, 26, FandangoParser::RuleNonterminal);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(683);
    match(FandangoParser::LESS_THAN);
    setState(684);
    identifier();
    setState(685);
    match(FandangoParser::GREATER_THAN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Generator_callContext ------------------------------------------------------------------

FandangoParser::Generator_callContext::Generator_callContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Generator_callContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

FandangoParser::Generator_callContext* FandangoParser::Generator_callContext::generator_call() {
  return getRuleContext<FandangoParser::Generator_callContext>(0);
}

tree::TerminalNode* FandangoParser::Generator_callContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

tree::TerminalNode* FandangoParser::Generator_callContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::SlicesContext* FandangoParser::Generator_callContext::slices() {
  return getRuleContext<FandangoParser::SlicesContext>(0);
}

tree::TerminalNode* FandangoParser::Generator_callContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

FandangoParser::GenexpContext* FandangoParser::Generator_callContext::genexp() {
  return getRuleContext<FandangoParser::GenexpContext>(0);
}

tree::TerminalNode* FandangoParser::Generator_callContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Generator_callContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::ArgumentsContext* FandangoParser::Generator_callContext::arguments() {
  return getRuleContext<FandangoParser::ArgumentsContext>(0);
}


size_t FandangoParser::Generator_callContext::getRuleIndex() const {
  return FandangoParser::RuleGenerator_call;
}


std::any FandangoParser::Generator_callContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGenerator_call(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Generator_callContext* FandangoParser::generator_call() {
   return generator_call(0);
}

FandangoParser::Generator_callContext* FandangoParser::generator_call(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Generator_callContext *_localctx = _tracker.createInstance<Generator_callContext>(_ctx, parentState);
  FandangoParser::Generator_callContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 28;
  enterRecursionRule(_localctx, 28, FandangoParser::RuleGenerator_call, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(688);
    identifier();
    _ctx->stop = _input->LT(-1);
    setState(708);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(706);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<Generator_callContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleGenerator_call);
          setState(690);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(691);
          match(FandangoParser::DOT);
          setState(692);
          identifier();
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<Generator_callContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleGenerator_call);
          setState(693);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(694);
          match(FandangoParser::OPEN_BRACK);
          setState(695);
          slices();
          setState(696);
          match(FandangoParser::CLOSE_BRACK);
          break;
        }

        case 3: {
          _localctx = _tracker.createInstance<Generator_callContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleGenerator_call);
          setState(698);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(699);
          genexp();
          break;
        }

        case 4: {
          _localctx = _tracker.createInstance<Generator_callContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleGenerator_call);
          setState(700);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(701);
          match(FandangoParser::OPEN_PAREN);
          setState(703);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if ((((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 78)) & 93071897) != 0)) {
            setState(702);
            arguments();
          }
          setState(705);
          match(FandangoParser::CLOSE_PAREN);
          break;
        }

        default:
          break;
        } 
      }
      setState(710);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- Char_setContext ------------------------------------------------------------------

FandangoParser::Char_setContext::Char_setContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Char_setContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::StringContext* FandangoParser::Char_setContext::string() {
  return getRuleContext<FandangoParser::StringContext>(0);
}

tree::TerminalNode* FandangoParser::Char_setContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

tree::TerminalNode* FandangoParser::Char_setContext::XOR() {
  return getToken(FandangoParser::XOR, 0);
}


size_t FandangoParser::Char_setContext::getRuleIndex() const {
  return FandangoParser::RuleChar_set;
}


std::any FandangoParser::Char_setContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitChar_set(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Char_setContext* FandangoParser::char_set() {
  Char_setContext *_localctx = _tracker.createInstance<Char_setContext>(_ctx, getState());
  enterRule(_localctx, 30, FandangoParser::RuleChar_set);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(711);
    match(FandangoParser::OPEN_BRACK);
    setState(713);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::XOR) {
      setState(712);
      match(FandangoParser::XOR);
    }
    setState(715);
    string();
    setState(716);
    match(FandangoParser::CLOSE_BRACK);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConstraintContext ------------------------------------------------------------------

FandangoParser::ConstraintContext::ConstraintContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::ConstraintContext::WHERE() {
  return getToken(FandangoParser::WHERE, 0);
}

FandangoParser::ImpliesContext* FandangoParser::ConstraintContext::implies() {
  return getRuleContext<FandangoParser::ImpliesContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::ConstraintContext::INDENT() {
  return getTokens(FandangoParser::INDENT);
}

tree::TerminalNode* FandangoParser::ConstraintContext::INDENT(size_t i) {
  return getToken(FandangoParser::INDENT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::ConstraintContext::DEDENT() {
  return getTokens(FandangoParser::DEDENT);
}

tree::TerminalNode* FandangoParser::ConstraintContext::DEDENT(size_t i) {
  return getToken(FandangoParser::DEDENT, i);
}

tree::TerminalNode* FandangoParser::ConstraintContext::MINIMIZING() {
  return getToken(FandangoParser::MINIMIZING, 0);
}

FandangoParser::ExprContext* FandangoParser::ConstraintContext::expr() {
  return getRuleContext<FandangoParser::ExprContext>(0);
}

tree::TerminalNode* FandangoParser::ConstraintContext::SEMI_COLON() {
  return getToken(FandangoParser::SEMI_COLON, 0);
}

tree::TerminalNode* FandangoParser::ConstraintContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::ConstraintContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::ConstraintContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}

tree::TerminalNode* FandangoParser::ConstraintContext::MAXIMIZING() {
  return getToken(FandangoParser::MAXIMIZING, 0);
}


size_t FandangoParser::ConstraintContext::getRuleIndex() const {
  return FandangoParser::RuleConstraint;
}


std::any FandangoParser::ConstraintContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitConstraint(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ConstraintContext* FandangoParser::constraint() {
  ConstraintContext *_localctx = _tracker.createInstance<ConstraintContext>(_ctx, getState());
  enterRule(_localctx, 32, FandangoParser::RuleConstraint);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(781);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(721);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::INDENT) {
        setState(718);
        match(FandangoParser::INDENT);
        setState(723);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(724);
      match(FandangoParser::WHERE);
      setState(725);
      implies();
      setState(729);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::DEDENT) {
        setState(726);
        match(FandangoParser::DEDENT);
        setState(731);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(735);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::INDENT) {
        setState(732);
        match(FandangoParser::INDENT);
        setState(737);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(738);
      match(FandangoParser::MINIMIZING);
      setState(739);
      expr();
      setState(747);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(740);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(742); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(741);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(744); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(746);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(752);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::DEDENT) {
        setState(749);
        match(FandangoParser::DEDENT);
        setState(754);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(758);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::INDENT) {
        setState(755);
        match(FandangoParser::INDENT);
        setState(760);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(761);
      match(FandangoParser::MAXIMIZING);
      setState(762);
      expr();
      setState(770);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(763);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(765); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(764);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(767); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(769);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(775);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::DEDENT) {
        setState(772);
        match(FandangoParser::DEDENT);
        setState(777);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(778);
      implies();
      setState(779);
      match(FandangoParser::SEMI_COLON);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ImpliesContext ------------------------------------------------------------------

FandangoParser::ImpliesContext::ImpliesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Formula_disjunctionContext *> FandangoParser::ImpliesContext::formula_disjunction() {
  return getRuleContexts<FandangoParser::Formula_disjunctionContext>();
}

FandangoParser::Formula_disjunctionContext* FandangoParser::ImpliesContext::formula_disjunction(size_t i) {
  return getRuleContext<FandangoParser::Formula_disjunctionContext>(i);
}

tree::TerminalNode* FandangoParser::ImpliesContext::ARROW() {
  return getToken(FandangoParser::ARROW, 0);
}

tree::TerminalNode* FandangoParser::ImpliesContext::SEMI_COLON() {
  return getToken(FandangoParser::SEMI_COLON, 0);
}

tree::TerminalNode* FandangoParser::ImpliesContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}

tree::TerminalNode* FandangoParser::ImpliesContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}

FandangoParser::QuantifierContext* FandangoParser::ImpliesContext::quantifier() {
  return getRuleContext<FandangoParser::QuantifierContext>(0);
}


size_t FandangoParser::ImpliesContext::getRuleIndex() const {
  return FandangoParser::RuleImplies;
}


std::any FandangoParser::ImpliesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImplies(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ImpliesContext* FandangoParser::implies() {
  ImpliesContext *_localctx = _tracker.createInstance<ImpliesContext>(_ctx, getState());
  enterRule(_localctx, 34, FandangoParser::RuleImplies);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(789);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 44, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(783);
      formula_disjunction();
      setState(784);
      match(FandangoParser::ARROW);
      setState(785);
      formula_disjunction();
      setState(786);
      _la = _input->LA(1);
      if (!(_la == FandangoParser::EOF || _la == FandangoParser::SEMI_COLON

      || _la == FandangoParser::NEWLINE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(788);
      quantifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QuantifierContext ------------------------------------------------------------------

FandangoParser::QuantifierContext::QuantifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::QuantifierContext::FORALL() {
  return getToken(FandangoParser::FORALL, 0);
}

FandangoParser::NonterminalContext* FandangoParser::QuantifierContext::nonterminal() {
  return getRuleContext<FandangoParser::NonterminalContext>(0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::IN() {
  return getToken(FandangoParser::IN, 0);
}

FandangoParser::Dot_selectionContext* FandangoParser::QuantifierContext::dot_selection() {
  return getRuleContext<FandangoParser::Dot_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::QuantifierContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::QuantifierContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}

tree::TerminalNode* FandangoParser::QuantifierContext::INDENT() {
  return getToken(FandangoParser::INDENT, 0);
}

FandangoParser::QuantifierContext* FandangoParser::QuantifierContext::quantifier() {
  return getRuleContext<FandangoParser::QuantifierContext>(0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::DEDENT() {
  return getToken(FandangoParser::DEDENT, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::EXISTS() {
  return getToken(FandangoParser::EXISTS, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::ANY() {
  return getToken(FandangoParser::ANY, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::QuantifierContext::OPEN_PAREN() {
  return getTokens(FandangoParser::OPEN_PAREN);
}

tree::TerminalNode* FandangoParser::QuantifierContext::OPEN_PAREN(size_t i) {
  return getToken(FandangoParser::OPEN_PAREN, i);
}

FandangoParser::Quantifier_in_lineContext* FandangoParser::QuantifierContext::quantifier_in_line() {
  return getRuleContext<FandangoParser::Quantifier_in_lineContext>(0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::FOR() {
  return getToken(FandangoParser::FOR, 0);
}

FandangoParser::Star_selectionContext* FandangoParser::QuantifierContext::star_selection() {
  return getRuleContext<FandangoParser::Star_selectionContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::QuantifierContext::CLOSE_PAREN() {
  return getTokens(FandangoParser::CLOSE_PAREN);
}

tree::TerminalNode* FandangoParser::QuantifierContext::CLOSE_PAREN(size_t i) {
  return getToken(FandangoParser::CLOSE_PAREN, i);
}

FandangoParser::IdentifierContext* FandangoParser::QuantifierContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::SEMI_COLON() {
  return getToken(FandangoParser::SEMI_COLON, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}

tree::TerminalNode* FandangoParser::QuantifierContext::ALL() {
  return getToken(FandangoParser::ALL, 0);
}

FandangoParser::Formula_disjunctionContext* FandangoParser::QuantifierContext::formula_disjunction() {
  return getRuleContext<FandangoParser::Formula_disjunctionContext>(0);
}


size_t FandangoParser::QuantifierContext::getRuleIndex() const {
  return FandangoParser::RuleQuantifier;
}


std::any FandangoParser::QuantifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitQuantifier(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::QuantifierContext* FandangoParser::quantifier() {
  QuantifierContext *_localctx = _tracker.createInstance<QuantifierContext>(_ctx, getState());
  enterRule(_localctx, 36, FandangoParser::RuleQuantifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(999);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 73, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(791);
      match(FandangoParser::FORALL);
      setState(792);
      nonterminal();
      setState(793);
      match(FandangoParser::IN);
      setState(794);
      dot_selection(0);
      setState(795);
      match(FandangoParser::COLON);
      setState(802);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::NEWLINE: {
          setState(796);
          match(FandangoParser::NEWLINE);
          setState(797);
          match(FandangoParser::INDENT);
          setState(798);
          quantifier();
          setState(799);
          match(FandangoParser::DEDENT);
          break;
        }

        case FandangoParser::FSTRING_START_QUOTE:
        case FandangoParser::FSTRING_START_SINGLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
        case FandangoParser::STRING:
        case FandangoParser::NUMBER:
        case FandangoParser::AWAIT:
        case FandangoParser::FALSE:
        case FandangoParser::NONE:
        case FandangoParser::NOT:
        case FandangoParser::TRUE:
        case FandangoParser::FORALL:
        case FandangoParser::EXISTS:
        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME:
        case FandangoParser::ELLIPSIS:
        case FandangoParser::STAR:
        case FandangoParser::OPEN_PAREN:
        case FandangoParser::POWER:
        case FandangoParser::OPEN_BRACK:
        case FandangoParser::OR_OP:
        case FandangoParser::ADD:
        case FandangoParser::MINUS:
        case FandangoParser::NOT_OP:
        case FandangoParser::OPEN_BRACE:
        case FandangoParser::LESS_THAN: {
          setState(801);
          quantifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(804);
      match(FandangoParser::EXISTS);
      setState(805);
      nonterminal();
      setState(806);
      match(FandangoParser::IN);
      setState(807);
      dot_selection(0);
      setState(808);
      match(FandangoParser::COLON);
      setState(815);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::NEWLINE: {
          setState(809);
          match(FandangoParser::NEWLINE);
          setState(810);
          match(FandangoParser::INDENT);
          setState(811);
          quantifier();
          setState(812);
          match(FandangoParser::DEDENT);
          break;
        }

        case FandangoParser::FSTRING_START_QUOTE:
        case FandangoParser::FSTRING_START_SINGLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
        case FandangoParser::STRING:
        case FandangoParser::NUMBER:
        case FandangoParser::AWAIT:
        case FandangoParser::FALSE:
        case FandangoParser::NONE:
        case FandangoParser::NOT:
        case FandangoParser::TRUE:
        case FandangoParser::FORALL:
        case FandangoParser::EXISTS:
        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME:
        case FandangoParser::ELLIPSIS:
        case FandangoParser::STAR:
        case FandangoParser::OPEN_PAREN:
        case FandangoParser::POWER:
        case FandangoParser::OPEN_BRACK:
        case FandangoParser::OR_OP:
        case FandangoParser::ADD:
        case FandangoParser::MINUS:
        case FandangoParser::NOT_OP:
        case FandangoParser::OPEN_BRACE:
        case FandangoParser::LESS_THAN: {
          setState(814);
          quantifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(817);
      match(FandangoParser::ANY);
      setState(818);
      match(FandangoParser::OPEN_PAREN);
      setState(819);
      quantifier_in_line();
      setState(820);
      match(FandangoParser::FOR);
      setState(823);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(821);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(822);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(825);
      match(FandangoParser::IN);
      setState(826);
      star_selection();
      setState(827);
      match(FandangoParser::CLOSE_PAREN);
      setState(835);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(828);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(830); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(829);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(832); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(834);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(837);
      match(FandangoParser::ANY);
      setState(838);
      match(FandangoParser::OPEN_PAREN);
      setState(839);
      match(FandangoParser::OPEN_BRACK);
      setState(840);
      quantifier_in_line();
      setState(841);
      match(FandangoParser::FOR);
      setState(844);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(842);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(843);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(846);
      match(FandangoParser::IN);
      setState(847);
      star_selection();
      setState(848);
      match(FandangoParser::CLOSE_BRACK);
      setState(849);
      match(FandangoParser::CLOSE_PAREN);
      setState(857);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(850);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(852); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(851);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(854); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(856);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(859);
      match(FandangoParser::ANY);
      setState(860);
      match(FandangoParser::OPEN_PAREN);
      setState(861);
      match(FandangoParser::OPEN_PAREN);
      setState(862);
      quantifier_in_line();
      setState(863);
      match(FandangoParser::FOR);
      setState(866);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(864);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(865);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(868);
      match(FandangoParser::IN);
      setState(869);
      star_selection();
      setState(870);
      match(FandangoParser::CLOSE_BRACK);
      setState(871);
      match(FandangoParser::CLOSE_PAREN);
      setState(879);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(872);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(874); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(873);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(876); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(878);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(881);
      match(FandangoParser::ANY);
      setState(882);
      match(FandangoParser::OPEN_PAREN);
      setState(883);
      match(FandangoParser::OPEN_BRACE);
      setState(884);
      quantifier_in_line();
      setState(885);
      match(FandangoParser::FOR);
      setState(888);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(886);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(887);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(890);
      match(FandangoParser::IN);
      setState(891);
      star_selection();
      setState(892);
      match(FandangoParser::CLOSE_BRACE);
      setState(893);
      match(FandangoParser::CLOSE_PAREN);
      setState(901);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(894);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(896); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(895);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(898); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(900);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(903);
      match(FandangoParser::ALL);
      setState(904);
      match(FandangoParser::OPEN_PAREN);
      setState(905);
      quantifier_in_line();
      setState(906);
      match(FandangoParser::FOR);
      setState(909);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(907);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(908);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(911);
      match(FandangoParser::IN);
      setState(912);
      star_selection();
      setState(913);
      match(FandangoParser::CLOSE_PAREN);
      setState(921);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(914);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(916); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(915);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(918); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(920);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(923);
      match(FandangoParser::ALL);
      setState(924);
      match(FandangoParser::OPEN_PAREN);
      setState(925);
      match(FandangoParser::OPEN_PAREN);
      setState(926);
      quantifier_in_line();
      setState(927);
      match(FandangoParser::FOR);
      setState(930);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(928);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(929);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(932);
      match(FandangoParser::IN);
      setState(933);
      star_selection();
      setState(934);
      match(FandangoParser::CLOSE_PAREN);
      setState(935);
      match(FandangoParser::CLOSE_PAREN);
      setState(943);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(936);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(938); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(937);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(940); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(942);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(945);
      match(FandangoParser::ALL);
      setState(946);
      match(FandangoParser::OPEN_PAREN);
      setState(947);
      match(FandangoParser::OPEN_BRACK);
      setState(948);
      quantifier_in_line();
      setState(949);
      match(FandangoParser::FOR);
      setState(952);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(950);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(951);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(954);
      match(FandangoParser::IN);
      setState(955);
      star_selection();
      setState(956);
      match(FandangoParser::CLOSE_BRACK);
      setState(957);
      match(FandangoParser::CLOSE_PAREN);
      setState(965);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(958);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(960); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(959);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(962); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(964);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(967);
      match(FandangoParser::ALL);
      setState(968);
      match(FandangoParser::OPEN_PAREN);
      setState(969);
      match(FandangoParser::OPEN_BRACE);
      setState(970);
      quantifier_in_line();
      setState(971);
      match(FandangoParser::FOR);
      setState(974);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(972);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(973);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(976);
      match(FandangoParser::IN);
      setState(977);
      star_selection();
      setState(978);
      match(FandangoParser::CLOSE_BRACE);
      setState(979);
      match(FandangoParser::CLOSE_PAREN);
      setState(987);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(980);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(982); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(981);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(984); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(986);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(989);
      formula_disjunction();
      setState(997);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::SEMI_COLON: {
          setState(990);
          match(FandangoParser::SEMI_COLON);
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(992); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(991);
                    match(FandangoParser::NEWLINE);
                    break;
                  }

            default:
              throw NoViableAltException(this);
            }
            setState(994); 
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 71, _ctx);
          } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
          break;
        }

        case FandangoParser::EOF: {
          setState(996);
          match(FandangoParser::EOF);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Quantifier_in_lineContext ------------------------------------------------------------------

FandangoParser::Quantifier_in_lineContext::Quantifier_in_lineContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::ANY() {
  return getToken(FandangoParser::ANY, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::Quantifier_in_lineContext::OPEN_PAREN() {
  return getTokens(FandangoParser::OPEN_PAREN);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::OPEN_PAREN(size_t i) {
  return getToken(FandangoParser::OPEN_PAREN, i);
}

FandangoParser::Quantifier_in_lineContext* FandangoParser::Quantifier_in_lineContext::quantifier_in_line() {
  return getRuleContext<FandangoParser::Quantifier_in_lineContext>(0);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::FOR() {
  return getToken(FandangoParser::FOR, 0);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::IN() {
  return getToken(FandangoParser::IN, 0);
}

FandangoParser::Star_selectionContext* FandangoParser::Quantifier_in_lineContext::star_selection() {
  return getRuleContext<FandangoParser::Star_selectionContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Quantifier_in_lineContext::CLOSE_PAREN() {
  return getTokens(FandangoParser::CLOSE_PAREN);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::CLOSE_PAREN(size_t i) {
  return getToken(FandangoParser::CLOSE_PAREN, i);
}

FandangoParser::NonterminalContext* FandangoParser::Quantifier_in_lineContext::nonterminal() {
  return getRuleContext<FandangoParser::NonterminalContext>(0);
}

FandangoParser::IdentifierContext* FandangoParser::Quantifier_in_lineContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}

tree::TerminalNode* FandangoParser::Quantifier_in_lineContext::ALL() {
  return getToken(FandangoParser::ALL, 0);
}

FandangoParser::Formula_disjunctionContext* FandangoParser::Quantifier_in_lineContext::formula_disjunction() {
  return getRuleContext<FandangoParser::Formula_disjunctionContext>(0);
}


size_t FandangoParser::Quantifier_in_lineContext::getRuleIndex() const {
  return FandangoParser::RuleQuantifier_in_line;
}


std::any FandangoParser::Quantifier_in_lineContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitQuantifier_in_line(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Quantifier_in_lineContext* FandangoParser::quantifier_in_line() {
  Quantifier_in_lineContext *_localctx = _tracker.createInstance<Quantifier_in_lineContext>(_ctx, getState());
  enterRule(_localctx, 38, FandangoParser::RuleQuantifier_in_line);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1110);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1001);
      match(FandangoParser::ANY);
      setState(1002);
      match(FandangoParser::OPEN_PAREN);
      setState(1003);
      quantifier_in_line();
      setState(1004);
      match(FandangoParser::FOR);
      setState(1007);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1005);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1006);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1009);
      match(FandangoParser::IN);
      setState(1010);
      star_selection();
      setState(1011);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1013);
      match(FandangoParser::ANY);
      setState(1014);
      match(FandangoParser::OPEN_PAREN);
      setState(1015);
      match(FandangoParser::OPEN_BRACK);
      setState(1016);
      quantifier_in_line();
      setState(1017);
      match(FandangoParser::FOR);
      setState(1020);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1018);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1019);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1022);
      match(FandangoParser::IN);
      setState(1023);
      star_selection();
      setState(1024);
      match(FandangoParser::CLOSE_BRACK);
      setState(1025);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1027);
      match(FandangoParser::ANY);
      setState(1028);
      match(FandangoParser::OPEN_PAREN);
      setState(1029);
      match(FandangoParser::OPEN_PAREN);
      setState(1030);
      quantifier_in_line();
      setState(1031);
      match(FandangoParser::FOR);
      setState(1034);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1032);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1033);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1036);
      match(FandangoParser::IN);
      setState(1037);
      star_selection();
      setState(1038);
      match(FandangoParser::CLOSE_BRACK);
      setState(1039);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1041);
      match(FandangoParser::ANY);
      setState(1042);
      match(FandangoParser::OPEN_PAREN);
      setState(1043);
      match(FandangoParser::OPEN_BRACE);
      setState(1044);
      quantifier_in_line();
      setState(1045);
      match(FandangoParser::FOR);
      setState(1048);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1046);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1047);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1050);
      match(FandangoParser::IN);
      setState(1051);
      star_selection();
      setState(1052);
      match(FandangoParser::CLOSE_BRACE);
      setState(1053);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1055);
      match(FandangoParser::ALL);
      setState(1056);
      match(FandangoParser::OPEN_PAREN);
      setState(1057);
      quantifier_in_line();
      setState(1058);
      match(FandangoParser::FOR);
      setState(1061);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1059);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1060);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1063);
      match(FandangoParser::IN);
      setState(1064);
      star_selection();
      setState(1065);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1067);
      match(FandangoParser::ALL);
      setState(1068);
      match(FandangoParser::OPEN_PAREN);
      setState(1069);
      match(FandangoParser::OPEN_PAREN);
      setState(1070);
      quantifier_in_line();
      setState(1071);
      match(FandangoParser::FOR);
      setState(1074);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1072);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1073);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1076);
      match(FandangoParser::IN);
      setState(1077);
      star_selection();
      setState(1078);
      match(FandangoParser::CLOSE_PAREN);
      setState(1079);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1081);
      match(FandangoParser::ALL);
      setState(1082);
      match(FandangoParser::OPEN_PAREN);
      setState(1083);
      match(FandangoParser::OPEN_BRACK);
      setState(1084);
      quantifier_in_line();
      setState(1085);
      match(FandangoParser::FOR);
      setState(1088);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1086);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1087);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1090);
      match(FandangoParser::IN);
      setState(1091);
      star_selection();
      setState(1092);
      match(FandangoParser::CLOSE_BRACK);
      setState(1093);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1095);
      match(FandangoParser::ALL);
      setState(1096);
      match(FandangoParser::OPEN_PAREN);
      setState(1097);
      match(FandangoParser::OPEN_BRACE);
      setState(1098);
      quantifier_in_line();
      setState(1099);
      match(FandangoParser::FOR);
      setState(1102);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::LESS_THAN: {
          setState(1100);
          nonterminal();
          break;
        }

        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME: {
          setState(1101);
          identifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1104);
      match(FandangoParser::IN);
      setState(1105);
      star_selection();
      setState(1106);
      match(FandangoParser::CLOSE_BRACE);
      setState(1107);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1109);
      formula_disjunction();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Formula_disjunctionContext ------------------------------------------------------------------

FandangoParser::Formula_disjunctionContext::Formula_disjunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Formula_conjunctionContext *> FandangoParser::Formula_disjunctionContext::formula_conjunction() {
  return getRuleContexts<FandangoParser::Formula_conjunctionContext>();
}

FandangoParser::Formula_conjunctionContext* FandangoParser::Formula_disjunctionContext::formula_conjunction(size_t i) {
  return getRuleContext<FandangoParser::Formula_conjunctionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Formula_disjunctionContext::OR() {
  return getTokens(FandangoParser::OR);
}

tree::TerminalNode* FandangoParser::Formula_disjunctionContext::OR(size_t i) {
  return getToken(FandangoParser::OR, i);
}


size_t FandangoParser::Formula_disjunctionContext::getRuleIndex() const {
  return FandangoParser::RuleFormula_disjunction;
}


std::any FandangoParser::Formula_disjunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFormula_disjunction(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Formula_disjunctionContext* FandangoParser::formula_disjunction() {
  Formula_disjunctionContext *_localctx = _tracker.createInstance<Formula_disjunctionContext>(_ctx, getState());
  enterRule(_localctx, 40, FandangoParser::RuleFormula_disjunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1112);
    formula_conjunction();
    setState(1117);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::OR) {
      setState(1113);
      match(FandangoParser::OR);
      setState(1114);
      formula_conjunction();
      setState(1119);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Formula_conjunctionContext ------------------------------------------------------------------

FandangoParser::Formula_conjunctionContext::Formula_conjunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Formula_atomContext *> FandangoParser::Formula_conjunctionContext::formula_atom() {
  return getRuleContexts<FandangoParser::Formula_atomContext>();
}

FandangoParser::Formula_atomContext* FandangoParser::Formula_conjunctionContext::formula_atom(size_t i) {
  return getRuleContext<FandangoParser::Formula_atomContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Formula_conjunctionContext::AND() {
  return getTokens(FandangoParser::AND);
}

tree::TerminalNode* FandangoParser::Formula_conjunctionContext::AND(size_t i) {
  return getToken(FandangoParser::AND, i);
}


size_t FandangoParser::Formula_conjunctionContext::getRuleIndex() const {
  return FandangoParser::RuleFormula_conjunction;
}


std::any FandangoParser::Formula_conjunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFormula_conjunction(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Formula_conjunctionContext* FandangoParser::formula_conjunction() {
  Formula_conjunctionContext *_localctx = _tracker.createInstance<Formula_conjunctionContext>(_ctx, getState());
  enterRule(_localctx, 42, FandangoParser::RuleFormula_conjunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1120);
    formula_atom();
    setState(1125);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::AND) {
      setState(1121);
      match(FandangoParser::AND);
      setState(1122);
      formula_atom();
      setState(1127);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Formula_atomContext ------------------------------------------------------------------

FandangoParser::Formula_atomContext::Formula_atomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Formula_comparisonContext* FandangoParser::Formula_atomContext::formula_comparison() {
  return getRuleContext<FandangoParser::Formula_comparisonContext>(0);
}

tree::TerminalNode* FandangoParser::Formula_atomContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::ImpliesContext* FandangoParser::Formula_atomContext::implies() {
  return getRuleContext<FandangoParser::ImpliesContext>(0);
}

tree::TerminalNode* FandangoParser::Formula_atomContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::ExprContext* FandangoParser::Formula_atomContext::expr() {
  return getRuleContext<FandangoParser::ExprContext>(0);
}


size_t FandangoParser::Formula_atomContext::getRuleIndex() const {
  return FandangoParser::RuleFormula_atom;
}


std::any FandangoParser::Formula_atomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFormula_atom(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Formula_atomContext* FandangoParser::formula_atom() {
  Formula_atomContext *_localctx = _tracker.createInstance<Formula_atomContext>(_ctx, getState());
  enterRule(_localctx, 44, FandangoParser::RuleFormula_atom);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1134);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1128);
      formula_comparison();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1129);
      match(FandangoParser::OPEN_PAREN);
      setState(1130);
      implies();
      setState(1131);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1133);
      expr();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Formula_comparisonContext ------------------------------------------------------------------

FandangoParser::Formula_comparisonContext::Formula_comparisonContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::ExprContext *> FandangoParser::Formula_comparisonContext::expr() {
  return getRuleContexts<FandangoParser::ExprContext>();
}

FandangoParser::ExprContext* FandangoParser::Formula_comparisonContext::expr(size_t i) {
  return getRuleContext<FandangoParser::ExprContext>(i);
}

tree::TerminalNode* FandangoParser::Formula_comparisonContext::LESS_THAN() {
  return getToken(FandangoParser::LESS_THAN, 0);
}

tree::TerminalNode* FandangoParser::Formula_comparisonContext::GREATER_THAN() {
  return getToken(FandangoParser::GREATER_THAN, 0);
}

tree::TerminalNode* FandangoParser::Formula_comparisonContext::EQUALS() {
  return getToken(FandangoParser::EQUALS, 0);
}

tree::TerminalNode* FandangoParser::Formula_comparisonContext::GT_EQ() {
  return getToken(FandangoParser::GT_EQ, 0);
}

tree::TerminalNode* FandangoParser::Formula_comparisonContext::LT_EQ() {
  return getToken(FandangoParser::LT_EQ, 0);
}

tree::TerminalNode* FandangoParser::Formula_comparisonContext::NOT_EQ_1() {
  return getToken(FandangoParser::NOT_EQ_1, 0);
}

tree::TerminalNode* FandangoParser::Formula_comparisonContext::NOT_EQ_2() {
  return getToken(FandangoParser::NOT_EQ_2, 0);
}


size_t FandangoParser::Formula_comparisonContext::getRuleIndex() const {
  return FandangoParser::RuleFormula_comparison;
}


std::any FandangoParser::Formula_comparisonContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFormula_comparison(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Formula_comparisonContext* FandangoParser::formula_comparison() {
  Formula_comparisonContext *_localctx = _tracker.createInstance<Formula_comparisonContext>(_ctx, getState());
  enterRule(_localctx, 46, FandangoParser::RuleFormula_comparison);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1136);
    expr();
    setState(1137);
    _la = _input->LA(1);
    if (!(((((_la - 104) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 104)) & 127) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(1138);
    expr();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExprContext ------------------------------------------------------------------

FandangoParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Selector_lengthContext* FandangoParser::ExprContext::selector_length() {
  return getRuleContext<FandangoParser::Selector_lengthContext>(0);
}

std::vector<FandangoParser::InversionContext *> FandangoParser::ExprContext::inversion() {
  return getRuleContexts<FandangoParser::InversionContext>();
}

FandangoParser::InversionContext* FandangoParser::ExprContext::inversion(size_t i) {
  return getRuleContext<FandangoParser::InversionContext>(i);
}

tree::TerminalNode* FandangoParser::ExprContext::IF() {
  return getToken(FandangoParser::IF, 0);
}

tree::TerminalNode* FandangoParser::ExprContext::ELSE() {
  return getToken(FandangoParser::ELSE, 0);
}


size_t FandangoParser::ExprContext::getRuleIndex() const {
  return FandangoParser::RuleExpr;
}


std::any FandangoParser::ExprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitExpr(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ExprContext* FandangoParser::expr() {
  ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());
  enterRule(_localctx, 48, FandangoParser::RuleExpr);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1148);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1140);
      selector_length();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1141);
      inversion();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1142);
      inversion();
      setState(1143);
      match(FandangoParser::IF);
      setState(1144);
      inversion();
      setState(1145);
      match(FandangoParser::ELSE);
      setState(1146);
      inversion();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Selector_lengthContext ------------------------------------------------------------------

FandangoParser::Selector_lengthContext::Selector_lengthContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FandangoParser::Selector_lengthContext::OR_OP() {
  return getTokens(FandangoParser::OR_OP);
}

tree::TerminalNode* FandangoParser::Selector_lengthContext::OR_OP(size_t i) {
  return getToken(FandangoParser::OR_OP, i);
}

FandangoParser::Dot_selectionContext* FandangoParser::Selector_lengthContext::dot_selection() {
  return getRuleContext<FandangoParser::Dot_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::Selector_lengthContext::LEN() {
  return getToken(FandangoParser::LEN, 0);
}

tree::TerminalNode* FandangoParser::Selector_lengthContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::Star_selectionContext* FandangoParser::Selector_lengthContext::star_selection() {
  return getRuleContext<FandangoParser::Star_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::Selector_lengthContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Star_selection_or_dot_selectionContext* FandangoParser::Selector_lengthContext::star_selection_or_dot_selection() {
  return getRuleContext<FandangoParser::Star_selection_or_dot_selectionContext>(0);
}


size_t FandangoParser::Selector_lengthContext::getRuleIndex() const {
  return FandangoParser::RuleSelector_length;
}


std::any FandangoParser::Selector_lengthContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSelector_length(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Selector_lengthContext* FandangoParser::selector_length() {
  Selector_lengthContext *_localctx = _tracker.createInstance<Selector_lengthContext>(_ctx, getState());
  enterRule(_localctx, 50, FandangoParser::RuleSelector_length);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1160);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::OR_OP: {
        enterOuterAlt(_localctx, 1);
        setState(1150);
        match(FandangoParser::OR_OP);
        setState(1151);
        dot_selection(0);
        setState(1152);
        match(FandangoParser::OR_OP);
        break;
      }

      case FandangoParser::LEN: {
        enterOuterAlt(_localctx, 2);
        setState(1154);
        match(FandangoParser::LEN);
        setState(1155);
        match(FandangoParser::OPEN_PAREN);
        setState(1156);
        star_selection();
        setState(1157);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 3);
        setState(1159);
        star_selection_or_dot_selection();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_selection_or_dot_selectionContext ------------------------------------------------------------------

FandangoParser::Star_selection_or_dot_selectionContext::Star_selection_or_dot_selectionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Star_selectionContext* FandangoParser::Star_selection_or_dot_selectionContext::star_selection() {
  return getRuleContext<FandangoParser::Star_selectionContext>(0);
}

FandangoParser::Dot_selectionContext* FandangoParser::Star_selection_or_dot_selectionContext::dot_selection() {
  return getRuleContext<FandangoParser::Dot_selectionContext>(0);
}


size_t FandangoParser::Star_selection_or_dot_selectionContext::getRuleIndex() const {
  return FandangoParser::RuleStar_selection_or_dot_selection;
}


std::any FandangoParser::Star_selection_or_dot_selectionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_selection_or_dot_selection(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_selection_or_dot_selectionContext* FandangoParser::star_selection_or_dot_selection() {
  Star_selection_or_dot_selectionContext *_localctx = _tracker.createInstance<Star_selection_or_dot_selectionContext>(_ctx, getState());
  enterRule(_localctx, 52, FandangoParser::RuleStar_selection_or_dot_selection);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1164);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::STAR:
      case FandangoParser::POWER: {
        enterOuterAlt(_localctx, 1);
        setState(1162);
        star_selection();
        break;
      }

      case FandangoParser::OPEN_PAREN:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(1163);
        dot_selection(0);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_selectionContext ------------------------------------------------------------------

FandangoParser::Star_selectionContext::Star_selectionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Star_selectionContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::Dot_selectionContext* FandangoParser::Star_selectionContext::dot_selection() {
  return getRuleContext<FandangoParser::Dot_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::Star_selectionContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}


size_t FandangoParser::Star_selectionContext::getRuleIndex() const {
  return FandangoParser::RuleStar_selection;
}


std::any FandangoParser::Star_selectionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_selection(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_selectionContext* FandangoParser::star_selection() {
  Star_selectionContext *_localctx = _tracker.createInstance<Star_selectionContext>(_ctx, getState());
  enterRule(_localctx, 54, FandangoParser::RuleStar_selection);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1170);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::STAR: {
        enterOuterAlt(_localctx, 1);
        setState(1166);
        match(FandangoParser::STAR);
        setState(1167);
        dot_selection(0);
        break;
      }

      case FandangoParser::POWER: {
        enterOuterAlt(_localctx, 2);
        setState(1168);
        match(FandangoParser::POWER);
        setState(1169);
        dot_selection(0);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Dot_selectionContext ------------------------------------------------------------------

FandangoParser::Dot_selectionContext::Dot_selectionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::SelectionContext* FandangoParser::Dot_selectionContext::selection() {
  return getRuleContext<FandangoParser::SelectionContext>(0);
}

FandangoParser::Dot_selectionContext* FandangoParser::Dot_selectionContext::dot_selection() {
  return getRuleContext<FandangoParser::Dot_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::Dot_selectionContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

tree::TerminalNode* FandangoParser::Dot_selectionContext::DOTDOT() {
  return getToken(FandangoParser::DOTDOT, 0);
}


size_t FandangoParser::Dot_selectionContext::getRuleIndex() const {
  return FandangoParser::RuleDot_selection;
}


std::any FandangoParser::Dot_selectionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDot_selection(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Dot_selectionContext* FandangoParser::dot_selection() {
   return dot_selection(0);
}

FandangoParser::Dot_selectionContext* FandangoParser::dot_selection(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Dot_selectionContext *_localctx = _tracker.createInstance<Dot_selectionContext>(_ctx, parentState);
  FandangoParser::Dot_selectionContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 56;
  enterRecursionRule(_localctx, 56, FandangoParser::RuleDot_selection, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1173);
    selection();
    _ctx->stop = _input->LT(-1);
    setState(1183);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(1181);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<Dot_selectionContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleDot_selection);
          setState(1175);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(1176);
          match(FandangoParser::DOT);
          setState(1177);
          selection();
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<Dot_selectionContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleDot_selection);
          setState(1178);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(1179);
          match(FandangoParser::DOTDOT);
          setState(1180);
          selection();
          break;
        }

        default:
          break;
        } 
      }
      setState(1185);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- SelectionContext ------------------------------------------------------------------

FandangoParser::SelectionContext::SelectionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Base_selectionContext* FandangoParser::SelectionContext::base_selection() {
  return getRuleContext<FandangoParser::Base_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::SelectionContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::Rs_slicesContext* FandangoParser::SelectionContext::rs_slices() {
  return getRuleContext<FandangoParser::Rs_slicesContext>(0);
}

tree::TerminalNode* FandangoParser::SelectionContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

tree::TerminalNode* FandangoParser::SelectionContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

FandangoParser::Rs_pairsContext* FandangoParser::SelectionContext::rs_pairs() {
  return getRuleContext<FandangoParser::Rs_pairsContext>(0);
}

tree::TerminalNode* FandangoParser::SelectionContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}


size_t FandangoParser::SelectionContext::getRuleIndex() const {
  return FandangoParser::RuleSelection;
}


std::any FandangoParser::SelectionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSelection(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::SelectionContext* FandangoParser::selection() {
  SelectionContext *_localctx = _tracker.createInstance<SelectionContext>(_ctx, getState());
  enterRule(_localctx, 58, FandangoParser::RuleSelection);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1197);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1186);
      base_selection();
      setState(1187);
      match(FandangoParser::OPEN_BRACK);
      setState(1188);
      rs_slices();
      setState(1189);
      match(FandangoParser::CLOSE_BRACK);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1191);
      base_selection();
      setState(1192);
      match(FandangoParser::OPEN_BRACE);
      setState(1193);
      rs_pairs();
      setState(1194);
      match(FandangoParser::CLOSE_BRACE);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1196);
      base_selection();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Base_selectionContext ------------------------------------------------------------------

FandangoParser::Base_selectionContext::Base_selectionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::NonterminalContext* FandangoParser::Base_selectionContext::nonterminal() {
  return getRuleContext<FandangoParser::NonterminalContext>(0);
}

tree::TerminalNode* FandangoParser::Base_selectionContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::Dot_selectionContext* FandangoParser::Base_selectionContext::dot_selection() {
  return getRuleContext<FandangoParser::Dot_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::Base_selectionContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}


size_t FandangoParser::Base_selectionContext::getRuleIndex() const {
  return FandangoParser::RuleBase_selection;
}


std::any FandangoParser::Base_selectionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitBase_selection(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Base_selectionContext* FandangoParser::base_selection() {
  Base_selectionContext *_localctx = _tracker.createInstance<Base_selectionContext>(_ctx, getState());
  enterRule(_localctx, 60, FandangoParser::RuleBase_selection);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1204);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 1);
        setState(1199);
        nonterminal();
        break;
      }

      case FandangoParser::OPEN_PAREN: {
        enterOuterAlt(_localctx, 2);
        setState(1200);
        match(FandangoParser::OPEN_PAREN);
        setState(1201);
        dot_selection(0);
        setState(1202);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Rs_pairsContext ------------------------------------------------------------------

FandangoParser::Rs_pairsContext::Rs_pairsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Rs_pairContext *> FandangoParser::Rs_pairsContext::rs_pair() {
  return getRuleContexts<FandangoParser::Rs_pairContext>();
}

FandangoParser::Rs_pairContext* FandangoParser::Rs_pairsContext::rs_pair(size_t i) {
  return getRuleContext<FandangoParser::Rs_pairContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Rs_pairsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Rs_pairsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Rs_pairsContext::getRuleIndex() const {
  return FandangoParser::RuleRs_pairs;
}


std::any FandangoParser::Rs_pairsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitRs_pairs(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Rs_pairsContext* FandangoParser::rs_pairs() {
  Rs_pairsContext *_localctx = _tracker.createInstance<Rs_pairsContext>(_ctx, getState());
  enterRule(_localctx, 62, FandangoParser::RuleRs_pairs);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1206);
    rs_pair();
    setState(1211);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1207);
        match(FandangoParser::COMMA);
        setState(1208);
        rs_pair(); 
      }
      setState(1213);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx);
    }
    setState(1215);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(1214);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Rs_pairContext ------------------------------------------------------------------

FandangoParser::Rs_pairContext::Rs_pairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Rs_pairContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::NonterminalContext* FandangoParser::Rs_pairContext::nonterminal() {
  return getRuleContext<FandangoParser::NonterminalContext>(0);
}

tree::TerminalNode* FandangoParser::Rs_pairContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::Rs_sliceContext* FandangoParser::Rs_pairContext::rs_slice() {
  return getRuleContext<FandangoParser::Rs_sliceContext>(0);
}


size_t FandangoParser::Rs_pairContext::getRuleIndex() const {
  return FandangoParser::RuleRs_pair;
}


std::any FandangoParser::Rs_pairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitRs_pair(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Rs_pairContext* FandangoParser::rs_pair() {
  Rs_pairContext *_localctx = _tracker.createInstance<Rs_pairContext>(_ctx, getState());
  enterRule(_localctx, 64, FandangoParser::RuleRs_pair);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1217);
    match(FandangoParser::STAR);
    setState(1218);
    nonterminal();
    setState(1221);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COLON) {
      setState(1219);
      match(FandangoParser::COLON);
      setState(1220);
      rs_slice();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Rs_slicesContext ------------------------------------------------------------------

FandangoParser::Rs_slicesContext::Rs_slicesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Rs_sliceContext *> FandangoParser::Rs_slicesContext::rs_slice() {
  return getRuleContexts<FandangoParser::Rs_sliceContext>();
}

FandangoParser::Rs_sliceContext* FandangoParser::Rs_slicesContext::rs_slice(size_t i) {
  return getRuleContext<FandangoParser::Rs_sliceContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Rs_slicesContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Rs_slicesContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Rs_slicesContext::getRuleIndex() const {
  return FandangoParser::RuleRs_slices;
}


std::any FandangoParser::Rs_slicesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitRs_slices(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Rs_slicesContext* FandangoParser::rs_slices() {
  Rs_slicesContext *_localctx = _tracker.createInstance<Rs_slicesContext>(_ctx, getState());
  enterRule(_localctx, 66, FandangoParser::RuleRs_slices);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1223);
    rs_slice();
    setState(1228);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 97, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1224);
        match(FandangoParser::COMMA);
        setState(1225);
        rs_slice(); 
      }
      setState(1230);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 97, _ctx);
    }
    setState(1232);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(1231);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Rs_sliceContext ------------------------------------------------------------------

FandangoParser::Rs_sliceContext::Rs_sliceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FandangoParser::Rs_sliceContext::NUMBER() {
  return getTokens(FandangoParser::NUMBER);
}

tree::TerminalNode* FandangoParser::Rs_sliceContext::NUMBER(size_t i) {
  return getToken(FandangoParser::NUMBER, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Rs_sliceContext::COLON() {
  return getTokens(FandangoParser::COLON);
}

tree::TerminalNode* FandangoParser::Rs_sliceContext::COLON(size_t i) {
  return getToken(FandangoParser::COLON, i);
}


size_t FandangoParser::Rs_sliceContext::getRuleIndex() const {
  return FandangoParser::RuleRs_slice;
}


std::any FandangoParser::Rs_sliceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitRs_slice(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Rs_sliceContext* FandangoParser::rs_slice() {
  Rs_sliceContext *_localctx = _tracker.createInstance<Rs_sliceContext>(_ctx, getState());
  enterRule(_localctx, 68, FandangoParser::RuleRs_slice);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1253);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1234);
      match(FandangoParser::NUMBER);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1236);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::NUMBER) {
        setState(1235);
        match(FandangoParser::NUMBER);
      }
      setState(1238);
      match(FandangoParser::COLON);
      setState(1240);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::NUMBER) {
        setState(1239);
        match(FandangoParser::NUMBER);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1243);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::NUMBER) {
        setState(1242);
        match(FandangoParser::NUMBER);
      }
      setState(1245);
      match(FandangoParser::COLON);
      setState(1247);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::NUMBER) {
        setState(1246);
        match(FandangoParser::NUMBER);
      }
      setState(1249);
      match(FandangoParser::COLON);
      setState(1251);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::NUMBER) {
        setState(1250);
        match(FandangoParser::NUMBER);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PythonContext ------------------------------------------------------------------

FandangoParser::PythonContext::PythonContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Compound_stmtContext* FandangoParser::PythonContext::compound_stmt() {
  return getRuleContext<FandangoParser::Compound_stmtContext>(0);
}

FandangoParser::Simple_stmtContext* FandangoParser::PythonContext::simple_stmt() {
  return getRuleContext<FandangoParser::Simple_stmtContext>(0);
}


size_t FandangoParser::PythonContext::getRuleIndex() const {
  return FandangoParser::RulePython;
}


std::any FandangoParser::PythonContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPython(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::PythonContext* FandangoParser::python() {
  PythonContext *_localctx = _tracker.createInstance<PythonContext>(_ctx, getState());
  enterRule(_localctx, 70, FandangoParser::RulePython);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1257);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ASYNC:
      case FandangoParser::CLASS:
      case FandangoParser::DEF:
      case FandangoParser::FOR:
      case FandangoParser::IF:
      case FandangoParser::MATCH:
      case FandangoParser::TRY:
      case FandangoParser::WHILE:
      case FandangoParser::WITH:
      case FandangoParser::AT: {
        enterOuterAlt(_localctx, 1);
        setState(1255);
        compound_stmt();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::ASSERT:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEL:
      case FandangoParser::FALSE:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IMPORT:
      case FandangoParser::LAMBDA:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TYPE:
      case FandangoParser::YIELD:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(1256);
        simple_stmt();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Python_tagContext ------------------------------------------------------------------

FandangoParser::Python_tagContext::Python_tagContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::StmtContext* FandangoParser::Python_tagContext::stmt() {
  return getRuleContext<FandangoParser::StmtContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Python_tagContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::Python_tagContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}


size_t FandangoParser::Python_tagContext::getRuleIndex() const {
  return FandangoParser::RulePython_tag;
}


std::any FandangoParser::Python_tagContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPython_tag(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Python_tagContext* FandangoParser::python_tag() {
  Python_tagContext *_localctx = _tracker.createInstance<Python_tagContext>(_ctx, getState());
  enterRule(_localctx, 72, FandangoParser::RulePython_tag);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1262);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::NEWLINE) {
      setState(1259);
      match(FandangoParser::NEWLINE);
      setState(1264);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }

    setState(1265);
    stmt();
    setState(1269);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::NEWLINE) {
      setState(1266);
      match(FandangoParser::NEWLINE);
      setState(1271);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IncludeContext ------------------------------------------------------------------

FandangoParser::IncludeContext::IncludeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::IncludeContext::INCLUDE() {
  return getToken(FandangoParser::INCLUDE, 0);
}

tree::TerminalNode* FandangoParser::IncludeContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::IncludeContext::STRING() {
  return getToken(FandangoParser::STRING, 0);
}

tree::TerminalNode* FandangoParser::IncludeContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

tree::TerminalNode* FandangoParser::IncludeContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}


size_t FandangoParser::IncludeContext::getRuleIndex() const {
  return FandangoParser::RuleInclude;
}


std::any FandangoParser::IncludeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitInclude(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::IncludeContext* FandangoParser::include() {
  IncludeContext *_localctx = _tracker.createInstance<IncludeContext>(_ctx, getState());
  enterRule(_localctx, 74, FandangoParser::RuleInclude);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1272);
    match(FandangoParser::INCLUDE);
    setState(1273);
    match(FandangoParser::OPEN_PAREN);
    setState(1274);
    match(FandangoParser::STRING);
    setState(1275);
    match(FandangoParser::CLOSE_PAREN);
    setState(1276);
    match(FandangoParser::NEWLINE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Grammar_settingContext ------------------------------------------------------------------

FandangoParser::Grammar_settingContext::Grammar_settingContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Grammar_settingContext::SETTING() {
  return getToken(FandangoParser::SETTING, 0);
}

FandangoParser::Grammar_setting_contentContext* FandangoParser::Grammar_settingContext::grammar_setting_content() {
  return getRuleContext<FandangoParser::Grammar_setting_contentContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Grammar_settingContext::INDENT() {
  return getTokens(FandangoParser::INDENT);
}

tree::TerminalNode* FandangoParser::Grammar_settingContext::INDENT(size_t i) {
  return getToken(FandangoParser::INDENT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Grammar_settingContext::DEDENT() {
  return getTokens(FandangoParser::DEDENT);
}

tree::TerminalNode* FandangoParser::Grammar_settingContext::DEDENT(size_t i) {
  return getToken(FandangoParser::DEDENT, i);
}


size_t FandangoParser::Grammar_settingContext::getRuleIndex() const {
  return FandangoParser::RuleGrammar_setting;
}


std::any FandangoParser::Grammar_settingContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGrammar_setting(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Grammar_settingContext* FandangoParser::grammar_setting() {
  Grammar_settingContext *_localctx = _tracker.createInstance<Grammar_settingContext>(_ctx, getState());
  enterRule(_localctx, 76, FandangoParser::RuleGrammar_setting);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1281);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::INDENT) {
      setState(1278);
      match(FandangoParser::INDENT);
      setState(1283);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1284);
    match(FandangoParser::SETTING);
    setState(1285);
    grammar_setting_content();
    setState(1289);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::DEDENT) {
      setState(1286);
      match(FandangoParser::DEDENT);
      setState(1291);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Grammar_setting_contentContext ------------------------------------------------------------------

FandangoParser::Grammar_setting_contentContext::Grammar_setting_contentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Grammar_selectorContext* FandangoParser::Grammar_setting_contentContext::grammar_selector() {
  return getRuleContext<FandangoParser::Grammar_selectorContext>(0);
}

std::vector<FandangoParser::Grammar_ruleContext *> FandangoParser::Grammar_setting_contentContext::grammar_rule() {
  return getRuleContexts<FandangoParser::Grammar_ruleContext>();
}

FandangoParser::Grammar_ruleContext* FandangoParser::Grammar_setting_contentContext::grammar_rule(size_t i) {
  return getRuleContext<FandangoParser::Grammar_ruleContext>(i);
}


size_t FandangoParser::Grammar_setting_contentContext::getRuleIndex() const {
  return FandangoParser::RuleGrammar_setting_content;
}


std::any FandangoParser::Grammar_setting_contentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGrammar_setting_content(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Grammar_setting_contentContext* FandangoParser::grammar_setting_content() {
  Grammar_setting_contentContext *_localctx = _tracker.createInstance<Grammar_setting_contentContext>(_ctx, getState());
  enterRule(_localctx, 78, FandangoParser::RuleGrammar_setting_content);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1292);
    grammar_selector();
    setState(1296);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1293);
        grammar_rule(); 
      }
      setState(1298);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Grammar_selectorContext ------------------------------------------------------------------

FandangoParser::Grammar_selectorContext::Grammar_selectorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::NonterminalContext* FandangoParser::Grammar_selectorContext::nonterminal() {
  return getRuleContext<FandangoParser::NonterminalContext>(0);
}

tree::TerminalNode* FandangoParser::Grammar_selectorContext::ALL_WITH_TYPE() {
  return getToken(FandangoParser::ALL_WITH_TYPE, 0);
}

tree::TerminalNode* FandangoParser::Grammar_selectorContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Grammar_selectorContext::NODE_TYPES() {
  return getToken(FandangoParser::NODE_TYPES, 0);
}

tree::TerminalNode* FandangoParser::Grammar_selectorContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Grammar_selectorContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}


size_t FandangoParser::Grammar_selectorContext::getRuleIndex() const {
  return FandangoParser::RuleGrammar_selector;
}


std::any FandangoParser::Grammar_selectorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGrammar_selector(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Grammar_selectorContext* FandangoParser::grammar_selector() {
  Grammar_selectorContext *_localctx = _tracker.createInstance<Grammar_selectorContext>(_ctx, getState());
  enterRule(_localctx, 80, FandangoParser::RuleGrammar_selector);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1305);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 1);
        setState(1299);
        nonterminal();
        break;
      }

      case FandangoParser::ALL_WITH_TYPE: {
        enterOuterAlt(_localctx, 2);
        setState(1300);
        match(FandangoParser::ALL_WITH_TYPE);
        setState(1301);
        match(FandangoParser::OPEN_PAREN);
        setState(1302);
        match(FandangoParser::NODE_TYPES);
        setState(1303);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

      case FandangoParser::STAR: {
        enterOuterAlt(_localctx, 3);
        setState(1304);
        match(FandangoParser::STAR);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Grammar_ruleContext ------------------------------------------------------------------

FandangoParser::Grammar_ruleContext::Grammar_ruleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Grammar_setting_keyContext* FandangoParser::Grammar_ruleContext::grammar_setting_key() {
  return getRuleContext<FandangoParser::Grammar_setting_keyContext>(0);
}

FandangoParser::Grammar_setting_valueContext* FandangoParser::Grammar_ruleContext::grammar_setting_value() {
  return getRuleContext<FandangoParser::Grammar_setting_valueContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Grammar_ruleContext::SPACES() {
  return getTokens(FandangoParser::SPACES);
}

tree::TerminalNode* FandangoParser::Grammar_ruleContext::SPACES(size_t i) {
  return getToken(FandangoParser::SPACES, i);
}

tree::TerminalNode* FandangoParser::Grammar_ruleContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}


size_t FandangoParser::Grammar_ruleContext::getRuleIndex() const {
  return FandangoParser::RuleGrammar_rule;
}


std::any FandangoParser::Grammar_ruleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGrammar_rule(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Grammar_ruleContext* FandangoParser::grammar_rule() {
  Grammar_ruleContext *_localctx = _tracker.createInstance<Grammar_ruleContext>(_ctx, getState());
  enterRule(_localctx, 82, FandangoParser::RuleGrammar_rule);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1307);
    grammar_setting_key();
    setState(1309);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx)) {
    case 1: {
      setState(1308);
      match(FandangoParser::SPACES);
      break;
    }

    default:
      break;
    }
    setState(1312);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::ASSIGN) {
      setState(1311);
      match(FandangoParser::ASSIGN);
    }
    setState(1315);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::SPACES) {
      setState(1314);
      match(FandangoParser::SPACES);
    }
    setState(1317);
    grammar_setting_value();
    setState(1319);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::SPACES) {
      setState(1318);
      match(FandangoParser::SPACES);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Grammar_setting_keyContext ------------------------------------------------------------------

FandangoParser::Grammar_setting_keyContext::Grammar_setting_keyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Grammar_setting_keyContext::NAME() {
  return getToken(FandangoParser::NAME, 0);
}


size_t FandangoParser::Grammar_setting_keyContext::getRuleIndex() const {
  return FandangoParser::RuleGrammar_setting_key;
}


std::any FandangoParser::Grammar_setting_keyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGrammar_setting_key(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Grammar_setting_keyContext* FandangoParser::grammar_setting_key() {
  Grammar_setting_keyContext *_localctx = _tracker.createInstance<Grammar_setting_keyContext>(_ctx, getState());
  enterRule(_localctx, 84, FandangoParser::RuleGrammar_setting_key);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1321);
    match(FandangoParser::NAME);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Grammar_setting_valueContext ------------------------------------------------------------------

FandangoParser::Grammar_setting_valueContext::Grammar_setting_valueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Literal_exprContext* FandangoParser::Grammar_setting_valueContext::literal_expr() {
  return getRuleContext<FandangoParser::Literal_exprContext>(0);
}


size_t FandangoParser::Grammar_setting_valueContext::getRuleIndex() const {
  return FandangoParser::RuleGrammar_setting_value;
}


std::any FandangoParser::Grammar_setting_valueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGrammar_setting_value(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Grammar_setting_valueContext* FandangoParser::grammar_setting_value() {
  Grammar_setting_valueContext *_localctx = _tracker.createInstance<Grammar_setting_valueContext>(_ctx, getState());
  enterRule(_localctx, 86, FandangoParser::RuleGrammar_setting_value);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1323);
    literal_expr();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Python_fileContext ------------------------------------------------------------------

FandangoParser::Python_fileContext::Python_fileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::StatementsContext* FandangoParser::Python_fileContext::statements() {
  return getRuleContext<FandangoParser::StatementsContext>(0);
}

tree::TerminalNode* FandangoParser::Python_fileContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}


size_t FandangoParser::Python_fileContext::getRuleIndex() const {
  return FandangoParser::RulePython_file;
}


std::any FandangoParser::Python_fileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPython_file(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Python_fileContext* FandangoParser::python_file() {
  Python_fileContext *_localctx = _tracker.createInstance<Python_fileContext>(_ctx, getState());
  enterRule(_localctx, 88, FandangoParser::RulePython_file);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1326);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5120027567020818936) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 1125908589849113) != 0)) {
      setState(1325);
      statements();
    }
    setState(1329);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 117, _ctx)) {
    case 1: {
      setState(1328);
      match(FandangoParser::EOF);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InteractiveContext ------------------------------------------------------------------

FandangoParser::InteractiveContext::InteractiveContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Statement_newlineContext* FandangoParser::InteractiveContext::statement_newline() {
  return getRuleContext<FandangoParser::Statement_newlineContext>(0);
}


size_t FandangoParser::InteractiveContext::getRuleIndex() const {
  return FandangoParser::RuleInteractive;
}


std::any FandangoParser::InteractiveContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitInteractive(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::InteractiveContext* FandangoParser::interactive() {
  InteractiveContext *_localctx = _tracker.createInstance<InteractiveContext>(_ctx, getState());
  enterRule(_localctx, 90, FandangoParser::RuleInteractive);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1331);
    statement_newline();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EvalContext ------------------------------------------------------------------

FandangoParser::EvalContext::EvalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ExpressionsContext* FandangoParser::EvalContext::expressions() {
  return getRuleContext<FandangoParser::ExpressionsContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::EvalContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::EvalContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}

tree::TerminalNode* FandangoParser::EvalContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}


size_t FandangoParser::EvalContext::getRuleIndex() const {
  return FandangoParser::RuleEval;
}


std::any FandangoParser::EvalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitEval(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::EvalContext* FandangoParser::eval() {
  EvalContext *_localctx = _tracker.createInstance<EvalContext>(_ctx, getState());
  enterRule(_localctx, 92, FandangoParser::RuleEval);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1333);
    expressions();
    setState(1337);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::NEWLINE) {
      setState(1334);
      match(FandangoParser::NEWLINE);
      setState(1339);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1341);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) {
    case 1: {
      setState(1340);
      match(FandangoParser::EOF);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Func_typeContext ------------------------------------------------------------------

FandangoParser::Func_typeContext::Func_typeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Func_typeContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Func_typeContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Func_typeContext::ARROW() {
  return getToken(FandangoParser::ARROW, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Func_typeContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

FandangoParser::Type_expressionsContext* FandangoParser::Func_typeContext::type_expressions() {
  return getRuleContext<FandangoParser::Type_expressionsContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Func_typeContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::Func_typeContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}

tree::TerminalNode* FandangoParser::Func_typeContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}


size_t FandangoParser::Func_typeContext::getRuleIndex() const {
  return FandangoParser::RuleFunc_type;
}


std::any FandangoParser::Func_typeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFunc_type(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Func_typeContext* FandangoParser::func_type() {
  Func_typeContext *_localctx = _tracker.createInstance<Func_typeContext>(_ctx, getState());
  enterRule(_localctx, 94, FandangoParser::RuleFunc_type);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1343);
    match(FandangoParser::OPEN_PAREN);
    setState(1345);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 93071897) != 0)) {
      setState(1344);
      type_expressions();
    }
    setState(1347);
    match(FandangoParser::CLOSE_PAREN);
    setState(1348);
    match(FandangoParser::ARROW);
    setState(1349);
    expression();
    setState(1353);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::NEWLINE) {
      setState(1350);
      match(FandangoParser::NEWLINE);
      setState(1355);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1357);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 122, _ctx)) {
    case 1: {
      setState(1356);
      match(FandangoParser::EOF);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementsContext ------------------------------------------------------------------

FandangoParser::StatementsContext::StatementsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::StmtContext *> FandangoParser::StatementsContext::stmt() {
  return getRuleContexts<FandangoParser::StmtContext>();
}

FandangoParser::StmtContext* FandangoParser::StatementsContext::stmt(size_t i) {
  return getRuleContext<FandangoParser::StmtContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::StatementsContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::StatementsContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}


size_t FandangoParser::StatementsContext::getRuleIndex() const {
  return FandangoParser::RuleStatements;
}


std::any FandangoParser::StatementsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStatements(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::StatementsContext* FandangoParser::statements() {
  StatementsContext *_localctx = _tracker.createInstance<StatementsContext>(_ctx, getState());
  enterRule(_localctx, 96, FandangoParser::RuleStatements);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1361); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1361);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::FSTRING_START_QUOTE:
        case FandangoParser::FSTRING_START_SINGLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
        case FandangoParser::STRING:
        case FandangoParser::NUMBER:
        case FandangoParser::ASSERT:
        case FandangoParser::ASYNC:
        case FandangoParser::AWAIT:
        case FandangoParser::BREAK:
        case FandangoParser::CLASS:
        case FandangoParser::CONTINUE:
        case FandangoParser::DEF:
        case FandangoParser::DEL:
        case FandangoParser::FALSE:
        case FandangoParser::FOR:
        case FandangoParser::FROM:
        case FandangoParser::GLOBAL:
        case FandangoParser::IF:
        case FandangoParser::IMPORT:
        case FandangoParser::LAMBDA:
        case FandangoParser::MATCH:
        case FandangoParser::NONE:
        case FandangoParser::NONLOCAL:
        case FandangoParser::NOT:
        case FandangoParser::PASS:
        case FandangoParser::RAISE:
        case FandangoParser::RETURN:
        case FandangoParser::TRUE:
        case FandangoParser::TRY:
        case FandangoParser::TYPE:
        case FandangoParser::WHILE:
        case FandangoParser::WITH:
        case FandangoParser::YIELD:
        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME:
        case FandangoParser::ELLIPSIS:
        case FandangoParser::STAR:
        case FandangoParser::OPEN_PAREN:
        case FandangoParser::POWER:
        case FandangoParser::OPEN_BRACK:
        case FandangoParser::OR_OP:
        case FandangoParser::ADD:
        case FandangoParser::MINUS:
        case FandangoParser::NOT_OP:
        case FandangoParser::OPEN_BRACE:
        case FandangoParser::LESS_THAN:
        case FandangoParser::AT: {
          setState(1359);
          stmt();
          break;
        }

        case FandangoParser::NEWLINE: {
          setState(1360);
          match(FandangoParser::NEWLINE);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1363); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5120027567020818936) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 1125908589849113) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StmtContext ------------------------------------------------------------------

FandangoParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Compound_stmtContext* FandangoParser::StmtContext::compound_stmt() {
  return getRuleContext<FandangoParser::Compound_stmtContext>(0);
}

FandangoParser::Simple_stmtsContext* FandangoParser::StmtContext::simple_stmts() {
  return getRuleContext<FandangoParser::Simple_stmtsContext>(0);
}


size_t FandangoParser::StmtContext::getRuleIndex() const {
  return FandangoParser::RuleStmt;
}


std::any FandangoParser::StmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::StmtContext* FandangoParser::stmt() {
  StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());
  enterRule(_localctx, 98, FandangoParser::RuleStmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1367);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ASYNC:
      case FandangoParser::CLASS:
      case FandangoParser::DEF:
      case FandangoParser::FOR:
      case FandangoParser::IF:
      case FandangoParser::MATCH:
      case FandangoParser::TRY:
      case FandangoParser::WHILE:
      case FandangoParser::WITH:
      case FandangoParser::AT: {
        enterOuterAlt(_localctx, 1);
        setState(1365);
        compound_stmt();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::ASSERT:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEL:
      case FandangoParser::FALSE:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IMPORT:
      case FandangoParser::LAMBDA:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TYPE:
      case FandangoParser::YIELD:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(1366);
        simple_stmts();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Statement_newlineContext ------------------------------------------------------------------

FandangoParser::Statement_newlineContext::Statement_newlineContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Compound_stmtContext* FandangoParser::Statement_newlineContext::compound_stmt() {
  return getRuleContext<FandangoParser::Compound_stmtContext>(0);
}

tree::TerminalNode* FandangoParser::Statement_newlineContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}

FandangoParser::Simple_stmtsContext* FandangoParser::Statement_newlineContext::simple_stmts() {
  return getRuleContext<FandangoParser::Simple_stmtsContext>(0);
}


size_t FandangoParser::Statement_newlineContext::getRuleIndex() const {
  return FandangoParser::RuleStatement_newline;
}


std::any FandangoParser::Statement_newlineContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStatement_newline(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Statement_newlineContext* FandangoParser::statement_newline() {
  Statement_newlineContext *_localctx = _tracker.createInstance<Statement_newlineContext>(_ctx, getState());
  enterRule(_localctx, 100, FandangoParser::RuleStatement_newline);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1374);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ASYNC:
      case FandangoParser::CLASS:
      case FandangoParser::DEF:
      case FandangoParser::FOR:
      case FandangoParser::IF:
      case FandangoParser::MATCH:
      case FandangoParser::TRY:
      case FandangoParser::WHILE:
      case FandangoParser::WITH:
      case FandangoParser::AT: {
        enterOuterAlt(_localctx, 1);
        setState(1369);
        compound_stmt();
        setState(1370);
        match(FandangoParser::NEWLINE);
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::ASSERT:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEL:
      case FandangoParser::FALSE:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IMPORT:
      case FandangoParser::LAMBDA:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TYPE:
      case FandangoParser::YIELD:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(1372);
        simple_stmts();
        break;
      }

      case FandangoParser::NEWLINE: {
        enterOuterAlt(_localctx, 3);
        setState(1373);
        match(FandangoParser::NEWLINE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Simple_stmtsContext ------------------------------------------------------------------

FandangoParser::Simple_stmtsContext::Simple_stmtsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Simple_stmtContext *> FandangoParser::Simple_stmtsContext::simple_stmt() {
  return getRuleContexts<FandangoParser::Simple_stmtContext>();
}

FandangoParser::Simple_stmtContext* FandangoParser::Simple_stmtsContext::simple_stmt(size_t i) {
  return getRuleContext<FandangoParser::Simple_stmtContext>(i);
}

tree::TerminalNode* FandangoParser::Simple_stmtsContext::EOF() {
  return getToken(FandangoParser::EOF, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::Simple_stmtsContext::SEMI_COLON() {
  return getTokens(FandangoParser::SEMI_COLON);
}

tree::TerminalNode* FandangoParser::Simple_stmtsContext::SEMI_COLON(size_t i) {
  return getToken(FandangoParser::SEMI_COLON, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Simple_stmtsContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::Simple_stmtsContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}


size_t FandangoParser::Simple_stmtsContext::getRuleIndex() const {
  return FandangoParser::RuleSimple_stmts;
}


std::any FandangoParser::Simple_stmtsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSimple_stmts(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Simple_stmtsContext* FandangoParser::simple_stmts() {
  Simple_stmtsContext *_localctx = _tracker.createInstance<Simple_stmtsContext>(_ctx, getState());
  enterRule(_localctx, 102, FandangoParser::RuleSimple_stmts);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1376);
    simple_stmt();
    setState(1381);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1377);
        match(FandangoParser::SEMI_COLON);
        setState(1378);
        simple_stmt(); 
      }
      setState(1383);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx);
    }
    setState(1385);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::SEMI_COLON) {
      setState(1384);
      match(FandangoParser::SEMI_COLON);
    }
    setState(1399);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx)) {
    case 1: {
      setState(1388); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1387);
                match(FandangoParser::NEWLINE);
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1390); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    case 2: {
      setState(1395);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::NEWLINE) {
        setState(1392);
        match(FandangoParser::NEWLINE);
        setState(1397);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1398);
      match(FandangoParser::EOF);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Simple_stmtContext ------------------------------------------------------------------

FandangoParser::Simple_stmtContext::Simple_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::AssignmentContext* FandangoParser::Simple_stmtContext::assignment() {
  return getRuleContext<FandangoParser::AssignmentContext>(0);
}

FandangoParser::Type_aliasContext* FandangoParser::Simple_stmtContext::type_alias() {
  return getRuleContext<FandangoParser::Type_aliasContext>(0);
}

FandangoParser::Star_expressionsContext* FandangoParser::Simple_stmtContext::star_expressions() {
  return getRuleContext<FandangoParser::Star_expressionsContext>(0);
}

FandangoParser::Return_stmtContext* FandangoParser::Simple_stmtContext::return_stmt() {
  return getRuleContext<FandangoParser::Return_stmtContext>(0);
}

FandangoParser::Import_stmtContext* FandangoParser::Simple_stmtContext::import_stmt() {
  return getRuleContext<FandangoParser::Import_stmtContext>(0);
}

FandangoParser::Raise_stmtContext* FandangoParser::Simple_stmtContext::raise_stmt() {
  return getRuleContext<FandangoParser::Raise_stmtContext>(0);
}

tree::TerminalNode* FandangoParser::Simple_stmtContext::PASS() {
  return getToken(FandangoParser::PASS, 0);
}

FandangoParser::Del_stmtContext* FandangoParser::Simple_stmtContext::del_stmt() {
  return getRuleContext<FandangoParser::Del_stmtContext>(0);
}

FandangoParser::Yield_stmtContext* FandangoParser::Simple_stmtContext::yield_stmt() {
  return getRuleContext<FandangoParser::Yield_stmtContext>(0);
}

FandangoParser::Assert_stmtContext* FandangoParser::Simple_stmtContext::assert_stmt() {
  return getRuleContext<FandangoParser::Assert_stmtContext>(0);
}

tree::TerminalNode* FandangoParser::Simple_stmtContext::BREAK() {
  return getToken(FandangoParser::BREAK, 0);
}

tree::TerminalNode* FandangoParser::Simple_stmtContext::CONTINUE() {
  return getToken(FandangoParser::CONTINUE, 0);
}

FandangoParser::Global_stmtContext* FandangoParser::Simple_stmtContext::global_stmt() {
  return getRuleContext<FandangoParser::Global_stmtContext>(0);
}

FandangoParser::Nonlocal_stmtContext* FandangoParser::Simple_stmtContext::nonlocal_stmt() {
  return getRuleContext<FandangoParser::Nonlocal_stmtContext>(0);
}


size_t FandangoParser::Simple_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleSimple_stmt;
}


std::any FandangoParser::Simple_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSimple_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Simple_stmtContext* FandangoParser::simple_stmt() {
  Simple_stmtContext *_localctx = _tracker.createInstance<Simple_stmtContext>(_ctx, getState());
  enterRule(_localctx, 104, FandangoParser::RuleSimple_stmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1415);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 132, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1401);
      assignment();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1402);
      type_alias();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1403);
      star_expressions();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1404);
      return_stmt();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1405);
      import_stmt();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1406);
      raise_stmt();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1407);
      match(FandangoParser::PASS);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1408);
      del_stmt();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1409);
      yield_stmt();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1410);
      assert_stmt();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1411);
      match(FandangoParser::BREAK);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(1412);
      match(FandangoParser::CONTINUE);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(1413);
      global_stmt();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(1414);
      nonlocal_stmt();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Compound_stmtContext ------------------------------------------------------------------

FandangoParser::Compound_stmtContext::Compound_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Function_defContext* FandangoParser::Compound_stmtContext::function_def() {
  return getRuleContext<FandangoParser::Function_defContext>(0);
}

FandangoParser::If_stmtContext* FandangoParser::Compound_stmtContext::if_stmt() {
  return getRuleContext<FandangoParser::If_stmtContext>(0);
}

FandangoParser::Class_defContext* FandangoParser::Compound_stmtContext::class_def() {
  return getRuleContext<FandangoParser::Class_defContext>(0);
}

FandangoParser::With_stmtContext* FandangoParser::Compound_stmtContext::with_stmt() {
  return getRuleContext<FandangoParser::With_stmtContext>(0);
}

FandangoParser::For_stmtContext* FandangoParser::Compound_stmtContext::for_stmt() {
  return getRuleContext<FandangoParser::For_stmtContext>(0);
}

FandangoParser::Try_stmtContext* FandangoParser::Compound_stmtContext::try_stmt() {
  return getRuleContext<FandangoParser::Try_stmtContext>(0);
}

FandangoParser::While_stmtContext* FandangoParser::Compound_stmtContext::while_stmt() {
  return getRuleContext<FandangoParser::While_stmtContext>(0);
}

FandangoParser::Match_stmtContext* FandangoParser::Compound_stmtContext::match_stmt() {
  return getRuleContext<FandangoParser::Match_stmtContext>(0);
}


size_t FandangoParser::Compound_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleCompound_stmt;
}


std::any FandangoParser::Compound_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitCompound_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Compound_stmtContext* FandangoParser::compound_stmt() {
  Compound_stmtContext *_localctx = _tracker.createInstance<Compound_stmtContext>(_ctx, getState());
  enterRule(_localctx, 106, FandangoParser::RuleCompound_stmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1425);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1417);
      function_def();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1418);
      if_stmt();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1419);
      class_def();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1420);
      with_stmt();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1421);
      for_stmt();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1422);
      try_stmt();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1423);
      while_stmt();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1424);
      match_stmt();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignmentContext ------------------------------------------------------------------

FandangoParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::AssignmentContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::AssignmentContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::ExpressionContext* FandangoParser::AssignmentContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::AssignmentContext::ASSIGN() {
  return getTokens(FandangoParser::ASSIGN);
}

tree::TerminalNode* FandangoParser::AssignmentContext::ASSIGN(size_t i) {
  return getToken(FandangoParser::ASSIGN, i);
}

FandangoParser::Annotated_rhsContext* FandangoParser::AssignmentContext::annotated_rhs() {
  return getRuleContext<FandangoParser::Annotated_rhsContext>(0);
}

tree::TerminalNode* FandangoParser::AssignmentContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::Single_targetContext* FandangoParser::AssignmentContext::single_target() {
  return getRuleContext<FandangoParser::Single_targetContext>(0);
}

tree::TerminalNode* FandangoParser::AssignmentContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Single_subscript_attribute_targetContext* FandangoParser::AssignmentContext::single_subscript_attribute_target() {
  return getRuleContext<FandangoParser::Single_subscript_attribute_targetContext>(0);
}

FandangoParser::Yield_exprContext* FandangoParser::AssignmentContext::yield_expr() {
  return getRuleContext<FandangoParser::Yield_exprContext>(0);
}

FandangoParser::Star_expressionsContext* FandangoParser::AssignmentContext::star_expressions() {
  return getRuleContext<FandangoParser::Star_expressionsContext>(0);
}

std::vector<FandangoParser::Star_targetsContext *> FandangoParser::AssignmentContext::star_targets() {
  return getRuleContexts<FandangoParser::Star_targetsContext>();
}

FandangoParser::Star_targetsContext* FandangoParser::AssignmentContext::star_targets(size_t i) {
  return getRuleContext<FandangoParser::Star_targetsContext>(i);
}

FandangoParser::AugassignContext* FandangoParser::AssignmentContext::augassign() {
  return getRuleContext<FandangoParser::AugassignContext>(0);
}


size_t FandangoParser::AssignmentContext::getRuleIndex() const {
  return FandangoParser::RuleAssignment;
}


std::any FandangoParser::AssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAssignment(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::AssignmentContext* FandangoParser::assignment() {
  AssignmentContext *_localctx = _tracker.createInstance<AssignmentContext>(_ctx, getState());
  enterRule(_localctx, 108, FandangoParser::RuleAssignment);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1464);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1427);
      identifier();
      setState(1428);
      match(FandangoParser::COLON);
      setState(1429);
      expression();
      setState(1432);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ASSIGN) {
        setState(1430);
        match(FandangoParser::ASSIGN);
        setState(1431);
        annotated_rhs();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1439);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 135, _ctx)) {
      case 1: {
        setState(1434);
        match(FandangoParser::OPEN_PAREN);
        setState(1435);
        single_target();
        setState(1436);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

      case 2: {
        setState(1438);
        single_subscript_attribute_target();
        break;
      }

      default:
        break;
      }
      setState(1441);
      match(FandangoParser::COLON);
      setState(1442);
      expression();
      setState(1445);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ASSIGN) {
        setState(1443);
        match(FandangoParser::ASSIGN);
        setState(1444);
        annotated_rhs();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1450); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1447);
                star_targets();
                setState(1448);
                match(FandangoParser::ASSIGN);
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1452); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 137, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      setState(1456);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::YIELD: {
          setState(1454);
          yield_expr();
          break;
        }

        case FandangoParser::FSTRING_START_QUOTE:
        case FandangoParser::FSTRING_START_SINGLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
        case FandangoParser::STRING:
        case FandangoParser::NUMBER:
        case FandangoParser::AWAIT:
        case FandangoParser::FALSE:
        case FandangoParser::LAMBDA:
        case FandangoParser::NONE:
        case FandangoParser::NOT:
        case FandangoParser::TRUE:
        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME:
        case FandangoParser::ELLIPSIS:
        case FandangoParser::STAR:
        case FandangoParser::OPEN_PAREN:
        case FandangoParser::POWER:
        case FandangoParser::OPEN_BRACK:
        case FandangoParser::OR_OP:
        case FandangoParser::ADD:
        case FandangoParser::MINUS:
        case FandangoParser::NOT_OP:
        case FandangoParser::OPEN_BRACE:
        case FandangoParser::LESS_THAN: {
          setState(1455);
          star_expressions();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1458);
      single_target();
      setState(1459);
      augassign();
      setState(1462);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FandangoParser::YIELD: {
          setState(1460);
          yield_expr();
          break;
        }

        case FandangoParser::FSTRING_START_QUOTE:
        case FandangoParser::FSTRING_START_SINGLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
        case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
        case FandangoParser::STRING:
        case FandangoParser::NUMBER:
        case FandangoParser::AWAIT:
        case FandangoParser::FALSE:
        case FandangoParser::LAMBDA:
        case FandangoParser::NONE:
        case FandangoParser::NOT:
        case FandangoParser::TRUE:
        case FandangoParser::ANY:
        case FandangoParser::ALL:
        case FandangoParser::LEN:
        case FandangoParser::NAME:
        case FandangoParser::ELLIPSIS:
        case FandangoParser::STAR:
        case FandangoParser::OPEN_PAREN:
        case FandangoParser::POWER:
        case FandangoParser::OPEN_BRACK:
        case FandangoParser::OR_OP:
        case FandangoParser::ADD:
        case FandangoParser::MINUS:
        case FandangoParser::NOT_OP:
        case FandangoParser::OPEN_BRACE:
        case FandangoParser::LESS_THAN: {
          setState(1461);
          star_expressions();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Annotated_rhsContext ------------------------------------------------------------------

FandangoParser::Annotated_rhsContext::Annotated_rhsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Yield_exprContext* FandangoParser::Annotated_rhsContext::yield_expr() {
  return getRuleContext<FandangoParser::Yield_exprContext>(0);
}

FandangoParser::Star_expressionsContext* FandangoParser::Annotated_rhsContext::star_expressions() {
  return getRuleContext<FandangoParser::Star_expressionsContext>(0);
}


size_t FandangoParser::Annotated_rhsContext::getRuleIndex() const {
  return FandangoParser::RuleAnnotated_rhs;
}


std::any FandangoParser::Annotated_rhsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAnnotated_rhs(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Annotated_rhsContext* FandangoParser::annotated_rhs() {
  Annotated_rhsContext *_localctx = _tracker.createInstance<Annotated_rhsContext>(_ctx, getState());
  enterRule(_localctx, 110, FandangoParser::RuleAnnotated_rhs);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1468);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::YIELD: {
        enterOuterAlt(_localctx, 1);
        setState(1466);
        yield_expr();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::AWAIT:
      case FandangoParser::FALSE:
      case FandangoParser::LAMBDA:
      case FandangoParser::NONE:
      case FandangoParser::NOT:
      case FandangoParser::TRUE:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(1467);
        star_expressions();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AugassignContext ------------------------------------------------------------------

FandangoParser::AugassignContext::AugassignContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::AugassignContext::ADD_ASSIGN() {
  return getToken(FandangoParser::ADD_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::SUB_ASSIGN() {
  return getToken(FandangoParser::SUB_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::MULT_ASSIGN() {
  return getToken(FandangoParser::MULT_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::AT_ASSIGN() {
  return getToken(FandangoParser::AT_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::DIV_ASSIGN() {
  return getToken(FandangoParser::DIV_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::MOD_ASSIGN() {
  return getToken(FandangoParser::MOD_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::AND_ASSIGN() {
  return getToken(FandangoParser::AND_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::OR_ASSIGN() {
  return getToken(FandangoParser::OR_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::XOR_ASSIGN() {
  return getToken(FandangoParser::XOR_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::LEFT_SHIFT_ASSIGN() {
  return getToken(FandangoParser::LEFT_SHIFT_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::RIGHT_SHIFT_ASSIGN() {
  return getToken(FandangoParser::RIGHT_SHIFT_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::POWER_ASSIGN() {
  return getToken(FandangoParser::POWER_ASSIGN, 0);
}

tree::TerminalNode* FandangoParser::AugassignContext::IDIV_ASSIGN() {
  return getToken(FandangoParser::IDIV_ASSIGN, 0);
}


size_t FandangoParser::AugassignContext::getRuleIndex() const {
  return FandangoParser::RuleAugassign;
}


std::any FandangoParser::AugassignContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAugassign(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::AugassignContext* FandangoParser::augassign() {
  AugassignContext *_localctx = _tracker.createInstance<AugassignContext>(_ctx, getState());
  enterRule(_localctx, 112, FandangoParser::RuleAugassign);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1470);
    _la = _input->LA(1);
    if (!(((((_la - 113) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 113)) & 8191) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Return_stmtContext ------------------------------------------------------------------

FandangoParser::Return_stmtContext::Return_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Return_stmtContext::RETURN() {
  return getToken(FandangoParser::RETURN, 0);
}

FandangoParser::Star_expressionsContext* FandangoParser::Return_stmtContext::star_expressions() {
  return getRuleContext<FandangoParser::Star_expressionsContext>(0);
}


size_t FandangoParser::Return_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleReturn_stmt;
}


std::any FandangoParser::Return_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitReturn_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Return_stmtContext* FandangoParser::return_stmt() {
  Return_stmtContext *_localctx = _tracker.createInstance<Return_stmtContext>(_ctx, getState());
  enterRule(_localctx, 114, FandangoParser::RuleReturn_stmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1472);
    match(FandangoParser::RETURN);
    setState(1474);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx)) {
    case 1: {
      setState(1473);
      star_expressions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Raise_stmtContext ------------------------------------------------------------------

FandangoParser::Raise_stmtContext::Raise_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Raise_stmtContext::RAISE() {
  return getToken(FandangoParser::RAISE, 0);
}

std::vector<FandangoParser::ExpressionContext *> FandangoParser::Raise_stmtContext::expression() {
  return getRuleContexts<FandangoParser::ExpressionContext>();
}

FandangoParser::ExpressionContext* FandangoParser::Raise_stmtContext::expression(size_t i) {
  return getRuleContext<FandangoParser::ExpressionContext>(i);
}

tree::TerminalNode* FandangoParser::Raise_stmtContext::FROM() {
  return getToken(FandangoParser::FROM, 0);
}


size_t FandangoParser::Raise_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleRaise_stmt;
}


std::any FandangoParser::Raise_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitRaise_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Raise_stmtContext* FandangoParser::raise_stmt() {
  Raise_stmtContext *_localctx = _tracker.createInstance<Raise_stmtContext>(_ctx, getState());
  enterRule(_localctx, 116, FandangoParser::RuleRaise_stmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1483);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 144, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1476);
      match(FandangoParser::RAISE);
      setState(1477);
      expression();
      setState(1480);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx)) {
      case 1: {
        setState(1478);
        match(FandangoParser::FROM);
        setState(1479);
        expression();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1482);
      match(FandangoParser::RAISE);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Global_stmtContext ------------------------------------------------------------------

FandangoParser::Global_stmtContext::Global_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Global_stmtContext::GLOBAL() {
  return getToken(FandangoParser::GLOBAL, 0);
}

std::vector<FandangoParser::IdentifierContext *> FandangoParser::Global_stmtContext::identifier() {
  return getRuleContexts<FandangoParser::IdentifierContext>();
}

FandangoParser::IdentifierContext* FandangoParser::Global_stmtContext::identifier(size_t i) {
  return getRuleContext<FandangoParser::IdentifierContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Global_stmtContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Global_stmtContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Global_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleGlobal_stmt;
}


std::any FandangoParser::Global_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGlobal_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Global_stmtContext* FandangoParser::global_stmt() {
  Global_stmtContext *_localctx = _tracker.createInstance<Global_stmtContext>(_ctx, getState());
  enterRule(_localctx, 118, FandangoParser::RuleGlobal_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1485);
    match(FandangoParser::GLOBAL);
    setState(1486);
    identifier();
    setState(1491);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::COMMA) {
      setState(1487);
      match(FandangoParser::COMMA);
      setState(1488);
      identifier();
      setState(1493);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Nonlocal_stmtContext ------------------------------------------------------------------

FandangoParser::Nonlocal_stmtContext::Nonlocal_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Nonlocal_stmtContext::NONLOCAL() {
  return getToken(FandangoParser::NONLOCAL, 0);
}

std::vector<FandangoParser::IdentifierContext *> FandangoParser::Nonlocal_stmtContext::identifier() {
  return getRuleContexts<FandangoParser::IdentifierContext>();
}

FandangoParser::IdentifierContext* FandangoParser::Nonlocal_stmtContext::identifier(size_t i) {
  return getRuleContext<FandangoParser::IdentifierContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Nonlocal_stmtContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Nonlocal_stmtContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Nonlocal_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleNonlocal_stmt;
}


std::any FandangoParser::Nonlocal_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitNonlocal_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Nonlocal_stmtContext* FandangoParser::nonlocal_stmt() {
  Nonlocal_stmtContext *_localctx = _tracker.createInstance<Nonlocal_stmtContext>(_ctx, getState());
  enterRule(_localctx, 120, FandangoParser::RuleNonlocal_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1494);
    match(FandangoParser::NONLOCAL);
    setState(1495);
    identifier();
    setState(1500);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::COMMA) {
      setState(1496);
      match(FandangoParser::COMMA);
      setState(1497);
      identifier();
      setState(1502);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Del_stmtContext ------------------------------------------------------------------

FandangoParser::Del_stmtContext::Del_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Del_stmtContext::DEL() {
  return getToken(FandangoParser::DEL, 0);
}

FandangoParser::Del_targetsContext* FandangoParser::Del_stmtContext::del_targets() {
  return getRuleContext<FandangoParser::Del_targetsContext>(0);
}


size_t FandangoParser::Del_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleDel_stmt;
}


std::any FandangoParser::Del_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDel_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Del_stmtContext* FandangoParser::del_stmt() {
  Del_stmtContext *_localctx = _tracker.createInstance<Del_stmtContext>(_ctx, getState());
  enterRule(_localctx, 122, FandangoParser::RuleDel_stmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1503);
    match(FandangoParser::DEL);
    setState(1504);
    del_targets();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Yield_stmtContext ------------------------------------------------------------------

FandangoParser::Yield_stmtContext::Yield_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Yield_exprContext* FandangoParser::Yield_stmtContext::yield_expr() {
  return getRuleContext<FandangoParser::Yield_exprContext>(0);
}


size_t FandangoParser::Yield_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleYield_stmt;
}


std::any FandangoParser::Yield_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitYield_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Yield_stmtContext* FandangoParser::yield_stmt() {
  Yield_stmtContext *_localctx = _tracker.createInstance<Yield_stmtContext>(_ctx, getState());
  enterRule(_localctx, 124, FandangoParser::RuleYield_stmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1506);
    yield_expr();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Assert_stmtContext ------------------------------------------------------------------

FandangoParser::Assert_stmtContext::Assert_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Assert_stmtContext::ASSERT() {
  return getToken(FandangoParser::ASSERT, 0);
}

std::vector<FandangoParser::ExpressionContext *> FandangoParser::Assert_stmtContext::expression() {
  return getRuleContexts<FandangoParser::ExpressionContext>();
}

FandangoParser::ExpressionContext* FandangoParser::Assert_stmtContext::expression(size_t i) {
  return getRuleContext<FandangoParser::ExpressionContext>(i);
}

tree::TerminalNode* FandangoParser::Assert_stmtContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Assert_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleAssert_stmt;
}


std::any FandangoParser::Assert_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAssert_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Assert_stmtContext* FandangoParser::assert_stmt() {
  Assert_stmtContext *_localctx = _tracker.createInstance<Assert_stmtContext>(_ctx, getState());
  enterRule(_localctx, 126, FandangoParser::RuleAssert_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1508);
    match(FandangoParser::ASSERT);
    setState(1509);
    expression();
    setState(1512);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(1510);
      match(FandangoParser::COMMA);
      setState(1511);
      expression();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Import_stmtContext ------------------------------------------------------------------

FandangoParser::Import_stmtContext::Import_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Import_nameContext* FandangoParser::Import_stmtContext::import_name() {
  return getRuleContext<FandangoParser::Import_nameContext>(0);
}

FandangoParser::Import_fromContext* FandangoParser::Import_stmtContext::import_from() {
  return getRuleContext<FandangoParser::Import_fromContext>(0);
}


size_t FandangoParser::Import_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleImport_stmt;
}


std::any FandangoParser::Import_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImport_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Import_stmtContext* FandangoParser::import_stmt() {
  Import_stmtContext *_localctx = _tracker.createInstance<Import_stmtContext>(_ctx, getState());
  enterRule(_localctx, 128, FandangoParser::RuleImport_stmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1516);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::IMPORT: {
        enterOuterAlt(_localctx, 1);
        setState(1514);
        import_name();
        break;
      }

      case FandangoParser::FROM: {
        enterOuterAlt(_localctx, 2);
        setState(1515);
        import_from();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Import_nameContext ------------------------------------------------------------------

FandangoParser::Import_nameContext::Import_nameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Import_nameContext::IMPORT() {
  return getToken(FandangoParser::IMPORT, 0);
}

FandangoParser::Dotted_as_namesContext* FandangoParser::Import_nameContext::dotted_as_names() {
  return getRuleContext<FandangoParser::Dotted_as_namesContext>(0);
}


size_t FandangoParser::Import_nameContext::getRuleIndex() const {
  return FandangoParser::RuleImport_name;
}


std::any FandangoParser::Import_nameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImport_name(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Import_nameContext* FandangoParser::import_name() {
  Import_nameContext *_localctx = _tracker.createInstance<Import_nameContext>(_ctx, getState());
  enterRule(_localctx, 130, FandangoParser::RuleImport_name);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1518);
    match(FandangoParser::IMPORT);
    setState(1519);
    dotted_as_names();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Import_fromContext ------------------------------------------------------------------

FandangoParser::Import_fromContext::Import_fromContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Import_fromContext::FROM() {
  return getToken(FandangoParser::FROM, 0);
}

FandangoParser::Dotted_nameContext* FandangoParser::Import_fromContext::dotted_name() {
  return getRuleContext<FandangoParser::Dotted_nameContext>(0);
}

tree::TerminalNode* FandangoParser::Import_fromContext::IMPORT() {
  return getToken(FandangoParser::IMPORT, 0);
}

FandangoParser::Import_from_targetsContext* FandangoParser::Import_fromContext::import_from_targets() {
  return getRuleContext<FandangoParser::Import_from_targetsContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Import_fromContext::DOT() {
  return getTokens(FandangoParser::DOT);
}

tree::TerminalNode* FandangoParser::Import_fromContext::DOT(size_t i) {
  return getToken(FandangoParser::DOT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Import_fromContext::ELLIPSIS() {
  return getTokens(FandangoParser::ELLIPSIS);
}

tree::TerminalNode* FandangoParser::Import_fromContext::ELLIPSIS(size_t i) {
  return getToken(FandangoParser::ELLIPSIS, i);
}


size_t FandangoParser::Import_fromContext::getRuleIndex() const {
  return FandangoParser::RuleImport_from;
}


std::any FandangoParser::Import_fromContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImport_from(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Import_fromContext* FandangoParser::import_from() {
  Import_fromContext *_localctx = _tracker.createInstance<Import_fromContext>(_ctx, getState());
  enterRule(_localctx, 132, FandangoParser::RuleImport_from);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1540);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 151, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1521);
      match(FandangoParser::FROM);
      setState(1525);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::ELLIPSIS

      || _la == FandangoParser::DOT) {
        setState(1522);
        _la = _input->LA(1);
        if (!(_la == FandangoParser::ELLIPSIS

        || _la == FandangoParser::DOT)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1527);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1528);
      dotted_name(0);
      setState(1529);
      match(FandangoParser::IMPORT);
      setState(1530);
      import_from_targets();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1532);
      match(FandangoParser::FROM);
      setState(1534); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1533);
        _la = _input->LA(1);
        if (!(_la == FandangoParser::ELLIPSIS

        || _la == FandangoParser::DOT)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1536); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == FandangoParser::ELLIPSIS

      || _la == FandangoParser::DOT);
      setState(1538);
      match(FandangoParser::IMPORT);
      setState(1539);
      import_from_targets();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Import_from_targetsContext ------------------------------------------------------------------

FandangoParser::Import_from_targetsContext::Import_from_targetsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Import_from_targetsContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::Import_from_as_namesContext* FandangoParser::Import_from_targetsContext::import_from_as_names() {
  return getRuleContext<FandangoParser::Import_from_as_namesContext>(0);
}

tree::TerminalNode* FandangoParser::Import_from_targetsContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Import_from_targetsContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}

tree::TerminalNode* FandangoParser::Import_from_targetsContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}


size_t FandangoParser::Import_from_targetsContext::getRuleIndex() const {
  return FandangoParser::RuleImport_from_targets;
}


std::any FandangoParser::Import_from_targetsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImport_from_targets(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Import_from_targetsContext* FandangoParser::import_from_targets() {
  Import_from_targetsContext *_localctx = _tracker.createInstance<Import_from_targetsContext>(_ctx, getState());
  enterRule(_localctx, 134, FandangoParser::RuleImport_from_targets);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1551);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::OPEN_PAREN: {
        enterOuterAlt(_localctx, 1);
        setState(1542);
        match(FandangoParser::OPEN_PAREN);
        setState(1543);
        import_from_as_names();
        setState(1545);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FandangoParser::COMMA) {
          setState(1544);
          match(FandangoParser::COMMA);
        }
        setState(1547);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME: {
        enterOuterAlt(_localctx, 2);
        setState(1549);
        import_from_as_names();
        break;
      }

      case FandangoParser::STAR: {
        enterOuterAlt(_localctx, 3);
        setState(1550);
        match(FandangoParser::STAR);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Import_from_as_namesContext ------------------------------------------------------------------

FandangoParser::Import_from_as_namesContext::Import_from_as_namesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Import_from_as_nameContext *> FandangoParser::Import_from_as_namesContext::import_from_as_name() {
  return getRuleContexts<FandangoParser::Import_from_as_nameContext>();
}

FandangoParser::Import_from_as_nameContext* FandangoParser::Import_from_as_namesContext::import_from_as_name(size_t i) {
  return getRuleContext<FandangoParser::Import_from_as_nameContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Import_from_as_namesContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Import_from_as_namesContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Import_from_as_namesContext::getRuleIndex() const {
  return FandangoParser::RuleImport_from_as_names;
}


std::any FandangoParser::Import_from_as_namesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImport_from_as_names(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Import_from_as_namesContext* FandangoParser::import_from_as_names() {
  Import_from_as_namesContext *_localctx = _tracker.createInstance<Import_from_as_namesContext>(_ctx, getState());
  enterRule(_localctx, 136, FandangoParser::RuleImport_from_as_names);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1553);
    import_from_as_name();
    setState(1558);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1554);
        match(FandangoParser::COMMA);
        setState(1555);
        import_from_as_name(); 
      }
      setState(1560);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Import_from_as_nameContext ------------------------------------------------------------------

FandangoParser::Import_from_as_nameContext::Import_from_as_nameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::IdentifierContext *> FandangoParser::Import_from_as_nameContext::identifier() {
  return getRuleContexts<FandangoParser::IdentifierContext>();
}

FandangoParser::IdentifierContext* FandangoParser::Import_from_as_nameContext::identifier(size_t i) {
  return getRuleContext<FandangoParser::IdentifierContext>(i);
}

tree::TerminalNode* FandangoParser::Import_from_as_nameContext::AS() {
  return getToken(FandangoParser::AS, 0);
}


size_t FandangoParser::Import_from_as_nameContext::getRuleIndex() const {
  return FandangoParser::RuleImport_from_as_name;
}


std::any FandangoParser::Import_from_as_nameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImport_from_as_name(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Import_from_as_nameContext* FandangoParser::import_from_as_name() {
  Import_from_as_nameContext *_localctx = _tracker.createInstance<Import_from_as_nameContext>(_ctx, getState());
  enterRule(_localctx, 138, FandangoParser::RuleImport_from_as_name);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1561);
    identifier();
    setState(1564);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::AS) {
      setState(1562);
      match(FandangoParser::AS);
      setState(1563);
      identifier();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Dotted_as_namesContext ------------------------------------------------------------------

FandangoParser::Dotted_as_namesContext::Dotted_as_namesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Dotted_as_nameContext *> FandangoParser::Dotted_as_namesContext::dotted_as_name() {
  return getRuleContexts<FandangoParser::Dotted_as_nameContext>();
}

FandangoParser::Dotted_as_nameContext* FandangoParser::Dotted_as_namesContext::dotted_as_name(size_t i) {
  return getRuleContext<FandangoParser::Dotted_as_nameContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Dotted_as_namesContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Dotted_as_namesContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Dotted_as_namesContext::getRuleIndex() const {
  return FandangoParser::RuleDotted_as_names;
}


std::any FandangoParser::Dotted_as_namesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDotted_as_names(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Dotted_as_namesContext* FandangoParser::dotted_as_names() {
  Dotted_as_namesContext *_localctx = _tracker.createInstance<Dotted_as_namesContext>(_ctx, getState());
  enterRule(_localctx, 140, FandangoParser::RuleDotted_as_names);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1566);
    dotted_as_name();
    setState(1571);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::COMMA) {
      setState(1567);
      match(FandangoParser::COMMA);
      setState(1568);
      dotted_as_name();
      setState(1573);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Dotted_as_nameContext ------------------------------------------------------------------

FandangoParser::Dotted_as_nameContext::Dotted_as_nameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Dotted_nameContext* FandangoParser::Dotted_as_nameContext::dotted_name() {
  return getRuleContext<FandangoParser::Dotted_nameContext>(0);
}

tree::TerminalNode* FandangoParser::Dotted_as_nameContext::AS() {
  return getToken(FandangoParser::AS, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Dotted_as_nameContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}


size_t FandangoParser::Dotted_as_nameContext::getRuleIndex() const {
  return FandangoParser::RuleDotted_as_name;
}


std::any FandangoParser::Dotted_as_nameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDotted_as_name(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Dotted_as_nameContext* FandangoParser::dotted_as_name() {
  Dotted_as_nameContext *_localctx = _tracker.createInstance<Dotted_as_nameContext>(_ctx, getState());
  enterRule(_localctx, 142, FandangoParser::RuleDotted_as_name);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1574);
    dotted_name(0);
    setState(1577);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::AS) {
      setState(1575);
      match(FandangoParser::AS);
      setState(1576);
      identifier();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Dotted_nameContext ------------------------------------------------------------------

FandangoParser::Dotted_nameContext::Dotted_nameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Dotted_nameContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

FandangoParser::Dotted_nameContext* FandangoParser::Dotted_nameContext::dotted_name() {
  return getRuleContext<FandangoParser::Dotted_nameContext>(0);
}

tree::TerminalNode* FandangoParser::Dotted_nameContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}


size_t FandangoParser::Dotted_nameContext::getRuleIndex() const {
  return FandangoParser::RuleDotted_name;
}


std::any FandangoParser::Dotted_nameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDotted_name(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Dotted_nameContext* FandangoParser::dotted_name() {
   return dotted_name(0);
}

FandangoParser::Dotted_nameContext* FandangoParser::dotted_name(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Dotted_nameContext *_localctx = _tracker.createInstance<Dotted_nameContext>(_ctx, parentState);
  FandangoParser::Dotted_nameContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 144;
  enterRecursionRule(_localctx, 144, FandangoParser::RuleDotted_name, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1580);
    identifier();
    _ctx->stop = _input->LT(-1);
    setState(1587);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<Dotted_nameContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleDotted_name);
        setState(1582);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(1583);
        match(FandangoParser::DOT);
        setState(1584);
        identifier(); 
      }
      setState(1589);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- BlockContext ------------------------------------------------------------------

FandangoParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::BlockContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}

tree::TerminalNode* FandangoParser::BlockContext::INDENT() {
  return getToken(FandangoParser::INDENT, 0);
}

FandangoParser::StatementsContext* FandangoParser::BlockContext::statements() {
  return getRuleContext<FandangoParser::StatementsContext>(0);
}

tree::TerminalNode* FandangoParser::BlockContext::DEDENT() {
  return getToken(FandangoParser::DEDENT, 0);
}

FandangoParser::Simple_stmtsContext* FandangoParser::BlockContext::simple_stmts() {
  return getRuleContext<FandangoParser::Simple_stmtsContext>(0);
}


size_t FandangoParser::BlockContext::getRuleIndex() const {
  return FandangoParser::RuleBlock;
}


std::any FandangoParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitBlock(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::BlockContext* FandangoParser::block() {
  BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
  enterRule(_localctx, 146, FandangoParser::RuleBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1596);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NEWLINE: {
        enterOuterAlt(_localctx, 1);
        setState(1590);
        match(FandangoParser::NEWLINE);
        setState(1591);
        match(FandangoParser::INDENT);
        setState(1592);
        statements();
        setState(1593);
        match(FandangoParser::DEDENT);
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::ASSERT:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEL:
      case FandangoParser::FALSE:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IMPORT:
      case FandangoParser::LAMBDA:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TYPE:
      case FandangoParser::YIELD:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(1595);
        simple_stmts();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DecoratorsContext ------------------------------------------------------------------

FandangoParser::DecoratorsContext::DecoratorsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FandangoParser::DecoratorsContext::AT() {
  return getTokens(FandangoParser::AT);
}

tree::TerminalNode* FandangoParser::DecoratorsContext::AT(size_t i) {
  return getToken(FandangoParser::AT, i);
}

std::vector<FandangoParser::Named_expressionContext *> FandangoParser::DecoratorsContext::named_expression() {
  return getRuleContexts<FandangoParser::Named_expressionContext>();
}

FandangoParser::Named_expressionContext* FandangoParser::DecoratorsContext::named_expression(size_t i) {
  return getRuleContext<FandangoParser::Named_expressionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::DecoratorsContext::NEWLINE() {
  return getTokens(FandangoParser::NEWLINE);
}

tree::TerminalNode* FandangoParser::DecoratorsContext::NEWLINE(size_t i) {
  return getToken(FandangoParser::NEWLINE, i);
}


size_t FandangoParser::DecoratorsContext::getRuleIndex() const {
  return FandangoParser::RuleDecorators;
}


std::any FandangoParser::DecoratorsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDecorators(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::DecoratorsContext* FandangoParser::decorators() {
  DecoratorsContext *_localctx = _tracker.createInstance<DecoratorsContext>(_ctx, getState());
  enterRule(_localctx, 148, FandangoParser::RuleDecorators);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1602); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1598);
      match(FandangoParser::AT);
      setState(1599);
      named_expression();
      setState(1600);
      match(FandangoParser::NEWLINE);
      setState(1604); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FandangoParser::AT);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Class_defContext ------------------------------------------------------------------

FandangoParser::Class_defContext::Class_defContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Class_def_rawContext* FandangoParser::Class_defContext::class_def_raw() {
  return getRuleContext<FandangoParser::Class_def_rawContext>(0);
}

FandangoParser::DecoratorsContext* FandangoParser::Class_defContext::decorators() {
  return getRuleContext<FandangoParser::DecoratorsContext>(0);
}


size_t FandangoParser::Class_defContext::getRuleIndex() const {
  return FandangoParser::RuleClass_def;
}


std::any FandangoParser::Class_defContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitClass_def(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Class_defContext* FandangoParser::class_def() {
  Class_defContext *_localctx = _tracker.createInstance<Class_defContext>(_ctx, getState());
  enterRule(_localctx, 150, FandangoParser::RuleClass_def);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1607);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::AT) {
      setState(1606);
      decorators();
    }
    setState(1609);
    class_def_raw();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Class_def_rawContext ------------------------------------------------------------------

FandangoParser::Class_def_rawContext::Class_def_rawContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Class_def_rawContext::CLASS() {
  return getToken(FandangoParser::CLASS, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Class_def_rawContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Class_def_rawContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Class_def_rawContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

FandangoParser::Type_paramsContext* FandangoParser::Class_def_rawContext::type_params() {
  return getRuleContext<FandangoParser::Type_paramsContext>(0);
}

tree::TerminalNode* FandangoParser::Class_def_rawContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Class_def_rawContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::ArgumentsContext* FandangoParser::Class_def_rawContext::arguments() {
  return getRuleContext<FandangoParser::ArgumentsContext>(0);
}


size_t FandangoParser::Class_def_rawContext::getRuleIndex() const {
  return FandangoParser::RuleClass_def_raw;
}


std::any FandangoParser::Class_def_rawContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitClass_def_raw(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Class_def_rawContext* FandangoParser::class_def_raw() {
  Class_def_rawContext *_localctx = _tracker.createInstance<Class_def_rawContext>(_ctx, getState());
  enterRule(_localctx, 152, FandangoParser::RuleClass_def_raw);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1611);
    match(FandangoParser::CLASS);
    setState(1612);
    identifier();
    setState(1614);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::OPEN_BRACK) {
      setState(1613);
      type_params();
    }
    setState(1621);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::OPEN_PAREN) {
      setState(1616);
      match(FandangoParser::OPEN_PAREN);
      setState(1618);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 93071897) != 0)) {
        setState(1617);
        arguments();
      }
      setState(1620);
      match(FandangoParser::CLOSE_PAREN);
    }
    setState(1623);
    match(FandangoParser::COLON);
    setState(1624);
    block();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Function_defContext ------------------------------------------------------------------

FandangoParser::Function_defContext::Function_defContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Function_def_rawContext* FandangoParser::Function_defContext::function_def_raw() {
  return getRuleContext<FandangoParser::Function_def_rawContext>(0);
}

FandangoParser::DecoratorsContext* FandangoParser::Function_defContext::decorators() {
  return getRuleContext<FandangoParser::DecoratorsContext>(0);
}


size_t FandangoParser::Function_defContext::getRuleIndex() const {
  return FandangoParser::RuleFunction_def;
}


std::any FandangoParser::Function_defContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFunction_def(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Function_defContext* FandangoParser::function_def() {
  Function_defContext *_localctx = _tracker.createInstance<Function_defContext>(_ctx, getState());
  enterRule(_localctx, 154, FandangoParser::RuleFunction_def);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1627);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::AT) {
      setState(1626);
      decorators();
    }
    setState(1629);
    function_def_raw();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Function_def_rawContext ------------------------------------------------------------------

FandangoParser::Function_def_rawContext::Function_def_rawContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Function_def_rawContext::DEF() {
  return getToken(FandangoParser::DEF, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Function_def_rawContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Function_def_rawContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Function_def_rawContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Function_def_rawContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Function_def_rawContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

tree::TerminalNode* FandangoParser::Function_def_rawContext::ASYNC() {
  return getToken(FandangoParser::ASYNC, 0);
}

FandangoParser::Type_paramsContext* FandangoParser::Function_def_rawContext::type_params() {
  return getRuleContext<FandangoParser::Type_paramsContext>(0);
}

FandangoParser::ParamsContext* FandangoParser::Function_def_rawContext::params() {
  return getRuleContext<FandangoParser::ParamsContext>(0);
}

tree::TerminalNode* FandangoParser::Function_def_rawContext::ARROW() {
  return getToken(FandangoParser::ARROW, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Function_def_rawContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

FandangoParser::Func_type_commentContext* FandangoParser::Function_def_rawContext::func_type_comment() {
  return getRuleContext<FandangoParser::Func_type_commentContext>(0);
}


size_t FandangoParser::Function_def_rawContext::getRuleIndex() const {
  return FandangoParser::RuleFunction_def_raw;
}


std::any FandangoParser::Function_def_rawContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFunction_def_raw(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Function_def_rawContext* FandangoParser::function_def_raw() {
  Function_def_rawContext *_localctx = _tracker.createInstance<Function_def_rawContext>(_ctx, getState());
  enterRule(_localctx, 156, FandangoParser::RuleFunction_def_raw);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1632);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::ASYNC) {
      setState(1631);
      match(FandangoParser::ASYNC);
    }
    setState(1634);
    match(FandangoParser::DEF);
    setState(1635);
    identifier();
    setState(1637);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::OPEN_BRACK) {
      setState(1636);
      type_params();
    }
    setState(1639);
    match(FandangoParser::OPEN_PAREN);
    setState(1641);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 56) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 56)) & 2181038151) != 0)) {
      setState(1640);
      params();
    }
    setState(1643);
    match(FandangoParser::CLOSE_PAREN);
    setState(1646);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::ARROW) {
      setState(1644);
      match(FandangoParser::ARROW);
      setState(1645);
      expression();
    }
    setState(1648);
    match(FandangoParser::COLON);
    setState(1650);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 170, _ctx)) {
    case 1: {
      setState(1649);
      func_type_comment();
      break;
    }

    default:
      break;
    }
    setState(1652);
    block();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParamsContext ------------------------------------------------------------------

FandangoParser::ParamsContext::ParamsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ParametersContext* FandangoParser::ParamsContext::parameters() {
  return getRuleContext<FandangoParser::ParametersContext>(0);
}


size_t FandangoParser::ParamsContext::getRuleIndex() const {
  return FandangoParser::RuleParams;
}


std::any FandangoParser::ParamsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParams(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ParamsContext* FandangoParser::params() {
  ParamsContext *_localctx = _tracker.createInstance<ParamsContext>(_ctx, getState());
  enterRule(_localctx, 158, FandangoParser::RuleParams);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1654);
    parameters();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParametersContext ------------------------------------------------------------------

FandangoParser::ParametersContext::ParametersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Slash_no_defaultContext* FandangoParser::ParametersContext::slash_no_default() {
  return getRuleContext<FandangoParser::Slash_no_defaultContext>(0);
}

std::vector<FandangoParser::Param_no_defaultContext *> FandangoParser::ParametersContext::param_no_default() {
  return getRuleContexts<FandangoParser::Param_no_defaultContext>();
}

FandangoParser::Param_no_defaultContext* FandangoParser::ParametersContext::param_no_default(size_t i) {
  return getRuleContext<FandangoParser::Param_no_defaultContext>(i);
}

std::vector<FandangoParser::Param_with_defaultContext *> FandangoParser::ParametersContext::param_with_default() {
  return getRuleContexts<FandangoParser::Param_with_defaultContext>();
}

FandangoParser::Param_with_defaultContext* FandangoParser::ParametersContext::param_with_default(size_t i) {
  return getRuleContext<FandangoParser::Param_with_defaultContext>(i);
}

FandangoParser::Star_etcContext* FandangoParser::ParametersContext::star_etc() {
  return getRuleContext<FandangoParser::Star_etcContext>(0);
}

FandangoParser::Slash_with_defaultContext* FandangoParser::ParametersContext::slash_with_default() {
  return getRuleContext<FandangoParser::Slash_with_defaultContext>(0);
}


size_t FandangoParser::ParametersContext::getRuleIndex() const {
  return FandangoParser::RuleParameters;
}


std::any FandangoParser::ParametersContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParameters(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ParametersContext* FandangoParser::parameters() {
  ParametersContext *_localctx = _tracker.createInstance<ParametersContext>(_ctx, getState());
  enterRule(_localctx, 160, FandangoParser::RuleParameters);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1705);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1656);
      slash_no_default();
      setState(1660);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1657);
          param_no_default(); 
        }
        setState(1662);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx);
      }
      setState(1666);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(1663);
        param_with_default();
        setState(1668);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1670);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(1669);
        star_etc();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1672);
      slash_with_default();
      setState(1676);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(1673);
        param_with_default();
        setState(1678);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1680);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(1679);
        star_etc();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1683); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1682);
                param_no_default();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1685); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 176, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      setState(1690);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(1687);
        param_with_default();
        setState(1692);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1694);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(1693);
        star_etc();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1697); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1696);
        param_with_default();
        setState(1699); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0));
      setState(1702);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(1701);
        star_etc();
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1704);
      star_etc();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Slash_no_defaultContext ------------------------------------------------------------------

FandangoParser::Slash_no_defaultContext::Slash_no_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Slash_no_defaultContext::DIV() {
  return getToken(FandangoParser::DIV, 0);
}

std::vector<FandangoParser::Param_no_defaultContext *> FandangoParser::Slash_no_defaultContext::param_no_default() {
  return getRuleContexts<FandangoParser::Param_no_defaultContext>();
}

FandangoParser::Param_no_defaultContext* FandangoParser::Slash_no_defaultContext::param_no_default(size_t i) {
  return getRuleContext<FandangoParser::Param_no_defaultContext>(i);
}

tree::TerminalNode* FandangoParser::Slash_no_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Slash_no_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleSlash_no_default;
}


std::any FandangoParser::Slash_no_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSlash_no_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Slash_no_defaultContext* FandangoParser::slash_no_default() {
  Slash_no_defaultContext *_localctx = _tracker.createInstance<Slash_no_defaultContext>(_ctx, getState());
  enterRule(_localctx, 162, FandangoParser::RuleSlash_no_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1708); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1707);
      param_no_default();
      setState(1710); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116089176692883456) != 0));
    setState(1712);
    match(FandangoParser::DIV);
    setState(1714);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(1713);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Slash_with_defaultContext ------------------------------------------------------------------

FandangoParser::Slash_with_defaultContext::Slash_with_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Slash_with_defaultContext::DIV() {
  return getToken(FandangoParser::DIV, 0);
}

std::vector<FandangoParser::Param_no_defaultContext *> FandangoParser::Slash_with_defaultContext::param_no_default() {
  return getRuleContexts<FandangoParser::Param_no_defaultContext>();
}

FandangoParser::Param_no_defaultContext* FandangoParser::Slash_with_defaultContext::param_no_default(size_t i) {
  return getRuleContext<FandangoParser::Param_no_defaultContext>(i);
}

std::vector<FandangoParser::Param_with_defaultContext *> FandangoParser::Slash_with_defaultContext::param_with_default() {
  return getRuleContexts<FandangoParser::Param_with_defaultContext>();
}

FandangoParser::Param_with_defaultContext* FandangoParser::Slash_with_defaultContext::param_with_default(size_t i) {
  return getRuleContext<FandangoParser::Param_with_defaultContext>(i);
}

tree::TerminalNode* FandangoParser::Slash_with_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Slash_with_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleSlash_with_default;
}


std::any FandangoParser::Slash_with_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSlash_with_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Slash_with_defaultContext* FandangoParser::slash_with_default() {
  Slash_with_defaultContext *_localctx = _tracker.createInstance<Slash_with_defaultContext>(_ctx, getState());
  enterRule(_localctx, 164, FandangoParser::RuleSlash_with_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1719);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 184, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1716);
        param_no_default(); 
      }
      setState(1721);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 184, _ctx);
    }
    setState(1723); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1722);
      param_with_default();
      setState(1725); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116089176692883456) != 0));
    setState(1727);
    match(FandangoParser::DIV);
    setState(1729);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(1728);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_etcContext ------------------------------------------------------------------

FandangoParser::Star_etcContext::Star_etcContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Star_etcContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::Param_no_defaultContext* FandangoParser::Star_etcContext::param_no_default() {
  return getRuleContext<FandangoParser::Param_no_defaultContext>(0);
}

std::vector<FandangoParser::Param_maybe_defaultContext *> FandangoParser::Star_etcContext::param_maybe_default() {
  return getRuleContexts<FandangoParser::Param_maybe_defaultContext>();
}

FandangoParser::Param_maybe_defaultContext* FandangoParser::Star_etcContext::param_maybe_default(size_t i) {
  return getRuleContext<FandangoParser::Param_maybe_defaultContext>(i);
}

FandangoParser::KwdsContext* FandangoParser::Star_etcContext::kwds() {
  return getRuleContext<FandangoParser::KwdsContext>(0);
}

FandangoParser::Param_no_default_star_annotationContext* FandangoParser::Star_etcContext::param_no_default_star_annotation() {
  return getRuleContext<FandangoParser::Param_no_default_star_annotationContext>(0);
}

tree::TerminalNode* FandangoParser::Star_etcContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Star_etcContext::getRuleIndex() const {
  return FandangoParser::RuleStar_etc;
}


std::any FandangoParser::Star_etcContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_etc(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_etcContext* FandangoParser::star_etc() {
  Star_etcContext *_localctx = _tracker.createInstance<Star_etcContext>(_ctx, getState());
  enterRule(_localctx, 166, FandangoParser::RuleStar_etc);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1764);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 193, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1731);
      match(FandangoParser::STAR);
      setState(1732);
      param_no_default();
      setState(1736);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(1733);
        param_maybe_default();
        setState(1738);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1740);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::POWER) {
        setState(1739);
        kwds();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1742);
      match(FandangoParser::STAR);
      setState(1743);
      param_no_default_star_annotation();
      setState(1747);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(1744);
        param_maybe_default();
        setState(1749);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1751);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::POWER) {
        setState(1750);
        kwds();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1753);
      match(FandangoParser::STAR);
      setState(1754);
      match(FandangoParser::COMMA);
      setState(1756); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1755);
        param_maybe_default();
        setState(1758); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0));
      setState(1761);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::POWER) {
        setState(1760);
        kwds();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1763);
      kwds();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KwdsContext ------------------------------------------------------------------

FandangoParser::KwdsContext::KwdsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::KwdsContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}

FandangoParser::Param_no_defaultContext* FandangoParser::KwdsContext::param_no_default() {
  return getRuleContext<FandangoParser::Param_no_defaultContext>(0);
}


size_t FandangoParser::KwdsContext::getRuleIndex() const {
  return FandangoParser::RuleKwds;
}


std::any FandangoParser::KwdsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKwds(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::KwdsContext* FandangoParser::kwds() {
  KwdsContext *_localctx = _tracker.createInstance<KwdsContext>(_ctx, getState());
  enterRule(_localctx, 168, FandangoParser::RuleKwds);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1766);
    match(FandangoParser::POWER);
    setState(1767);
    param_no_default();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Param_no_defaultContext ------------------------------------------------------------------

FandangoParser::Param_no_defaultContext::Param_no_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ParamContext* FandangoParser::Param_no_defaultContext::param() {
  return getRuleContext<FandangoParser::ParamContext>(0);
}

tree::TerminalNode* FandangoParser::Param_no_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Param_no_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleParam_no_default;
}


std::any FandangoParser::Param_no_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParam_no_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Param_no_defaultContext* FandangoParser::param_no_default() {
  Param_no_defaultContext *_localctx = _tracker.createInstance<Param_no_defaultContext>(_ctx, getState());
  enterRule(_localctx, 170, FandangoParser::RuleParam_no_default);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1773);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 194, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1769);
      param();
      setState(1770);
      match(FandangoParser::COMMA);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1772);
      param();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Param_no_default_star_annotationContext ------------------------------------------------------------------

FandangoParser::Param_no_default_star_annotationContext::Param_no_default_star_annotationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Param_star_annotationContext* FandangoParser::Param_no_default_star_annotationContext::param_star_annotation() {
  return getRuleContext<FandangoParser::Param_star_annotationContext>(0);
}

tree::TerminalNode* FandangoParser::Param_no_default_star_annotationContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Param_no_default_star_annotationContext::getRuleIndex() const {
  return FandangoParser::RuleParam_no_default_star_annotation;
}


std::any FandangoParser::Param_no_default_star_annotationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParam_no_default_star_annotation(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Param_no_default_star_annotationContext* FandangoParser::param_no_default_star_annotation() {
  Param_no_default_star_annotationContext *_localctx = _tracker.createInstance<Param_no_default_star_annotationContext>(_ctx, getState());
  enterRule(_localctx, 172, FandangoParser::RuleParam_no_default_star_annotation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1779);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 195, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1775);
      param_star_annotation();
      setState(1776);
      match(FandangoParser::COMMA);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1778);
      param_star_annotation();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Param_with_defaultContext ------------------------------------------------------------------

FandangoParser::Param_with_defaultContext::Param_with_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ParamContext* FandangoParser::Param_with_defaultContext::param() {
  return getRuleContext<FandangoParser::ParamContext>(0);
}

FandangoParser::DefaultContext* FandangoParser::Param_with_defaultContext::default_() {
  return getRuleContext<FandangoParser::DefaultContext>(0);
}

tree::TerminalNode* FandangoParser::Param_with_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Param_with_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleParam_with_default;
}


std::any FandangoParser::Param_with_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParam_with_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Param_with_defaultContext* FandangoParser::param_with_default() {
  Param_with_defaultContext *_localctx = _tracker.createInstance<Param_with_defaultContext>(_ctx, getState());
  enterRule(_localctx, 174, FandangoParser::RuleParam_with_default);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1788);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 196, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1781);
      param();
      setState(1782);
      default_();
      setState(1783);
      match(FandangoParser::COMMA);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1785);
      param();
      setState(1786);
      default_();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Param_maybe_defaultContext ------------------------------------------------------------------

FandangoParser::Param_maybe_defaultContext::Param_maybe_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ParamContext* FandangoParser::Param_maybe_defaultContext::param() {
  return getRuleContext<FandangoParser::ParamContext>(0);
}

tree::TerminalNode* FandangoParser::Param_maybe_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}

FandangoParser::DefaultContext* FandangoParser::Param_maybe_defaultContext::default_() {
  return getRuleContext<FandangoParser::DefaultContext>(0);
}


size_t FandangoParser::Param_maybe_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleParam_maybe_default;
}


std::any FandangoParser::Param_maybe_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParam_maybe_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Param_maybe_defaultContext* FandangoParser::param_maybe_default() {
  Param_maybe_defaultContext *_localctx = _tracker.createInstance<Param_maybe_defaultContext>(_ctx, getState());
  enterRule(_localctx, 176, FandangoParser::RuleParam_maybe_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1800);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 199, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1790);
      param();
      setState(1792);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ASSIGN) {
        setState(1791);
        default_();
      }
      setState(1794);
      match(FandangoParser::COMMA);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1796);
      param();
      setState(1798);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ASSIGN) {
        setState(1797);
        default_();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParamContext ------------------------------------------------------------------

FandangoParser::ParamContext::ParamContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::ParamContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

FandangoParser::AnnotationContext* FandangoParser::ParamContext::annotation() {
  return getRuleContext<FandangoParser::AnnotationContext>(0);
}


size_t FandangoParser::ParamContext::getRuleIndex() const {
  return FandangoParser::RuleParam;
}


std::any FandangoParser::ParamContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParam(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ParamContext* FandangoParser::param() {
  ParamContext *_localctx = _tracker.createInstance<ParamContext>(_ctx, getState());
  enterRule(_localctx, 178, FandangoParser::RuleParam);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1802);
    identifier();
    setState(1804);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COLON) {
      setState(1803);
      annotation();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Param_star_annotationContext ------------------------------------------------------------------

FandangoParser::Param_star_annotationContext::Param_star_annotationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Param_star_annotationContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

FandangoParser::Star_annotationContext* FandangoParser::Param_star_annotationContext::star_annotation() {
  return getRuleContext<FandangoParser::Star_annotationContext>(0);
}


size_t FandangoParser::Param_star_annotationContext::getRuleIndex() const {
  return FandangoParser::RuleParam_star_annotation;
}


std::any FandangoParser::Param_star_annotationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitParam_star_annotation(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Param_star_annotationContext* FandangoParser::param_star_annotation() {
  Param_star_annotationContext *_localctx = _tracker.createInstance<Param_star_annotationContext>(_ctx, getState());
  enterRule(_localctx, 180, FandangoParser::RuleParam_star_annotation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1806);
    identifier();
    setState(1807);
    star_annotation();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AnnotationContext ------------------------------------------------------------------

FandangoParser::AnnotationContext::AnnotationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::AnnotationContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::ExpressionContext* FandangoParser::AnnotationContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::AnnotationContext::getRuleIndex() const {
  return FandangoParser::RuleAnnotation;
}


std::any FandangoParser::AnnotationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAnnotation(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::AnnotationContext* FandangoParser::annotation() {
  AnnotationContext *_localctx = _tracker.createInstance<AnnotationContext>(_ctx, getState());
  enterRule(_localctx, 182, FandangoParser::RuleAnnotation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1809);
    match(FandangoParser::COLON);
    setState(1810);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_annotationContext ------------------------------------------------------------------

FandangoParser::Star_annotationContext::Star_annotationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Star_annotationContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::Star_expressionContext* FandangoParser::Star_annotationContext::star_expression() {
  return getRuleContext<FandangoParser::Star_expressionContext>(0);
}


size_t FandangoParser::Star_annotationContext::getRuleIndex() const {
  return FandangoParser::RuleStar_annotation;
}


std::any FandangoParser::Star_annotationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_annotation(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_annotationContext* FandangoParser::star_annotation() {
  Star_annotationContext *_localctx = _tracker.createInstance<Star_annotationContext>(_ctx, getState());
  enterRule(_localctx, 184, FandangoParser::RuleStar_annotation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1812);
    match(FandangoParser::COLON);
    setState(1813);
    star_expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefaultContext ------------------------------------------------------------------

FandangoParser::DefaultContext::DefaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::DefaultContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}

FandangoParser::ExpressionContext* FandangoParser::DefaultContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::DefaultContext::getRuleIndex() const {
  return FandangoParser::RuleDefault;
}


std::any FandangoParser::DefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDefault(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::DefaultContext* FandangoParser::default_() {
  DefaultContext *_localctx = _tracker.createInstance<DefaultContext>(_ctx, getState());
  enterRule(_localctx, 186, FandangoParser::RuleDefault);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1815);
    match(FandangoParser::ASSIGN);
    setState(1816);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- If_stmtContext ------------------------------------------------------------------

FandangoParser::If_stmtContext::If_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::If_stmtContext::IF() {
  return getToken(FandangoParser::IF, 0);
}

FandangoParser::Named_expressionContext* FandangoParser::If_stmtContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}

tree::TerminalNode* FandangoParser::If_stmtContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::If_stmtContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

FandangoParser::Elif_stmtContext* FandangoParser::If_stmtContext::elif_stmt() {
  return getRuleContext<FandangoParser::Elif_stmtContext>(0);
}

FandangoParser::Else_blockContext* FandangoParser::If_stmtContext::else_block() {
  return getRuleContext<FandangoParser::Else_blockContext>(0);
}


size_t FandangoParser::If_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleIf_stmt;
}


std::any FandangoParser::If_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitIf_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::If_stmtContext* FandangoParser::if_stmt() {
  If_stmtContext *_localctx = _tracker.createInstance<If_stmtContext>(_ctx, getState());
  enterRule(_localctx, 188, FandangoParser::RuleIf_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1831);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 202, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1818);
      match(FandangoParser::IF);
      setState(1819);
      named_expression();
      setState(1820);
      match(FandangoParser::COLON);
      setState(1821);
      block();
      setState(1822);
      elif_stmt();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1824);
      match(FandangoParser::IF);
      setState(1825);
      named_expression();
      setState(1826);
      match(FandangoParser::COLON);
      setState(1827);
      block();
      setState(1829);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ELSE) {
        setState(1828);
        else_block();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Elif_stmtContext ------------------------------------------------------------------

FandangoParser::Elif_stmtContext::Elif_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Elif_stmtContext::ELIF() {
  return getToken(FandangoParser::ELIF, 0);
}

FandangoParser::Named_expressionContext* FandangoParser::Elif_stmtContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}

tree::TerminalNode* FandangoParser::Elif_stmtContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Elif_stmtContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

FandangoParser::Elif_stmtContext* FandangoParser::Elif_stmtContext::elif_stmt() {
  return getRuleContext<FandangoParser::Elif_stmtContext>(0);
}

FandangoParser::Else_blockContext* FandangoParser::Elif_stmtContext::else_block() {
  return getRuleContext<FandangoParser::Else_blockContext>(0);
}


size_t FandangoParser::Elif_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleElif_stmt;
}


std::any FandangoParser::Elif_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitElif_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Elif_stmtContext* FandangoParser::elif_stmt() {
  Elif_stmtContext *_localctx = _tracker.createInstance<Elif_stmtContext>(_ctx, getState());
  enterRule(_localctx, 190, FandangoParser::RuleElif_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1846);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 204, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1833);
      match(FandangoParser::ELIF);
      setState(1834);
      named_expression();
      setState(1835);
      match(FandangoParser::COLON);
      setState(1836);
      block();
      setState(1837);
      elif_stmt();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1839);
      match(FandangoParser::ELIF);
      setState(1840);
      named_expression();
      setState(1841);
      match(FandangoParser::COLON);
      setState(1842);
      block();
      setState(1844);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ELSE) {
        setState(1843);
        else_block();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Else_blockContext ------------------------------------------------------------------

FandangoParser::Else_blockContext::Else_blockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Else_blockContext::ELSE() {
  return getToken(FandangoParser::ELSE, 0);
}

tree::TerminalNode* FandangoParser::Else_blockContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Else_blockContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}


size_t FandangoParser::Else_blockContext::getRuleIndex() const {
  return FandangoParser::RuleElse_block;
}


std::any FandangoParser::Else_blockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitElse_block(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Else_blockContext* FandangoParser::else_block() {
  Else_blockContext *_localctx = _tracker.createInstance<Else_blockContext>(_ctx, getState());
  enterRule(_localctx, 192, FandangoParser::RuleElse_block);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1848);
    match(FandangoParser::ELSE);
    setState(1849);
    match(FandangoParser::COLON);
    setState(1850);
    block();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- While_stmtContext ------------------------------------------------------------------

FandangoParser::While_stmtContext::While_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::While_stmtContext::WHILE() {
  return getToken(FandangoParser::WHILE, 0);
}

FandangoParser::Named_expressionContext* FandangoParser::While_stmtContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}

tree::TerminalNode* FandangoParser::While_stmtContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::While_stmtContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

FandangoParser::Else_blockContext* FandangoParser::While_stmtContext::else_block() {
  return getRuleContext<FandangoParser::Else_blockContext>(0);
}


size_t FandangoParser::While_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleWhile_stmt;
}


std::any FandangoParser::While_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitWhile_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::While_stmtContext* FandangoParser::while_stmt() {
  While_stmtContext *_localctx = _tracker.createInstance<While_stmtContext>(_ctx, getState());
  enterRule(_localctx, 194, FandangoParser::RuleWhile_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1852);
    match(FandangoParser::WHILE);
    setState(1853);
    named_expression();
    setState(1854);
    match(FandangoParser::COLON);
    setState(1855);
    block();
    setState(1857);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::ELSE) {
      setState(1856);
      else_block();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- For_stmtContext ------------------------------------------------------------------

FandangoParser::For_stmtContext::For_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::For_stmtContext::FOR() {
  return getToken(FandangoParser::FOR, 0);
}

FandangoParser::Star_targetsContext* FandangoParser::For_stmtContext::star_targets() {
  return getRuleContext<FandangoParser::Star_targetsContext>(0);
}

tree::TerminalNode* FandangoParser::For_stmtContext::IN() {
  return getToken(FandangoParser::IN, 0);
}

FandangoParser::Star_expressionsContext* FandangoParser::For_stmtContext::star_expressions() {
  return getRuleContext<FandangoParser::Star_expressionsContext>(0);
}

tree::TerminalNode* FandangoParser::For_stmtContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::For_stmtContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

FandangoParser::Else_blockContext* FandangoParser::For_stmtContext::else_block() {
  return getRuleContext<FandangoParser::Else_blockContext>(0);
}

tree::TerminalNode* FandangoParser::For_stmtContext::ASYNC() {
  return getToken(FandangoParser::ASYNC, 0);
}


size_t FandangoParser::For_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleFor_stmt;
}


std::any FandangoParser::For_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFor_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::For_stmtContext* FandangoParser::for_stmt() {
  For_stmtContext *_localctx = _tracker.createInstance<For_stmtContext>(_ctx, getState());
  enterRule(_localctx, 196, FandangoParser::RuleFor_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1878);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::FOR: {
        enterOuterAlt(_localctx, 1);
        setState(1859);
        match(FandangoParser::FOR);
        setState(1860);
        star_targets();
        setState(1861);
        match(FandangoParser::IN);
        setState(1862);
        star_expressions();
        setState(1863);
        match(FandangoParser::COLON);
        setState(1864);
        block();
        setState(1866);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FandangoParser::ELSE) {
          setState(1865);
          else_block();
        }
        break;
      }

      case FandangoParser::ASYNC: {
        enterOuterAlt(_localctx, 2);
        setState(1868);
        match(FandangoParser::ASYNC);
        setState(1869);
        match(FandangoParser::FOR);
        setState(1870);
        star_targets();
        setState(1871);
        match(FandangoParser::IN);
        setState(1872);
        star_expressions();
        setState(1873);
        match(FandangoParser::COLON);
        setState(1874);
        block();
        setState(1876);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FandangoParser::ELSE) {
          setState(1875);
          else_block();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- With_stmtContext ------------------------------------------------------------------

FandangoParser::With_stmtContext::With_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::With_stmtContext::WITH() {
  return getToken(FandangoParser::WITH, 0);
}

tree::TerminalNode* FandangoParser::With_stmtContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

std::vector<FandangoParser::With_itemContext *> FandangoParser::With_stmtContext::with_item() {
  return getRuleContexts<FandangoParser::With_itemContext>();
}

FandangoParser::With_itemContext* FandangoParser::With_stmtContext::with_item(size_t i) {
  return getRuleContext<FandangoParser::With_itemContext>(i);
}

tree::TerminalNode* FandangoParser::With_stmtContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

tree::TerminalNode* FandangoParser::With_stmtContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::With_stmtContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::With_stmtContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::With_stmtContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}

tree::TerminalNode* FandangoParser::With_stmtContext::ASYNC() {
  return getToken(FandangoParser::ASYNC, 0);
}


size_t FandangoParser::With_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleWith_stmt;
}


std::any FandangoParser::With_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitWith_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::With_stmtContext* FandangoParser::with_stmt() {
  With_stmtContext *_localctx = _tracker.createInstance<With_stmtContext>(_ctx, getState());
  enterRule(_localctx, 198, FandangoParser::RuleWith_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1940);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 215, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1880);
      match(FandangoParser::WITH);
      setState(1881);
      match(FandangoParser::OPEN_PAREN);
      setState(1882);
      with_item();
      setState(1887);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 209, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1883);
          match(FandangoParser::COMMA);
          setState(1884);
          with_item(); 
        }
        setState(1889);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 209, _ctx);
      }
      setState(1891);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(1890);
        match(FandangoParser::COMMA);
      }
      setState(1893);
      match(FandangoParser::CLOSE_PAREN);
      setState(1894);
      match(FandangoParser::COLON);
      setState(1895);
      block();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1897);
      match(FandangoParser::WITH);
      setState(1898);
      with_item();
      setState(1903);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::COMMA) {
        setState(1899);
        match(FandangoParser::COMMA);
        setState(1900);
        with_item();
        setState(1905);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1906);
      match(FandangoParser::COLON);
      setState(1907);
      block();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1909);
      match(FandangoParser::ASYNC);
      setState(1910);
      match(FandangoParser::WITH);
      setState(1911);
      match(FandangoParser::OPEN_PAREN);
      setState(1912);
      with_item();
      setState(1917);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 212, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1913);
          match(FandangoParser::COMMA);
          setState(1914);
          with_item(); 
        }
        setState(1919);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 212, _ctx);
      }
      setState(1921);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(1920);
        match(FandangoParser::COMMA);
      }
      setState(1923);
      match(FandangoParser::CLOSE_PAREN);
      setState(1924);
      match(FandangoParser::COLON);
      setState(1925);
      block();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1927);
      match(FandangoParser::ASYNC);
      setState(1928);
      match(FandangoParser::WITH);
      setState(1929);
      with_item();
      setState(1934);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::COMMA) {
        setState(1930);
        match(FandangoParser::COMMA);
        setState(1931);
        with_item();
        setState(1936);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1937);
      match(FandangoParser::COLON);
      setState(1938);
      block();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- With_itemContext ------------------------------------------------------------------

FandangoParser::With_itemContext::With_itemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ExpressionContext* FandangoParser::With_itemContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

tree::TerminalNode* FandangoParser::With_itemContext::AS() {
  return getToken(FandangoParser::AS, 0);
}

FandangoParser::Star_targetContext* FandangoParser::With_itemContext::star_target() {
  return getRuleContext<FandangoParser::Star_targetContext>(0);
}


size_t FandangoParser::With_itemContext::getRuleIndex() const {
  return FandangoParser::RuleWith_item;
}


std::any FandangoParser::With_itemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitWith_item(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::With_itemContext* FandangoParser::with_item() {
  With_itemContext *_localctx = _tracker.createInstance<With_itemContext>(_ctx, getState());
  enterRule(_localctx, 200, FandangoParser::RuleWith_item);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1947);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 216, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1942);
      expression();
      setState(1943);
      match(FandangoParser::AS);
      setState(1944);
      star_target();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1946);
      expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Try_stmtContext ------------------------------------------------------------------

FandangoParser::Try_stmtContext::Try_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Try_stmtContext::TRY() {
  return getToken(FandangoParser::TRY, 0);
}

tree::TerminalNode* FandangoParser::Try_stmtContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Try_stmtContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

FandangoParser::Finally_blockContext* FandangoParser::Try_stmtContext::finally_block() {
  return getRuleContext<FandangoParser::Finally_blockContext>(0);
}

std::vector<FandangoParser::Except_blockContext *> FandangoParser::Try_stmtContext::except_block() {
  return getRuleContexts<FandangoParser::Except_blockContext>();
}

FandangoParser::Except_blockContext* FandangoParser::Try_stmtContext::except_block(size_t i) {
  return getRuleContext<FandangoParser::Except_blockContext>(i);
}

FandangoParser::Else_blockContext* FandangoParser::Try_stmtContext::else_block() {
  return getRuleContext<FandangoParser::Else_blockContext>(0);
}

std::vector<FandangoParser::Except_star_blockContext *> FandangoParser::Try_stmtContext::except_star_block() {
  return getRuleContexts<FandangoParser::Except_star_blockContext>();
}

FandangoParser::Except_star_blockContext* FandangoParser::Try_stmtContext::except_star_block(size_t i) {
  return getRuleContext<FandangoParser::Except_star_blockContext>(i);
}


size_t FandangoParser::Try_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleTry_stmt;
}


std::any FandangoParser::Try_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitTry_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Try_stmtContext* FandangoParser::try_stmt() {
  Try_stmtContext *_localctx = _tracker.createInstance<Try_stmtContext>(_ctx, getState());
  enterRule(_localctx, 202, FandangoParser::RuleTry_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1982);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 223, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1949);
      match(FandangoParser::TRY);
      setState(1950);
      match(FandangoParser::COLON);
      setState(1951);
      block();
      setState(1952);
      finally_block();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1954);
      match(FandangoParser::TRY);
      setState(1955);
      match(FandangoParser::COLON);
      setState(1956);
      block();
      setState(1958); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1957);
        except_block();
        setState(1960); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == FandangoParser::EXCEPT);
      setState(1963);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ELSE) {
        setState(1962);
        else_block();
      }
      setState(1966);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::FINALLY) {
        setState(1965);
        finally_block();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1968);
      match(FandangoParser::TRY);
      setState(1969);
      match(FandangoParser::COLON);
      setState(1970);
      block();
      setState(1972); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1971);
        except_star_block();
        setState(1974); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == FandangoParser::EXCEPT);
      setState(1977);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::ELSE) {
        setState(1976);
        else_block();
      }
      setState(1980);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::FINALLY) {
        setState(1979);
        finally_block();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Except_blockContext ------------------------------------------------------------------

FandangoParser::Except_blockContext::Except_blockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Except_blockContext::EXCEPT() {
  return getToken(FandangoParser::EXCEPT, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Except_blockContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

tree::TerminalNode* FandangoParser::Except_blockContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Except_blockContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

tree::TerminalNode* FandangoParser::Except_blockContext::AS() {
  return getToken(FandangoParser::AS, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Except_blockContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}


size_t FandangoParser::Except_blockContext::getRuleIndex() const {
  return FandangoParser::RuleExcept_block;
}


std::any FandangoParser::Except_blockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitExcept_block(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Except_blockContext* FandangoParser::except_block() {
  Except_blockContext *_localctx = _tracker.createInstance<Except_blockContext>(_ctx, getState());
  enterRule(_localctx, 204, FandangoParser::RuleExcept_block);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1996);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1984);
      match(FandangoParser::EXCEPT);
      setState(1985);
      expression();
      setState(1988);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::AS) {
        setState(1986);
        match(FandangoParser::AS);
        setState(1987);
        identifier();
      }
      setState(1990);
      match(FandangoParser::COLON);
      setState(1991);
      block();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1993);
      match(FandangoParser::EXCEPT);
      setState(1994);
      match(FandangoParser::COLON);
      setState(1995);
      block();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Except_star_blockContext ------------------------------------------------------------------

FandangoParser::Except_star_blockContext::Except_star_blockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Except_star_blockContext::EXCEPT() {
  return getToken(FandangoParser::EXCEPT, 0);
}

tree::TerminalNode* FandangoParser::Except_star_blockContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Except_star_blockContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

tree::TerminalNode* FandangoParser::Except_star_blockContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Except_star_blockContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

tree::TerminalNode* FandangoParser::Except_star_blockContext::AS() {
  return getToken(FandangoParser::AS, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Except_star_blockContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}


size_t FandangoParser::Except_star_blockContext::getRuleIndex() const {
  return FandangoParser::RuleExcept_star_block;
}


std::any FandangoParser::Except_star_blockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitExcept_star_block(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Except_star_blockContext* FandangoParser::except_star_block() {
  Except_star_blockContext *_localctx = _tracker.createInstance<Except_star_blockContext>(_ctx, getState());
  enterRule(_localctx, 206, FandangoParser::RuleExcept_star_block);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1998);
    match(FandangoParser::EXCEPT);
    setState(1999);
    match(FandangoParser::STAR);
    setState(2000);
    expression();
    setState(2003);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::AS) {
      setState(2001);
      match(FandangoParser::AS);
      setState(2002);
      identifier();
    }
    setState(2005);
    match(FandangoParser::COLON);
    setState(2006);
    block();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Finally_blockContext ------------------------------------------------------------------

FandangoParser::Finally_blockContext::Finally_blockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Finally_blockContext::FINALLY() {
  return getToken(FandangoParser::FINALLY, 0);
}

tree::TerminalNode* FandangoParser::Finally_blockContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Finally_blockContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}


size_t FandangoParser::Finally_blockContext::getRuleIndex() const {
  return FandangoParser::RuleFinally_block;
}


std::any FandangoParser::Finally_blockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFinally_block(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Finally_blockContext* FandangoParser::finally_block() {
  Finally_blockContext *_localctx = _tracker.createInstance<Finally_blockContext>(_ctx, getState());
  enterRule(_localctx, 208, FandangoParser::RuleFinally_block);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2008);
    match(FandangoParser::FINALLY);
    setState(2009);
    match(FandangoParser::COLON);
    setState(2010);
    block();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Match_stmtContext ------------------------------------------------------------------

FandangoParser::Match_stmtContext::Match_stmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Match_stmtContext::MATCH() {
  return getToken(FandangoParser::MATCH, 0);
}

FandangoParser::Subject_exprContext* FandangoParser::Match_stmtContext::subject_expr() {
  return getRuleContext<FandangoParser::Subject_exprContext>(0);
}

tree::TerminalNode* FandangoParser::Match_stmtContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

tree::TerminalNode* FandangoParser::Match_stmtContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}

tree::TerminalNode* FandangoParser::Match_stmtContext::INDENT() {
  return getToken(FandangoParser::INDENT, 0);
}

tree::TerminalNode* FandangoParser::Match_stmtContext::DEDENT() {
  return getToken(FandangoParser::DEDENT, 0);
}

std::vector<FandangoParser::Case_blockContext *> FandangoParser::Match_stmtContext::case_block() {
  return getRuleContexts<FandangoParser::Case_blockContext>();
}

FandangoParser::Case_blockContext* FandangoParser::Match_stmtContext::case_block(size_t i) {
  return getRuleContext<FandangoParser::Case_blockContext>(i);
}


size_t FandangoParser::Match_stmtContext::getRuleIndex() const {
  return FandangoParser::RuleMatch_stmt;
}


std::any FandangoParser::Match_stmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitMatch_stmt(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Match_stmtContext* FandangoParser::match_stmt() {
  Match_stmtContext *_localctx = _tracker.createInstance<Match_stmtContext>(_ctx, getState());
  enterRule(_localctx, 210, FandangoParser::RuleMatch_stmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2012);
    match(FandangoParser::MATCH);
    setState(2013);
    subject_expr();
    setState(2014);
    match(FandangoParser::COLON);
    setState(2015);
    match(FandangoParser::NEWLINE);
    setState(2016);
    match(FandangoParser::INDENT);
    setState(2018); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(2017);
      case_block();
      setState(2020); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FandangoParser::CASE);
    setState(2022);
    match(FandangoParser::DEDENT);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Subject_exprContext ------------------------------------------------------------------

FandangoParser::Subject_exprContext::Subject_exprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Star_named_expressionContext* FandangoParser::Subject_exprContext::star_named_expression() {
  return getRuleContext<FandangoParser::Star_named_expressionContext>(0);
}

tree::TerminalNode* FandangoParser::Subject_exprContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}

FandangoParser::Star_named_expressionsContext* FandangoParser::Subject_exprContext::star_named_expressions() {
  return getRuleContext<FandangoParser::Star_named_expressionsContext>(0);
}

FandangoParser::Named_expressionContext* FandangoParser::Subject_exprContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}


size_t FandangoParser::Subject_exprContext::getRuleIndex() const {
  return FandangoParser::RuleSubject_expr;
}


std::any FandangoParser::Subject_exprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSubject_expr(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Subject_exprContext* FandangoParser::subject_expr() {
  Subject_exprContext *_localctx = _tracker.createInstance<Subject_exprContext>(_ctx, getState());
  enterRule(_localctx, 212, FandangoParser::RuleSubject_expr);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2030);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 229, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2024);
      star_named_expression();
      setState(2025);
      match(FandangoParser::COMMA);
      setState(2027);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 93071897) != 0)) {
        setState(2026);
        star_named_expressions();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2029);
      named_expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Case_blockContext ------------------------------------------------------------------

FandangoParser::Case_blockContext::Case_blockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Case_blockContext::CASE() {
  return getToken(FandangoParser::CASE, 0);
}

FandangoParser::PatternsContext* FandangoParser::Case_blockContext::patterns() {
  return getRuleContext<FandangoParser::PatternsContext>(0);
}

tree::TerminalNode* FandangoParser::Case_blockContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::BlockContext* FandangoParser::Case_blockContext::block() {
  return getRuleContext<FandangoParser::BlockContext>(0);
}

FandangoParser::GuardContext* FandangoParser::Case_blockContext::guard() {
  return getRuleContext<FandangoParser::GuardContext>(0);
}


size_t FandangoParser::Case_blockContext::getRuleIndex() const {
  return FandangoParser::RuleCase_block;
}


std::any FandangoParser::Case_blockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitCase_block(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Case_blockContext* FandangoParser::case_block() {
  Case_blockContext *_localctx = _tracker.createInstance<Case_blockContext>(_ctx, getState());
  enterRule(_localctx, 214, FandangoParser::RuleCase_block);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2032);
    match(FandangoParser::CASE);
    setState(2033);
    patterns();
    setState(2035);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::IF) {
      setState(2034);
      guard();
    }
    setState(2037);
    match(FandangoParser::COLON);
    setState(2038);
    block();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GuardContext ------------------------------------------------------------------

FandangoParser::GuardContext::GuardContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::GuardContext::IF() {
  return getToken(FandangoParser::IF, 0);
}

FandangoParser::Named_expressionContext* FandangoParser::GuardContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}


size_t FandangoParser::GuardContext::getRuleIndex() const {
  return FandangoParser::RuleGuard;
}


std::any FandangoParser::GuardContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGuard(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::GuardContext* FandangoParser::guard() {
  GuardContext *_localctx = _tracker.createInstance<GuardContext>(_ctx, getState());
  enterRule(_localctx, 216, FandangoParser::RuleGuard);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2040);
    match(FandangoParser::IF);
    setState(2041);
    named_expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PatternsContext ------------------------------------------------------------------

FandangoParser::PatternsContext::PatternsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Open_sequence_patternContext* FandangoParser::PatternsContext::open_sequence_pattern() {
  return getRuleContext<FandangoParser::Open_sequence_patternContext>(0);
}

FandangoParser::PatternContext* FandangoParser::PatternsContext::pattern() {
  return getRuleContext<FandangoParser::PatternContext>(0);
}


size_t FandangoParser::PatternsContext::getRuleIndex() const {
  return FandangoParser::RulePatterns;
}


std::any FandangoParser::PatternsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPatterns(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::PatternsContext* FandangoParser::patterns() {
  PatternsContext *_localctx = _tracker.createInstance<PatternsContext>(_ctx, getState());
  enterRule(_localctx, 218, FandangoParser::RulePatterns);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2045);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 231, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2043);
      open_sequence_pattern();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2044);
      pattern();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PatternContext ------------------------------------------------------------------

FandangoParser::PatternContext::PatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::As_patternContext* FandangoParser::PatternContext::as_pattern() {
  return getRuleContext<FandangoParser::As_patternContext>(0);
}

FandangoParser::Or_patternContext* FandangoParser::PatternContext::or_pattern() {
  return getRuleContext<FandangoParser::Or_patternContext>(0);
}


size_t FandangoParser::PatternContext::getRuleIndex() const {
  return FandangoParser::RulePattern;
}


std::any FandangoParser::PatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::PatternContext* FandangoParser::pattern() {
  PatternContext *_localctx = _tracker.createInstance<PatternContext>(_ctx, getState());
  enterRule(_localctx, 220, FandangoParser::RulePattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2049);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 232, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2047);
      as_pattern();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2048);
      or_pattern();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- As_patternContext ------------------------------------------------------------------

FandangoParser::As_patternContext::As_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Or_patternContext* FandangoParser::As_patternContext::or_pattern() {
  return getRuleContext<FandangoParser::Or_patternContext>(0);
}

tree::TerminalNode* FandangoParser::As_patternContext::AS() {
  return getToken(FandangoParser::AS, 0);
}

FandangoParser::Pattern_capture_targetContext* FandangoParser::As_patternContext::pattern_capture_target() {
  return getRuleContext<FandangoParser::Pattern_capture_targetContext>(0);
}


size_t FandangoParser::As_patternContext::getRuleIndex() const {
  return FandangoParser::RuleAs_pattern;
}


std::any FandangoParser::As_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAs_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::As_patternContext* FandangoParser::as_pattern() {
  As_patternContext *_localctx = _tracker.createInstance<As_patternContext>(_ctx, getState());
  enterRule(_localctx, 222, FandangoParser::RuleAs_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2051);
    or_pattern();
    setState(2052);
    match(FandangoParser::AS);
    setState(2053);
    pattern_capture_target();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Or_patternContext ------------------------------------------------------------------

FandangoParser::Or_patternContext::Or_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Closed_patternContext *> FandangoParser::Or_patternContext::closed_pattern() {
  return getRuleContexts<FandangoParser::Closed_patternContext>();
}

FandangoParser::Closed_patternContext* FandangoParser::Or_patternContext::closed_pattern(size_t i) {
  return getRuleContext<FandangoParser::Closed_patternContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Or_patternContext::OR_OP() {
  return getTokens(FandangoParser::OR_OP);
}

tree::TerminalNode* FandangoParser::Or_patternContext::OR_OP(size_t i) {
  return getToken(FandangoParser::OR_OP, i);
}


size_t FandangoParser::Or_patternContext::getRuleIndex() const {
  return FandangoParser::RuleOr_pattern;
}


std::any FandangoParser::Or_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitOr_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Or_patternContext* FandangoParser::or_pattern() {
  Or_patternContext *_localctx = _tracker.createInstance<Or_patternContext>(_ctx, getState());
  enterRule(_localctx, 224, FandangoParser::RuleOr_pattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2055);
    closed_pattern();
    setState(2060);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::OR_OP) {
      setState(2056);
      match(FandangoParser::OR_OP);
      setState(2057);
      closed_pattern();
      setState(2062);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Closed_patternContext ------------------------------------------------------------------

FandangoParser::Closed_patternContext::Closed_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Literal_patternContext* FandangoParser::Closed_patternContext::literal_pattern() {
  return getRuleContext<FandangoParser::Literal_patternContext>(0);
}

FandangoParser::Capture_patternContext* FandangoParser::Closed_patternContext::capture_pattern() {
  return getRuleContext<FandangoParser::Capture_patternContext>(0);
}

FandangoParser::Wildcard_patternContext* FandangoParser::Closed_patternContext::wildcard_pattern() {
  return getRuleContext<FandangoParser::Wildcard_patternContext>(0);
}

FandangoParser::Value_patternContext* FandangoParser::Closed_patternContext::value_pattern() {
  return getRuleContext<FandangoParser::Value_patternContext>(0);
}

FandangoParser::Group_patternContext* FandangoParser::Closed_patternContext::group_pattern() {
  return getRuleContext<FandangoParser::Group_patternContext>(0);
}

FandangoParser::Sequence_patternContext* FandangoParser::Closed_patternContext::sequence_pattern() {
  return getRuleContext<FandangoParser::Sequence_patternContext>(0);
}

FandangoParser::Mapping_patternContext* FandangoParser::Closed_patternContext::mapping_pattern() {
  return getRuleContext<FandangoParser::Mapping_patternContext>(0);
}

FandangoParser::Class_patternContext* FandangoParser::Closed_patternContext::class_pattern() {
  return getRuleContext<FandangoParser::Class_patternContext>(0);
}


size_t FandangoParser::Closed_patternContext::getRuleIndex() const {
  return FandangoParser::RuleClosed_pattern;
}


std::any FandangoParser::Closed_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitClosed_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Closed_patternContext* FandangoParser::closed_pattern() {
  Closed_patternContext *_localctx = _tracker.createInstance<Closed_patternContext>(_ctx, getState());
  enterRule(_localctx, 226, FandangoParser::RuleClosed_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2071);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2063);
      literal_pattern();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2064);
      capture_pattern();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2065);
      wildcard_pattern();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2066);
      value_pattern();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2067);
      group_pattern();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2068);
      sequence_pattern();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2069);
      mapping_pattern();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2070);
      class_pattern();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Literal_patternContext ------------------------------------------------------------------

FandangoParser::Literal_patternContext::Literal_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Signed_numberContext* FandangoParser::Literal_patternContext::signed_number() {
  return getRuleContext<FandangoParser::Signed_numberContext>(0);
}

FandangoParser::Complex_numberContext* FandangoParser::Literal_patternContext::complex_number() {
  return getRuleContext<FandangoParser::Complex_numberContext>(0);
}

FandangoParser::StringsContext* FandangoParser::Literal_patternContext::strings() {
  return getRuleContext<FandangoParser::StringsContext>(0);
}

tree::TerminalNode* FandangoParser::Literal_patternContext::NONE() {
  return getToken(FandangoParser::NONE, 0);
}

tree::TerminalNode* FandangoParser::Literal_patternContext::TRUE() {
  return getToken(FandangoParser::TRUE, 0);
}

tree::TerminalNode* FandangoParser::Literal_patternContext::FALSE() {
  return getToken(FandangoParser::FALSE, 0);
}


size_t FandangoParser::Literal_patternContext::getRuleIndex() const {
  return FandangoParser::RuleLiteral_pattern;
}


std::any FandangoParser::Literal_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLiteral_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Literal_patternContext* FandangoParser::literal_pattern() {
  Literal_patternContext *_localctx = _tracker.createInstance<Literal_patternContext>(_ctx, getState());
  enterRule(_localctx, 228, FandangoParser::RuleLiteral_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2079);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 235, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2073);
      signed_number();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2074);
      complex_number();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2075);
      strings();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2076);
      match(FandangoParser::NONE);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2077);
      match(FandangoParser::TRUE);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2078);
      match(FandangoParser::FALSE);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Literal_exprContext ------------------------------------------------------------------

FandangoParser::Literal_exprContext::Literal_exprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Signed_numberContext* FandangoParser::Literal_exprContext::signed_number() {
  return getRuleContext<FandangoParser::Signed_numberContext>(0);
}

FandangoParser::Complex_numberContext* FandangoParser::Literal_exprContext::complex_number() {
  return getRuleContext<FandangoParser::Complex_numberContext>(0);
}

FandangoParser::StringsContext* FandangoParser::Literal_exprContext::strings() {
  return getRuleContext<FandangoParser::StringsContext>(0);
}

tree::TerminalNode* FandangoParser::Literal_exprContext::NONE() {
  return getToken(FandangoParser::NONE, 0);
}

tree::TerminalNode* FandangoParser::Literal_exprContext::TRUE() {
  return getToken(FandangoParser::TRUE, 0);
}

tree::TerminalNode* FandangoParser::Literal_exprContext::FALSE() {
  return getToken(FandangoParser::FALSE, 0);
}


size_t FandangoParser::Literal_exprContext::getRuleIndex() const {
  return FandangoParser::RuleLiteral_expr;
}


std::any FandangoParser::Literal_exprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLiteral_expr(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Literal_exprContext* FandangoParser::literal_expr() {
  Literal_exprContext *_localctx = _tracker.createInstance<Literal_exprContext>(_ctx, getState());
  enterRule(_localctx, 230, FandangoParser::RuleLiteral_expr);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2087);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 236, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2081);
      signed_number();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2082);
      complex_number();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2083);
      strings();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2084);
      match(FandangoParser::NONE);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2085);
      match(FandangoParser::TRUE);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2086);
      match(FandangoParser::FALSE);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Complex_numberContext ------------------------------------------------------------------

FandangoParser::Complex_numberContext::Complex_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Signed_real_numberContext* FandangoParser::Complex_numberContext::signed_real_number() {
  return getRuleContext<FandangoParser::Signed_real_numberContext>(0);
}

tree::TerminalNode* FandangoParser::Complex_numberContext::ADD() {
  return getToken(FandangoParser::ADD, 0);
}

FandangoParser::Imaginary_numberContext* FandangoParser::Complex_numberContext::imaginary_number() {
  return getRuleContext<FandangoParser::Imaginary_numberContext>(0);
}

tree::TerminalNode* FandangoParser::Complex_numberContext::MINUS() {
  return getToken(FandangoParser::MINUS, 0);
}


size_t FandangoParser::Complex_numberContext::getRuleIndex() const {
  return FandangoParser::RuleComplex_number;
}


std::any FandangoParser::Complex_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitComplex_number(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Complex_numberContext* FandangoParser::complex_number() {
  Complex_numberContext *_localctx = _tracker.createInstance<Complex_numberContext>(_ctx, getState());
  enterRule(_localctx, 232, FandangoParser::RuleComplex_number);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2097);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 237, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2089);
      signed_real_number();
      setState(2090);
      match(FandangoParser::ADD);
      setState(2091);
      imaginary_number();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2093);
      signed_real_number();
      setState(2094);
      match(FandangoParser::MINUS);
      setState(2095);
      imaginary_number();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Signed_numberContext ------------------------------------------------------------------

FandangoParser::Signed_numberContext::Signed_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Signed_numberContext::NUMBER() {
  return getToken(FandangoParser::NUMBER, 0);
}

tree::TerminalNode* FandangoParser::Signed_numberContext::MINUS() {
  return getToken(FandangoParser::MINUS, 0);
}


size_t FandangoParser::Signed_numberContext::getRuleIndex() const {
  return FandangoParser::RuleSigned_number;
}


std::any FandangoParser::Signed_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSigned_number(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Signed_numberContext* FandangoParser::signed_number() {
  Signed_numberContext *_localctx = _tracker.createInstance<Signed_numberContext>(_ctx, getState());
  enterRule(_localctx, 234, FandangoParser::RuleSigned_number);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2102);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NUMBER: {
        enterOuterAlt(_localctx, 1);
        setState(2099);
        match(FandangoParser::NUMBER);
        break;
      }

      case FandangoParser::MINUS: {
        enterOuterAlt(_localctx, 2);
        setState(2100);
        match(FandangoParser::MINUS);
        setState(2101);
        match(FandangoParser::NUMBER);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Signed_real_numberContext ------------------------------------------------------------------

FandangoParser::Signed_real_numberContext::Signed_real_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Real_numberContext* FandangoParser::Signed_real_numberContext::real_number() {
  return getRuleContext<FandangoParser::Real_numberContext>(0);
}

tree::TerminalNode* FandangoParser::Signed_real_numberContext::MINUS() {
  return getToken(FandangoParser::MINUS, 0);
}


size_t FandangoParser::Signed_real_numberContext::getRuleIndex() const {
  return FandangoParser::RuleSigned_real_number;
}


std::any FandangoParser::Signed_real_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSigned_real_number(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Signed_real_numberContext* FandangoParser::signed_real_number() {
  Signed_real_numberContext *_localctx = _tracker.createInstance<Signed_real_numberContext>(_ctx, getState());
  enterRule(_localctx, 236, FandangoParser::RuleSigned_real_number);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2107);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NUMBER: {
        enterOuterAlt(_localctx, 1);
        setState(2104);
        real_number();
        break;
      }

      case FandangoParser::MINUS: {
        enterOuterAlt(_localctx, 2);
        setState(2105);
        match(FandangoParser::MINUS);
        setState(2106);
        real_number();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Real_numberContext ------------------------------------------------------------------

FandangoParser::Real_numberContext::Real_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Real_numberContext::NUMBER() {
  return getToken(FandangoParser::NUMBER, 0);
}


size_t FandangoParser::Real_numberContext::getRuleIndex() const {
  return FandangoParser::RuleReal_number;
}


std::any FandangoParser::Real_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitReal_number(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Real_numberContext* FandangoParser::real_number() {
  Real_numberContext *_localctx = _tracker.createInstance<Real_numberContext>(_ctx, getState());
  enterRule(_localctx, 238, FandangoParser::RuleReal_number);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2109);
    match(FandangoParser::NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Imaginary_numberContext ------------------------------------------------------------------

FandangoParser::Imaginary_numberContext::Imaginary_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Imaginary_numberContext::NUMBER() {
  return getToken(FandangoParser::NUMBER, 0);
}


size_t FandangoParser::Imaginary_numberContext::getRuleIndex() const {
  return FandangoParser::RuleImaginary_number;
}


std::any FandangoParser::Imaginary_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitImaginary_number(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Imaginary_numberContext* FandangoParser::imaginary_number() {
  Imaginary_numberContext *_localctx = _tracker.createInstance<Imaginary_numberContext>(_ctx, getState());
  enterRule(_localctx, 240, FandangoParser::RuleImaginary_number);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2111);
    match(FandangoParser::NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Capture_patternContext ------------------------------------------------------------------

FandangoParser::Capture_patternContext::Capture_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Pattern_capture_targetContext* FandangoParser::Capture_patternContext::pattern_capture_target() {
  return getRuleContext<FandangoParser::Pattern_capture_targetContext>(0);
}


size_t FandangoParser::Capture_patternContext::getRuleIndex() const {
  return FandangoParser::RuleCapture_pattern;
}


std::any FandangoParser::Capture_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitCapture_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Capture_patternContext* FandangoParser::capture_pattern() {
  Capture_patternContext *_localctx = _tracker.createInstance<Capture_patternContext>(_ctx, getState());
  enterRule(_localctx, 242, FandangoParser::RuleCapture_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2113);
    pattern_capture_target();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Pattern_capture_targetContext ------------------------------------------------------------------

FandangoParser::Pattern_capture_targetContext::Pattern_capture_targetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Pattern_capture_targetContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}


size_t FandangoParser::Pattern_capture_targetContext::getRuleIndex() const {
  return FandangoParser::RulePattern_capture_target;
}


std::any FandangoParser::Pattern_capture_targetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPattern_capture_target(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Pattern_capture_targetContext* FandangoParser::pattern_capture_target() {
  Pattern_capture_targetContext *_localctx = _tracker.createInstance<Pattern_capture_targetContext>(_ctx, getState());
  enterRule(_localctx, 244, FandangoParser::RulePattern_capture_target);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2115);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Wildcard_patternContext ------------------------------------------------------------------

FandangoParser::Wildcard_patternContext::Wildcard_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Wildcard_patternContext::UNDERSCORE() {
  return getToken(FandangoParser::UNDERSCORE, 0);
}


size_t FandangoParser::Wildcard_patternContext::getRuleIndex() const {
  return FandangoParser::RuleWildcard_pattern;
}


std::any FandangoParser::Wildcard_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitWildcard_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Wildcard_patternContext* FandangoParser::wildcard_pattern() {
  Wildcard_patternContext *_localctx = _tracker.createInstance<Wildcard_patternContext>(_ctx, getState());
  enterRule(_localctx, 246, FandangoParser::RuleWildcard_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2117);
    match(FandangoParser::UNDERSCORE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Value_patternContext ------------------------------------------------------------------

FandangoParser::Value_patternContext::Value_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::AttrContext* FandangoParser::Value_patternContext::attr() {
  return getRuleContext<FandangoParser::AttrContext>(0);
}


size_t FandangoParser::Value_patternContext::getRuleIndex() const {
  return FandangoParser::RuleValue_pattern;
}


std::any FandangoParser::Value_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitValue_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Value_patternContext* FandangoParser::value_pattern() {
  Value_patternContext *_localctx = _tracker.createInstance<Value_patternContext>(_ctx, getState());
  enterRule(_localctx, 248, FandangoParser::RuleValue_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2119);
    attr();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttrContext ------------------------------------------------------------------

FandangoParser::AttrContext::AttrContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Name_or_attrContext* FandangoParser::AttrContext::name_or_attr() {
  return getRuleContext<FandangoParser::Name_or_attrContext>(0);
}

tree::TerminalNode* FandangoParser::AttrContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

FandangoParser::IdentifierContext* FandangoParser::AttrContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}


size_t FandangoParser::AttrContext::getRuleIndex() const {
  return FandangoParser::RuleAttr;
}


std::any FandangoParser::AttrContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAttr(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::AttrContext* FandangoParser::attr() {
  AttrContext *_localctx = _tracker.createInstance<AttrContext>(_ctx, getState());
  enterRule(_localctx, 250, FandangoParser::RuleAttr);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2121);
    name_or_attr(0);
    setState(2122);
    match(FandangoParser::DOT);
    setState(2123);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Name_or_attrContext ------------------------------------------------------------------

FandangoParser::Name_or_attrContext::Name_or_attrContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Name_or_attrContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

FandangoParser::Name_or_attrContext* FandangoParser::Name_or_attrContext::name_or_attr() {
  return getRuleContext<FandangoParser::Name_or_attrContext>(0);
}

tree::TerminalNode* FandangoParser::Name_or_attrContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}


size_t FandangoParser::Name_or_attrContext::getRuleIndex() const {
  return FandangoParser::RuleName_or_attr;
}


std::any FandangoParser::Name_or_attrContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitName_or_attr(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Name_or_attrContext* FandangoParser::name_or_attr() {
   return name_or_attr(0);
}

FandangoParser::Name_or_attrContext* FandangoParser::name_or_attr(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Name_or_attrContext *_localctx = _tracker.createInstance<Name_or_attrContext>(_ctx, parentState);
  FandangoParser::Name_or_attrContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 252;
  enterRecursionRule(_localctx, 252, FandangoParser::RuleName_or_attr, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2126);
    identifier();
    _ctx->stop = _input->LT(-1);
    setState(2133);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 240, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<Name_or_attrContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleName_or_attr);
        setState(2128);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(2129);
        match(FandangoParser::DOT);
        setState(2130);
        identifier(); 
      }
      setState(2135);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 240, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- Group_patternContext ------------------------------------------------------------------

FandangoParser::Group_patternContext::Group_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Group_patternContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::PatternContext* FandangoParser::Group_patternContext::pattern() {
  return getRuleContext<FandangoParser::PatternContext>(0);
}

tree::TerminalNode* FandangoParser::Group_patternContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}


size_t FandangoParser::Group_patternContext::getRuleIndex() const {
  return FandangoParser::RuleGroup_pattern;
}


std::any FandangoParser::Group_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGroup_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Group_patternContext* FandangoParser::group_pattern() {
  Group_patternContext *_localctx = _tracker.createInstance<Group_patternContext>(_ctx, getState());
  enterRule(_localctx, 254, FandangoParser::RuleGroup_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2136);
    match(FandangoParser::OPEN_PAREN);
    setState(2137);
    pattern();
    setState(2138);
    match(FandangoParser::CLOSE_PAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Sequence_patternContext ------------------------------------------------------------------

FandangoParser::Sequence_patternContext::Sequence_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Sequence_patternContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

tree::TerminalNode* FandangoParser::Sequence_patternContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

FandangoParser::Maybe_sequence_patternContext* FandangoParser::Sequence_patternContext::maybe_sequence_pattern() {
  return getRuleContext<FandangoParser::Maybe_sequence_patternContext>(0);
}

tree::TerminalNode* FandangoParser::Sequence_patternContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Sequence_patternContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Open_sequence_patternContext* FandangoParser::Sequence_patternContext::open_sequence_pattern() {
  return getRuleContext<FandangoParser::Open_sequence_patternContext>(0);
}


size_t FandangoParser::Sequence_patternContext::getRuleIndex() const {
  return FandangoParser::RuleSequence_pattern;
}


std::any FandangoParser::Sequence_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSequence_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Sequence_patternContext* FandangoParser::sequence_pattern() {
  Sequence_patternContext *_localctx = _tracker.createInstance<Sequence_patternContext>(_ctx, getState());
  enterRule(_localctx, 256, FandangoParser::RuleSequence_pattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2150);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::OPEN_BRACK: {
        enterOuterAlt(_localctx, 1);
        setState(2140);
        match(FandangoParser::OPEN_BRACK);
        setState(2142);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 5116124636009988600) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 81)) & 1125899909005571) != 0)) {
          setState(2141);
          maybe_sequence_pattern();
        }
        setState(2144);
        match(FandangoParser::CLOSE_BRACK);
        break;
      }

      case FandangoParser::OPEN_PAREN: {
        enterOuterAlt(_localctx, 2);
        setState(2145);
        match(FandangoParser::OPEN_PAREN);
        setState(2147);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 5116124636009988600) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 81)) & 1125899909005571) != 0)) {
          setState(2146);
          open_sequence_pattern();
        }
        setState(2149);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Open_sequence_patternContext ------------------------------------------------------------------

FandangoParser::Open_sequence_patternContext::Open_sequence_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Maybe_star_patternContext* FandangoParser::Open_sequence_patternContext::maybe_star_pattern() {
  return getRuleContext<FandangoParser::Maybe_star_patternContext>(0);
}

tree::TerminalNode* FandangoParser::Open_sequence_patternContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}

FandangoParser::Maybe_sequence_patternContext* FandangoParser::Open_sequence_patternContext::maybe_sequence_pattern() {
  return getRuleContext<FandangoParser::Maybe_sequence_patternContext>(0);
}


size_t FandangoParser::Open_sequence_patternContext::getRuleIndex() const {
  return FandangoParser::RuleOpen_sequence_pattern;
}


std::any FandangoParser::Open_sequence_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitOpen_sequence_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Open_sequence_patternContext* FandangoParser::open_sequence_pattern() {
  Open_sequence_patternContext *_localctx = _tracker.createInstance<Open_sequence_patternContext>(_ctx, getState());
  enterRule(_localctx, 258, FandangoParser::RuleOpen_sequence_pattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2152);
    maybe_star_pattern();
    setState(2153);
    match(FandangoParser::COMMA);
    setState(2155);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116124636009988600) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 81)) & 1125899909005571) != 0)) {
      setState(2154);
      maybe_sequence_pattern();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Maybe_sequence_patternContext ------------------------------------------------------------------

FandangoParser::Maybe_sequence_patternContext::Maybe_sequence_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Maybe_star_patternContext *> FandangoParser::Maybe_sequence_patternContext::maybe_star_pattern() {
  return getRuleContexts<FandangoParser::Maybe_star_patternContext>();
}

FandangoParser::Maybe_star_patternContext* FandangoParser::Maybe_sequence_patternContext::maybe_star_pattern(size_t i) {
  return getRuleContext<FandangoParser::Maybe_star_patternContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Maybe_sequence_patternContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Maybe_sequence_patternContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Maybe_sequence_patternContext::getRuleIndex() const {
  return FandangoParser::RuleMaybe_sequence_pattern;
}


std::any FandangoParser::Maybe_sequence_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitMaybe_sequence_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Maybe_sequence_patternContext* FandangoParser::maybe_sequence_pattern() {
  Maybe_sequence_patternContext *_localctx = _tracker.createInstance<Maybe_sequence_patternContext>(_ctx, getState());
  enterRule(_localctx, 260, FandangoParser::RuleMaybe_sequence_pattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2157);
    maybe_star_pattern();
    setState(2162);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2158);
        match(FandangoParser::COMMA);
        setState(2159);
        maybe_star_pattern(); 
      }
      setState(2164);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx);
    }
    setState(2166);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2165);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Maybe_star_patternContext ------------------------------------------------------------------

FandangoParser::Maybe_star_patternContext::Maybe_star_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Star_patternContext* FandangoParser::Maybe_star_patternContext::star_pattern() {
  return getRuleContext<FandangoParser::Star_patternContext>(0);
}

FandangoParser::PatternContext* FandangoParser::Maybe_star_patternContext::pattern() {
  return getRuleContext<FandangoParser::PatternContext>(0);
}


size_t FandangoParser::Maybe_star_patternContext::getRuleIndex() const {
  return FandangoParser::RuleMaybe_star_pattern;
}


std::any FandangoParser::Maybe_star_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitMaybe_star_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Maybe_star_patternContext* FandangoParser::maybe_star_pattern() {
  Maybe_star_patternContext *_localctx = _tracker.createInstance<Maybe_star_patternContext>(_ctx, getState());
  enterRule(_localctx, 262, FandangoParser::RuleMaybe_star_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2170);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::STAR: {
        enterOuterAlt(_localctx, 1);
        setState(2168);
        star_pattern();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::FALSE:
      case FandangoParser::NONE:
      case FandangoParser::TRUE:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::MINUS:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::UNDERSCORE: {
        enterOuterAlt(_localctx, 2);
        setState(2169);
        pattern();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_patternContext ------------------------------------------------------------------

FandangoParser::Star_patternContext::Star_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Star_patternContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::Pattern_capture_targetContext* FandangoParser::Star_patternContext::pattern_capture_target() {
  return getRuleContext<FandangoParser::Pattern_capture_targetContext>(0);
}

FandangoParser::Wildcard_patternContext* FandangoParser::Star_patternContext::wildcard_pattern() {
  return getRuleContext<FandangoParser::Wildcard_patternContext>(0);
}


size_t FandangoParser::Star_patternContext::getRuleIndex() const {
  return FandangoParser::RuleStar_pattern;
}


std::any FandangoParser::Star_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_patternContext* FandangoParser::star_pattern() {
  Star_patternContext *_localctx = _tracker.createInstance<Star_patternContext>(_ctx, getState());
  enterRule(_localctx, 264, FandangoParser::RuleStar_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2176);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 248, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2172);
      match(FandangoParser::STAR);
      setState(2173);
      pattern_capture_target();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2174);
      match(FandangoParser::STAR);
      setState(2175);
      wildcard_pattern();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Mapping_patternContext ------------------------------------------------------------------

FandangoParser::Mapping_patternContext::Mapping_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Mapping_patternContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

tree::TerminalNode* FandangoParser::Mapping_patternContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}

FandangoParser::Double_star_patternContext* FandangoParser::Mapping_patternContext::double_star_pattern() {
  return getRuleContext<FandangoParser::Double_star_patternContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Mapping_patternContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Mapping_patternContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}

FandangoParser::Items_patternContext* FandangoParser::Mapping_patternContext::items_pattern() {
  return getRuleContext<FandangoParser::Items_patternContext>(0);
}


size_t FandangoParser::Mapping_patternContext::getRuleIndex() const {
  return FandangoParser::RuleMapping_pattern;
}


std::any FandangoParser::Mapping_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitMapping_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Mapping_patternContext* FandangoParser::mapping_pattern() {
  Mapping_patternContext *_localctx = _tracker.createInstance<Mapping_patternContext>(_ctx, getState());
  enterRule(_localctx, 266, FandangoParser::RuleMapping_pattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2203);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2178);
      match(FandangoParser::OPEN_BRACE);
      setState(2179);
      match(FandangoParser::CLOSE_BRACE);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2180);
      match(FandangoParser::OPEN_BRACE);
      setState(2181);
      double_star_pattern();
      setState(2183);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(2182);
        match(FandangoParser::COMMA);
      }
      setState(2185);
      match(FandangoParser::CLOSE_BRACE);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2187);
      match(FandangoParser::OPEN_BRACE);
      setState(2188);
      items_pattern();
      setState(2189);
      match(FandangoParser::COMMA);
      setState(2190);
      double_star_pattern();
      setState(2192);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(2191);
        match(FandangoParser::COMMA);
      }
      setState(2194);
      match(FandangoParser::CLOSE_BRACE);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2196);
      match(FandangoParser::OPEN_BRACE);
      setState(2197);
      items_pattern();
      setState(2199);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(2198);
        match(FandangoParser::COMMA);
      }
      setState(2201);
      match(FandangoParser::CLOSE_BRACE);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Items_patternContext ------------------------------------------------------------------

FandangoParser::Items_patternContext::Items_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Key_value_patternContext *> FandangoParser::Items_patternContext::key_value_pattern() {
  return getRuleContexts<FandangoParser::Key_value_patternContext>();
}

FandangoParser::Key_value_patternContext* FandangoParser::Items_patternContext::key_value_pattern(size_t i) {
  return getRuleContext<FandangoParser::Key_value_patternContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Items_patternContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Items_patternContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Items_patternContext::getRuleIndex() const {
  return FandangoParser::RuleItems_pattern;
}


std::any FandangoParser::Items_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitItems_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Items_patternContext* FandangoParser::items_pattern() {
  Items_patternContext *_localctx = _tracker.createInstance<Items_patternContext>(_ctx, getState());
  enterRule(_localctx, 268, FandangoParser::RuleItems_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2205);
    key_value_pattern();
    setState(2210);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 253, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2206);
        match(FandangoParser::COMMA);
        setState(2207);
        key_value_pattern(); 
      }
      setState(2212);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 253, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Key_value_patternContext ------------------------------------------------------------------

FandangoParser::Key_value_patternContext::Key_value_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Key_value_patternContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::PatternContext* FandangoParser::Key_value_patternContext::pattern() {
  return getRuleContext<FandangoParser::PatternContext>(0);
}

FandangoParser::Literal_exprContext* FandangoParser::Key_value_patternContext::literal_expr() {
  return getRuleContext<FandangoParser::Literal_exprContext>(0);
}

FandangoParser::AttrContext* FandangoParser::Key_value_patternContext::attr() {
  return getRuleContext<FandangoParser::AttrContext>(0);
}


size_t FandangoParser::Key_value_patternContext::getRuleIndex() const {
  return FandangoParser::RuleKey_value_pattern;
}


std::any FandangoParser::Key_value_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKey_value_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Key_value_patternContext* FandangoParser::key_value_pattern() {
  Key_value_patternContext *_localctx = _tracker.createInstance<Key_value_patternContext>(_ctx, getState());
  enterRule(_localctx, 270, FandangoParser::RuleKey_value_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2215);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::FALSE:
      case FandangoParser::NONE:
      case FandangoParser::TRUE:
      case FandangoParser::MINUS: {
        setState(2213);
        literal_expr();
        break;
      }

      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME: {
        setState(2214);
        attr();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2217);
    match(FandangoParser::COLON);
    setState(2218);
    pattern();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Double_star_patternContext ------------------------------------------------------------------

FandangoParser::Double_star_patternContext::Double_star_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Double_star_patternContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}

FandangoParser::Pattern_capture_targetContext* FandangoParser::Double_star_patternContext::pattern_capture_target() {
  return getRuleContext<FandangoParser::Pattern_capture_targetContext>(0);
}


size_t FandangoParser::Double_star_patternContext::getRuleIndex() const {
  return FandangoParser::RuleDouble_star_pattern;
}


std::any FandangoParser::Double_star_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDouble_star_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Double_star_patternContext* FandangoParser::double_star_pattern() {
  Double_star_patternContext *_localctx = _tracker.createInstance<Double_star_patternContext>(_ctx, getState());
  enterRule(_localctx, 272, FandangoParser::RuleDouble_star_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2220);
    match(FandangoParser::POWER);
    setState(2221);
    pattern_capture_target();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Class_patternContext ------------------------------------------------------------------

FandangoParser::Class_patternContext::Class_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Name_or_attrContext* FandangoParser::Class_patternContext::name_or_attr() {
  return getRuleContext<FandangoParser::Name_or_attrContext>(0);
}

tree::TerminalNode* FandangoParser::Class_patternContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Class_patternContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Positional_patternsContext* FandangoParser::Class_patternContext::positional_patterns() {
  return getRuleContext<FandangoParser::Positional_patternsContext>(0);
}

std::vector<tree::TerminalNode *> FandangoParser::Class_patternContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Class_patternContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}

FandangoParser::Keyword_patternsContext* FandangoParser::Class_patternContext::keyword_patterns() {
  return getRuleContext<FandangoParser::Keyword_patternsContext>(0);
}


size_t FandangoParser::Class_patternContext::getRuleIndex() const {
  return FandangoParser::RuleClass_pattern;
}


std::any FandangoParser::Class_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitClass_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Class_patternContext* FandangoParser::class_pattern() {
  Class_patternContext *_localctx = _tracker.createInstance<Class_patternContext>(_ctx, getState());
  enterRule(_localctx, 274, FandangoParser::RuleClass_pattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2253);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 258, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2223);
      name_or_attr(0);
      setState(2224);
      match(FandangoParser::OPEN_PAREN);
      setState(2225);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2227);
      name_or_attr(0);
      setState(2228);
      match(FandangoParser::OPEN_PAREN);
      setState(2229);
      positional_patterns();
      setState(2231);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(2230);
        match(FandangoParser::COMMA);
      }
      setState(2233);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2235);
      name_or_attr(0);
      setState(2236);
      match(FandangoParser::OPEN_PAREN);
      setState(2237);
      keyword_patterns();
      setState(2239);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(2238);
        match(FandangoParser::COMMA);
      }
      setState(2241);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2243);
      name_or_attr(0);
      setState(2244);
      match(FandangoParser::OPEN_PAREN);
      setState(2245);
      positional_patterns();
      setState(2246);
      match(FandangoParser::COMMA);
      setState(2247);
      keyword_patterns();
      setState(2249);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(2248);
        match(FandangoParser::COMMA);
      }
      setState(2251);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Positional_patternsContext ------------------------------------------------------------------

FandangoParser::Positional_patternsContext::Positional_patternsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::PatternContext *> FandangoParser::Positional_patternsContext::pattern() {
  return getRuleContexts<FandangoParser::PatternContext>();
}

FandangoParser::PatternContext* FandangoParser::Positional_patternsContext::pattern(size_t i) {
  return getRuleContext<FandangoParser::PatternContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Positional_patternsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Positional_patternsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Positional_patternsContext::getRuleIndex() const {
  return FandangoParser::RulePositional_patterns;
}


std::any FandangoParser::Positional_patternsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPositional_patterns(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Positional_patternsContext* FandangoParser::positional_patterns() {
  Positional_patternsContext *_localctx = _tracker.createInstance<Positional_patternsContext>(_ctx, getState());
  enterRule(_localctx, 276, FandangoParser::RulePositional_patterns);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2255);
    pattern();
    setState(2260);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 259, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2256);
        match(FandangoParser::COMMA);
        setState(2257);
        pattern(); 
      }
      setState(2262);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 259, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Keyword_patternsContext ------------------------------------------------------------------

FandangoParser::Keyword_patternsContext::Keyword_patternsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Keyword_patternContext *> FandangoParser::Keyword_patternsContext::keyword_pattern() {
  return getRuleContexts<FandangoParser::Keyword_patternContext>();
}

FandangoParser::Keyword_patternContext* FandangoParser::Keyword_patternsContext::keyword_pattern(size_t i) {
  return getRuleContext<FandangoParser::Keyword_patternContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Keyword_patternsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Keyword_patternsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Keyword_patternsContext::getRuleIndex() const {
  return FandangoParser::RuleKeyword_patterns;
}


std::any FandangoParser::Keyword_patternsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKeyword_patterns(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Keyword_patternsContext* FandangoParser::keyword_patterns() {
  Keyword_patternsContext *_localctx = _tracker.createInstance<Keyword_patternsContext>(_ctx, getState());
  enterRule(_localctx, 278, FandangoParser::RuleKeyword_patterns);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2263);
    keyword_pattern();
    setState(2268);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 260, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2264);
        match(FandangoParser::COMMA);
        setState(2265);
        keyword_pattern(); 
      }
      setState(2270);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 260, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Keyword_patternContext ------------------------------------------------------------------

FandangoParser::Keyword_patternContext::Keyword_patternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Keyword_patternContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Keyword_patternContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}

FandangoParser::PatternContext* FandangoParser::Keyword_patternContext::pattern() {
  return getRuleContext<FandangoParser::PatternContext>(0);
}


size_t FandangoParser::Keyword_patternContext::getRuleIndex() const {
  return FandangoParser::RuleKeyword_pattern;
}


std::any FandangoParser::Keyword_patternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKeyword_pattern(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Keyword_patternContext* FandangoParser::keyword_pattern() {
  Keyword_patternContext *_localctx = _tracker.createInstance<Keyword_patternContext>(_ctx, getState());
  enterRule(_localctx, 280, FandangoParser::RuleKeyword_pattern);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2271);
    identifier();
    setState(2272);
    match(FandangoParser::ASSIGN);
    setState(2273);
    pattern();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Type_aliasContext ------------------------------------------------------------------

FandangoParser::Type_aliasContext::Type_aliasContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Type_aliasContext::TYPE() {
  return getToken(FandangoParser::TYPE, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Type_aliasContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Type_aliasContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Type_aliasContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

FandangoParser::Type_paramsContext* FandangoParser::Type_aliasContext::type_params() {
  return getRuleContext<FandangoParser::Type_paramsContext>(0);
}


size_t FandangoParser::Type_aliasContext::getRuleIndex() const {
  return FandangoParser::RuleType_alias;
}


std::any FandangoParser::Type_aliasContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitType_alias(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Type_aliasContext* FandangoParser::type_alias() {
  Type_aliasContext *_localctx = _tracker.createInstance<Type_aliasContext>(_ctx, getState());
  enterRule(_localctx, 282, FandangoParser::RuleType_alias);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2275);
    match(FandangoParser::TYPE);
    setState(2276);
    identifier();
    setState(2278);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::OPEN_BRACK) {
      setState(2277);
      type_params();
    }
    setState(2280);
    match(FandangoParser::ASSIGN);
    setState(2281);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Type_paramsContext ------------------------------------------------------------------

FandangoParser::Type_paramsContext::Type_paramsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Type_paramsContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::Type_param_seqContext* FandangoParser::Type_paramsContext::type_param_seq() {
  return getRuleContext<FandangoParser::Type_param_seqContext>(0);
}

tree::TerminalNode* FandangoParser::Type_paramsContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}


size_t FandangoParser::Type_paramsContext::getRuleIndex() const {
  return FandangoParser::RuleType_params;
}


std::any FandangoParser::Type_paramsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitType_params(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Type_paramsContext* FandangoParser::type_params() {
  Type_paramsContext *_localctx = _tracker.createInstance<Type_paramsContext>(_ctx, getState());
  enterRule(_localctx, 284, FandangoParser::RuleType_params);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2283);
    match(FandangoParser::OPEN_BRACK);
    setState(2284);
    type_param_seq();
    setState(2285);
    match(FandangoParser::CLOSE_BRACK);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Type_param_seqContext ------------------------------------------------------------------

FandangoParser::Type_param_seqContext::Type_param_seqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Type_paramContext *> FandangoParser::Type_param_seqContext::type_param() {
  return getRuleContexts<FandangoParser::Type_paramContext>();
}

FandangoParser::Type_paramContext* FandangoParser::Type_param_seqContext::type_param(size_t i) {
  return getRuleContext<FandangoParser::Type_paramContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Type_param_seqContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Type_param_seqContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Type_param_seqContext::getRuleIndex() const {
  return FandangoParser::RuleType_param_seq;
}


std::any FandangoParser::Type_param_seqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitType_param_seq(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Type_param_seqContext* FandangoParser::type_param_seq() {
  Type_param_seqContext *_localctx = _tracker.createInstance<Type_param_seqContext>(_ctx, getState());
  enterRule(_localctx, 286, FandangoParser::RuleType_param_seq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2287);
    type_param();
    setState(2292);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 262, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2288);
        match(FandangoParser::COMMA);
        setState(2289);
        type_param(); 
      }
      setState(2294);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 262, _ctx);
    }
    setState(2296);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2295);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Type_paramContext ------------------------------------------------------------------

FandangoParser::Type_paramContext::Type_paramContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Type_paramContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

FandangoParser::Type_param_boundContext* FandangoParser::Type_paramContext::type_param_bound() {
  return getRuleContext<FandangoParser::Type_param_boundContext>(0);
}

tree::TerminalNode* FandangoParser::Type_paramContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

tree::TerminalNode* FandangoParser::Type_paramContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}


size_t FandangoParser::Type_paramContext::getRuleIndex() const {
  return FandangoParser::RuleType_param;
}


std::any FandangoParser::Type_paramContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitType_param(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Type_paramContext* FandangoParser::type_param() {
  Type_paramContext *_localctx = _tracker.createInstance<Type_paramContext>(_ctx, getState());
  enterRule(_localctx, 288, FandangoParser::RuleType_param);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2306);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME: {
        enterOuterAlt(_localctx, 1);
        setState(2298);
        identifier();
        setState(2300);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FandangoParser::COLON) {
          setState(2299);
          type_param_bound();
        }
        break;
      }

      case FandangoParser::STAR: {
        enterOuterAlt(_localctx, 2);
        setState(2302);
        match(FandangoParser::STAR);
        setState(2303);
        identifier();
        break;
      }

      case FandangoParser::POWER: {
        enterOuterAlt(_localctx, 3);
        setState(2304);
        match(FandangoParser::POWER);
        setState(2305);
        identifier();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Type_param_boundContext ------------------------------------------------------------------

FandangoParser::Type_param_boundContext::Type_param_boundContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Type_param_boundContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Type_param_boundContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::Type_param_boundContext::getRuleIndex() const {
  return FandangoParser::RuleType_param_bound;
}


std::any FandangoParser::Type_param_boundContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitType_param_bound(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Type_param_boundContext* FandangoParser::type_param_bound() {
  Type_param_boundContext *_localctx = _tracker.createInstance<Type_param_boundContext>(_ctx, getState());
  enterRule(_localctx, 290, FandangoParser::RuleType_param_bound);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2308);
    match(FandangoParser::COLON);
    setState(2309);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionsContext ------------------------------------------------------------------

FandangoParser::ExpressionsContext::ExpressionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::ExpressionContext *> FandangoParser::ExpressionsContext::expression() {
  return getRuleContexts<FandangoParser::ExpressionContext>();
}

FandangoParser::ExpressionContext* FandangoParser::ExpressionsContext::expression(size_t i) {
  return getRuleContext<FandangoParser::ExpressionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::ExpressionsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::ExpressionsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::ExpressionsContext::getRuleIndex() const {
  return FandangoParser::RuleExpressions;
}


std::any FandangoParser::ExpressionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitExpressions(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ExpressionsContext* FandangoParser::expressions() {
  ExpressionsContext *_localctx = _tracker.createInstance<ExpressionsContext>(_ctx, getState());
  enterRule(_localctx, 292, FandangoParser::RuleExpressions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2311);
    expression();
    setState(2316);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 266, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2312);
        match(FandangoParser::COMMA);
        setState(2313);
        expression(); 
      }
      setState(2318);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 266, _ctx);
    }
    setState(2320);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2319);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionContext ------------------------------------------------------------------

FandangoParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::DisjunctionContext *> FandangoParser::ExpressionContext::disjunction() {
  return getRuleContexts<FandangoParser::DisjunctionContext>();
}

FandangoParser::DisjunctionContext* FandangoParser::ExpressionContext::disjunction(size_t i) {
  return getRuleContext<FandangoParser::DisjunctionContext>(i);
}

tree::TerminalNode* FandangoParser::ExpressionContext::IF() {
  return getToken(FandangoParser::IF, 0);
}

tree::TerminalNode* FandangoParser::ExpressionContext::ELSE() {
  return getToken(FandangoParser::ELSE, 0);
}

FandangoParser::ExpressionContext* FandangoParser::ExpressionContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

FandangoParser::LambdefContext* FandangoParser::ExpressionContext::lambdef() {
  return getRuleContext<FandangoParser::LambdefContext>(0);
}


size_t FandangoParser::ExpressionContext::getRuleIndex() const {
  return FandangoParser::RuleExpression;
}


std::any FandangoParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitExpression(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ExpressionContext* FandangoParser::expression() {
  ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
  enterRule(_localctx, 294, FandangoParser::RuleExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2330);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 268, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2322);
      disjunction();
      setState(2323);
      match(FandangoParser::IF);
      setState(2324);
      disjunction();
      setState(2325);
      match(FandangoParser::ELSE);
      setState(2326);
      expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2328);
      disjunction();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2329);
      lambdef();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Yield_exprContext ------------------------------------------------------------------

FandangoParser::Yield_exprContext::Yield_exprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Yield_exprContext::YIELD() {
  return getToken(FandangoParser::YIELD, 0);
}

tree::TerminalNode* FandangoParser::Yield_exprContext::FROM() {
  return getToken(FandangoParser::FROM, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Yield_exprContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

FandangoParser::Star_expressionsContext* FandangoParser::Yield_exprContext::star_expressions() {
  return getRuleContext<FandangoParser::Star_expressionsContext>(0);
}


size_t FandangoParser::Yield_exprContext::getRuleIndex() const {
  return FandangoParser::RuleYield_expr;
}


std::any FandangoParser::Yield_exprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitYield_expr(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Yield_exprContext* FandangoParser::yield_expr() {
  Yield_exprContext *_localctx = _tracker.createInstance<Yield_exprContext>(_ctx, getState());
  enterRule(_localctx, 296, FandangoParser::RuleYield_expr);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2339);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 270, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2332);
      match(FandangoParser::YIELD);
      setState(2333);
      match(FandangoParser::FROM);
      setState(2334);
      expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2335);
      match(FandangoParser::YIELD);
      setState(2337);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 269, _ctx)) {
      case 1: {
        setState(2336);
        star_expressions();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_expressionsContext ------------------------------------------------------------------

FandangoParser::Star_expressionsContext::Star_expressionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Star_expressionContext *> FandangoParser::Star_expressionsContext::star_expression() {
  return getRuleContexts<FandangoParser::Star_expressionContext>();
}

FandangoParser::Star_expressionContext* FandangoParser::Star_expressionsContext::star_expression(size_t i) {
  return getRuleContext<FandangoParser::Star_expressionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Star_expressionsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Star_expressionsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Star_expressionsContext::getRuleIndex() const {
  return FandangoParser::RuleStar_expressions;
}


std::any FandangoParser::Star_expressionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_expressions(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_expressionsContext* FandangoParser::star_expressions() {
  Star_expressionsContext *_localctx = _tracker.createInstance<Star_expressionsContext>(_ctx, getState());
  enterRule(_localctx, 298, FandangoParser::RuleStar_expressions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2341);
    star_expression();
    setState(2346);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 271, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2342);
        match(FandangoParser::COMMA);
        setState(2343);
        star_expression(); 
      }
      setState(2348);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 271, _ctx);
    }
    setState(2350);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2349);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_expressionContext ------------------------------------------------------------------

FandangoParser::Star_expressionContext::Star_expressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Star_selectionContext* FandangoParser::Star_expressionContext::star_selection() {
  return getRuleContext<FandangoParser::Star_selectionContext>(0);
}

tree::TerminalNode* FandangoParser::Star_expressionContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Star_expressionContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}

FandangoParser::ExpressionContext* FandangoParser::Star_expressionContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::Star_expressionContext::getRuleIndex() const {
  return FandangoParser::RuleStar_expression;
}


std::any FandangoParser::Star_expressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_expression(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_expressionContext* FandangoParser::star_expression() {
  Star_expressionContext *_localctx = _tracker.createInstance<Star_expressionContext>(_ctx, getState());
  enterRule(_localctx, 300, FandangoParser::RuleStar_expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2356);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 273, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2352);
      star_selection();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2353);
      match(FandangoParser::STAR);
      setState(2354);
      bitwise_or(0);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2355);
      expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_named_expressionsContext ------------------------------------------------------------------

FandangoParser::Star_named_expressionsContext::Star_named_expressionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Star_named_expressionContext *> FandangoParser::Star_named_expressionsContext::star_named_expression() {
  return getRuleContexts<FandangoParser::Star_named_expressionContext>();
}

FandangoParser::Star_named_expressionContext* FandangoParser::Star_named_expressionsContext::star_named_expression(size_t i) {
  return getRuleContext<FandangoParser::Star_named_expressionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Star_named_expressionsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Star_named_expressionsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Star_named_expressionsContext::getRuleIndex() const {
  return FandangoParser::RuleStar_named_expressions;
}


std::any FandangoParser::Star_named_expressionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_named_expressions(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_named_expressionsContext* FandangoParser::star_named_expressions() {
  Star_named_expressionsContext *_localctx = _tracker.createInstance<Star_named_expressionsContext>(_ctx, getState());
  enterRule(_localctx, 302, FandangoParser::RuleStar_named_expressions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2358);
    star_named_expression();
    setState(2363);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 274, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2359);
        match(FandangoParser::COMMA);
        setState(2360);
        star_named_expression(); 
      }
      setState(2365);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 274, _ctx);
    }
    setState(2367);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2366);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_named_expressionContext ------------------------------------------------------------------

FandangoParser::Star_named_expressionContext::Star_named_expressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Star_named_expressionContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Star_named_expressionContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}

FandangoParser::Named_expressionContext* FandangoParser::Star_named_expressionContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}


size_t FandangoParser::Star_named_expressionContext::getRuleIndex() const {
  return FandangoParser::RuleStar_named_expression;
}


std::any FandangoParser::Star_named_expressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_named_expression(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_named_expressionContext* FandangoParser::star_named_expression() {
  Star_named_expressionContext *_localctx = _tracker.createInstance<Star_named_expressionContext>(_ctx, getState());
  enterRule(_localctx, 304, FandangoParser::RuleStar_named_expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2372);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 276, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2369);
      match(FandangoParser::STAR);
      setState(2370);
      bitwise_or(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2371);
      named_expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Assignment_expressionContext ------------------------------------------------------------------

FandangoParser::Assignment_expressionContext::Assignment_expressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Assignment_expressionContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Assignment_expressionContext::EXPR_ASSIGN() {
  return getToken(FandangoParser::EXPR_ASSIGN, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Assignment_expressionContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::Assignment_expressionContext::getRuleIndex() const {
  return FandangoParser::RuleAssignment_expression;
}


std::any FandangoParser::Assignment_expressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAssignment_expression(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Assignment_expressionContext* FandangoParser::assignment_expression() {
  Assignment_expressionContext *_localctx = _tracker.createInstance<Assignment_expressionContext>(_ctx, getState());
  enterRule(_localctx, 306, FandangoParser::RuleAssignment_expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2374);
    identifier();
    setState(2375);
    match(FandangoParser::EXPR_ASSIGN);
    setState(2376);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Named_expressionContext ------------------------------------------------------------------

FandangoParser::Named_expressionContext::Named_expressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Assignment_expressionContext* FandangoParser::Named_expressionContext::assignment_expression() {
  return getRuleContext<FandangoParser::Assignment_expressionContext>(0);
}

FandangoParser::ExpressionContext* FandangoParser::Named_expressionContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::Named_expressionContext::getRuleIndex() const {
  return FandangoParser::RuleNamed_expression;
}


std::any FandangoParser::Named_expressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitNamed_expression(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Named_expressionContext* FandangoParser::named_expression() {
  Named_expressionContext *_localctx = _tracker.createInstance<Named_expressionContext>(_ctx, getState());
  enterRule(_localctx, 308, FandangoParser::RuleNamed_expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2380);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 277, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2378);
      assignment_expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2379);
      expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DisjunctionContext ------------------------------------------------------------------

FandangoParser::DisjunctionContext::DisjunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::ConjunctionContext *> FandangoParser::DisjunctionContext::conjunction() {
  return getRuleContexts<FandangoParser::ConjunctionContext>();
}

FandangoParser::ConjunctionContext* FandangoParser::DisjunctionContext::conjunction(size_t i) {
  return getRuleContext<FandangoParser::ConjunctionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::DisjunctionContext::OR() {
  return getTokens(FandangoParser::OR);
}

tree::TerminalNode* FandangoParser::DisjunctionContext::OR(size_t i) {
  return getToken(FandangoParser::OR, i);
}


size_t FandangoParser::DisjunctionContext::getRuleIndex() const {
  return FandangoParser::RuleDisjunction;
}


std::any FandangoParser::DisjunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDisjunction(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::DisjunctionContext* FandangoParser::disjunction() {
  DisjunctionContext *_localctx = _tracker.createInstance<DisjunctionContext>(_ctx, getState());
  enterRule(_localctx, 310, FandangoParser::RuleDisjunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2382);
    conjunction();
    setState(2387);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::OR) {
      setState(2383);
      match(FandangoParser::OR);
      setState(2384);
      conjunction();
      setState(2389);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConjunctionContext ------------------------------------------------------------------

FandangoParser::ConjunctionContext::ConjunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::InversionContext *> FandangoParser::ConjunctionContext::inversion() {
  return getRuleContexts<FandangoParser::InversionContext>();
}

FandangoParser::InversionContext* FandangoParser::ConjunctionContext::inversion(size_t i) {
  return getRuleContext<FandangoParser::InversionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::ConjunctionContext::AND() {
  return getTokens(FandangoParser::AND);
}

tree::TerminalNode* FandangoParser::ConjunctionContext::AND(size_t i) {
  return getToken(FandangoParser::AND, i);
}


size_t FandangoParser::ConjunctionContext::getRuleIndex() const {
  return FandangoParser::RuleConjunction;
}


std::any FandangoParser::ConjunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitConjunction(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ConjunctionContext* FandangoParser::conjunction() {
  ConjunctionContext *_localctx = _tracker.createInstance<ConjunctionContext>(_ctx, getState());
  enterRule(_localctx, 312, FandangoParser::RuleConjunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2390);
    inversion();
    setState(2395);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::AND) {
      setState(2391);
      match(FandangoParser::AND);
      setState(2392);
      inversion();
      setState(2397);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InversionContext ------------------------------------------------------------------

FandangoParser::InversionContext::InversionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::InversionContext::NOT() {
  return getToken(FandangoParser::NOT, 0);
}

FandangoParser::InversionContext* FandangoParser::InversionContext::inversion() {
  return getRuleContext<FandangoParser::InversionContext>(0);
}

FandangoParser::ComparisonContext* FandangoParser::InversionContext::comparison() {
  return getRuleContext<FandangoParser::ComparisonContext>(0);
}


size_t FandangoParser::InversionContext::getRuleIndex() const {
  return FandangoParser::RuleInversion;
}


std::any FandangoParser::InversionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitInversion(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::InversionContext* FandangoParser::inversion() {
  InversionContext *_localctx = _tracker.createInstance<InversionContext>(_ctx, getState());
  enterRule(_localctx, 314, FandangoParser::RuleInversion);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2401);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NOT: {
        enterOuterAlt(_localctx, 1);
        setState(2398);
        match(FandangoParser::NOT);
        setState(2399);
        inversion();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::AWAIT:
      case FandangoParser::FALSE:
      case FandangoParser::NONE:
      case FandangoParser::TRUE:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(2400);
        comparison();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ComparisonContext ------------------------------------------------------------------

FandangoParser::ComparisonContext::ComparisonContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Bitwise_orContext* FandangoParser::ComparisonContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}

std::vector<FandangoParser::Compare_op_bitwise_or_pairContext *> FandangoParser::ComparisonContext::compare_op_bitwise_or_pair() {
  return getRuleContexts<FandangoParser::Compare_op_bitwise_or_pairContext>();
}

FandangoParser::Compare_op_bitwise_or_pairContext* FandangoParser::ComparisonContext::compare_op_bitwise_or_pair(size_t i) {
  return getRuleContext<FandangoParser::Compare_op_bitwise_or_pairContext>(i);
}


size_t FandangoParser::ComparisonContext::getRuleIndex() const {
  return FandangoParser::RuleComparison;
}


std::any FandangoParser::ComparisonContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitComparison(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ComparisonContext* FandangoParser::comparison() {
  ComparisonContext *_localctx = _tracker.createInstance<ComparisonContext>(_ctx, getState());
  enterRule(_localctx, 316, FandangoParser::RuleComparison);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2403);
    bitwise_or(0);
    setState(2407);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 281, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2404);
        compare_op_bitwise_or_pair(); 
      }
      setState(2409);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 281, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Compare_op_bitwise_or_pairContext ------------------------------------------------------------------

FandangoParser::Compare_op_bitwise_or_pairContext::Compare_op_bitwise_or_pairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Eq_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::eq_bitwise_or() {
  return getRuleContext<FandangoParser::Eq_bitwise_orContext>(0);
}

FandangoParser::Noteq_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::noteq_bitwise_or() {
  return getRuleContext<FandangoParser::Noteq_bitwise_orContext>(0);
}

FandangoParser::Lte_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::lte_bitwise_or() {
  return getRuleContext<FandangoParser::Lte_bitwise_orContext>(0);
}

FandangoParser::Lt_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::lt_bitwise_or() {
  return getRuleContext<FandangoParser::Lt_bitwise_orContext>(0);
}

FandangoParser::Gte_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::gte_bitwise_or() {
  return getRuleContext<FandangoParser::Gte_bitwise_orContext>(0);
}

FandangoParser::Gt_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::gt_bitwise_or() {
  return getRuleContext<FandangoParser::Gt_bitwise_orContext>(0);
}

FandangoParser::Notin_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::notin_bitwise_or() {
  return getRuleContext<FandangoParser::Notin_bitwise_orContext>(0);
}

FandangoParser::In_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::in_bitwise_or() {
  return getRuleContext<FandangoParser::In_bitwise_orContext>(0);
}

FandangoParser::Isnot_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::isnot_bitwise_or() {
  return getRuleContext<FandangoParser::Isnot_bitwise_orContext>(0);
}

FandangoParser::Is_bitwise_orContext* FandangoParser::Compare_op_bitwise_or_pairContext::is_bitwise_or() {
  return getRuleContext<FandangoParser::Is_bitwise_orContext>(0);
}


size_t FandangoParser::Compare_op_bitwise_or_pairContext::getRuleIndex() const {
  return FandangoParser::RuleCompare_op_bitwise_or_pair;
}


std::any FandangoParser::Compare_op_bitwise_or_pairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitCompare_op_bitwise_or_pair(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Compare_op_bitwise_or_pairContext* FandangoParser::compare_op_bitwise_or_pair() {
  Compare_op_bitwise_or_pairContext *_localctx = _tracker.createInstance<Compare_op_bitwise_or_pairContext>(_ctx, getState());
  enterRule(_localctx, 318, FandangoParser::RuleCompare_op_bitwise_or_pair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2420);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 282, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2410);
      eq_bitwise_or();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2411);
      noteq_bitwise_or();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2412);
      lte_bitwise_or();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2413);
      lt_bitwise_or();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2414);
      gte_bitwise_or();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2415);
      gt_bitwise_or();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2416);
      notin_bitwise_or();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2417);
      in_bitwise_or();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2418);
      isnot_bitwise_or();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(2419);
      is_bitwise_or();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Eq_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Eq_bitwise_orContext::Eq_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Eq_bitwise_orContext::EQUALS() {
  return getToken(FandangoParser::EQUALS, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Eq_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Eq_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleEq_bitwise_or;
}


std::any FandangoParser::Eq_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitEq_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Eq_bitwise_orContext* FandangoParser::eq_bitwise_or() {
  Eq_bitwise_orContext *_localctx = _tracker.createInstance<Eq_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 320, FandangoParser::RuleEq_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2422);
    match(FandangoParser::EQUALS);
    setState(2423);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Noteq_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Noteq_bitwise_orContext::Noteq_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Noteq_bitwise_orContext::NOT_EQ_2() {
  return getToken(FandangoParser::NOT_EQ_2, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Noteq_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}

tree::TerminalNode* FandangoParser::Noteq_bitwise_orContext::NOT_EQ_1() {
  return getToken(FandangoParser::NOT_EQ_1, 0);
}


size_t FandangoParser::Noteq_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleNoteq_bitwise_or;
}


std::any FandangoParser::Noteq_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitNoteq_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Noteq_bitwise_orContext* FandangoParser::noteq_bitwise_or() {
  Noteq_bitwise_orContext *_localctx = _tracker.createInstance<Noteq_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 322, FandangoParser::RuleNoteq_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2429);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NOT_EQ_2: {
        enterOuterAlt(_localctx, 1);
        setState(2425);
        match(FandangoParser::NOT_EQ_2);
        setState(2426);
        bitwise_or(0);
        break;
      }

      case FandangoParser::NOT_EQ_1: {
        enterOuterAlt(_localctx, 2);
        setState(2427);
        match(FandangoParser::NOT_EQ_1);
        setState(2428);
        bitwise_or(0);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lte_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Lte_bitwise_orContext::Lte_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Lte_bitwise_orContext::LT_EQ() {
  return getToken(FandangoParser::LT_EQ, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Lte_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Lte_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleLte_bitwise_or;
}


std::any FandangoParser::Lte_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLte_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lte_bitwise_orContext* FandangoParser::lte_bitwise_or() {
  Lte_bitwise_orContext *_localctx = _tracker.createInstance<Lte_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 324, FandangoParser::RuleLte_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2431);
    match(FandangoParser::LT_EQ);
    setState(2432);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lt_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Lt_bitwise_orContext::Lt_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Lt_bitwise_orContext::LESS_THAN() {
  return getToken(FandangoParser::LESS_THAN, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Lt_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Lt_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleLt_bitwise_or;
}


std::any FandangoParser::Lt_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLt_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lt_bitwise_orContext* FandangoParser::lt_bitwise_or() {
  Lt_bitwise_orContext *_localctx = _tracker.createInstance<Lt_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 326, FandangoParser::RuleLt_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2434);
    match(FandangoParser::LESS_THAN);
    setState(2435);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Gte_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Gte_bitwise_orContext::Gte_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Gte_bitwise_orContext::GT_EQ() {
  return getToken(FandangoParser::GT_EQ, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Gte_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Gte_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleGte_bitwise_or;
}


std::any FandangoParser::Gte_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGte_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Gte_bitwise_orContext* FandangoParser::gte_bitwise_or() {
  Gte_bitwise_orContext *_localctx = _tracker.createInstance<Gte_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 328, FandangoParser::RuleGte_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2437);
    match(FandangoParser::GT_EQ);
    setState(2438);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Gt_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Gt_bitwise_orContext::Gt_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Gt_bitwise_orContext::GREATER_THAN() {
  return getToken(FandangoParser::GREATER_THAN, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Gt_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Gt_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleGt_bitwise_or;
}


std::any FandangoParser::Gt_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGt_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Gt_bitwise_orContext* FandangoParser::gt_bitwise_or() {
  Gt_bitwise_orContext *_localctx = _tracker.createInstance<Gt_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 330, FandangoParser::RuleGt_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2440);
    match(FandangoParser::GREATER_THAN);
    setState(2441);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Notin_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Notin_bitwise_orContext::Notin_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Notin_bitwise_orContext::NOT() {
  return getToken(FandangoParser::NOT, 0);
}

tree::TerminalNode* FandangoParser::Notin_bitwise_orContext::IN() {
  return getToken(FandangoParser::IN, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Notin_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Notin_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleNotin_bitwise_or;
}


std::any FandangoParser::Notin_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitNotin_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Notin_bitwise_orContext* FandangoParser::notin_bitwise_or() {
  Notin_bitwise_orContext *_localctx = _tracker.createInstance<Notin_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 332, FandangoParser::RuleNotin_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2443);
    match(FandangoParser::NOT);
    setState(2444);
    match(FandangoParser::IN);
    setState(2445);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- In_bitwise_orContext ------------------------------------------------------------------

FandangoParser::In_bitwise_orContext::In_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::In_bitwise_orContext::IN() {
  return getToken(FandangoParser::IN, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::In_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::In_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleIn_bitwise_or;
}


std::any FandangoParser::In_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitIn_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::In_bitwise_orContext* FandangoParser::in_bitwise_or() {
  In_bitwise_orContext *_localctx = _tracker.createInstance<In_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 334, FandangoParser::RuleIn_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2447);
    match(FandangoParser::IN);
    setState(2448);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Isnot_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Isnot_bitwise_orContext::Isnot_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Isnot_bitwise_orContext::IS() {
  return getToken(FandangoParser::IS, 0);
}

tree::TerminalNode* FandangoParser::Isnot_bitwise_orContext::NOT() {
  return getToken(FandangoParser::NOT, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Isnot_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Isnot_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleIsnot_bitwise_or;
}


std::any FandangoParser::Isnot_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitIsnot_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Isnot_bitwise_orContext* FandangoParser::isnot_bitwise_or() {
  Isnot_bitwise_orContext *_localctx = _tracker.createInstance<Isnot_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 336, FandangoParser::RuleIsnot_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2450);
    match(FandangoParser::IS);
    setState(2451);
    match(FandangoParser::NOT);
    setState(2452);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Is_bitwise_orContext ------------------------------------------------------------------

FandangoParser::Is_bitwise_orContext::Is_bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Is_bitwise_orContext::IS() {
  return getToken(FandangoParser::IS, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Is_bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}


size_t FandangoParser::Is_bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleIs_bitwise_or;
}


std::any FandangoParser::Is_bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitIs_bitwise_or(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Is_bitwise_orContext* FandangoParser::is_bitwise_or() {
  Is_bitwise_orContext *_localctx = _tracker.createInstance<Is_bitwise_orContext>(_ctx, getState());
  enterRule(_localctx, 338, FandangoParser::RuleIs_bitwise_or);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2454);
    match(FandangoParser::IS);
    setState(2455);
    bitwise_or(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Bitwise_orContext ------------------------------------------------------------------

FandangoParser::Bitwise_orContext::Bitwise_orContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Bitwise_xorContext* FandangoParser::Bitwise_orContext::bitwise_xor() {
  return getRuleContext<FandangoParser::Bitwise_xorContext>(0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Bitwise_orContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}

tree::TerminalNode* FandangoParser::Bitwise_orContext::OR_OP() {
  return getToken(FandangoParser::OR_OP, 0);
}


size_t FandangoParser::Bitwise_orContext::getRuleIndex() const {
  return FandangoParser::RuleBitwise_or;
}


std::any FandangoParser::Bitwise_orContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitBitwise_or(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Bitwise_orContext* FandangoParser::bitwise_or() {
   return bitwise_or(0);
}

FandangoParser::Bitwise_orContext* FandangoParser::bitwise_or(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Bitwise_orContext *_localctx = _tracker.createInstance<Bitwise_orContext>(_ctx, parentState);
  FandangoParser::Bitwise_orContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 340;
  enterRecursionRule(_localctx, 340, FandangoParser::RuleBitwise_or, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2458);
    bitwise_xor(0);
    _ctx->stop = _input->LT(-1);
    setState(2465);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 284, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<Bitwise_orContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleBitwise_or);
        setState(2460);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(2461);
        match(FandangoParser::OR_OP);
        setState(2462);
        bitwise_xor(0); 
      }
      setState(2467);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 284, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- Bitwise_xorContext ------------------------------------------------------------------

FandangoParser::Bitwise_xorContext::Bitwise_xorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Bitwise_andContext* FandangoParser::Bitwise_xorContext::bitwise_and() {
  return getRuleContext<FandangoParser::Bitwise_andContext>(0);
}

FandangoParser::Bitwise_xorContext* FandangoParser::Bitwise_xorContext::bitwise_xor() {
  return getRuleContext<FandangoParser::Bitwise_xorContext>(0);
}

tree::TerminalNode* FandangoParser::Bitwise_xorContext::XOR() {
  return getToken(FandangoParser::XOR, 0);
}


size_t FandangoParser::Bitwise_xorContext::getRuleIndex() const {
  return FandangoParser::RuleBitwise_xor;
}


std::any FandangoParser::Bitwise_xorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitBitwise_xor(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Bitwise_xorContext* FandangoParser::bitwise_xor() {
   return bitwise_xor(0);
}

FandangoParser::Bitwise_xorContext* FandangoParser::bitwise_xor(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Bitwise_xorContext *_localctx = _tracker.createInstance<Bitwise_xorContext>(_ctx, parentState);
  FandangoParser::Bitwise_xorContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 342;
  enterRecursionRule(_localctx, 342, FandangoParser::RuleBitwise_xor, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2469);
    bitwise_and(0);
    _ctx->stop = _input->LT(-1);
    setState(2476);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 285, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<Bitwise_xorContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleBitwise_xor);
        setState(2471);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(2472);
        match(FandangoParser::XOR);
        setState(2473);
        bitwise_and(0); 
      }
      setState(2478);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 285, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- Bitwise_andContext ------------------------------------------------------------------

FandangoParser::Bitwise_andContext::Bitwise_andContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Shift_exprContext* FandangoParser::Bitwise_andContext::shift_expr() {
  return getRuleContext<FandangoParser::Shift_exprContext>(0);
}

FandangoParser::Bitwise_andContext* FandangoParser::Bitwise_andContext::bitwise_and() {
  return getRuleContext<FandangoParser::Bitwise_andContext>(0);
}

tree::TerminalNode* FandangoParser::Bitwise_andContext::AND_OP() {
  return getToken(FandangoParser::AND_OP, 0);
}


size_t FandangoParser::Bitwise_andContext::getRuleIndex() const {
  return FandangoParser::RuleBitwise_and;
}


std::any FandangoParser::Bitwise_andContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitBitwise_and(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Bitwise_andContext* FandangoParser::bitwise_and() {
   return bitwise_and(0);
}

FandangoParser::Bitwise_andContext* FandangoParser::bitwise_and(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Bitwise_andContext *_localctx = _tracker.createInstance<Bitwise_andContext>(_ctx, parentState);
  FandangoParser::Bitwise_andContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 344;
  enterRecursionRule(_localctx, 344, FandangoParser::RuleBitwise_and, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2480);
    shift_expr(0);
    _ctx->stop = _input->LT(-1);
    setState(2487);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 286, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<Bitwise_andContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleBitwise_and);
        setState(2482);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(2483);
        match(FandangoParser::AND_OP);
        setState(2484);
        shift_expr(0); 
      }
      setState(2489);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 286, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- Shift_exprContext ------------------------------------------------------------------

FandangoParser::Shift_exprContext::Shift_exprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::SumContext* FandangoParser::Shift_exprContext::sum() {
  return getRuleContext<FandangoParser::SumContext>(0);
}

FandangoParser::Shift_exprContext* FandangoParser::Shift_exprContext::shift_expr() {
  return getRuleContext<FandangoParser::Shift_exprContext>(0);
}

tree::TerminalNode* FandangoParser::Shift_exprContext::LEFT_SHIFT() {
  return getToken(FandangoParser::LEFT_SHIFT, 0);
}

tree::TerminalNode* FandangoParser::Shift_exprContext::RIGHT_SHIFT() {
  return getToken(FandangoParser::RIGHT_SHIFT, 0);
}


size_t FandangoParser::Shift_exprContext::getRuleIndex() const {
  return FandangoParser::RuleShift_expr;
}


std::any FandangoParser::Shift_exprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitShift_expr(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::Shift_exprContext* FandangoParser::shift_expr() {
   return shift_expr(0);
}

FandangoParser::Shift_exprContext* FandangoParser::shift_expr(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::Shift_exprContext *_localctx = _tracker.createInstance<Shift_exprContext>(_ctx, parentState);
  FandangoParser::Shift_exprContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 346;
  enterRecursionRule(_localctx, 346, FandangoParser::RuleShift_expr, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2491);
    sum(0);
    _ctx->stop = _input->LT(-1);
    setState(2501);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 288, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(2499);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 287, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<Shift_exprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleShift_expr);
          setState(2493);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(2494);
          match(FandangoParser::LEFT_SHIFT);
          setState(2495);
          sum(0);
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<Shift_exprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleShift_expr);
          setState(2496);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(2497);
          match(FandangoParser::RIGHT_SHIFT);
          setState(2498);
          sum(0);
          break;
        }

        default:
          break;
        } 
      }
      setState(2503);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 288, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- SumContext ------------------------------------------------------------------

FandangoParser::SumContext::SumContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::TermContext* FandangoParser::SumContext::term() {
  return getRuleContext<FandangoParser::TermContext>(0);
}

FandangoParser::SumContext* FandangoParser::SumContext::sum() {
  return getRuleContext<FandangoParser::SumContext>(0);
}

tree::TerminalNode* FandangoParser::SumContext::ADD() {
  return getToken(FandangoParser::ADD, 0);
}

tree::TerminalNode* FandangoParser::SumContext::MINUS() {
  return getToken(FandangoParser::MINUS, 0);
}


size_t FandangoParser::SumContext::getRuleIndex() const {
  return FandangoParser::RuleSum;
}


std::any FandangoParser::SumContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSum(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::SumContext* FandangoParser::sum() {
   return sum(0);
}

FandangoParser::SumContext* FandangoParser::sum(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::SumContext *_localctx = _tracker.createInstance<SumContext>(_ctx, parentState);
  FandangoParser::SumContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 348;
  enterRecursionRule(_localctx, 348, FandangoParser::RuleSum, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2505);
    term(0);
    _ctx->stop = _input->LT(-1);
    setState(2515);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 290, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(2513);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 289, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<SumContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleSum);
          setState(2507);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(2508);
          match(FandangoParser::ADD);
          setState(2509);
          term(0);
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<SumContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleSum);
          setState(2510);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(2511);
          match(FandangoParser::MINUS);
          setState(2512);
          term(0);
          break;
        }

        default:
          break;
        } 
      }
      setState(2517);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 290, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- TermContext ------------------------------------------------------------------

FandangoParser::TermContext::TermContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::FactorContext* FandangoParser::TermContext::factor() {
  return getRuleContext<FandangoParser::FactorContext>(0);
}

FandangoParser::TermContext* FandangoParser::TermContext::term() {
  return getRuleContext<FandangoParser::TermContext>(0);
}

tree::TerminalNode* FandangoParser::TermContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

tree::TerminalNode* FandangoParser::TermContext::DIV() {
  return getToken(FandangoParser::DIV, 0);
}

tree::TerminalNode* FandangoParser::TermContext::IDIV() {
  return getToken(FandangoParser::IDIV, 0);
}

tree::TerminalNode* FandangoParser::TermContext::MOD() {
  return getToken(FandangoParser::MOD, 0);
}

tree::TerminalNode* FandangoParser::TermContext::AT() {
  return getToken(FandangoParser::AT, 0);
}


size_t FandangoParser::TermContext::getRuleIndex() const {
  return FandangoParser::RuleTerm;
}


std::any FandangoParser::TermContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitTerm(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::TermContext* FandangoParser::term() {
   return term(0);
}

FandangoParser::TermContext* FandangoParser::term(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::TermContext *_localctx = _tracker.createInstance<TermContext>(_ctx, parentState);
  FandangoParser::TermContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 350;
  enterRecursionRule(_localctx, 350, FandangoParser::RuleTerm, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2519);
    factor();
    _ctx->stop = _input->LT(-1);
    setState(2538);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 292, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(2536);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 291, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<TermContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleTerm);
          setState(2521);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(2522);
          match(FandangoParser::STAR);
          setState(2523);
          factor();
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<TermContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleTerm);
          setState(2524);

          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
          setState(2525);
          match(FandangoParser::DIV);
          setState(2526);
          factor();
          break;
        }

        case 3: {
          _localctx = _tracker.createInstance<TermContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleTerm);
          setState(2527);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(2528);
          match(FandangoParser::IDIV);
          setState(2529);
          factor();
          break;
        }

        case 4: {
          _localctx = _tracker.createInstance<TermContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleTerm);
          setState(2530);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(2531);
          match(FandangoParser::MOD);
          setState(2532);
          factor();
          break;
        }

        case 5: {
          _localctx = _tracker.createInstance<TermContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleTerm);
          setState(2533);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(2534);
          match(FandangoParser::AT);
          setState(2535);
          factor();
          break;
        }

        default:
          break;
        } 
      }
      setState(2540);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 292, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- FactorContext ------------------------------------------------------------------

FandangoParser::FactorContext::FactorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::FactorContext::ADD() {
  return getToken(FandangoParser::ADD, 0);
}

FandangoParser::FactorContext* FandangoParser::FactorContext::factor() {
  return getRuleContext<FandangoParser::FactorContext>(0);
}

tree::TerminalNode* FandangoParser::FactorContext::MINUS() {
  return getToken(FandangoParser::MINUS, 0);
}

tree::TerminalNode* FandangoParser::FactorContext::NOT_OP() {
  return getToken(FandangoParser::NOT_OP, 0);
}

FandangoParser::PowerContext* FandangoParser::FactorContext::power() {
  return getRuleContext<FandangoParser::PowerContext>(0);
}


size_t FandangoParser::FactorContext::getRuleIndex() const {
  return FandangoParser::RuleFactor;
}


std::any FandangoParser::FactorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFactor(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::FactorContext* FandangoParser::factor() {
  FactorContext *_localctx = _tracker.createInstance<FactorContext>(_ctx, getState());
  enterRule(_localctx, 352, FandangoParser::RuleFactor);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2548);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ADD: {
        enterOuterAlt(_localctx, 1);
        setState(2541);
        match(FandangoParser::ADD);
        setState(2542);
        factor();
        break;
      }

      case FandangoParser::MINUS: {
        enterOuterAlt(_localctx, 2);
        setState(2543);
        match(FandangoParser::MINUS);
        setState(2544);
        factor();
        break;
      }

      case FandangoParser::NOT_OP: {
        enterOuterAlt(_localctx, 3);
        setState(2545);
        match(FandangoParser::NOT_OP);
        setState(2546);
        factor();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::AWAIT:
      case FandangoParser::FALSE:
      case FandangoParser::NONE:
      case FandangoParser::TRUE:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 4);
        setState(2547);
        power();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PowerContext ------------------------------------------------------------------

FandangoParser::PowerContext::PowerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Await_primaryContext* FandangoParser::PowerContext::await_primary() {
  return getRuleContext<FandangoParser::Await_primaryContext>(0);
}

tree::TerminalNode* FandangoParser::PowerContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}

FandangoParser::FactorContext* FandangoParser::PowerContext::factor() {
  return getRuleContext<FandangoParser::FactorContext>(0);
}


size_t FandangoParser::PowerContext::getRuleIndex() const {
  return FandangoParser::RulePower;
}


std::any FandangoParser::PowerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPower(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::PowerContext* FandangoParser::power() {
  PowerContext *_localctx = _tracker.createInstance<PowerContext>(_ctx, getState());
  enterRule(_localctx, 354, FandangoParser::RulePower);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2555);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2550);
      await_primary();
      setState(2551);
      match(FandangoParser::POWER);
      setState(2552);
      factor();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2554);
      await_primary();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Await_primaryContext ------------------------------------------------------------------

FandangoParser::Await_primaryContext::Await_primaryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Await_primaryContext::AWAIT() {
  return getToken(FandangoParser::AWAIT, 0);
}

FandangoParser::PrimaryContext* FandangoParser::Await_primaryContext::primary() {
  return getRuleContext<FandangoParser::PrimaryContext>(0);
}


size_t FandangoParser::Await_primaryContext::getRuleIndex() const {
  return FandangoParser::RuleAwait_primary;
}


std::any FandangoParser::Await_primaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAwait_primary(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Await_primaryContext* FandangoParser::await_primary() {
  Await_primaryContext *_localctx = _tracker.createInstance<Await_primaryContext>(_ctx, getState());
  enterRule(_localctx, 356, FandangoParser::RuleAwait_primary);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2560);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::AWAIT: {
        enterOuterAlt(_localctx, 1);
        setState(2557);
        match(FandangoParser::AWAIT);
        setState(2558);
        primary(0);
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::FALSE:
      case FandangoParser::NONE:
      case FandangoParser::TRUE:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        enterOuterAlt(_localctx, 2);
        setState(2559);
        primary(0);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PrimaryContext ------------------------------------------------------------------

FandangoParser::PrimaryContext::PrimaryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::AtomContext* FandangoParser::PrimaryContext::atom() {
  return getRuleContext<FandangoParser::AtomContext>(0);
}

FandangoParser::PrimaryContext* FandangoParser::PrimaryContext::primary() {
  return getRuleContext<FandangoParser::PrimaryContext>(0);
}

tree::TerminalNode* FandangoParser::PrimaryContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

FandangoParser::IdentifierContext* FandangoParser::PrimaryContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

FandangoParser::GenexpContext* FandangoParser::PrimaryContext::genexp() {
  return getRuleContext<FandangoParser::GenexpContext>(0);
}

tree::TerminalNode* FandangoParser::PrimaryContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::PrimaryContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::ArgumentsContext* FandangoParser::PrimaryContext::arguments() {
  return getRuleContext<FandangoParser::ArgumentsContext>(0);
}

tree::TerminalNode* FandangoParser::PrimaryContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::SlicesContext* FandangoParser::PrimaryContext::slices() {
  return getRuleContext<FandangoParser::SlicesContext>(0);
}

tree::TerminalNode* FandangoParser::PrimaryContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}


size_t FandangoParser::PrimaryContext::getRuleIndex() const {
  return FandangoParser::RulePrimary;
}


std::any FandangoParser::PrimaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitPrimary(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::PrimaryContext* FandangoParser::primary() {
   return primary(0);
}

FandangoParser::PrimaryContext* FandangoParser::primary(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::PrimaryContext *_localctx = _tracker.createInstance<PrimaryContext>(_ctx, parentState);
  FandangoParser::PrimaryContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 358;
  enterRecursionRule(_localctx, 358, FandangoParser::RulePrimary, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2563);
    atom();
    _ctx->stop = _input->LT(-1);
    setState(2583);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(2581);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 297, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<PrimaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePrimary);
          setState(2565);

          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
          setState(2566);
          match(FandangoParser::DOT);
          setState(2567);
          identifier();
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<PrimaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePrimary);
          setState(2568);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(2569);
          genexp();
          break;
        }

        case 3: {
          _localctx = _tracker.createInstance<PrimaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePrimary);
          setState(2570);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(2571);
          match(FandangoParser::OPEN_PAREN);
          setState(2573);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if ((((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 78)) & 93071897) != 0)) {
            setState(2572);
            arguments();
          }
          setState(2575);
          match(FandangoParser::CLOSE_PAREN);
          break;
        }

        case 4: {
          _localctx = _tracker.createInstance<PrimaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePrimary);
          setState(2576);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(2577);
          match(FandangoParser::OPEN_BRACK);
          setState(2578);
          slices();
          setState(2579);
          match(FandangoParser::CLOSE_BRACK);
          break;
        }

        default:
          break;
        } 
      }
      setState(2585);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- SlicesContext ------------------------------------------------------------------

FandangoParser::SlicesContext::SlicesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::SliceContext *> FandangoParser::SlicesContext::slice() {
  return getRuleContexts<FandangoParser::SliceContext>();
}

FandangoParser::SliceContext* FandangoParser::SlicesContext::slice(size_t i) {
  return getRuleContext<FandangoParser::SliceContext>(i);
}

std::vector<FandangoParser::Starred_expressionContext *> FandangoParser::SlicesContext::starred_expression() {
  return getRuleContexts<FandangoParser::Starred_expressionContext>();
}

FandangoParser::Starred_expressionContext* FandangoParser::SlicesContext::starred_expression(size_t i) {
  return getRuleContext<FandangoParser::Starred_expressionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::SlicesContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::SlicesContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::SlicesContext::getRuleIndex() const {
  return FandangoParser::RuleSlices;
}


std::any FandangoParser::SlicesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSlices(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::SlicesContext* FandangoParser::slices() {
  SlicesContext *_localctx = _tracker.createInstance<SlicesContext>(_ctx, getState());
  enterRule(_localctx, 360, FandangoParser::RuleSlices);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2588);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 299, _ctx)) {
    case 1: {
      setState(2586);
      slice();
      break;
    }

    case 2: {
      setState(2587);
      starred_expression();
      break;
    }

    default:
      break;
    }
    setState(2597);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2590);
        match(FandangoParser::COMMA);
        setState(2593);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 300, _ctx)) {
        case 1: {
          setState(2591);
          slice();
          break;
        }

        case 2: {
          setState(2592);
          starred_expression();
          break;
        }

        default:
          break;
        } 
      }
      setState(2599);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx);
    }
    setState(2601);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2600);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SliceContext ------------------------------------------------------------------

FandangoParser::SliceContext::SliceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FandangoParser::SliceContext::COLON() {
  return getTokens(FandangoParser::COLON);
}

tree::TerminalNode* FandangoParser::SliceContext::COLON(size_t i) {
  return getToken(FandangoParser::COLON, i);
}

std::vector<FandangoParser::ExpressionContext *> FandangoParser::SliceContext::expression() {
  return getRuleContexts<FandangoParser::ExpressionContext>();
}

FandangoParser::ExpressionContext* FandangoParser::SliceContext::expression(size_t i) {
  return getRuleContext<FandangoParser::ExpressionContext>(i);
}

FandangoParser::Named_expressionContext* FandangoParser::SliceContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}


size_t FandangoParser::SliceContext::getRuleIndex() const {
  return FandangoParser::RuleSlice;
}


std::any FandangoParser::SliceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSlice(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::SliceContext* FandangoParser::slice() {
  SliceContext *_localctx = _tracker.createInstance<SliceContext>(_ctx, getState());
  enterRule(_localctx, 362, FandangoParser::RuleSlice);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2617);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 307, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2604);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 93071897) != 0)) {
        setState(2603);
        expression();
      }
      setState(2606);
      match(FandangoParser::COLON);
      setState(2608);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 93071897) != 0)) {
        setState(2607);
        expression();
      }
      setState(2614);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COLON) {
        setState(2610);
        match(FandangoParser::COLON);
        setState(2612);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 78)) & 93071897) != 0)) {
          setState(2611);
          expression();
        }
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2616);
      named_expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AtomContext ------------------------------------------------------------------

FandangoParser::AtomContext::AtomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Selector_lengthContext* FandangoParser::AtomContext::selector_length() {
  return getRuleContext<FandangoParser::Selector_lengthContext>(0);
}

FandangoParser::IdentifierContext* FandangoParser::AtomContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::AtomContext::TRUE() {
  return getToken(FandangoParser::TRUE, 0);
}

tree::TerminalNode* FandangoParser::AtomContext::FALSE() {
  return getToken(FandangoParser::FALSE, 0);
}

tree::TerminalNode* FandangoParser::AtomContext::NONE() {
  return getToken(FandangoParser::NONE, 0);
}

FandangoParser::StringsContext* FandangoParser::AtomContext::strings() {
  return getRuleContext<FandangoParser::StringsContext>(0);
}

tree::TerminalNode* FandangoParser::AtomContext::NUMBER() {
  return getToken(FandangoParser::NUMBER, 0);
}

FandangoParser::TupleContext* FandangoParser::AtomContext::tuple() {
  return getRuleContext<FandangoParser::TupleContext>(0);
}

FandangoParser::GroupContext* FandangoParser::AtomContext::group() {
  return getRuleContext<FandangoParser::GroupContext>(0);
}

FandangoParser::GenexpContext* FandangoParser::AtomContext::genexp() {
  return getRuleContext<FandangoParser::GenexpContext>(0);
}

FandangoParser::ListContext* FandangoParser::AtomContext::list() {
  return getRuleContext<FandangoParser::ListContext>(0);
}

FandangoParser::ListcompContext* FandangoParser::AtomContext::listcomp() {
  return getRuleContext<FandangoParser::ListcompContext>(0);
}

FandangoParser::DictContext* FandangoParser::AtomContext::dict() {
  return getRuleContext<FandangoParser::DictContext>(0);
}

FandangoParser::SetContext* FandangoParser::AtomContext::set() {
  return getRuleContext<FandangoParser::SetContext>(0);
}

FandangoParser::DictcompContext* FandangoParser::AtomContext::dictcomp() {
  return getRuleContext<FandangoParser::DictcompContext>(0);
}

FandangoParser::SetcompContext* FandangoParser::AtomContext::setcomp() {
  return getRuleContext<FandangoParser::SetcompContext>(0);
}

tree::TerminalNode* FandangoParser::AtomContext::ELLIPSIS() {
  return getToken(FandangoParser::ELLIPSIS, 0);
}


size_t FandangoParser::AtomContext::getRuleIndex() const {
  return FandangoParser::RuleAtom;
}


std::any FandangoParser::AtomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitAtom(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::AtomContext* FandangoParser::atom() {
  AtomContext *_localctx = _tracker.createInstance<AtomContext>(_ctx, getState());
  enterRule(_localctx, 364, FandangoParser::RuleAtom);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2642);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 311, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2619);
      selector_length();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2620);
      identifier();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2621);
      match(FandangoParser::TRUE);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2622);
      match(FandangoParser::FALSE);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2623);
      match(FandangoParser::NONE);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2624);
      strings();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2625);
      match(FandangoParser::NUMBER);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2629);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 308, _ctx)) {
      case 1: {
        setState(2626);
        tuple();
        break;
      }

      case 2: {
        setState(2627);
        group();
        break;
      }

      case 3: {
        setState(2628);
        genexp();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2633);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 309, _ctx)) {
      case 1: {
        setState(2631);
        list();
        break;
      }

      case 2: {
        setState(2632);
        listcomp();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(2639);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 310, _ctx)) {
      case 1: {
        setState(2635);
        dict();
        break;
      }

      case 2: {
        setState(2636);
        set();
        break;
      }

      case 3: {
        setState(2637);
        dictcomp();
        break;
      }

      case 4: {
        setState(2638);
        setcomp();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(2641);
      match(FandangoParser::ELLIPSIS);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupContext ------------------------------------------------------------------

FandangoParser::GroupContext::GroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::GroupContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::GroupContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Yield_exprContext* FandangoParser::GroupContext::yield_expr() {
  return getRuleContext<FandangoParser::Yield_exprContext>(0);
}

FandangoParser::Named_expressionContext* FandangoParser::GroupContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}


size_t FandangoParser::GroupContext::getRuleIndex() const {
  return FandangoParser::RuleGroup;
}


std::any FandangoParser::GroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGroup(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::GroupContext* FandangoParser::group() {
  GroupContext *_localctx = _tracker.createInstance<GroupContext>(_ctx, getState());
  enterRule(_localctx, 366, FandangoParser::RuleGroup);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2644);
    match(FandangoParser::OPEN_PAREN);
    setState(2647);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::YIELD: {
        setState(2645);
        yield_expr();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::AWAIT:
      case FandangoParser::FALSE:
      case FandangoParser::LAMBDA:
      case FandangoParser::NONE:
      case FandangoParser::NOT:
      case FandangoParser::TRUE:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        setState(2646);
        named_expression();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2649);
    match(FandangoParser::CLOSE_PAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LambdefContext ------------------------------------------------------------------

FandangoParser::LambdefContext::LambdefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::LambdefContext::LAMBDA() {
  return getToken(FandangoParser::LAMBDA, 0);
}

tree::TerminalNode* FandangoParser::LambdefContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

FandangoParser::ExpressionContext* FandangoParser::LambdefContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

FandangoParser::Lambda_paramsContext* FandangoParser::LambdefContext::lambda_params() {
  return getRuleContext<FandangoParser::Lambda_paramsContext>(0);
}


size_t FandangoParser::LambdefContext::getRuleIndex() const {
  return FandangoParser::RuleLambdef;
}


std::any FandangoParser::LambdefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambdef(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::LambdefContext* FandangoParser::lambdef() {
  LambdefContext *_localctx = _tracker.createInstance<LambdefContext>(_ctx, getState());
  enterRule(_localctx, 368, FandangoParser::RuleLambdef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2651);
    match(FandangoParser::LAMBDA);
    setState(2653);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 56) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 56)) & 2181038151) != 0)) {
      setState(2652);
      lambda_params();
    }
    setState(2655);
    match(FandangoParser::COLON);
    setState(2656);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_paramsContext ------------------------------------------------------------------

FandangoParser::Lambda_paramsContext::Lambda_paramsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Lambda_parametersContext* FandangoParser::Lambda_paramsContext::lambda_parameters() {
  return getRuleContext<FandangoParser::Lambda_parametersContext>(0);
}


size_t FandangoParser::Lambda_paramsContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_params;
}


std::any FandangoParser::Lambda_paramsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_params(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_paramsContext* FandangoParser::lambda_params() {
  Lambda_paramsContext *_localctx = _tracker.createInstance<Lambda_paramsContext>(_ctx, getState());
  enterRule(_localctx, 370, FandangoParser::RuleLambda_params);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2658);
    lambda_parameters();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_parametersContext ------------------------------------------------------------------

FandangoParser::Lambda_parametersContext::Lambda_parametersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Lambda_slash_no_defaultContext* FandangoParser::Lambda_parametersContext::lambda_slash_no_default() {
  return getRuleContext<FandangoParser::Lambda_slash_no_defaultContext>(0);
}

std::vector<FandangoParser::Lambda_param_no_defaultContext *> FandangoParser::Lambda_parametersContext::lambda_param_no_default() {
  return getRuleContexts<FandangoParser::Lambda_param_no_defaultContext>();
}

FandangoParser::Lambda_param_no_defaultContext* FandangoParser::Lambda_parametersContext::lambda_param_no_default(size_t i) {
  return getRuleContext<FandangoParser::Lambda_param_no_defaultContext>(i);
}

std::vector<FandangoParser::Lambda_param_with_defaultContext *> FandangoParser::Lambda_parametersContext::lambda_param_with_default() {
  return getRuleContexts<FandangoParser::Lambda_param_with_defaultContext>();
}

FandangoParser::Lambda_param_with_defaultContext* FandangoParser::Lambda_parametersContext::lambda_param_with_default(size_t i) {
  return getRuleContext<FandangoParser::Lambda_param_with_defaultContext>(i);
}

FandangoParser::Lambda_star_etcContext* FandangoParser::Lambda_parametersContext::lambda_star_etc() {
  return getRuleContext<FandangoParser::Lambda_star_etcContext>(0);
}

FandangoParser::Lambda_slash_with_defaultContext* FandangoParser::Lambda_parametersContext::lambda_slash_with_default() {
  return getRuleContext<FandangoParser::Lambda_slash_with_defaultContext>(0);
}


size_t FandangoParser::Lambda_parametersContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_parameters;
}


std::any FandangoParser::Lambda_parametersContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_parameters(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_parametersContext* FandangoParser::lambda_parameters() {
  Lambda_parametersContext *_localctx = _tracker.createInstance<Lambda_parametersContext>(_ctx, getState());
  enterRule(_localctx, 372, FandangoParser::RuleLambda_parameters);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(2709);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 324, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2660);
      lambda_slash_no_default();
      setState(2664);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 314, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2661);
          lambda_param_no_default(); 
        }
        setState(2666);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 314, _ctx);
      }
      setState(2670);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(2667);
        lambda_param_with_default();
        setState(2672);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2674);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(2673);
        lambda_star_etc();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2676);
      lambda_slash_with_default();
      setState(2680);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(2677);
        lambda_param_with_default();
        setState(2682);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2684);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(2683);
        lambda_star_etc();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2687); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2686);
                lambda_param_no_default();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(2689); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 319, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      setState(2694);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(2691);
        lambda_param_with_default();
        setState(2696);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2698);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(2697);
        lambda_star_etc();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2701); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(2700);
        lambda_param_with_default();
        setState(2703); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0));
      setState(2706);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::STAR

      || _la == FandangoParser::POWER) {
        setState(2705);
        lambda_star_etc();
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2708);
      lambda_star_etc();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_slash_no_defaultContext ------------------------------------------------------------------

FandangoParser::Lambda_slash_no_defaultContext::Lambda_slash_no_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Lambda_slash_no_defaultContext::DIV() {
  return getToken(FandangoParser::DIV, 0);
}

std::vector<FandangoParser::Lambda_param_no_defaultContext *> FandangoParser::Lambda_slash_no_defaultContext::lambda_param_no_default() {
  return getRuleContexts<FandangoParser::Lambda_param_no_defaultContext>();
}

FandangoParser::Lambda_param_no_defaultContext* FandangoParser::Lambda_slash_no_defaultContext::lambda_param_no_default(size_t i) {
  return getRuleContext<FandangoParser::Lambda_param_no_defaultContext>(i);
}

tree::TerminalNode* FandangoParser::Lambda_slash_no_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Lambda_slash_no_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_slash_no_default;
}


std::any FandangoParser::Lambda_slash_no_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_slash_no_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_slash_no_defaultContext* FandangoParser::lambda_slash_no_default() {
  Lambda_slash_no_defaultContext *_localctx = _tracker.createInstance<Lambda_slash_no_defaultContext>(_ctx, getState());
  enterRule(_localctx, 374, FandangoParser::RuleLambda_slash_no_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2712); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(2711);
      lambda_param_no_default();
      setState(2714); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116089176692883456) != 0));
    setState(2716);
    match(FandangoParser::DIV);
    setState(2718);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2717);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_slash_with_defaultContext ------------------------------------------------------------------

FandangoParser::Lambda_slash_with_defaultContext::Lambda_slash_with_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Lambda_slash_with_defaultContext::DIV() {
  return getToken(FandangoParser::DIV, 0);
}

std::vector<FandangoParser::Lambda_param_no_defaultContext *> FandangoParser::Lambda_slash_with_defaultContext::lambda_param_no_default() {
  return getRuleContexts<FandangoParser::Lambda_param_no_defaultContext>();
}

FandangoParser::Lambda_param_no_defaultContext* FandangoParser::Lambda_slash_with_defaultContext::lambda_param_no_default(size_t i) {
  return getRuleContext<FandangoParser::Lambda_param_no_defaultContext>(i);
}

std::vector<FandangoParser::Lambda_param_with_defaultContext *> FandangoParser::Lambda_slash_with_defaultContext::lambda_param_with_default() {
  return getRuleContexts<FandangoParser::Lambda_param_with_defaultContext>();
}

FandangoParser::Lambda_param_with_defaultContext* FandangoParser::Lambda_slash_with_defaultContext::lambda_param_with_default(size_t i) {
  return getRuleContext<FandangoParser::Lambda_param_with_defaultContext>(i);
}

tree::TerminalNode* FandangoParser::Lambda_slash_with_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Lambda_slash_with_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_slash_with_default;
}


std::any FandangoParser::Lambda_slash_with_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_slash_with_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_slash_with_defaultContext* FandangoParser::lambda_slash_with_default() {
  Lambda_slash_with_defaultContext *_localctx = _tracker.createInstance<Lambda_slash_with_defaultContext>(_ctx, getState());
  enterRule(_localctx, 376, FandangoParser::RuleLambda_slash_with_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2723);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2720);
        lambda_param_no_default(); 
      }
      setState(2725);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _ctx);
    }
    setState(2727); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(2726);
      lambda_param_with_default();
      setState(2729); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116089176692883456) != 0));
    setState(2731);
    match(FandangoParser::DIV);
    setState(2733);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2732);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_star_etcContext ------------------------------------------------------------------

FandangoParser::Lambda_star_etcContext::Lambda_star_etcContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Lambda_star_etcContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::Lambda_param_no_defaultContext* FandangoParser::Lambda_star_etcContext::lambda_param_no_default() {
  return getRuleContext<FandangoParser::Lambda_param_no_defaultContext>(0);
}

std::vector<FandangoParser::Lambda_param_maybe_defaultContext *> FandangoParser::Lambda_star_etcContext::lambda_param_maybe_default() {
  return getRuleContexts<FandangoParser::Lambda_param_maybe_defaultContext>();
}

FandangoParser::Lambda_param_maybe_defaultContext* FandangoParser::Lambda_star_etcContext::lambda_param_maybe_default(size_t i) {
  return getRuleContext<FandangoParser::Lambda_param_maybe_defaultContext>(i);
}

FandangoParser::Lambda_kwdsContext* FandangoParser::Lambda_star_etcContext::lambda_kwds() {
  return getRuleContext<FandangoParser::Lambda_kwdsContext>(0);
}

tree::TerminalNode* FandangoParser::Lambda_star_etcContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Lambda_star_etcContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_star_etc;
}


std::any FandangoParser::Lambda_star_etcContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_star_etc(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_star_etcContext* FandangoParser::lambda_star_etc() {
  Lambda_star_etcContext *_localctx = _tracker.createInstance<Lambda_star_etcContext>(_ctx, getState());
  enterRule(_localctx, 378, FandangoParser::RuleLambda_star_etc);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2757);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 334, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2735);
      match(FandangoParser::STAR);
      setState(2736);
      lambda_param_no_default();
      setState(2740);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0)) {
        setState(2737);
        lambda_param_maybe_default();
        setState(2742);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2744);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::POWER) {
        setState(2743);
        lambda_kwds();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2746);
      match(FandangoParser::STAR);
      setState(2747);
      match(FandangoParser::COMMA);
      setState(2749); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(2748);
        lambda_param_maybe_default();
        setState(2751); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116089176692883456) != 0));
      setState(2754);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::POWER) {
        setState(2753);
        lambda_kwds();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2756);
      lambda_kwds();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_kwdsContext ------------------------------------------------------------------

FandangoParser::Lambda_kwdsContext::Lambda_kwdsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Lambda_kwdsContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}

FandangoParser::Lambda_param_no_defaultContext* FandangoParser::Lambda_kwdsContext::lambda_param_no_default() {
  return getRuleContext<FandangoParser::Lambda_param_no_defaultContext>(0);
}


size_t FandangoParser::Lambda_kwdsContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_kwds;
}


std::any FandangoParser::Lambda_kwdsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_kwds(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_kwdsContext* FandangoParser::lambda_kwds() {
  Lambda_kwdsContext *_localctx = _tracker.createInstance<Lambda_kwdsContext>(_ctx, getState());
  enterRule(_localctx, 380, FandangoParser::RuleLambda_kwds);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2759);
    match(FandangoParser::POWER);
    setState(2760);
    lambda_param_no_default();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_param_no_defaultContext ------------------------------------------------------------------

FandangoParser::Lambda_param_no_defaultContext::Lambda_param_no_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Lambda_paramContext* FandangoParser::Lambda_param_no_defaultContext::lambda_param() {
  return getRuleContext<FandangoParser::Lambda_paramContext>(0);
}

tree::TerminalNode* FandangoParser::Lambda_param_no_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Lambda_param_no_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_param_no_default;
}


std::any FandangoParser::Lambda_param_no_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_param_no_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_param_no_defaultContext* FandangoParser::lambda_param_no_default() {
  Lambda_param_no_defaultContext *_localctx = _tracker.createInstance<Lambda_param_no_defaultContext>(_ctx, getState());
  enterRule(_localctx, 382, FandangoParser::RuleLambda_param_no_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2762);
    lambda_param();
    setState(2764);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2763);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_param_with_defaultContext ------------------------------------------------------------------

FandangoParser::Lambda_param_with_defaultContext::Lambda_param_with_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Lambda_paramContext* FandangoParser::Lambda_param_with_defaultContext::lambda_param() {
  return getRuleContext<FandangoParser::Lambda_paramContext>(0);
}

FandangoParser::DefaultContext* FandangoParser::Lambda_param_with_defaultContext::default_() {
  return getRuleContext<FandangoParser::DefaultContext>(0);
}

tree::TerminalNode* FandangoParser::Lambda_param_with_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Lambda_param_with_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_param_with_default;
}


std::any FandangoParser::Lambda_param_with_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_param_with_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_param_with_defaultContext* FandangoParser::lambda_param_with_default() {
  Lambda_param_with_defaultContext *_localctx = _tracker.createInstance<Lambda_param_with_defaultContext>(_ctx, getState());
  enterRule(_localctx, 384, FandangoParser::RuleLambda_param_with_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2766);
    lambda_param();
    setState(2767);
    default_();
    setState(2769);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2768);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_param_maybe_defaultContext ------------------------------------------------------------------

FandangoParser::Lambda_param_maybe_defaultContext::Lambda_param_maybe_defaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Lambda_paramContext* FandangoParser::Lambda_param_maybe_defaultContext::lambda_param() {
  return getRuleContext<FandangoParser::Lambda_paramContext>(0);
}

FandangoParser::DefaultContext* FandangoParser::Lambda_param_maybe_defaultContext::default_() {
  return getRuleContext<FandangoParser::DefaultContext>(0);
}

tree::TerminalNode* FandangoParser::Lambda_param_maybe_defaultContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::Lambda_param_maybe_defaultContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_param_maybe_default;
}


std::any FandangoParser::Lambda_param_maybe_defaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_param_maybe_default(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_param_maybe_defaultContext* FandangoParser::lambda_param_maybe_default() {
  Lambda_param_maybe_defaultContext *_localctx = _tracker.createInstance<Lambda_param_maybe_defaultContext>(_ctx, getState());
  enterRule(_localctx, 386, FandangoParser::RuleLambda_param_maybe_default);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2771);
    lambda_param();
    setState(2773);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::ASSIGN) {
      setState(2772);
      default_();
    }
    setState(2776);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(2775);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Lambda_paramContext ------------------------------------------------------------------

FandangoParser::Lambda_paramContext::Lambda_paramContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Lambda_paramContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}


size_t FandangoParser::Lambda_paramContext::getRuleIndex() const {
  return FandangoParser::RuleLambda_param;
}


std::any FandangoParser::Lambda_paramContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitLambda_param(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Lambda_paramContext* FandangoParser::lambda_param() {
  Lambda_paramContext *_localctx = _tracker.createInstance<Lambda_paramContext>(_ctx, getState());
  enterRule(_localctx, 388, FandangoParser::RuleLambda_param);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2778);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_middle_no_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_middle_no_quoteContext::Fstring_middle_no_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_replacement_fieldContext* FandangoParser::Fstring_middle_no_quoteContext::fstring_replacement_field() {
  return getRuleContext<FandangoParser::Fstring_replacement_fieldContext>(0);
}

FandangoParser::Fstring_any_no_quoteContext* FandangoParser::Fstring_middle_no_quoteContext::fstring_any_no_quote() {
  return getRuleContext<FandangoParser::Fstring_any_no_quoteContext>(0);
}


size_t FandangoParser::Fstring_middle_no_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_middle_no_quote;
}


std::any FandangoParser::Fstring_middle_no_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_middle_no_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_middle_no_quoteContext* FandangoParser::fstring_middle_no_quote() {
  Fstring_middle_no_quoteContext *_localctx = _tracker.createInstance<Fstring_middle_no_quoteContext>(_ctx, getState());
  enterRule(_localctx, 390, FandangoParser::RuleFstring_middle_no_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2782);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 339, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2780);
      fstring_replacement_field();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2781);
      fstring_any_no_quote();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_middle_no_single_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_middle_no_single_quoteContext::Fstring_middle_no_single_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_replacement_fieldContext* FandangoParser::Fstring_middle_no_single_quoteContext::fstring_replacement_field() {
  return getRuleContext<FandangoParser::Fstring_replacement_fieldContext>(0);
}

FandangoParser::Fstring_any_no_single_quoteContext* FandangoParser::Fstring_middle_no_single_quoteContext::fstring_any_no_single_quote() {
  return getRuleContext<FandangoParser::Fstring_any_no_single_quoteContext>(0);
}


size_t FandangoParser::Fstring_middle_no_single_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_middle_no_single_quote;
}


std::any FandangoParser::Fstring_middle_no_single_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_middle_no_single_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_middle_no_single_quoteContext* FandangoParser::fstring_middle_no_single_quote() {
  Fstring_middle_no_single_quoteContext *_localctx = _tracker.createInstance<Fstring_middle_no_single_quoteContext>(_ctx, getState());
  enterRule(_localctx, 392, FandangoParser::RuleFstring_middle_no_single_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2786);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 340, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2784);
      fstring_replacement_field();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2785);
      fstring_any_no_single_quote();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_middle_breaks_no_triple_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_middle_breaks_no_triple_quoteContext::Fstring_middle_breaks_no_triple_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_replacement_fieldContext* FandangoParser::Fstring_middle_breaks_no_triple_quoteContext::fstring_replacement_field() {
  return getRuleContext<FandangoParser::Fstring_replacement_fieldContext>(0);
}

FandangoParser::Fstring_any_breaks_no_triple_quoteContext* FandangoParser::Fstring_middle_breaks_no_triple_quoteContext::fstring_any_breaks_no_triple_quote() {
  return getRuleContext<FandangoParser::Fstring_any_breaks_no_triple_quoteContext>(0);
}


size_t FandangoParser::Fstring_middle_breaks_no_triple_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_middle_breaks_no_triple_quote;
}


std::any FandangoParser::Fstring_middle_breaks_no_triple_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_middle_breaks_no_triple_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_middle_breaks_no_triple_quoteContext* FandangoParser::fstring_middle_breaks_no_triple_quote() {
  Fstring_middle_breaks_no_triple_quoteContext *_localctx = _tracker.createInstance<Fstring_middle_breaks_no_triple_quoteContext>(_ctx, getState());
  enterRule(_localctx, 394, FandangoParser::RuleFstring_middle_breaks_no_triple_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2790);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 341, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2788);
      fstring_replacement_field();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2789);
      fstring_any_breaks_no_triple_quote();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_middle_breaks_no_triple_single_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext::Fstring_middle_breaks_no_triple_single_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_replacement_fieldContext* FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext::fstring_replacement_field() {
  return getRuleContext<FandangoParser::Fstring_replacement_fieldContext>(0);
}

FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext* FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext::fstring_any_breaks_no_triple_single_quote() {
  return getRuleContext<FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext>(0);
}


size_t FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_middle_breaks_no_triple_single_quote;
}


std::any FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_middle_breaks_no_triple_single_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext* FandangoParser::fstring_middle_breaks_no_triple_single_quote() {
  Fstring_middle_breaks_no_triple_single_quoteContext *_localctx = _tracker.createInstance<Fstring_middle_breaks_no_triple_single_quoteContext>(_ctx, getState());
  enterRule(_localctx, 396, FandangoParser::RuleFstring_middle_breaks_no_triple_single_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2794);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 342, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2792);
      fstring_replacement_field();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2793);
      fstring_any_breaks_no_triple_single_quote();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_any_no_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_any_no_quoteContext::Fstring_any_no_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_anyContext* FandangoParser::Fstring_any_no_quoteContext::fstring_any() {
  return getRuleContext<FandangoParser::Fstring_anyContext>(0);
}

tree::TerminalNode* FandangoParser::Fstring_any_no_quoteContext::FSTRING_END_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_SINGLE_QUOTE, 0);
}

tree::TerminalNode* FandangoParser::Fstring_any_no_quoteContext::FSTRING_END_TRIPLE_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_TRIPLE_SINGLE_QUOTE, 0);
}


size_t FandangoParser::Fstring_any_no_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_any_no_quote;
}


std::any FandangoParser::Fstring_any_no_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_any_no_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_any_no_quoteContext* FandangoParser::fstring_any_no_quote() {
  Fstring_any_no_quoteContext *_localctx = _tracker.createInstance<Fstring_any_no_quoteContext>(_ctx, getState());
  enterRule(_localctx, 398, FandangoParser::RuleFstring_any_no_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2799);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NUMBER:
      case FandangoParser::PYTHON_START:
      case FandangoParser::PYTHON_END:
      case FandangoParser::AND:
      case FandangoParser::AS:
      case FandangoParser::ASSERT:
      case FandangoParser::ASYNC:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CASE:
      case FandangoParser::CLASS:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEF:
      case FandangoParser::DEL:
      case FandangoParser::ELIF:
      case FandangoParser::ELSE:
      case FandangoParser::EXCEPT:
      case FandangoParser::FALSE:
      case FandangoParser::FINALLY:
      case FandangoParser::FOR:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IF:
      case FandangoParser::IMPORT:
      case FandangoParser::IN:
      case FandangoParser::IS:
      case FandangoParser::LAMBDA:
      case FandangoParser::MATCH:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::OR:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TRY:
      case FandangoParser::TYPE:
      case FandangoParser::WHILE:
      case FandangoParser::WHERE:
      case FandangoParser::WITH:
      case FandangoParser::YIELD:
      case FandangoParser::FORALL:
      case FandangoParser::EXISTS:
      case FandangoParser::MAXIMIZING:
      case FandangoParser::MINIMIZING:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::GRAMMAR_ASSIGN:
      case FandangoParser::QUESTION:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::DOTDOT:
      case FandangoParser::DOT:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::CLOSE_PAREN:
      case FandangoParser::COMMA:
      case FandangoParser::COLON:
      case FandangoParser::SEMI_COLON:
      case FandangoParser::POWER:
      case FandangoParser::ASSIGN:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::CLOSE_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::XOR:
      case FandangoParser::AND_OP:
      case FandangoParser::LEFT_SHIFT:
      case FandangoParser::RIGHT_SHIFT:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::DIV:
      case FandangoParser::MOD:
      case FandangoParser::IDIV:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::CLOSE_BRACE:
      case FandangoParser::LESS_THAN:
      case FandangoParser::GREATER_THAN:
      case FandangoParser::EQUALS:
      case FandangoParser::GT_EQ:
      case FandangoParser::LT_EQ:
      case FandangoParser::NOT_EQ_1:
      case FandangoParser::NOT_EQ_2:
      case FandangoParser::AT:
      case FandangoParser::ARROW:
      case FandangoParser::ADD_ASSIGN:
      case FandangoParser::SUB_ASSIGN:
      case FandangoParser::MULT_ASSIGN:
      case FandangoParser::AT_ASSIGN:
      case FandangoParser::DIV_ASSIGN:
      case FandangoParser::MOD_ASSIGN:
      case FandangoParser::AND_ASSIGN:
      case FandangoParser::OR_ASSIGN:
      case FandangoParser::XOR_ASSIGN:
      case FandangoParser::LEFT_SHIFT_ASSIGN:
      case FandangoParser::RIGHT_SHIFT_ASSIGN:
      case FandangoParser::POWER_ASSIGN:
      case FandangoParser::IDIV_ASSIGN:
      case FandangoParser::EXPR_ASSIGN:
      case FandangoParser::EXCL:
      case FandangoParser::SKIP_:
      case FandangoParser::UNKNOWN_CHAR: {
        enterOuterAlt(_localctx, 1);
        setState(2796);
        fstring_any();
        break;
      }

      case FandangoParser::FSTRING_END_SINGLE_QUOTE: {
        enterOuterAlt(_localctx, 2);
        setState(2797);
        match(FandangoParser::FSTRING_END_SINGLE_QUOTE);
        break;
      }

      case FandangoParser::FSTRING_END_TRIPLE_SINGLE_QUOTE: {
        enterOuterAlt(_localctx, 3);
        setState(2798);
        match(FandangoParser::FSTRING_END_TRIPLE_SINGLE_QUOTE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_any_no_single_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_any_no_single_quoteContext::Fstring_any_no_single_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_anyContext* FandangoParser::Fstring_any_no_single_quoteContext::fstring_any() {
  return getRuleContext<FandangoParser::Fstring_anyContext>(0);
}

tree::TerminalNode* FandangoParser::Fstring_any_no_single_quoteContext::FSTRING_END_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_QUOTE, 0);
}

tree::TerminalNode* FandangoParser::Fstring_any_no_single_quoteContext::FSTRING_END_TRIPLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_TRIPLE_QUOTE, 0);
}


size_t FandangoParser::Fstring_any_no_single_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_any_no_single_quote;
}


std::any FandangoParser::Fstring_any_no_single_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_any_no_single_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_any_no_single_quoteContext* FandangoParser::fstring_any_no_single_quote() {
  Fstring_any_no_single_quoteContext *_localctx = _tracker.createInstance<Fstring_any_no_single_quoteContext>(_ctx, getState());
  enterRule(_localctx, 400, FandangoParser::RuleFstring_any_no_single_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2804);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NUMBER:
      case FandangoParser::PYTHON_START:
      case FandangoParser::PYTHON_END:
      case FandangoParser::AND:
      case FandangoParser::AS:
      case FandangoParser::ASSERT:
      case FandangoParser::ASYNC:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CASE:
      case FandangoParser::CLASS:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEF:
      case FandangoParser::DEL:
      case FandangoParser::ELIF:
      case FandangoParser::ELSE:
      case FandangoParser::EXCEPT:
      case FandangoParser::FALSE:
      case FandangoParser::FINALLY:
      case FandangoParser::FOR:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IF:
      case FandangoParser::IMPORT:
      case FandangoParser::IN:
      case FandangoParser::IS:
      case FandangoParser::LAMBDA:
      case FandangoParser::MATCH:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::OR:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TRY:
      case FandangoParser::TYPE:
      case FandangoParser::WHILE:
      case FandangoParser::WHERE:
      case FandangoParser::WITH:
      case FandangoParser::YIELD:
      case FandangoParser::FORALL:
      case FandangoParser::EXISTS:
      case FandangoParser::MAXIMIZING:
      case FandangoParser::MINIMIZING:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::GRAMMAR_ASSIGN:
      case FandangoParser::QUESTION:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::DOTDOT:
      case FandangoParser::DOT:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::CLOSE_PAREN:
      case FandangoParser::COMMA:
      case FandangoParser::COLON:
      case FandangoParser::SEMI_COLON:
      case FandangoParser::POWER:
      case FandangoParser::ASSIGN:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::CLOSE_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::XOR:
      case FandangoParser::AND_OP:
      case FandangoParser::LEFT_SHIFT:
      case FandangoParser::RIGHT_SHIFT:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::DIV:
      case FandangoParser::MOD:
      case FandangoParser::IDIV:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::CLOSE_BRACE:
      case FandangoParser::LESS_THAN:
      case FandangoParser::GREATER_THAN:
      case FandangoParser::EQUALS:
      case FandangoParser::GT_EQ:
      case FandangoParser::LT_EQ:
      case FandangoParser::NOT_EQ_1:
      case FandangoParser::NOT_EQ_2:
      case FandangoParser::AT:
      case FandangoParser::ARROW:
      case FandangoParser::ADD_ASSIGN:
      case FandangoParser::SUB_ASSIGN:
      case FandangoParser::MULT_ASSIGN:
      case FandangoParser::AT_ASSIGN:
      case FandangoParser::DIV_ASSIGN:
      case FandangoParser::MOD_ASSIGN:
      case FandangoParser::AND_ASSIGN:
      case FandangoParser::OR_ASSIGN:
      case FandangoParser::XOR_ASSIGN:
      case FandangoParser::LEFT_SHIFT_ASSIGN:
      case FandangoParser::RIGHT_SHIFT_ASSIGN:
      case FandangoParser::POWER_ASSIGN:
      case FandangoParser::IDIV_ASSIGN:
      case FandangoParser::EXPR_ASSIGN:
      case FandangoParser::EXCL:
      case FandangoParser::SKIP_:
      case FandangoParser::UNKNOWN_CHAR: {
        enterOuterAlt(_localctx, 1);
        setState(2801);
        fstring_any();
        break;
      }

      case FandangoParser::FSTRING_END_QUOTE: {
        enterOuterAlt(_localctx, 2);
        setState(2802);
        match(FandangoParser::FSTRING_END_QUOTE);
        break;
      }

      case FandangoParser::FSTRING_END_TRIPLE_QUOTE: {
        enterOuterAlt(_localctx, 3);
        setState(2803);
        match(FandangoParser::FSTRING_END_TRIPLE_QUOTE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_middleContext ------------------------------------------------------------------

FandangoParser::Fstring_middleContext::Fstring_middleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_anyContext* FandangoParser::Fstring_middleContext::fstring_any() {
  return getRuleContext<FandangoParser::Fstring_anyContext>(0);
}

tree::TerminalNode* FandangoParser::Fstring_middleContext::FSTRING_END_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_SINGLE_QUOTE, 0);
}

tree::TerminalNode* FandangoParser::Fstring_middleContext::FSTRING_END_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_QUOTE, 0);
}


size_t FandangoParser::Fstring_middleContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_middle;
}


std::any FandangoParser::Fstring_middleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_middle(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_middleContext* FandangoParser::fstring_middle() {
  Fstring_middleContext *_localctx = _tracker.createInstance<Fstring_middleContext>(_ctx, getState());
  enterRule(_localctx, 402, FandangoParser::RuleFstring_middle);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2809);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NUMBER:
      case FandangoParser::PYTHON_START:
      case FandangoParser::PYTHON_END:
      case FandangoParser::AND:
      case FandangoParser::AS:
      case FandangoParser::ASSERT:
      case FandangoParser::ASYNC:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CASE:
      case FandangoParser::CLASS:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEF:
      case FandangoParser::DEL:
      case FandangoParser::ELIF:
      case FandangoParser::ELSE:
      case FandangoParser::EXCEPT:
      case FandangoParser::FALSE:
      case FandangoParser::FINALLY:
      case FandangoParser::FOR:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IF:
      case FandangoParser::IMPORT:
      case FandangoParser::IN:
      case FandangoParser::IS:
      case FandangoParser::LAMBDA:
      case FandangoParser::MATCH:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::OR:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TRY:
      case FandangoParser::TYPE:
      case FandangoParser::WHILE:
      case FandangoParser::WHERE:
      case FandangoParser::WITH:
      case FandangoParser::YIELD:
      case FandangoParser::FORALL:
      case FandangoParser::EXISTS:
      case FandangoParser::MAXIMIZING:
      case FandangoParser::MINIMIZING:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::GRAMMAR_ASSIGN:
      case FandangoParser::QUESTION:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::DOTDOT:
      case FandangoParser::DOT:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::CLOSE_PAREN:
      case FandangoParser::COMMA:
      case FandangoParser::COLON:
      case FandangoParser::SEMI_COLON:
      case FandangoParser::POWER:
      case FandangoParser::ASSIGN:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::CLOSE_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::XOR:
      case FandangoParser::AND_OP:
      case FandangoParser::LEFT_SHIFT:
      case FandangoParser::RIGHT_SHIFT:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::DIV:
      case FandangoParser::MOD:
      case FandangoParser::IDIV:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::CLOSE_BRACE:
      case FandangoParser::LESS_THAN:
      case FandangoParser::GREATER_THAN:
      case FandangoParser::EQUALS:
      case FandangoParser::GT_EQ:
      case FandangoParser::LT_EQ:
      case FandangoParser::NOT_EQ_1:
      case FandangoParser::NOT_EQ_2:
      case FandangoParser::AT:
      case FandangoParser::ARROW:
      case FandangoParser::ADD_ASSIGN:
      case FandangoParser::SUB_ASSIGN:
      case FandangoParser::MULT_ASSIGN:
      case FandangoParser::AT_ASSIGN:
      case FandangoParser::DIV_ASSIGN:
      case FandangoParser::MOD_ASSIGN:
      case FandangoParser::AND_ASSIGN:
      case FandangoParser::OR_ASSIGN:
      case FandangoParser::XOR_ASSIGN:
      case FandangoParser::LEFT_SHIFT_ASSIGN:
      case FandangoParser::RIGHT_SHIFT_ASSIGN:
      case FandangoParser::POWER_ASSIGN:
      case FandangoParser::IDIV_ASSIGN:
      case FandangoParser::EXPR_ASSIGN:
      case FandangoParser::EXCL:
      case FandangoParser::SKIP_:
      case FandangoParser::UNKNOWN_CHAR: {
        enterOuterAlt(_localctx, 1);
        setState(2806);
        fstring_any();
        break;
      }

      case FandangoParser::FSTRING_END_SINGLE_QUOTE: {
        enterOuterAlt(_localctx, 2);
        setState(2807);
        match(FandangoParser::FSTRING_END_SINGLE_QUOTE);
        break;
      }

      case FandangoParser::FSTRING_END_QUOTE: {
        enterOuterAlt(_localctx, 3);
        setState(2808);
        match(FandangoParser::FSTRING_END_QUOTE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_any_breaks_no_triple_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_any_breaks_no_triple_quoteContext::Fstring_any_breaks_no_triple_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_anyContext* FandangoParser::Fstring_any_breaks_no_triple_quoteContext::fstring_any() {
  return getRuleContext<FandangoParser::Fstring_anyContext>(0);
}

tree::TerminalNode* FandangoParser::Fstring_any_breaks_no_triple_quoteContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}

tree::TerminalNode* FandangoParser::Fstring_any_breaks_no_triple_quoteContext::FSTRING_END_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_SINGLE_QUOTE, 0);
}


size_t FandangoParser::Fstring_any_breaks_no_triple_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_any_breaks_no_triple_quote;
}


std::any FandangoParser::Fstring_any_breaks_no_triple_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_any_breaks_no_triple_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_any_breaks_no_triple_quoteContext* FandangoParser::fstring_any_breaks_no_triple_quote() {
  Fstring_any_breaks_no_triple_quoteContext *_localctx = _tracker.createInstance<Fstring_any_breaks_no_triple_quoteContext>(_ctx, getState());
  enterRule(_localctx, 404, FandangoParser::RuleFstring_any_breaks_no_triple_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2814);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NUMBER:
      case FandangoParser::PYTHON_START:
      case FandangoParser::PYTHON_END:
      case FandangoParser::AND:
      case FandangoParser::AS:
      case FandangoParser::ASSERT:
      case FandangoParser::ASYNC:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CASE:
      case FandangoParser::CLASS:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEF:
      case FandangoParser::DEL:
      case FandangoParser::ELIF:
      case FandangoParser::ELSE:
      case FandangoParser::EXCEPT:
      case FandangoParser::FALSE:
      case FandangoParser::FINALLY:
      case FandangoParser::FOR:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IF:
      case FandangoParser::IMPORT:
      case FandangoParser::IN:
      case FandangoParser::IS:
      case FandangoParser::LAMBDA:
      case FandangoParser::MATCH:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::OR:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TRY:
      case FandangoParser::TYPE:
      case FandangoParser::WHILE:
      case FandangoParser::WHERE:
      case FandangoParser::WITH:
      case FandangoParser::YIELD:
      case FandangoParser::FORALL:
      case FandangoParser::EXISTS:
      case FandangoParser::MAXIMIZING:
      case FandangoParser::MINIMIZING:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::GRAMMAR_ASSIGN:
      case FandangoParser::QUESTION:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::DOTDOT:
      case FandangoParser::DOT:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::CLOSE_PAREN:
      case FandangoParser::COMMA:
      case FandangoParser::COLON:
      case FandangoParser::SEMI_COLON:
      case FandangoParser::POWER:
      case FandangoParser::ASSIGN:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::CLOSE_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::XOR:
      case FandangoParser::AND_OP:
      case FandangoParser::LEFT_SHIFT:
      case FandangoParser::RIGHT_SHIFT:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::DIV:
      case FandangoParser::MOD:
      case FandangoParser::IDIV:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::CLOSE_BRACE:
      case FandangoParser::LESS_THAN:
      case FandangoParser::GREATER_THAN:
      case FandangoParser::EQUALS:
      case FandangoParser::GT_EQ:
      case FandangoParser::LT_EQ:
      case FandangoParser::NOT_EQ_1:
      case FandangoParser::NOT_EQ_2:
      case FandangoParser::AT:
      case FandangoParser::ARROW:
      case FandangoParser::ADD_ASSIGN:
      case FandangoParser::SUB_ASSIGN:
      case FandangoParser::MULT_ASSIGN:
      case FandangoParser::AT_ASSIGN:
      case FandangoParser::DIV_ASSIGN:
      case FandangoParser::MOD_ASSIGN:
      case FandangoParser::AND_ASSIGN:
      case FandangoParser::OR_ASSIGN:
      case FandangoParser::XOR_ASSIGN:
      case FandangoParser::LEFT_SHIFT_ASSIGN:
      case FandangoParser::RIGHT_SHIFT_ASSIGN:
      case FandangoParser::POWER_ASSIGN:
      case FandangoParser::IDIV_ASSIGN:
      case FandangoParser::EXPR_ASSIGN:
      case FandangoParser::EXCL:
      case FandangoParser::SKIP_:
      case FandangoParser::UNKNOWN_CHAR: {
        enterOuterAlt(_localctx, 1);
        setState(2811);
        fstring_any();
        break;
      }

      case FandangoParser::NEWLINE: {
        enterOuterAlt(_localctx, 2);
        setState(2812);
        match(FandangoParser::NEWLINE);
        break;
      }

      case FandangoParser::FSTRING_END_SINGLE_QUOTE: {
        enterOuterAlt(_localctx, 3);
        setState(2813);
        match(FandangoParser::FSTRING_END_SINGLE_QUOTE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_any_breaks_no_triple_single_quoteContext ------------------------------------------------------------------

FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext::Fstring_any_breaks_no_triple_single_quoteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_anyContext* FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext::fstring_any() {
  return getRuleContext<FandangoParser::Fstring_anyContext>(0);
}

tree::TerminalNode* FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}

tree::TerminalNode* FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext::FSTRING_END_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_QUOTE, 0);
}


size_t FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_any_breaks_no_triple_single_quote;
}


std::any FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_any_breaks_no_triple_single_quote(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_any_breaks_no_triple_single_quoteContext* FandangoParser::fstring_any_breaks_no_triple_single_quote() {
  Fstring_any_breaks_no_triple_single_quoteContext *_localctx = _tracker.createInstance<Fstring_any_breaks_no_triple_single_quoteContext>(_ctx, getState());
  enterRule(_localctx, 406, FandangoParser::RuleFstring_any_breaks_no_triple_single_quote);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2819);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::NUMBER:
      case FandangoParser::PYTHON_START:
      case FandangoParser::PYTHON_END:
      case FandangoParser::AND:
      case FandangoParser::AS:
      case FandangoParser::ASSERT:
      case FandangoParser::ASYNC:
      case FandangoParser::AWAIT:
      case FandangoParser::BREAK:
      case FandangoParser::CASE:
      case FandangoParser::CLASS:
      case FandangoParser::CONTINUE:
      case FandangoParser::DEF:
      case FandangoParser::DEL:
      case FandangoParser::ELIF:
      case FandangoParser::ELSE:
      case FandangoParser::EXCEPT:
      case FandangoParser::FALSE:
      case FandangoParser::FINALLY:
      case FandangoParser::FOR:
      case FandangoParser::FROM:
      case FandangoParser::GLOBAL:
      case FandangoParser::IF:
      case FandangoParser::IMPORT:
      case FandangoParser::IN:
      case FandangoParser::IS:
      case FandangoParser::LAMBDA:
      case FandangoParser::MATCH:
      case FandangoParser::NONE:
      case FandangoParser::NONLOCAL:
      case FandangoParser::NOT:
      case FandangoParser::OR:
      case FandangoParser::PASS:
      case FandangoParser::RAISE:
      case FandangoParser::RETURN:
      case FandangoParser::TRUE:
      case FandangoParser::TRY:
      case FandangoParser::TYPE:
      case FandangoParser::WHILE:
      case FandangoParser::WHERE:
      case FandangoParser::WITH:
      case FandangoParser::YIELD:
      case FandangoParser::FORALL:
      case FandangoParser::EXISTS:
      case FandangoParser::MAXIMIZING:
      case FandangoParser::MINIMIZING:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::GRAMMAR_ASSIGN:
      case FandangoParser::QUESTION:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::DOTDOT:
      case FandangoParser::DOT:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::CLOSE_PAREN:
      case FandangoParser::COMMA:
      case FandangoParser::COLON:
      case FandangoParser::SEMI_COLON:
      case FandangoParser::POWER:
      case FandangoParser::ASSIGN:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::CLOSE_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::XOR:
      case FandangoParser::AND_OP:
      case FandangoParser::LEFT_SHIFT:
      case FandangoParser::RIGHT_SHIFT:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::DIV:
      case FandangoParser::MOD:
      case FandangoParser::IDIV:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::CLOSE_BRACE:
      case FandangoParser::LESS_THAN:
      case FandangoParser::GREATER_THAN:
      case FandangoParser::EQUALS:
      case FandangoParser::GT_EQ:
      case FandangoParser::LT_EQ:
      case FandangoParser::NOT_EQ_1:
      case FandangoParser::NOT_EQ_2:
      case FandangoParser::AT:
      case FandangoParser::ARROW:
      case FandangoParser::ADD_ASSIGN:
      case FandangoParser::SUB_ASSIGN:
      case FandangoParser::MULT_ASSIGN:
      case FandangoParser::AT_ASSIGN:
      case FandangoParser::DIV_ASSIGN:
      case FandangoParser::MOD_ASSIGN:
      case FandangoParser::AND_ASSIGN:
      case FandangoParser::OR_ASSIGN:
      case FandangoParser::XOR_ASSIGN:
      case FandangoParser::LEFT_SHIFT_ASSIGN:
      case FandangoParser::RIGHT_SHIFT_ASSIGN:
      case FandangoParser::POWER_ASSIGN:
      case FandangoParser::IDIV_ASSIGN:
      case FandangoParser::EXPR_ASSIGN:
      case FandangoParser::EXCL:
      case FandangoParser::SKIP_:
      case FandangoParser::UNKNOWN_CHAR: {
        enterOuterAlt(_localctx, 1);
        setState(2816);
        fstring_any();
        break;
      }

      case FandangoParser::NEWLINE: {
        enterOuterAlt(_localctx, 2);
        setState(2817);
        match(FandangoParser::NEWLINE);
        break;
      }

      case FandangoParser::FSTRING_END_QUOTE: {
        enterOuterAlt(_localctx, 3);
        setState(2818);
        match(FandangoParser::FSTRING_END_QUOTE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_anyContext ------------------------------------------------------------------

FandangoParser::Fstring_anyContext::Fstring_anyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NUMBER() {
  return getTokens(FandangoParser::NUMBER);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NUMBER(size_t i) {
  return getToken(FandangoParser::NUMBER, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::PYTHON_START() {
  return getTokens(FandangoParser::PYTHON_START);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::PYTHON_START(size_t i) {
  return getToken(FandangoParser::PYTHON_START, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::PYTHON_END() {
  return getTokens(FandangoParser::PYTHON_END);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::PYTHON_END(size_t i) {
  return getToken(FandangoParser::PYTHON_END, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::AND() {
  return getTokens(FandangoParser::AND);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::AND(size_t i) {
  return getToken(FandangoParser::AND, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::AS() {
  return getTokens(FandangoParser::AS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::AS(size_t i) {
  return getToken(FandangoParser::AS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ASSERT() {
  return getTokens(FandangoParser::ASSERT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ASSERT(size_t i) {
  return getToken(FandangoParser::ASSERT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ASYNC() {
  return getTokens(FandangoParser::ASYNC);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ASYNC(size_t i) {
  return getToken(FandangoParser::ASYNC, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::AWAIT() {
  return getTokens(FandangoParser::AWAIT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::AWAIT(size_t i) {
  return getToken(FandangoParser::AWAIT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::BREAK() {
  return getTokens(FandangoParser::BREAK);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::BREAK(size_t i) {
  return getToken(FandangoParser::BREAK, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::CASE() {
  return getTokens(FandangoParser::CASE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::CASE(size_t i) {
  return getToken(FandangoParser::CASE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::CLASS() {
  return getTokens(FandangoParser::CLASS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::CLASS(size_t i) {
  return getToken(FandangoParser::CLASS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::CONTINUE() {
  return getTokens(FandangoParser::CONTINUE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::CONTINUE(size_t i) {
  return getToken(FandangoParser::CONTINUE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::DEF() {
  return getTokens(FandangoParser::DEF);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::DEF(size_t i) {
  return getToken(FandangoParser::DEF, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::DEL() {
  return getTokens(FandangoParser::DEL);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::DEL(size_t i) {
  return getToken(FandangoParser::DEL, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ELIF() {
  return getTokens(FandangoParser::ELIF);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ELIF(size_t i) {
  return getToken(FandangoParser::ELIF, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ELSE() {
  return getTokens(FandangoParser::ELSE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ELSE(size_t i) {
  return getToken(FandangoParser::ELSE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::EXCEPT() {
  return getTokens(FandangoParser::EXCEPT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::EXCEPT(size_t i) {
  return getToken(FandangoParser::EXCEPT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::FALSE() {
  return getTokens(FandangoParser::FALSE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::FALSE(size_t i) {
  return getToken(FandangoParser::FALSE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::FINALLY() {
  return getTokens(FandangoParser::FINALLY);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::FINALLY(size_t i) {
  return getToken(FandangoParser::FINALLY, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::FOR() {
  return getTokens(FandangoParser::FOR);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::FOR(size_t i) {
  return getToken(FandangoParser::FOR, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::FROM() {
  return getTokens(FandangoParser::FROM);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::FROM(size_t i) {
  return getToken(FandangoParser::FROM, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::GLOBAL() {
  return getTokens(FandangoParser::GLOBAL);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::GLOBAL(size_t i) {
  return getToken(FandangoParser::GLOBAL, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::IF() {
  return getTokens(FandangoParser::IF);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::IF(size_t i) {
  return getToken(FandangoParser::IF, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::IMPORT() {
  return getTokens(FandangoParser::IMPORT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::IMPORT(size_t i) {
  return getToken(FandangoParser::IMPORT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::IN() {
  return getTokens(FandangoParser::IN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::IN(size_t i) {
  return getToken(FandangoParser::IN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::IS() {
  return getTokens(FandangoParser::IS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::IS(size_t i) {
  return getToken(FandangoParser::IS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::LAMBDA() {
  return getTokens(FandangoParser::LAMBDA);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::LAMBDA(size_t i) {
  return getToken(FandangoParser::LAMBDA, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::MATCH() {
  return getTokens(FandangoParser::MATCH);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::MATCH(size_t i) {
  return getToken(FandangoParser::MATCH, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NONE() {
  return getTokens(FandangoParser::NONE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NONE(size_t i) {
  return getToken(FandangoParser::NONE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NONLOCAL() {
  return getTokens(FandangoParser::NONLOCAL);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NONLOCAL(size_t i) {
  return getToken(FandangoParser::NONLOCAL, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NOT() {
  return getTokens(FandangoParser::NOT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NOT(size_t i) {
  return getToken(FandangoParser::NOT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::OR() {
  return getTokens(FandangoParser::OR);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::OR(size_t i) {
  return getToken(FandangoParser::OR, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::PASS() {
  return getTokens(FandangoParser::PASS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::PASS(size_t i) {
  return getToken(FandangoParser::PASS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::RAISE() {
  return getTokens(FandangoParser::RAISE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::RAISE(size_t i) {
  return getToken(FandangoParser::RAISE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::RETURN() {
  return getTokens(FandangoParser::RETURN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::RETURN(size_t i) {
  return getToken(FandangoParser::RETURN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::TRUE() {
  return getTokens(FandangoParser::TRUE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::TRUE(size_t i) {
  return getToken(FandangoParser::TRUE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::TRY() {
  return getTokens(FandangoParser::TRY);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::TRY(size_t i) {
  return getToken(FandangoParser::TRY, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::TYPE() {
  return getTokens(FandangoParser::TYPE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::TYPE(size_t i) {
  return getToken(FandangoParser::TYPE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::WHILE() {
  return getTokens(FandangoParser::WHILE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::WHILE(size_t i) {
  return getToken(FandangoParser::WHILE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::WHERE() {
  return getTokens(FandangoParser::WHERE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::WHERE(size_t i) {
  return getToken(FandangoParser::WHERE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::WITH() {
  return getTokens(FandangoParser::WITH);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::WITH(size_t i) {
  return getToken(FandangoParser::WITH, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::YIELD() {
  return getTokens(FandangoParser::YIELD);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::YIELD(size_t i) {
  return getToken(FandangoParser::YIELD, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::FORALL() {
  return getTokens(FandangoParser::FORALL);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::FORALL(size_t i) {
  return getToken(FandangoParser::FORALL, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::EXISTS() {
  return getTokens(FandangoParser::EXISTS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::EXISTS(size_t i) {
  return getToken(FandangoParser::EXISTS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::MAXIMIZING() {
  return getTokens(FandangoParser::MAXIMIZING);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::MAXIMIZING(size_t i) {
  return getToken(FandangoParser::MAXIMIZING, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::MINIMIZING() {
  return getTokens(FandangoParser::MINIMIZING);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::MINIMIZING(size_t i) {
  return getToken(FandangoParser::MINIMIZING, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ANY() {
  return getTokens(FandangoParser::ANY);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ANY(size_t i) {
  return getToken(FandangoParser::ANY, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ALL() {
  return getTokens(FandangoParser::ALL);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ALL(size_t i) {
  return getToken(FandangoParser::ALL, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::LEN() {
  return getTokens(FandangoParser::LEN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::LEN(size_t i) {
  return getToken(FandangoParser::LEN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NAME() {
  return getTokens(FandangoParser::NAME);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NAME(size_t i) {
  return getToken(FandangoParser::NAME, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::GRAMMAR_ASSIGN() {
  return getTokens(FandangoParser::GRAMMAR_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::GRAMMAR_ASSIGN(size_t i) {
  return getToken(FandangoParser::GRAMMAR_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::QUESTION() {
  return getTokens(FandangoParser::QUESTION);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::QUESTION(size_t i) {
  return getToken(FandangoParser::QUESTION, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::DOT() {
  return getTokens(FandangoParser::DOT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::DOT(size_t i) {
  return getToken(FandangoParser::DOT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::DOTDOT() {
  return getTokens(FandangoParser::DOTDOT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::DOTDOT(size_t i) {
  return getToken(FandangoParser::DOTDOT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ELLIPSIS() {
  return getTokens(FandangoParser::ELLIPSIS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ELLIPSIS(size_t i) {
  return getToken(FandangoParser::ELLIPSIS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::STAR() {
  return getTokens(FandangoParser::STAR);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::STAR(size_t i) {
  return getToken(FandangoParser::STAR, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::OPEN_PAREN() {
  return getTokens(FandangoParser::OPEN_PAREN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::OPEN_PAREN(size_t i) {
  return getToken(FandangoParser::OPEN_PAREN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::CLOSE_PAREN() {
  return getTokens(FandangoParser::CLOSE_PAREN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::CLOSE_PAREN(size_t i) {
  return getToken(FandangoParser::CLOSE_PAREN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::COLON() {
  return getTokens(FandangoParser::COLON);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::COLON(size_t i) {
  return getToken(FandangoParser::COLON, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::SEMI_COLON() {
  return getTokens(FandangoParser::SEMI_COLON);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::SEMI_COLON(size_t i) {
  return getToken(FandangoParser::SEMI_COLON, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::POWER() {
  return getTokens(FandangoParser::POWER);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::POWER(size_t i) {
  return getToken(FandangoParser::POWER, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ASSIGN() {
  return getTokens(FandangoParser::ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ASSIGN(size_t i) {
  return getToken(FandangoParser::ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::OPEN_BRACK() {
  return getTokens(FandangoParser::OPEN_BRACK);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::OPEN_BRACK(size_t i) {
  return getToken(FandangoParser::OPEN_BRACK, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::CLOSE_BRACK() {
  return getTokens(FandangoParser::CLOSE_BRACK);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::CLOSE_BRACK(size_t i) {
  return getToken(FandangoParser::CLOSE_BRACK, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::OR_OP() {
  return getTokens(FandangoParser::OR_OP);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::OR_OP(size_t i) {
  return getToken(FandangoParser::OR_OP, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::XOR() {
  return getTokens(FandangoParser::XOR);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::XOR(size_t i) {
  return getToken(FandangoParser::XOR, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::AND_OP() {
  return getTokens(FandangoParser::AND_OP);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::AND_OP(size_t i) {
  return getToken(FandangoParser::AND_OP, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::LEFT_SHIFT() {
  return getTokens(FandangoParser::LEFT_SHIFT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::LEFT_SHIFT(size_t i) {
  return getToken(FandangoParser::LEFT_SHIFT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::RIGHT_SHIFT() {
  return getTokens(FandangoParser::RIGHT_SHIFT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::RIGHT_SHIFT(size_t i) {
  return getToken(FandangoParser::RIGHT_SHIFT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ADD() {
  return getTokens(FandangoParser::ADD);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ADD(size_t i) {
  return getToken(FandangoParser::ADD, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::MINUS() {
  return getTokens(FandangoParser::MINUS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::MINUS(size_t i) {
  return getToken(FandangoParser::MINUS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::DIV() {
  return getTokens(FandangoParser::DIV);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::DIV(size_t i) {
  return getToken(FandangoParser::DIV, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::MOD() {
  return getTokens(FandangoParser::MOD);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::MOD(size_t i) {
  return getToken(FandangoParser::MOD, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::IDIV() {
  return getTokens(FandangoParser::IDIV);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::IDIV(size_t i) {
  return getToken(FandangoParser::IDIV, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NOT_OP() {
  return getTokens(FandangoParser::NOT_OP);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NOT_OP(size_t i) {
  return getToken(FandangoParser::NOT_OP, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::OPEN_BRACE() {
  return getTokens(FandangoParser::OPEN_BRACE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::OPEN_BRACE(size_t i) {
  return getToken(FandangoParser::OPEN_BRACE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::CLOSE_BRACE() {
  return getTokens(FandangoParser::CLOSE_BRACE);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::CLOSE_BRACE(size_t i) {
  return getToken(FandangoParser::CLOSE_BRACE, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::LESS_THAN() {
  return getTokens(FandangoParser::LESS_THAN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::LESS_THAN(size_t i) {
  return getToken(FandangoParser::LESS_THAN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::GREATER_THAN() {
  return getTokens(FandangoParser::GREATER_THAN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::GREATER_THAN(size_t i) {
  return getToken(FandangoParser::GREATER_THAN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::EQUALS() {
  return getTokens(FandangoParser::EQUALS);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::EQUALS(size_t i) {
  return getToken(FandangoParser::EQUALS, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::GT_EQ() {
  return getTokens(FandangoParser::GT_EQ);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::GT_EQ(size_t i) {
  return getToken(FandangoParser::GT_EQ, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::LT_EQ() {
  return getTokens(FandangoParser::LT_EQ);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::LT_EQ(size_t i) {
  return getToken(FandangoParser::LT_EQ, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NOT_EQ_1() {
  return getTokens(FandangoParser::NOT_EQ_1);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NOT_EQ_1(size_t i) {
  return getToken(FandangoParser::NOT_EQ_1, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::NOT_EQ_2() {
  return getTokens(FandangoParser::NOT_EQ_2);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::NOT_EQ_2(size_t i) {
  return getToken(FandangoParser::NOT_EQ_2, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::AT() {
  return getTokens(FandangoParser::AT);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::AT(size_t i) {
  return getToken(FandangoParser::AT, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ARROW() {
  return getTokens(FandangoParser::ARROW);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ARROW(size_t i) {
  return getToken(FandangoParser::ARROW, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::ADD_ASSIGN() {
  return getTokens(FandangoParser::ADD_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::ADD_ASSIGN(size_t i) {
  return getToken(FandangoParser::ADD_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::SUB_ASSIGN() {
  return getTokens(FandangoParser::SUB_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::SUB_ASSIGN(size_t i) {
  return getToken(FandangoParser::SUB_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::MULT_ASSIGN() {
  return getTokens(FandangoParser::MULT_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::MULT_ASSIGN(size_t i) {
  return getToken(FandangoParser::MULT_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::AT_ASSIGN() {
  return getTokens(FandangoParser::AT_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::AT_ASSIGN(size_t i) {
  return getToken(FandangoParser::AT_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::DIV_ASSIGN() {
  return getTokens(FandangoParser::DIV_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::DIV_ASSIGN(size_t i) {
  return getToken(FandangoParser::DIV_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::MOD_ASSIGN() {
  return getTokens(FandangoParser::MOD_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::MOD_ASSIGN(size_t i) {
  return getToken(FandangoParser::MOD_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::AND_ASSIGN() {
  return getTokens(FandangoParser::AND_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::AND_ASSIGN(size_t i) {
  return getToken(FandangoParser::AND_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::OR_ASSIGN() {
  return getTokens(FandangoParser::OR_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::OR_ASSIGN(size_t i) {
  return getToken(FandangoParser::OR_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::XOR_ASSIGN() {
  return getTokens(FandangoParser::XOR_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::XOR_ASSIGN(size_t i) {
  return getToken(FandangoParser::XOR_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::LEFT_SHIFT_ASSIGN() {
  return getTokens(FandangoParser::LEFT_SHIFT_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::LEFT_SHIFT_ASSIGN(size_t i) {
  return getToken(FandangoParser::LEFT_SHIFT_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::RIGHT_SHIFT_ASSIGN() {
  return getTokens(FandangoParser::RIGHT_SHIFT_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::RIGHT_SHIFT_ASSIGN(size_t i) {
  return getToken(FandangoParser::RIGHT_SHIFT_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::POWER_ASSIGN() {
  return getTokens(FandangoParser::POWER_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::POWER_ASSIGN(size_t i) {
  return getToken(FandangoParser::POWER_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::IDIV_ASSIGN() {
  return getTokens(FandangoParser::IDIV_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::IDIV_ASSIGN(size_t i) {
  return getToken(FandangoParser::IDIV_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::EXPR_ASSIGN() {
  return getTokens(FandangoParser::EXPR_ASSIGN);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::EXPR_ASSIGN(size_t i) {
  return getToken(FandangoParser::EXPR_ASSIGN, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::EXCL() {
  return getTokens(FandangoParser::EXCL);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::EXCL(size_t i) {
  return getToken(FandangoParser::EXCL, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::SKIP_() {
  return getTokens(FandangoParser::SKIP_);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::SKIP_(size_t i) {
  return getToken(FandangoParser::SKIP_, i);
}

std::vector<tree::TerminalNode *> FandangoParser::Fstring_anyContext::UNKNOWN_CHAR() {
  return getTokens(FandangoParser::UNKNOWN_CHAR);
}

tree::TerminalNode* FandangoParser::Fstring_anyContext::UNKNOWN_CHAR(size_t i) {
  return getToken(FandangoParser::UNKNOWN_CHAR, i);
}


size_t FandangoParser::Fstring_anyContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_any;
}


std::any FandangoParser::Fstring_anyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_any(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_anyContext* FandangoParser::fstring_any() {
  Fstring_anyContext *_localctx = _tracker.createInstance<Fstring_anyContext>(_ctx, getState());
  enterRule(_localctx, 408, FandangoParser::RuleFstring_any);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2927); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(2927);
              _errHandler->sync(this);
              switch (_input->LA(1)) {
                case FandangoParser::NUMBER: {
                  setState(2821);
                  match(FandangoParser::NUMBER);
                  break;
                }

                case FandangoParser::PYTHON_START: {
                  setState(2822);
                  match(FandangoParser::PYTHON_START);
                  break;
                }

                case FandangoParser::PYTHON_END: {
                  setState(2823);
                  match(FandangoParser::PYTHON_END);
                  break;
                }

                case FandangoParser::AND: {
                  setState(2824);
                  match(FandangoParser::AND);
                  break;
                }

                case FandangoParser::AS: {
                  setState(2825);
                  match(FandangoParser::AS);
                  break;
                }

                case FandangoParser::ASSERT: {
                  setState(2826);
                  match(FandangoParser::ASSERT);
                  break;
                }

                case FandangoParser::ASYNC: {
                  setState(2827);
                  match(FandangoParser::ASYNC);
                  break;
                }

                case FandangoParser::AWAIT: {
                  setState(2828);
                  match(FandangoParser::AWAIT);
                  break;
                }

                case FandangoParser::BREAK: {
                  setState(2829);
                  match(FandangoParser::BREAK);
                  break;
                }

                case FandangoParser::CASE: {
                  setState(2830);
                  match(FandangoParser::CASE);
                  break;
                }

                case FandangoParser::CLASS: {
                  setState(2831);
                  match(FandangoParser::CLASS);
                  break;
                }

                case FandangoParser::CONTINUE: {
                  setState(2832);
                  match(FandangoParser::CONTINUE);
                  break;
                }

                case FandangoParser::DEF: {
                  setState(2833);
                  match(FandangoParser::DEF);
                  break;
                }

                case FandangoParser::DEL: {
                  setState(2834);
                  match(FandangoParser::DEL);
                  break;
                }

                case FandangoParser::ELIF: {
                  setState(2835);
                  match(FandangoParser::ELIF);
                  break;
                }

                case FandangoParser::ELSE: {
                  setState(2836);
                  match(FandangoParser::ELSE);
                  break;
                }

                case FandangoParser::EXCEPT: {
                  setState(2837);
                  match(FandangoParser::EXCEPT);
                  break;
                }

                case FandangoParser::FALSE: {
                  setState(2838);
                  match(FandangoParser::FALSE);
                  break;
                }

                case FandangoParser::FINALLY: {
                  setState(2839);
                  match(FandangoParser::FINALLY);
                  break;
                }

                case FandangoParser::FOR: {
                  setState(2840);
                  match(FandangoParser::FOR);
                  break;
                }

                case FandangoParser::FROM: {
                  setState(2841);
                  match(FandangoParser::FROM);
                  break;
                }

                case FandangoParser::GLOBAL: {
                  setState(2842);
                  match(FandangoParser::GLOBAL);
                  break;
                }

                case FandangoParser::IF: {
                  setState(2843);
                  match(FandangoParser::IF);
                  break;
                }

                case FandangoParser::IMPORT: {
                  setState(2844);
                  match(FandangoParser::IMPORT);
                  break;
                }

                case FandangoParser::IN: {
                  setState(2845);
                  match(FandangoParser::IN);
                  break;
                }

                case FandangoParser::IS: {
                  setState(2846);
                  match(FandangoParser::IS);
                  break;
                }

                case FandangoParser::LAMBDA: {
                  setState(2847);
                  match(FandangoParser::LAMBDA);
                  break;
                }

                case FandangoParser::MATCH: {
                  setState(2848);
                  match(FandangoParser::MATCH);
                  break;
                }

                case FandangoParser::NONE: {
                  setState(2849);
                  match(FandangoParser::NONE);
                  break;
                }

                case FandangoParser::NONLOCAL: {
                  setState(2850);
                  match(FandangoParser::NONLOCAL);
                  break;
                }

                case FandangoParser::NOT: {
                  setState(2851);
                  match(FandangoParser::NOT);
                  break;
                }

                case FandangoParser::OR: {
                  setState(2852);
                  match(FandangoParser::OR);
                  break;
                }

                case FandangoParser::PASS: {
                  setState(2853);
                  match(FandangoParser::PASS);
                  break;
                }

                case FandangoParser::RAISE: {
                  setState(2854);
                  match(FandangoParser::RAISE);
                  break;
                }

                case FandangoParser::RETURN: {
                  setState(2855);
                  match(FandangoParser::RETURN);
                  break;
                }

                case FandangoParser::TRUE: {
                  setState(2856);
                  match(FandangoParser::TRUE);
                  break;
                }

                case FandangoParser::TRY: {
                  setState(2857);
                  match(FandangoParser::TRY);
                  break;
                }

                case FandangoParser::TYPE: {
                  setState(2858);
                  match(FandangoParser::TYPE);
                  break;
                }

                case FandangoParser::WHILE: {
                  setState(2859);
                  match(FandangoParser::WHILE);
                  break;
                }

                case FandangoParser::WHERE: {
                  setState(2860);
                  match(FandangoParser::WHERE);
                  break;
                }

                case FandangoParser::WITH: {
                  setState(2861);
                  match(FandangoParser::WITH);
                  break;
                }

                case FandangoParser::YIELD: {
                  setState(2862);
                  match(FandangoParser::YIELD);
                  break;
                }

                case FandangoParser::FORALL: {
                  setState(2863);
                  match(FandangoParser::FORALL);
                  break;
                }

                case FandangoParser::EXISTS: {
                  setState(2864);
                  match(FandangoParser::EXISTS);
                  break;
                }

                case FandangoParser::MAXIMIZING: {
                  setState(2865);
                  match(FandangoParser::MAXIMIZING);
                  break;
                }

                case FandangoParser::MINIMIZING: {
                  setState(2866);
                  match(FandangoParser::MINIMIZING);
                  break;
                }

                case FandangoParser::ANY: {
                  setState(2867);
                  match(FandangoParser::ANY);
                  break;
                }

                case FandangoParser::ALL: {
                  setState(2868);
                  match(FandangoParser::ALL);
                  break;
                }

                case FandangoParser::LEN: {
                  setState(2869);
                  match(FandangoParser::LEN);
                  break;
                }

                case FandangoParser::NAME: {
                  setState(2870);
                  match(FandangoParser::NAME);
                  break;
                }

                case FandangoParser::GRAMMAR_ASSIGN: {
                  setState(2871);
                  match(FandangoParser::GRAMMAR_ASSIGN);
                  break;
                }

                case FandangoParser::QUESTION: {
                  setState(2872);
                  match(FandangoParser::QUESTION);
                  break;
                }

                case FandangoParser::DOT: {
                  setState(2873);
                  match(FandangoParser::DOT);
                  break;
                }

                case FandangoParser::DOTDOT: {
                  setState(2874);
                  match(FandangoParser::DOTDOT);
                  break;
                }

                case FandangoParser::ELLIPSIS: {
                  setState(2875);
                  match(FandangoParser::ELLIPSIS);
                  break;
                }

                case FandangoParser::STAR: {
                  setState(2876);
                  match(FandangoParser::STAR);
                  break;
                }

                case FandangoParser::OPEN_PAREN: {
                  setState(2877);
                  match(FandangoParser::OPEN_PAREN);
                  break;
                }

                case FandangoParser::CLOSE_PAREN: {
                  setState(2878);
                  match(FandangoParser::CLOSE_PAREN);
                  break;
                }

                case FandangoParser::COMMA: {
                  setState(2879);
                  match(FandangoParser::COMMA);
                  break;
                }

                case FandangoParser::COLON: {
                  setState(2880);
                  match(FandangoParser::COLON);
                  break;
                }

                case FandangoParser::SEMI_COLON: {
                  setState(2881);
                  match(FandangoParser::SEMI_COLON);
                  break;
                }

                case FandangoParser::POWER: {
                  setState(2882);
                  match(FandangoParser::POWER);
                  break;
                }

                case FandangoParser::ASSIGN: {
                  setState(2883);
                  match(FandangoParser::ASSIGN);
                  break;
                }

                case FandangoParser::OPEN_BRACK: {
                  setState(2884);
                  match(FandangoParser::OPEN_BRACK);
                  break;
                }

                case FandangoParser::CLOSE_BRACK: {
                  setState(2885);
                  match(FandangoParser::CLOSE_BRACK);
                  break;
                }

                case FandangoParser::OR_OP: {
                  setState(2886);
                  match(FandangoParser::OR_OP);
                  break;
                }

                case FandangoParser::XOR: {
                  setState(2887);
                  match(FandangoParser::XOR);
                  break;
                }

                case FandangoParser::AND_OP: {
                  setState(2888);
                  match(FandangoParser::AND_OP);
                  break;
                }

                case FandangoParser::LEFT_SHIFT: {
                  setState(2889);
                  match(FandangoParser::LEFT_SHIFT);
                  break;
                }

                case FandangoParser::RIGHT_SHIFT: {
                  setState(2890);
                  match(FandangoParser::RIGHT_SHIFT);
                  break;
                }

                case FandangoParser::ADD: {
                  setState(2891);
                  match(FandangoParser::ADD);
                  break;
                }

                case FandangoParser::MINUS: {
                  setState(2892);
                  match(FandangoParser::MINUS);
                  break;
                }

                case FandangoParser::DIV: {
                  setState(2893);
                  match(FandangoParser::DIV);
                  break;
                }

                case FandangoParser::MOD: {
                  setState(2894);
                  match(FandangoParser::MOD);
                  break;
                }

                case FandangoParser::IDIV: {
                  setState(2895);
                  match(FandangoParser::IDIV);
                  break;
                }

                case FandangoParser::NOT_OP: {
                  setState(2896);
                  match(FandangoParser::NOT_OP);
                  break;
                }

                case FandangoParser::OPEN_BRACE: {
                  setState(2897);
                  match(FandangoParser::OPEN_BRACE);
                  setState(2898);
                  match(FandangoParser::OPEN_BRACE);
                  break;
                }

                case FandangoParser::CLOSE_BRACE: {
                  setState(2899);
                  match(FandangoParser::CLOSE_BRACE);
                  setState(2900);
                  match(FandangoParser::CLOSE_BRACE);
                  break;
                }

                case FandangoParser::LESS_THAN: {
                  setState(2901);
                  match(FandangoParser::LESS_THAN);
                  break;
                }

                case FandangoParser::GREATER_THAN: {
                  setState(2902);
                  match(FandangoParser::GREATER_THAN);
                  break;
                }

                case FandangoParser::EQUALS: {
                  setState(2903);
                  match(FandangoParser::EQUALS);
                  break;
                }

                case FandangoParser::GT_EQ: {
                  setState(2904);
                  match(FandangoParser::GT_EQ);
                  break;
                }

                case FandangoParser::LT_EQ: {
                  setState(2905);
                  match(FandangoParser::LT_EQ);
                  break;
                }

                case FandangoParser::NOT_EQ_1: {
                  setState(2906);
                  match(FandangoParser::NOT_EQ_1);
                  break;
                }

                case FandangoParser::NOT_EQ_2: {
                  setState(2907);
                  match(FandangoParser::NOT_EQ_2);
                  break;
                }

                case FandangoParser::AT: {
                  setState(2908);
                  match(FandangoParser::AT);
                  break;
                }

                case FandangoParser::ARROW: {
                  setState(2909);
                  match(FandangoParser::ARROW);
                  break;
                }

                case FandangoParser::ADD_ASSIGN: {
                  setState(2910);
                  match(FandangoParser::ADD_ASSIGN);
                  break;
                }

                case FandangoParser::SUB_ASSIGN: {
                  setState(2911);
                  match(FandangoParser::SUB_ASSIGN);
                  break;
                }

                case FandangoParser::MULT_ASSIGN: {
                  setState(2912);
                  match(FandangoParser::MULT_ASSIGN);
                  break;
                }

                case FandangoParser::AT_ASSIGN: {
                  setState(2913);
                  match(FandangoParser::AT_ASSIGN);
                  break;
                }

                case FandangoParser::DIV_ASSIGN: {
                  setState(2914);
                  match(FandangoParser::DIV_ASSIGN);
                  break;
                }

                case FandangoParser::MOD_ASSIGN: {
                  setState(2915);
                  match(FandangoParser::MOD_ASSIGN);
                  break;
                }

                case FandangoParser::AND_ASSIGN: {
                  setState(2916);
                  match(FandangoParser::AND_ASSIGN);
                  break;
                }

                case FandangoParser::OR_ASSIGN: {
                  setState(2917);
                  match(FandangoParser::OR_ASSIGN);
                  break;
                }

                case FandangoParser::XOR_ASSIGN: {
                  setState(2918);
                  match(FandangoParser::XOR_ASSIGN);
                  break;
                }

                case FandangoParser::LEFT_SHIFT_ASSIGN: {
                  setState(2919);
                  match(FandangoParser::LEFT_SHIFT_ASSIGN);
                  break;
                }

                case FandangoParser::RIGHT_SHIFT_ASSIGN: {
                  setState(2920);
                  match(FandangoParser::RIGHT_SHIFT_ASSIGN);
                  break;
                }

                case FandangoParser::POWER_ASSIGN: {
                  setState(2921);
                  match(FandangoParser::POWER_ASSIGN);
                  break;
                }

                case FandangoParser::IDIV_ASSIGN: {
                  setState(2922);
                  match(FandangoParser::IDIV_ASSIGN);
                  break;
                }

                case FandangoParser::EXPR_ASSIGN: {
                  setState(2923);
                  match(FandangoParser::EXPR_ASSIGN);
                  break;
                }

                case FandangoParser::EXCL: {
                  setState(2924);
                  match(FandangoParser::EXCL);
                  break;
                }

                case FandangoParser::SKIP_: {
                  setState(2925);
                  match(FandangoParser::SKIP_);
                  break;
                }

                case FandangoParser::UNKNOWN_CHAR: {
                  setState(2926);
                  match(FandangoParser::UNKNOWN_CHAR);
                  break;
                }

              default:
                throw NoViableAltException(this);
              }
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(2929); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 349, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_replacement_fieldContext ------------------------------------------------------------------

FandangoParser::Fstring_replacement_fieldContext::Fstring_replacement_fieldContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Fstring_replacement_fieldContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

tree::TerminalNode* FandangoParser::Fstring_replacement_fieldContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}

FandangoParser::Yield_exprContext* FandangoParser::Fstring_replacement_fieldContext::yield_expr() {
  return getRuleContext<FandangoParser::Yield_exprContext>(0);
}

FandangoParser::Star_expressionsContext* FandangoParser::Fstring_replacement_fieldContext::star_expressions() {
  return getRuleContext<FandangoParser::Star_expressionsContext>(0);
}

tree::TerminalNode* FandangoParser::Fstring_replacement_fieldContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}

FandangoParser::Fstring_conversionContext* FandangoParser::Fstring_replacement_fieldContext::fstring_conversion() {
  return getRuleContext<FandangoParser::Fstring_conversionContext>(0);
}

FandangoParser::Fstring_full_format_specContext* FandangoParser::Fstring_replacement_fieldContext::fstring_full_format_spec() {
  return getRuleContext<FandangoParser::Fstring_full_format_specContext>(0);
}


size_t FandangoParser::Fstring_replacement_fieldContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_replacement_field;
}


std::any FandangoParser::Fstring_replacement_fieldContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_replacement_field(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_replacement_fieldContext* FandangoParser::fstring_replacement_field() {
  Fstring_replacement_fieldContext *_localctx = _tracker.createInstance<Fstring_replacement_fieldContext>(_ctx, getState());
  enterRule(_localctx, 410, FandangoParser::RuleFstring_replacement_field);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2931);
    match(FandangoParser::OPEN_BRACE);
    setState(2934);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::YIELD: {
        setState(2932);
        yield_expr();
        break;
      }

      case FandangoParser::FSTRING_START_QUOTE:
      case FandangoParser::FSTRING_START_SINGLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE:
      case FandangoParser::STRING:
      case FandangoParser::NUMBER:
      case FandangoParser::AWAIT:
      case FandangoParser::FALSE:
      case FandangoParser::LAMBDA:
      case FandangoParser::NONE:
      case FandangoParser::NOT:
      case FandangoParser::TRUE:
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME:
      case FandangoParser::ELLIPSIS:
      case FandangoParser::STAR:
      case FandangoParser::OPEN_PAREN:
      case FandangoParser::POWER:
      case FandangoParser::OPEN_BRACK:
      case FandangoParser::OR_OP:
      case FandangoParser::ADD:
      case FandangoParser::MINUS:
      case FandangoParser::NOT_OP:
      case FandangoParser::OPEN_BRACE:
      case FandangoParser::LESS_THAN: {
        setState(2933);
        star_expressions();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2937);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::ASSIGN) {
      setState(2936);
      match(FandangoParser::ASSIGN);
    }
    setState(2940);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::EXCL) {
      setState(2939);
      fstring_conversion();
    }
    setState(2943);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COLON) {
      setState(2942);
      fstring_full_format_spec();
    }
    setState(2945);
    match(FandangoParser::CLOSE_BRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_conversionContext ------------------------------------------------------------------

FandangoParser::Fstring_conversionContext::Fstring_conversionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Fstring_conversionContext::EXCL() {
  return getToken(FandangoParser::EXCL, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Fstring_conversionContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}


size_t FandangoParser::Fstring_conversionContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_conversion;
}


std::any FandangoParser::Fstring_conversionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_conversion(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_conversionContext* FandangoParser::fstring_conversion() {
  Fstring_conversionContext *_localctx = _tracker.createInstance<Fstring_conversionContext>(_ctx, getState());
  enterRule(_localctx, 412, FandangoParser::RuleFstring_conversion);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2947);
    match(FandangoParser::EXCL);
    setState(2948);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_full_format_specContext ------------------------------------------------------------------

FandangoParser::Fstring_full_format_specContext::Fstring_full_format_specContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Fstring_full_format_specContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}

std::vector<FandangoParser::Fstring_format_specContext *> FandangoParser::Fstring_full_format_specContext::fstring_format_spec() {
  return getRuleContexts<FandangoParser::Fstring_format_specContext>();
}

FandangoParser::Fstring_format_specContext* FandangoParser::Fstring_full_format_specContext::fstring_format_spec(size_t i) {
  return getRuleContext<FandangoParser::Fstring_format_specContext>(i);
}


size_t FandangoParser::Fstring_full_format_specContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_full_format_spec;
}


std::any FandangoParser::Fstring_full_format_specContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_full_format_spec(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_full_format_specContext* FandangoParser::fstring_full_format_spec() {
  Fstring_full_format_specContext *_localctx = _tracker.createInstance<Fstring_full_format_specContext>(_ctx, getState());
  enterRule(_localctx, 414, FandangoParser::RuleFstring_full_format_spec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2950);
    match(FandangoParser::COLON);
    setState(2954);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 354, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2951);
        fstring_format_spec(); 
      }
      setState(2956);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 354, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Fstring_format_specContext ------------------------------------------------------------------

FandangoParser::Fstring_format_specContext::Fstring_format_specContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Fstring_replacement_fieldContext* FandangoParser::Fstring_format_specContext::fstring_replacement_field() {
  return getRuleContext<FandangoParser::Fstring_replacement_fieldContext>(0);
}

FandangoParser::Fstring_middleContext* FandangoParser::Fstring_format_specContext::fstring_middle() {
  return getRuleContext<FandangoParser::Fstring_middleContext>(0);
}


size_t FandangoParser::Fstring_format_specContext::getRuleIndex() const {
  return FandangoParser::RuleFstring_format_spec;
}


std::any FandangoParser::Fstring_format_specContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring_format_spec(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Fstring_format_specContext* FandangoParser::fstring_format_spec() {
  Fstring_format_specContext *_localctx = _tracker.createInstance<Fstring_format_specContext>(_ctx, getState());
  enterRule(_localctx, 416, FandangoParser::RuleFstring_format_spec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2959);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 355, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2957);
      fstring_replacement_field();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2958);
      fstring_middle();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FstringContext ------------------------------------------------------------------

FandangoParser::FstringContext::FstringContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_START_QUOTE() {
  return getToken(FandangoParser::FSTRING_START_QUOTE, 0);
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_END_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_QUOTE, 0);
}

std::vector<FandangoParser::Fstring_middle_no_quoteContext *> FandangoParser::FstringContext::fstring_middle_no_quote() {
  return getRuleContexts<FandangoParser::Fstring_middle_no_quoteContext>();
}

FandangoParser::Fstring_middle_no_quoteContext* FandangoParser::FstringContext::fstring_middle_no_quote(size_t i) {
  return getRuleContext<FandangoParser::Fstring_middle_no_quoteContext>(i);
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_START_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_START_SINGLE_QUOTE, 0);
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_END_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_SINGLE_QUOTE, 0);
}

std::vector<FandangoParser::Fstring_middle_no_single_quoteContext *> FandangoParser::FstringContext::fstring_middle_no_single_quote() {
  return getRuleContexts<FandangoParser::Fstring_middle_no_single_quoteContext>();
}

FandangoParser::Fstring_middle_no_single_quoteContext* FandangoParser::FstringContext::fstring_middle_no_single_quote(size_t i) {
  return getRuleContext<FandangoParser::Fstring_middle_no_single_quoteContext>(i);
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_START_TRIPLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_START_TRIPLE_QUOTE, 0);
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_END_TRIPLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_TRIPLE_QUOTE, 0);
}

std::vector<FandangoParser::Fstring_middle_breaks_no_triple_quoteContext *> FandangoParser::FstringContext::fstring_middle_breaks_no_triple_quote() {
  return getRuleContexts<FandangoParser::Fstring_middle_breaks_no_triple_quoteContext>();
}

FandangoParser::Fstring_middle_breaks_no_triple_quoteContext* FandangoParser::FstringContext::fstring_middle_breaks_no_triple_quote(size_t i) {
  return getRuleContext<FandangoParser::Fstring_middle_breaks_no_triple_quoteContext>(i);
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_START_TRIPLE_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE, 0);
}

tree::TerminalNode* FandangoParser::FstringContext::FSTRING_END_TRIPLE_SINGLE_QUOTE() {
  return getToken(FandangoParser::FSTRING_END_TRIPLE_SINGLE_QUOTE, 0);
}

std::vector<FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext *> FandangoParser::FstringContext::fstring_middle_breaks_no_triple_single_quote() {
  return getRuleContexts<FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext>();
}

FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext* FandangoParser::FstringContext::fstring_middle_breaks_no_triple_single_quote(size_t i) {
  return getRuleContext<FandangoParser::Fstring_middle_breaks_no_triple_single_quoteContext>(i);
}


size_t FandangoParser::FstringContext::getRuleIndex() const {
  return FandangoParser::RuleFstring;
}


std::any FandangoParser::FstringContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFstring(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::FstringContext* FandangoParser::fstring() {
  FstringContext *_localctx = _tracker.createInstance<FstringContext>(_ctx, getState());
  enterRule(_localctx, 418, FandangoParser::RuleFstring);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2993);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::FSTRING_START_QUOTE: {
        enterOuterAlt(_localctx, 1);
        setState(2961);
        match(FandangoParser::FSTRING_START_QUOTE);
        setState(2965);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (((((_la - 8) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 8)) & 740842138635337725) != 0) || ((((_la - 75) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 75)) & 171136785840078843) != 0)) {
          setState(2962);
          fstring_middle_no_quote();
          setState(2967);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2968);
        match(FandangoParser::FSTRING_END_QUOTE);
        break;
      }

      case FandangoParser::FSTRING_START_SINGLE_QUOTE: {
        enterOuterAlt(_localctx, 2);
        setState(2969);
        match(FandangoParser::FSTRING_START_SINGLE_QUOTE);
        setState(2973);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (((((_la - 8) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 8)) & 380554168445698045) != 0) || ((((_la - 75) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 75)) & 171136785840078843) != 0)) {
          setState(2970);
          fstring_middle_no_single_quote();
          setState(2975);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2976);
        match(FandangoParser::FSTRING_END_SINGLE_QUOTE);
        break;
      }

      case FandangoParser::FSTRING_START_TRIPLE_QUOTE: {
        enterOuterAlt(_localctx, 3);
        setState(2977);
        match(FandangoParser::FSTRING_START_TRIPLE_QUOTE);
        setState(2981);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (((((_la - 8) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 8)) & 596726950559481853) != 0) || ((((_la - 75) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 75)) & 180143985094819835) != 0)) {
          setState(2978);
          fstring_middle_breaks_no_triple_quote();
          setState(2983);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2984);
        match(FandangoParser::FSTRING_END_TRIPLE_QUOTE);
        break;
      }

      case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE: {
        enterOuterAlt(_localctx, 4);
        setState(2985);
        match(FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE);
        setState(2989);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (((((_la - 8) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 8)) & 308496574407770109) != 0) || ((((_la - 75) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 75)) & 180143985094819835) != 0)) {
          setState(2986);
          fstring_middle_breaks_no_triple_single_quote();
          setState(2991);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2992);
        match(FandangoParser::FSTRING_END_TRIPLE_SINGLE_QUOTE);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StringContext ------------------------------------------------------------------

FandangoParser::StringContext::StringContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::StringContext::STRING() {
  return getToken(FandangoParser::STRING, 0);
}


size_t FandangoParser::StringContext::getRuleIndex() const {
  return FandangoParser::RuleString;
}


std::any FandangoParser::StringContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitString(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::StringContext* FandangoParser::string() {
  StringContext *_localctx = _tracker.createInstance<StringContext>(_ctx, getState());
  enterRule(_localctx, 420, FandangoParser::RuleString);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2995);
    match(FandangoParser::STRING);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StringsContext ------------------------------------------------------------------

FandangoParser::StringsContext::StringsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::FstringContext *> FandangoParser::StringsContext::fstring() {
  return getRuleContexts<FandangoParser::FstringContext>();
}

FandangoParser::FstringContext* FandangoParser::StringsContext::fstring(size_t i) {
  return getRuleContext<FandangoParser::FstringContext>(i);
}

std::vector<FandangoParser::StringContext *> FandangoParser::StringsContext::string() {
  return getRuleContexts<FandangoParser::StringContext>();
}

FandangoParser::StringContext* FandangoParser::StringsContext::string(size_t i) {
  return getRuleContext<FandangoParser::StringContext>(i);
}


size_t FandangoParser::StringsContext::getRuleIndex() const {
  return FandangoParser::RuleStrings;
}


std::any FandangoParser::StringsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStrings(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::StringsContext* FandangoParser::strings() {
  StringsContext *_localctx = _tracker.createInstance<StringsContext>(_ctx, getState());
  enterRule(_localctx, 422, FandangoParser::RuleStrings);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2999); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(2999);
              _errHandler->sync(this);
              switch (_input->LA(1)) {
                case FandangoParser::FSTRING_START_QUOTE:
                case FandangoParser::FSTRING_START_SINGLE_QUOTE:
                case FandangoParser::FSTRING_START_TRIPLE_QUOTE:
                case FandangoParser::FSTRING_START_TRIPLE_SINGLE_QUOTE: {
                  setState(2997);
                  fstring();
                  break;
                }

                case FandangoParser::STRING: {
                  setState(2998);
                  string();
                  break;
                }

              default:
                throw NoViableAltException(this);
              }
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(3001); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 362, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ListContext ------------------------------------------------------------------

FandangoParser::ListContext::ListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::ListContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

tree::TerminalNode* FandangoParser::ListContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

FandangoParser::Star_named_expressionsContext* FandangoParser::ListContext::star_named_expressions() {
  return getRuleContext<FandangoParser::Star_named_expressionsContext>(0);
}


size_t FandangoParser::ListContext::getRuleIndex() const {
  return FandangoParser::RuleList;
}


std::any FandangoParser::ListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitList(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ListContext* FandangoParser::list() {
  ListContext *_localctx = _tracker.createInstance<ListContext>(_ctx, getState());
  enterRule(_localctx, 424, FandangoParser::RuleList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3003);
    match(FandangoParser::OPEN_BRACK);
    setState(3005);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 93071897) != 0)) {
      setState(3004);
      star_named_expressions();
    }
    setState(3007);
    match(FandangoParser::CLOSE_BRACK);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TupleContext ------------------------------------------------------------------

FandangoParser::TupleContext::TupleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::TupleContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::TupleContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Star_named_expressionContext* FandangoParser::TupleContext::star_named_expression() {
  return getRuleContext<FandangoParser::Star_named_expressionContext>(0);
}

tree::TerminalNode* FandangoParser::TupleContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}

FandangoParser::Star_named_expressionsContext* FandangoParser::TupleContext::star_named_expressions() {
  return getRuleContext<FandangoParser::Star_named_expressionsContext>(0);
}


size_t FandangoParser::TupleContext::getRuleIndex() const {
  return FandangoParser::RuleTuple;
}


std::any FandangoParser::TupleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitTuple(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::TupleContext* FandangoParser::tuple() {
  TupleContext *_localctx = _tracker.createInstance<TupleContext>(_ctx, getState());
  enterRule(_localctx, 426, FandangoParser::RuleTuple);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3009);
    match(FandangoParser::OPEN_PAREN);
    setState(3014);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 93071897) != 0)) {
      setState(3010);
      star_named_expression();
      setState(3011);
      match(FandangoParser::COMMA);

      setState(3012);
      star_named_expressions();
    }
    setState(3016);
    match(FandangoParser::CLOSE_PAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetContext ------------------------------------------------------------------

FandangoParser::SetContext::SetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::SetContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

FandangoParser::Star_named_expressionsContext* FandangoParser::SetContext::star_named_expressions() {
  return getRuleContext<FandangoParser::Star_named_expressionsContext>(0);
}

tree::TerminalNode* FandangoParser::SetContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}


size_t FandangoParser::SetContext::getRuleIndex() const {
  return FandangoParser::RuleSet;
}


std::any FandangoParser::SetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSet(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::SetContext* FandangoParser::set() {
  SetContext *_localctx = _tracker.createInstance<SetContext>(_ctx, getState());
  enterRule(_localctx, 428, FandangoParser::RuleSet);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3018);
    match(FandangoParser::OPEN_BRACE);
    setState(3019);
    star_named_expressions();
    setState(3020);
    match(FandangoParser::CLOSE_BRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DictContext ------------------------------------------------------------------

FandangoParser::DictContext::DictContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::DictContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

tree::TerminalNode* FandangoParser::DictContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}

FandangoParser::Double_starred_kvpairsContext* FandangoParser::DictContext::double_starred_kvpairs() {
  return getRuleContext<FandangoParser::Double_starred_kvpairsContext>(0);
}


size_t FandangoParser::DictContext::getRuleIndex() const {
  return FandangoParser::RuleDict;
}


std::any FandangoParser::DictContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDict(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::DictContext* FandangoParser::dict() {
  DictContext *_localctx = _tracker.createInstance<DictContext>(_ctx, getState());
  enterRule(_localctx, 430, FandangoParser::RuleDict);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3022);
    match(FandangoParser::OPEN_BRACE);
    setState(3024);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 93071897) != 0)) {
      setState(3023);
      double_starred_kvpairs();
    }
    setState(3026);
    match(FandangoParser::CLOSE_BRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Double_starred_kvpairsContext ------------------------------------------------------------------

FandangoParser::Double_starred_kvpairsContext::Double_starred_kvpairsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Double_starred_kvpairContext *> FandangoParser::Double_starred_kvpairsContext::double_starred_kvpair() {
  return getRuleContexts<FandangoParser::Double_starred_kvpairContext>();
}

FandangoParser::Double_starred_kvpairContext* FandangoParser::Double_starred_kvpairsContext::double_starred_kvpair(size_t i) {
  return getRuleContext<FandangoParser::Double_starred_kvpairContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Double_starred_kvpairsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Double_starred_kvpairsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Double_starred_kvpairsContext::getRuleIndex() const {
  return FandangoParser::RuleDouble_starred_kvpairs;
}


std::any FandangoParser::Double_starred_kvpairsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDouble_starred_kvpairs(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Double_starred_kvpairsContext* FandangoParser::double_starred_kvpairs() {
  Double_starred_kvpairsContext *_localctx = _tracker.createInstance<Double_starred_kvpairsContext>(_ctx, getState());
  enterRule(_localctx, 432, FandangoParser::RuleDouble_starred_kvpairs);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3028);
    double_starred_kvpair();
    setState(3033);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 366, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3029);
        match(FandangoParser::COMMA);
        setState(3030);
        double_starred_kvpair(); 
      }
      setState(3035);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 366, _ctx);
    }
    setState(3037);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(3036);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Double_starred_kvpairContext ------------------------------------------------------------------

FandangoParser::Double_starred_kvpairContext::Double_starred_kvpairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Double_starred_kvpairContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}

FandangoParser::Bitwise_orContext* FandangoParser::Double_starred_kvpairContext::bitwise_or() {
  return getRuleContext<FandangoParser::Bitwise_orContext>(0);
}

FandangoParser::KvpairContext* FandangoParser::Double_starred_kvpairContext::kvpair() {
  return getRuleContext<FandangoParser::KvpairContext>(0);
}


size_t FandangoParser::Double_starred_kvpairContext::getRuleIndex() const {
  return FandangoParser::RuleDouble_starred_kvpair;
}


std::any FandangoParser::Double_starred_kvpairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDouble_starred_kvpair(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Double_starred_kvpairContext* FandangoParser::double_starred_kvpair() {
  Double_starred_kvpairContext *_localctx = _tracker.createInstance<Double_starred_kvpairContext>(_ctx, getState());
  enterRule(_localctx, 434, FandangoParser::RuleDouble_starred_kvpair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3042);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 368, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3039);
      match(FandangoParser::POWER);
      setState(3040);
      bitwise_or(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3041);
      kvpair();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KvpairContext ------------------------------------------------------------------

FandangoParser::KvpairContext::KvpairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::ExpressionContext *> FandangoParser::KvpairContext::expression() {
  return getRuleContexts<FandangoParser::ExpressionContext>();
}

FandangoParser::ExpressionContext* FandangoParser::KvpairContext::expression(size_t i) {
  return getRuleContext<FandangoParser::ExpressionContext>(i);
}

tree::TerminalNode* FandangoParser::KvpairContext::COLON() {
  return getToken(FandangoParser::COLON, 0);
}


size_t FandangoParser::KvpairContext::getRuleIndex() const {
  return FandangoParser::RuleKvpair;
}


std::any FandangoParser::KvpairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKvpair(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::KvpairContext* FandangoParser::kvpair() {
  KvpairContext *_localctx = _tracker.createInstance<KvpairContext>(_ctx, getState());
  enterRule(_localctx, 436, FandangoParser::RuleKvpair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3044);
    expression();
    setState(3045);
    match(FandangoParser::COLON);
    setState(3046);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- For_if_clausesContext ------------------------------------------------------------------

FandangoParser::For_if_clausesContext::For_if_clausesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::For_if_clauseContext *> FandangoParser::For_if_clausesContext::for_if_clause() {
  return getRuleContexts<FandangoParser::For_if_clauseContext>();
}

FandangoParser::For_if_clauseContext* FandangoParser::For_if_clausesContext::for_if_clause(size_t i) {
  return getRuleContext<FandangoParser::For_if_clauseContext>(i);
}


size_t FandangoParser::For_if_clausesContext::getRuleIndex() const {
  return FandangoParser::RuleFor_if_clauses;
}


std::any FandangoParser::For_if_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFor_if_clauses(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::For_if_clausesContext* FandangoParser::for_if_clauses() {
  For_if_clausesContext *_localctx = _tracker.createInstance<For_if_clausesContext>(_ctx, getState());
  enterRule(_localctx, 438, FandangoParser::RuleFor_if_clauses);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3049); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(3048);
      for_if_clause();
      setState(3051); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FandangoParser::ASYNC

    || _la == FandangoParser::FOR);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- For_if_clauseContext ------------------------------------------------------------------

FandangoParser::For_if_clauseContext::For_if_clauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::For_if_clauseContext::FOR() {
  return getToken(FandangoParser::FOR, 0);
}

FandangoParser::Star_targetsContext* FandangoParser::For_if_clauseContext::star_targets() {
  return getRuleContext<FandangoParser::Star_targetsContext>(0);
}

tree::TerminalNode* FandangoParser::For_if_clauseContext::IN() {
  return getToken(FandangoParser::IN, 0);
}

std::vector<FandangoParser::DisjunctionContext *> FandangoParser::For_if_clauseContext::disjunction() {
  return getRuleContexts<FandangoParser::DisjunctionContext>();
}

FandangoParser::DisjunctionContext* FandangoParser::For_if_clauseContext::disjunction(size_t i) {
  return getRuleContext<FandangoParser::DisjunctionContext>(i);
}

tree::TerminalNode* FandangoParser::For_if_clauseContext::ASYNC() {
  return getToken(FandangoParser::ASYNC, 0);
}

std::vector<tree::TerminalNode *> FandangoParser::For_if_clauseContext::IF() {
  return getTokens(FandangoParser::IF);
}

tree::TerminalNode* FandangoParser::For_if_clauseContext::IF(size_t i) {
  return getToken(FandangoParser::IF, i);
}


size_t FandangoParser::For_if_clauseContext::getRuleIndex() const {
  return FandangoParser::RuleFor_if_clause;
}


std::any FandangoParser::For_if_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFor_if_clause(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::For_if_clauseContext* FandangoParser::for_if_clause() {
  For_if_clauseContext *_localctx = _tracker.createInstance<For_if_clauseContext>(_ctx, getState());
  enterRule(_localctx, 440, FandangoParser::RuleFor_if_clause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3054);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::ASYNC) {
      setState(3053);
      match(FandangoParser::ASYNC);
    }
    setState(3056);
    match(FandangoParser::FOR);
    setState(3057);
    star_targets();
    setState(3058);
    match(FandangoParser::IN);
    setState(3059);
    disjunction();
    setState(3064);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FandangoParser::IF) {
      setState(3060);
      match(FandangoParser::IF);
      setState(3061);
      disjunction();
      setState(3066);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ListcompContext ------------------------------------------------------------------

FandangoParser::ListcompContext::ListcompContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::ListcompContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::Named_expressionContext* FandangoParser::ListcompContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}

FandangoParser::For_if_clausesContext* FandangoParser::ListcompContext::for_if_clauses() {
  return getRuleContext<FandangoParser::For_if_clausesContext>(0);
}

tree::TerminalNode* FandangoParser::ListcompContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}


size_t FandangoParser::ListcompContext::getRuleIndex() const {
  return FandangoParser::RuleListcomp;
}


std::any FandangoParser::ListcompContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitListcomp(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ListcompContext* FandangoParser::listcomp() {
  ListcompContext *_localctx = _tracker.createInstance<ListcompContext>(_ctx, getState());
  enterRule(_localctx, 442, FandangoParser::RuleListcomp);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3067);
    match(FandangoParser::OPEN_BRACK);
    setState(3068);
    named_expression();
    setState(3069);
    for_if_clauses();
    setState(3070);
    match(FandangoParser::CLOSE_BRACK);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetcompContext ------------------------------------------------------------------

FandangoParser::SetcompContext::SetcompContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::SetcompContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

FandangoParser::Named_expressionContext* FandangoParser::SetcompContext::named_expression() {
  return getRuleContext<FandangoParser::Named_expressionContext>(0);
}

FandangoParser::For_if_clausesContext* FandangoParser::SetcompContext::for_if_clauses() {
  return getRuleContext<FandangoParser::For_if_clausesContext>(0);
}

tree::TerminalNode* FandangoParser::SetcompContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}


size_t FandangoParser::SetcompContext::getRuleIndex() const {
  return FandangoParser::RuleSetcomp;
}


std::any FandangoParser::SetcompContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSetcomp(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::SetcompContext* FandangoParser::setcomp() {
  SetcompContext *_localctx = _tracker.createInstance<SetcompContext>(_ctx, getState());
  enterRule(_localctx, 444, FandangoParser::RuleSetcomp);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3072);
    match(FandangoParser::OPEN_BRACE);
    setState(3073);
    named_expression();
    setState(3074);
    for_if_clauses();
    setState(3075);
    match(FandangoParser::CLOSE_BRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GenexpContext ------------------------------------------------------------------

FandangoParser::GenexpContext::GenexpContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::GenexpContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::For_if_clausesContext* FandangoParser::GenexpContext::for_if_clauses() {
  return getRuleContext<FandangoParser::For_if_clausesContext>(0);
}

tree::TerminalNode* FandangoParser::GenexpContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Assignment_expressionContext* FandangoParser::GenexpContext::assignment_expression() {
  return getRuleContext<FandangoParser::Assignment_expressionContext>(0);
}

FandangoParser::ExpressionContext* FandangoParser::GenexpContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::GenexpContext::getRuleIndex() const {
  return FandangoParser::RuleGenexp;
}


std::any FandangoParser::GenexpContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitGenexp(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::GenexpContext* FandangoParser::genexp() {
  GenexpContext *_localctx = _tracker.createInstance<GenexpContext>(_ctx, getState());
  enterRule(_localctx, 446, FandangoParser::RuleGenexp);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3077);
    match(FandangoParser::OPEN_PAREN);
    setState(3080);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _ctx)) {
    case 1: {
      setState(3078);
      assignment_expression();
      break;
    }

    case 2: {
      setState(3079);
      expression();
      break;
    }

    default:
      break;
    }
    setState(3082);
    for_if_clauses();
    setState(3083);
    match(FandangoParser::CLOSE_PAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DictcompContext ------------------------------------------------------------------

FandangoParser::DictcompContext::DictcompContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::DictcompContext::OPEN_BRACE() {
  return getToken(FandangoParser::OPEN_BRACE, 0);
}

FandangoParser::KvpairContext* FandangoParser::DictcompContext::kvpair() {
  return getRuleContext<FandangoParser::KvpairContext>(0);
}

FandangoParser::For_if_clausesContext* FandangoParser::DictcompContext::for_if_clauses() {
  return getRuleContext<FandangoParser::For_if_clausesContext>(0);
}

tree::TerminalNode* FandangoParser::DictcompContext::CLOSE_BRACE() {
  return getToken(FandangoParser::CLOSE_BRACE, 0);
}


size_t FandangoParser::DictcompContext::getRuleIndex() const {
  return FandangoParser::RuleDictcomp;
}


std::any FandangoParser::DictcompContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDictcomp(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::DictcompContext* FandangoParser::dictcomp() {
  DictcompContext *_localctx = _tracker.createInstance<DictcompContext>(_ctx, getState());
  enterRule(_localctx, 448, FandangoParser::RuleDictcomp);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3085);
    match(FandangoParser::OPEN_BRACE);
    setState(3086);
    kvpair();
    setState(3087);
    for_if_clauses();
    setState(3088);
    match(FandangoParser::CLOSE_BRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgumentsContext ------------------------------------------------------------------

FandangoParser::ArgumentsContext::ArgumentsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::ArgsContext* FandangoParser::ArgumentsContext::args() {
  return getRuleContext<FandangoParser::ArgsContext>(0);
}

tree::TerminalNode* FandangoParser::ArgumentsContext::COMMA() {
  return getToken(FandangoParser::COMMA, 0);
}


size_t FandangoParser::ArgumentsContext::getRuleIndex() const {
  return FandangoParser::RuleArguments;
}


std::any FandangoParser::ArgumentsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitArguments(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ArgumentsContext* FandangoParser::arguments() {
  ArgumentsContext *_localctx = _tracker.createInstance<ArgumentsContext>(_ctx, getState());
  enterRule(_localctx, 450, FandangoParser::RuleArguments);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3090);
    args();
    setState(3092);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(3091);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgsContext ------------------------------------------------------------------

FandangoParser::ArgsContext::ArgsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::ArgContext *> FandangoParser::ArgsContext::arg() {
  return getRuleContexts<FandangoParser::ArgContext>();
}

FandangoParser::ArgContext* FandangoParser::ArgsContext::arg(size_t i) {
  return getRuleContext<FandangoParser::ArgContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::ArgsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::ArgsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}

FandangoParser::KwargsContext* FandangoParser::ArgsContext::kwargs() {
  return getRuleContext<FandangoParser::KwargsContext>(0);
}


size_t FandangoParser::ArgsContext::getRuleIndex() const {
  return FandangoParser::RuleArgs;
}


std::any FandangoParser::ArgsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitArgs(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ArgsContext* FandangoParser::args() {
  ArgsContext *_localctx = _tracker.createInstance<ArgsContext>(_ctx, getState());
  enterRule(_localctx, 452, FandangoParser::RuleArgs);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(3107);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 376, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3094);
      arg();
      setState(3099);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 374, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3095);
          match(FandangoParser::COMMA);
          setState(3096);
          arg(); 
        }
        setState(3101);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 374, _ctx);
      }
      setState(3104);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx)) {
      case 1: {
        setState(3102);
        match(FandangoParser::COMMA);
        setState(3103);
        kwargs();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3106);
      kwargs();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ArgContext ------------------------------------------------------------------

FandangoParser::ArgContext::ArgContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Star_selectionContext* FandangoParser::ArgContext::star_selection() {
  return getRuleContext<FandangoParser::Star_selectionContext>(0);
}

FandangoParser::Starred_expressionContext* FandangoParser::ArgContext::starred_expression() {
  return getRuleContext<FandangoParser::Starred_expressionContext>(0);
}

FandangoParser::Assignment_expressionContext* FandangoParser::ArgContext::assignment_expression() {
  return getRuleContext<FandangoParser::Assignment_expressionContext>(0);
}

FandangoParser::ExpressionContext* FandangoParser::ArgContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::ArgContext::getRuleIndex() const {
  return FandangoParser::RuleArg;
}


std::any FandangoParser::ArgContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitArg(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::ArgContext* FandangoParser::arg() {
  ArgContext *_localctx = _tracker.createInstance<ArgContext>(_ctx, getState());
  enterRule(_localctx, 454, FandangoParser::RuleArg);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3113);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 377, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3109);
      star_selection();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3110);
      starred_expression();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3111);
      assignment_expression();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3112);
      expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KwargsContext ------------------------------------------------------------------

FandangoParser::KwargsContext::KwargsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Kwarg_or_starredContext *> FandangoParser::KwargsContext::kwarg_or_starred() {
  return getRuleContexts<FandangoParser::Kwarg_or_starredContext>();
}

FandangoParser::Kwarg_or_starredContext* FandangoParser::KwargsContext::kwarg_or_starred(size_t i) {
  return getRuleContext<FandangoParser::Kwarg_or_starredContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::KwargsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::KwargsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}

std::vector<FandangoParser::Kwarg_or_double_starredContext *> FandangoParser::KwargsContext::kwarg_or_double_starred() {
  return getRuleContexts<FandangoParser::Kwarg_or_double_starredContext>();
}

FandangoParser::Kwarg_or_double_starredContext* FandangoParser::KwargsContext::kwarg_or_double_starred(size_t i) {
  return getRuleContext<FandangoParser::Kwarg_or_double_starredContext>(i);
}


size_t FandangoParser::KwargsContext::getRuleIndex() const {
  return FandangoParser::RuleKwargs;
}


std::any FandangoParser::KwargsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKwargs(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::KwargsContext* FandangoParser::kwargs() {
  KwargsContext *_localctx = _tracker.createInstance<KwargsContext>(_ctx, getState());
  enterRule(_localctx, 456, FandangoParser::RuleKwargs);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(3148);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 382, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3115);
      kwarg_or_starred();
      setState(3120);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 378, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3116);
          match(FandangoParser::COMMA);
          setState(3117);
          kwarg_or_starred(); 
        }
        setState(3122);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 378, _ctx);
      }
      setState(3123);
      match(FandangoParser::COMMA);
      setState(3124);
      kwarg_or_double_starred();
      setState(3129);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 379, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3125);
          match(FandangoParser::COMMA);
          setState(3126);
          kwarg_or_double_starred(); 
        }
        setState(3131);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 379, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3132);
      kwarg_or_starred();
      setState(3137);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 380, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3133);
          match(FandangoParser::COMMA);
          setState(3134);
          kwarg_or_starred(); 
        }
        setState(3139);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 380, _ctx);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3140);
      kwarg_or_double_starred();
      setState(3145);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 381, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3141);
          match(FandangoParser::COMMA);
          setState(3142);
          kwarg_or_double_starred(); 
        }
        setState(3147);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 381, _ctx);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Starred_expressionContext ------------------------------------------------------------------

FandangoParser::Starred_expressionContext::Starred_expressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Starred_expressionContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Starred_expressionContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}


size_t FandangoParser::Starred_expressionContext::getRuleIndex() const {
  return FandangoParser::RuleStarred_expression;
}


std::any FandangoParser::Starred_expressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStarred_expression(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Starred_expressionContext* FandangoParser::starred_expression() {
  Starred_expressionContext *_localctx = _tracker.createInstance<Starred_expressionContext>(_ctx, getState());
  enterRule(_localctx, 458, FandangoParser::RuleStarred_expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3150);
    match(FandangoParser::STAR);
    setState(3151);
    expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Kwarg_or_starredContext ------------------------------------------------------------------

FandangoParser::Kwarg_or_starredContext::Kwarg_or_starredContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Kwarg_or_starredContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Kwarg_or_starredContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Kwarg_or_starredContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

FandangoParser::Starred_expressionContext* FandangoParser::Kwarg_or_starredContext::starred_expression() {
  return getRuleContext<FandangoParser::Starred_expressionContext>(0);
}


size_t FandangoParser::Kwarg_or_starredContext::getRuleIndex() const {
  return FandangoParser::RuleKwarg_or_starred;
}


std::any FandangoParser::Kwarg_or_starredContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKwarg_or_starred(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Kwarg_or_starredContext* FandangoParser::kwarg_or_starred() {
  Kwarg_or_starredContext *_localctx = _tracker.createInstance<Kwarg_or_starredContext>(_ctx, getState());
  enterRule(_localctx, 460, FandangoParser::RuleKwarg_or_starred);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3158);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME: {
        enterOuterAlt(_localctx, 1);
        setState(3153);
        identifier();
        setState(3154);
        match(FandangoParser::ASSIGN);
        setState(3155);
        expression();
        break;
      }

      case FandangoParser::STAR: {
        enterOuterAlt(_localctx, 2);
        setState(3157);
        starred_expression();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Kwarg_or_double_starredContext ------------------------------------------------------------------

FandangoParser::Kwarg_or_double_starredContext::Kwarg_or_double_starredContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Kwarg_or_double_starredContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Kwarg_or_double_starredContext::ASSIGN() {
  return getToken(FandangoParser::ASSIGN, 0);
}

FandangoParser::ExpressionContext* FandangoParser::Kwarg_or_double_starredContext::expression() {
  return getRuleContext<FandangoParser::ExpressionContext>(0);
}

tree::TerminalNode* FandangoParser::Kwarg_or_double_starredContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}


size_t FandangoParser::Kwarg_or_double_starredContext::getRuleIndex() const {
  return FandangoParser::RuleKwarg_or_double_starred;
}


std::any FandangoParser::Kwarg_or_double_starredContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitKwarg_or_double_starred(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Kwarg_or_double_starredContext* FandangoParser::kwarg_or_double_starred() {
  Kwarg_or_double_starredContext *_localctx = _tracker.createInstance<Kwarg_or_double_starredContext>(_ctx, getState());
  enterRule(_localctx, 462, FandangoParser::RuleKwarg_or_double_starred);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3166);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME: {
        enterOuterAlt(_localctx, 1);
        setState(3160);
        identifier();
        setState(3161);
        match(FandangoParser::ASSIGN);
        setState(3162);
        expression();
        break;
      }

      case FandangoParser::POWER: {
        enterOuterAlt(_localctx, 2);
        setState(3164);
        match(FandangoParser::POWER);
        setState(3165);
        expression();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_targetsContext ------------------------------------------------------------------

FandangoParser::Star_targetsContext::Star_targetsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Star_targetContext *> FandangoParser::Star_targetsContext::star_target() {
  return getRuleContexts<FandangoParser::Star_targetContext>();
}

FandangoParser::Star_targetContext* FandangoParser::Star_targetsContext::star_target(size_t i) {
  return getRuleContext<FandangoParser::Star_targetContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Star_targetsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Star_targetsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Star_targetsContext::getRuleIndex() const {
  return FandangoParser::RuleStar_targets;
}


std::any FandangoParser::Star_targetsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_targets(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_targetsContext* FandangoParser::star_targets() {
  Star_targetsContext *_localctx = _tracker.createInstance<Star_targetsContext>(_ctx, getState());
  enterRule(_localctx, 464, FandangoParser::RuleStar_targets);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3168);
    star_target();
    setState(3173);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 385, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3169);
        match(FandangoParser::COMMA);
        setState(3170);
        star_target(); 
      }
      setState(3175);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 385, _ctx);
    }
    setState(3177);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(3176);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_targets_list_seqContext ------------------------------------------------------------------

FandangoParser::Star_targets_list_seqContext::Star_targets_list_seqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Star_targetContext *> FandangoParser::Star_targets_list_seqContext::star_target() {
  return getRuleContexts<FandangoParser::Star_targetContext>();
}

FandangoParser::Star_targetContext* FandangoParser::Star_targets_list_seqContext::star_target(size_t i) {
  return getRuleContext<FandangoParser::Star_targetContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Star_targets_list_seqContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Star_targets_list_seqContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Star_targets_list_seqContext::getRuleIndex() const {
  return FandangoParser::RuleStar_targets_list_seq;
}


std::any FandangoParser::Star_targets_list_seqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_targets_list_seq(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_targets_list_seqContext* FandangoParser::star_targets_list_seq() {
  Star_targets_list_seqContext *_localctx = _tracker.createInstance<Star_targets_list_seqContext>(_ctx, getState());
  enterRule(_localctx, 466, FandangoParser::RuleStar_targets_list_seq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3179);
    star_target();
    setState(3184);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 387, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3180);
        match(FandangoParser::COMMA);
        setState(3181);
        star_target(); 
      }
      setState(3186);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 387, _ctx);
    }
    setState(3188);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(3187);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_targets_tuple_seqContext ------------------------------------------------------------------

FandangoParser::Star_targets_tuple_seqContext::Star_targets_tuple_seqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Star_targetContext *> FandangoParser::Star_targets_tuple_seqContext::star_target() {
  return getRuleContexts<FandangoParser::Star_targetContext>();
}

FandangoParser::Star_targetContext* FandangoParser::Star_targets_tuple_seqContext::star_target(size_t i) {
  return getRuleContext<FandangoParser::Star_targetContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Star_targets_tuple_seqContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Star_targets_tuple_seqContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Star_targets_tuple_seqContext::getRuleIndex() const {
  return FandangoParser::RuleStar_targets_tuple_seq;
}


std::any FandangoParser::Star_targets_tuple_seqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_targets_tuple_seq(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_targets_tuple_seqContext* FandangoParser::star_targets_tuple_seq() {
  Star_targets_tuple_seqContext *_localctx = _tracker.createInstance<Star_targets_tuple_seqContext>(_ctx, getState());
  enterRule(_localctx, 468, FandangoParser::RuleStar_targets_tuple_seq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(3203);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 391, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3190);
      star_target();
      setState(3193); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(3191);
                match(FandangoParser::COMMA);
                setState(3192);
                star_target();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(3195); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 389, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      setState(3198);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FandangoParser::COMMA) {
        setState(3197);
        match(FandangoParser::COMMA);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3200);
      star_target();
      setState(3201);
      match(FandangoParser::COMMA);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_targetContext ------------------------------------------------------------------

FandangoParser::Star_targetContext::Star_targetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Star_targetContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

FandangoParser::Star_targetContext* FandangoParser::Star_targetContext::star_target() {
  return getRuleContext<FandangoParser::Star_targetContext>(0);
}

FandangoParser::Target_with_star_atomContext* FandangoParser::Star_targetContext::target_with_star_atom() {
  return getRuleContext<FandangoParser::Target_with_star_atomContext>(0);
}


size_t FandangoParser::Star_targetContext::getRuleIndex() const {
  return FandangoParser::RuleStar_target;
}


std::any FandangoParser::Star_targetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_target(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_targetContext* FandangoParser::star_target() {
  Star_targetContext *_localctx = _tracker.createInstance<Star_targetContext>(_ctx, getState());
  enterRule(_localctx, 470, FandangoParser::RuleStar_target);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3208);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 392, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3205);
      match(FandangoParser::STAR);
      setState(3206);
      star_target();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3207);
      target_with_star_atom();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Target_with_star_atomContext ------------------------------------------------------------------

FandangoParser::Target_with_star_atomContext::Target_with_star_atomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::T_primaryContext* FandangoParser::Target_with_star_atomContext::t_primary() {
  return getRuleContext<FandangoParser::T_primaryContext>(0);
}

tree::TerminalNode* FandangoParser::Target_with_star_atomContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Target_with_star_atomContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Target_with_star_atomContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::SlicesContext* FandangoParser::Target_with_star_atomContext::slices() {
  return getRuleContext<FandangoParser::SlicesContext>(0);
}

tree::TerminalNode* FandangoParser::Target_with_star_atomContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

FandangoParser::Star_atomContext* FandangoParser::Target_with_star_atomContext::star_atom() {
  return getRuleContext<FandangoParser::Star_atomContext>(0);
}


size_t FandangoParser::Target_with_star_atomContext::getRuleIndex() const {
  return FandangoParser::RuleTarget_with_star_atom;
}


std::any FandangoParser::Target_with_star_atomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitTarget_with_star_atom(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Target_with_star_atomContext* FandangoParser::target_with_star_atom() {
  Target_with_star_atomContext *_localctx = _tracker.createInstance<Target_with_star_atomContext>(_ctx, getState());
  enterRule(_localctx, 472, FandangoParser::RuleTarget_with_star_atom);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3220);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 393, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3210);
      t_primary(0);
      setState(3211);
      match(FandangoParser::DOT);
      setState(3212);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3214);
      t_primary(0);
      setState(3215);
      match(FandangoParser::OPEN_BRACK);
      setState(3216);
      slices();
      setState(3217);
      match(FandangoParser::CLOSE_BRACK);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3219);
      star_atom();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Star_atomContext ------------------------------------------------------------------

FandangoParser::Star_atomContext::Star_atomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Star_atomContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Star_atomContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::Target_with_star_atomContext* FandangoParser::Star_atomContext::target_with_star_atom() {
  return getRuleContext<FandangoParser::Target_with_star_atomContext>(0);
}

tree::TerminalNode* FandangoParser::Star_atomContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Star_targets_tuple_seqContext* FandangoParser::Star_atomContext::star_targets_tuple_seq() {
  return getRuleContext<FandangoParser::Star_targets_tuple_seqContext>(0);
}

tree::TerminalNode* FandangoParser::Star_atomContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

tree::TerminalNode* FandangoParser::Star_atomContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

FandangoParser::Star_targets_list_seqContext* FandangoParser::Star_atomContext::star_targets_list_seq() {
  return getRuleContext<FandangoParser::Star_targets_list_seqContext>(0);
}


size_t FandangoParser::Star_atomContext::getRuleIndex() const {
  return FandangoParser::RuleStar_atom;
}


std::any FandangoParser::Star_atomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitStar_atom(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Star_atomContext* FandangoParser::star_atom() {
  Star_atomContext *_localctx = _tracker.createInstance<Star_atomContext>(_ctx, getState());
  enterRule(_localctx, 474, FandangoParser::RuleStar_atom);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3237);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 396, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3222);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3223);
      match(FandangoParser::OPEN_PAREN);
      setState(3224);
      target_with_star_atom();
      setState(3225);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3227);
      match(FandangoParser::OPEN_PAREN);
      setState(3229);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116124636009988600) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 83896857) != 0)) {
        setState(3228);
        star_targets_tuple_seq();
      }
      setState(3231);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3232);
      match(FandangoParser::OPEN_BRACK);
      setState(3234);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 5116124636009988600) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 83896857) != 0)) {
        setState(3233);
        star_targets_list_seq();
      }
      setState(3236);
      match(FandangoParser::CLOSE_BRACK);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Single_targetContext ------------------------------------------------------------------

FandangoParser::Single_targetContext::Single_targetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::Single_subscript_attribute_targetContext* FandangoParser::Single_targetContext::single_subscript_attribute_target() {
  return getRuleContext<FandangoParser::Single_subscript_attribute_targetContext>(0);
}

FandangoParser::IdentifierContext* FandangoParser::Single_targetContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Single_targetContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

FandangoParser::Single_targetContext* FandangoParser::Single_targetContext::single_target() {
  return getRuleContext<FandangoParser::Single_targetContext>(0);
}

tree::TerminalNode* FandangoParser::Single_targetContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}


size_t FandangoParser::Single_targetContext::getRuleIndex() const {
  return FandangoParser::RuleSingle_target;
}


std::any FandangoParser::Single_targetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSingle_target(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Single_targetContext* FandangoParser::single_target() {
  Single_targetContext *_localctx = _tracker.createInstance<Single_targetContext>(_ctx, getState());
  enterRule(_localctx, 476, FandangoParser::RuleSingle_target);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3245);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 397, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3239);
      single_subscript_attribute_target();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3240);
      identifier();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3241);
      match(FandangoParser::OPEN_PAREN);
      setState(3242);
      single_target();
      setState(3243);
      match(FandangoParser::CLOSE_PAREN);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Single_subscript_attribute_targetContext ------------------------------------------------------------------

FandangoParser::Single_subscript_attribute_targetContext::Single_subscript_attribute_targetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::T_primaryContext* FandangoParser::Single_subscript_attribute_targetContext::t_primary() {
  return getRuleContext<FandangoParser::T_primaryContext>(0);
}

tree::TerminalNode* FandangoParser::Single_subscript_attribute_targetContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Single_subscript_attribute_targetContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Single_subscript_attribute_targetContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::SlicesContext* FandangoParser::Single_subscript_attribute_targetContext::slices() {
  return getRuleContext<FandangoParser::SlicesContext>(0);
}

tree::TerminalNode* FandangoParser::Single_subscript_attribute_targetContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}


size_t FandangoParser::Single_subscript_attribute_targetContext::getRuleIndex() const {
  return FandangoParser::RuleSingle_subscript_attribute_target;
}


std::any FandangoParser::Single_subscript_attribute_targetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitSingle_subscript_attribute_target(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Single_subscript_attribute_targetContext* FandangoParser::single_subscript_attribute_target() {
  Single_subscript_attribute_targetContext *_localctx = _tracker.createInstance<Single_subscript_attribute_targetContext>(_ctx, getState());
  enterRule(_localctx, 478, FandangoParser::RuleSingle_subscript_attribute_target);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3256);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 398, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3247);
      t_primary(0);
      setState(3248);
      match(FandangoParser::DOT);
      setState(3249);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3251);
      t_primary(0);
      setState(3252);
      match(FandangoParser::OPEN_BRACK);
      setState(3253);
      slices();
      setState(3254);
      match(FandangoParser::CLOSE_BRACK);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- T_primaryContext ------------------------------------------------------------------

FandangoParser::T_primaryContext::T_primaryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::AtomContext* FandangoParser::T_primaryContext::atom() {
  return getRuleContext<FandangoParser::AtomContext>(0);
}

FandangoParser::T_primaryContext* FandangoParser::T_primaryContext::t_primary() {
  return getRuleContext<FandangoParser::T_primaryContext>(0);
}

tree::TerminalNode* FandangoParser::T_primaryContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

FandangoParser::IdentifierContext* FandangoParser::T_primaryContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::T_primaryContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::SlicesContext* FandangoParser::T_primaryContext::slices() {
  return getRuleContext<FandangoParser::SlicesContext>(0);
}

tree::TerminalNode* FandangoParser::T_primaryContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

FandangoParser::GenexpContext* FandangoParser::T_primaryContext::genexp() {
  return getRuleContext<FandangoParser::GenexpContext>(0);
}

tree::TerminalNode* FandangoParser::T_primaryContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::T_primaryContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::ArgumentsContext* FandangoParser::T_primaryContext::arguments() {
  return getRuleContext<FandangoParser::ArgumentsContext>(0);
}


size_t FandangoParser::T_primaryContext::getRuleIndex() const {
  return FandangoParser::RuleT_primary;
}


std::any FandangoParser::T_primaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitT_primary(this);
  else
    return visitor->visitChildren(this);
}


FandangoParser::T_primaryContext* FandangoParser::t_primary() {
   return t_primary(0);
}

FandangoParser::T_primaryContext* FandangoParser::t_primary(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  FandangoParser::T_primaryContext *_localctx = _tracker.createInstance<T_primaryContext>(_ctx, parentState);
  FandangoParser::T_primaryContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 480;
  enterRecursionRule(_localctx, 480, FandangoParser::RuleT_primary, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3259);
    atom();
    _ctx->stop = _input->LT(-1);
    setState(3279);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 401, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(3277);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 400, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<T_primaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleT_primary);
          setState(3261);

          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
          setState(3262);
          match(FandangoParser::DOT);
          setState(3263);
          identifier();
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<T_primaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleT_primary);
          setState(3264);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(3265);
          match(FandangoParser::OPEN_BRACK);
          setState(3266);
          slices();
          setState(3267);
          match(FandangoParser::CLOSE_BRACK);
          break;
        }

        case 3: {
          _localctx = _tracker.createInstance<T_primaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleT_primary);
          setState(3269);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(3270);
          genexp();
          break;
        }

        case 4: {
          _localctx = _tracker.createInstance<T_primaryContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleT_primary);
          setState(3271);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(3272);
          match(FandangoParser::OPEN_PAREN);
          setState(3274);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if ((((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & 5116125804241158648) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 78)) & 93071897) != 0)) {
            setState(3273);
            arguments();
          }
          setState(3276);
          match(FandangoParser::CLOSE_PAREN);
          break;
        }

        default:
          break;
        } 
      }
      setState(3281);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 401, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- Del_targetsContext ------------------------------------------------------------------

FandangoParser::Del_targetsContext::Del_targetsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::Del_targetContext *> FandangoParser::Del_targetsContext::del_target() {
  return getRuleContexts<FandangoParser::Del_targetContext>();
}

FandangoParser::Del_targetContext* FandangoParser::Del_targetsContext::del_target(size_t i) {
  return getRuleContext<FandangoParser::Del_targetContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Del_targetsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Del_targetsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}


size_t FandangoParser::Del_targetsContext::getRuleIndex() const {
  return FandangoParser::RuleDel_targets;
}


std::any FandangoParser::Del_targetsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDel_targets(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Del_targetsContext* FandangoParser::del_targets() {
  Del_targetsContext *_localctx = _tracker.createInstance<Del_targetsContext>(_ctx, getState());
  enterRule(_localctx, 482, FandangoParser::RuleDel_targets);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3282);
    del_target();
    setState(3287);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 402, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3283);
        match(FandangoParser::COMMA);
        setState(3284);
        del_target(); 
      }
      setState(3289);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 402, _ctx);
    }
    setState(3291);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FandangoParser::COMMA) {
      setState(3290);
      match(FandangoParser::COMMA);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Del_targetContext ------------------------------------------------------------------

FandangoParser::Del_targetContext::Del_targetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::T_primaryContext* FandangoParser::Del_targetContext::t_primary() {
  return getRuleContext<FandangoParser::T_primaryContext>(0);
}

tree::TerminalNode* FandangoParser::Del_targetContext::DOT() {
  return getToken(FandangoParser::DOT, 0);
}

FandangoParser::IdentifierContext* FandangoParser::Del_targetContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Del_targetContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

FandangoParser::SlicesContext* FandangoParser::Del_targetContext::slices() {
  return getRuleContext<FandangoParser::SlicesContext>(0);
}

tree::TerminalNode* FandangoParser::Del_targetContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}

FandangoParser::Del_t_atomContext* FandangoParser::Del_targetContext::del_t_atom() {
  return getRuleContext<FandangoParser::Del_t_atomContext>(0);
}


size_t FandangoParser::Del_targetContext::getRuleIndex() const {
  return FandangoParser::RuleDel_target;
}


std::any FandangoParser::Del_targetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDel_target(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Del_targetContext* FandangoParser::del_target() {
  Del_targetContext *_localctx = _tracker.createInstance<Del_targetContext>(_ctx, getState());
  enterRule(_localctx, 484, FandangoParser::RuleDel_target);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3303);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 404, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3293);
      t_primary(0);
      setState(3294);
      match(FandangoParser::DOT);
      setState(3295);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3297);
      t_primary(0);
      setState(3298);
      match(FandangoParser::OPEN_BRACK);
      setState(3299);
      slices();
      setState(3300);
      match(FandangoParser::CLOSE_BRACK);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3302);
      del_t_atom();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Del_t_atomContext ------------------------------------------------------------------

FandangoParser::Del_t_atomContext::Del_t_atomContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FandangoParser::IdentifierContext* FandangoParser::Del_t_atomContext::identifier() {
  return getRuleContext<FandangoParser::IdentifierContext>(0);
}

tree::TerminalNode* FandangoParser::Del_t_atomContext::OPEN_PAREN() {
  return getToken(FandangoParser::OPEN_PAREN, 0);
}

tree::TerminalNode* FandangoParser::Del_t_atomContext::CLOSE_PAREN() {
  return getToken(FandangoParser::CLOSE_PAREN, 0);
}

FandangoParser::Del_targetsContext* FandangoParser::Del_t_atomContext::del_targets() {
  return getRuleContext<FandangoParser::Del_targetsContext>(0);
}

tree::TerminalNode* FandangoParser::Del_t_atomContext::OPEN_BRACK() {
  return getToken(FandangoParser::OPEN_BRACK, 0);
}

tree::TerminalNode* FandangoParser::Del_t_atomContext::CLOSE_BRACK() {
  return getToken(FandangoParser::CLOSE_BRACK, 0);
}


size_t FandangoParser::Del_t_atomContext::getRuleIndex() const {
  return FandangoParser::RuleDel_t_atom;
}


std::any FandangoParser::Del_t_atomContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitDel_t_atom(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Del_t_atomContext* FandangoParser::del_t_atom() {
  Del_t_atomContext *_localctx = _tracker.createInstance<Del_t_atomContext>(_ctx, getState());
  enterRule(_localctx, 486, FandangoParser::RuleDel_t_atom);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3316);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FandangoParser::ANY:
      case FandangoParser::ALL:
      case FandangoParser::LEN:
      case FandangoParser::NAME: {
        enterOuterAlt(_localctx, 1);
        setState(3305);
        identifier();
        break;
      }

      case FandangoParser::OPEN_PAREN: {
        enterOuterAlt(_localctx, 2);
        setState(3306);
        match(FandangoParser::OPEN_PAREN);
        setState(3308);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 5116124636009988600) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 78)) & 83896857) != 0)) {
          setState(3307);
          del_targets();
        }
        setState(3310);
        match(FandangoParser::CLOSE_PAREN);
        break;
      }

      case FandangoParser::OPEN_BRACK: {
        enterOuterAlt(_localctx, 3);
        setState(3311);
        match(FandangoParser::OPEN_BRACK);
        setState(3313);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 5116124636009988600) != 0) || ((((_la - 78) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 78)) & 83896857) != 0)) {
          setState(3312);
          del_targets();
        }
        setState(3315);
        match(FandangoParser::CLOSE_BRACK);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Type_expressionsContext ------------------------------------------------------------------

FandangoParser::Type_expressionsContext::Type_expressionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FandangoParser::ExpressionContext *> FandangoParser::Type_expressionsContext::expression() {
  return getRuleContexts<FandangoParser::ExpressionContext>();
}

FandangoParser::ExpressionContext* FandangoParser::Type_expressionsContext::expression(size_t i) {
  return getRuleContext<FandangoParser::ExpressionContext>(i);
}

std::vector<tree::TerminalNode *> FandangoParser::Type_expressionsContext::COMMA() {
  return getTokens(FandangoParser::COMMA);
}

tree::TerminalNode* FandangoParser::Type_expressionsContext::COMMA(size_t i) {
  return getToken(FandangoParser::COMMA, i);
}

tree::TerminalNode* FandangoParser::Type_expressionsContext::STAR() {
  return getToken(FandangoParser::STAR, 0);
}

tree::TerminalNode* FandangoParser::Type_expressionsContext::POWER() {
  return getToken(FandangoParser::POWER, 0);
}


size_t FandangoParser::Type_expressionsContext::getRuleIndex() const {
  return FandangoParser::RuleType_expressions;
}


std::any FandangoParser::Type_expressionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitType_expressions(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Type_expressionsContext* FandangoParser::type_expressions() {
  Type_expressionsContext *_localctx = _tracker.createInstance<Type_expressionsContext>(_ctx, getState());
  enterRule(_localctx, 488, FandangoParser::RuleType_expressions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(3375);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 412, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3318);
      expression();
      setState(3323);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 408, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3319);
          match(FandangoParser::COMMA);
          setState(3320);
          expression(); 
        }
        setState(3325);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 408, _ctx);
      }
      setState(3326);
      match(FandangoParser::COMMA);
      setState(3327);
      match(FandangoParser::STAR);
      setState(3328);
      expression();
      setState(3329);
      match(FandangoParser::COMMA);
      setState(3330);
      match(FandangoParser::POWER);
      setState(3331);
      expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3333);
      expression();
      setState(3338);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 409, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3334);
          match(FandangoParser::COMMA);
          setState(3335);
          expression(); 
        }
        setState(3340);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 409, _ctx);
      }
      setState(3341);
      match(FandangoParser::COMMA);
      setState(3342);
      match(FandangoParser::STAR);
      setState(3343);
      expression();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3345);
      expression();
      setState(3350);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 410, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3346);
          match(FandangoParser::COMMA);
          setState(3347);
          expression(); 
        }
        setState(3352);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 410, _ctx);
      }
      setState(3353);
      match(FandangoParser::COMMA);
      setState(3354);
      match(FandangoParser::POWER);
      setState(3355);
      expression();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3357);
      match(FandangoParser::STAR);
      setState(3358);
      expression();
      setState(3359);
      match(FandangoParser::COMMA);
      setState(3360);
      match(FandangoParser::POWER);
      setState(3361);
      expression();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3363);
      match(FandangoParser::STAR);
      setState(3364);
      expression();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(3365);
      match(FandangoParser::POWER);
      setState(3366);
      expression();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(3367);
      expression();
      setState(3372);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FandangoParser::COMMA) {
        setState(3368);
        match(FandangoParser::COMMA);
        setState(3369);
        expression();
        setState(3374);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Func_type_commentContext ------------------------------------------------------------------

FandangoParser::Func_type_commentContext::Func_type_commentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::Func_type_commentContext::NEWLINE() {
  return getToken(FandangoParser::NEWLINE, 0);
}


size_t FandangoParser::Func_type_commentContext::getRuleIndex() const {
  return FandangoParser::RuleFunc_type_comment;
}


std::any FandangoParser::Func_type_commentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitFunc_type_comment(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::Func_type_commentContext* FandangoParser::func_type_comment() {
  Func_type_commentContext *_localctx = _tracker.createInstance<Func_type_commentContext>(_ctx, getState());
  enterRule(_localctx, 490, FandangoParser::RuleFunc_type_comment);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3377);
    match(FandangoParser::NEWLINE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierContext ------------------------------------------------------------------

FandangoParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FandangoParser::IdentifierContext::NAME() {
  return getToken(FandangoParser::NAME, 0);
}

tree::TerminalNode* FandangoParser::IdentifierContext::ANY() {
  return getToken(FandangoParser::ANY, 0);
}

tree::TerminalNode* FandangoParser::IdentifierContext::ALL() {
  return getToken(FandangoParser::ALL, 0);
}

tree::TerminalNode* FandangoParser::IdentifierContext::LEN() {
  return getToken(FandangoParser::LEN, 0);
}


size_t FandangoParser::IdentifierContext::getRuleIndex() const {
  return FandangoParser::RuleIdentifier;
}


std::any FandangoParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FandangoParserVisitor*>(visitor))
    return parserVisitor->visitIdentifier(this);
  else
    return visitor->visitChildren(this);
}

FandangoParser::IdentifierContext* FandangoParser::identifier() {
  IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
  enterRule(_localctx, 492, FandangoParser::RuleIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3379);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 5116089176692883456) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

bool FandangoParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
  switch (ruleIndex) {
    case 14: return generator_callSempred(antlrcpp::downCast<Generator_callContext *>(context), predicateIndex);
    case 28: return dot_selectionSempred(antlrcpp::downCast<Dot_selectionContext *>(context), predicateIndex);
    case 72: return dotted_nameSempred(antlrcpp::downCast<Dotted_nameContext *>(context), predicateIndex);
    case 126: return name_or_attrSempred(antlrcpp::downCast<Name_or_attrContext *>(context), predicateIndex);
    case 170: return bitwise_orSempred(antlrcpp::downCast<Bitwise_orContext *>(context), predicateIndex);
    case 171: return bitwise_xorSempred(antlrcpp::downCast<Bitwise_xorContext *>(context), predicateIndex);
    case 172: return bitwise_andSempred(antlrcpp::downCast<Bitwise_andContext *>(context), predicateIndex);
    case 173: return shift_exprSempred(antlrcpp::downCast<Shift_exprContext *>(context), predicateIndex);
    case 174: return sumSempred(antlrcpp::downCast<SumContext *>(context), predicateIndex);
    case 175: return termSempred(antlrcpp::downCast<TermContext *>(context), predicateIndex);
    case 179: return primarySempred(antlrcpp::downCast<PrimaryContext *>(context), predicateIndex);
    case 240: return t_primarySempred(antlrcpp::downCast<T_primaryContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool FandangoParser::generator_callSempred(Generator_callContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return precpred(_ctx, 4);
    case 1: return precpred(_ctx, 3);
    case 2: return precpred(_ctx, 2);
    case 3: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool FandangoParser::dot_selectionSempred(Dot_selectionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 4: return precpred(_ctx, 2);
    case 5: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool FandangoParser::dotted_nameSempred(Dotted_nameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 6: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::name_or_attrSempred(Name_or_attrContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 7: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::bitwise_orSempred(Bitwise_orContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 8: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::bitwise_xorSempred(Bitwise_xorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 9: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::bitwise_andSempred(Bitwise_andContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 10: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::shift_exprSempred(Shift_exprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 11: return precpred(_ctx, 3);
    case 12: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::sumSempred(SumContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 13: return precpred(_ctx, 3);
    case 14: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::termSempred(TermContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 15: return precpred(_ctx, 6);
    case 16: return precpred(_ctx, 5);
    case 17: return precpred(_ctx, 4);
    case 18: return precpred(_ctx, 3);
    case 19: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::primarySempred(PrimaryContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 20: return precpred(_ctx, 5);
    case 21: return precpred(_ctx, 4);
    case 22: return precpred(_ctx, 3);
    case 23: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool FandangoParser::t_primarySempred(T_primaryContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 24: return precpred(_ctx, 5);
    case 25: return precpred(_ctx, 4);
    case 26: return precpred(_ctx, 3);
    case 27: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

void FandangoParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  fandangoparserParserInitialize();
#else
  ::antlr4::internal::call_once(fandangoparserParserOnceFlag, fandangoparserParserInitialize);
#endif
}
