
// Generated from FeatParser.g4 by ANTLR 4.13.2


#include "FeatParserVisitor.h"

#include "FeatParser.h"


using namespace antlrcpp;

using namespace antlr4;

namespace {

struct FeatParserStaticData final {
  FeatParserStaticData(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) {}

  FeatParserStaticData(const FeatParserStaticData&) = delete;
  FeatParserStaticData(FeatParserStaticData&&) = delete;
  FeatParserStaticData& operator=(const FeatParserStaticData&) = delete;
  FeatParserStaticData& operator=(FeatParserStaticData&&) = 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 featparserParserOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
std::unique_ptr<FeatParserStaticData> featparserParserStaticData = nullptr;

void featparserParserInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  if (featparserParserStaticData != nullptr) {
    return;
  }
#else
  assert(featparserParserStaticData == nullptr);
#endif
  auto staticData = std::make_unique<FeatParserStaticData>(
    std::vector<std::string>{
      "file", "topLevelStatement", "include", "glyphClassAssign", "langsysAssign", 
      "mark_statement", "anchorDef", "valueRecordDef", "featureBlock", "tableBlock", 
      "anonBlock", "lookupBlockTopLevel", "featureStatement", "lookupBlockOrUse", 
      "cvParameterBlock", "cvParameterStatement", "cvParameter", "statement", 
      "featureUse", "scriptAssign", "langAssign", "lookupflagAssign", "lookupflagElement", 
      "ignoreSubOrPos", "substitute", "position", "valuePattern", "valueRecord", 
      "valueLiteral", "cursiveElement", "baseToMarkElement", "ligatureMarkElement", 
      "parameters", "sizemenuname", "featureNames", "subtable", "table_BASE", 
      "baseStatement", "axisTags", "axisScripts", "baseScript", "table_GDEF", 
      "gdefStatement", "gdefGlyphClass", "gdefAttach", "gdefLigCaretPos", 
      "gdefLigCaretIndex", "table_head", "headStatement", "head", "table_hhea", 
      "hheaStatement", "hhea", "table_vhea", "vheaStatement", "vhea", "table_name", 
      "nameStatement", "nameID", "table_OS_2", "os_2Statement", "os_2", 
      "table_STAT", "statStatement", "designAxis", "axisValue", "axisValueStatement", 
      "axisValueLocation", "axisValueFlags", "elidedFallbackName", "nameEntryStatement", 
      "elidedFallbackNameID", "nameEntry", "table_vmtx", "vmtxStatement", 
      "vmtx", "anchor", "lookupPattern", "lookupPatternElement", "pattern", 
      "patternElement", "glyphClassOptional", "glyphClass", "gcLiteral", 
      "gcLiteralElement", "glyph", "glyphName", "label", "tag", "fixedNum", 
      "genNum", "featureFile", "statementFile", "cvStatementFile", "baseFile", 
      "headFile", "hheaFile", "vheaFile", "gdefFile", "nameFile", "vmtxFile", 
      "os_2File", "statFile", "axisValueFile", "nameEntryFile", "subtok", 
      "revtok", "anontok", "enumtok", "postok", "markligtok"
    },
    std::vector<std::string>{
      "", "'anon'", "'anonymous'", "", "", "'include'", "'feature'", "'table'", 
      "'script'", "'language'", "'languagesystem'", "'subtable'", "'lookup'", 
      "'lookupflag'", "'.notdef'", "'RightToLeft'", "'IgnoreBaseGlyphs'", 
      "'IgnoreLigatures'", "'IgnoreMarks'", "'UseMarkFilteringSet'", "'MarkAttachmentType'", 
      "'excludeDFLT'", "'includeDFLT'", "'exclude_dflt'", "'include_dflt'", 
      "'useExtension'", "'<'", "'>'", "'enumerate'", "'enum'", "'except'", 
      "'ignore'", "'substitute'", "'sub'", "'reversesub'", "'rsub'", "'by'", 
      "'from'", "'position'", "'pos'", "'parameters'", "'featureNames'", 
      "'cvParameters'", "'FeatUILabelNameID'", "'FeatUITooltipTextNameID'", 
      "'SampleTextNameID'", "'ParamUILabelNameID'", "'Character'", "'sizemenuname'", 
      "'contourpoint'", "'anchor'", "'anchorDef'", "'valueRecordDef'", "'mark'", 
      "'markClass'", "'cursive'", "'base'", "'ligature'", "'lig'", "'ligComponent'", 
      "'NULL'", "'BASE'", "'HorizAxis.BaseTagList'", "'VertAxis.BaseTagList'", 
      "'HorizAxis.BaseScriptList'", "'VertAxis.BaseScriptList'", "'GDEF'", 
      "'GlyphClassDef'", "'Attach'", "'LigatureCaretByPos'", "'LigatureCaretByIndex'", 
      "'head'", "'FontRevision'", "'hhea'", "'Ascender'", "'Descender'", 
      "'LineGap'", "'CaretOffset'", "'name'", "'nameid'", "'OS/2'", "'FSType'", 
      "'fsType'", "'LowerOpSize'", "'UpperOpSize'", "'Panose'", "'TypoAscender'", 
      "'TypoDescender'", "'TypoLineGap'", "'winAscent'", "'winDescent'", 
      "'XHeight'", "'CapHeight'", "'WeightClass'", "'WidthClass'", "'Vendor'", 
      "'UnicodeRange'", "'CodePageRange'", "'FamilyClass'", "'STAT'", "'ElidedFallbackName'", 
      "'ElidedFallbackNameID'", "'DesignAxis'", "'AxisValue'", "'flag'", 
      "'location'", "'ElidableAxisValueName'", "'OlderSiblingFontAttribute'", 
      "'vhea'", "'VertTypoAscender'", "'VertTypoDescender'", "'VertTypoLineGap'", 
      "'vmtx'", "'VertOriginY'", "'VertAdvanceY'", "", "'}'", "'['", "']'", 
      "'-'", "';'", "'='", "'''", "','", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "'('", "", "')'"
    },
    std::vector<std::string>{
      "", "ANON", "ANON_v", "COMMENT", "WHITESPACE", "INCLUDE", "FEATURE", 
      "TABLE", "SCRIPT", "LANGUAGE", "LANGSYS", "SUBTABLE", "LOOKUP", "LOOKUPFLAG", 
      "NOTDEF", "RIGHT_TO_LEFT", "IGNORE_BASE_GLYPHS", "IGNORE_LIGATURES", 
      "IGNORE_MARKS", "USE_MARK_FILTERING_SET", "MARK_ATTACHMENT_TYPE", 
      "EXCLUDE_DFLT", "INCLUDE_DFLT", "EXCLUDE_dflt", "INCLUDE_dflt", "USE_EXTENSION", 
      "BEGINVALUE", "ENDVALUE", "ENUMERATE", "ENUMERATE_v", "EXCEPT", "IGNORE", 
      "SUBSTITUTE", "SUBSTITUTE_v", "REVERSE", "REVERSE_v", "BY", "FROM", 
      "POSITION", "POSITION_v", "PARAMETERS", "FEATURE_NAMES", "CV_PARAMETERS", 
      "CV_UI_LABEL", "CV_TOOLTIP", "CV_SAMPLE_TEXT", "CV_PARAM_LABEL", "CV_CHARACTER", 
      "SIZEMENUNAME", "CONTOURPOINT", "ANCHOR", "ANCHOR_DEF", "VALUE_RECORD_DEF", 
      "MARK", "MARK_CLASS", "CURSIVE", "MARKBASE", "MARKLIG", "MARKLIG_v", 
      "LIG_COMPONENT", "KNULL", "BASE", "HA_BTL", "VA_BTL", "HA_BSL", "VA_BSL", 
      "GDEF", "GLYPH_CLASS_DEF", "ATTACH", "LIG_CARET_BY_POS", "LIG_CARET_BY_IDX", 
      "HEAD", "FONT_REVISION", "HHEA", "ASCENDER", "DESCENDER", "LINE_GAP", 
      "CARET_OFFSET", "NAME", "NAMEID", "OS_2", "FS_TYPE", "FS_TYPE_v", 
      "OS2_LOWER_OP_SIZE", "OS2_UPPER_OP_SIZE", "PANOSE", "TYPO_ASCENDER", 
      "TYPO_DESCENDER", "TYPO_LINE_GAP", "WIN_ASCENT", "WIN_DESCENT", "X_HEIGHT", 
      "CAP_HEIGHT", "WEIGHT_CLASS", "WIDTH_CLASS", "VENDOR", "UNICODE_RANGE", 
      "CODE_PAGE_RANGE", "FAMILY_CLASS", "STAT", "ELIDED_FALLBACK_NAME", 
      "ELIDED_FALLBACK_NAME_ID", "DESIGN_AXIS", "AXIS_VALUE", "FLAG", "LOCATION", 
      "AXIS_EAVN", "AXIS_OSFA", "VHEA", "VERT_TYPO_ASCENDER", "VERT_TYPO_DESCENDER", 
      "VERT_TYPO_LINE_GAP", "VMTX", "VERT_ORIGIN_Y", "VERT_ADVANCE_Y", "LCBRACE", 
      "RCBRACE", "LBRACKET", "RBRACKET", "HYPHEN", "SEMI", "EQUALS", "MARKER", 
      "COMMA", "QUOTE", "GCLASS", "CID", "ESCGNAME", "NAMELABEL", "EXTNAME", 
      "POINTNUM", "NUMEXT", "NUMOCT", "NUM", "CATCHTAG", "A_WHITESPACE", 
      "A_LABEL", "A_LBRACE", "A_CLOSE", "A_LINE", "I_WHITESPACE", "I_RPAREN", 
      "IFILE", "I_LPAREN", "STRVAL", "EQUOTE"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,145,1156,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,1,0,1,0,1,0,1,0,1,0,5,0,228,8,0,10,0,12,0,231,9,0,1,0,1,0,1,1,1,
  	1,1,1,1,1,1,1,1,1,3,1,241,8,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,
  	1,3,1,4,1,4,1,4,1,4,1,5,1,5,1,5,3,5,261,8,5,1,5,1,5,1,5,1,6,1,6,1,6,1,
  	6,1,6,3,6,271,8,6,1,6,1,6,1,7,1,7,1,7,1,7,1,8,1,8,1,8,3,8,282,8,8,1,8,
  	1,8,4,8,286,8,8,11,8,12,8,287,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,
  	1,9,1,9,1,9,1,9,3,9,304,8,9,1,10,1,10,1,10,1,10,5,10,310,8,10,10,10,12,
  	10,313,9,10,1,10,1,10,1,11,1,11,1,11,3,11,320,8,11,1,11,1,11,4,11,324,
  	8,11,11,11,12,11,325,1,11,1,11,1,11,1,11,1,12,1,12,1,12,3,12,335,8,12,
  	1,13,1,13,1,13,3,13,340,8,13,1,13,1,13,4,13,344,8,13,11,13,12,13,345,
  	1,13,1,13,1,13,3,13,351,8,13,1,13,1,13,1,14,1,14,1,14,5,14,358,8,14,10,
  	14,12,14,361,9,14,1,14,1,14,1,14,1,15,1,15,3,15,368,8,15,1,15,1,15,1,
  	16,1,16,1,16,4,16,375,8,16,11,16,12,16,376,1,16,1,16,1,16,1,16,3,16,383,
  	8,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,
  	1,17,3,17,399,8,17,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19,1,20,1,20,
  	1,20,3,20,412,8,20,1,21,1,21,1,21,4,21,417,8,21,11,21,12,21,418,3,21,
  	421,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,431,8,22,1,23,1,
  	23,1,23,1,23,3,23,437,8,23,1,23,1,23,1,23,5,23,442,8,23,10,23,12,23,445,
  	9,23,1,24,1,24,1,24,1,24,5,24,451,8,24,10,24,12,24,454,9,24,3,24,456,
  	8,24,1,24,1,24,1,24,1,24,1,24,3,24,463,8,24,3,24,465,8,24,1,24,1,24,1,
  	24,1,24,1,24,3,24,472,8,24,3,24,474,8,24,3,24,476,8,24,1,25,3,25,479,
  	8,25,1,25,1,25,3,25,483,8,25,1,25,1,25,5,25,487,8,25,10,25,12,25,490,
  	9,25,1,25,1,25,4,25,494,8,25,11,25,12,25,495,1,25,5,25,499,8,25,10,25,
  	12,25,502,9,25,1,25,1,25,1,25,3,25,507,8,25,1,25,1,25,1,25,4,25,512,8,
  	25,11,25,12,25,513,1,25,3,25,517,8,25,1,25,1,25,1,25,4,25,522,8,25,11,
  	25,12,25,523,1,25,3,25,527,8,25,1,25,1,25,1,25,4,25,532,8,25,11,25,12,
  	25,533,1,25,3,25,537,8,25,3,25,539,8,25,1,26,1,26,3,26,543,8,26,1,27,
  	1,27,1,27,1,27,1,27,3,27,550,8,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,
  	3,28,559,8,28,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,3,30,569,8,30,1,
  	31,1,31,1,31,3,31,574,8,31,1,31,3,31,577,8,31,1,31,3,31,580,8,31,1,32,
  	1,32,4,32,584,8,32,11,32,12,32,585,1,33,1,33,1,33,1,33,1,33,3,33,593,
  	8,33,3,33,595,8,33,1,33,1,33,1,33,1,33,1,34,1,34,1,34,4,34,604,8,34,11,
  	34,12,34,605,1,34,1,34,1,35,1,35,1,36,1,36,1,36,4,36,615,8,36,11,36,12,
  	36,616,1,36,1,36,1,36,1,36,1,37,1,37,1,37,3,37,626,8,37,1,37,1,37,1,38,
  	1,38,4,38,632,8,38,11,38,12,38,633,1,39,1,39,1,39,1,39,5,39,640,8,39,
  	10,39,12,39,643,9,39,1,40,1,40,1,40,4,40,648,8,40,11,40,12,40,649,1,41,
  	1,41,1,41,4,41,655,8,41,11,41,12,41,656,1,41,1,41,1,41,1,41,1,42,1,42,
  	1,42,1,42,1,42,3,42,668,8,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,43,
  	1,43,1,43,1,43,1,44,1,44,1,44,4,44,684,8,44,11,44,12,44,685,1,45,1,45,
  	1,45,4,45,691,8,45,11,45,12,45,692,1,46,1,46,1,46,4,46,698,8,46,11,46,
  	12,46,699,1,47,1,47,1,47,4,47,705,8,47,11,47,12,47,706,1,47,1,47,1,47,
  	1,47,1,48,1,48,3,48,715,8,48,1,48,1,48,1,49,1,49,1,49,1,50,1,50,1,50,
  	5,50,725,8,50,10,50,12,50,728,9,50,1,50,1,50,1,50,1,50,1,51,1,51,3,51,
  	736,8,51,1,51,1,51,1,52,1,52,1,52,1,53,1,53,1,53,5,53,746,8,53,10,53,
  	12,53,749,9,53,1,53,1,53,1,53,1,53,1,54,1,54,3,54,757,8,54,1,54,1,54,
  	1,55,1,55,1,55,1,56,1,56,1,56,4,56,767,8,56,11,56,12,56,768,1,56,1,56,
  	1,56,1,56,1,57,1,57,3,57,777,8,57,1,57,1,57,1,58,1,58,1,58,1,58,1,58,
  	1,58,3,58,787,8,58,3,58,789,8,58,1,58,1,58,1,58,1,58,1,59,1,59,1,59,4,
  	59,798,8,59,11,59,12,59,799,1,59,1,59,1,59,1,59,1,60,1,60,3,60,808,8,
  	60,1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,
  	61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,4,61,835,8,
  	61,11,61,12,61,836,3,61,839,8,61,1,62,1,62,1,62,4,62,844,8,62,11,62,12,
  	62,845,1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,3,63,857,8,63,1,63,
  	1,63,1,64,1,64,1,64,1,64,1,64,4,64,866,8,64,11,64,12,64,867,1,64,1,64,
  	1,65,1,65,1,65,4,65,875,8,65,11,65,12,65,876,1,65,1,65,1,66,1,66,1,66,
  	1,66,3,66,885,8,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,3,67,894,8,67,3,
  	67,896,8,67,1,68,1,68,4,68,900,8,68,11,68,12,68,901,1,69,1,69,1,69,4,
  	69,907,8,69,11,69,12,69,908,1,69,1,69,1,70,1,70,3,70,915,8,70,1,70,1,
  	70,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72,3,72,927,8,72,3,72,929,8,72,
  	1,72,1,72,1,72,1,72,1,73,1,73,1,73,4,73,938,8,73,11,73,12,73,939,1,73,
  	1,73,1,73,1,73,1,74,1,74,3,74,948,8,74,1,74,1,74,1,75,1,75,1,75,1,75,
  	1,76,1,76,1,76,1,76,1,76,1,76,3,76,962,8,76,1,76,1,76,3,76,966,8,76,1,
  	76,1,76,1,77,4,77,971,8,77,11,77,12,77,972,1,78,1,78,1,78,5,78,978,8,
  	78,10,78,12,78,981,9,78,1,79,4,79,984,8,79,11,79,12,79,985,1,80,1,80,
  	3,80,990,8,80,1,80,3,80,993,8,80,1,81,3,81,996,8,81,1,82,1,82,3,82,1000,
  	8,82,1,83,1,83,4,83,1004,8,83,11,83,12,83,1005,1,83,1,83,1,84,1,84,1,
  	84,3,84,1013,8,84,1,84,3,84,1016,8,84,1,85,1,85,3,85,1020,8,85,1,86,1,
  	86,1,87,1,87,1,88,1,88,1,89,1,89,1,90,1,90,1,91,5,91,1033,8,91,10,91,
  	12,91,1036,9,91,1,91,1,91,1,92,5,92,1041,8,92,10,92,12,92,1044,9,92,1,
  	92,1,92,1,93,5,93,1049,8,93,10,93,12,93,1052,9,93,1,93,1,93,1,94,5,94,
  	1057,8,94,10,94,12,94,1060,9,94,1,94,1,94,1,95,5,95,1065,8,95,10,95,12,
  	95,1068,9,95,1,95,1,95,1,96,5,96,1073,8,96,10,96,12,96,1076,9,96,1,96,
  	1,96,1,97,5,97,1081,8,97,10,97,12,97,1084,9,97,1,97,1,97,1,98,5,98,1089,
  	8,98,10,98,12,98,1092,9,98,1,98,1,98,1,99,5,99,1097,8,99,10,99,12,99,
  	1100,9,99,1,99,1,99,1,100,5,100,1105,8,100,10,100,12,100,1108,9,100,1,
  	100,1,100,1,101,5,101,1113,8,101,10,101,12,101,1116,9,101,1,101,1,101,
  	1,102,5,102,1121,8,102,10,102,12,102,1124,9,102,1,102,1,102,1,103,5,103,
  	1129,8,103,10,103,12,103,1132,9,103,1,103,1,103,1,104,5,104,1137,8,104,
  	10,104,12,104,1140,9,104,1,104,1,104,1,105,1,105,1,106,1,106,1,107,1,
  	107,1,108,1,108,1,109,1,109,1,110,1,110,1,110,0,0,111,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,0,23,1,0,43,46,1,0,21,24,1,0,36,37,1,0,62,63,1,0,64,65,
  	1,0,74,77,1,0,109,111,1,0,86,92,2,0,81,84,93,94,1,0,96,97,1,0,106,107,
  	1,0,113,114,2,0,14,14,127,129,2,0,53,53,128,128,3,0,53,53,128,129,134,
  	134,2,0,130,130,133,133,1,0,131,133,1,0,32,33,1,0,34,35,1,0,1,2,1,0,28,
  	29,1,0,38,39,1,0,57,58,1216,0,229,1,0,0,0,2,240,1,0,0,0,4,244,1,0,0,0,
  	6,249,1,0,0,0,8,253,1,0,0,0,10,257,1,0,0,0,12,265,1,0,0,0,14,274,1,0,
  	0,0,16,278,1,0,0,0,18,293,1,0,0,0,20,305,1,0,0,0,22,316,1,0,0,0,24,334,
  	1,0,0,0,26,336,1,0,0,0,28,354,1,0,0,0,30,367,1,0,0,0,32,382,1,0,0,0,34,
  	398,1,0,0,0,36,402,1,0,0,0,38,405,1,0,0,0,40,408,1,0,0,0,42,413,1,0,0,
  	0,44,430,1,0,0,0,46,432,1,0,0,0,48,455,1,0,0,0,50,478,1,0,0,0,52,540,
  	1,0,0,0,54,549,1,0,0,0,56,558,1,0,0,0,58,560,1,0,0,0,60,564,1,0,0,0,62,
  	570,1,0,0,0,64,581,1,0,0,0,66,587,1,0,0,0,68,600,1,0,0,0,70,609,1,0,0,
  	0,72,611,1,0,0,0,74,625,1,0,0,0,76,629,1,0,0,0,78,635,1,0,0,0,80,644,
  	1,0,0,0,82,651,1,0,0,0,84,667,1,0,0,0,86,671,1,0,0,0,88,680,1,0,0,0,90,
  	687,1,0,0,0,92,694,1,0,0,0,94,701,1,0,0,0,96,714,1,0,0,0,98,718,1,0,0,
  	0,100,721,1,0,0,0,102,735,1,0,0,0,104,739,1,0,0,0,106,742,1,0,0,0,108,
  	756,1,0,0,0,110,760,1,0,0,0,112,763,1,0,0,0,114,776,1,0,0,0,116,780,1,
  	0,0,0,118,794,1,0,0,0,120,807,1,0,0,0,122,838,1,0,0,0,124,840,1,0,0,0,
  	126,856,1,0,0,0,128,860,1,0,0,0,130,871,1,0,0,0,132,884,1,0,0,0,134,888,
  	1,0,0,0,136,897,1,0,0,0,138,903,1,0,0,0,140,914,1,0,0,0,142,918,1,0,0,
  	0,144,921,1,0,0,0,146,934,1,0,0,0,148,947,1,0,0,0,150,951,1,0,0,0,152,
  	955,1,0,0,0,154,970,1,0,0,0,156,974,1,0,0,0,158,983,1,0,0,0,160,989,1,
  	0,0,0,162,995,1,0,0,0,164,999,1,0,0,0,166,1001,1,0,0,0,168,1015,1,0,0,
  	0,170,1019,1,0,0,0,172,1021,1,0,0,0,174,1023,1,0,0,0,176,1025,1,0,0,0,
  	178,1027,1,0,0,0,180,1029,1,0,0,0,182,1034,1,0,0,0,184,1042,1,0,0,0,186,
  	1050,1,0,0,0,188,1058,1,0,0,0,190,1066,1,0,0,0,192,1074,1,0,0,0,194,1082,
  	1,0,0,0,196,1090,1,0,0,0,198,1098,1,0,0,0,200,1106,1,0,0,0,202,1114,1,
  	0,0,0,204,1122,1,0,0,0,206,1130,1,0,0,0,208,1138,1,0,0,0,210,1143,1,0,
  	0,0,212,1145,1,0,0,0,214,1147,1,0,0,0,216,1149,1,0,0,0,218,1151,1,0,0,
  	0,220,1153,1,0,0,0,222,228,3,2,1,0,223,228,3,16,8,0,224,228,3,18,9,0,
  	225,228,3,20,10,0,226,228,3,22,11,0,227,222,1,0,0,0,227,223,1,0,0,0,227,
  	224,1,0,0,0,227,225,1,0,0,0,227,226,1,0,0,0,228,231,1,0,0,0,229,227,1,
  	0,0,0,229,230,1,0,0,0,230,232,1,0,0,0,231,229,1,0,0,0,232,233,5,0,0,1,
  	233,1,1,0,0,0,234,241,3,4,2,0,235,241,3,6,3,0,236,241,3,8,4,0,237,241,
  	3,10,5,0,238,241,3,12,6,0,239,241,3,14,7,0,240,234,1,0,0,0,240,235,1,
  	0,0,0,240,236,1,0,0,0,240,237,1,0,0,0,240,238,1,0,0,0,240,239,1,0,0,0,
  	241,242,1,0,0,0,242,243,5,120,0,0,243,3,1,0,0,0,244,245,5,5,0,0,245,246,
  	5,141,0,0,246,247,5,142,0,0,247,248,5,143,0,0,248,5,1,0,0,0,249,250,5,
  	125,0,0,250,251,5,121,0,0,251,252,3,164,82,0,252,7,1,0,0,0,253,254,5,
  	10,0,0,254,255,3,176,88,0,255,256,3,176,88,0,256,9,1,0,0,0,257,260,5,
  	54,0,0,258,261,3,170,85,0,259,261,3,164,82,0,260,258,1,0,0,0,260,259,
  	1,0,0,0,261,262,1,0,0,0,262,263,3,152,76,0,263,264,5,125,0,0,264,11,1,
  	0,0,0,265,266,5,51,0,0,266,267,5,133,0,0,267,270,5,133,0,0,268,269,5,
  	49,0,0,269,271,5,133,0,0,270,268,1,0,0,0,270,271,1,0,0,0,271,272,1,0,
  	0,0,272,273,3,174,87,0,273,13,1,0,0,0,274,275,5,52,0,0,275,276,3,56,28,
  	0,276,277,3,174,87,0,277,15,1,0,0,0,278,279,5,6,0,0,279,281,3,176,88,
  	0,280,282,5,25,0,0,281,280,1,0,0,0,281,282,1,0,0,0,282,283,1,0,0,0,283,
  	285,5,115,0,0,284,286,3,24,12,0,285,284,1,0,0,0,286,287,1,0,0,0,287,285,
  	1,0,0,0,287,288,1,0,0,0,288,289,1,0,0,0,289,290,5,116,0,0,290,291,3,176,
  	88,0,291,292,5,120,0,0,292,17,1,0,0,0,293,303,5,7,0,0,294,304,3,72,36,
  	0,295,304,3,82,41,0,296,304,3,94,47,0,297,304,3,100,50,0,298,304,3,106,
  	53,0,299,304,3,112,56,0,300,304,3,118,59,0,301,304,3,124,62,0,302,304,
  	3,146,73,0,303,294,1,0,0,0,303,295,1,0,0,0,303,296,1,0,0,0,303,297,1,
  	0,0,0,303,298,1,0,0,0,303,299,1,0,0,0,303,300,1,0,0,0,303,301,1,0,0,0,
  	303,302,1,0,0,0,304,19,1,0,0,0,305,306,3,214,107,0,306,307,5,136,0,0,
  	307,311,5,137,0,0,308,310,5,139,0,0,309,308,1,0,0,0,310,313,1,0,0,0,311,
  	309,1,0,0,0,311,312,1,0,0,0,312,314,1,0,0,0,313,311,1,0,0,0,314,315,5,
  	138,0,0,315,21,1,0,0,0,316,317,5,12,0,0,317,319,3,174,87,0,318,320,5,
  	25,0,0,319,318,1,0,0,0,319,320,1,0,0,0,320,321,1,0,0,0,321,323,5,115,
  	0,0,322,324,3,34,17,0,323,322,1,0,0,0,324,325,1,0,0,0,325,323,1,0,0,0,
  	325,326,1,0,0,0,326,327,1,0,0,0,327,328,5,116,0,0,328,329,3,174,87,0,
  	329,330,5,120,0,0,330,23,1,0,0,0,331,335,3,34,17,0,332,335,3,26,13,0,
  	333,335,3,28,14,0,334,331,1,0,0,0,334,332,1,0,0,0,334,333,1,0,0,0,335,
  	25,1,0,0,0,336,337,5,12,0,0,337,350,3,174,87,0,338,340,5,25,0,0,339,338,
  	1,0,0,0,339,340,1,0,0,0,340,341,1,0,0,0,341,343,5,115,0,0,342,344,3,34,
  	17,0,343,342,1,0,0,0,344,345,1,0,0,0,345,343,1,0,0,0,345,346,1,0,0,0,
  	346,347,1,0,0,0,347,348,5,116,0,0,348,349,3,174,87,0,349,351,1,0,0,0,
  	350,339,1,0,0,0,350,351,1,0,0,0,351,352,1,0,0,0,352,353,5,120,0,0,353,
  	27,1,0,0,0,354,355,5,42,0,0,355,359,5,115,0,0,356,358,3,30,15,0,357,356,
  	1,0,0,0,358,361,1,0,0,0,359,357,1,0,0,0,359,360,1,0,0,0,360,362,1,0,0,
  	0,361,359,1,0,0,0,362,363,5,116,0,0,363,364,5,120,0,0,364,29,1,0,0,0,
  	365,368,3,32,16,0,366,368,3,4,2,0,367,365,1,0,0,0,367,366,1,0,0,0,368,
  	369,1,0,0,0,369,370,5,120,0,0,370,31,1,0,0,0,371,372,7,0,0,0,372,374,
  	5,115,0,0,373,375,3,140,70,0,374,373,1,0,0,0,375,376,1,0,0,0,376,374,
  	1,0,0,0,376,377,1,0,0,0,377,378,1,0,0,0,378,379,5,116,0,0,379,383,1,0,
  	0,0,380,381,5,47,0,0,381,383,3,180,90,0,382,371,1,0,0,0,382,380,1,0,0,
  	0,383,33,1,0,0,0,384,399,3,36,18,0,385,399,3,38,19,0,386,399,3,40,20,
  	0,387,399,3,42,21,0,388,399,3,6,3,0,389,399,3,46,23,0,390,399,3,48,24,
  	0,391,399,3,10,5,0,392,399,3,50,25,0,393,399,3,64,32,0,394,399,3,66,33,
  	0,395,399,3,68,34,0,396,399,3,70,35,0,397,399,3,4,2,0,398,384,1,0,0,0,
  	398,385,1,0,0,0,398,386,1,0,0,0,398,387,1,0,0,0,398,388,1,0,0,0,398,389,
  	1,0,0,0,398,390,1,0,0,0,398,391,1,0,0,0,398,392,1,0,0,0,398,393,1,0,0,
  	0,398,394,1,0,0,0,398,395,1,0,0,0,398,396,1,0,0,0,398,397,1,0,0,0,399,
  	400,1,0,0,0,400,401,5,120,0,0,401,35,1,0,0,0,402,403,5,6,0,0,403,404,
  	3,176,88,0,404,37,1,0,0,0,405,406,5,8,0,0,406,407,3,176,88,0,407,39,1,
  	0,0,0,408,409,5,9,0,0,409,411,3,176,88,0,410,412,7,1,0,0,411,410,1,0,
  	0,0,411,412,1,0,0,0,412,41,1,0,0,0,413,420,5,13,0,0,414,421,5,133,0,0,
  	415,417,3,44,22,0,416,415,1,0,0,0,417,418,1,0,0,0,418,416,1,0,0,0,418,
  	419,1,0,0,0,419,421,1,0,0,0,420,414,1,0,0,0,420,416,1,0,0,0,421,43,1,
  	0,0,0,422,431,5,15,0,0,423,431,5,16,0,0,424,431,5,17,0,0,425,431,5,18,
  	0,0,426,427,5,20,0,0,427,431,3,164,82,0,428,429,5,19,0,0,429,431,3,164,
  	82,0,430,422,1,0,0,0,430,423,1,0,0,0,430,424,1,0,0,0,430,425,1,0,0,0,
  	430,426,1,0,0,0,430,428,1,0,0,0,431,45,1,0,0,0,432,436,5,31,0,0,433,437,
  	3,210,105,0,434,437,3,212,106,0,435,437,3,218,109,0,436,433,1,0,0,0,436,
  	434,1,0,0,0,436,435,1,0,0,0,437,438,1,0,0,0,438,443,3,154,77,0,439,440,
  	5,123,0,0,440,442,3,154,77,0,441,439,1,0,0,0,442,445,1,0,0,0,443,441,
  	1,0,0,0,443,444,1,0,0,0,444,47,1,0,0,0,445,443,1,0,0,0,446,447,5,30,0,
  	0,447,452,3,154,77,0,448,449,5,123,0,0,449,451,3,154,77,0,450,448,1,0,
  	0,0,451,454,1,0,0,0,452,450,1,0,0,0,452,453,1,0,0,0,453,456,1,0,0,0,454,
  	452,1,0,0,0,455,446,1,0,0,0,455,456,1,0,0,0,456,475,1,0,0,0,457,458,3,
  	212,106,0,458,464,3,154,77,0,459,462,5,36,0,0,460,463,5,60,0,0,461,463,
  	3,154,77,0,462,460,1,0,0,0,462,461,1,0,0,0,463,465,1,0,0,0,464,459,1,
  	0,0,0,464,465,1,0,0,0,465,476,1,0,0,0,466,467,3,210,105,0,467,473,3,154,
  	77,0,468,471,7,2,0,0,469,472,5,60,0,0,470,472,3,154,77,0,471,469,1,0,
  	0,0,471,470,1,0,0,0,472,474,1,0,0,0,473,468,1,0,0,0,473,474,1,0,0,0,474,
  	476,1,0,0,0,475,457,1,0,0,0,475,466,1,0,0,0,476,49,1,0,0,0,477,479,3,
  	216,108,0,478,477,1,0,0,0,478,479,1,0,0,0,479,480,1,0,0,0,480,482,3,218,
  	109,0,481,483,3,158,79,0,482,481,1,0,0,0,482,483,1,0,0,0,483,538,1,0,
  	0,0,484,488,3,54,27,0,485,487,3,52,26,0,486,485,1,0,0,0,487,490,1,0,0,
  	0,488,486,1,0,0,0,488,489,1,0,0,0,489,539,1,0,0,0,490,488,1,0,0,0,491,
  	492,5,12,0,0,492,494,3,174,87,0,493,491,1,0,0,0,494,495,1,0,0,0,495,493,
  	1,0,0,0,495,496,1,0,0,0,496,500,1,0,0,0,497,499,3,156,78,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,539,1,0,0,0,
  	502,500,1,0,0,0,503,504,5,55,0,0,504,506,3,58,29,0,505,507,3,158,79,0,
  	506,505,1,0,0,0,506,507,1,0,0,0,507,539,1,0,0,0,508,509,5,56,0,0,509,
  	511,3,158,79,0,510,512,3,60,30,0,511,510,1,0,0,0,512,513,1,0,0,0,513,
  	511,1,0,0,0,513,514,1,0,0,0,514,516,1,0,0,0,515,517,3,158,79,0,516,515,
  	1,0,0,0,516,517,1,0,0,0,517,539,1,0,0,0,518,519,3,220,110,0,519,521,3,
  	158,79,0,520,522,3,62,31,0,521,520,1,0,0,0,522,523,1,0,0,0,523,521,1,
  	0,0,0,523,524,1,0,0,0,524,526,1,0,0,0,525,527,3,158,79,0,526,525,1,0,
  	0,0,526,527,1,0,0,0,527,539,1,0,0,0,528,529,5,53,0,0,529,531,3,158,79,
  	0,530,532,3,60,30,0,531,530,1,0,0,0,532,533,1,0,0,0,533,531,1,0,0,0,533,
  	534,1,0,0,0,534,536,1,0,0,0,535,537,3,158,79,0,536,535,1,0,0,0,536,537,
  	1,0,0,0,537,539,1,0,0,0,538,484,1,0,0,0,538,493,1,0,0,0,538,503,1,0,0,
  	0,538,508,1,0,0,0,538,518,1,0,0,0,538,528,1,0,0,0,539,51,1,0,0,0,540,
  	542,3,160,80,0,541,543,3,54,27,0,542,541,1,0,0,0,542,543,1,0,0,0,543,
  	53,1,0,0,0,544,545,5,26,0,0,545,546,3,174,87,0,546,547,5,27,0,0,547,550,
  	1,0,0,0,548,550,3,56,28,0,549,544,1,0,0,0,549,548,1,0,0,0,550,55,1,0,
  	0,0,551,552,5,26,0,0,552,553,5,133,0,0,553,554,5,133,0,0,554,555,5,133,
  	0,0,555,556,5,133,0,0,556,559,5,27,0,0,557,559,5,133,0,0,558,551,1,0,
  	0,0,558,557,1,0,0,0,559,57,1,0,0,0,560,561,3,160,80,0,561,562,3,152,76,
  	0,562,563,3,152,76,0,563,59,1,0,0,0,564,565,3,152,76,0,565,566,5,53,0,
  	0,566,568,5,125,0,0,567,569,5,122,0,0,568,567,1,0,0,0,568,569,1,0,0,0,
  	569,61,1,0,0,0,570,573,3,152,76,0,571,572,5,53,0,0,572,574,5,125,0,0,
  	573,571,1,0,0,0,573,574,1,0,0,0,574,576,1,0,0,0,575,577,5,59,0,0,576,
  	575,1,0,0,0,576,577,1,0,0,0,577,579,1,0,0,0,578,580,5,122,0,0,579,578,
  	1,0,0,0,579,580,1,0,0,0,580,63,1,0,0,0,581,583,5,40,0,0,582,584,3,178,
  	89,0,583,582,1,0,0,0,584,585,1,0,0,0,585,583,1,0,0,0,585,586,1,0,0,0,
  	586,65,1,0,0,0,587,594,5,48,0,0,588,592,3,180,90,0,589,590,3,180,90,0,
  	590,591,3,180,90,0,591,593,1,0,0,0,592,589,1,0,0,0,592,593,1,0,0,0,593,
  	595,1,0,0,0,594,588,1,0,0,0,594,595,1,0,0,0,595,596,1,0,0,0,596,597,5,
  	124,0,0,597,598,5,144,0,0,598,599,5,145,0,0,599,67,1,0,0,0,600,601,5,
  	41,0,0,601,603,5,115,0,0,602,604,3,140,70,0,603,602,1,0,0,0,604,605,1,
  	0,0,0,605,603,1,0,0,0,605,606,1,0,0,0,606,607,1,0,0,0,607,608,5,116,0,
  	0,608,69,1,0,0,0,609,610,5,11,0,0,610,71,1,0,0,0,611,612,5,61,0,0,612,
  	614,5,115,0,0,613,615,3,74,37,0,614,613,1,0,0,0,615,616,1,0,0,0,616,614,
  	1,0,0,0,616,617,1,0,0,0,617,618,1,0,0,0,618,619,5,116,0,0,619,620,5,61,
  	0,0,620,621,5,120,0,0,621,73,1,0,0,0,622,626,3,76,38,0,623,626,3,78,39,
  	0,624,626,3,4,2,0,625,622,1,0,0,0,625,623,1,0,0,0,625,624,1,0,0,0,626,
  	627,1,0,0,0,627,628,5,120,0,0,628,75,1,0,0,0,629,631,7,3,0,0,630,632,
  	3,176,88,0,631,630,1,0,0,0,632,633,1,0,0,0,633,631,1,0,0,0,633,634,1,
  	0,0,0,634,77,1,0,0,0,635,636,7,4,0,0,636,641,3,80,40,0,637,638,5,123,
  	0,0,638,640,3,80,40,0,639,637,1,0,0,0,640,643,1,0,0,0,641,639,1,0,0,0,
  	641,642,1,0,0,0,642,79,1,0,0,0,643,641,1,0,0,0,644,645,3,176,88,0,645,
  	647,3,176,88,0,646,648,5,133,0,0,647,646,1,0,0,0,648,649,1,0,0,0,649,
  	647,1,0,0,0,649,650,1,0,0,0,650,81,1,0,0,0,651,652,5,66,0,0,652,654,5,
  	115,0,0,653,655,3,84,42,0,654,653,1,0,0,0,655,656,1,0,0,0,656,654,1,0,
  	0,0,656,657,1,0,0,0,657,658,1,0,0,0,658,659,5,116,0,0,659,660,5,66,0,
  	0,660,661,5,120,0,0,661,83,1,0,0,0,662,668,3,86,43,0,663,668,3,88,44,
  	0,664,668,3,90,45,0,665,668,3,92,46,0,666,668,3,4,2,0,667,662,1,0,0,0,
  	667,663,1,0,0,0,667,664,1,0,0,0,667,665,1,0,0,0,667,666,1,0,0,0,668,669,
  	1,0,0,0,669,670,5,120,0,0,670,85,1,0,0,0,671,672,5,67,0,0,672,673,3,162,
  	81,0,673,674,5,123,0,0,674,675,3,162,81,0,675,676,5,123,0,0,676,677,3,
  	162,81,0,677,678,5,123,0,0,678,679,3,162,81,0,679,87,1,0,0,0,680,681,
  	5,68,0,0,681,683,3,154,77,0,682,684,5,133,0,0,683,682,1,0,0,0,684,685,
  	1,0,0,0,685,683,1,0,0,0,685,686,1,0,0,0,686,89,1,0,0,0,687,688,5,69,0,
  	0,688,690,3,154,77,0,689,691,5,133,0,0,690,689,1,0,0,0,691,692,1,0,0,
  	0,692,690,1,0,0,0,692,693,1,0,0,0,693,91,1,0,0,0,694,695,5,70,0,0,695,
  	697,3,154,77,0,696,698,5,133,0,0,697,696,1,0,0,0,698,699,1,0,0,0,699,
  	697,1,0,0,0,699,700,1,0,0,0,700,93,1,0,0,0,701,702,5,71,0,0,702,704,5,
  	115,0,0,703,705,3,96,48,0,704,703,1,0,0,0,705,706,1,0,0,0,706,704,1,0,
  	0,0,706,707,1,0,0,0,707,708,1,0,0,0,708,709,5,116,0,0,709,710,5,71,0,
  	0,710,711,5,120,0,0,711,95,1,0,0,0,712,715,3,98,49,0,713,715,3,4,2,0,
  	714,712,1,0,0,0,714,713,1,0,0,0,715,716,1,0,0,0,716,717,5,120,0,0,717,
  	97,1,0,0,0,718,719,5,72,0,0,719,720,5,130,0,0,720,99,1,0,0,0,721,722,
  	5,73,0,0,722,726,5,115,0,0,723,725,3,102,51,0,724,723,1,0,0,0,725,728,
  	1,0,0,0,726,724,1,0,0,0,726,727,1,0,0,0,727,729,1,0,0,0,728,726,1,0,0,
  	0,729,730,5,116,0,0,730,731,5,73,0,0,731,732,5,120,0,0,732,101,1,0,0,
  	0,733,736,3,104,52,0,734,736,3,4,2,0,735,733,1,0,0,0,735,734,1,0,0,0,
  	736,737,1,0,0,0,737,738,5,120,0,0,738,103,1,0,0,0,739,740,7,5,0,0,740,
  	741,5,133,0,0,741,105,1,0,0,0,742,743,5,108,0,0,743,747,5,115,0,0,744,
  	746,3,108,54,0,745,744,1,0,0,0,746,749,1,0,0,0,747,745,1,0,0,0,747,748,
  	1,0,0,0,748,750,1,0,0,0,749,747,1,0,0,0,750,751,5,116,0,0,751,752,5,108,
  	0,0,752,753,5,120,0,0,753,107,1,0,0,0,754,757,3,110,55,0,755,757,3,4,
  	2,0,756,754,1,0,0,0,756,755,1,0,0,0,757,758,1,0,0,0,758,759,5,120,0,0,
  	759,109,1,0,0,0,760,761,7,6,0,0,761,762,5,133,0,0,762,111,1,0,0,0,763,
  	764,5,78,0,0,764,766,5,115,0,0,765,767,3,114,57,0,766,765,1,0,0,0,767,
  	768,1,0,0,0,768,766,1,0,0,0,768,769,1,0,0,0,769,770,1,0,0,0,770,771,5,
  	116,0,0,771,772,5,78,0,0,772,773,5,120,0,0,773,113,1,0,0,0,774,777,3,
  	116,58,0,775,777,3,4,2,0,776,774,1,0,0,0,776,775,1,0,0,0,777,778,1,0,
  	0,0,778,779,5,120,0,0,779,115,1,0,0,0,780,781,5,79,0,0,781,788,3,180,
  	90,0,782,786,3,180,90,0,783,784,3,180,90,0,784,785,3,180,90,0,785,787,
  	1,0,0,0,786,783,1,0,0,0,786,787,1,0,0,0,787,789,1,0,0,0,788,782,1,0,0,
  	0,788,789,1,0,0,0,789,790,1,0,0,0,790,791,5,124,0,0,791,792,5,144,0,0,
  	792,793,5,145,0,0,793,117,1,0,0,0,794,795,5,80,0,0,795,797,5,115,0,0,
  	796,798,3,120,60,0,797,796,1,0,0,0,798,799,1,0,0,0,799,797,1,0,0,0,799,
  	800,1,0,0,0,800,801,1,0,0,0,801,802,5,116,0,0,802,803,5,80,0,0,803,804,
  	5,120,0,0,804,119,1,0,0,0,805,808,3,122,61,0,806,808,3,4,2,0,807,805,
  	1,0,0,0,807,806,1,0,0,0,808,809,1,0,0,0,809,810,5,120,0,0,810,121,1,0,
  	0,0,811,812,7,7,0,0,812,839,5,133,0,0,813,814,7,8,0,0,814,839,5,133,0,
  	0,815,816,5,98,0,0,816,839,3,180,90,0,817,818,5,95,0,0,818,819,5,124,
  	0,0,819,820,5,144,0,0,820,839,5,145,0,0,821,822,5,85,0,0,822,823,5,133,
  	0,0,823,824,5,133,0,0,824,825,5,133,0,0,825,826,5,133,0,0,826,827,5,133,
  	0,0,827,828,5,133,0,0,828,829,5,133,0,0,829,830,5,133,0,0,830,831,5,133,
  	0,0,831,839,5,133,0,0,832,834,7,9,0,0,833,835,5,133,0,0,834,833,1,0,0,
  	0,835,836,1,0,0,0,836,834,1,0,0,0,836,837,1,0,0,0,837,839,1,0,0,0,838,
  	811,1,0,0,0,838,813,1,0,0,0,838,815,1,0,0,0,838,817,1,0,0,0,838,821,1,
  	0,0,0,838,832,1,0,0,0,839,123,1,0,0,0,840,841,5,99,0,0,841,843,5,115,
  	0,0,842,844,3,126,63,0,843,842,1,0,0,0,844,845,1,0,0,0,845,843,1,0,0,
  	0,845,846,1,0,0,0,846,847,1,0,0,0,847,848,5,116,0,0,848,849,5,99,0,0,
  	849,850,5,120,0,0,850,125,1,0,0,0,851,857,3,128,64,0,852,857,3,130,65,
  	0,853,857,3,138,69,0,854,857,3,142,71,0,855,857,3,4,2,0,856,851,1,0,0,
  	0,856,852,1,0,0,0,856,853,1,0,0,0,856,854,1,0,0,0,856,855,1,0,0,0,857,
  	858,1,0,0,0,858,859,5,120,0,0,859,127,1,0,0,0,860,861,5,102,0,0,861,862,
  	3,176,88,0,862,863,5,133,0,0,863,865,5,115,0,0,864,866,3,140,70,0,865,
  	864,1,0,0,0,866,867,1,0,0,0,867,865,1,0,0,0,867,868,1,0,0,0,868,869,1,
  	0,0,0,869,870,5,116,0,0,870,129,1,0,0,0,871,872,5,103,0,0,872,874,5,115,
  	0,0,873,875,3,132,66,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,878,1,0,0,0,878,879,5,116,0,0,879,131,1,0,0,0,880,
  	885,3,144,72,0,881,885,3,134,67,0,882,885,3,136,68,0,883,885,3,4,2,0,
  	884,880,1,0,0,0,884,881,1,0,0,0,884,882,1,0,0,0,884,883,1,0,0,0,885,886,
  	1,0,0,0,886,887,5,120,0,0,887,133,1,0,0,0,888,889,5,105,0,0,889,890,3,
  	176,88,0,890,895,3,178,89,0,891,893,3,178,89,0,892,894,3,178,89,0,893,
  	892,1,0,0,0,893,894,1,0,0,0,894,896,1,0,0,0,895,891,1,0,0,0,895,896,1,
  	0,0,0,896,135,1,0,0,0,897,899,5,104,0,0,898,900,7,10,0,0,899,898,1,0,
  	0,0,900,901,1,0,0,0,901,899,1,0,0,0,901,902,1,0,0,0,902,137,1,0,0,0,903,
  	904,5,100,0,0,904,906,5,115,0,0,905,907,3,140,70,0,906,905,1,0,0,0,907,
  	908,1,0,0,0,908,906,1,0,0,0,908,909,1,0,0,0,909,910,1,0,0,0,910,911,5,
  	116,0,0,911,139,1,0,0,0,912,915,3,144,72,0,913,915,3,4,2,0,914,912,1,
  	0,0,0,914,913,1,0,0,0,915,916,1,0,0,0,916,917,5,120,0,0,917,141,1,0,0,
  	0,918,919,5,101,0,0,919,920,3,180,90,0,920,143,1,0,0,0,921,928,5,78,0,
  	0,922,926,3,180,90,0,923,924,3,180,90,0,924,925,3,180,90,0,925,927,1,
  	0,0,0,926,923,1,0,0,0,926,927,1,0,0,0,927,929,1,0,0,0,928,922,1,0,0,0,
  	928,929,1,0,0,0,929,930,1,0,0,0,930,931,5,124,0,0,931,932,5,144,0,0,932,
  	933,5,145,0,0,933,145,1,0,0,0,934,935,5,112,0,0,935,937,5,115,0,0,936,
  	938,3,148,74,0,937,936,1,0,0,0,938,939,1,0,0,0,939,937,1,0,0,0,939,940,
  	1,0,0,0,940,941,1,0,0,0,941,942,5,116,0,0,942,943,5,112,0,0,943,944,5,
  	120,0,0,944,147,1,0,0,0,945,948,3,150,75,0,946,948,3,4,2,0,947,945,1,
  	0,0,0,947,946,1,0,0,0,948,949,1,0,0,0,949,950,5,120,0,0,950,149,1,0,0,
  	0,951,952,7,11,0,0,952,953,3,170,85,0,953,954,5,133,0,0,954,151,1,0,0,
  	0,955,956,5,26,0,0,956,965,5,50,0,0,957,958,5,133,0,0,958,961,5,133,0,
  	0,959,960,5,49,0,0,960,962,5,133,0,0,961,959,1,0,0,0,961,962,1,0,0,0,
  	962,966,1,0,0,0,963,966,5,60,0,0,964,966,3,174,87,0,965,957,1,0,0,0,965,
  	963,1,0,0,0,965,964,1,0,0,0,966,967,1,0,0,0,967,968,5,27,0,0,968,153,
  	1,0,0,0,969,971,3,156,78,0,970,969,1,0,0,0,971,972,1,0,0,0,972,970,1,
  	0,0,0,972,973,1,0,0,0,973,155,1,0,0,0,974,979,3,160,80,0,975,976,5,12,
  	0,0,976,978,3,174,87,0,977,975,1,0,0,0,978,981,1,0,0,0,979,977,1,0,0,
  	0,979,980,1,0,0,0,980,157,1,0,0,0,981,979,1,0,0,0,982,984,3,160,80,0,
  	983,982,1,0,0,0,984,985,1,0,0,0,985,983,1,0,0,0,985,986,1,0,0,0,986,159,
  	1,0,0,0,987,990,3,164,82,0,988,990,3,170,85,0,989,987,1,0,0,0,989,988,
  	1,0,0,0,990,992,1,0,0,0,991,993,5,122,0,0,992,991,1,0,0,0,992,993,1,0,
  	0,0,993,161,1,0,0,0,994,996,3,164,82,0,995,994,1,0,0,0,995,996,1,0,0,
  	0,996,163,1,0,0,0,997,1000,5,125,0,0,998,1000,3,166,83,0,999,997,1,0,
  	0,0,999,998,1,0,0,0,1000,165,1,0,0,0,1001,1003,5,117,0,0,1002,1004,3,
  	168,84,0,1003,1002,1,0,0,0,1004,1005,1,0,0,0,1005,1003,1,0,0,0,1005,1006,
  	1,0,0,0,1006,1007,1,0,0,0,1007,1008,5,118,0,0,1008,167,1,0,0,0,1009,1012,
  	3,170,85,0,1010,1011,5,119,0,0,1011,1013,3,170,85,0,1012,1010,1,0,0,0,
  	1012,1013,1,0,0,0,1013,1016,1,0,0,0,1014,1016,5,125,0,0,1015,1009,1,0,
  	0,0,1015,1014,1,0,0,0,1016,169,1,0,0,0,1017,1020,3,172,86,0,1018,1020,
  	5,126,0,0,1019,1017,1,0,0,0,1019,1018,1,0,0,0,1020,171,1,0,0,0,1021,1022,
  	7,12,0,0,1022,173,1,0,0,0,1023,1024,7,13,0,0,1024,175,1,0,0,0,1025,1026,
  	7,14,0,0,1026,177,1,0,0,0,1027,1028,7,15,0,0,1028,179,1,0,0,0,1029,1030,
  	7,16,0,0,1030,181,1,0,0,0,1031,1033,3,24,12,0,1032,1031,1,0,0,0,1033,
  	1036,1,0,0,0,1034,1032,1,0,0,0,1034,1035,1,0,0,0,1035,1037,1,0,0,0,1036,
  	1034,1,0,0,0,1037,1038,5,0,0,1,1038,183,1,0,0,0,1039,1041,3,34,17,0,1040,
  	1039,1,0,0,0,1041,1044,1,0,0,0,1042,1040,1,0,0,0,1042,1043,1,0,0,0,1043,
  	1045,1,0,0,0,1044,1042,1,0,0,0,1045,1046,5,0,0,1,1046,185,1,0,0,0,1047,
  	1049,3,30,15,0,1048,1047,1,0,0,0,1049,1052,1,0,0,0,1050,1048,1,0,0,0,
  	1050,1051,1,0,0,0,1051,1053,1,0,0,0,1052,1050,1,0,0,0,1053,1054,5,0,0,
  	1,1054,187,1,0,0,0,1055,1057,3,74,37,0,1056,1055,1,0,0,0,1057,1060,1,
  	0,0,0,1058,1056,1,0,0,0,1058,1059,1,0,0,0,1059,1061,1,0,0,0,1060,1058,
  	1,0,0,0,1061,1062,5,0,0,1,1062,189,1,0,0,0,1063,1065,3,96,48,0,1064,1063,
  	1,0,0,0,1065,1068,1,0,0,0,1066,1064,1,0,0,0,1066,1067,1,0,0,0,1067,1069,
  	1,0,0,0,1068,1066,1,0,0,0,1069,1070,5,0,0,1,1070,191,1,0,0,0,1071,1073,
  	3,102,51,0,1072,1071,1,0,0,0,1073,1076,1,0,0,0,1074,1072,1,0,0,0,1074,
  	1075,1,0,0,0,1075,1077,1,0,0,0,1076,1074,1,0,0,0,1077,1078,5,0,0,1,1078,
  	193,1,0,0,0,1079,1081,3,108,54,0,1080,1079,1,0,0,0,1081,1084,1,0,0,0,
  	1082,1080,1,0,0,0,1082,1083,1,0,0,0,1083,1085,1,0,0,0,1084,1082,1,0,0,
  	0,1085,1086,5,0,0,1,1086,195,1,0,0,0,1087,1089,3,84,42,0,1088,1087,1,
  	0,0,0,1089,1092,1,0,0,0,1090,1088,1,0,0,0,1090,1091,1,0,0,0,1091,1093,
  	1,0,0,0,1092,1090,1,0,0,0,1093,1094,5,0,0,1,1094,197,1,0,0,0,1095,1097,
  	3,114,57,0,1096,1095,1,0,0,0,1097,1100,1,0,0,0,1098,1096,1,0,0,0,1098,
  	1099,1,0,0,0,1099,1101,1,0,0,0,1100,1098,1,0,0,0,1101,1102,5,0,0,1,1102,
  	199,1,0,0,0,1103,1105,3,148,74,0,1104,1103,1,0,0,0,1105,1108,1,0,0,0,
  	1106,1104,1,0,0,0,1106,1107,1,0,0,0,1107,1109,1,0,0,0,1108,1106,1,0,0,
  	0,1109,1110,5,0,0,1,1110,201,1,0,0,0,1111,1113,3,120,60,0,1112,1111,1,
  	0,0,0,1113,1116,1,0,0,0,1114,1112,1,0,0,0,1114,1115,1,0,0,0,1115,1117,
  	1,0,0,0,1116,1114,1,0,0,0,1117,1118,5,0,0,1,1118,203,1,0,0,0,1119,1121,
  	3,126,63,0,1120,1119,1,0,0,0,1121,1124,1,0,0,0,1122,1120,1,0,0,0,1122,
  	1123,1,0,0,0,1123,1125,1,0,0,0,1124,1122,1,0,0,0,1125,1126,5,0,0,1,1126,
  	205,1,0,0,0,1127,1129,3,132,66,0,1128,1127,1,0,0,0,1129,1132,1,0,0,0,
  	1130,1128,1,0,0,0,1130,1131,1,0,0,0,1131,1133,1,0,0,0,1132,1130,1,0,0,
  	0,1133,1134,5,0,0,1,1134,207,1,0,0,0,1135,1137,3,140,70,0,1136,1135,1,
  	0,0,0,1137,1140,1,0,0,0,1138,1136,1,0,0,0,1138,1139,1,0,0,0,1139,1141,
  	1,0,0,0,1140,1138,1,0,0,0,1141,1142,5,0,0,1,1142,209,1,0,0,0,1143,1144,
  	7,17,0,0,1144,211,1,0,0,0,1145,1146,7,18,0,0,1146,213,1,0,0,0,1147,1148,
  	7,19,0,0,1148,215,1,0,0,0,1149,1150,7,20,0,0,1150,217,1,0,0,0,1151,1152,
  	7,21,0,0,1152,219,1,0,0,0,1153,1154,7,22,0,0,1154,221,1,0,0,0,122,227,
  	229,240,260,270,281,287,303,311,319,325,334,339,345,350,359,367,376,382,
  	398,411,418,420,430,436,443,452,455,462,464,471,473,475,478,482,488,495,
  	500,506,513,516,523,526,533,536,538,542,549,558,568,573,576,579,585,592,
  	594,605,616,625,633,641,649,656,667,685,692,699,706,714,726,735,747,756,
  	768,776,786,788,799,807,836,838,845,856,867,876,884,893,895,901,908,914,
  	926,928,939,947,961,965,972,979,985,989,992,995,999,1005,1012,1015,1019,
  	1034,1042,1050,1058,1066,1074,1082,1090,1098,1106,1114,1122,1130,1138
  };
  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);
  }
  featparserParserStaticData = std::move(staticData);
}

}

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

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

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

const atn::ATN& FeatParser::getATN() const {
  return *featparserParserStaticData->atn;
}

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

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

const dfa::Vocabulary& FeatParser::getVocabulary() const {
  return featparserParserStaticData->vocabulary;
}

antlr4::atn::SerializedATNView FeatParser::getSerializedATN() const {
  return featparserParserStaticData->serializedATN;
}


//----------------- FileContext ------------------------------------------------------------------

FeatParser::FileContext::FileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::FileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::TopLevelStatementContext *> FeatParser::FileContext::topLevelStatement() {
  return getRuleContexts<FeatParser::TopLevelStatementContext>();
}

FeatParser::TopLevelStatementContext* FeatParser::FileContext::topLevelStatement(size_t i) {
  return getRuleContext<FeatParser::TopLevelStatementContext>(i);
}

std::vector<FeatParser::FeatureBlockContext *> FeatParser::FileContext::featureBlock() {
  return getRuleContexts<FeatParser::FeatureBlockContext>();
}

FeatParser::FeatureBlockContext* FeatParser::FileContext::featureBlock(size_t i) {
  return getRuleContext<FeatParser::FeatureBlockContext>(i);
}

std::vector<FeatParser::TableBlockContext *> FeatParser::FileContext::tableBlock() {
  return getRuleContexts<FeatParser::TableBlockContext>();
}

FeatParser::TableBlockContext* FeatParser::FileContext::tableBlock(size_t i) {
  return getRuleContext<FeatParser::TableBlockContext>(i);
}

std::vector<FeatParser::AnonBlockContext *> FeatParser::FileContext::anonBlock() {
  return getRuleContexts<FeatParser::AnonBlockContext>();
}

FeatParser::AnonBlockContext* FeatParser::FileContext::anonBlock(size_t i) {
  return getRuleContext<FeatParser::AnonBlockContext>(i);
}

std::vector<FeatParser::LookupBlockTopLevelContext *> FeatParser::FileContext::lookupBlockTopLevel() {
  return getRuleContexts<FeatParser::LookupBlockTopLevelContext>();
}

FeatParser::LookupBlockTopLevelContext* FeatParser::FileContext::lookupBlockTopLevel(size_t i) {
  return getRuleContext<FeatParser::LookupBlockTopLevelContext>(i);
}


size_t FeatParser::FileContext::getRuleIndex() const {
  return FeatParser::RuleFile;
}


std::any FeatParser::FileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::FileContext* FeatParser::file() {
  FileContext *_localctx = _tracker.createInstance<FileContext>(_ctx, getState());
  enterRule(_localctx, 0, FeatParser::RuleFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(229);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 24769797950543078) != 0) || _la == FeatParser::GCLASS) {
      setState(227);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case FeatParser::INCLUDE:
        case FeatParser::LANGSYS:
        case FeatParser::ANCHOR_DEF:
        case FeatParser::VALUE_RECORD_DEF:
        case FeatParser::MARK_CLASS:
        case FeatParser::GCLASS: {
          setState(222);
          topLevelStatement();
          break;
        }

        case FeatParser::FEATURE: {
          setState(223);
          featureBlock();
          break;
        }

        case FeatParser::TABLE: {
          setState(224);
          tableBlock();
          break;
        }

        case FeatParser::ANON:
        case FeatParser::ANON_v: {
          setState(225);
          anonBlock();
          break;
        }

        case FeatParser::LOOKUP: {
          setState(226);
          lookupBlockTopLevel();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(231);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(232);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TopLevelStatementContext ------------------------------------------------------------------

FeatParser::TopLevelStatementContext::TopLevelStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::TopLevelStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::IncludeContext* FeatParser::TopLevelStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}

FeatParser::GlyphClassAssignContext* FeatParser::TopLevelStatementContext::glyphClassAssign() {
  return getRuleContext<FeatParser::GlyphClassAssignContext>(0);
}

FeatParser::LangsysAssignContext* FeatParser::TopLevelStatementContext::langsysAssign() {
  return getRuleContext<FeatParser::LangsysAssignContext>(0);
}

FeatParser::Mark_statementContext* FeatParser::TopLevelStatementContext::mark_statement() {
  return getRuleContext<FeatParser::Mark_statementContext>(0);
}

FeatParser::AnchorDefContext* FeatParser::TopLevelStatementContext::anchorDef() {
  return getRuleContext<FeatParser::AnchorDefContext>(0);
}

FeatParser::ValueRecordDefContext* FeatParser::TopLevelStatementContext::valueRecordDef() {
  return getRuleContext<FeatParser::ValueRecordDefContext>(0);
}


size_t FeatParser::TopLevelStatementContext::getRuleIndex() const {
  return FeatParser::RuleTopLevelStatement;
}


std::any FeatParser::TopLevelStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTopLevelStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::TopLevelStatementContext* FeatParser::topLevelStatement() {
  TopLevelStatementContext *_localctx = _tracker.createInstance<TopLevelStatementContext>(_ctx, getState());
  enterRule(_localctx, 2, FeatParser::RuleTopLevelStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(240);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::INCLUDE: {
        setState(234);
        include();
        break;
      }

      case FeatParser::GCLASS: {
        setState(235);
        glyphClassAssign();
        break;
      }

      case FeatParser::LANGSYS: {
        setState(236);
        langsysAssign();
        break;
      }

      case FeatParser::MARK_CLASS: {
        setState(237);
        mark_statement();
        break;
      }

      case FeatParser::ANCHOR_DEF: {
        setState(238);
        anchorDef();
        break;
      }

      case FeatParser::VALUE_RECORD_DEF: {
        setState(239);
        valueRecordDef();
        break;
      }

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

  return _localctx;
}

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

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

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

tree::TerminalNode* FeatParser::IncludeContext::I_RPAREN() {
  return getToken(FeatParser::I_RPAREN, 0);
}

tree::TerminalNode* FeatParser::IncludeContext::IFILE() {
  return getToken(FeatParser::IFILE, 0);
}

tree::TerminalNode* FeatParser::IncludeContext::I_LPAREN() {
  return getToken(FeatParser::I_LPAREN, 0);
}


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


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

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(244);
    match(FeatParser::INCLUDE);
    setState(245);
    match(FeatParser::I_RPAREN);
    setState(246);
    match(FeatParser::IFILE);
    setState(247);
    match(FeatParser::I_LPAREN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GlyphClassAssignContext ------------------------------------------------------------------

FeatParser::GlyphClassAssignContext::GlyphClassAssignContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GlyphClassAssignContext::GCLASS() {
  return getToken(FeatParser::GCLASS, 0);
}

tree::TerminalNode* FeatParser::GlyphClassAssignContext::EQUALS() {
  return getToken(FeatParser::EQUALS, 0);
}

FeatParser::GlyphClassContext* FeatParser::GlyphClassAssignContext::glyphClass() {
  return getRuleContext<FeatParser::GlyphClassContext>(0);
}


size_t FeatParser::GlyphClassAssignContext::getRuleIndex() const {
  return FeatParser::RuleGlyphClassAssign;
}


std::any FeatParser::GlyphClassAssignContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGlyphClassAssign(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GlyphClassAssignContext* FeatParser::glyphClassAssign() {
  GlyphClassAssignContext *_localctx = _tracker.createInstance<GlyphClassAssignContext>(_ctx, getState());
  enterRule(_localctx, 6, FeatParser::RuleGlyphClassAssign);

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

  return _localctx;
}

//----------------- LangsysAssignContext ------------------------------------------------------------------

FeatParser::LangsysAssignContext::LangsysAssignContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::LangsysAssignContext::LANGSYS() {
  return getToken(FeatParser::LANGSYS, 0);
}

std::vector<FeatParser::TagContext *> FeatParser::LangsysAssignContext::tag() {
  return getRuleContexts<FeatParser::TagContext>();
}

FeatParser::TagContext* FeatParser::LangsysAssignContext::tag(size_t i) {
  return getRuleContext<FeatParser::TagContext>(i);
}


size_t FeatParser::LangsysAssignContext::getRuleIndex() const {
  return FeatParser::RuleLangsysAssign;
}


std::any FeatParser::LangsysAssignContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLangsysAssign(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LangsysAssignContext* FeatParser::langsysAssign() {
  LangsysAssignContext *_localctx = _tracker.createInstance<LangsysAssignContext>(_ctx, getState());
  enterRule(_localctx, 8, FeatParser::RuleLangsysAssign);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(253);
    match(FeatParser::LANGSYS);
    setState(254);
    antlrcpp::downCast<LangsysAssignContext *>(_localctx)->script = tag();
    setState(255);
    antlrcpp::downCast<LangsysAssignContext *>(_localctx)->lang = tag();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Mark_statementContext ------------------------------------------------------------------

FeatParser::Mark_statementContext::Mark_statementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::Mark_statementContext::MARK_CLASS() {
  return getToken(FeatParser::MARK_CLASS, 0);
}

FeatParser::AnchorContext* FeatParser::Mark_statementContext::anchor() {
  return getRuleContext<FeatParser::AnchorContext>(0);
}

tree::TerminalNode* FeatParser::Mark_statementContext::GCLASS() {
  return getToken(FeatParser::GCLASS, 0);
}

FeatParser::GlyphContext* FeatParser::Mark_statementContext::glyph() {
  return getRuleContext<FeatParser::GlyphContext>(0);
}

FeatParser::GlyphClassContext* FeatParser::Mark_statementContext::glyphClass() {
  return getRuleContext<FeatParser::GlyphClassContext>(0);
}


size_t FeatParser::Mark_statementContext::getRuleIndex() const {
  return FeatParser::RuleMark_statement;
}


std::any FeatParser::Mark_statementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitMark_statement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Mark_statementContext* FeatParser::mark_statement() {
  Mark_statementContext *_localctx = _tracker.createInstance<Mark_statementContext>(_ctx, getState());
  enterRule(_localctx, 10, FeatParser::RuleMark_statement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(257);
    match(FeatParser::MARK_CLASS);
    setState(260);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NOTDEF:
      case FeatParser::CID:
      case FeatParser::ESCGNAME:
      case FeatParser::NAMELABEL:
      case FeatParser::EXTNAME: {
        setState(258);
        glyph();
        break;
      }

      case FeatParser::LBRACKET:
      case FeatParser::GCLASS: {
        setState(259);
        glyphClass();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(262);
    anchor();
    setState(263);
    match(FeatParser::GCLASS);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AnchorDefContext ------------------------------------------------------------------

FeatParser::AnchorDefContext::AnchorDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AnchorDefContext::ANCHOR_DEF() {
  return getToken(FeatParser::ANCHOR_DEF, 0);
}

std::vector<tree::TerminalNode *> FeatParser::AnchorDefContext::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::AnchorDefContext::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}

FeatParser::LabelContext* FeatParser::AnchorDefContext::label() {
  return getRuleContext<FeatParser::LabelContext>(0);
}

tree::TerminalNode* FeatParser::AnchorDefContext::CONTOURPOINT() {
  return getToken(FeatParser::CONTOURPOINT, 0);
}


size_t FeatParser::AnchorDefContext::getRuleIndex() const {
  return FeatParser::RuleAnchorDef;
}


std::any FeatParser::AnchorDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAnchorDef(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AnchorDefContext* FeatParser::anchorDef() {
  AnchorDefContext *_localctx = _tracker.createInstance<AnchorDefContext>(_ctx, getState());
  enterRule(_localctx, 12, FeatParser::RuleAnchorDef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(265);
    match(FeatParser::ANCHOR_DEF);
    setState(266);
    antlrcpp::downCast<AnchorDefContext *>(_localctx)->xval = match(FeatParser::NUM);
    setState(267);
    antlrcpp::downCast<AnchorDefContext *>(_localctx)->yval = match(FeatParser::NUM);
    setState(270);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FeatParser::CONTOURPOINT) {
      setState(268);
      match(FeatParser::CONTOURPOINT);
      setState(269);
      antlrcpp::downCast<AnchorDefContext *>(_localctx)->cp = match(FeatParser::NUM);
    }
    setState(272);
    antlrcpp::downCast<AnchorDefContext *>(_localctx)->name = label();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ValueRecordDefContext ------------------------------------------------------------------

FeatParser::ValueRecordDefContext::ValueRecordDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::ValueRecordDefContext::VALUE_RECORD_DEF() {
  return getToken(FeatParser::VALUE_RECORD_DEF, 0);
}

FeatParser::ValueLiteralContext* FeatParser::ValueRecordDefContext::valueLiteral() {
  return getRuleContext<FeatParser::ValueLiteralContext>(0);
}

FeatParser::LabelContext* FeatParser::ValueRecordDefContext::label() {
  return getRuleContext<FeatParser::LabelContext>(0);
}


size_t FeatParser::ValueRecordDefContext::getRuleIndex() const {
  return FeatParser::RuleValueRecordDef;
}


std::any FeatParser::ValueRecordDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitValueRecordDef(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ValueRecordDefContext* FeatParser::valueRecordDef() {
  ValueRecordDefContext *_localctx = _tracker.createInstance<ValueRecordDefContext>(_ctx, getState());
  enterRule(_localctx, 14, FeatParser::RuleValueRecordDef);

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

  return _localctx;
}

//----------------- FeatureBlockContext ------------------------------------------------------------------

FeatParser::FeatureBlockContext::FeatureBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::FeatureBlockContext::FEATURE() {
  return getToken(FeatParser::FEATURE, 0);
}

tree::TerminalNode* FeatParser::FeatureBlockContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::FeatureBlockContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::FeatureBlockContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::TagContext *> FeatParser::FeatureBlockContext::tag() {
  return getRuleContexts<FeatParser::TagContext>();
}

FeatParser::TagContext* FeatParser::FeatureBlockContext::tag(size_t i) {
  return getRuleContext<FeatParser::TagContext>(i);
}

tree::TerminalNode* FeatParser::FeatureBlockContext::USE_EXTENSION() {
  return getToken(FeatParser::USE_EXTENSION, 0);
}

std::vector<FeatParser::FeatureStatementContext *> FeatParser::FeatureBlockContext::featureStatement() {
  return getRuleContexts<FeatParser::FeatureStatementContext>();
}

FeatParser::FeatureStatementContext* FeatParser::FeatureBlockContext::featureStatement(size_t i) {
  return getRuleContext<FeatParser::FeatureStatementContext>(i);
}


size_t FeatParser::FeatureBlockContext::getRuleIndex() const {
  return FeatParser::RuleFeatureBlock;
}


std::any FeatParser::FeatureBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitFeatureBlock(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::FeatureBlockContext* FeatParser::featureBlock() {
  FeatureBlockContext *_localctx = _tracker.createInstance<FeatureBlockContext>(_ctx, getState());
  enterRule(_localctx, 16, FeatParser::RuleFeatureBlock);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(278);
    match(FeatParser::FEATURE);
    setState(279);
    antlrcpp::downCast<FeatureBlockContext *>(_localctx)->starttag = tag();
    setState(281);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FeatParser::USE_EXTENSION) {
      setState(280);
      match(FeatParser::USE_EXTENSION);
    }
    setState(283);
    match(FeatParser::LCBRACE);
    setState(285); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(284);
      featureStatement();
      setState(287); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 18304463152364384) != 0) || _la == FeatParser::GCLASS);
    setState(289);
    match(FeatParser::RCBRACE);
    setState(290);
    antlrcpp::downCast<FeatureBlockContext *>(_localctx)->endtag = tag();
    setState(291);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableBlockContext ------------------------------------------------------------------

FeatParser::TableBlockContext::TableBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::TableBlockContext::TABLE() {
  return getToken(FeatParser::TABLE, 0);
}

FeatParser::Table_BASEContext* FeatParser::TableBlockContext::table_BASE() {
  return getRuleContext<FeatParser::Table_BASEContext>(0);
}

FeatParser::Table_GDEFContext* FeatParser::TableBlockContext::table_GDEF() {
  return getRuleContext<FeatParser::Table_GDEFContext>(0);
}

FeatParser::Table_headContext* FeatParser::TableBlockContext::table_head() {
  return getRuleContext<FeatParser::Table_headContext>(0);
}

FeatParser::Table_hheaContext* FeatParser::TableBlockContext::table_hhea() {
  return getRuleContext<FeatParser::Table_hheaContext>(0);
}

FeatParser::Table_vheaContext* FeatParser::TableBlockContext::table_vhea() {
  return getRuleContext<FeatParser::Table_vheaContext>(0);
}

FeatParser::Table_nameContext* FeatParser::TableBlockContext::table_name() {
  return getRuleContext<FeatParser::Table_nameContext>(0);
}

FeatParser::Table_OS_2Context* FeatParser::TableBlockContext::table_OS_2() {
  return getRuleContext<FeatParser::Table_OS_2Context>(0);
}

FeatParser::Table_STATContext* FeatParser::TableBlockContext::table_STAT() {
  return getRuleContext<FeatParser::Table_STATContext>(0);
}

FeatParser::Table_vmtxContext* FeatParser::TableBlockContext::table_vmtx() {
  return getRuleContext<FeatParser::Table_vmtxContext>(0);
}


size_t FeatParser::TableBlockContext::getRuleIndex() const {
  return FeatParser::RuleTableBlock;
}


std::any FeatParser::TableBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTableBlock(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::TableBlockContext* FeatParser::tableBlock() {
  TableBlockContext *_localctx = _tracker.createInstance<TableBlockContext>(_ctx, getState());
  enterRule(_localctx, 18, FeatParser::RuleTableBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(293);
    match(FeatParser::TABLE);
    setState(303);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::BASE: {
        setState(294);
        table_BASE();
        break;
      }

      case FeatParser::GDEF: {
        setState(295);
        table_GDEF();
        break;
      }

      case FeatParser::HEAD: {
        setState(296);
        table_head();
        break;
      }

      case FeatParser::HHEA: {
        setState(297);
        table_hhea();
        break;
      }

      case FeatParser::VHEA: {
        setState(298);
        table_vhea();
        break;
      }

      case FeatParser::NAME: {
        setState(299);
        table_name();
        break;
      }

      case FeatParser::OS_2: {
        setState(300);
        table_OS_2();
        break;
      }

      case FeatParser::STAT: {
        setState(301);
        table_STAT();
        break;
      }

      case FeatParser::VMTX: {
        setState(302);
        table_vmtx();
        break;
      }

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

  return _localctx;
}

//----------------- AnonBlockContext ------------------------------------------------------------------

FeatParser::AnonBlockContext::AnonBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::AnontokContext* FeatParser::AnonBlockContext::anontok() {
  return getRuleContext<FeatParser::AnontokContext>(0);
}

tree::TerminalNode* FeatParser::AnonBlockContext::A_LABEL() {
  return getToken(FeatParser::A_LABEL, 0);
}

tree::TerminalNode* FeatParser::AnonBlockContext::A_LBRACE() {
  return getToken(FeatParser::A_LBRACE, 0);
}

tree::TerminalNode* FeatParser::AnonBlockContext::A_CLOSE() {
  return getToken(FeatParser::A_CLOSE, 0);
}

std::vector<tree::TerminalNode *> FeatParser::AnonBlockContext::A_LINE() {
  return getTokens(FeatParser::A_LINE);
}

tree::TerminalNode* FeatParser::AnonBlockContext::A_LINE(size_t i) {
  return getToken(FeatParser::A_LINE, i);
}


size_t FeatParser::AnonBlockContext::getRuleIndex() const {
  return FeatParser::RuleAnonBlock;
}


std::any FeatParser::AnonBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAnonBlock(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AnonBlockContext* FeatParser::anonBlock() {
  AnonBlockContext *_localctx = _tracker.createInstance<AnonBlockContext>(_ctx, getState());
  enterRule(_localctx, 20, FeatParser::RuleAnonBlock);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(305);
    anontok();
    setState(306);
    match(FeatParser::A_LABEL);
    setState(307);
    match(FeatParser::A_LBRACE);
    setState(311);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::A_LINE) {
      setState(308);
      match(FeatParser::A_LINE);
      setState(313);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(314);
    match(FeatParser::A_CLOSE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LookupBlockTopLevelContext ------------------------------------------------------------------

FeatParser::LookupBlockTopLevelContext::LookupBlockTopLevelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::LookupBlockTopLevelContext::LOOKUP() {
  return getToken(FeatParser::LOOKUP, 0);
}

tree::TerminalNode* FeatParser::LookupBlockTopLevelContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::LookupBlockTopLevelContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::LookupBlockTopLevelContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::LabelContext *> FeatParser::LookupBlockTopLevelContext::label() {
  return getRuleContexts<FeatParser::LabelContext>();
}

FeatParser::LabelContext* FeatParser::LookupBlockTopLevelContext::label(size_t i) {
  return getRuleContext<FeatParser::LabelContext>(i);
}

tree::TerminalNode* FeatParser::LookupBlockTopLevelContext::USE_EXTENSION() {
  return getToken(FeatParser::USE_EXTENSION, 0);
}

std::vector<FeatParser::StatementContext *> FeatParser::LookupBlockTopLevelContext::statement() {
  return getRuleContexts<FeatParser::StatementContext>();
}

FeatParser::StatementContext* FeatParser::LookupBlockTopLevelContext::statement(size_t i) {
  return getRuleContext<FeatParser::StatementContext>(i);
}


size_t FeatParser::LookupBlockTopLevelContext::getRuleIndex() const {
  return FeatParser::RuleLookupBlockTopLevel;
}


std::any FeatParser::LookupBlockTopLevelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLookupBlockTopLevel(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LookupBlockTopLevelContext* FeatParser::lookupBlockTopLevel() {
  LookupBlockTopLevelContext *_localctx = _tracker.createInstance<LookupBlockTopLevelContext>(_ctx, getState());
  enterRule(_localctx, 22, FeatParser::RuleLookupBlockTopLevel);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(316);
    match(FeatParser::LOOKUP);
    setState(317);
    antlrcpp::downCast<LookupBlockTopLevelContext *>(_localctx)->startlabel = label();
    setState(319);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FeatParser::USE_EXTENSION) {
      setState(318);
      match(FeatParser::USE_EXTENSION);
    }
    setState(321);
    match(FeatParser::LCBRACE);
    setState(323); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(322);
      statement();
      setState(325); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 18300065105849184) != 0) || _la == FeatParser::GCLASS);
    setState(327);
    match(FeatParser::RCBRACE);
    setState(328);
    antlrcpp::downCast<LookupBlockTopLevelContext *>(_localctx)->endlabel = label();
    setState(329);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FeatureStatementContext ------------------------------------------------------------------

FeatParser::FeatureStatementContext::FeatureStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::StatementContext* FeatParser::FeatureStatementContext::statement() {
  return getRuleContext<FeatParser::StatementContext>(0);
}

FeatParser::LookupBlockOrUseContext* FeatParser::FeatureStatementContext::lookupBlockOrUse() {
  return getRuleContext<FeatParser::LookupBlockOrUseContext>(0);
}

FeatParser::CvParameterBlockContext* FeatParser::FeatureStatementContext::cvParameterBlock() {
  return getRuleContext<FeatParser::CvParameterBlockContext>(0);
}


size_t FeatParser::FeatureStatementContext::getRuleIndex() const {
  return FeatParser::RuleFeatureStatement;
}


std::any FeatParser::FeatureStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitFeatureStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::FeatureStatementContext* FeatParser::featureStatement() {
  FeatureStatementContext *_localctx = _tracker.createInstance<FeatureStatementContext>(_ctx, getState());
  enterRule(_localctx, 24, FeatParser::RuleFeatureStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(334);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::INCLUDE:
      case FeatParser::FEATURE:
      case FeatParser::SCRIPT:
      case FeatParser::LANGUAGE:
      case FeatParser::SUBTABLE:
      case FeatParser::LOOKUPFLAG:
      case FeatParser::ENUMERATE:
      case FeatParser::ENUMERATE_v:
      case FeatParser::EXCEPT:
      case FeatParser::IGNORE:
      case FeatParser::SUBSTITUTE:
      case FeatParser::SUBSTITUTE_v:
      case FeatParser::REVERSE:
      case FeatParser::REVERSE_v:
      case FeatParser::POSITION:
      case FeatParser::POSITION_v:
      case FeatParser::PARAMETERS:
      case FeatParser::FEATURE_NAMES:
      case FeatParser::SIZEMENUNAME:
      case FeatParser::MARK_CLASS:
      case FeatParser::GCLASS: {
        enterOuterAlt(_localctx, 1);
        setState(331);
        statement();
        break;
      }

      case FeatParser::LOOKUP: {
        enterOuterAlt(_localctx, 2);
        setState(332);
        lookupBlockOrUse();
        break;
      }

      case FeatParser::CV_PARAMETERS: {
        enterOuterAlt(_localctx, 3);
        setState(333);
        cvParameterBlock();
        break;
      }

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

  return _localctx;
}

//----------------- LookupBlockOrUseContext ------------------------------------------------------------------

FeatParser::LookupBlockOrUseContext::LookupBlockOrUseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::LookupBlockOrUseContext::LOOKUP() {
  return getToken(FeatParser::LOOKUP, 0);
}

tree::TerminalNode* FeatParser::LookupBlockOrUseContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::LabelContext *> FeatParser::LookupBlockOrUseContext::label() {
  return getRuleContexts<FeatParser::LabelContext>();
}

FeatParser::LabelContext* FeatParser::LookupBlockOrUseContext::label(size_t i) {
  return getRuleContext<FeatParser::LabelContext>(i);
}

tree::TerminalNode* FeatParser::LookupBlockOrUseContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::LookupBlockOrUseContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::LookupBlockOrUseContext::USE_EXTENSION() {
  return getToken(FeatParser::USE_EXTENSION, 0);
}

std::vector<FeatParser::StatementContext *> FeatParser::LookupBlockOrUseContext::statement() {
  return getRuleContexts<FeatParser::StatementContext>();
}

FeatParser::StatementContext* FeatParser::LookupBlockOrUseContext::statement(size_t i) {
  return getRuleContext<FeatParser::StatementContext>(i);
}


size_t FeatParser::LookupBlockOrUseContext::getRuleIndex() const {
  return FeatParser::RuleLookupBlockOrUse;
}


std::any FeatParser::LookupBlockOrUseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLookupBlockOrUse(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LookupBlockOrUseContext* FeatParser::lookupBlockOrUse() {
  LookupBlockOrUseContext *_localctx = _tracker.createInstance<LookupBlockOrUseContext>(_ctx, getState());
  enterRule(_localctx, 26, FeatParser::RuleLookupBlockOrUse);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(336);
    match(FeatParser::LOOKUP);
    setState(337);
    antlrcpp::downCast<LookupBlockOrUseContext *>(_localctx)->startlabel = label();
    setState(350);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FeatParser::USE_EXTENSION || _la == FeatParser::LCBRACE) {
      setState(339);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FeatParser::USE_EXTENSION) {
        setState(338);
        match(FeatParser::USE_EXTENSION);
      }
      setState(341);
      match(FeatParser::LCBRACE);
      setState(343); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(342);
        statement();
        setState(345); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 18300065105849184) != 0) || _la == FeatParser::GCLASS);
      setState(347);
      match(FeatParser::RCBRACE);
      setState(348);
      antlrcpp::downCast<LookupBlockOrUseContext *>(_localctx)->endlabel = label();
    }
    setState(352);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CvParameterBlockContext ------------------------------------------------------------------

FeatParser::CvParameterBlockContext::CvParameterBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::CvParameterBlockContext::CV_PARAMETERS() {
  return getToken(FeatParser::CV_PARAMETERS, 0);
}

tree::TerminalNode* FeatParser::CvParameterBlockContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::CvParameterBlockContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::CvParameterBlockContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::CvParameterStatementContext *> FeatParser::CvParameterBlockContext::cvParameterStatement() {
  return getRuleContexts<FeatParser::CvParameterStatementContext>();
}

FeatParser::CvParameterStatementContext* FeatParser::CvParameterBlockContext::cvParameterStatement(size_t i) {
  return getRuleContext<FeatParser::CvParameterStatementContext>(i);
}


size_t FeatParser::CvParameterBlockContext::getRuleIndex() const {
  return FeatParser::RuleCvParameterBlock;
}


std::any FeatParser::CvParameterBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitCvParameterBlock(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::CvParameterBlockContext* FeatParser::cvParameterBlock() {
  CvParameterBlockContext *_localctx = _tracker.createInstance<CvParameterBlockContext>(_ctx, getState());
  enterRule(_localctx, 28, FeatParser::RuleCvParameterBlock);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(354);
    match(FeatParser::CV_PARAMETERS);
    setState(355);
    match(FeatParser::LCBRACE);
    setState(359);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 272678883688480) != 0)) {
      setState(356);
      cvParameterStatement();
      setState(361);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(362);
    match(FeatParser::RCBRACE);
    setState(363);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CvParameterStatementContext ------------------------------------------------------------------

FeatParser::CvParameterStatementContext::CvParameterStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::CvParameterStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::CvParameterContext* FeatParser::CvParameterStatementContext::cvParameter() {
  return getRuleContext<FeatParser::CvParameterContext>(0);
}

FeatParser::IncludeContext* FeatParser::CvParameterStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::CvParameterStatementContext::getRuleIndex() const {
  return FeatParser::RuleCvParameterStatement;
}


std::any FeatParser::CvParameterStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitCvParameterStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::CvParameterStatementContext* FeatParser::cvParameterStatement() {
  CvParameterStatementContext *_localctx = _tracker.createInstance<CvParameterStatementContext>(_ctx, getState());
  enterRule(_localctx, 30, FeatParser::RuleCvParameterStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(367);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::CV_UI_LABEL:
      case FeatParser::CV_TOOLTIP:
      case FeatParser::CV_SAMPLE_TEXT:
      case FeatParser::CV_PARAM_LABEL:
      case FeatParser::CV_CHARACTER: {
        setState(365);
        cvParameter();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(366);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- CvParameterContext ------------------------------------------------------------------

FeatParser::CvParameterContext::CvParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::CvParameterContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::CvParameterContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::CvParameterContext::CV_UI_LABEL() {
  return getToken(FeatParser::CV_UI_LABEL, 0);
}

tree::TerminalNode* FeatParser::CvParameterContext::CV_TOOLTIP() {
  return getToken(FeatParser::CV_TOOLTIP, 0);
}

tree::TerminalNode* FeatParser::CvParameterContext::CV_SAMPLE_TEXT() {
  return getToken(FeatParser::CV_SAMPLE_TEXT, 0);
}

tree::TerminalNode* FeatParser::CvParameterContext::CV_PARAM_LABEL() {
  return getToken(FeatParser::CV_PARAM_LABEL, 0);
}

std::vector<FeatParser::NameEntryStatementContext *> FeatParser::CvParameterContext::nameEntryStatement() {
  return getRuleContexts<FeatParser::NameEntryStatementContext>();
}

FeatParser::NameEntryStatementContext* FeatParser::CvParameterContext::nameEntryStatement(size_t i) {
  return getRuleContext<FeatParser::NameEntryStatementContext>(i);
}

tree::TerminalNode* FeatParser::CvParameterContext::CV_CHARACTER() {
  return getToken(FeatParser::CV_CHARACTER, 0);
}

FeatParser::GenNumContext* FeatParser::CvParameterContext::genNum() {
  return getRuleContext<FeatParser::GenNumContext>(0);
}


size_t FeatParser::CvParameterContext::getRuleIndex() const {
  return FeatParser::RuleCvParameter;
}


std::any FeatParser::CvParameterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitCvParameter(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::CvParameterContext* FeatParser::cvParameter() {
  CvParameterContext *_localctx = _tracker.createInstance<CvParameterContext>(_ctx, getState());
  enterRule(_localctx, 32, FeatParser::RuleCvParameter);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(382);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::CV_UI_LABEL:
      case FeatParser::CV_TOOLTIP:
      case FeatParser::CV_SAMPLE_TEXT:
      case FeatParser::CV_PARAM_LABEL: {
        enterOuterAlt(_localctx, 1);
        setState(371);
        _la = _input->LA(1);
        if (!((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 131941395333120) != 0))) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(372);
        match(FeatParser::LCBRACE);
        setState(374); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(373);
          nameEntryStatement();
          setState(376); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == FeatParser::INCLUDE || _la == FeatParser::NAME);
        setState(378);
        match(FeatParser::RCBRACE);
        break;
      }

      case FeatParser::CV_CHARACTER: {
        enterOuterAlt(_localctx, 2);
        setState(380);
        match(FeatParser::CV_CHARACTER);
        setState(381);
        genNum();
        break;
      }

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

  return _localctx;
}

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

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

tree::TerminalNode* FeatParser::StatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::FeatureUseContext* FeatParser::StatementContext::featureUse() {
  return getRuleContext<FeatParser::FeatureUseContext>(0);
}

FeatParser::ScriptAssignContext* FeatParser::StatementContext::scriptAssign() {
  return getRuleContext<FeatParser::ScriptAssignContext>(0);
}

FeatParser::LangAssignContext* FeatParser::StatementContext::langAssign() {
  return getRuleContext<FeatParser::LangAssignContext>(0);
}

FeatParser::LookupflagAssignContext* FeatParser::StatementContext::lookupflagAssign() {
  return getRuleContext<FeatParser::LookupflagAssignContext>(0);
}

FeatParser::GlyphClassAssignContext* FeatParser::StatementContext::glyphClassAssign() {
  return getRuleContext<FeatParser::GlyphClassAssignContext>(0);
}

FeatParser::IgnoreSubOrPosContext* FeatParser::StatementContext::ignoreSubOrPos() {
  return getRuleContext<FeatParser::IgnoreSubOrPosContext>(0);
}

FeatParser::SubstituteContext* FeatParser::StatementContext::substitute() {
  return getRuleContext<FeatParser::SubstituteContext>(0);
}

FeatParser::Mark_statementContext* FeatParser::StatementContext::mark_statement() {
  return getRuleContext<FeatParser::Mark_statementContext>(0);
}

FeatParser::PositionContext* FeatParser::StatementContext::position() {
  return getRuleContext<FeatParser::PositionContext>(0);
}

FeatParser::ParametersContext* FeatParser::StatementContext::parameters() {
  return getRuleContext<FeatParser::ParametersContext>(0);
}

FeatParser::SizemenunameContext* FeatParser::StatementContext::sizemenuname() {
  return getRuleContext<FeatParser::SizemenunameContext>(0);
}

FeatParser::FeatureNamesContext* FeatParser::StatementContext::featureNames() {
  return getRuleContext<FeatParser::FeatureNamesContext>(0);
}

FeatParser::SubtableContext* FeatParser::StatementContext::subtable() {
  return getRuleContext<FeatParser::SubtableContext>(0);
}

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


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


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

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(398);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::FEATURE: {
        setState(384);
        featureUse();
        break;
      }

      case FeatParser::SCRIPT: {
        setState(385);
        scriptAssign();
        break;
      }

      case FeatParser::LANGUAGE: {
        setState(386);
        langAssign();
        break;
      }

      case FeatParser::LOOKUPFLAG: {
        setState(387);
        lookupflagAssign();
        break;
      }

      case FeatParser::GCLASS: {
        setState(388);
        glyphClassAssign();
        break;
      }

      case FeatParser::IGNORE: {
        setState(389);
        ignoreSubOrPos();
        break;
      }

      case FeatParser::EXCEPT:
      case FeatParser::SUBSTITUTE:
      case FeatParser::SUBSTITUTE_v:
      case FeatParser::REVERSE:
      case FeatParser::REVERSE_v: {
        setState(390);
        substitute();
        break;
      }

      case FeatParser::MARK_CLASS: {
        setState(391);
        mark_statement();
        break;
      }

      case FeatParser::ENUMERATE:
      case FeatParser::ENUMERATE_v:
      case FeatParser::POSITION:
      case FeatParser::POSITION_v: {
        setState(392);
        position();
        break;
      }

      case FeatParser::PARAMETERS: {
        setState(393);
        parameters();
        break;
      }

      case FeatParser::SIZEMENUNAME: {
        setState(394);
        sizemenuname();
        break;
      }

      case FeatParser::FEATURE_NAMES: {
        setState(395);
        featureNames();
        break;
      }

      case FeatParser::SUBTABLE: {
        setState(396);
        subtable();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(397);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- FeatureUseContext ------------------------------------------------------------------

FeatParser::FeatureUseContext::FeatureUseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::FeatureUseContext::FEATURE() {
  return getToken(FeatParser::FEATURE, 0);
}

FeatParser::TagContext* FeatParser::FeatureUseContext::tag() {
  return getRuleContext<FeatParser::TagContext>(0);
}


size_t FeatParser::FeatureUseContext::getRuleIndex() const {
  return FeatParser::RuleFeatureUse;
}


std::any FeatParser::FeatureUseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitFeatureUse(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::FeatureUseContext* FeatParser::featureUse() {
  FeatureUseContext *_localctx = _tracker.createInstance<FeatureUseContext>(_ctx, getState());
  enterRule(_localctx, 36, FeatParser::RuleFeatureUse);

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

  return _localctx;
}

//----------------- ScriptAssignContext ------------------------------------------------------------------

FeatParser::ScriptAssignContext::ScriptAssignContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::ScriptAssignContext::SCRIPT() {
  return getToken(FeatParser::SCRIPT, 0);
}

FeatParser::TagContext* FeatParser::ScriptAssignContext::tag() {
  return getRuleContext<FeatParser::TagContext>(0);
}


size_t FeatParser::ScriptAssignContext::getRuleIndex() const {
  return FeatParser::RuleScriptAssign;
}


std::any FeatParser::ScriptAssignContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitScriptAssign(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ScriptAssignContext* FeatParser::scriptAssign() {
  ScriptAssignContext *_localctx = _tracker.createInstance<ScriptAssignContext>(_ctx, getState());
  enterRule(_localctx, 38, FeatParser::RuleScriptAssign);

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

  return _localctx;
}

//----------------- LangAssignContext ------------------------------------------------------------------

FeatParser::LangAssignContext::LangAssignContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::LangAssignContext::LANGUAGE() {
  return getToken(FeatParser::LANGUAGE, 0);
}

FeatParser::TagContext* FeatParser::LangAssignContext::tag() {
  return getRuleContext<FeatParser::TagContext>(0);
}

tree::TerminalNode* FeatParser::LangAssignContext::EXCLUDE_DFLT() {
  return getToken(FeatParser::EXCLUDE_DFLT, 0);
}

tree::TerminalNode* FeatParser::LangAssignContext::INCLUDE_DFLT() {
  return getToken(FeatParser::INCLUDE_DFLT, 0);
}

tree::TerminalNode* FeatParser::LangAssignContext::EXCLUDE_dflt() {
  return getToken(FeatParser::EXCLUDE_dflt, 0);
}

tree::TerminalNode* FeatParser::LangAssignContext::INCLUDE_dflt() {
  return getToken(FeatParser::INCLUDE_dflt, 0);
}


size_t FeatParser::LangAssignContext::getRuleIndex() const {
  return FeatParser::RuleLangAssign;
}


std::any FeatParser::LangAssignContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLangAssign(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LangAssignContext* FeatParser::langAssign() {
  LangAssignContext *_localctx = _tracker.createInstance<LangAssignContext>(_ctx, getState());
  enterRule(_localctx, 40, FeatParser::RuleLangAssign);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(408);
    match(FeatParser::LANGUAGE);
    setState(409);
    tag();
    setState(411);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 31457280) != 0)) {
      setState(410);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 31457280) != 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;
}

//----------------- LookupflagAssignContext ------------------------------------------------------------------

FeatParser::LookupflagAssignContext::LookupflagAssignContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::LookupflagAssignContext::LOOKUPFLAG() {
  return getToken(FeatParser::LOOKUPFLAG, 0);
}

tree::TerminalNode* FeatParser::LookupflagAssignContext::NUM() {
  return getToken(FeatParser::NUM, 0);
}

std::vector<FeatParser::LookupflagElementContext *> FeatParser::LookupflagAssignContext::lookupflagElement() {
  return getRuleContexts<FeatParser::LookupflagElementContext>();
}

FeatParser::LookupflagElementContext* FeatParser::LookupflagAssignContext::lookupflagElement(size_t i) {
  return getRuleContext<FeatParser::LookupflagElementContext>(i);
}


size_t FeatParser::LookupflagAssignContext::getRuleIndex() const {
  return FeatParser::RuleLookupflagAssign;
}


std::any FeatParser::LookupflagAssignContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLookupflagAssign(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LookupflagAssignContext* FeatParser::lookupflagAssign() {
  LookupflagAssignContext *_localctx = _tracker.createInstance<LookupflagAssignContext>(_ctx, getState());
  enterRule(_localctx, 42, FeatParser::RuleLookupflagAssign);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(413);
    match(FeatParser::LOOKUPFLAG);
    setState(420);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NUM: {
        setState(414);
        match(FeatParser::NUM);
        break;
      }

      case FeatParser::RIGHT_TO_LEFT:
      case FeatParser::IGNORE_BASE_GLYPHS:
      case FeatParser::IGNORE_LIGATURES:
      case FeatParser::IGNORE_MARKS:
      case FeatParser::USE_MARK_FILTERING_SET:
      case FeatParser::MARK_ATTACHMENT_TYPE: {
        setState(416); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(415);
          lookupflagElement();
          setState(418); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 2064384) != 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;
}

//----------------- LookupflagElementContext ------------------------------------------------------------------

FeatParser::LookupflagElementContext::LookupflagElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::LookupflagElementContext::RIGHT_TO_LEFT() {
  return getToken(FeatParser::RIGHT_TO_LEFT, 0);
}

tree::TerminalNode* FeatParser::LookupflagElementContext::IGNORE_BASE_GLYPHS() {
  return getToken(FeatParser::IGNORE_BASE_GLYPHS, 0);
}

tree::TerminalNode* FeatParser::LookupflagElementContext::IGNORE_LIGATURES() {
  return getToken(FeatParser::IGNORE_LIGATURES, 0);
}

tree::TerminalNode* FeatParser::LookupflagElementContext::IGNORE_MARKS() {
  return getToken(FeatParser::IGNORE_MARKS, 0);
}

tree::TerminalNode* FeatParser::LookupflagElementContext::MARK_ATTACHMENT_TYPE() {
  return getToken(FeatParser::MARK_ATTACHMENT_TYPE, 0);
}

FeatParser::GlyphClassContext* FeatParser::LookupflagElementContext::glyphClass() {
  return getRuleContext<FeatParser::GlyphClassContext>(0);
}

tree::TerminalNode* FeatParser::LookupflagElementContext::USE_MARK_FILTERING_SET() {
  return getToken(FeatParser::USE_MARK_FILTERING_SET, 0);
}


size_t FeatParser::LookupflagElementContext::getRuleIndex() const {
  return FeatParser::RuleLookupflagElement;
}


std::any FeatParser::LookupflagElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLookupflagElement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LookupflagElementContext* FeatParser::lookupflagElement() {
  LookupflagElementContext *_localctx = _tracker.createInstance<LookupflagElementContext>(_ctx, getState());
  enterRule(_localctx, 44, FeatParser::RuleLookupflagElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(430);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::RIGHT_TO_LEFT: {
        enterOuterAlt(_localctx, 1);
        setState(422);
        match(FeatParser::RIGHT_TO_LEFT);
        break;
      }

      case FeatParser::IGNORE_BASE_GLYPHS: {
        enterOuterAlt(_localctx, 2);
        setState(423);
        match(FeatParser::IGNORE_BASE_GLYPHS);
        break;
      }

      case FeatParser::IGNORE_LIGATURES: {
        enterOuterAlt(_localctx, 3);
        setState(424);
        match(FeatParser::IGNORE_LIGATURES);
        break;
      }

      case FeatParser::IGNORE_MARKS: {
        enterOuterAlt(_localctx, 4);
        setState(425);
        match(FeatParser::IGNORE_MARKS);
        break;
      }

      case FeatParser::MARK_ATTACHMENT_TYPE: {
        enterOuterAlt(_localctx, 5);
        setState(426);
        match(FeatParser::MARK_ATTACHMENT_TYPE);
        setState(427);
        glyphClass();
        break;
      }

      case FeatParser::USE_MARK_FILTERING_SET: {
        enterOuterAlt(_localctx, 6);
        setState(428);
        match(FeatParser::USE_MARK_FILTERING_SET);
        setState(429);
        glyphClass();
        break;
      }

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

  return _localctx;
}

//----------------- IgnoreSubOrPosContext ------------------------------------------------------------------

FeatParser::IgnoreSubOrPosContext::IgnoreSubOrPosContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::IgnoreSubOrPosContext::IGNORE() {
  return getToken(FeatParser::IGNORE, 0);
}

std::vector<FeatParser::LookupPatternContext *> FeatParser::IgnoreSubOrPosContext::lookupPattern() {
  return getRuleContexts<FeatParser::LookupPatternContext>();
}

FeatParser::LookupPatternContext* FeatParser::IgnoreSubOrPosContext::lookupPattern(size_t i) {
  return getRuleContext<FeatParser::LookupPatternContext>(i);
}

FeatParser::SubtokContext* FeatParser::IgnoreSubOrPosContext::subtok() {
  return getRuleContext<FeatParser::SubtokContext>(0);
}

FeatParser::RevtokContext* FeatParser::IgnoreSubOrPosContext::revtok() {
  return getRuleContext<FeatParser::RevtokContext>(0);
}

FeatParser::PostokContext* FeatParser::IgnoreSubOrPosContext::postok() {
  return getRuleContext<FeatParser::PostokContext>(0);
}

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

tree::TerminalNode* FeatParser::IgnoreSubOrPosContext::COMMA(size_t i) {
  return getToken(FeatParser::COMMA, i);
}


size_t FeatParser::IgnoreSubOrPosContext::getRuleIndex() const {
  return FeatParser::RuleIgnoreSubOrPos;
}


std::any FeatParser::IgnoreSubOrPosContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitIgnoreSubOrPos(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::IgnoreSubOrPosContext* FeatParser::ignoreSubOrPos() {
  IgnoreSubOrPosContext *_localctx = _tracker.createInstance<IgnoreSubOrPosContext>(_ctx, getState());
  enterRule(_localctx, 46, FeatParser::RuleIgnoreSubOrPos);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(432);
    match(FeatParser::IGNORE);
    setState(436);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::SUBSTITUTE:
      case FeatParser::SUBSTITUTE_v: {
        setState(433);
        subtok();
        break;
      }

      case FeatParser::REVERSE:
      case FeatParser::REVERSE_v: {
        setState(434);
        revtok();
        break;
      }

      case FeatParser::POSITION:
      case FeatParser::POSITION_v: {
        setState(435);
        postok();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(438);
    lookupPattern();
    setState(443);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::COMMA) {
      setState(439);
      match(FeatParser::COMMA);
      setState(440);
      lookupPattern();
      setState(445);
      _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;
}

//----------------- SubstituteContext ------------------------------------------------------------------

FeatParser::SubstituteContext::SubstituteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::RevtokContext* FeatParser::SubstituteContext::revtok() {
  return getRuleContext<FeatParser::RevtokContext>(0);
}

FeatParser::SubtokContext* FeatParser::SubstituteContext::subtok() {
  return getRuleContext<FeatParser::SubtokContext>(0);
}

tree::TerminalNode* FeatParser::SubstituteContext::EXCEPT() {
  return getToken(FeatParser::EXCEPT, 0);
}

std::vector<FeatParser::LookupPatternContext *> FeatParser::SubstituteContext::lookupPattern() {
  return getRuleContexts<FeatParser::LookupPatternContext>();
}

FeatParser::LookupPatternContext* FeatParser::SubstituteContext::lookupPattern(size_t i) {
  return getRuleContext<FeatParser::LookupPatternContext>(i);
}

tree::TerminalNode* FeatParser::SubstituteContext::BY() {
  return getToken(FeatParser::BY, 0);
}

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

tree::TerminalNode* FeatParser::SubstituteContext::COMMA(size_t i) {
  return getToken(FeatParser::COMMA, i);
}

tree::TerminalNode* FeatParser::SubstituteContext::FROM() {
  return getToken(FeatParser::FROM, 0);
}

tree::TerminalNode* FeatParser::SubstituteContext::KNULL() {
  return getToken(FeatParser::KNULL, 0);
}


size_t FeatParser::SubstituteContext::getRuleIndex() const {
  return FeatParser::RuleSubstitute;
}


std::any FeatParser::SubstituteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitSubstitute(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::SubstituteContext* FeatParser::substitute() {
  SubstituteContext *_localctx = _tracker.createInstance<SubstituteContext>(_ctx, getState());
  enterRule(_localctx, 48, FeatParser::RuleSubstitute);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == FeatParser::EXCEPT) {
      setState(446);
      match(FeatParser::EXCEPT);
      setState(447);
      lookupPattern();
      setState(452);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == FeatParser::COMMA) {
        setState(448);
        match(FeatParser::COMMA);
        setState(449);
        lookupPattern();
        setState(454);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(475);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::REVERSE:
      case FeatParser::REVERSE_v: {
        setState(457);
        revtok();
        setState(458);
        antlrcpp::downCast<SubstituteContext *>(_localctx)->startpat = lookupPattern();
        setState(464);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::BY) {
          setState(459);
          match(FeatParser::BY);
          setState(462);
          _errHandler->sync(this);
          switch (_input->LA(1)) {
            case FeatParser::KNULL: {
              setState(460);
              match(FeatParser::KNULL);
              break;
            }

            case FeatParser::NOTDEF:
            case FeatParser::LBRACKET:
            case FeatParser::GCLASS:
            case FeatParser::CID:
            case FeatParser::ESCGNAME:
            case FeatParser::NAMELABEL:
            case FeatParser::EXTNAME: {
              setState(461);
              antlrcpp::downCast<SubstituteContext *>(_localctx)->endpat = lookupPattern();
              break;
            }

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

      case FeatParser::SUBSTITUTE:
      case FeatParser::SUBSTITUTE_v: {
        setState(466);
        subtok();
        setState(467);
        antlrcpp::downCast<SubstituteContext *>(_localctx)->startpat = lookupPattern();
        setState(473);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::BY

        || _la == FeatParser::FROM) {
          setState(468);
          _la = _input->LA(1);
          if (!(_la == FeatParser::BY

          || _la == FeatParser::FROM)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(471);
          _errHandler->sync(this);
          switch (_input->LA(1)) {
            case FeatParser::KNULL: {
              setState(469);
              match(FeatParser::KNULL);
              break;
            }

            case FeatParser::NOTDEF:
            case FeatParser::LBRACKET:
            case FeatParser::GCLASS:
            case FeatParser::CID:
            case FeatParser::ESCGNAME:
            case FeatParser::NAMELABEL:
            case FeatParser::EXTNAME: {
              setState(470);
              antlrcpp::downCast<SubstituteContext *>(_localctx)->endpat = lookupPattern();
              break;
            }

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

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

  return _localctx;
}

//----------------- PositionContext ------------------------------------------------------------------

FeatParser::PositionContext::PositionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::PostokContext* FeatParser::PositionContext::postok() {
  return getRuleContext<FeatParser::PostokContext>(0);
}

FeatParser::EnumtokContext* FeatParser::PositionContext::enumtok() {
  return getRuleContext<FeatParser::EnumtokContext>(0);
}

std::vector<FeatParser::PatternContext *> FeatParser::PositionContext::pattern() {
  return getRuleContexts<FeatParser::PatternContext>();
}

FeatParser::PatternContext* FeatParser::PositionContext::pattern(size_t i) {
  return getRuleContext<FeatParser::PatternContext>(i);
}

FeatParser::ValueRecordContext* FeatParser::PositionContext::valueRecord() {
  return getRuleContext<FeatParser::ValueRecordContext>(0);
}

tree::TerminalNode* FeatParser::PositionContext::CURSIVE() {
  return getToken(FeatParser::CURSIVE, 0);
}

FeatParser::CursiveElementContext* FeatParser::PositionContext::cursiveElement() {
  return getRuleContext<FeatParser::CursiveElementContext>(0);
}

tree::TerminalNode* FeatParser::PositionContext::MARKBASE() {
  return getToken(FeatParser::MARKBASE, 0);
}

FeatParser::MarkligtokContext* FeatParser::PositionContext::markligtok() {
  return getRuleContext<FeatParser::MarkligtokContext>(0);
}

tree::TerminalNode* FeatParser::PositionContext::MARK() {
  return getToken(FeatParser::MARK, 0);
}

std::vector<FeatParser::ValuePatternContext *> FeatParser::PositionContext::valuePattern() {
  return getRuleContexts<FeatParser::ValuePatternContext>();
}

FeatParser::ValuePatternContext* FeatParser::PositionContext::valuePattern(size_t i) {
  return getRuleContext<FeatParser::ValuePatternContext>(i);
}

std::vector<tree::TerminalNode *> FeatParser::PositionContext::LOOKUP() {
  return getTokens(FeatParser::LOOKUP);
}

tree::TerminalNode* FeatParser::PositionContext::LOOKUP(size_t i) {
  return getToken(FeatParser::LOOKUP, i);
}

std::vector<FeatParser::LabelContext *> FeatParser::PositionContext::label() {
  return getRuleContexts<FeatParser::LabelContext>();
}

FeatParser::LabelContext* FeatParser::PositionContext::label(size_t i) {
  return getRuleContext<FeatParser::LabelContext>(i);
}

std::vector<FeatParser::LookupPatternElementContext *> FeatParser::PositionContext::lookupPatternElement() {
  return getRuleContexts<FeatParser::LookupPatternElementContext>();
}

FeatParser::LookupPatternElementContext* FeatParser::PositionContext::lookupPatternElement(size_t i) {
  return getRuleContext<FeatParser::LookupPatternElementContext>(i);
}

std::vector<FeatParser::BaseToMarkElementContext *> FeatParser::PositionContext::baseToMarkElement() {
  return getRuleContexts<FeatParser::BaseToMarkElementContext>();
}

FeatParser::BaseToMarkElementContext* FeatParser::PositionContext::baseToMarkElement(size_t i) {
  return getRuleContext<FeatParser::BaseToMarkElementContext>(i);
}

std::vector<FeatParser::LigatureMarkElementContext *> FeatParser::PositionContext::ligatureMarkElement() {
  return getRuleContexts<FeatParser::LigatureMarkElementContext>();
}

FeatParser::LigatureMarkElementContext* FeatParser::PositionContext::ligatureMarkElement(size_t i) {
  return getRuleContext<FeatParser::LigatureMarkElementContext>(i);
}


size_t FeatParser::PositionContext::getRuleIndex() const {
  return FeatParser::RulePosition;
}


std::any FeatParser::PositionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitPosition(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::PositionContext* FeatParser::position() {
  PositionContext *_localctx = _tracker.createInstance<PositionContext>(_ctx, getState());
  enterRule(_localctx, 50, FeatParser::RulePosition);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == FeatParser::ENUMERATE

    || _la == FeatParser::ENUMERATE_v) {
      setState(477);
      enumtok();
    }
    setState(480);
    postok();
    setState(482);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 117)) & 7937) != 0)) {
      setState(481);
      antlrcpp::downCast<PositionContext *>(_localctx)->startpat = pattern();
    }
    setState(538);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::BEGINVALUE:
      case FeatParser::NUM: {
        setState(484);
        valueRecord();
        setState(488);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 117)) & 7937) != 0)) {
          setState(485);
          valuePattern();
          setState(490);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case FeatParser::LOOKUP: {
        setState(493); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(491);
          match(FeatParser::LOOKUP);
          setState(492);
          label();
          setState(495); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == FeatParser::LOOKUP);
        setState(500);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 117)) & 7937) != 0)) {
          setState(497);
          lookupPatternElement();
          setState(502);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case FeatParser::CURSIVE: {
        setState(503);
        match(FeatParser::CURSIVE);
        setState(504);
        cursiveElement();
        setState(506);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 117)) & 7937) != 0)) {
          setState(505);
          antlrcpp::downCast<PositionContext *>(_localctx)->endpat = pattern();
        }
        break;
      }

      case FeatParser::MARKBASE: {
        setState(508);
        match(FeatParser::MARKBASE);
        setState(509);
        antlrcpp::downCast<PositionContext *>(_localctx)->midpat = pattern();
        setState(511); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(510);
          baseToMarkElement();
          setState(513); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == FeatParser::BEGINVALUE);
        setState(516);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 117)) & 7937) != 0)) {
          setState(515);
          antlrcpp::downCast<PositionContext *>(_localctx)->endpat = pattern();
        }
        break;
      }

      case FeatParser::MARKLIG:
      case FeatParser::MARKLIG_v: {
        setState(518);
        markligtok();
        setState(519);
        antlrcpp::downCast<PositionContext *>(_localctx)->midpat = pattern();
        setState(521); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(520);
          ligatureMarkElement();
          setState(523); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == FeatParser::BEGINVALUE);
        setState(526);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 117)) & 7937) != 0)) {
          setState(525);
          antlrcpp::downCast<PositionContext *>(_localctx)->endpat = pattern();
        }
        break;
      }

      case FeatParser::MARK: {
        setState(528);
        match(FeatParser::MARK);
        setState(529);
        antlrcpp::downCast<PositionContext *>(_localctx)->midpat = pattern();
        setState(531); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(530);
          baseToMarkElement();
          setState(533); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == FeatParser::BEGINVALUE);
        setState(536);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 117)) & 7937) != 0)) {
          setState(535);
          antlrcpp::downCast<PositionContext *>(_localctx)->endpat = 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;
}

//----------------- ValuePatternContext ------------------------------------------------------------------

FeatParser::ValuePatternContext::ValuePatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::PatternElementContext* FeatParser::ValuePatternContext::patternElement() {
  return getRuleContext<FeatParser::PatternElementContext>(0);
}

FeatParser::ValueRecordContext* FeatParser::ValuePatternContext::valueRecord() {
  return getRuleContext<FeatParser::ValueRecordContext>(0);
}


size_t FeatParser::ValuePatternContext::getRuleIndex() const {
  return FeatParser::RuleValuePattern;
}


std::any FeatParser::ValuePatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitValuePattern(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ValuePatternContext* FeatParser::valuePattern() {
  ValuePatternContext *_localctx = _tracker.createInstance<ValuePatternContext>(_ctx, getState());
  enterRule(_localctx, 52, FeatParser::RuleValuePattern);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == FeatParser::BEGINVALUE || _la == FeatParser::NUM) {
      setState(541);
      valueRecord();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ValueRecordContext ------------------------------------------------------------------

FeatParser::ValueRecordContext::ValueRecordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::ValueRecordContext::BEGINVALUE() {
  return getToken(FeatParser::BEGINVALUE, 0);
}

tree::TerminalNode* FeatParser::ValueRecordContext::ENDVALUE() {
  return getToken(FeatParser::ENDVALUE, 0);
}

FeatParser::LabelContext* FeatParser::ValueRecordContext::label() {
  return getRuleContext<FeatParser::LabelContext>(0);
}

FeatParser::ValueLiteralContext* FeatParser::ValueRecordContext::valueLiteral() {
  return getRuleContext<FeatParser::ValueLiteralContext>(0);
}


size_t FeatParser::ValueRecordContext::getRuleIndex() const {
  return FeatParser::RuleValueRecord;
}


std::any FeatParser::ValueRecordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitValueRecord(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ValueRecordContext* FeatParser::valueRecord() {
  ValueRecordContext *_localctx = _tracker.createInstance<ValueRecordContext>(_ctx, getState());
  enterRule(_localctx, 54, FeatParser::RuleValueRecord);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(549);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(544);
      match(FeatParser::BEGINVALUE);
      setState(545);
      antlrcpp::downCast<ValueRecordContext *>(_localctx)->valuename = label();
      setState(546);
      match(FeatParser::ENDVALUE);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(548);
      valueLiteral();
      break;
    }

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

  return _localctx;
}

//----------------- ValueLiteralContext ------------------------------------------------------------------

FeatParser::ValueLiteralContext::ValueLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::ValueLiteralContext::BEGINVALUE() {
  return getToken(FeatParser::BEGINVALUE, 0);
}

std::vector<tree::TerminalNode *> FeatParser::ValueLiteralContext::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::ValueLiteralContext::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}

tree::TerminalNode* FeatParser::ValueLiteralContext::ENDVALUE() {
  return getToken(FeatParser::ENDVALUE, 0);
}


size_t FeatParser::ValueLiteralContext::getRuleIndex() const {
  return FeatParser::RuleValueLiteral;
}


std::any FeatParser::ValueLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitValueLiteral(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ValueLiteralContext* FeatParser::valueLiteral() {
  ValueLiteralContext *_localctx = _tracker.createInstance<ValueLiteralContext>(_ctx, getState());
  enterRule(_localctx, 56, FeatParser::RuleValueLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(558);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::BEGINVALUE: {
        enterOuterAlt(_localctx, 1);
        setState(551);
        match(FeatParser::BEGINVALUE);
        setState(552);
        match(FeatParser::NUM);
        setState(553);
        match(FeatParser::NUM);
        setState(554);
        match(FeatParser::NUM);
        setState(555);
        match(FeatParser::NUM);
        setState(556);
        match(FeatParser::ENDVALUE);
        break;
      }

      case FeatParser::NUM: {
        enterOuterAlt(_localctx, 2);
        setState(557);
        match(FeatParser::NUM);
        break;
      }

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

  return _localctx;
}

//----------------- CursiveElementContext ------------------------------------------------------------------

FeatParser::CursiveElementContext::CursiveElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::PatternElementContext* FeatParser::CursiveElementContext::patternElement() {
  return getRuleContext<FeatParser::PatternElementContext>(0);
}

std::vector<FeatParser::AnchorContext *> FeatParser::CursiveElementContext::anchor() {
  return getRuleContexts<FeatParser::AnchorContext>();
}

FeatParser::AnchorContext* FeatParser::CursiveElementContext::anchor(size_t i) {
  return getRuleContext<FeatParser::AnchorContext>(i);
}


size_t FeatParser::CursiveElementContext::getRuleIndex() const {
  return FeatParser::RuleCursiveElement;
}


std::any FeatParser::CursiveElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitCursiveElement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::CursiveElementContext* FeatParser::cursiveElement() {
  CursiveElementContext *_localctx = _tracker.createInstance<CursiveElementContext>(_ctx, getState());
  enterRule(_localctx, 58, FeatParser::RuleCursiveElement);

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

  return _localctx;
}

//----------------- BaseToMarkElementContext ------------------------------------------------------------------

FeatParser::BaseToMarkElementContext::BaseToMarkElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::AnchorContext* FeatParser::BaseToMarkElementContext::anchor() {
  return getRuleContext<FeatParser::AnchorContext>(0);
}

tree::TerminalNode* FeatParser::BaseToMarkElementContext::MARK() {
  return getToken(FeatParser::MARK, 0);
}

tree::TerminalNode* FeatParser::BaseToMarkElementContext::GCLASS() {
  return getToken(FeatParser::GCLASS, 0);
}

tree::TerminalNode* FeatParser::BaseToMarkElementContext::MARKER() {
  return getToken(FeatParser::MARKER, 0);
}


size_t FeatParser::BaseToMarkElementContext::getRuleIndex() const {
  return FeatParser::RuleBaseToMarkElement;
}


std::any FeatParser::BaseToMarkElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitBaseToMarkElement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::BaseToMarkElementContext* FeatParser::baseToMarkElement() {
  BaseToMarkElementContext *_localctx = _tracker.createInstance<BaseToMarkElementContext>(_ctx, getState());
  enterRule(_localctx, 60, FeatParser::RuleBaseToMarkElement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(564);
    anchor();
    setState(565);
    match(FeatParser::MARK);
    setState(566);
    match(FeatParser::GCLASS);
    setState(568);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- LigatureMarkElementContext ------------------------------------------------------------------

FeatParser::LigatureMarkElementContext::LigatureMarkElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::AnchorContext* FeatParser::LigatureMarkElementContext::anchor() {
  return getRuleContext<FeatParser::AnchorContext>(0);
}

tree::TerminalNode* FeatParser::LigatureMarkElementContext::MARK() {
  return getToken(FeatParser::MARK, 0);
}

tree::TerminalNode* FeatParser::LigatureMarkElementContext::GCLASS() {
  return getToken(FeatParser::GCLASS, 0);
}

tree::TerminalNode* FeatParser::LigatureMarkElementContext::LIG_COMPONENT() {
  return getToken(FeatParser::LIG_COMPONENT, 0);
}

tree::TerminalNode* FeatParser::LigatureMarkElementContext::MARKER() {
  return getToken(FeatParser::MARKER, 0);
}


size_t FeatParser::LigatureMarkElementContext::getRuleIndex() const {
  return FeatParser::RuleLigatureMarkElement;
}


std::any FeatParser::LigatureMarkElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLigatureMarkElement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LigatureMarkElementContext* FeatParser::ligatureMarkElement() {
  LigatureMarkElementContext *_localctx = _tracker.createInstance<LigatureMarkElementContext>(_ctx, getState());
  enterRule(_localctx, 62, FeatParser::RuleLigatureMarkElement);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == FeatParser::MARK) {
      setState(571);
      match(FeatParser::MARK);
      setState(572);
      match(FeatParser::GCLASS);
    }
    setState(576);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FeatParser::LIG_COMPONENT) {
      setState(575);
      match(FeatParser::LIG_COMPONENT);
    }
    setState(579);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- ParametersContext ------------------------------------------------------------------

FeatParser::ParametersContext::ParametersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::ParametersContext::PARAMETERS() {
  return getToken(FeatParser::PARAMETERS, 0);
}

std::vector<FeatParser::FixedNumContext *> FeatParser::ParametersContext::fixedNum() {
  return getRuleContexts<FeatParser::FixedNumContext>();
}

FeatParser::FixedNumContext* FeatParser::ParametersContext::fixedNum(size_t i) {
  return getRuleContext<FeatParser::FixedNumContext>(i);
}


size_t FeatParser::ParametersContext::getRuleIndex() const {
  return FeatParser::RuleParameters;
}


std::any FeatParser::ParametersContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitParameters(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ParametersContext* FeatParser::parameters() {
  ParametersContext *_localctx = _tracker.createInstance<ParametersContext>(_ctx, getState());
  enterRule(_localctx, 64, FeatParser::RuleParameters);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(581);
    match(FeatParser::PARAMETERS);
    setState(583); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(582);
      fixedNum();
      setState(585); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::POINTNUM

    || _la == FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SizemenunameContext ------------------------------------------------------------------

FeatParser::SizemenunameContext::SizemenunameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::SizemenunameContext::SIZEMENUNAME() {
  return getToken(FeatParser::SIZEMENUNAME, 0);
}

tree::TerminalNode* FeatParser::SizemenunameContext::QUOTE() {
  return getToken(FeatParser::QUOTE, 0);
}

tree::TerminalNode* FeatParser::SizemenunameContext::STRVAL() {
  return getToken(FeatParser::STRVAL, 0);
}

tree::TerminalNode* FeatParser::SizemenunameContext::EQUOTE() {
  return getToken(FeatParser::EQUOTE, 0);
}

std::vector<FeatParser::GenNumContext *> FeatParser::SizemenunameContext::genNum() {
  return getRuleContexts<FeatParser::GenNumContext>();
}

FeatParser::GenNumContext* FeatParser::SizemenunameContext::genNum(size_t i) {
  return getRuleContext<FeatParser::GenNumContext>(i);
}


size_t FeatParser::SizemenunameContext::getRuleIndex() const {
  return FeatParser::RuleSizemenuname;
}


std::any FeatParser::SizemenunameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitSizemenuname(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::SizemenunameContext* FeatParser::sizemenuname() {
  SizemenunameContext *_localctx = _tracker.createInstance<SizemenunameContext>(_ctx, getState());
  enterRule(_localctx, 66, FeatParser::RuleSizemenuname);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (((((_la - 131) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 131)) & 7) != 0)) {
      setState(588);
      genNum();
      setState(592);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 131) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 131)) & 7) != 0)) {
        setState(589);
        genNum();
        setState(590);
        genNum();
      }
    }
    setState(596);
    match(FeatParser::QUOTE);
    setState(597);
    match(FeatParser::STRVAL);
    setState(598);
    match(FeatParser::EQUOTE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FeatureNamesContext ------------------------------------------------------------------

FeatParser::FeatureNamesContext::FeatureNamesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::FeatureNamesContext::FEATURE_NAMES() {
  return getToken(FeatParser::FEATURE_NAMES, 0);
}

tree::TerminalNode* FeatParser::FeatureNamesContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::FeatureNamesContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

std::vector<FeatParser::NameEntryStatementContext *> FeatParser::FeatureNamesContext::nameEntryStatement() {
  return getRuleContexts<FeatParser::NameEntryStatementContext>();
}

FeatParser::NameEntryStatementContext* FeatParser::FeatureNamesContext::nameEntryStatement(size_t i) {
  return getRuleContext<FeatParser::NameEntryStatementContext>(i);
}


size_t FeatParser::FeatureNamesContext::getRuleIndex() const {
  return FeatParser::RuleFeatureNames;
}


std::any FeatParser::FeatureNamesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitFeatureNames(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::FeatureNamesContext* FeatParser::featureNames() {
  FeatureNamesContext *_localctx = _tracker.createInstance<FeatureNamesContext>(_ctx, getState());
  enterRule(_localctx, 68, FeatParser::RuleFeatureNames);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(600);
    match(FeatParser::FEATURE_NAMES);
    setState(601);
    match(FeatParser::LCBRACE);
    setState(603); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(602);
      nameEntryStatement();
      setState(605); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || _la == FeatParser::NAME);
    setState(607);
    match(FeatParser::RCBRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SubtableContext ------------------------------------------------------------------

FeatParser::SubtableContext::SubtableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::SubtableContext::SUBTABLE() {
  return getToken(FeatParser::SUBTABLE, 0);
}


size_t FeatParser::SubtableContext::getRuleIndex() const {
  return FeatParser::RuleSubtable;
}


std::any FeatParser::SubtableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitSubtable(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::SubtableContext* FeatParser::subtable() {
  SubtableContext *_localctx = _tracker.createInstance<SubtableContext>(_ctx, getState());
  enterRule(_localctx, 70, FeatParser::RuleSubtable);

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

  return _localctx;
}

//----------------- Table_BASEContext ------------------------------------------------------------------

FeatParser::Table_BASEContext::Table_BASEContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_BASEContext::BASE() {
  return getTokens(FeatParser::BASE);
}

tree::TerminalNode* FeatParser::Table_BASEContext::BASE(size_t i) {
  return getToken(FeatParser::BASE, i);
}

tree::TerminalNode* FeatParser::Table_BASEContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_BASEContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_BASEContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::BaseStatementContext *> FeatParser::Table_BASEContext::baseStatement() {
  return getRuleContexts<FeatParser::BaseStatementContext>();
}

FeatParser::BaseStatementContext* FeatParser::Table_BASEContext::baseStatement(size_t i) {
  return getRuleContext<FeatParser::BaseStatementContext>(i);
}


size_t FeatParser::Table_BASEContext::getRuleIndex() const {
  return FeatParser::RuleTable_BASE;
}


std::any FeatParser::Table_BASEContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_BASE(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_BASEContext* FeatParser::table_BASE() {
  Table_BASEContext *_localctx = _tracker.createInstance<Table_BASEContext>(_ctx, getState());
  enterRule(_localctx, 72, FeatParser::RuleTable_BASE);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(611);
    match(FeatParser::BASE);
    setState(612);
    match(FeatParser::LCBRACE);
    setState(614); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(613);
      baseStatement();
      setState(616); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (((((_la - 5) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 5)) & 2161727821137838081) != 0));
    setState(618);
    match(FeatParser::RCBRACE);
    setState(619);
    match(FeatParser::BASE);
    setState(620);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseStatementContext ------------------------------------------------------------------

FeatParser::BaseStatementContext::BaseStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::BaseStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::AxisTagsContext* FeatParser::BaseStatementContext::axisTags() {
  return getRuleContext<FeatParser::AxisTagsContext>(0);
}

FeatParser::AxisScriptsContext* FeatParser::BaseStatementContext::axisScripts() {
  return getRuleContext<FeatParser::AxisScriptsContext>(0);
}

FeatParser::IncludeContext* FeatParser::BaseStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::BaseStatementContext::getRuleIndex() const {
  return FeatParser::RuleBaseStatement;
}


std::any FeatParser::BaseStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitBaseStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::BaseStatementContext* FeatParser::baseStatement() {
  BaseStatementContext *_localctx = _tracker.createInstance<BaseStatementContext>(_ctx, getState());
  enterRule(_localctx, 74, FeatParser::RuleBaseStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(625);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::HA_BTL:
      case FeatParser::VA_BTL: {
        setState(622);
        axisTags();
        break;
      }

      case FeatParser::HA_BSL:
      case FeatParser::VA_BSL: {
        setState(623);
        axisScripts();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(624);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- AxisTagsContext ------------------------------------------------------------------

FeatParser::AxisTagsContext::AxisTagsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AxisTagsContext::HA_BTL() {
  return getToken(FeatParser::HA_BTL, 0);
}

tree::TerminalNode* FeatParser::AxisTagsContext::VA_BTL() {
  return getToken(FeatParser::VA_BTL, 0);
}

std::vector<FeatParser::TagContext *> FeatParser::AxisTagsContext::tag() {
  return getRuleContexts<FeatParser::TagContext>();
}

FeatParser::TagContext* FeatParser::AxisTagsContext::tag(size_t i) {
  return getRuleContext<FeatParser::TagContext>(i);
}


size_t FeatParser::AxisTagsContext::getRuleIndex() const {
  return FeatParser::RuleAxisTags;
}


std::any FeatParser::AxisTagsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAxisTags(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AxisTagsContext* FeatParser::axisTags() {
  AxisTagsContext *_localctx = _tracker.createInstance<AxisTagsContext>(_ctx, getState());
  enterRule(_localctx, 76, FeatParser::RuleAxisTags);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(629);
    _la = _input->LA(1);
    if (!(_la == FeatParser::HA_BTL

    || _la == FeatParser::VA_BTL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(631); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(630);
      tag();
      setState(633); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::MARK || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 67) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AxisScriptsContext ------------------------------------------------------------------

FeatParser::AxisScriptsContext::AxisScriptsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FeatParser::BaseScriptContext *> FeatParser::AxisScriptsContext::baseScript() {
  return getRuleContexts<FeatParser::BaseScriptContext>();
}

FeatParser::BaseScriptContext* FeatParser::AxisScriptsContext::baseScript(size_t i) {
  return getRuleContext<FeatParser::BaseScriptContext>(i);
}

tree::TerminalNode* FeatParser::AxisScriptsContext::HA_BSL() {
  return getToken(FeatParser::HA_BSL, 0);
}

tree::TerminalNode* FeatParser::AxisScriptsContext::VA_BSL() {
  return getToken(FeatParser::VA_BSL, 0);
}

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

tree::TerminalNode* FeatParser::AxisScriptsContext::COMMA(size_t i) {
  return getToken(FeatParser::COMMA, i);
}


size_t FeatParser::AxisScriptsContext::getRuleIndex() const {
  return FeatParser::RuleAxisScripts;
}


std::any FeatParser::AxisScriptsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAxisScripts(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AxisScriptsContext* FeatParser::axisScripts() {
  AxisScriptsContext *_localctx = _tracker.createInstance<AxisScriptsContext>(_ctx, getState());
  enterRule(_localctx, 78, FeatParser::RuleAxisScripts);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(635);
    _la = _input->LA(1);
    if (!(_la == FeatParser::HA_BSL

    || _la == FeatParser::VA_BSL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(636);
    baseScript();
    setState(641);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::COMMA) {
      setState(637);
      match(FeatParser::COMMA);
      setState(638);
      baseScript();
      setState(643);
      _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;
}

//----------------- BaseScriptContext ------------------------------------------------------------------

FeatParser::BaseScriptContext::BaseScriptContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FeatParser::TagContext *> FeatParser::BaseScriptContext::tag() {
  return getRuleContexts<FeatParser::TagContext>();
}

FeatParser::TagContext* FeatParser::BaseScriptContext::tag(size_t i) {
  return getRuleContext<FeatParser::TagContext>(i);
}

std::vector<tree::TerminalNode *> FeatParser::BaseScriptContext::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::BaseScriptContext::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}


size_t FeatParser::BaseScriptContext::getRuleIndex() const {
  return FeatParser::RuleBaseScript;
}


std::any FeatParser::BaseScriptContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitBaseScript(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::BaseScriptContext* FeatParser::baseScript() {
  BaseScriptContext *_localctx = _tracker.createInstance<BaseScriptContext>(_ctx, getState());
  enterRule(_localctx, 80, FeatParser::RuleBaseScript);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(644);
    antlrcpp::downCast<BaseScriptContext *>(_localctx)->script = tag();
    setState(645);
    antlrcpp::downCast<BaseScriptContext *>(_localctx)->db = tag();
    setState(647); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(646);
      match(FeatParser::NUM);
      setState(649); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Table_GDEFContext ------------------------------------------------------------------

FeatParser::Table_GDEFContext::Table_GDEFContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_GDEFContext::GDEF() {
  return getTokens(FeatParser::GDEF);
}

tree::TerminalNode* FeatParser::Table_GDEFContext::GDEF(size_t i) {
  return getToken(FeatParser::GDEF, i);
}

tree::TerminalNode* FeatParser::Table_GDEFContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_GDEFContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_GDEFContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::GdefStatementContext *> FeatParser::Table_GDEFContext::gdefStatement() {
  return getRuleContexts<FeatParser::GdefStatementContext>();
}

FeatParser::GdefStatementContext* FeatParser::Table_GDEFContext::gdefStatement(size_t i) {
  return getRuleContext<FeatParser::GdefStatementContext>(i);
}


size_t FeatParser::Table_GDEFContext::getRuleIndex() const {
  return FeatParser::RuleTable_GDEF;
}


std::any FeatParser::Table_GDEFContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_GDEF(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_GDEFContext* FeatParser::table_GDEF() {
  Table_GDEFContext *_localctx = _tracker.createInstance<Table_GDEFContext>(_ctx, getState());
  enterRule(_localctx, 82, FeatParser::RuleTable_GDEF);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(651);
    match(FeatParser::GDEF);
    setState(652);
    match(FeatParser::LCBRACE);
    setState(654); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(653);
      gdefStatement();
      setState(656); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || ((((_la - 67) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 67)) & 15) != 0));
    setState(658);
    match(FeatParser::RCBRACE);
    setState(659);
    match(FeatParser::GDEF);
    setState(660);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GdefStatementContext ------------------------------------------------------------------

FeatParser::GdefStatementContext::GdefStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GdefStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::GdefGlyphClassContext* FeatParser::GdefStatementContext::gdefGlyphClass() {
  return getRuleContext<FeatParser::GdefGlyphClassContext>(0);
}

FeatParser::GdefAttachContext* FeatParser::GdefStatementContext::gdefAttach() {
  return getRuleContext<FeatParser::GdefAttachContext>(0);
}

FeatParser::GdefLigCaretPosContext* FeatParser::GdefStatementContext::gdefLigCaretPos() {
  return getRuleContext<FeatParser::GdefLigCaretPosContext>(0);
}

FeatParser::GdefLigCaretIndexContext* FeatParser::GdefStatementContext::gdefLigCaretIndex() {
  return getRuleContext<FeatParser::GdefLigCaretIndexContext>(0);
}

FeatParser::IncludeContext* FeatParser::GdefStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::GdefStatementContext::getRuleIndex() const {
  return FeatParser::RuleGdefStatement;
}


std::any FeatParser::GdefStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGdefStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GdefStatementContext* FeatParser::gdefStatement() {
  GdefStatementContext *_localctx = _tracker.createInstance<GdefStatementContext>(_ctx, getState());
  enterRule(_localctx, 84, FeatParser::RuleGdefStatement);

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

      case FeatParser::ATTACH: {
        setState(663);
        gdefAttach();
        break;
      }

      case FeatParser::LIG_CARET_BY_POS: {
        setState(664);
        gdefLigCaretPos();
        break;
      }

      case FeatParser::LIG_CARET_BY_IDX: {
        setState(665);
        gdefLigCaretIndex();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(666);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- GdefGlyphClassContext ------------------------------------------------------------------

FeatParser::GdefGlyphClassContext::GdefGlyphClassContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GdefGlyphClassContext::GLYPH_CLASS_DEF() {
  return getToken(FeatParser::GLYPH_CLASS_DEF, 0);
}

std::vector<FeatParser::GlyphClassOptionalContext *> FeatParser::GdefGlyphClassContext::glyphClassOptional() {
  return getRuleContexts<FeatParser::GlyphClassOptionalContext>();
}

FeatParser::GlyphClassOptionalContext* FeatParser::GdefGlyphClassContext::glyphClassOptional(size_t i) {
  return getRuleContext<FeatParser::GlyphClassOptionalContext>(i);
}

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

tree::TerminalNode* FeatParser::GdefGlyphClassContext::COMMA(size_t i) {
  return getToken(FeatParser::COMMA, i);
}


size_t FeatParser::GdefGlyphClassContext::getRuleIndex() const {
  return FeatParser::RuleGdefGlyphClass;
}


std::any FeatParser::GdefGlyphClassContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGdefGlyphClass(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GdefGlyphClassContext* FeatParser::gdefGlyphClass() {
  GdefGlyphClassContext *_localctx = _tracker.createInstance<GdefGlyphClassContext>(_ctx, getState());
  enterRule(_localctx, 86, FeatParser::RuleGdefGlyphClass);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(671);
    match(FeatParser::GLYPH_CLASS_DEF);
    setState(672);
    glyphClassOptional();
    setState(673);
    match(FeatParser::COMMA);
    setState(674);
    glyphClassOptional();
    setState(675);
    match(FeatParser::COMMA);
    setState(676);
    glyphClassOptional();
    setState(677);
    match(FeatParser::COMMA);
    setState(678);
    glyphClassOptional();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GdefAttachContext ------------------------------------------------------------------

FeatParser::GdefAttachContext::GdefAttachContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GdefAttachContext::ATTACH() {
  return getToken(FeatParser::ATTACH, 0);
}

FeatParser::LookupPatternContext* FeatParser::GdefAttachContext::lookupPattern() {
  return getRuleContext<FeatParser::LookupPatternContext>(0);
}

std::vector<tree::TerminalNode *> FeatParser::GdefAttachContext::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::GdefAttachContext::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}


size_t FeatParser::GdefAttachContext::getRuleIndex() const {
  return FeatParser::RuleGdefAttach;
}


std::any FeatParser::GdefAttachContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGdefAttach(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GdefAttachContext* FeatParser::gdefAttach() {
  GdefAttachContext *_localctx = _tracker.createInstance<GdefAttachContext>(_ctx, getState());
  enterRule(_localctx, 88, FeatParser::RuleGdefAttach);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(680);
    match(FeatParser::ATTACH);
    setState(681);
    lookupPattern();
    setState(683); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(682);
      match(FeatParser::NUM);
      setState(685); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GdefLigCaretPosContext ------------------------------------------------------------------

FeatParser::GdefLigCaretPosContext::GdefLigCaretPosContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GdefLigCaretPosContext::LIG_CARET_BY_POS() {
  return getToken(FeatParser::LIG_CARET_BY_POS, 0);
}

FeatParser::LookupPatternContext* FeatParser::GdefLigCaretPosContext::lookupPattern() {
  return getRuleContext<FeatParser::LookupPatternContext>(0);
}

std::vector<tree::TerminalNode *> FeatParser::GdefLigCaretPosContext::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::GdefLigCaretPosContext::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}


size_t FeatParser::GdefLigCaretPosContext::getRuleIndex() const {
  return FeatParser::RuleGdefLigCaretPos;
}


std::any FeatParser::GdefLigCaretPosContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGdefLigCaretPos(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GdefLigCaretPosContext* FeatParser::gdefLigCaretPos() {
  GdefLigCaretPosContext *_localctx = _tracker.createInstance<GdefLigCaretPosContext>(_ctx, getState());
  enterRule(_localctx, 90, FeatParser::RuleGdefLigCaretPos);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(687);
    match(FeatParser::LIG_CARET_BY_POS);
    setState(688);
    lookupPattern();
    setState(690); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(689);
      match(FeatParser::NUM);
      setState(692); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GdefLigCaretIndexContext ------------------------------------------------------------------

FeatParser::GdefLigCaretIndexContext::GdefLigCaretIndexContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GdefLigCaretIndexContext::LIG_CARET_BY_IDX() {
  return getToken(FeatParser::LIG_CARET_BY_IDX, 0);
}

FeatParser::LookupPatternContext* FeatParser::GdefLigCaretIndexContext::lookupPattern() {
  return getRuleContext<FeatParser::LookupPatternContext>(0);
}

std::vector<tree::TerminalNode *> FeatParser::GdefLigCaretIndexContext::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::GdefLigCaretIndexContext::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}


size_t FeatParser::GdefLigCaretIndexContext::getRuleIndex() const {
  return FeatParser::RuleGdefLigCaretIndex;
}


std::any FeatParser::GdefLigCaretIndexContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGdefLigCaretIndex(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GdefLigCaretIndexContext* FeatParser::gdefLigCaretIndex() {
  GdefLigCaretIndexContext *_localctx = _tracker.createInstance<GdefLigCaretIndexContext>(_ctx, getState());
  enterRule(_localctx, 92, FeatParser::RuleGdefLigCaretIndex);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(694);
    match(FeatParser::LIG_CARET_BY_IDX);
    setState(695);
    lookupPattern();
    setState(697); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(696);
      match(FeatParser::NUM);
      setState(699); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Table_headContext ------------------------------------------------------------------

FeatParser::Table_headContext::Table_headContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_headContext::HEAD() {
  return getTokens(FeatParser::HEAD);
}

tree::TerminalNode* FeatParser::Table_headContext::HEAD(size_t i) {
  return getToken(FeatParser::HEAD, i);
}

tree::TerminalNode* FeatParser::Table_headContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_headContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_headContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::HeadStatementContext *> FeatParser::Table_headContext::headStatement() {
  return getRuleContexts<FeatParser::HeadStatementContext>();
}

FeatParser::HeadStatementContext* FeatParser::Table_headContext::headStatement(size_t i) {
  return getRuleContext<FeatParser::HeadStatementContext>(i);
}


size_t FeatParser::Table_headContext::getRuleIndex() const {
  return FeatParser::RuleTable_head;
}


std::any FeatParser::Table_headContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_head(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_headContext* FeatParser::table_head() {
  Table_headContext *_localctx = _tracker.createInstance<Table_headContext>(_ctx, getState());
  enterRule(_localctx, 94, FeatParser::RuleTable_head);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(701);
    match(FeatParser::HEAD);
    setState(702);
    match(FeatParser::LCBRACE);
    setState(704); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(703);
      headStatement();
      setState(706); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || _la == FeatParser::FONT_REVISION);
    setState(708);
    match(FeatParser::RCBRACE);
    setState(709);
    match(FeatParser::HEAD);
    setState(710);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HeadStatementContext ------------------------------------------------------------------

FeatParser::HeadStatementContext::HeadStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::HeadStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::HeadContext* FeatParser::HeadStatementContext::head() {
  return getRuleContext<FeatParser::HeadContext>(0);
}

FeatParser::IncludeContext* FeatParser::HeadStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::HeadStatementContext::getRuleIndex() const {
  return FeatParser::RuleHeadStatement;
}


std::any FeatParser::HeadStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitHeadStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::HeadStatementContext* FeatParser::headStatement() {
  HeadStatementContext *_localctx = _tracker.createInstance<HeadStatementContext>(_ctx, getState());
  enterRule(_localctx, 96, FeatParser::RuleHeadStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(714);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::FONT_REVISION: {
        setState(712);
        head();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(713);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- HeadContext ------------------------------------------------------------------

FeatParser::HeadContext::HeadContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::HeadContext::FONT_REVISION() {
  return getToken(FeatParser::FONT_REVISION, 0);
}

tree::TerminalNode* FeatParser::HeadContext::POINTNUM() {
  return getToken(FeatParser::POINTNUM, 0);
}


size_t FeatParser::HeadContext::getRuleIndex() const {
  return FeatParser::RuleHead;
}


std::any FeatParser::HeadContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitHead(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::HeadContext* FeatParser::head() {
  HeadContext *_localctx = _tracker.createInstance<HeadContext>(_ctx, getState());
  enterRule(_localctx, 98, FeatParser::RuleHead);

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

  return _localctx;
}

//----------------- Table_hheaContext ------------------------------------------------------------------

FeatParser::Table_hheaContext::Table_hheaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_hheaContext::HHEA() {
  return getTokens(FeatParser::HHEA);
}

tree::TerminalNode* FeatParser::Table_hheaContext::HHEA(size_t i) {
  return getToken(FeatParser::HHEA, i);
}

tree::TerminalNode* FeatParser::Table_hheaContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_hheaContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_hheaContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::HheaStatementContext *> FeatParser::Table_hheaContext::hheaStatement() {
  return getRuleContexts<FeatParser::HheaStatementContext>();
}

FeatParser::HheaStatementContext* FeatParser::Table_hheaContext::hheaStatement(size_t i) {
  return getRuleContext<FeatParser::HheaStatementContext>(i);
}


size_t FeatParser::Table_hheaContext::getRuleIndex() const {
  return FeatParser::RuleTable_hhea;
}


std::any FeatParser::Table_hheaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_hhea(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_hheaContext* FeatParser::table_hhea() {
  Table_hheaContext *_localctx = _tracker.createInstance<Table_hheaContext>(_ctx, getState());
  enterRule(_localctx, 100, FeatParser::RuleTable_hhea);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(721);
    match(FeatParser::HHEA);
    setState(722);
    match(FeatParser::LCBRACE);
    setState(726);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 15) != 0)) {
      setState(723);
      hheaStatement();
      setState(728);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(729);
    match(FeatParser::RCBRACE);
    setState(730);
    match(FeatParser::HHEA);
    setState(731);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HheaStatementContext ------------------------------------------------------------------

FeatParser::HheaStatementContext::HheaStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::HheaStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::HheaContext* FeatParser::HheaStatementContext::hhea() {
  return getRuleContext<FeatParser::HheaContext>(0);
}

FeatParser::IncludeContext* FeatParser::HheaStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::HheaStatementContext::getRuleIndex() const {
  return FeatParser::RuleHheaStatement;
}


std::any FeatParser::HheaStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitHheaStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::HheaStatementContext* FeatParser::hheaStatement() {
  HheaStatementContext *_localctx = _tracker.createInstance<HheaStatementContext>(_ctx, getState());
  enterRule(_localctx, 102, FeatParser::RuleHheaStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(735);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::ASCENDER:
      case FeatParser::DESCENDER:
      case FeatParser::LINE_GAP:
      case FeatParser::CARET_OFFSET: {
        setState(733);
        hhea();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(734);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- HheaContext ------------------------------------------------------------------

FeatParser::HheaContext::HheaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::HheaContext::NUM() {
  return getToken(FeatParser::NUM, 0);
}

tree::TerminalNode* FeatParser::HheaContext::CARET_OFFSET() {
  return getToken(FeatParser::CARET_OFFSET, 0);
}

tree::TerminalNode* FeatParser::HheaContext::ASCENDER() {
  return getToken(FeatParser::ASCENDER, 0);
}

tree::TerminalNode* FeatParser::HheaContext::DESCENDER() {
  return getToken(FeatParser::DESCENDER, 0);
}

tree::TerminalNode* FeatParser::HheaContext::LINE_GAP() {
  return getToken(FeatParser::LINE_GAP, 0);
}


size_t FeatParser::HheaContext::getRuleIndex() const {
  return FeatParser::RuleHhea;
}


std::any FeatParser::HheaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitHhea(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::HheaContext* FeatParser::hhea() {
  HheaContext *_localctx = _tracker.createInstance<HheaContext>(_ctx, getState());
  enterRule(_localctx, 104, FeatParser::RuleHhea);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(739);
    _la = _input->LA(1);
    if (!(((((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 15) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(740);
    match(FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Table_vheaContext ------------------------------------------------------------------

FeatParser::Table_vheaContext::Table_vheaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_vheaContext::VHEA() {
  return getTokens(FeatParser::VHEA);
}

tree::TerminalNode* FeatParser::Table_vheaContext::VHEA(size_t i) {
  return getToken(FeatParser::VHEA, i);
}

tree::TerminalNode* FeatParser::Table_vheaContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_vheaContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_vheaContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::VheaStatementContext *> FeatParser::Table_vheaContext::vheaStatement() {
  return getRuleContexts<FeatParser::VheaStatementContext>();
}

FeatParser::VheaStatementContext* FeatParser::Table_vheaContext::vheaStatement(size_t i) {
  return getRuleContext<FeatParser::VheaStatementContext>(i);
}


size_t FeatParser::Table_vheaContext::getRuleIndex() const {
  return FeatParser::RuleTable_vhea;
}


std::any FeatParser::Table_vheaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_vhea(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_vheaContext* FeatParser::table_vhea() {
  Table_vheaContext *_localctx = _tracker.createInstance<Table_vheaContext>(_ctx, getState());
  enterRule(_localctx, 106, FeatParser::RuleTable_vhea);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(742);
    match(FeatParser::VHEA);
    setState(743);
    match(FeatParser::LCBRACE);
    setState(747);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 109) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 109)) & 7) != 0)) {
      setState(744);
      vheaStatement();
      setState(749);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(750);
    match(FeatParser::RCBRACE);
    setState(751);
    match(FeatParser::VHEA);
    setState(752);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VheaStatementContext ------------------------------------------------------------------

FeatParser::VheaStatementContext::VheaStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::VheaStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::VheaContext* FeatParser::VheaStatementContext::vhea() {
  return getRuleContext<FeatParser::VheaContext>(0);
}

FeatParser::IncludeContext* FeatParser::VheaStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::VheaStatementContext::getRuleIndex() const {
  return FeatParser::RuleVheaStatement;
}


std::any FeatParser::VheaStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitVheaStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::VheaStatementContext* FeatParser::vheaStatement() {
  VheaStatementContext *_localctx = _tracker.createInstance<VheaStatementContext>(_ctx, getState());
  enterRule(_localctx, 108, FeatParser::RuleVheaStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(756);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::VERT_TYPO_ASCENDER:
      case FeatParser::VERT_TYPO_DESCENDER:
      case FeatParser::VERT_TYPO_LINE_GAP: {
        setState(754);
        vhea();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(755);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- VheaContext ------------------------------------------------------------------

FeatParser::VheaContext::VheaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::VheaContext::NUM() {
  return getToken(FeatParser::NUM, 0);
}

tree::TerminalNode* FeatParser::VheaContext::VERT_TYPO_ASCENDER() {
  return getToken(FeatParser::VERT_TYPO_ASCENDER, 0);
}

tree::TerminalNode* FeatParser::VheaContext::VERT_TYPO_DESCENDER() {
  return getToken(FeatParser::VERT_TYPO_DESCENDER, 0);
}

tree::TerminalNode* FeatParser::VheaContext::VERT_TYPO_LINE_GAP() {
  return getToken(FeatParser::VERT_TYPO_LINE_GAP, 0);
}


size_t FeatParser::VheaContext::getRuleIndex() const {
  return FeatParser::RuleVhea;
}


std::any FeatParser::VheaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitVhea(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::VheaContext* FeatParser::vhea() {
  VheaContext *_localctx = _tracker.createInstance<VheaContext>(_ctx, getState());
  enterRule(_localctx, 110, FeatParser::RuleVhea);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(760);
    _la = _input->LA(1);
    if (!(((((_la - 109) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 109)) & 7) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(761);
    match(FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Table_nameContext ------------------------------------------------------------------

FeatParser::Table_nameContext::Table_nameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_nameContext::NAME() {
  return getTokens(FeatParser::NAME);
}

tree::TerminalNode* FeatParser::Table_nameContext::NAME(size_t i) {
  return getToken(FeatParser::NAME, i);
}

tree::TerminalNode* FeatParser::Table_nameContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_nameContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_nameContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::NameStatementContext *> FeatParser::Table_nameContext::nameStatement() {
  return getRuleContexts<FeatParser::NameStatementContext>();
}

FeatParser::NameStatementContext* FeatParser::Table_nameContext::nameStatement(size_t i) {
  return getRuleContext<FeatParser::NameStatementContext>(i);
}


size_t FeatParser::Table_nameContext::getRuleIndex() const {
  return FeatParser::RuleTable_name;
}


std::any FeatParser::Table_nameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_name(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_nameContext* FeatParser::table_name() {
  Table_nameContext *_localctx = _tracker.createInstance<Table_nameContext>(_ctx, getState());
  enterRule(_localctx, 112, FeatParser::RuleTable_name);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(763);
    match(FeatParser::NAME);
    setState(764);
    match(FeatParser::LCBRACE);
    setState(766); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(765);
      nameStatement();
      setState(768); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || _la == FeatParser::NAMEID);
    setState(770);
    match(FeatParser::RCBRACE);
    setState(771);
    match(FeatParser::NAME);
    setState(772);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NameStatementContext ------------------------------------------------------------------

FeatParser::NameStatementContext::NameStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::NameStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::NameIDContext* FeatParser::NameStatementContext::nameID() {
  return getRuleContext<FeatParser::NameIDContext>(0);
}

FeatParser::IncludeContext* FeatParser::NameStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::NameStatementContext::getRuleIndex() const {
  return FeatParser::RuleNameStatement;
}


std::any FeatParser::NameStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitNameStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::NameStatementContext* FeatParser::nameStatement() {
  NameStatementContext *_localctx = _tracker.createInstance<NameStatementContext>(_ctx, getState());
  enterRule(_localctx, 114, FeatParser::RuleNameStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(776);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NAMEID: {
        setState(774);
        nameID();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(775);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- NameIDContext ------------------------------------------------------------------

FeatParser::NameIDContext::NameIDContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::NameIDContext::NAMEID() {
  return getToken(FeatParser::NAMEID, 0);
}

tree::TerminalNode* FeatParser::NameIDContext::QUOTE() {
  return getToken(FeatParser::QUOTE, 0);
}

tree::TerminalNode* FeatParser::NameIDContext::STRVAL() {
  return getToken(FeatParser::STRVAL, 0);
}

tree::TerminalNode* FeatParser::NameIDContext::EQUOTE() {
  return getToken(FeatParser::EQUOTE, 0);
}

std::vector<FeatParser::GenNumContext *> FeatParser::NameIDContext::genNum() {
  return getRuleContexts<FeatParser::GenNumContext>();
}

FeatParser::GenNumContext* FeatParser::NameIDContext::genNum(size_t i) {
  return getRuleContext<FeatParser::GenNumContext>(i);
}


size_t FeatParser::NameIDContext::getRuleIndex() const {
  return FeatParser::RuleNameID;
}


std::any FeatParser::NameIDContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitNameID(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::NameIDContext* FeatParser::nameID() {
  NameIDContext *_localctx = _tracker.createInstance<NameIDContext>(_ctx, getState());
  enterRule(_localctx, 116, FeatParser::RuleNameID);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(780);
    match(FeatParser::NAMEID);
    setState(781);
    antlrcpp::downCast<NameIDContext *>(_localctx)->id = genNum();
    setState(788);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 131) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 131)) & 7) != 0)) {
      setState(782);
      antlrcpp::downCast<NameIDContext *>(_localctx)->plat = genNum();
      setState(786);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 131) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 131)) & 7) != 0)) {
        setState(783);
        antlrcpp::downCast<NameIDContext *>(_localctx)->spec = genNum();
        setState(784);
        antlrcpp::downCast<NameIDContext *>(_localctx)->lang = genNum();
      }
    }
    setState(790);
    match(FeatParser::QUOTE);
    setState(791);
    match(FeatParser::STRVAL);
    setState(792);
    match(FeatParser::EQUOTE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Table_OS_2Context ------------------------------------------------------------------

FeatParser::Table_OS_2Context::Table_OS_2Context(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_OS_2Context::OS_2() {
  return getTokens(FeatParser::OS_2);
}

tree::TerminalNode* FeatParser::Table_OS_2Context::OS_2(size_t i) {
  return getToken(FeatParser::OS_2, i);
}

tree::TerminalNode* FeatParser::Table_OS_2Context::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_OS_2Context::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_OS_2Context::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::Os_2StatementContext *> FeatParser::Table_OS_2Context::os_2Statement() {
  return getRuleContexts<FeatParser::Os_2StatementContext>();
}

FeatParser::Os_2StatementContext* FeatParser::Table_OS_2Context::os_2Statement(size_t i) {
  return getRuleContext<FeatParser::Os_2StatementContext>(i);
}


size_t FeatParser::Table_OS_2Context::getRuleIndex() const {
  return FeatParser::RuleTable_OS_2;
}


std::any FeatParser::Table_OS_2Context::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_OS_2(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_OS_2Context* FeatParser::table_OS_2() {
  Table_OS_2Context *_localctx = _tracker.createInstance<Table_OS_2Context>(_ctx, getState());
  enterRule(_localctx, 118, FeatParser::RuleTable_OS_2);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(794);
    match(FeatParser::OS_2);
    setState(795);
    match(FeatParser::LCBRACE);
    setState(797); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(796);
      os_2Statement();
      setState(799); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || ((((_la - 81) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 81)) & 262143) != 0));
    setState(801);
    match(FeatParser::RCBRACE);
    setState(802);
    match(FeatParser::OS_2);
    setState(803);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Os_2StatementContext ------------------------------------------------------------------

FeatParser::Os_2StatementContext::Os_2StatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::Os_2StatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::Os_2Context* FeatParser::Os_2StatementContext::os_2() {
  return getRuleContext<FeatParser::Os_2Context>(0);
}

FeatParser::IncludeContext* FeatParser::Os_2StatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::Os_2StatementContext::getRuleIndex() const {
  return FeatParser::RuleOs_2Statement;
}


std::any FeatParser::Os_2StatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitOs_2Statement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Os_2StatementContext* FeatParser::os_2Statement() {
  Os_2StatementContext *_localctx = _tracker.createInstance<Os_2StatementContext>(_ctx, getState());
  enterRule(_localctx, 120, FeatParser::RuleOs_2Statement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(807);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::FS_TYPE:
      case FeatParser::FS_TYPE_v:
      case FeatParser::OS2_LOWER_OP_SIZE:
      case FeatParser::OS2_UPPER_OP_SIZE:
      case FeatParser::PANOSE:
      case FeatParser::TYPO_ASCENDER:
      case FeatParser::TYPO_DESCENDER:
      case FeatParser::TYPO_LINE_GAP:
      case FeatParser::WIN_ASCENT:
      case FeatParser::WIN_DESCENT:
      case FeatParser::X_HEIGHT:
      case FeatParser::CAP_HEIGHT:
      case FeatParser::WEIGHT_CLASS:
      case FeatParser::WIDTH_CLASS:
      case FeatParser::VENDOR:
      case FeatParser::UNICODE_RANGE:
      case FeatParser::CODE_PAGE_RANGE:
      case FeatParser::FAMILY_CLASS: {
        setState(805);
        os_2();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(806);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- Os_2Context ------------------------------------------------------------------

FeatParser::Os_2Context::Os_2Context(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::Os_2Context::TYPO_ASCENDER() {
  return getToken(FeatParser::TYPO_ASCENDER, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::TYPO_DESCENDER() {
  return getToken(FeatParser::TYPO_DESCENDER, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::TYPO_LINE_GAP() {
  return getToken(FeatParser::TYPO_LINE_GAP, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::WIN_ASCENT() {
  return getToken(FeatParser::WIN_ASCENT, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::WIN_DESCENT() {
  return getToken(FeatParser::WIN_DESCENT, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::X_HEIGHT() {
  return getToken(FeatParser::X_HEIGHT, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::CAP_HEIGHT() {
  return getToken(FeatParser::CAP_HEIGHT, 0);
}

std::vector<tree::TerminalNode *> FeatParser::Os_2Context::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::Os_2Context::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}

tree::TerminalNode* FeatParser::Os_2Context::FS_TYPE() {
  return getToken(FeatParser::FS_TYPE, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::FS_TYPE_v() {
  return getToken(FeatParser::FS_TYPE_v, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::WEIGHT_CLASS() {
  return getToken(FeatParser::WEIGHT_CLASS, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::WIDTH_CLASS() {
  return getToken(FeatParser::WIDTH_CLASS, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::OS2_LOWER_OP_SIZE() {
  return getToken(FeatParser::OS2_LOWER_OP_SIZE, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::OS2_UPPER_OP_SIZE() {
  return getToken(FeatParser::OS2_UPPER_OP_SIZE, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::FAMILY_CLASS() {
  return getToken(FeatParser::FAMILY_CLASS, 0);
}

FeatParser::GenNumContext* FeatParser::Os_2Context::genNum() {
  return getRuleContext<FeatParser::GenNumContext>(0);
}

tree::TerminalNode* FeatParser::Os_2Context::VENDOR() {
  return getToken(FeatParser::VENDOR, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::QUOTE() {
  return getToken(FeatParser::QUOTE, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::STRVAL() {
  return getToken(FeatParser::STRVAL, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::EQUOTE() {
  return getToken(FeatParser::EQUOTE, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::PANOSE() {
  return getToken(FeatParser::PANOSE, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::UNICODE_RANGE() {
  return getToken(FeatParser::UNICODE_RANGE, 0);
}

tree::TerminalNode* FeatParser::Os_2Context::CODE_PAGE_RANGE() {
  return getToken(FeatParser::CODE_PAGE_RANGE, 0);
}


size_t FeatParser::Os_2Context::getRuleIndex() const {
  return FeatParser::RuleOs_2;
}


std::any FeatParser::Os_2Context::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitOs_2(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Os_2Context* FeatParser::os_2() {
  Os_2Context *_localctx = _tracker.createInstance<Os_2Context>(_ctx, getState());
  enterRule(_localctx, 122, FeatParser::RuleOs_2);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(838);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::TYPO_ASCENDER:
      case FeatParser::TYPO_DESCENDER:
      case FeatParser::TYPO_LINE_GAP:
      case FeatParser::WIN_ASCENT:
      case FeatParser::WIN_DESCENT:
      case FeatParser::X_HEIGHT:
      case FeatParser::CAP_HEIGHT: {
        enterOuterAlt(_localctx, 1);
        setState(811);
        _la = _input->LA(1);
        if (!(((((_la - 86) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 86)) & 127) != 0))) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(812);
        antlrcpp::downCast<Os_2Context *>(_localctx)->num = match(FeatParser::NUM);
        break;
      }

      case FeatParser::FS_TYPE:
      case FeatParser::FS_TYPE_v:
      case FeatParser::OS2_LOWER_OP_SIZE:
      case FeatParser::OS2_UPPER_OP_SIZE:
      case FeatParser::WEIGHT_CLASS:
      case FeatParser::WIDTH_CLASS: {
        enterOuterAlt(_localctx, 2);
        setState(813);
        _la = _input->LA(1);
        if (!(((((_la - 81) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 81)) & 12303) != 0))) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(814);
        antlrcpp::downCast<Os_2Context *>(_localctx)->unum = match(FeatParser::NUM);
        break;
      }

      case FeatParser::FAMILY_CLASS: {
        enterOuterAlt(_localctx, 3);
        setState(815);
        match(FeatParser::FAMILY_CLASS);
        setState(816);
        antlrcpp::downCast<Os_2Context *>(_localctx)->gnum = genNum();
        break;
      }

      case FeatParser::VENDOR: {
        enterOuterAlt(_localctx, 4);
        setState(817);
        match(FeatParser::VENDOR);
        setState(818);
        match(FeatParser::QUOTE);
        setState(819);
        match(FeatParser::STRVAL);
        setState(820);
        match(FeatParser::EQUOTE);
        break;
      }

      case FeatParser::PANOSE: {
        enterOuterAlt(_localctx, 5);
        setState(821);
        match(FeatParser::PANOSE);
        setState(822);
        match(FeatParser::NUM);
        setState(823);
        match(FeatParser::NUM);
        setState(824);
        match(FeatParser::NUM);
        setState(825);
        match(FeatParser::NUM);
        setState(826);
        match(FeatParser::NUM);
        setState(827);
        match(FeatParser::NUM);
        setState(828);
        match(FeatParser::NUM);
        setState(829);
        match(FeatParser::NUM);
        setState(830);
        match(FeatParser::NUM);
        setState(831);
        match(FeatParser::NUM);
        break;
      }

      case FeatParser::UNICODE_RANGE:
      case FeatParser::CODE_PAGE_RANGE: {
        enterOuterAlt(_localctx, 6);
        setState(832);
        _la = _input->LA(1);
        if (!(_la == FeatParser::UNICODE_RANGE

        || _la == FeatParser::CODE_PAGE_RANGE)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(834); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(833);
          match(FeatParser::NUM);
          setState(836); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == FeatParser::NUM);
        break;
      }

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

  return _localctx;
}

//----------------- Table_STATContext ------------------------------------------------------------------

FeatParser::Table_STATContext::Table_STATContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_STATContext::STAT() {
  return getTokens(FeatParser::STAT);
}

tree::TerminalNode* FeatParser::Table_STATContext::STAT(size_t i) {
  return getToken(FeatParser::STAT, i);
}

tree::TerminalNode* FeatParser::Table_STATContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_STATContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_STATContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::StatStatementContext *> FeatParser::Table_STATContext::statStatement() {
  return getRuleContexts<FeatParser::StatStatementContext>();
}

FeatParser::StatStatementContext* FeatParser::Table_STATContext::statStatement(size_t i) {
  return getRuleContext<FeatParser::StatStatementContext>(i);
}


size_t FeatParser::Table_STATContext::getRuleIndex() const {
  return FeatParser::RuleTable_STAT;
}


std::any FeatParser::Table_STATContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_STAT(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_STATContext* FeatParser::table_STAT() {
  Table_STATContext *_localctx = _tracker.createInstance<Table_STATContext>(_ctx, getState());
  enterRule(_localctx, 124, FeatParser::RuleTable_STAT);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(840);
    match(FeatParser::STAT);
    setState(841);
    match(FeatParser::LCBRACE);
    setState(843); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(842);
      statStatement();
      setState(845); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || ((((_la - 100) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 100)) & 15) != 0));
    setState(847);
    match(FeatParser::RCBRACE);
    setState(848);
    match(FeatParser::STAT);
    setState(849);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatStatementContext ------------------------------------------------------------------

FeatParser::StatStatementContext::StatStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::StatStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::DesignAxisContext* FeatParser::StatStatementContext::designAxis() {
  return getRuleContext<FeatParser::DesignAxisContext>(0);
}

FeatParser::AxisValueContext* FeatParser::StatStatementContext::axisValue() {
  return getRuleContext<FeatParser::AxisValueContext>(0);
}

FeatParser::ElidedFallbackNameContext* FeatParser::StatStatementContext::elidedFallbackName() {
  return getRuleContext<FeatParser::ElidedFallbackNameContext>(0);
}

FeatParser::ElidedFallbackNameIDContext* FeatParser::StatStatementContext::elidedFallbackNameID() {
  return getRuleContext<FeatParser::ElidedFallbackNameIDContext>(0);
}

FeatParser::IncludeContext* FeatParser::StatStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::StatStatementContext::getRuleIndex() const {
  return FeatParser::RuleStatStatement;
}


std::any FeatParser::StatStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitStatStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::StatStatementContext* FeatParser::statStatement() {
  StatStatementContext *_localctx = _tracker.createInstance<StatStatementContext>(_ctx, getState());
  enterRule(_localctx, 126, FeatParser::RuleStatStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(856);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::DESIGN_AXIS: {
        setState(851);
        designAxis();
        break;
      }

      case FeatParser::AXIS_VALUE: {
        setState(852);
        axisValue();
        break;
      }

      case FeatParser::ELIDED_FALLBACK_NAME: {
        setState(853);
        elidedFallbackName();
        break;
      }

      case FeatParser::ELIDED_FALLBACK_NAME_ID: {
        setState(854);
        elidedFallbackNameID();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(855);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- DesignAxisContext ------------------------------------------------------------------

FeatParser::DesignAxisContext::DesignAxisContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::DesignAxisContext::DESIGN_AXIS() {
  return getToken(FeatParser::DESIGN_AXIS, 0);
}

FeatParser::TagContext* FeatParser::DesignAxisContext::tag() {
  return getRuleContext<FeatParser::TagContext>(0);
}

tree::TerminalNode* FeatParser::DesignAxisContext::NUM() {
  return getToken(FeatParser::NUM, 0);
}

tree::TerminalNode* FeatParser::DesignAxisContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::DesignAxisContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

std::vector<FeatParser::NameEntryStatementContext *> FeatParser::DesignAxisContext::nameEntryStatement() {
  return getRuleContexts<FeatParser::NameEntryStatementContext>();
}

FeatParser::NameEntryStatementContext* FeatParser::DesignAxisContext::nameEntryStatement(size_t i) {
  return getRuleContext<FeatParser::NameEntryStatementContext>(i);
}


size_t FeatParser::DesignAxisContext::getRuleIndex() const {
  return FeatParser::RuleDesignAxis;
}


std::any FeatParser::DesignAxisContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitDesignAxis(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::DesignAxisContext* FeatParser::designAxis() {
  DesignAxisContext *_localctx = _tracker.createInstance<DesignAxisContext>(_ctx, getState());
  enterRule(_localctx, 128, FeatParser::RuleDesignAxis);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(860);
    match(FeatParser::DESIGN_AXIS);
    setState(861);
    tag();
    setState(862);
    match(FeatParser::NUM);
    setState(863);
    match(FeatParser::LCBRACE);
    setState(865); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(864);
      nameEntryStatement();
      setState(867); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || _la == FeatParser::NAME);
    setState(869);
    match(FeatParser::RCBRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AxisValueContext ------------------------------------------------------------------

FeatParser::AxisValueContext::AxisValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AxisValueContext::AXIS_VALUE() {
  return getToken(FeatParser::AXIS_VALUE, 0);
}

tree::TerminalNode* FeatParser::AxisValueContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::AxisValueContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

std::vector<FeatParser::AxisValueStatementContext *> FeatParser::AxisValueContext::axisValueStatement() {
  return getRuleContexts<FeatParser::AxisValueStatementContext>();
}

FeatParser::AxisValueStatementContext* FeatParser::AxisValueContext::axisValueStatement(size_t i) {
  return getRuleContext<FeatParser::AxisValueStatementContext>(i);
}


size_t FeatParser::AxisValueContext::getRuleIndex() const {
  return FeatParser::RuleAxisValue;
}


std::any FeatParser::AxisValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAxisValue(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AxisValueContext* FeatParser::axisValue() {
  AxisValueContext *_localctx = _tracker.createInstance<AxisValueContext>(_ctx, getState());
  enterRule(_localctx, 130, FeatParser::RuleAxisValue);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(871);
    match(FeatParser::AXIS_VALUE);
    setState(872);
    match(FeatParser::LCBRACE);
    setState(874); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(873);
      axisValueStatement();
      setState(876); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 201326593) != 0));
    setState(878);
    match(FeatParser::RCBRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AxisValueStatementContext ------------------------------------------------------------------

FeatParser::AxisValueStatementContext::AxisValueStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AxisValueStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::NameEntryContext* FeatParser::AxisValueStatementContext::nameEntry() {
  return getRuleContext<FeatParser::NameEntryContext>(0);
}

FeatParser::AxisValueLocationContext* FeatParser::AxisValueStatementContext::axisValueLocation() {
  return getRuleContext<FeatParser::AxisValueLocationContext>(0);
}

FeatParser::AxisValueFlagsContext* FeatParser::AxisValueStatementContext::axisValueFlags() {
  return getRuleContext<FeatParser::AxisValueFlagsContext>(0);
}

FeatParser::IncludeContext* FeatParser::AxisValueStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::AxisValueStatementContext::getRuleIndex() const {
  return FeatParser::RuleAxisValueStatement;
}


std::any FeatParser::AxisValueStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAxisValueStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AxisValueStatementContext* FeatParser::axisValueStatement() {
  AxisValueStatementContext *_localctx = _tracker.createInstance<AxisValueStatementContext>(_ctx, getState());
  enterRule(_localctx, 132, FeatParser::RuleAxisValueStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(884);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NAME: {
        setState(880);
        nameEntry();
        break;
      }

      case FeatParser::LOCATION: {
        setState(881);
        axisValueLocation();
        break;
      }

      case FeatParser::FLAG: {
        setState(882);
        axisValueFlags();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(883);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- AxisValueLocationContext ------------------------------------------------------------------

FeatParser::AxisValueLocationContext::AxisValueLocationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AxisValueLocationContext::LOCATION() {
  return getToken(FeatParser::LOCATION, 0);
}

FeatParser::TagContext* FeatParser::AxisValueLocationContext::tag() {
  return getRuleContext<FeatParser::TagContext>(0);
}

std::vector<FeatParser::FixedNumContext *> FeatParser::AxisValueLocationContext::fixedNum() {
  return getRuleContexts<FeatParser::FixedNumContext>();
}

FeatParser::FixedNumContext* FeatParser::AxisValueLocationContext::fixedNum(size_t i) {
  return getRuleContext<FeatParser::FixedNumContext>(i);
}


size_t FeatParser::AxisValueLocationContext::getRuleIndex() const {
  return FeatParser::RuleAxisValueLocation;
}


std::any FeatParser::AxisValueLocationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAxisValueLocation(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AxisValueLocationContext* FeatParser::axisValueLocation() {
  AxisValueLocationContext *_localctx = _tracker.createInstance<AxisValueLocationContext>(_ctx, getState());
  enterRule(_localctx, 134, FeatParser::RuleAxisValueLocation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(888);
    match(FeatParser::LOCATION);
    setState(889);
    tag();
    setState(890);
    fixedNum();
    setState(895);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == FeatParser::POINTNUM

    || _la == FeatParser::NUM) {
      setState(891);
      fixedNum();
      setState(893);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == FeatParser::POINTNUM

      || _la == FeatParser::NUM) {
        setState(892);
        fixedNum();
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AxisValueFlagsContext ------------------------------------------------------------------

FeatParser::AxisValueFlagsContext::AxisValueFlagsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AxisValueFlagsContext::FLAG() {
  return getToken(FeatParser::FLAG, 0);
}

std::vector<tree::TerminalNode *> FeatParser::AxisValueFlagsContext::AXIS_OSFA() {
  return getTokens(FeatParser::AXIS_OSFA);
}

tree::TerminalNode* FeatParser::AxisValueFlagsContext::AXIS_OSFA(size_t i) {
  return getToken(FeatParser::AXIS_OSFA, i);
}

std::vector<tree::TerminalNode *> FeatParser::AxisValueFlagsContext::AXIS_EAVN() {
  return getTokens(FeatParser::AXIS_EAVN);
}

tree::TerminalNode* FeatParser::AxisValueFlagsContext::AXIS_EAVN(size_t i) {
  return getToken(FeatParser::AXIS_EAVN, i);
}


size_t FeatParser::AxisValueFlagsContext::getRuleIndex() const {
  return FeatParser::RuleAxisValueFlags;
}


std::any FeatParser::AxisValueFlagsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAxisValueFlags(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AxisValueFlagsContext* FeatParser::axisValueFlags() {
  AxisValueFlagsContext *_localctx = _tracker.createInstance<AxisValueFlagsContext>(_ctx, getState());
  enterRule(_localctx, 136, FeatParser::RuleAxisValueFlags);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(897);
    match(FeatParser::FLAG);
    setState(899); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(898);
      _la = _input->LA(1);
      if (!(_la == FeatParser::AXIS_EAVN

      || _la == FeatParser::AXIS_OSFA)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(901); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::AXIS_EAVN

    || _la == FeatParser::AXIS_OSFA);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElidedFallbackNameContext ------------------------------------------------------------------

FeatParser::ElidedFallbackNameContext::ElidedFallbackNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::ElidedFallbackNameContext::ELIDED_FALLBACK_NAME() {
  return getToken(FeatParser::ELIDED_FALLBACK_NAME, 0);
}

tree::TerminalNode* FeatParser::ElidedFallbackNameContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::ElidedFallbackNameContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

std::vector<FeatParser::NameEntryStatementContext *> FeatParser::ElidedFallbackNameContext::nameEntryStatement() {
  return getRuleContexts<FeatParser::NameEntryStatementContext>();
}

FeatParser::NameEntryStatementContext* FeatParser::ElidedFallbackNameContext::nameEntryStatement(size_t i) {
  return getRuleContext<FeatParser::NameEntryStatementContext>(i);
}


size_t FeatParser::ElidedFallbackNameContext::getRuleIndex() const {
  return FeatParser::RuleElidedFallbackName;
}


std::any FeatParser::ElidedFallbackNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitElidedFallbackName(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ElidedFallbackNameContext* FeatParser::elidedFallbackName() {
  ElidedFallbackNameContext *_localctx = _tracker.createInstance<ElidedFallbackNameContext>(_ctx, getState());
  enterRule(_localctx, 138, FeatParser::RuleElidedFallbackName);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(903);
    match(FeatParser::ELIDED_FALLBACK_NAME);
    setState(904);
    match(FeatParser::LCBRACE);
    setState(906); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(905);
      nameEntryStatement();
      setState(908); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || _la == FeatParser::NAME);
    setState(910);
    match(FeatParser::RCBRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NameEntryStatementContext ------------------------------------------------------------------

FeatParser::NameEntryStatementContext::NameEntryStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::NameEntryStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::NameEntryContext* FeatParser::NameEntryStatementContext::nameEntry() {
  return getRuleContext<FeatParser::NameEntryContext>(0);
}

FeatParser::IncludeContext* FeatParser::NameEntryStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::NameEntryStatementContext::getRuleIndex() const {
  return FeatParser::RuleNameEntryStatement;
}


std::any FeatParser::NameEntryStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitNameEntryStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::NameEntryStatementContext* FeatParser::nameEntryStatement() {
  NameEntryStatementContext *_localctx = _tracker.createInstance<NameEntryStatementContext>(_ctx, getState());
  enterRule(_localctx, 140, FeatParser::RuleNameEntryStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(914);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NAME: {
        setState(912);
        nameEntry();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(913);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- ElidedFallbackNameIDContext ------------------------------------------------------------------

FeatParser::ElidedFallbackNameIDContext::ElidedFallbackNameIDContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::ElidedFallbackNameIDContext::ELIDED_FALLBACK_NAME_ID() {
  return getToken(FeatParser::ELIDED_FALLBACK_NAME_ID, 0);
}

FeatParser::GenNumContext* FeatParser::ElidedFallbackNameIDContext::genNum() {
  return getRuleContext<FeatParser::GenNumContext>(0);
}


size_t FeatParser::ElidedFallbackNameIDContext::getRuleIndex() const {
  return FeatParser::RuleElidedFallbackNameID;
}


std::any FeatParser::ElidedFallbackNameIDContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitElidedFallbackNameID(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::ElidedFallbackNameIDContext* FeatParser::elidedFallbackNameID() {
  ElidedFallbackNameIDContext *_localctx = _tracker.createInstance<ElidedFallbackNameIDContext>(_ctx, getState());
  enterRule(_localctx, 142, FeatParser::RuleElidedFallbackNameID);

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

  return _localctx;
}

//----------------- NameEntryContext ------------------------------------------------------------------

FeatParser::NameEntryContext::NameEntryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::NameEntryContext::NAME() {
  return getToken(FeatParser::NAME, 0);
}

tree::TerminalNode* FeatParser::NameEntryContext::QUOTE() {
  return getToken(FeatParser::QUOTE, 0);
}

tree::TerminalNode* FeatParser::NameEntryContext::STRVAL() {
  return getToken(FeatParser::STRVAL, 0);
}

tree::TerminalNode* FeatParser::NameEntryContext::EQUOTE() {
  return getToken(FeatParser::EQUOTE, 0);
}

std::vector<FeatParser::GenNumContext *> FeatParser::NameEntryContext::genNum() {
  return getRuleContexts<FeatParser::GenNumContext>();
}

FeatParser::GenNumContext* FeatParser::NameEntryContext::genNum(size_t i) {
  return getRuleContext<FeatParser::GenNumContext>(i);
}


size_t FeatParser::NameEntryContext::getRuleIndex() const {
  return FeatParser::RuleNameEntry;
}


std::any FeatParser::NameEntryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitNameEntry(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::NameEntryContext* FeatParser::nameEntry() {
  NameEntryContext *_localctx = _tracker.createInstance<NameEntryContext>(_ctx, getState());
  enterRule(_localctx, 144, FeatParser::RuleNameEntry);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (((((_la - 131) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 131)) & 7) != 0)) {
      setState(922);
      genNum();
      setState(926);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 131) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 131)) & 7) != 0)) {
        setState(923);
        genNum();
        setState(924);
        genNum();
      }
    }
    setState(930);
    match(FeatParser::QUOTE);
    setState(931);
    match(FeatParser::STRVAL);
    setState(932);
    match(FeatParser::EQUOTE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Table_vmtxContext ------------------------------------------------------------------

FeatParser::Table_vmtxContext::Table_vmtxContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> FeatParser::Table_vmtxContext::VMTX() {
  return getTokens(FeatParser::VMTX);
}

tree::TerminalNode* FeatParser::Table_vmtxContext::VMTX(size_t i) {
  return getToken(FeatParser::VMTX, i);
}

tree::TerminalNode* FeatParser::Table_vmtxContext::LCBRACE() {
  return getToken(FeatParser::LCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_vmtxContext::RCBRACE() {
  return getToken(FeatParser::RCBRACE, 0);
}

tree::TerminalNode* FeatParser::Table_vmtxContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

std::vector<FeatParser::VmtxStatementContext *> FeatParser::Table_vmtxContext::vmtxStatement() {
  return getRuleContexts<FeatParser::VmtxStatementContext>();
}

FeatParser::VmtxStatementContext* FeatParser::Table_vmtxContext::vmtxStatement(size_t i) {
  return getRuleContext<FeatParser::VmtxStatementContext>(i);
}


size_t FeatParser::Table_vmtxContext::getRuleIndex() const {
  return FeatParser::RuleTable_vmtx;
}


std::any FeatParser::Table_vmtxContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTable_vmtx(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Table_vmtxContext* FeatParser::table_vmtx() {
  Table_vmtxContext *_localctx = _tracker.createInstance<Table_vmtxContext>(_ctx, getState());
  enterRule(_localctx, 146, FeatParser::RuleTable_vmtx);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(934);
    match(FeatParser::VMTX);
    setState(935);
    match(FeatParser::LCBRACE);
    setState(937); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(936);
      vmtxStatement();
      setState(939); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::INCLUDE || _la == FeatParser::VERT_ORIGIN_Y

    || _la == FeatParser::VERT_ADVANCE_Y);
    setState(941);
    match(FeatParser::RCBRACE);
    setState(942);
    match(FeatParser::VMTX);
    setState(943);
    match(FeatParser::SEMI);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VmtxStatementContext ------------------------------------------------------------------

FeatParser::VmtxStatementContext::VmtxStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::VmtxStatementContext::SEMI() {
  return getToken(FeatParser::SEMI, 0);
}

FeatParser::VmtxContext* FeatParser::VmtxStatementContext::vmtx() {
  return getRuleContext<FeatParser::VmtxContext>(0);
}

FeatParser::IncludeContext* FeatParser::VmtxStatementContext::include() {
  return getRuleContext<FeatParser::IncludeContext>(0);
}


size_t FeatParser::VmtxStatementContext::getRuleIndex() const {
  return FeatParser::RuleVmtxStatement;
}


std::any FeatParser::VmtxStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitVmtxStatement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::VmtxStatementContext* FeatParser::vmtxStatement() {
  VmtxStatementContext *_localctx = _tracker.createInstance<VmtxStatementContext>(_ctx, getState());
  enterRule(_localctx, 148, FeatParser::RuleVmtxStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(947);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::VERT_ORIGIN_Y:
      case FeatParser::VERT_ADVANCE_Y: {
        setState(945);
        vmtx();
        break;
      }

      case FeatParser::INCLUDE: {
        setState(946);
        include();
        break;
      }

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

  return _localctx;
}

//----------------- VmtxContext ------------------------------------------------------------------

FeatParser::VmtxContext::VmtxContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::GlyphContext* FeatParser::VmtxContext::glyph() {
  return getRuleContext<FeatParser::GlyphContext>(0);
}

tree::TerminalNode* FeatParser::VmtxContext::NUM() {
  return getToken(FeatParser::NUM, 0);
}

tree::TerminalNode* FeatParser::VmtxContext::VERT_ORIGIN_Y() {
  return getToken(FeatParser::VERT_ORIGIN_Y, 0);
}

tree::TerminalNode* FeatParser::VmtxContext::VERT_ADVANCE_Y() {
  return getToken(FeatParser::VERT_ADVANCE_Y, 0);
}


size_t FeatParser::VmtxContext::getRuleIndex() const {
  return FeatParser::RuleVmtx;
}


std::any FeatParser::VmtxContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitVmtx(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::VmtxContext* FeatParser::vmtx() {
  VmtxContext *_localctx = _tracker.createInstance<VmtxContext>(_ctx, getState());
  enterRule(_localctx, 150, FeatParser::RuleVmtx);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(951);
    _la = _input->LA(1);
    if (!(_la == FeatParser::VERT_ORIGIN_Y

    || _la == FeatParser::VERT_ADVANCE_Y)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(952);
    glyph();
    setState(953);
    match(FeatParser::NUM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AnchorContext ------------------------------------------------------------------

FeatParser::AnchorContext::AnchorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AnchorContext::BEGINVALUE() {
  return getToken(FeatParser::BEGINVALUE, 0);
}

tree::TerminalNode* FeatParser::AnchorContext::ANCHOR() {
  return getToken(FeatParser::ANCHOR, 0);
}

tree::TerminalNode* FeatParser::AnchorContext::ENDVALUE() {
  return getToken(FeatParser::ENDVALUE, 0);
}

tree::TerminalNode* FeatParser::AnchorContext::KNULL() {
  return getToken(FeatParser::KNULL, 0);
}

FeatParser::LabelContext* FeatParser::AnchorContext::label() {
  return getRuleContext<FeatParser::LabelContext>(0);
}

std::vector<tree::TerminalNode *> FeatParser::AnchorContext::NUM() {
  return getTokens(FeatParser::NUM);
}

tree::TerminalNode* FeatParser::AnchorContext::NUM(size_t i) {
  return getToken(FeatParser::NUM, i);
}

tree::TerminalNode* FeatParser::AnchorContext::CONTOURPOINT() {
  return getToken(FeatParser::CONTOURPOINT, 0);
}


size_t FeatParser::AnchorContext::getRuleIndex() const {
  return FeatParser::RuleAnchor;
}


std::any FeatParser::AnchorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAnchor(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AnchorContext* FeatParser::anchor() {
  AnchorContext *_localctx = _tracker.createInstance<AnchorContext>(_ctx, getState());
  enterRule(_localctx, 152, FeatParser::RuleAnchor);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(955);
    match(FeatParser::BEGINVALUE);
    setState(956);
    match(FeatParser::ANCHOR);
    setState(965);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NUM: {
        setState(957);
        antlrcpp::downCast<AnchorContext *>(_localctx)->xval = match(FeatParser::NUM);
        setState(958);
        antlrcpp::downCast<AnchorContext *>(_localctx)->yval = match(FeatParser::NUM);
        setState(961);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::CONTOURPOINT) {
          setState(959);
          match(FeatParser::CONTOURPOINT);
          setState(960);
          antlrcpp::downCast<AnchorContext *>(_localctx)->cp = match(FeatParser::NUM);
        }
        break;
      }

      case FeatParser::KNULL: {
        setState(963);
        match(FeatParser::KNULL);
        break;
      }

      case FeatParser::MARK:
      case FeatParser::NAMELABEL: {
        setState(964);
        antlrcpp::downCast<AnchorContext *>(_localctx)->name = label();
        break;
      }

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

  return _localctx;
}

//----------------- LookupPatternContext ------------------------------------------------------------------

FeatParser::LookupPatternContext::LookupPatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FeatParser::LookupPatternElementContext *> FeatParser::LookupPatternContext::lookupPatternElement() {
  return getRuleContexts<FeatParser::LookupPatternElementContext>();
}

FeatParser::LookupPatternElementContext* FeatParser::LookupPatternContext::lookupPatternElement(size_t i) {
  return getRuleContext<FeatParser::LookupPatternElementContext>(i);
}


size_t FeatParser::LookupPatternContext::getRuleIndex() const {
  return FeatParser::RuleLookupPattern;
}


std::any FeatParser::LookupPatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLookupPattern(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LookupPatternContext* FeatParser::lookupPattern() {
  LookupPatternContext *_localctx = _tracker.createInstance<LookupPatternContext>(_ctx, getState());
  enterRule(_localctx, 154, FeatParser::RuleLookupPattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(970); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(969);
      lookupPatternElement();
      setState(972); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 117)) & 7937) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LookupPatternElementContext ------------------------------------------------------------------

FeatParser::LookupPatternElementContext::LookupPatternElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::PatternElementContext* FeatParser::LookupPatternElementContext::patternElement() {
  return getRuleContext<FeatParser::PatternElementContext>(0);
}

std::vector<tree::TerminalNode *> FeatParser::LookupPatternElementContext::LOOKUP() {
  return getTokens(FeatParser::LOOKUP);
}

tree::TerminalNode* FeatParser::LookupPatternElementContext::LOOKUP(size_t i) {
  return getToken(FeatParser::LOOKUP, i);
}

std::vector<FeatParser::LabelContext *> FeatParser::LookupPatternElementContext::label() {
  return getRuleContexts<FeatParser::LabelContext>();
}

FeatParser::LabelContext* FeatParser::LookupPatternElementContext::label(size_t i) {
  return getRuleContext<FeatParser::LabelContext>(i);
}


size_t FeatParser::LookupPatternElementContext::getRuleIndex() const {
  return FeatParser::RuleLookupPatternElement;
}


std::any FeatParser::LookupPatternElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLookupPatternElement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LookupPatternElementContext* FeatParser::lookupPatternElement() {
  LookupPatternElementContext *_localctx = _tracker.createInstance<LookupPatternElementContext>(_ctx, getState());
  enterRule(_localctx, 156, FeatParser::RuleLookupPatternElement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(974);
    patternElement();
    setState(979);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::LOOKUP) {
      setState(975);
      match(FeatParser::LOOKUP);
      setState(976);
      label();
      setState(981);
      _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;
}

//----------------- PatternContext ------------------------------------------------------------------

FeatParser::PatternContext::PatternContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FeatParser::PatternElementContext *> FeatParser::PatternContext::patternElement() {
  return getRuleContexts<FeatParser::PatternElementContext>();
}

FeatParser::PatternElementContext* FeatParser::PatternContext::patternElement(size_t i) {
  return getRuleContext<FeatParser::PatternElementContext>(i);
}


size_t FeatParser::PatternContext::getRuleIndex() const {
  return FeatParser::RulePattern;
}


std::any FeatParser::PatternContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitPattern(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::PatternContext* FeatParser::pattern() {
  PatternContext *_localctx = _tracker.createInstance<PatternContext>(_ctx, getState());
  enterRule(_localctx, 158, FeatParser::RulePattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(983); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(982);
      patternElement();
      setState(985); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::NOTDEF || ((((_la - 117) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 117)) & 7937) != 0));
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PatternElementContext ------------------------------------------------------------------

FeatParser::PatternElementContext::PatternElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::GlyphClassContext* FeatParser::PatternElementContext::glyphClass() {
  return getRuleContext<FeatParser::GlyphClassContext>(0);
}

FeatParser::GlyphContext* FeatParser::PatternElementContext::glyph() {
  return getRuleContext<FeatParser::GlyphContext>(0);
}

tree::TerminalNode* FeatParser::PatternElementContext::MARKER() {
  return getToken(FeatParser::MARKER, 0);
}


size_t FeatParser::PatternElementContext::getRuleIndex() const {
  return FeatParser::RulePatternElement;
}


std::any FeatParser::PatternElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitPatternElement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::PatternElementContext* FeatParser::patternElement() {
  PatternElementContext *_localctx = _tracker.createInstance<PatternElementContext>(_ctx, getState());
  enterRule(_localctx, 160, FeatParser::RulePatternElement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(989);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::LBRACKET:
      case FeatParser::GCLASS: {
        setState(987);
        glyphClass();
        break;
      }

      case FeatParser::NOTDEF:
      case FeatParser::CID:
      case FeatParser::ESCGNAME:
      case FeatParser::NAMELABEL:
      case FeatParser::EXTNAME: {
        setState(988);
        glyph();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(992);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- GlyphClassOptionalContext ------------------------------------------------------------------

FeatParser::GlyphClassOptionalContext::GlyphClassOptionalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::GlyphClassContext* FeatParser::GlyphClassOptionalContext::glyphClass() {
  return getRuleContext<FeatParser::GlyphClassContext>(0);
}


size_t FeatParser::GlyphClassOptionalContext::getRuleIndex() const {
  return FeatParser::RuleGlyphClassOptional;
}


std::any FeatParser::GlyphClassOptionalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGlyphClassOptional(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GlyphClassOptionalContext* FeatParser::glyphClassOptional() {
  GlyphClassOptionalContext *_localctx = _tracker.createInstance<GlyphClassOptionalContext>(_ctx, getState());
  enterRule(_localctx, 162, FeatParser::RuleGlyphClassOptional);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == FeatParser::LBRACKET

    || _la == FeatParser::GCLASS) {
      setState(994);
      glyphClass();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GlyphClassContext ------------------------------------------------------------------

FeatParser::GlyphClassContext::GlyphClassContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GlyphClassContext::GCLASS() {
  return getToken(FeatParser::GCLASS, 0);
}

FeatParser::GcLiteralContext* FeatParser::GlyphClassContext::gcLiteral() {
  return getRuleContext<FeatParser::GcLiteralContext>(0);
}


size_t FeatParser::GlyphClassContext::getRuleIndex() const {
  return FeatParser::RuleGlyphClass;
}


std::any FeatParser::GlyphClassContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGlyphClass(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GlyphClassContext* FeatParser::glyphClass() {
  GlyphClassContext *_localctx = _tracker.createInstance<GlyphClassContext>(_ctx, getState());
  enterRule(_localctx, 164, FeatParser::RuleGlyphClass);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(999);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::GCLASS: {
        enterOuterAlt(_localctx, 1);
        setState(997);
        match(FeatParser::GCLASS);
        break;
      }

      case FeatParser::LBRACKET: {
        enterOuterAlt(_localctx, 2);
        setState(998);
        gcLiteral();
        break;
      }

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

  return _localctx;
}

//----------------- GcLiteralContext ------------------------------------------------------------------

FeatParser::GcLiteralContext::GcLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GcLiteralContext::LBRACKET() {
  return getToken(FeatParser::LBRACKET, 0);
}

tree::TerminalNode* FeatParser::GcLiteralContext::RBRACKET() {
  return getToken(FeatParser::RBRACKET, 0);
}

std::vector<FeatParser::GcLiteralElementContext *> FeatParser::GcLiteralContext::gcLiteralElement() {
  return getRuleContexts<FeatParser::GcLiteralElementContext>();
}

FeatParser::GcLiteralElementContext* FeatParser::GcLiteralContext::gcLiteralElement(size_t i) {
  return getRuleContext<FeatParser::GcLiteralElementContext>(i);
}


size_t FeatParser::GcLiteralContext::getRuleIndex() const {
  return FeatParser::RuleGcLiteral;
}


std::any FeatParser::GcLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGcLiteral(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GcLiteralContext* FeatParser::gcLiteral() {
  GcLiteralContext *_localctx = _tracker.createInstance<GcLiteralContext>(_ctx, getState());
  enterRule(_localctx, 166, FeatParser::RuleGcLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1001);
    match(FeatParser::LBRACKET);
    setState(1003); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1002);
      gcLiteralElement();
      setState(1005); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == FeatParser::NOTDEF || ((((_la - 125) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 125)) & 31) != 0));
    setState(1007);
    match(FeatParser::RBRACKET);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GcLiteralElementContext ------------------------------------------------------------------

FeatParser::GcLiteralElementContext::GcLiteralElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<FeatParser::GlyphContext *> FeatParser::GcLiteralElementContext::glyph() {
  return getRuleContexts<FeatParser::GlyphContext>();
}

FeatParser::GlyphContext* FeatParser::GcLiteralElementContext::glyph(size_t i) {
  return getRuleContext<FeatParser::GlyphContext>(i);
}

tree::TerminalNode* FeatParser::GcLiteralElementContext::HYPHEN() {
  return getToken(FeatParser::HYPHEN, 0);
}

tree::TerminalNode* FeatParser::GcLiteralElementContext::GCLASS() {
  return getToken(FeatParser::GCLASS, 0);
}


size_t FeatParser::GcLiteralElementContext::getRuleIndex() const {
  return FeatParser::RuleGcLiteralElement;
}


std::any FeatParser::GcLiteralElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGcLiteralElement(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GcLiteralElementContext* FeatParser::gcLiteralElement() {
  GcLiteralElementContext *_localctx = _tracker.createInstance<GcLiteralElementContext>(_ctx, getState());
  enterRule(_localctx, 168, FeatParser::RuleGcLiteralElement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1015);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NOTDEF:
      case FeatParser::CID:
      case FeatParser::ESCGNAME:
      case FeatParser::NAMELABEL:
      case FeatParser::EXTNAME: {
        enterOuterAlt(_localctx, 1);
        setState(1009);
        antlrcpp::downCast<GcLiteralElementContext *>(_localctx)->startg = glyph();
        setState(1012);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == FeatParser::HYPHEN) {
          setState(1010);
          match(FeatParser::HYPHEN);
          setState(1011);
          antlrcpp::downCast<GcLiteralElementContext *>(_localctx)->endg = glyph();
        }
        break;
      }

      case FeatParser::GCLASS: {
        enterOuterAlt(_localctx, 2);
        setState(1014);
        match(FeatParser::GCLASS);
        break;
      }

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

  return _localctx;
}

//----------------- GlyphContext ------------------------------------------------------------------

FeatParser::GlyphContext::GlyphContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

FeatParser::GlyphNameContext* FeatParser::GlyphContext::glyphName() {
  return getRuleContext<FeatParser::GlyphNameContext>(0);
}

tree::TerminalNode* FeatParser::GlyphContext::CID() {
  return getToken(FeatParser::CID, 0);
}


size_t FeatParser::GlyphContext::getRuleIndex() const {
  return FeatParser::RuleGlyph;
}


std::any FeatParser::GlyphContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGlyph(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GlyphContext* FeatParser::glyph() {
  GlyphContext *_localctx = _tracker.createInstance<GlyphContext>(_ctx, getState());
  enterRule(_localctx, 170, FeatParser::RuleGlyph);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1019);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case FeatParser::NOTDEF:
      case FeatParser::ESCGNAME:
      case FeatParser::NAMELABEL:
      case FeatParser::EXTNAME: {
        enterOuterAlt(_localctx, 1);
        setState(1017);
        glyphName();
        break;
      }

      case FeatParser::CID: {
        enterOuterAlt(_localctx, 2);
        setState(1018);
        match(FeatParser::CID);
        break;
      }

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

  return _localctx;
}

//----------------- GlyphNameContext ------------------------------------------------------------------

FeatParser::GlyphNameContext::GlyphNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GlyphNameContext::ESCGNAME() {
  return getToken(FeatParser::ESCGNAME, 0);
}

tree::TerminalNode* FeatParser::GlyphNameContext::NAMELABEL() {
  return getToken(FeatParser::NAMELABEL, 0);
}

tree::TerminalNode* FeatParser::GlyphNameContext::EXTNAME() {
  return getToken(FeatParser::EXTNAME, 0);
}

tree::TerminalNode* FeatParser::GlyphNameContext::NOTDEF() {
  return getToken(FeatParser::NOTDEF, 0);
}


size_t FeatParser::GlyphNameContext::getRuleIndex() const {
  return FeatParser::RuleGlyphName;
}


std::any FeatParser::GlyphNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGlyphName(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GlyphNameContext* FeatParser::glyphName() {
  GlyphNameContext *_localctx = _tracker.createInstance<GlyphNameContext>(_ctx, getState());
  enterRule(_localctx, 172, FeatParser::RuleGlyphName);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1021);
    _la = _input->LA(1);
    if (!(_la == FeatParser::NOTDEF || ((((_la - 127) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 127)) & 7) != 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;
}

//----------------- LabelContext ------------------------------------------------------------------

FeatParser::LabelContext::LabelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::LabelContext::NAMELABEL() {
  return getToken(FeatParser::NAMELABEL, 0);
}

tree::TerminalNode* FeatParser::LabelContext::MARK() {
  return getToken(FeatParser::MARK, 0);
}


size_t FeatParser::LabelContext::getRuleIndex() const {
  return FeatParser::RuleLabel;
}


std::any FeatParser::LabelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitLabel(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::LabelContext* FeatParser::label() {
  LabelContext *_localctx = _tracker.createInstance<LabelContext>(_ctx, getState());
  enterRule(_localctx, 174, FeatParser::RuleLabel);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1023);
    _la = _input->LA(1);
    if (!(_la == FeatParser::MARK || _la == FeatParser::NAMELABEL)) {
    _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;
}

//----------------- TagContext ------------------------------------------------------------------

FeatParser::TagContext::TagContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::TagContext::NAMELABEL() {
  return getToken(FeatParser::NAMELABEL, 0);
}

tree::TerminalNode* FeatParser::TagContext::EXTNAME() {
  return getToken(FeatParser::EXTNAME, 0);
}

tree::TerminalNode* FeatParser::TagContext::CATCHTAG() {
  return getToken(FeatParser::CATCHTAG, 0);
}

tree::TerminalNode* FeatParser::TagContext::MARK() {
  return getToken(FeatParser::MARK, 0);
}


size_t FeatParser::TagContext::getRuleIndex() const {
  return FeatParser::RuleTag;
}


std::any FeatParser::TagContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitTag(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::TagContext* FeatParser::tag() {
  TagContext *_localctx = _tracker.createInstance<TagContext>(_ctx, getState());
  enterRule(_localctx, 176, FeatParser::RuleTag);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1025);
    _la = _input->LA(1);
    if (!(_la == FeatParser::MARK || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 67) != 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;
}

//----------------- FixedNumContext ------------------------------------------------------------------

FeatParser::FixedNumContext::FixedNumContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::FixedNumContext::POINTNUM() {
  return getToken(FeatParser::POINTNUM, 0);
}

tree::TerminalNode* FeatParser::FixedNumContext::NUM() {
  return getToken(FeatParser::NUM, 0);
}


size_t FeatParser::FixedNumContext::getRuleIndex() const {
  return FeatParser::RuleFixedNum;
}


std::any FeatParser::FixedNumContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitFixedNum(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::FixedNumContext* FeatParser::fixedNum() {
  FixedNumContext *_localctx = _tracker.createInstance<FixedNumContext>(_ctx, getState());
  enterRule(_localctx, 178, FeatParser::RuleFixedNum);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1027);
    _la = _input->LA(1);
    if (!(_la == FeatParser::POINTNUM

    || _la == FeatParser::NUM)) {
    _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;
}

//----------------- GenNumContext ------------------------------------------------------------------

FeatParser::GenNumContext::GenNumContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GenNumContext::NUM() {
  return getToken(FeatParser::NUM, 0);
}

tree::TerminalNode* FeatParser::GenNumContext::NUMOCT() {
  return getToken(FeatParser::NUMOCT, 0);
}

tree::TerminalNode* FeatParser::GenNumContext::NUMEXT() {
  return getToken(FeatParser::NUMEXT, 0);
}


size_t FeatParser::GenNumContext::getRuleIndex() const {
  return FeatParser::RuleGenNum;
}


std::any FeatParser::GenNumContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGenNum(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GenNumContext* FeatParser::genNum() {
  GenNumContext *_localctx = _tracker.createInstance<GenNumContext>(_ctx, getState());
  enterRule(_localctx, 180, FeatParser::RuleGenNum);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1029);
    _la = _input->LA(1);
    if (!(((((_la - 131) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 131)) & 7) != 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;
}

//----------------- FeatureFileContext ------------------------------------------------------------------

FeatParser::FeatureFileContext::FeatureFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::FeatureFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::FeatureStatementContext *> FeatParser::FeatureFileContext::featureStatement() {
  return getRuleContexts<FeatParser::FeatureStatementContext>();
}

FeatParser::FeatureStatementContext* FeatParser::FeatureFileContext::featureStatement(size_t i) {
  return getRuleContext<FeatParser::FeatureStatementContext>(i);
}


size_t FeatParser::FeatureFileContext::getRuleIndex() const {
  return FeatParser::RuleFeatureFile;
}


std::any FeatParser::FeatureFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitFeatureFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::FeatureFileContext* FeatParser::featureFile() {
  FeatureFileContext *_localctx = _tracker.createInstance<FeatureFileContext>(_ctx, getState());
  enterRule(_localctx, 182, FeatParser::RuleFeatureFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1034);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 18304463152364384) != 0) || _la == FeatParser::GCLASS) {
      setState(1031);
      featureStatement();
      setState(1036);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1037);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementFileContext ------------------------------------------------------------------

FeatParser::StatementFileContext::StatementFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::StatementFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::StatementContext *> FeatParser::StatementFileContext::statement() {
  return getRuleContexts<FeatParser::StatementContext>();
}

FeatParser::StatementContext* FeatParser::StatementFileContext::statement(size_t i) {
  return getRuleContext<FeatParser::StatementContext>(i);
}


size_t FeatParser::StatementFileContext::getRuleIndex() const {
  return FeatParser::RuleStatementFile;
}


std::any FeatParser::StatementFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitStatementFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::StatementFileContext* FeatParser::statementFile() {
  StatementFileContext *_localctx = _tracker.createInstance<StatementFileContext>(_ctx, getState());
  enterRule(_localctx, 184, FeatParser::RuleStatementFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1042);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 18300065105849184) != 0) || _la == FeatParser::GCLASS) {
      setState(1039);
      statement();
      setState(1044);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1045);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CvStatementFileContext ------------------------------------------------------------------

FeatParser::CvStatementFileContext::CvStatementFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::CvStatementFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::CvParameterStatementContext *> FeatParser::CvStatementFileContext::cvParameterStatement() {
  return getRuleContexts<FeatParser::CvParameterStatementContext>();
}

FeatParser::CvParameterStatementContext* FeatParser::CvStatementFileContext::cvParameterStatement(size_t i) {
  return getRuleContext<FeatParser::CvParameterStatementContext>(i);
}


size_t FeatParser::CvStatementFileContext::getRuleIndex() const {
  return FeatParser::RuleCvStatementFile;
}


std::any FeatParser::CvStatementFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitCvStatementFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::CvStatementFileContext* FeatParser::cvStatementFile() {
  CvStatementFileContext *_localctx = _tracker.createInstance<CvStatementFileContext>(_ctx, getState());
  enterRule(_localctx, 186, FeatParser::RuleCvStatementFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1050);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 272678883688480) != 0)) {
      setState(1047);
      cvParameterStatement();
      setState(1052);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1053);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseFileContext ------------------------------------------------------------------

FeatParser::BaseFileContext::BaseFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::BaseFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::BaseStatementContext *> FeatParser::BaseFileContext::baseStatement() {
  return getRuleContexts<FeatParser::BaseStatementContext>();
}

FeatParser::BaseStatementContext* FeatParser::BaseFileContext::baseStatement(size_t i) {
  return getRuleContext<FeatParser::BaseStatementContext>(i);
}


size_t FeatParser::BaseFileContext::getRuleIndex() const {
  return FeatParser::RuleBaseFile;
}


std::any FeatParser::BaseFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitBaseFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::BaseFileContext* FeatParser::baseFile() {
  BaseFileContext *_localctx = _tracker.createInstance<BaseFileContext>(_ctx, getState());
  enterRule(_localctx, 188, FeatParser::RuleBaseFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1058);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 5) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 5)) & 2161727821137838081) != 0)) {
      setState(1055);
      baseStatement();
      setState(1060);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1061);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HeadFileContext ------------------------------------------------------------------

FeatParser::HeadFileContext::HeadFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::HeadFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::HeadStatementContext *> FeatParser::HeadFileContext::headStatement() {
  return getRuleContexts<FeatParser::HeadStatementContext>();
}

FeatParser::HeadStatementContext* FeatParser::HeadFileContext::headStatement(size_t i) {
  return getRuleContext<FeatParser::HeadStatementContext>(i);
}


size_t FeatParser::HeadFileContext::getRuleIndex() const {
  return FeatParser::RuleHeadFile;
}


std::any FeatParser::HeadFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitHeadFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::HeadFileContext* FeatParser::headFile() {
  HeadFileContext *_localctx = _tracker.createInstance<HeadFileContext>(_ctx, getState());
  enterRule(_localctx, 190, FeatParser::RuleHeadFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1066);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || _la == FeatParser::FONT_REVISION) {
      setState(1063);
      headStatement();
      setState(1068);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1069);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HheaFileContext ------------------------------------------------------------------

FeatParser::HheaFileContext::HheaFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::HheaFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::HheaStatementContext *> FeatParser::HheaFileContext::hheaStatement() {
  return getRuleContexts<FeatParser::HheaStatementContext>();
}

FeatParser::HheaStatementContext* FeatParser::HheaFileContext::hheaStatement(size_t i) {
  return getRuleContext<FeatParser::HheaStatementContext>(i);
}


size_t FeatParser::HheaFileContext::getRuleIndex() const {
  return FeatParser::RuleHheaFile;
}


std::any FeatParser::HheaFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitHheaFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::HheaFileContext* FeatParser::hheaFile() {
  HheaFileContext *_localctx = _tracker.createInstance<HheaFileContext>(_ctx, getState());
  enterRule(_localctx, 192, FeatParser::RuleHheaFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1074);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 15) != 0)) {
      setState(1071);
      hheaStatement();
      setState(1076);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1077);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VheaFileContext ------------------------------------------------------------------

FeatParser::VheaFileContext::VheaFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::VheaFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::VheaStatementContext *> FeatParser::VheaFileContext::vheaStatement() {
  return getRuleContexts<FeatParser::VheaStatementContext>();
}

FeatParser::VheaStatementContext* FeatParser::VheaFileContext::vheaStatement(size_t i) {
  return getRuleContext<FeatParser::VheaStatementContext>(i);
}


size_t FeatParser::VheaFileContext::getRuleIndex() const {
  return FeatParser::RuleVheaFile;
}


std::any FeatParser::VheaFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitVheaFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::VheaFileContext* FeatParser::vheaFile() {
  VheaFileContext *_localctx = _tracker.createInstance<VheaFileContext>(_ctx, getState());
  enterRule(_localctx, 194, FeatParser::RuleVheaFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1082);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 109) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 109)) & 7) != 0)) {
      setState(1079);
      vheaStatement();
      setState(1084);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1085);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GdefFileContext ------------------------------------------------------------------

FeatParser::GdefFileContext::GdefFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::GdefFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::GdefStatementContext *> FeatParser::GdefFileContext::gdefStatement() {
  return getRuleContexts<FeatParser::GdefStatementContext>();
}

FeatParser::GdefStatementContext* FeatParser::GdefFileContext::gdefStatement(size_t i) {
  return getRuleContext<FeatParser::GdefStatementContext>(i);
}


size_t FeatParser::GdefFileContext::getRuleIndex() const {
  return FeatParser::RuleGdefFile;
}


std::any FeatParser::GdefFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitGdefFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::GdefFileContext* FeatParser::gdefFile() {
  GdefFileContext *_localctx = _tracker.createInstance<GdefFileContext>(_ctx, getState());
  enterRule(_localctx, 196, FeatParser::RuleGdefFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1090);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 67) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 67)) & 15) != 0)) {
      setState(1087);
      gdefStatement();
      setState(1092);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1093);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NameFileContext ------------------------------------------------------------------

FeatParser::NameFileContext::NameFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::NameFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::NameStatementContext *> FeatParser::NameFileContext::nameStatement() {
  return getRuleContexts<FeatParser::NameStatementContext>();
}

FeatParser::NameStatementContext* FeatParser::NameFileContext::nameStatement(size_t i) {
  return getRuleContext<FeatParser::NameStatementContext>(i);
}


size_t FeatParser::NameFileContext::getRuleIndex() const {
  return FeatParser::RuleNameFile;
}


std::any FeatParser::NameFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitNameFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::NameFileContext* FeatParser::nameFile() {
  NameFileContext *_localctx = _tracker.createInstance<NameFileContext>(_ctx, getState());
  enterRule(_localctx, 198, FeatParser::RuleNameFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1098);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || _la == FeatParser::NAMEID) {
      setState(1095);
      nameStatement();
      setState(1100);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1101);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VmtxFileContext ------------------------------------------------------------------

FeatParser::VmtxFileContext::VmtxFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::VmtxFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::VmtxStatementContext *> FeatParser::VmtxFileContext::vmtxStatement() {
  return getRuleContexts<FeatParser::VmtxStatementContext>();
}

FeatParser::VmtxStatementContext* FeatParser::VmtxFileContext::vmtxStatement(size_t i) {
  return getRuleContext<FeatParser::VmtxStatementContext>(i);
}


size_t FeatParser::VmtxFileContext::getRuleIndex() const {
  return FeatParser::RuleVmtxFile;
}


std::any FeatParser::VmtxFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitVmtxFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::VmtxFileContext* FeatParser::vmtxFile() {
  VmtxFileContext *_localctx = _tracker.createInstance<VmtxFileContext>(_ctx, getState());
  enterRule(_localctx, 200, FeatParser::RuleVmtxFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1106);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || _la == FeatParser::VERT_ORIGIN_Y

    || _la == FeatParser::VERT_ADVANCE_Y) {
      setState(1103);
      vmtxStatement();
      setState(1108);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1109);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Os_2FileContext ------------------------------------------------------------------

FeatParser::Os_2FileContext::Os_2FileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::Os_2FileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::Os_2StatementContext *> FeatParser::Os_2FileContext::os_2Statement() {
  return getRuleContexts<FeatParser::Os_2StatementContext>();
}

FeatParser::Os_2StatementContext* FeatParser::Os_2FileContext::os_2Statement(size_t i) {
  return getRuleContext<FeatParser::Os_2StatementContext>(i);
}


size_t FeatParser::Os_2FileContext::getRuleIndex() const {
  return FeatParser::RuleOs_2File;
}


std::any FeatParser::Os_2FileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitOs_2File(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::Os_2FileContext* FeatParser::os_2File() {
  Os_2FileContext *_localctx = _tracker.createInstance<Os_2FileContext>(_ctx, getState());
  enterRule(_localctx, 202, FeatParser::RuleOs_2File);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1114);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 81) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 81)) & 262143) != 0)) {
      setState(1111);
      os_2Statement();
      setState(1116);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1117);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatFileContext ------------------------------------------------------------------

FeatParser::StatFileContext::StatFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::StatFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::StatStatementContext *> FeatParser::StatFileContext::statStatement() {
  return getRuleContexts<FeatParser::StatStatementContext>();
}

FeatParser::StatStatementContext* FeatParser::StatFileContext::statStatement(size_t i) {
  return getRuleContext<FeatParser::StatStatementContext>(i);
}


size_t FeatParser::StatFileContext::getRuleIndex() const {
  return FeatParser::RuleStatFile;
}


std::any FeatParser::StatFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitStatFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::StatFileContext* FeatParser::statFile() {
  StatFileContext *_localctx = _tracker.createInstance<StatFileContext>(_ctx, getState());
  enterRule(_localctx, 204, FeatParser::RuleStatFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1122);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 100) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 100)) & 15) != 0)) {
      setState(1119);
      statStatement();
      setState(1124);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1125);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AxisValueFileContext ------------------------------------------------------------------

FeatParser::AxisValueFileContext::AxisValueFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AxisValueFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::AxisValueStatementContext *> FeatParser::AxisValueFileContext::axisValueStatement() {
  return getRuleContexts<FeatParser::AxisValueStatementContext>();
}

FeatParser::AxisValueStatementContext* FeatParser::AxisValueFileContext::axisValueStatement(size_t i) {
  return getRuleContext<FeatParser::AxisValueStatementContext>(i);
}


size_t FeatParser::AxisValueFileContext::getRuleIndex() const {
  return FeatParser::RuleAxisValueFile;
}


std::any FeatParser::AxisValueFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAxisValueFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AxisValueFileContext* FeatParser::axisValueFile() {
  AxisValueFileContext *_localctx = _tracker.createInstance<AxisValueFileContext>(_ctx, getState());
  enterRule(_localctx, 206, FeatParser::RuleAxisValueFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1130);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || ((((_la - 78) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 78)) & 201326593) != 0)) {
      setState(1127);
      axisValueStatement();
      setState(1132);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1133);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NameEntryFileContext ------------------------------------------------------------------

FeatParser::NameEntryFileContext::NameEntryFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::NameEntryFileContext::EOF() {
  return getToken(FeatParser::EOF, 0);
}

std::vector<FeatParser::NameEntryStatementContext *> FeatParser::NameEntryFileContext::nameEntryStatement() {
  return getRuleContexts<FeatParser::NameEntryStatementContext>();
}

FeatParser::NameEntryStatementContext* FeatParser::NameEntryFileContext::nameEntryStatement(size_t i) {
  return getRuleContext<FeatParser::NameEntryStatementContext>(i);
}


size_t FeatParser::NameEntryFileContext::getRuleIndex() const {
  return FeatParser::RuleNameEntryFile;
}


std::any FeatParser::NameEntryFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitNameEntryFile(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::NameEntryFileContext* FeatParser::nameEntryFile() {
  NameEntryFileContext *_localctx = _tracker.createInstance<NameEntryFileContext>(_ctx, getState());
  enterRule(_localctx, 208, FeatParser::RuleNameEntryFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1138);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == FeatParser::INCLUDE || _la == FeatParser::NAME) {
      setState(1135);
      nameEntryStatement();
      setState(1140);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1141);
    match(FeatParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SubtokContext ------------------------------------------------------------------

FeatParser::SubtokContext::SubtokContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::SubtokContext::SUBSTITUTE() {
  return getToken(FeatParser::SUBSTITUTE, 0);
}

tree::TerminalNode* FeatParser::SubtokContext::SUBSTITUTE_v() {
  return getToken(FeatParser::SUBSTITUTE_v, 0);
}


size_t FeatParser::SubtokContext::getRuleIndex() const {
  return FeatParser::RuleSubtok;
}


std::any FeatParser::SubtokContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitSubtok(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::SubtokContext* FeatParser::subtok() {
  SubtokContext *_localctx = _tracker.createInstance<SubtokContext>(_ctx, getState());
  enterRule(_localctx, 210, FeatParser::RuleSubtok);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1143);
    _la = _input->LA(1);
    if (!(_la == FeatParser::SUBSTITUTE

    || _la == FeatParser::SUBSTITUTE_v)) {
    _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;
}

//----------------- RevtokContext ------------------------------------------------------------------

FeatParser::RevtokContext::RevtokContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::RevtokContext::REVERSE() {
  return getToken(FeatParser::REVERSE, 0);
}

tree::TerminalNode* FeatParser::RevtokContext::REVERSE_v() {
  return getToken(FeatParser::REVERSE_v, 0);
}


size_t FeatParser::RevtokContext::getRuleIndex() const {
  return FeatParser::RuleRevtok;
}


std::any FeatParser::RevtokContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitRevtok(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::RevtokContext* FeatParser::revtok() {
  RevtokContext *_localctx = _tracker.createInstance<RevtokContext>(_ctx, getState());
  enterRule(_localctx, 212, FeatParser::RuleRevtok);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1145);
    _la = _input->LA(1);
    if (!(_la == FeatParser::REVERSE

    || _la == FeatParser::REVERSE_v)) {
    _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;
}

//----------------- AnontokContext ------------------------------------------------------------------

FeatParser::AnontokContext::AnontokContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::AnontokContext::ANON() {
  return getToken(FeatParser::ANON, 0);
}

tree::TerminalNode* FeatParser::AnontokContext::ANON_v() {
  return getToken(FeatParser::ANON_v, 0);
}


size_t FeatParser::AnontokContext::getRuleIndex() const {
  return FeatParser::RuleAnontok;
}


std::any FeatParser::AnontokContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitAnontok(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::AnontokContext* FeatParser::anontok() {
  AnontokContext *_localctx = _tracker.createInstance<AnontokContext>(_ctx, getState());
  enterRule(_localctx, 214, FeatParser::RuleAnontok);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1147);
    _la = _input->LA(1);
    if (!(_la == FeatParser::ANON

    || _la == FeatParser::ANON_v)) {
    _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;
}

//----------------- EnumtokContext ------------------------------------------------------------------

FeatParser::EnumtokContext::EnumtokContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::EnumtokContext::ENUMERATE() {
  return getToken(FeatParser::ENUMERATE, 0);
}

tree::TerminalNode* FeatParser::EnumtokContext::ENUMERATE_v() {
  return getToken(FeatParser::ENUMERATE_v, 0);
}


size_t FeatParser::EnumtokContext::getRuleIndex() const {
  return FeatParser::RuleEnumtok;
}


std::any FeatParser::EnumtokContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitEnumtok(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::EnumtokContext* FeatParser::enumtok() {
  EnumtokContext *_localctx = _tracker.createInstance<EnumtokContext>(_ctx, getState());
  enterRule(_localctx, 216, FeatParser::RuleEnumtok);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1149);
    _la = _input->LA(1);
    if (!(_la == FeatParser::ENUMERATE

    || _la == FeatParser::ENUMERATE_v)) {
    _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;
}

//----------------- PostokContext ------------------------------------------------------------------

FeatParser::PostokContext::PostokContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::PostokContext::POSITION() {
  return getToken(FeatParser::POSITION, 0);
}

tree::TerminalNode* FeatParser::PostokContext::POSITION_v() {
  return getToken(FeatParser::POSITION_v, 0);
}


size_t FeatParser::PostokContext::getRuleIndex() const {
  return FeatParser::RulePostok;
}


std::any FeatParser::PostokContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitPostok(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::PostokContext* FeatParser::postok() {
  PostokContext *_localctx = _tracker.createInstance<PostokContext>(_ctx, getState());
  enterRule(_localctx, 218, FeatParser::RulePostok);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1151);
    _la = _input->LA(1);
    if (!(_la == FeatParser::POSITION

    || _la == FeatParser::POSITION_v)) {
    _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;
}

//----------------- MarkligtokContext ------------------------------------------------------------------

FeatParser::MarkligtokContext::MarkligtokContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* FeatParser::MarkligtokContext::MARKLIG() {
  return getToken(FeatParser::MARKLIG, 0);
}

tree::TerminalNode* FeatParser::MarkligtokContext::MARKLIG_v() {
  return getToken(FeatParser::MARKLIG_v, 0);
}


size_t FeatParser::MarkligtokContext::getRuleIndex() const {
  return FeatParser::RuleMarkligtok;
}


std::any FeatParser::MarkligtokContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<FeatParserVisitor*>(visitor))
    return parserVisitor->visitMarkligtok(this);
  else
    return visitor->visitChildren(this);
}

FeatParser::MarkligtokContext* FeatParser::markligtok() {
  MarkligtokContext *_localctx = _tracker.createInstance<MarkligtokContext>(_ctx, getState());
  enterRule(_localctx, 220, FeatParser::RuleMarkligtok);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1153);
    _la = _input->LA(1);
    if (!(_la == FeatParser::MARKLIG

    || _la == FeatParser::MARKLIG_v)) {
    _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;
}

void FeatParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  featparserParserInitialize();
#else
  ::antlr4::internal::call_once(featparserParserOnceFlag, featparserParserInitialize);
#endif
}
