001// Generated from de/isas/lipidomics/palinom/HMDB.g4 by ANTLR 4.7.2 002package de.isas.lipidomics.palinom; 003import org.antlr.v4.runtime.atn.*; 004import org.antlr.v4.runtime.dfa.DFA; 005import org.antlr.v4.runtime.*; 006import org.antlr.v4.runtime.misc.*; 007import org.antlr.v4.runtime.tree.*; 008import java.util.List; 009import java.util.Iterator; 010import java.util.ArrayList; 011 012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 013public class HMDBParser extends Parser { 014 static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); } 015 016 protected static final DFA[] _decisionToDFA; 017 protected static final PredictionContextCache _sharedContextCache = 018 new PredictionContextCache(); 019 public static final int 020 T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 021 T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 022 T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 023 T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 024 T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 025 T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, 026 T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, 027 T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, 028 T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, 029 T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, 030 T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, 031 T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, 032 T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, 033 T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, 034 T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, 035 T__107=108, T__108=109, T__109=110, T__110=111, T__111=112, T__112=113, 036 T__113=114, T__114=115, T__115=116, T__116=117, T__117=118, T__118=119, 037 T__119=120, T__120=121, T__121=122, T__122=123, T__123=124, T__124=125, 038 T__125=126, T__126=127, T__127=128, T__128=129, T__129=130, T__130=131, 039 T__131=132, T__132=133, T__133=134, T__134=135, T__135=136, T__136=137, 040 T__137=138, T__138=139, T__139=140, T__140=141, T__141=142, T__142=143, 041 T__143=144, T__144=145, T__145=146, T__146=147, T__147=148, T__148=149, 042 T__149=150, T__150=151, T__151=152, T__152=153, T__153=154, T__154=155, 043 T__155=156, T__156=157, T__157=158, T__158=159, T__159=160, T__160=161, 044 T__161=162, T__162=163, T__163=164, T__164=165, T__165=166, T__166=167, 045 T__167=168, T__168=169, T__169=170, T__170=171, T__171=172, T__172=173, 046 T__173=174, T__174=175, T__175=176, T__176=177, T__177=178, T__178=179, 047 T__179=180, T__180=181, T__181=182, T__182=183, T__183=184, T__184=185, 048 T__185=186, T__186=187, T__187=188, T__188=189, T__189=190, T__190=191, 049 T__191=192, T__192=193, T__193=194, T__194=195, T__195=196, T__196=197, 050 T__197=198, T__198=199, T__199=200, T__200=201, T__201=202, T__202=203, 051 T__203=204, T__204=205, T__205=206, T__206=207, T__207=208, T__208=209, 052 T__209=210, T__210=211, T__211=212, T__212=213, T__213=214, T__214=215, 053 T__215=216, T__216=217, T__217=218, T__218=219, T__219=220, T__220=221, 054 T__221=222, T__222=223, T__223=224, T__224=225, T__225=226, SPACE=227, 055 COLON=228, SEMICOLON=229, DASH=230, UNDERSCORE=231, SLASH=232, BACKSLASH=233, 056 COMMA=234, ROB=235, RCB=236; 057 public static final int 058 RULE_lipid = 0, RULE_lipid_pure = 1, RULE_lipid_class = 2, RULE_lipid_suffix = 3, 059 RULE_fa = 4, RULE_fa_core = 5, RULE_furan_fa = 6, RULE_furan_fa_mono = 7, 060 RULE_furan_fa_di = 8, RULE_lcb = 9, RULE_lcb_core = 10, RULE_carbon = 11, 061 RULE_db = 12, RULE_db_count = 13, RULE_db_suffix = 14, RULE_db_suffix_number = 15, 062 RULE_db_positions = 16, RULE_db_position = 17, RULE_db_single_position = 18, 063 RULE_db_position_number = 19, RULE_cistrans = 20, RULE_ether = 21, RULE_ether_link_pos = 22, 064 RULE_ether_type = 23, RULE_hydroxyl = 24, RULE_fa_lcb_suffix = 25, RULE_fa_lcb_suffix_core = 26, 065 RULE_fa_lcb_suffix_type = 27, RULE_fa_lcb_suffix_number = 28, RULE_fa_lcb_prefix = 29, 066 RULE_fa_lcb_prefix_type = 30, RULE_fa_species = 31, RULE_fa2 = 32, RULE_fa2_sorted = 33, 067 RULE_fa2_unsorted = 34, RULE_fa3 = 35, RULE_fa3_sorted = 36, RULE_fa3_unsorted = 37, 068 RULE_fa4 = 38, RULE_fa4_sorted = 39, RULE_fa4_unsorted = 40, RULE_fatty_acid = 41, 069 RULE_fa_hg = 42, RULE_fa_fa = 43, RULE_interlink_fa = 44, RULE_mediator = 45, 070 RULE_mediator_single = 46, RULE_med_positions = 47, RULE_med_position = 48, 071 RULE_med_suffix = 49, RULE_gl = 50, RULE_gl_regular = 51, RULE_gl_fa = 52, 072 RULE_gl_hg = 53, RULE_gl_molecular = 54, RULE_gl_molecular_fa = 55, RULE_gl_molecular_hg = 56, 073 RULE_gl_mono = 57, RULE_gl_mono_fa = 58, RULE_gl_mono_hg = 59, RULE_pl = 60, 074 RULE_pl_regular = 61, RULE_pl_fa = 62, RULE_pl_hg = 63, RULE_pl_three = 64, 075 RULE_pl_three_fa = 65, RULE_pl_three_hg = 66, RULE_pl_four = 67, RULE_pl_four_fa = 68, 076 RULE_pl_four_hg = 69, RULE_sl = 70, RULE_sl_hg = 71, RULE_sl_hg_names = 72, 077 RULE_ganglioside = 73, RULE_ganglioside_names = 74, RULE_sl_hg_prefix = 75, 078 RULE_sl_hg_suffix = 76, RULE_sl_lcb = 77, RULE_sl_lcb_species = 78, RULE_sl_lcb_subspecies = 79, 079 RULE_st = 80, RULE_st_species = 81, RULE_st_species_hg = 82, RULE_st_species_fa = 83, 080 RULE_st_sub1 = 84, RULE_st_sub1_hg = 85, RULE_st_sub1_fa = 86, RULE_st_sub2 = 87, 081 RULE_st_sub2_hg = 88, RULE_st_sub2_fa = 89, RULE_unsorted_fa_separator = 90, 082 RULE_sorted_fa_separator = 91, RULE_headgroup_separator = 92, RULE_carbon_db_separator = 93, 083 RULE_db_position_separator = 94, RULE_med_position_separator = 95, RULE_fa_lcb_suffix_separator = 96, 084 RULE_fa_lcb_prefix_separator = 97, RULE_number = 98, RULE_digit = 99; 085 private static String[] makeRuleNames() { 086 return new String[] { 087 "lipid", "lipid_pure", "lipid_class", "lipid_suffix", "fa", "fa_core", 088 "furan_fa", "furan_fa_mono", "furan_fa_di", "lcb", "lcb_core", "carbon", 089 "db", "db_count", "db_suffix", "db_suffix_number", "db_positions", "db_position", 090 "db_single_position", "db_position_number", "cistrans", "ether", "ether_link_pos", 091 "ether_type", "hydroxyl", "fa_lcb_suffix", "fa_lcb_suffix_core", "fa_lcb_suffix_type", 092 "fa_lcb_suffix_number", "fa_lcb_prefix", "fa_lcb_prefix_type", "fa_species", 093 "fa2", "fa2_sorted", "fa2_unsorted", "fa3", "fa3_sorted", "fa3_unsorted", 094 "fa4", "fa4_sorted", "fa4_unsorted", "fatty_acid", "fa_hg", "fa_fa", 095 "interlink_fa", "mediator", "mediator_single", "med_positions", "med_position", 096 "med_suffix", "gl", "gl_regular", "gl_fa", "gl_hg", "gl_molecular", "gl_molecular_fa", 097 "gl_molecular_hg", "gl_mono", "gl_mono_fa", "gl_mono_hg", "pl", "pl_regular", 098 "pl_fa", "pl_hg", "pl_three", "pl_three_fa", "pl_three_hg", "pl_four", 099 "pl_four_fa", "pl_four_hg", "sl", "sl_hg", "sl_hg_names", "ganglioside", 100 "ganglioside_names", "sl_hg_prefix", "sl_hg_suffix", "sl_lcb", "sl_lcb_species", 101 "sl_lcb_subspecies", "st", "st_species", "st_species_hg", "st_species_fa", 102 "st_sub1", "st_sub1_hg", "st_sub1_fa", "st_sub2", "st_sub2_hg", "st_sub2_fa", 103 "unsorted_fa_separator", "sorted_fa_separator", "headgroup_separator", 104 "carbon_db_separator", "db_position_separator", "med_position_separator", 105 "fa_lcb_suffix_separator", "fa_lcb_prefix_separator", "number", "digit" 106 }; 107 } 108 public static final String[] ruleNames = makeRuleNames(); 109 110 private static String[] makeLiteralNames() { 111 return new String[] { 112 null, "'[rac]'", "'M'", "'MonoMe('", "'D'", "'DiMe('", "'e'", "'n'", 113 "'E'", "'Z'", "'o-'", "'O-'", "'P-'", "'i-'", "'a-'", "'m'", "'d'", "'t'", 114 "'OH'", "'me'", "'iso'", "'FA'", "'fatty acid'", "'fatty alcohol'", "'NAE'", 115 "'GP-NAE'", "'FAHFA'", "'KETE'", "'keto'", "'oxo'", "'Hp'", "'EPE'", 116 "'ETE'", "'ODE'", "'EPT'", "'H'", "'LXA4'", "'hydroxy'", "'Di'", "'RvE1'", 117 "'glyceryl'", "'EpETrE'", "'DHE'", "'ETrE'", "'DHA'", "'DoHA'", "'LTB4'", 118 "'PGE2'", "' PGE2'", "'PGF2alpha'", "'trihydroxy'", "'TriH'", "'OTrE'", 119 "'dihydroxy'", "'Ep'", "'LXB4'", "'Tri'", "'PAHSA'", "'MUFA'", "'GPGP'", 120 "'GPIP'", "'PGE1'", "'PGG2'", "'SFA'", "'PUFA'", "'PGI2'", "'TXA2'", 121 "'CoA'", "'FAOH'", "'EA'", "'beta'", "'PGH2'", "'LTD4'", "'kete'", "'DPE'", 122 "' PGD2'", "'PGD2'", "'PGF2'", "'LTC4'", "'LTA4'", "'PGD1'", "'PGA1'", 123 "'LTDE4'", "'epoxyoleate'", "'epoxystearate'", "'carboxy'", "'PGH1'", 124 "'EtrE'", "'HXA3'", "'HxA3'", "'HXA3-C'", "'S'", "'R'", "'MG'", "'DG'", 125 "'TG'", "'MAG'", "'DAG'", "'TAG'", "'MHDG'", "'DHDG'", "'MGDG'", "'DGDG'", 126 "'LPA'", "'LPC'", "'LPE'", "'LPG'", "'LPI'", "'LPS'", "'PA'", "'PC'", 127 "'PE'", "'PG'", "'PI'", "'PS'", "'PGP'", "'PIP'", "'PIP[3]'", "'PIP[4]'", 128 "'PIP[5]'", "'PIP2'", "'PIP2[3,4]'", "'PIP2[3,5]'", "'PIP2[4,5]'", "'PIP3'", 129 "'PIP3[3,4,5]'", "'CDP-DAG'", "'LysoPA'", "'LysoPC'", "'LysoPE'", "'LysoPG'", 130 "'LysoPI'", "'LysoPS'", "'PE-NMe'", "'PE-NMe2'", "'CDP-DG'", "'NAPE'", 131 "'BMP'", "'LBPA'", "'Lysobisphosphatidate'", "'CL'", "'MLCL'", "'DLCL'", 132 "'HexCer'", "'Hex2Cer'", "'SM'", "'PE-Cer'", "'Cer'", "'CerP'", "'IPC'", 133 "'MIPC'", "'M(IP)2C'", "'Gb3Cer'", "'Gb4Cer'", "'Forssman'", "'MSGG'", 134 "'DSGG'", "'NOR1'", "'NORint'", "'NOR2'", "'Globo-H'", "'Globo-A'", "'SB1a'", 135 "'SM1b'", "'SM1a'", "'Branched-Forssman'", "'Globo-B'", "'Para-Forssman'", 136 "'Globo-Lex-9'", "'LysoSM'", "'Glucosylceramide'", "'Ceramide'", "'Tetrahexosylceramide'", 137 "'Ganglioside'", "'Gb3'", "'GA2'", "'GA1'", "'GM3'", "'GM2'", "'GM1'", 138 "'GD3'", "'GT3'", "'GD1'", "'GT1'", "'GQ1'", "'GM4'", "'GD2'", "'GT2'", 139 "'GP1'", "'GD1a'", "'GM1b'", "'GT1b'", "'GQ1b'", "'GT1a'", "'GQ1c'", 140 "'GP1c'", "'GD1c'", "'GD1b'", "'GT1c'", "'Glc'", "'NAc'", "'Gal'", "'Fuc'", 141 "'SO3'", "'NeuGc'", "'i'", "'NeuAc'", "'Lac'", "'Lex'", "'(3'-sulfo)'", 142 "'Ac-O-9'", "'(alpha2-8)'", "'(alpha2-6)'", "'Sulfo'", "' alpha'", "'SE'", 143 "'CE'", "'0'", "'1'", "'2'", "'3'", "'4'", "'5'", "'6'", "'7'", "'8'", 144 "'9'", "' '", "':'", "';'", "'-'", "'_'", "'/'", "'\\'", "','", "'('", 145 "')'" 146 }; 147 } 148 private static final String[] _LITERAL_NAMES = makeLiteralNames(); 149 private static String[] makeSymbolicNames() { 150 return new String[] { 151 null, null, null, null, null, null, null, null, null, null, null, null, 152 null, null, null, null, null, null, null, null, null, null, null, null, 153 null, null, null, null, null, null, null, null, null, null, null, null, 154 null, null, null, null, null, null, null, null, null, null, null, null, 155 null, null, null, null, null, null, null, null, null, null, null, null, 156 null, null, null, null, null, null, null, null, null, null, null, null, 157 null, null, null, null, null, null, null, null, null, null, null, null, 158 null, null, null, null, null, null, null, null, null, null, null, null, 159 null, null, null, null, null, null, null, null, null, null, null, null, 160 null, null, null, null, null, null, null, null, null, null, null, null, 161 null, null, null, null, null, null, null, null, null, null, null, null, 162 null, null, null, null, null, null, null, null, null, null, null, null, 163 null, null, null, null, null, null, null, null, null, null, null, null, 164 null, null, null, null, null, null, null, null, null, null, null, null, 165 null, null, null, null, null, null, null, null, null, null, null, null, 166 null, null, null, null, null, null, null, null, null, null, null, null, 167 null, null, null, null, null, null, null, null, null, null, null, null, 168 null, null, null, null, null, null, null, null, null, null, null, null, 169 null, null, null, null, null, null, null, null, null, null, null, "SPACE", 170 "COLON", "SEMICOLON", "DASH", "UNDERSCORE", "SLASH", "BACKSLASH", "COMMA", 171 "ROB", "RCB" 172 }; 173 } 174 private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 175 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 176 177 /** 178 * @deprecated Use {@link #VOCABULARY} instead. 179 */ 180 @Deprecated 181 public static final String[] tokenNames; 182 static { 183 tokenNames = new String[_SYMBOLIC_NAMES.length]; 184 for (int i = 0; i < tokenNames.length; i++) { 185 tokenNames[i] = VOCABULARY.getLiteralName(i); 186 if (tokenNames[i] == null) { 187 tokenNames[i] = VOCABULARY.getSymbolicName(i); 188 } 189 190 if (tokenNames[i] == null) { 191 tokenNames[i] = "<INVALID>"; 192 } 193 } 194 } 195 196 @Override 197 @Deprecated 198 public String[] getTokenNames() { 199 return tokenNames; 200 } 201 202 @Override 203 204 public Vocabulary getVocabulary() { 205 return VOCABULARY; 206 } 207 208 @Override 209 public String getGrammarFileName() { return "HMDB.g4"; } 210 211 @Override 212 public String[] getRuleNames() { return ruleNames; } 213 214 @Override 215 public String getSerializedATN() { return _serializedATN; } 216 217 @Override 218 public ATN getATN() { return _ATN; } 219 220 public HMDBParser(TokenStream input) { 221 super(input); 222 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 223 } 224 225 public static class LipidContext extends ParserRuleContext { 226 public Lipid_pureContext lipid_pure() { 227 return getRuleContext(Lipid_pureContext.class,0); 228 } 229 public TerminalNode EOF() { return getToken(HMDBParser.EOF, 0); } 230 public LipidContext(ParserRuleContext parent, int invokingState) { 231 super(parent, invokingState); 232 } 233 @Override public int getRuleIndex() { return RULE_lipid; } 234 @Override 235 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 236 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitLipid(this); 237 else return visitor.visitChildren(this); 238 } 239 } 240 241 public final LipidContext lipid() throws RecognitionException { 242 LipidContext _localctx = new LipidContext(_ctx, getState()); 243 enterRule(_localctx, 0, RULE_lipid); 244 try { 245 enterOuterAlt(_localctx, 1); 246 { 247 setState(200); 248 lipid_pure(); 249 setState(201); 250 match(EOF); 251 } 252 } 253 catch (RecognitionException re) { 254 _localctx.exception = re; 255 _errHandler.reportError(this, re); 256 _errHandler.recover(this, re); 257 } 258 finally { 259 exitRule(); 260 } 261 return _localctx; 262 } 263 264 public static class Lipid_pureContext extends ParserRuleContext { 265 public Lipid_classContext lipid_class() { 266 return getRuleContext(Lipid_classContext.class,0); 267 } 268 public Lipid_suffixContext lipid_suffix() { 269 return getRuleContext(Lipid_suffixContext.class,0); 270 } 271 public Lipid_pureContext(ParserRuleContext parent, int invokingState) { 272 super(parent, invokingState); 273 } 274 @Override public int getRuleIndex() { return RULE_lipid_pure; } 275 @Override 276 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 277 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitLipid_pure(this); 278 else return visitor.visitChildren(this); 279 } 280 } 281 282 public final Lipid_pureContext lipid_pure() throws RecognitionException { 283 Lipid_pureContext _localctx = new Lipid_pureContext(_ctx, getState()); 284 enterRule(_localctx, 2, RULE_lipid_pure); 285 try { 286 setState(207); 287 _errHandler.sync(this); 288 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 289 case 1: 290 enterOuterAlt(_localctx, 1); 291 { 292 setState(203); 293 lipid_class(); 294 } 295 break; 296 case 2: 297 enterOuterAlt(_localctx, 2); 298 { 299 setState(204); 300 lipid_class(); 301 setState(205); 302 lipid_suffix(); 303 } 304 break; 305 } 306 } 307 catch (RecognitionException re) { 308 _localctx.exception = re; 309 _errHandler.reportError(this, re); 310 _errHandler.recover(this, re); 311 } 312 finally { 313 exitRule(); 314 } 315 return _localctx; 316 } 317 318 public static class Lipid_classContext extends ParserRuleContext { 319 public Fatty_acidContext fatty_acid() { 320 return getRuleContext(Fatty_acidContext.class,0); 321 } 322 public GlContext gl() { 323 return getRuleContext(GlContext.class,0); 324 } 325 public PlContext pl() { 326 return getRuleContext(PlContext.class,0); 327 } 328 public SlContext sl() { 329 return getRuleContext(SlContext.class,0); 330 } 331 public StContext st() { 332 return getRuleContext(StContext.class,0); 333 } 334 public Lipid_classContext(ParserRuleContext parent, int invokingState) { 335 super(parent, invokingState); 336 } 337 @Override public int getRuleIndex() { return RULE_lipid_class; } 338 @Override 339 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 340 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitLipid_class(this); 341 else return visitor.visitChildren(this); 342 } 343 } 344 345 public final Lipid_classContext lipid_class() throws RecognitionException { 346 Lipid_classContext _localctx = new Lipid_classContext(_ctx, getState()); 347 enterRule(_localctx, 4, RULE_lipid_class); 348 try { 349 setState(214); 350 _errHandler.sync(this); 351 switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { 352 case 1: 353 enterOuterAlt(_localctx, 1); 354 { 355 setState(209); 356 fatty_acid(); 357 } 358 break; 359 case 2: 360 enterOuterAlt(_localctx, 2); 361 { 362 setState(210); 363 gl(); 364 } 365 break; 366 case 3: 367 enterOuterAlt(_localctx, 3); 368 { 369 setState(211); 370 pl(); 371 } 372 break; 373 case 4: 374 enterOuterAlt(_localctx, 4); 375 { 376 setState(212); 377 sl(); 378 } 379 break; 380 case 5: 381 enterOuterAlt(_localctx, 5); 382 { 383 setState(213); 384 st(); 385 } 386 break; 387 } 388 } 389 catch (RecognitionException re) { 390 _localctx.exception = re; 391 _errHandler.reportError(this, re); 392 _errHandler.recover(this, re); 393 } 394 finally { 395 exitRule(); 396 } 397 return _localctx; 398 } 399 400 public static class Lipid_suffixContext extends ParserRuleContext { 401 public Lipid_suffixContext(ParserRuleContext parent, int invokingState) { 402 super(parent, invokingState); 403 } 404 @Override public int getRuleIndex() { return RULE_lipid_suffix; } 405 @Override 406 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 407 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitLipid_suffix(this); 408 else return visitor.visitChildren(this); 409 } 410 } 411 412 public final Lipid_suffixContext lipid_suffix() throws RecognitionException { 413 Lipid_suffixContext _localctx = new Lipid_suffixContext(_ctx, getState()); 414 enterRule(_localctx, 6, RULE_lipid_suffix); 415 try { 416 enterOuterAlt(_localctx, 1); 417 { 418 setState(216); 419 match(T__0); 420 } 421 } 422 catch (RecognitionException re) { 423 _localctx.exception = re; 424 _errHandler.reportError(this, re); 425 _errHandler.recover(this, re); 426 } 427 finally { 428 exitRule(); 429 } 430 return _localctx; 431 } 432 433 public static class FaContext extends ParserRuleContext { 434 public Fa_coreContext fa_core() { 435 return getRuleContext(Fa_coreContext.class,0); 436 } 437 public Furan_faContext furan_fa() { 438 return getRuleContext(Furan_faContext.class,0); 439 } 440 public Fa_lcb_prefixContext fa_lcb_prefix() { 441 return getRuleContext(Fa_lcb_prefixContext.class,0); 442 } 443 public Fa_lcb_suffixContext fa_lcb_suffix() { 444 return getRuleContext(Fa_lcb_suffixContext.class,0); 445 } 446 public FaContext(ParserRuleContext parent, int invokingState) { 447 super(parent, invokingState); 448 } 449 @Override public int getRuleIndex() { return RULE_fa; } 450 @Override 451 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 452 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa(this); 453 else return visitor.visitChildren(this); 454 } 455 } 456 457 public final FaContext fa() throws RecognitionException { 458 FaContext _localctx = new FaContext(_ctx, getState()); 459 enterRule(_localctx, 8, RULE_fa); 460 try { 461 setState(230); 462 _errHandler.sync(this); 463 switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) { 464 case 1: 465 enterOuterAlt(_localctx, 1); 466 { 467 setState(218); 468 fa_core(); 469 } 470 break; 471 case 2: 472 enterOuterAlt(_localctx, 2); 473 { 474 setState(219); 475 furan_fa(); 476 } 477 break; 478 case 3: 479 enterOuterAlt(_localctx, 3); 480 { 481 setState(220); 482 fa_lcb_prefix(); 483 setState(221); 484 fa_core(); 485 } 486 break; 487 case 4: 488 enterOuterAlt(_localctx, 4); 489 { 490 setState(223); 491 fa_core(); 492 setState(224); 493 fa_lcb_suffix(); 494 } 495 break; 496 case 5: 497 enterOuterAlt(_localctx, 5); 498 { 499 setState(226); 500 fa_lcb_prefix(); 501 setState(227); 502 fa_core(); 503 setState(228); 504 fa_lcb_suffix(); 505 } 506 break; 507 } 508 } 509 catch (RecognitionException re) { 510 _localctx.exception = re; 511 _errHandler.reportError(this, re); 512 _errHandler.recover(this, re); 513 } 514 finally { 515 exitRule(); 516 } 517 return _localctx; 518 } 519 520 public static class Fa_coreContext extends ParserRuleContext { 521 public CarbonContext carbon() { 522 return getRuleContext(CarbonContext.class,0); 523 } 524 public Carbon_db_separatorContext carbon_db_separator() { 525 return getRuleContext(Carbon_db_separatorContext.class,0); 526 } 527 public DbContext db() { 528 return getRuleContext(DbContext.class,0); 529 } 530 public EtherContext ether() { 531 return getRuleContext(EtherContext.class,0); 532 } 533 public Fa_coreContext(ParserRuleContext parent, int invokingState) { 534 super(parent, invokingState); 535 } 536 @Override public int getRuleIndex() { return RULE_fa_core; } 537 @Override 538 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 539 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_core(this); 540 else return visitor.visitChildren(this); 541 } 542 } 543 544 public final Fa_coreContext fa_core() throws RecognitionException { 545 Fa_coreContext _localctx = new Fa_coreContext(_ctx, getState()); 546 enterRule(_localctx, 10, RULE_fa_core); 547 try { 548 setState(241); 549 _errHandler.sync(this); 550 switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { 551 case 1: 552 enterOuterAlt(_localctx, 1); 553 { 554 setState(232); 555 carbon(); 556 setState(233); 557 carbon_db_separator(); 558 setState(234); 559 db(); 560 } 561 break; 562 case 2: 563 enterOuterAlt(_localctx, 2); 564 { 565 setState(236); 566 ether(); 567 setState(237); 568 carbon(); 569 setState(238); 570 carbon_db_separator(); 571 setState(239); 572 db(); 573 } 574 break; 575 } 576 } 577 catch (RecognitionException re) { 578 _localctx.exception = re; 579 _errHandler.reportError(this, re); 580 _errHandler.recover(this, re); 581 } 582 finally { 583 exitRule(); 584 } 585 return _localctx; 586 } 587 588 public static class Furan_faContext extends ParserRuleContext { 589 public Furan_fa_monoContext furan_fa_mono() { 590 return getRuleContext(Furan_fa_monoContext.class,0); 591 } 592 public Furan_fa_diContext furan_fa_di() { 593 return getRuleContext(Furan_fa_diContext.class,0); 594 } 595 public Furan_faContext(ParserRuleContext parent, int invokingState) { 596 super(parent, invokingState); 597 } 598 @Override public int getRuleIndex() { return RULE_furan_fa; } 599 @Override 600 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 601 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFuran_fa(this); 602 else return visitor.visitChildren(this); 603 } 604 } 605 606 public final Furan_faContext furan_fa() throws RecognitionException { 607 Furan_faContext _localctx = new Furan_faContext(_ctx, getState()); 608 enterRule(_localctx, 12, RULE_furan_fa); 609 try { 610 setState(245); 611 _errHandler.sync(this); 612 switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { 613 case 1: 614 enterOuterAlt(_localctx, 1); 615 { 616 setState(243); 617 furan_fa_mono(); 618 } 619 break; 620 case 2: 621 enterOuterAlt(_localctx, 2); 622 { 623 setState(244); 624 furan_fa_di(); 625 } 626 break; 627 } 628 } 629 catch (RecognitionException re) { 630 _localctx.exception = re; 631 _errHandler.reportError(this, re); 632 _errHandler.recover(this, re); 633 } 634 finally { 635 exitRule(); 636 } 637 return _localctx; 638 } 639 640 public static class Furan_fa_monoContext extends ParserRuleContext { 641 public List<NumberContext> number() { 642 return getRuleContexts(NumberContext.class); 643 } 644 public NumberContext number(int i) { 645 return getRuleContext(NumberContext.class,i); 646 } 647 public TerminalNode COMMA() { return getToken(HMDBParser.COMMA, 0); } 648 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 649 public Furan_fa_monoContext(ParserRuleContext parent, int invokingState) { 650 super(parent, invokingState); 651 } 652 @Override public int getRuleIndex() { return RULE_furan_fa_mono; } 653 @Override 654 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 655 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFuran_fa_mono(this); 656 else return visitor.visitChildren(this); 657 } 658 } 659 660 public final Furan_fa_monoContext furan_fa_mono() throws RecognitionException { 661 Furan_fa_monoContext _localctx = new Furan_fa_monoContext(_ctx, getState()); 662 enterRule(_localctx, 14, RULE_furan_fa_mono); 663 try { 664 setState(257); 665 _errHandler.sync(this); 666 switch (_input.LA(1)) { 667 case T__216: 668 case T__217: 669 case T__218: 670 case T__219: 671 case T__220: 672 case T__221: 673 case T__222: 674 case T__223: 675 case T__224: 676 case T__225: 677 enterOuterAlt(_localctx, 1); 678 { 679 setState(247); 680 number(); 681 setState(248); 682 match(T__1); 683 setState(249); 684 number(); 685 } 686 break; 687 case T__2: 688 enterOuterAlt(_localctx, 2); 689 { 690 setState(251); 691 match(T__2); 692 setState(252); 693 number(); 694 setState(253); 695 match(COMMA); 696 setState(254); 697 number(); 698 setState(255); 699 match(RCB); 700 } 701 break; 702 default: 703 throw new NoViableAltException(this); 704 } 705 } 706 catch (RecognitionException re) { 707 _localctx.exception = re; 708 _errHandler.reportError(this, re); 709 _errHandler.recover(this, re); 710 } 711 finally { 712 exitRule(); 713 } 714 return _localctx; 715 } 716 717 public static class Furan_fa_diContext extends ParserRuleContext { 718 public List<NumberContext> number() { 719 return getRuleContexts(NumberContext.class); 720 } 721 public NumberContext number(int i) { 722 return getRuleContext(NumberContext.class,i); 723 } 724 public TerminalNode COMMA() { return getToken(HMDBParser.COMMA, 0); } 725 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 726 public Furan_fa_diContext(ParserRuleContext parent, int invokingState) { 727 super(parent, invokingState); 728 } 729 @Override public int getRuleIndex() { return RULE_furan_fa_di; } 730 @Override 731 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 732 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFuran_fa_di(this); 733 else return visitor.visitChildren(this); 734 } 735 } 736 737 public final Furan_fa_diContext furan_fa_di() throws RecognitionException { 738 Furan_fa_diContext _localctx = new Furan_fa_diContext(_ctx, getState()); 739 enterRule(_localctx, 16, RULE_furan_fa_di); 740 try { 741 setState(269); 742 _errHandler.sync(this); 743 switch (_input.LA(1)) { 744 case T__216: 745 case T__217: 746 case T__218: 747 case T__219: 748 case T__220: 749 case T__221: 750 case T__222: 751 case T__223: 752 case T__224: 753 case T__225: 754 enterOuterAlt(_localctx, 1); 755 { 756 setState(259); 757 number(); 758 setState(260); 759 match(T__3); 760 setState(261); 761 number(); 762 } 763 break; 764 case T__4: 765 enterOuterAlt(_localctx, 2); 766 { 767 setState(263); 768 match(T__4); 769 setState(264); 770 number(); 771 setState(265); 772 match(COMMA); 773 setState(266); 774 number(); 775 setState(267); 776 match(RCB); 777 } 778 break; 779 default: 780 throw new NoViableAltException(this); 781 } 782 } 783 catch (RecognitionException re) { 784 _localctx.exception = re; 785 _errHandler.reportError(this, re); 786 _errHandler.recover(this, re); 787 } 788 finally { 789 exitRule(); 790 } 791 return _localctx; 792 } 793 794 public static class LcbContext extends ParserRuleContext { 795 public Lcb_coreContext lcb_core() { 796 return getRuleContext(Lcb_coreContext.class,0); 797 } 798 public Fa_lcb_prefixContext fa_lcb_prefix() { 799 return getRuleContext(Fa_lcb_prefixContext.class,0); 800 } 801 public Fa_lcb_suffixContext fa_lcb_suffix() { 802 return getRuleContext(Fa_lcb_suffixContext.class,0); 803 } 804 public LcbContext(ParserRuleContext parent, int invokingState) { 805 super(parent, invokingState); 806 } 807 @Override public int getRuleIndex() { return RULE_lcb; } 808 @Override 809 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 810 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitLcb(this); 811 else return visitor.visitChildren(this); 812 } 813 } 814 815 public final LcbContext lcb() throws RecognitionException { 816 LcbContext _localctx = new LcbContext(_ctx, getState()); 817 enterRule(_localctx, 18, RULE_lcb); 818 try { 819 setState(282); 820 _errHandler.sync(this); 821 switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { 822 case 1: 823 enterOuterAlt(_localctx, 1); 824 { 825 setState(271); 826 lcb_core(); 827 } 828 break; 829 case 2: 830 enterOuterAlt(_localctx, 2); 831 { 832 setState(272); 833 fa_lcb_prefix(); 834 setState(273); 835 lcb_core(); 836 } 837 break; 838 case 3: 839 enterOuterAlt(_localctx, 3); 840 { 841 setState(275); 842 lcb_core(); 843 setState(276); 844 fa_lcb_suffix(); 845 } 846 break; 847 case 4: 848 enterOuterAlt(_localctx, 4); 849 { 850 setState(278); 851 fa_lcb_prefix(); 852 setState(279); 853 lcb_core(); 854 setState(280); 855 fa_lcb_suffix(); 856 } 857 break; 858 } 859 } 860 catch (RecognitionException re) { 861 _localctx.exception = re; 862 _errHandler.reportError(this, re); 863 _errHandler.recover(this, re); 864 } 865 finally { 866 exitRule(); 867 } 868 return _localctx; 869 } 870 871 public static class Lcb_coreContext extends ParserRuleContext { 872 public HydroxylContext hydroxyl() { 873 return getRuleContext(HydroxylContext.class,0); 874 } 875 public CarbonContext carbon() { 876 return getRuleContext(CarbonContext.class,0); 877 } 878 public Carbon_db_separatorContext carbon_db_separator() { 879 return getRuleContext(Carbon_db_separatorContext.class,0); 880 } 881 public DbContext db() { 882 return getRuleContext(DbContext.class,0); 883 } 884 public Lcb_coreContext(ParserRuleContext parent, int invokingState) { 885 super(parent, invokingState); 886 } 887 @Override public int getRuleIndex() { return RULE_lcb_core; } 888 @Override 889 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 890 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitLcb_core(this); 891 else return visitor.visitChildren(this); 892 } 893 } 894 895 public final Lcb_coreContext lcb_core() throws RecognitionException { 896 Lcb_coreContext _localctx = new Lcb_coreContext(_ctx, getState()); 897 enterRule(_localctx, 20, RULE_lcb_core); 898 try { 899 enterOuterAlt(_localctx, 1); 900 { 901 setState(284); 902 hydroxyl(); 903 setState(285); 904 carbon(); 905 setState(286); 906 carbon_db_separator(); 907 setState(287); 908 db(); 909 } 910 } 911 catch (RecognitionException re) { 912 _localctx.exception = re; 913 _errHandler.reportError(this, re); 914 _errHandler.recover(this, re); 915 } 916 finally { 917 exitRule(); 918 } 919 return _localctx; 920 } 921 922 public static class CarbonContext extends ParserRuleContext { 923 public NumberContext number() { 924 return getRuleContext(NumberContext.class,0); 925 } 926 public CarbonContext(ParserRuleContext parent, int invokingState) { 927 super(parent, invokingState); 928 } 929 @Override public int getRuleIndex() { return RULE_carbon; } 930 @Override 931 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 932 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitCarbon(this); 933 else return visitor.visitChildren(this); 934 } 935 } 936 937 public final CarbonContext carbon() throws RecognitionException { 938 CarbonContext _localctx = new CarbonContext(_ctx, getState()); 939 enterRule(_localctx, 22, RULE_carbon); 940 try { 941 enterOuterAlt(_localctx, 1); 942 { 943 setState(289); 944 number(); 945 } 946 } 947 catch (RecognitionException re) { 948 _localctx.exception = re; 949 _errHandler.reportError(this, re); 950 _errHandler.recover(this, re); 951 } 952 finally { 953 exitRule(); 954 } 955 return _localctx; 956 } 957 958 public static class DbContext extends ParserRuleContext { 959 public Db_countContext db_count() { 960 return getRuleContext(Db_countContext.class,0); 961 } 962 public Db_positionsContext db_positions() { 963 return getRuleContext(Db_positionsContext.class,0); 964 } 965 public Db_suffixContext db_suffix() { 966 return getRuleContext(Db_suffixContext.class,0); 967 } 968 public DbContext(ParserRuleContext parent, int invokingState) { 969 super(parent, invokingState); 970 } 971 @Override public int getRuleIndex() { return RULE_db; } 972 @Override 973 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 974 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb(this); 975 else return visitor.visitChildren(this); 976 } 977 } 978 979 public final DbContext db() throws RecognitionException { 980 DbContext _localctx = new DbContext(_ctx, getState()); 981 enterRule(_localctx, 24, RULE_db); 982 try { 983 setState(302); 984 _errHandler.sync(this); 985 switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) { 986 case 1: 987 enterOuterAlt(_localctx, 1); 988 { 989 setState(291); 990 db_count(); 991 } 992 break; 993 case 2: 994 enterOuterAlt(_localctx, 2); 995 { 996 setState(292); 997 db_count(); 998 setState(293); 999 db_positions(); 1000 } 1001 break; 1002 case 3: 1003 enterOuterAlt(_localctx, 3); 1004 { 1005 setState(295); 1006 db_count(); 1007 setState(296); 1008 db_suffix(); 1009 } 1010 break; 1011 case 4: 1012 enterOuterAlt(_localctx, 4); 1013 { 1014 setState(298); 1015 db_count(); 1016 setState(299); 1017 db_positions(); 1018 setState(300); 1019 db_suffix(); 1020 } 1021 break; 1022 } 1023 } 1024 catch (RecognitionException re) { 1025 _localctx.exception = re; 1026 _errHandler.reportError(this, re); 1027 _errHandler.recover(this, re); 1028 } 1029 finally { 1030 exitRule(); 1031 } 1032 return _localctx; 1033 } 1034 1035 public static class Db_countContext extends ParserRuleContext { 1036 public NumberContext number() { 1037 return getRuleContext(NumberContext.class,0); 1038 } 1039 public Db_countContext(ParserRuleContext parent, int invokingState) { 1040 super(parent, invokingState); 1041 } 1042 @Override public int getRuleIndex() { return RULE_db_count; } 1043 @Override 1044 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1045 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_count(this); 1046 else return visitor.visitChildren(this); 1047 } 1048 } 1049 1050 public final Db_countContext db_count() throws RecognitionException { 1051 Db_countContext _localctx = new Db_countContext(_ctx, getState()); 1052 enterRule(_localctx, 26, RULE_db_count); 1053 try { 1054 enterOuterAlt(_localctx, 1); 1055 { 1056 setState(304); 1057 number(); 1058 } 1059 } 1060 catch (RecognitionException re) { 1061 _localctx.exception = re; 1062 _errHandler.reportError(this, re); 1063 _errHandler.recover(this, re); 1064 } 1065 finally { 1066 exitRule(); 1067 } 1068 return _localctx; 1069 } 1070 1071 public static class Db_suffixContext extends ParserRuleContext { 1072 public Db_suffix_numberContext db_suffix_number() { 1073 return getRuleContext(Db_suffix_numberContext.class,0); 1074 } 1075 public Db_suffixContext(ParserRuleContext parent, int invokingState) { 1076 super(parent, invokingState); 1077 } 1078 @Override public int getRuleIndex() { return RULE_db_suffix; } 1079 @Override 1080 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1081 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_suffix(this); 1082 else return visitor.visitChildren(this); 1083 } 1084 } 1085 1086 public final Db_suffixContext db_suffix() throws RecognitionException { 1087 Db_suffixContext _localctx = new Db_suffixContext(_ctx, getState()); 1088 enterRule(_localctx, 28, RULE_db_suffix); 1089 try { 1090 setState(309); 1091 _errHandler.sync(this); 1092 switch (_input.LA(1)) { 1093 case T__5: 1094 enterOuterAlt(_localctx, 1); 1095 { 1096 setState(306); 1097 match(T__5); 1098 } 1099 break; 1100 case T__6: 1101 enterOuterAlt(_localctx, 2); 1102 { 1103 setState(307); 1104 match(T__6); 1105 setState(308); 1106 db_suffix_number(); 1107 } 1108 break; 1109 default: 1110 throw new NoViableAltException(this); 1111 } 1112 } 1113 catch (RecognitionException re) { 1114 _localctx.exception = re; 1115 _errHandler.reportError(this, re); 1116 _errHandler.recover(this, re); 1117 } 1118 finally { 1119 exitRule(); 1120 } 1121 return _localctx; 1122 } 1123 1124 public static class Db_suffix_numberContext extends ParserRuleContext { 1125 public NumberContext number() { 1126 return getRuleContext(NumberContext.class,0); 1127 } 1128 public Db_suffix_numberContext(ParserRuleContext parent, int invokingState) { 1129 super(parent, invokingState); 1130 } 1131 @Override public int getRuleIndex() { return RULE_db_suffix_number; } 1132 @Override 1133 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1134 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_suffix_number(this); 1135 else return visitor.visitChildren(this); 1136 } 1137 } 1138 1139 public final Db_suffix_numberContext db_suffix_number() throws RecognitionException { 1140 Db_suffix_numberContext _localctx = new Db_suffix_numberContext(_ctx, getState()); 1141 enterRule(_localctx, 30, RULE_db_suffix_number); 1142 try { 1143 enterOuterAlt(_localctx, 1); 1144 { 1145 setState(311); 1146 number(); 1147 } 1148 } 1149 catch (RecognitionException re) { 1150 _localctx.exception = re; 1151 _errHandler.reportError(this, re); 1152 _errHandler.recover(this, re); 1153 } 1154 finally { 1155 exitRule(); 1156 } 1157 return _localctx; 1158 } 1159 1160 public static class Db_positionsContext extends ParserRuleContext { 1161 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 1162 public Db_positionContext db_position() { 1163 return getRuleContext(Db_positionContext.class,0); 1164 } 1165 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 1166 public Db_positionsContext(ParserRuleContext parent, int invokingState) { 1167 super(parent, invokingState); 1168 } 1169 @Override public int getRuleIndex() { return RULE_db_positions; } 1170 @Override 1171 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1172 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_positions(this); 1173 else return visitor.visitChildren(this); 1174 } 1175 } 1176 1177 public final Db_positionsContext db_positions() throws RecognitionException { 1178 Db_positionsContext _localctx = new Db_positionsContext(_ctx, getState()); 1179 enterRule(_localctx, 32, RULE_db_positions); 1180 try { 1181 enterOuterAlt(_localctx, 1); 1182 { 1183 setState(313); 1184 match(ROB); 1185 setState(314); 1186 db_position(0); 1187 setState(315); 1188 match(RCB); 1189 } 1190 } 1191 catch (RecognitionException re) { 1192 _localctx.exception = re; 1193 _errHandler.reportError(this, re); 1194 _errHandler.recover(this, re); 1195 } 1196 finally { 1197 exitRule(); 1198 } 1199 return _localctx; 1200 } 1201 1202 public static class Db_positionContext extends ParserRuleContext { 1203 public Db_single_positionContext db_single_position() { 1204 return getRuleContext(Db_single_positionContext.class,0); 1205 } 1206 public List<Db_positionContext> db_position() { 1207 return getRuleContexts(Db_positionContext.class); 1208 } 1209 public Db_positionContext db_position(int i) { 1210 return getRuleContext(Db_positionContext.class,i); 1211 } 1212 public Db_position_separatorContext db_position_separator() { 1213 return getRuleContext(Db_position_separatorContext.class,0); 1214 } 1215 public Db_positionContext(ParserRuleContext parent, int invokingState) { 1216 super(parent, invokingState); 1217 } 1218 @Override public int getRuleIndex() { return RULE_db_position; } 1219 @Override 1220 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1221 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_position(this); 1222 else return visitor.visitChildren(this); 1223 } 1224 } 1225 1226 public final Db_positionContext db_position() throws RecognitionException { 1227 return db_position(0); 1228 } 1229 1230 private Db_positionContext db_position(int _p) throws RecognitionException { 1231 ParserRuleContext _parentctx = _ctx; 1232 int _parentState = getState(); 1233 Db_positionContext _localctx = new Db_positionContext(_ctx, _parentState); 1234 Db_positionContext _prevctx = _localctx; 1235 int _startState = 34; 1236 enterRecursionRule(_localctx, 34, RULE_db_position, _p); 1237 try { 1238 int _alt; 1239 enterOuterAlt(_localctx, 1); 1240 { 1241 { 1242 setState(318); 1243 db_single_position(); 1244 } 1245 _ctx.stop = _input.LT(-1); 1246 setState(326); 1247 _errHandler.sync(this); 1248 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1249 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1250 if ( _alt==1 ) { 1251 if ( _parseListeners!=null ) triggerExitRuleEvent(); 1252 _prevctx = _localctx; 1253 { 1254 { 1255 _localctx = new Db_positionContext(_parentctx, _parentState); 1256 pushNewRecursionContext(_localctx, _startState, RULE_db_position); 1257 setState(320); 1258 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); 1259 setState(321); 1260 db_position_separator(); 1261 setState(322); 1262 db_position(2); 1263 } 1264 } 1265 } 1266 setState(328); 1267 _errHandler.sync(this); 1268 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1269 } 1270 } 1271 } 1272 catch (RecognitionException re) { 1273 _localctx.exception = re; 1274 _errHandler.reportError(this, re); 1275 _errHandler.recover(this, re); 1276 } 1277 finally { 1278 unrollRecursionContexts(_parentctx); 1279 } 1280 return _localctx; 1281 } 1282 1283 public static class Db_single_positionContext extends ParserRuleContext { 1284 public Db_position_numberContext db_position_number() { 1285 return getRuleContext(Db_position_numberContext.class,0); 1286 } 1287 public CistransContext cistrans() { 1288 return getRuleContext(CistransContext.class,0); 1289 } 1290 public Db_single_positionContext(ParserRuleContext parent, int invokingState) { 1291 super(parent, invokingState); 1292 } 1293 @Override public int getRuleIndex() { return RULE_db_single_position; } 1294 @Override 1295 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1296 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_single_position(this); 1297 else return visitor.visitChildren(this); 1298 } 1299 } 1300 1301 public final Db_single_positionContext db_single_position() throws RecognitionException { 1302 Db_single_positionContext _localctx = new Db_single_positionContext(_ctx, getState()); 1303 enterRule(_localctx, 36, RULE_db_single_position); 1304 try { 1305 setState(333); 1306 _errHandler.sync(this); 1307 switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) { 1308 case 1: 1309 enterOuterAlt(_localctx, 1); 1310 { 1311 setState(329); 1312 db_position_number(); 1313 } 1314 break; 1315 case 2: 1316 enterOuterAlt(_localctx, 2); 1317 { 1318 setState(330); 1319 db_position_number(); 1320 setState(331); 1321 cistrans(); 1322 } 1323 break; 1324 } 1325 } 1326 catch (RecognitionException re) { 1327 _localctx.exception = re; 1328 _errHandler.reportError(this, re); 1329 _errHandler.recover(this, re); 1330 } 1331 finally { 1332 exitRule(); 1333 } 1334 return _localctx; 1335 } 1336 1337 public static class Db_position_numberContext extends ParserRuleContext { 1338 public NumberContext number() { 1339 return getRuleContext(NumberContext.class,0); 1340 } 1341 public Db_position_numberContext(ParserRuleContext parent, int invokingState) { 1342 super(parent, invokingState); 1343 } 1344 @Override public int getRuleIndex() { return RULE_db_position_number; } 1345 @Override 1346 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1347 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_position_number(this); 1348 else return visitor.visitChildren(this); 1349 } 1350 } 1351 1352 public final Db_position_numberContext db_position_number() throws RecognitionException { 1353 Db_position_numberContext _localctx = new Db_position_numberContext(_ctx, getState()); 1354 enterRule(_localctx, 38, RULE_db_position_number); 1355 try { 1356 enterOuterAlt(_localctx, 1); 1357 { 1358 setState(335); 1359 number(); 1360 } 1361 } 1362 catch (RecognitionException re) { 1363 _localctx.exception = re; 1364 _errHandler.reportError(this, re); 1365 _errHandler.recover(this, re); 1366 } 1367 finally { 1368 exitRule(); 1369 } 1370 return _localctx; 1371 } 1372 1373 public static class CistransContext extends ParserRuleContext { 1374 public CistransContext(ParserRuleContext parent, int invokingState) { 1375 super(parent, invokingState); 1376 } 1377 @Override public int getRuleIndex() { return RULE_cistrans; } 1378 @Override 1379 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1380 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitCistrans(this); 1381 else return visitor.visitChildren(this); 1382 } 1383 } 1384 1385 public final CistransContext cistrans() throws RecognitionException { 1386 CistransContext _localctx = new CistransContext(_ctx, getState()); 1387 enterRule(_localctx, 40, RULE_cistrans); 1388 int _la; 1389 try { 1390 enterOuterAlt(_localctx, 1); 1391 { 1392 setState(337); 1393 _la = _input.LA(1); 1394 if ( !(_la==T__7 || _la==T__8) ) { 1395 _errHandler.recoverInline(this); 1396 } 1397 else { 1398 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1399 _errHandler.reportMatch(this); 1400 consume(); 1401 } 1402 } 1403 } 1404 catch (RecognitionException re) { 1405 _localctx.exception = re; 1406 _errHandler.reportError(this, re); 1407 _errHandler.recover(this, re); 1408 } 1409 finally { 1410 exitRule(); 1411 } 1412 return _localctx; 1413 } 1414 1415 public static class EtherContext extends ParserRuleContext { 1416 public Ether_typeContext ether_type() { 1417 return getRuleContext(Ether_typeContext.class,0); 1418 } 1419 public Ether_link_posContext ether_link_pos() { 1420 return getRuleContext(Ether_link_posContext.class,0); 1421 } 1422 public EtherContext(ParserRuleContext parent, int invokingState) { 1423 super(parent, invokingState); 1424 } 1425 @Override public int getRuleIndex() { return RULE_ether; } 1426 @Override 1427 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1428 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitEther(this); 1429 else return visitor.visitChildren(this); 1430 } 1431 } 1432 1433 public final EtherContext ether() throws RecognitionException { 1434 EtherContext _localctx = new EtherContext(_ctx, getState()); 1435 enterRule(_localctx, 42, RULE_ether); 1436 try { 1437 setState(343); 1438 _errHandler.sync(this); 1439 switch (_input.LA(1)) { 1440 case T__9: 1441 case T__10: 1442 case T__11: 1443 case T__12: 1444 case T__13: 1445 enterOuterAlt(_localctx, 1); 1446 { 1447 setState(339); 1448 ether_type(); 1449 } 1450 break; 1451 case T__216: 1452 case T__217: 1453 case T__218: 1454 case T__219: 1455 case T__220: 1456 case T__221: 1457 case T__222: 1458 case T__223: 1459 case T__224: 1460 case T__225: 1461 enterOuterAlt(_localctx, 2); 1462 { 1463 setState(340); 1464 ether_link_pos(); 1465 setState(341); 1466 ether_type(); 1467 } 1468 break; 1469 default: 1470 throw new NoViableAltException(this); 1471 } 1472 } 1473 catch (RecognitionException re) { 1474 _localctx.exception = re; 1475 _errHandler.reportError(this, re); 1476 _errHandler.recover(this, re); 1477 } 1478 finally { 1479 exitRule(); 1480 } 1481 return _localctx; 1482 } 1483 1484 public static class Ether_link_posContext extends ParserRuleContext { 1485 public NumberContext number() { 1486 return getRuleContext(NumberContext.class,0); 1487 } 1488 public TerminalNode DASH() { return getToken(HMDBParser.DASH, 0); } 1489 public Ether_link_posContext(ParserRuleContext parent, int invokingState) { 1490 super(parent, invokingState); 1491 } 1492 @Override public int getRuleIndex() { return RULE_ether_link_pos; } 1493 @Override 1494 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1495 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitEther_link_pos(this); 1496 else return visitor.visitChildren(this); 1497 } 1498 } 1499 1500 public final Ether_link_posContext ether_link_pos() throws RecognitionException { 1501 Ether_link_posContext _localctx = new Ether_link_posContext(_ctx, getState()); 1502 enterRule(_localctx, 44, RULE_ether_link_pos); 1503 try { 1504 enterOuterAlt(_localctx, 1); 1505 { 1506 setState(345); 1507 number(); 1508 setState(346); 1509 match(DASH); 1510 } 1511 } 1512 catch (RecognitionException re) { 1513 _localctx.exception = re; 1514 _errHandler.reportError(this, re); 1515 _errHandler.recover(this, re); 1516 } 1517 finally { 1518 exitRule(); 1519 } 1520 return _localctx; 1521 } 1522 1523 public static class Ether_typeContext extends ParserRuleContext { 1524 public Ether_typeContext(ParserRuleContext parent, int invokingState) { 1525 super(parent, invokingState); 1526 } 1527 @Override public int getRuleIndex() { return RULE_ether_type; } 1528 @Override 1529 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1530 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitEther_type(this); 1531 else return visitor.visitChildren(this); 1532 } 1533 } 1534 1535 public final Ether_typeContext ether_type() throws RecognitionException { 1536 Ether_typeContext _localctx = new Ether_typeContext(_ctx, getState()); 1537 enterRule(_localctx, 46, RULE_ether_type); 1538 int _la; 1539 try { 1540 enterOuterAlt(_localctx, 1); 1541 { 1542 setState(348); 1543 _la = _input.LA(1); 1544 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << T__13))) != 0)) ) { 1545 _errHandler.recoverInline(this); 1546 } 1547 else { 1548 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1549 _errHandler.reportMatch(this); 1550 consume(); 1551 } 1552 } 1553 } 1554 catch (RecognitionException re) { 1555 _localctx.exception = re; 1556 _errHandler.reportError(this, re); 1557 _errHandler.recover(this, re); 1558 } 1559 finally { 1560 exitRule(); 1561 } 1562 return _localctx; 1563 } 1564 1565 public static class HydroxylContext extends ParserRuleContext { 1566 public HydroxylContext(ParserRuleContext parent, int invokingState) { 1567 super(parent, invokingState); 1568 } 1569 @Override public int getRuleIndex() { return RULE_hydroxyl; } 1570 @Override 1571 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1572 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitHydroxyl(this); 1573 else return visitor.visitChildren(this); 1574 } 1575 } 1576 1577 public final HydroxylContext hydroxyl() throws RecognitionException { 1578 HydroxylContext _localctx = new HydroxylContext(_ctx, getState()); 1579 enterRule(_localctx, 48, RULE_hydroxyl); 1580 int _la; 1581 try { 1582 enterOuterAlt(_localctx, 1); 1583 { 1584 setState(350); 1585 _la = _input.LA(1); 1586 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__14) | (1L << T__15) | (1L << T__16))) != 0)) ) { 1587 _errHandler.recoverInline(this); 1588 } 1589 else { 1590 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1591 _errHandler.reportMatch(this); 1592 consume(); 1593 } 1594 } 1595 } 1596 catch (RecognitionException re) { 1597 _localctx.exception = re; 1598 _errHandler.reportError(this, re); 1599 _errHandler.recover(this, re); 1600 } 1601 finally { 1602 exitRule(); 1603 } 1604 return _localctx; 1605 } 1606 1607 public static class Fa_lcb_suffixContext extends ParserRuleContext { 1608 public Fa_lcb_suffix_coreContext fa_lcb_suffix_core() { 1609 return getRuleContext(Fa_lcb_suffix_coreContext.class,0); 1610 } 1611 public Fa_lcb_suffix_separatorContext fa_lcb_suffix_separator() { 1612 return getRuleContext(Fa_lcb_suffix_separatorContext.class,0); 1613 } 1614 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 1615 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 1616 public Fa_lcb_suffixContext(ParserRuleContext parent, int invokingState) { 1617 super(parent, invokingState); 1618 } 1619 @Override public int getRuleIndex() { return RULE_fa_lcb_suffix; } 1620 @Override 1621 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1622 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_suffix(this); 1623 else return visitor.visitChildren(this); 1624 } 1625 } 1626 1627 public final Fa_lcb_suffixContext fa_lcb_suffix() throws RecognitionException { 1628 Fa_lcb_suffixContext _localctx = new Fa_lcb_suffixContext(_ctx, getState()); 1629 enterRule(_localctx, 50, RULE_fa_lcb_suffix); 1630 try { 1631 setState(360); 1632 _errHandler.sync(this); 1633 switch (_input.LA(1)) { 1634 case T__17: 1635 case T__18: 1636 case T__216: 1637 case T__217: 1638 case T__218: 1639 case T__219: 1640 case T__220: 1641 case T__221: 1642 case T__222: 1643 case T__223: 1644 case T__224: 1645 case T__225: 1646 enterOuterAlt(_localctx, 1); 1647 { 1648 setState(352); 1649 fa_lcb_suffix_core(); 1650 } 1651 break; 1652 case DASH: 1653 enterOuterAlt(_localctx, 2); 1654 { 1655 setState(353); 1656 fa_lcb_suffix_separator(); 1657 setState(354); 1658 fa_lcb_suffix_core(); 1659 } 1660 break; 1661 case ROB: 1662 enterOuterAlt(_localctx, 3); 1663 { 1664 setState(356); 1665 match(ROB); 1666 setState(357); 1667 fa_lcb_suffix_core(); 1668 setState(358); 1669 match(RCB); 1670 } 1671 break; 1672 default: 1673 throw new NoViableAltException(this); 1674 } 1675 } 1676 catch (RecognitionException re) { 1677 _localctx.exception = re; 1678 _errHandler.reportError(this, re); 1679 _errHandler.recover(this, re); 1680 } 1681 finally { 1682 exitRule(); 1683 } 1684 return _localctx; 1685 } 1686 1687 public static class Fa_lcb_suffix_coreContext extends ParserRuleContext { 1688 public Fa_lcb_suffix_typeContext fa_lcb_suffix_type() { 1689 return getRuleContext(Fa_lcb_suffix_typeContext.class,0); 1690 } 1691 public Fa_lcb_suffix_numberContext fa_lcb_suffix_number() { 1692 return getRuleContext(Fa_lcb_suffix_numberContext.class,0); 1693 } 1694 public Fa_lcb_suffix_separatorContext fa_lcb_suffix_separator() { 1695 return getRuleContext(Fa_lcb_suffix_separatorContext.class,0); 1696 } 1697 public Fa_lcb_suffix_coreContext(ParserRuleContext parent, int invokingState) { 1698 super(parent, invokingState); 1699 } 1700 @Override public int getRuleIndex() { return RULE_fa_lcb_suffix_core; } 1701 @Override 1702 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1703 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_suffix_core(this); 1704 else return visitor.visitChildren(this); 1705 } 1706 } 1707 1708 public final Fa_lcb_suffix_coreContext fa_lcb_suffix_core() throws RecognitionException { 1709 Fa_lcb_suffix_coreContext _localctx = new Fa_lcb_suffix_coreContext(_ctx, getState()); 1710 enterRule(_localctx, 52, RULE_fa_lcb_suffix_core); 1711 try { 1712 setState(370); 1713 _errHandler.sync(this); 1714 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1715 case 1: 1716 enterOuterAlt(_localctx, 1); 1717 { 1718 setState(362); 1719 fa_lcb_suffix_type(); 1720 } 1721 break; 1722 case 2: 1723 enterOuterAlt(_localctx, 2); 1724 { 1725 setState(363); 1726 fa_lcb_suffix_number(); 1727 setState(364); 1728 fa_lcb_suffix_type(); 1729 } 1730 break; 1731 case 3: 1732 enterOuterAlt(_localctx, 3); 1733 { 1734 setState(366); 1735 fa_lcb_suffix_number(); 1736 setState(367); 1737 fa_lcb_suffix_separator(); 1738 setState(368); 1739 fa_lcb_suffix_type(); 1740 } 1741 break; 1742 } 1743 } 1744 catch (RecognitionException re) { 1745 _localctx.exception = re; 1746 _errHandler.reportError(this, re); 1747 _errHandler.recover(this, re); 1748 } 1749 finally { 1750 exitRule(); 1751 } 1752 return _localctx; 1753 } 1754 1755 public static class Fa_lcb_suffix_typeContext extends ParserRuleContext { 1756 public Fa_lcb_suffix_typeContext(ParserRuleContext parent, int invokingState) { 1757 super(parent, invokingState); 1758 } 1759 @Override public int getRuleIndex() { return RULE_fa_lcb_suffix_type; } 1760 @Override 1761 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1762 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_suffix_type(this); 1763 else return visitor.visitChildren(this); 1764 } 1765 } 1766 1767 public final Fa_lcb_suffix_typeContext fa_lcb_suffix_type() throws RecognitionException { 1768 Fa_lcb_suffix_typeContext _localctx = new Fa_lcb_suffix_typeContext(_ctx, getState()); 1769 enterRule(_localctx, 54, RULE_fa_lcb_suffix_type); 1770 int _la; 1771 try { 1772 enterOuterAlt(_localctx, 1); 1773 { 1774 setState(372); 1775 _la = _input.LA(1); 1776 if ( !(_la==T__17 || _la==T__18) ) { 1777 _errHandler.recoverInline(this); 1778 } 1779 else { 1780 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1781 _errHandler.reportMatch(this); 1782 consume(); 1783 } 1784 } 1785 } 1786 catch (RecognitionException re) { 1787 _localctx.exception = re; 1788 _errHandler.reportError(this, re); 1789 _errHandler.recover(this, re); 1790 } 1791 finally { 1792 exitRule(); 1793 } 1794 return _localctx; 1795 } 1796 1797 public static class Fa_lcb_suffix_numberContext extends ParserRuleContext { 1798 public NumberContext number() { 1799 return getRuleContext(NumberContext.class,0); 1800 } 1801 public Fa_lcb_suffix_numberContext(ParserRuleContext parent, int invokingState) { 1802 super(parent, invokingState); 1803 } 1804 @Override public int getRuleIndex() { return RULE_fa_lcb_suffix_number; } 1805 @Override 1806 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1807 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_suffix_number(this); 1808 else return visitor.visitChildren(this); 1809 } 1810 } 1811 1812 public final Fa_lcb_suffix_numberContext fa_lcb_suffix_number() throws RecognitionException { 1813 Fa_lcb_suffix_numberContext _localctx = new Fa_lcb_suffix_numberContext(_ctx, getState()); 1814 enterRule(_localctx, 56, RULE_fa_lcb_suffix_number); 1815 try { 1816 enterOuterAlt(_localctx, 1); 1817 { 1818 setState(374); 1819 number(); 1820 } 1821 } 1822 catch (RecognitionException re) { 1823 _localctx.exception = re; 1824 _errHandler.reportError(this, re); 1825 _errHandler.recover(this, re); 1826 } 1827 finally { 1828 exitRule(); 1829 } 1830 return _localctx; 1831 } 1832 1833 public static class Fa_lcb_prefixContext extends ParserRuleContext { 1834 public Fa_lcb_prefix_typeContext fa_lcb_prefix_type() { 1835 return getRuleContext(Fa_lcb_prefix_typeContext.class,0); 1836 } 1837 public Fa_lcb_prefix_separatorContext fa_lcb_prefix_separator() { 1838 return getRuleContext(Fa_lcb_prefix_separatorContext.class,0); 1839 } 1840 public Fa_lcb_prefixContext(ParserRuleContext parent, int invokingState) { 1841 super(parent, invokingState); 1842 } 1843 @Override public int getRuleIndex() { return RULE_fa_lcb_prefix; } 1844 @Override 1845 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1846 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_prefix(this); 1847 else return visitor.visitChildren(this); 1848 } 1849 } 1850 1851 public final Fa_lcb_prefixContext fa_lcb_prefix() throws RecognitionException { 1852 Fa_lcb_prefixContext _localctx = new Fa_lcb_prefixContext(_ctx, getState()); 1853 enterRule(_localctx, 58, RULE_fa_lcb_prefix); 1854 try { 1855 setState(380); 1856 _errHandler.sync(this); 1857 switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { 1858 case 1: 1859 enterOuterAlt(_localctx, 1); 1860 { 1861 setState(376); 1862 fa_lcb_prefix_type(); 1863 } 1864 break; 1865 case 2: 1866 enterOuterAlt(_localctx, 2); 1867 { 1868 setState(377); 1869 fa_lcb_prefix_type(); 1870 setState(378); 1871 fa_lcb_prefix_separator(); 1872 } 1873 break; 1874 } 1875 } 1876 catch (RecognitionException re) { 1877 _localctx.exception = re; 1878 _errHandler.reportError(this, re); 1879 _errHandler.recover(this, re); 1880 } 1881 finally { 1882 exitRule(); 1883 } 1884 return _localctx; 1885 } 1886 1887 public static class Fa_lcb_prefix_typeContext extends ParserRuleContext { 1888 public Fa_lcb_prefix_typeContext(ParserRuleContext parent, int invokingState) { 1889 super(parent, invokingState); 1890 } 1891 @Override public int getRuleIndex() { return RULE_fa_lcb_prefix_type; } 1892 @Override 1893 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1894 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_prefix_type(this); 1895 else return visitor.visitChildren(this); 1896 } 1897 } 1898 1899 public final Fa_lcb_prefix_typeContext fa_lcb_prefix_type() throws RecognitionException { 1900 Fa_lcb_prefix_typeContext _localctx = new Fa_lcb_prefix_typeContext(_ctx, getState()); 1901 enterRule(_localctx, 60, RULE_fa_lcb_prefix_type); 1902 try { 1903 enterOuterAlt(_localctx, 1); 1904 { 1905 setState(382); 1906 match(T__19); 1907 } 1908 } 1909 catch (RecognitionException re) { 1910 _localctx.exception = re; 1911 _errHandler.reportError(this, re); 1912 _errHandler.recover(this, re); 1913 } 1914 finally { 1915 exitRule(); 1916 } 1917 return _localctx; 1918 } 1919 1920 public static class Fa_speciesContext extends ParserRuleContext { 1921 public FaContext fa() { 1922 return getRuleContext(FaContext.class,0); 1923 } 1924 public Fa_speciesContext(ParserRuleContext parent, int invokingState) { 1925 super(parent, invokingState); 1926 } 1927 @Override public int getRuleIndex() { return RULE_fa_species; } 1928 @Override 1929 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1930 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_species(this); 1931 else return visitor.visitChildren(this); 1932 } 1933 } 1934 1935 public final Fa_speciesContext fa_species() throws RecognitionException { 1936 Fa_speciesContext _localctx = new Fa_speciesContext(_ctx, getState()); 1937 enterRule(_localctx, 62, RULE_fa_species); 1938 try { 1939 enterOuterAlt(_localctx, 1); 1940 { 1941 setState(384); 1942 fa(); 1943 } 1944 } 1945 catch (RecognitionException re) { 1946 _localctx.exception = re; 1947 _errHandler.reportError(this, re); 1948 _errHandler.recover(this, re); 1949 } 1950 finally { 1951 exitRule(); 1952 } 1953 return _localctx; 1954 } 1955 1956 public static class Fa2Context extends ParserRuleContext { 1957 public Fa2_sortedContext fa2_sorted() { 1958 return getRuleContext(Fa2_sortedContext.class,0); 1959 } 1960 public Fa2_unsortedContext fa2_unsorted() { 1961 return getRuleContext(Fa2_unsortedContext.class,0); 1962 } 1963 public Fa2Context(ParserRuleContext parent, int invokingState) { 1964 super(parent, invokingState); 1965 } 1966 @Override public int getRuleIndex() { return RULE_fa2; } 1967 @Override 1968 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1969 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa2(this); 1970 else return visitor.visitChildren(this); 1971 } 1972 } 1973 1974 public final Fa2Context fa2() throws RecognitionException { 1975 Fa2Context _localctx = new Fa2Context(_ctx, getState()); 1976 enterRule(_localctx, 64, RULE_fa2); 1977 try { 1978 setState(388); 1979 _errHandler.sync(this); 1980 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1981 case 1: 1982 enterOuterAlt(_localctx, 1); 1983 { 1984 setState(386); 1985 fa2_sorted(); 1986 } 1987 break; 1988 case 2: 1989 enterOuterAlt(_localctx, 2); 1990 { 1991 setState(387); 1992 fa2_unsorted(); 1993 } 1994 break; 1995 } 1996 } 1997 catch (RecognitionException re) { 1998 _localctx.exception = re; 1999 _errHandler.reportError(this, re); 2000 _errHandler.recover(this, re); 2001 } 2002 finally { 2003 exitRule(); 2004 } 2005 return _localctx; 2006 } 2007 2008 public static class Fa2_sortedContext extends ParserRuleContext { 2009 public List<FaContext> fa() { 2010 return getRuleContexts(FaContext.class); 2011 } 2012 public FaContext fa(int i) { 2013 return getRuleContext(FaContext.class,i); 2014 } 2015 public Sorted_fa_separatorContext sorted_fa_separator() { 2016 return getRuleContext(Sorted_fa_separatorContext.class,0); 2017 } 2018 public Fa2_sortedContext(ParserRuleContext parent, int invokingState) { 2019 super(parent, invokingState); 2020 } 2021 @Override public int getRuleIndex() { return RULE_fa2_sorted; } 2022 @Override 2023 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2024 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa2_sorted(this); 2025 else return visitor.visitChildren(this); 2026 } 2027 } 2028 2029 public final Fa2_sortedContext fa2_sorted() throws RecognitionException { 2030 Fa2_sortedContext _localctx = new Fa2_sortedContext(_ctx, getState()); 2031 enterRule(_localctx, 66, RULE_fa2_sorted); 2032 try { 2033 enterOuterAlt(_localctx, 1); 2034 { 2035 setState(390); 2036 fa(); 2037 setState(391); 2038 sorted_fa_separator(); 2039 setState(392); 2040 fa(); 2041 } 2042 } 2043 catch (RecognitionException re) { 2044 _localctx.exception = re; 2045 _errHandler.reportError(this, re); 2046 _errHandler.recover(this, re); 2047 } 2048 finally { 2049 exitRule(); 2050 } 2051 return _localctx; 2052 } 2053 2054 public static class Fa2_unsortedContext extends ParserRuleContext { 2055 public List<FaContext> fa() { 2056 return getRuleContexts(FaContext.class); 2057 } 2058 public FaContext fa(int i) { 2059 return getRuleContext(FaContext.class,i); 2060 } 2061 public Unsorted_fa_separatorContext unsorted_fa_separator() { 2062 return getRuleContext(Unsorted_fa_separatorContext.class,0); 2063 } 2064 public Fa2_unsortedContext(ParserRuleContext parent, int invokingState) { 2065 super(parent, invokingState); 2066 } 2067 @Override public int getRuleIndex() { return RULE_fa2_unsorted; } 2068 @Override 2069 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2070 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa2_unsorted(this); 2071 else return visitor.visitChildren(this); 2072 } 2073 } 2074 2075 public final Fa2_unsortedContext fa2_unsorted() throws RecognitionException { 2076 Fa2_unsortedContext _localctx = new Fa2_unsortedContext(_ctx, getState()); 2077 enterRule(_localctx, 68, RULE_fa2_unsorted); 2078 try { 2079 enterOuterAlt(_localctx, 1); 2080 { 2081 setState(394); 2082 fa(); 2083 setState(395); 2084 unsorted_fa_separator(); 2085 setState(396); 2086 fa(); 2087 } 2088 } 2089 catch (RecognitionException re) { 2090 _localctx.exception = re; 2091 _errHandler.reportError(this, re); 2092 _errHandler.recover(this, re); 2093 } 2094 finally { 2095 exitRule(); 2096 } 2097 return _localctx; 2098 } 2099 2100 public static class Fa3Context extends ParserRuleContext { 2101 public Fa3_sortedContext fa3_sorted() { 2102 return getRuleContext(Fa3_sortedContext.class,0); 2103 } 2104 public Fa3_unsortedContext fa3_unsorted() { 2105 return getRuleContext(Fa3_unsortedContext.class,0); 2106 } 2107 public Fa3Context(ParserRuleContext parent, int invokingState) { 2108 super(parent, invokingState); 2109 } 2110 @Override public int getRuleIndex() { return RULE_fa3; } 2111 @Override 2112 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2113 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa3(this); 2114 else return visitor.visitChildren(this); 2115 } 2116 } 2117 2118 public final Fa3Context fa3() throws RecognitionException { 2119 Fa3Context _localctx = new Fa3Context(_ctx, getState()); 2120 enterRule(_localctx, 70, RULE_fa3); 2121 try { 2122 setState(400); 2123 _errHandler.sync(this); 2124 switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { 2125 case 1: 2126 enterOuterAlt(_localctx, 1); 2127 { 2128 setState(398); 2129 fa3_sorted(); 2130 } 2131 break; 2132 case 2: 2133 enterOuterAlt(_localctx, 2); 2134 { 2135 setState(399); 2136 fa3_unsorted(); 2137 } 2138 break; 2139 } 2140 } 2141 catch (RecognitionException re) { 2142 _localctx.exception = re; 2143 _errHandler.reportError(this, re); 2144 _errHandler.recover(this, re); 2145 } 2146 finally { 2147 exitRule(); 2148 } 2149 return _localctx; 2150 } 2151 2152 public static class Fa3_sortedContext extends ParserRuleContext { 2153 public List<FaContext> fa() { 2154 return getRuleContexts(FaContext.class); 2155 } 2156 public FaContext fa(int i) { 2157 return getRuleContext(FaContext.class,i); 2158 } 2159 public List<Sorted_fa_separatorContext> sorted_fa_separator() { 2160 return getRuleContexts(Sorted_fa_separatorContext.class); 2161 } 2162 public Sorted_fa_separatorContext sorted_fa_separator(int i) { 2163 return getRuleContext(Sorted_fa_separatorContext.class,i); 2164 } 2165 public Fa3_sortedContext(ParserRuleContext parent, int invokingState) { 2166 super(parent, invokingState); 2167 } 2168 @Override public int getRuleIndex() { return RULE_fa3_sorted; } 2169 @Override 2170 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2171 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa3_sorted(this); 2172 else return visitor.visitChildren(this); 2173 } 2174 } 2175 2176 public final Fa3_sortedContext fa3_sorted() throws RecognitionException { 2177 Fa3_sortedContext _localctx = new Fa3_sortedContext(_ctx, getState()); 2178 enterRule(_localctx, 72, RULE_fa3_sorted); 2179 try { 2180 enterOuterAlt(_localctx, 1); 2181 { 2182 setState(402); 2183 fa(); 2184 setState(403); 2185 sorted_fa_separator(); 2186 setState(404); 2187 fa(); 2188 setState(405); 2189 sorted_fa_separator(); 2190 setState(406); 2191 fa(); 2192 } 2193 } 2194 catch (RecognitionException re) { 2195 _localctx.exception = re; 2196 _errHandler.reportError(this, re); 2197 _errHandler.recover(this, re); 2198 } 2199 finally { 2200 exitRule(); 2201 } 2202 return _localctx; 2203 } 2204 2205 public static class Fa3_unsortedContext extends ParserRuleContext { 2206 public List<FaContext> fa() { 2207 return getRuleContexts(FaContext.class); 2208 } 2209 public FaContext fa(int i) { 2210 return getRuleContext(FaContext.class,i); 2211 } 2212 public List<Unsorted_fa_separatorContext> unsorted_fa_separator() { 2213 return getRuleContexts(Unsorted_fa_separatorContext.class); 2214 } 2215 public Unsorted_fa_separatorContext unsorted_fa_separator(int i) { 2216 return getRuleContext(Unsorted_fa_separatorContext.class,i); 2217 } 2218 public Fa3_unsortedContext(ParserRuleContext parent, int invokingState) { 2219 super(parent, invokingState); 2220 } 2221 @Override public int getRuleIndex() { return RULE_fa3_unsorted; } 2222 @Override 2223 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2224 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa3_unsorted(this); 2225 else return visitor.visitChildren(this); 2226 } 2227 } 2228 2229 public final Fa3_unsortedContext fa3_unsorted() throws RecognitionException { 2230 Fa3_unsortedContext _localctx = new Fa3_unsortedContext(_ctx, getState()); 2231 enterRule(_localctx, 74, RULE_fa3_unsorted); 2232 try { 2233 enterOuterAlt(_localctx, 1); 2234 { 2235 setState(408); 2236 fa(); 2237 setState(409); 2238 unsorted_fa_separator(); 2239 setState(410); 2240 fa(); 2241 setState(411); 2242 unsorted_fa_separator(); 2243 setState(412); 2244 fa(); 2245 } 2246 } 2247 catch (RecognitionException re) { 2248 _localctx.exception = re; 2249 _errHandler.reportError(this, re); 2250 _errHandler.recover(this, re); 2251 } 2252 finally { 2253 exitRule(); 2254 } 2255 return _localctx; 2256 } 2257 2258 public static class Fa4Context extends ParserRuleContext { 2259 public Fa4_sortedContext fa4_sorted() { 2260 return getRuleContext(Fa4_sortedContext.class,0); 2261 } 2262 public Fa4_unsortedContext fa4_unsorted() { 2263 return getRuleContext(Fa4_unsortedContext.class,0); 2264 } 2265 public Fa4Context(ParserRuleContext parent, int invokingState) { 2266 super(parent, invokingState); 2267 } 2268 @Override public int getRuleIndex() { return RULE_fa4; } 2269 @Override 2270 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2271 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa4(this); 2272 else return visitor.visitChildren(this); 2273 } 2274 } 2275 2276 public final Fa4Context fa4() throws RecognitionException { 2277 Fa4Context _localctx = new Fa4Context(_ctx, getState()); 2278 enterRule(_localctx, 76, RULE_fa4); 2279 try { 2280 setState(416); 2281 _errHandler.sync(this); 2282 switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) { 2283 case 1: 2284 enterOuterAlt(_localctx, 1); 2285 { 2286 setState(414); 2287 fa4_sorted(); 2288 } 2289 break; 2290 case 2: 2291 enterOuterAlt(_localctx, 2); 2292 { 2293 setState(415); 2294 fa4_unsorted(); 2295 } 2296 break; 2297 } 2298 } 2299 catch (RecognitionException re) { 2300 _localctx.exception = re; 2301 _errHandler.reportError(this, re); 2302 _errHandler.recover(this, re); 2303 } 2304 finally { 2305 exitRule(); 2306 } 2307 return _localctx; 2308 } 2309 2310 public static class Fa4_sortedContext extends ParserRuleContext { 2311 public List<FaContext> fa() { 2312 return getRuleContexts(FaContext.class); 2313 } 2314 public FaContext fa(int i) { 2315 return getRuleContext(FaContext.class,i); 2316 } 2317 public List<Sorted_fa_separatorContext> sorted_fa_separator() { 2318 return getRuleContexts(Sorted_fa_separatorContext.class); 2319 } 2320 public Sorted_fa_separatorContext sorted_fa_separator(int i) { 2321 return getRuleContext(Sorted_fa_separatorContext.class,i); 2322 } 2323 public Fa4_sortedContext(ParserRuleContext parent, int invokingState) { 2324 super(parent, invokingState); 2325 } 2326 @Override public int getRuleIndex() { return RULE_fa4_sorted; } 2327 @Override 2328 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2329 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa4_sorted(this); 2330 else return visitor.visitChildren(this); 2331 } 2332 } 2333 2334 public final Fa4_sortedContext fa4_sorted() throws RecognitionException { 2335 Fa4_sortedContext _localctx = new Fa4_sortedContext(_ctx, getState()); 2336 enterRule(_localctx, 78, RULE_fa4_sorted); 2337 try { 2338 enterOuterAlt(_localctx, 1); 2339 { 2340 setState(418); 2341 fa(); 2342 setState(419); 2343 sorted_fa_separator(); 2344 setState(420); 2345 fa(); 2346 setState(421); 2347 sorted_fa_separator(); 2348 setState(422); 2349 fa(); 2350 setState(423); 2351 sorted_fa_separator(); 2352 setState(424); 2353 fa(); 2354 } 2355 } 2356 catch (RecognitionException re) { 2357 _localctx.exception = re; 2358 _errHandler.reportError(this, re); 2359 _errHandler.recover(this, re); 2360 } 2361 finally { 2362 exitRule(); 2363 } 2364 return _localctx; 2365 } 2366 2367 public static class Fa4_unsortedContext extends ParserRuleContext { 2368 public List<FaContext> fa() { 2369 return getRuleContexts(FaContext.class); 2370 } 2371 public FaContext fa(int i) { 2372 return getRuleContext(FaContext.class,i); 2373 } 2374 public List<Unsorted_fa_separatorContext> unsorted_fa_separator() { 2375 return getRuleContexts(Unsorted_fa_separatorContext.class); 2376 } 2377 public Unsorted_fa_separatorContext unsorted_fa_separator(int i) { 2378 return getRuleContext(Unsorted_fa_separatorContext.class,i); 2379 } 2380 public Fa4_unsortedContext(ParserRuleContext parent, int invokingState) { 2381 super(parent, invokingState); 2382 } 2383 @Override public int getRuleIndex() { return RULE_fa4_unsorted; } 2384 @Override 2385 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2386 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa4_unsorted(this); 2387 else return visitor.visitChildren(this); 2388 } 2389 } 2390 2391 public final Fa4_unsortedContext fa4_unsorted() throws RecognitionException { 2392 Fa4_unsortedContext _localctx = new Fa4_unsortedContext(_ctx, getState()); 2393 enterRule(_localctx, 80, RULE_fa4_unsorted); 2394 try { 2395 enterOuterAlt(_localctx, 1); 2396 { 2397 setState(426); 2398 fa(); 2399 setState(427); 2400 unsorted_fa_separator(); 2401 setState(428); 2402 fa(); 2403 setState(429); 2404 unsorted_fa_separator(); 2405 setState(430); 2406 fa(); 2407 setState(431); 2408 unsorted_fa_separator(); 2409 setState(432); 2410 fa(); 2411 } 2412 } 2413 catch (RecognitionException re) { 2414 _localctx.exception = re; 2415 _errHandler.reportError(this, re); 2416 _errHandler.recover(this, re); 2417 } 2418 finally { 2419 exitRule(); 2420 } 2421 return _localctx; 2422 } 2423 2424 public static class Fatty_acidContext extends ParserRuleContext { 2425 public Fa_hgContext fa_hg() { 2426 return getRuleContext(Fa_hgContext.class,0); 2427 } 2428 public Fa_faContext fa_fa() { 2429 return getRuleContext(Fa_faContext.class,0); 2430 } 2431 public Interlink_faContext interlink_fa() { 2432 return getRuleContext(Interlink_faContext.class,0); 2433 } 2434 public Headgroup_separatorContext headgroup_separator() { 2435 return getRuleContext(Headgroup_separatorContext.class,0); 2436 } 2437 public MediatorContext mediator() { 2438 return getRuleContext(MediatorContext.class,0); 2439 } 2440 public Fatty_acidContext(ParserRuleContext parent, int invokingState) { 2441 super(parent, invokingState); 2442 } 2443 @Override public int getRuleIndex() { return RULE_fatty_acid; } 2444 @Override 2445 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2446 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFatty_acid(this); 2447 else return visitor.visitChildren(this); 2448 } 2449 } 2450 2451 public final Fatty_acidContext fatty_acid() throws RecognitionException { 2452 Fatty_acidContext _localctx = new Fatty_acidContext(_ctx, getState()); 2453 enterRule(_localctx, 82, RULE_fatty_acid); 2454 try { 2455 setState(445); 2456 _errHandler.sync(this); 2457 switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { 2458 case 1: 2459 enterOuterAlt(_localctx, 1); 2460 { 2461 setState(434); 2462 fa_hg(); 2463 setState(435); 2464 fa_fa(); 2465 } 2466 break; 2467 case 2: 2468 enterOuterAlt(_localctx, 2); 2469 { 2470 setState(437); 2471 fa_hg(); 2472 setState(438); 2473 interlink_fa(); 2474 } 2475 break; 2476 case 3: 2477 enterOuterAlt(_localctx, 3); 2478 { 2479 setState(440); 2480 fa_hg(); 2481 setState(441); 2482 headgroup_separator(); 2483 setState(442); 2484 fa_fa(); 2485 } 2486 break; 2487 case 4: 2488 enterOuterAlt(_localctx, 4); 2489 { 2490 setState(444); 2491 mediator(); 2492 } 2493 break; 2494 } 2495 } 2496 catch (RecognitionException re) { 2497 _localctx.exception = re; 2498 _errHandler.reportError(this, re); 2499 _errHandler.recover(this, re); 2500 } 2501 finally { 2502 exitRule(); 2503 } 2504 return _localctx; 2505 } 2506 2507 public static class Fa_hgContext extends ParserRuleContext { 2508 public Fa_hgContext(ParserRuleContext parent, int invokingState) { 2509 super(parent, invokingState); 2510 } 2511 @Override public int getRuleIndex() { return RULE_fa_hg; } 2512 @Override 2513 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2514 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_hg(this); 2515 else return visitor.visitChildren(this); 2516 } 2517 } 2518 2519 public final Fa_hgContext fa_hg() throws RecognitionException { 2520 Fa_hgContext _localctx = new Fa_hgContext(_ctx, getState()); 2521 enterRule(_localctx, 84, RULE_fa_hg); 2522 int _la; 2523 try { 2524 enterOuterAlt(_localctx, 1); 2525 { 2526 setState(447); 2527 _la = _input.LA(1); 2528 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25))) != 0)) ) { 2529 _errHandler.recoverInline(this); 2530 } 2531 else { 2532 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2533 _errHandler.reportMatch(this); 2534 consume(); 2535 } 2536 } 2537 } 2538 catch (RecognitionException re) { 2539 _localctx.exception = re; 2540 _errHandler.reportError(this, re); 2541 _errHandler.recover(this, re); 2542 } 2543 finally { 2544 exitRule(); 2545 } 2546 return _localctx; 2547 } 2548 2549 public static class Fa_faContext extends ParserRuleContext { 2550 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 2551 public FaContext fa() { 2552 return getRuleContext(FaContext.class,0); 2553 } 2554 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 2555 public Fa_faContext(ParserRuleContext parent, int invokingState) { 2556 super(parent, invokingState); 2557 } 2558 @Override public int getRuleIndex() { return RULE_fa_fa; } 2559 @Override 2560 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2561 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_fa(this); 2562 else return visitor.visitChildren(this); 2563 } 2564 } 2565 2566 public final Fa_faContext fa_fa() throws RecognitionException { 2567 Fa_faContext _localctx = new Fa_faContext(_ctx, getState()); 2568 enterRule(_localctx, 86, RULE_fa_fa); 2569 try { 2570 enterOuterAlt(_localctx, 1); 2571 { 2572 setState(449); 2573 match(ROB); 2574 setState(450); 2575 fa(); 2576 setState(451); 2577 match(RCB); 2578 } 2579 } 2580 catch (RecognitionException re) { 2581 _localctx.exception = re; 2582 _errHandler.reportError(this, re); 2583 _errHandler.recover(this, re); 2584 } 2585 finally { 2586 exitRule(); 2587 } 2588 return _localctx; 2589 } 2590 2591 public static class Interlink_faContext extends ParserRuleContext { 2592 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 2593 public List<FaContext> fa() { 2594 return getRuleContexts(FaContext.class); 2595 } 2596 public FaContext fa(int i) { 2597 return getRuleContext(FaContext.class,i); 2598 } 2599 public Sorted_fa_separatorContext sorted_fa_separator() { 2600 return getRuleContext(Sorted_fa_separatorContext.class,0); 2601 } 2602 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 2603 public Interlink_faContext(ParserRuleContext parent, int invokingState) { 2604 super(parent, invokingState); 2605 } 2606 @Override public int getRuleIndex() { return RULE_interlink_fa; } 2607 @Override 2608 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2609 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitInterlink_fa(this); 2610 else return visitor.visitChildren(this); 2611 } 2612 } 2613 2614 public final Interlink_faContext interlink_fa() throws RecognitionException { 2615 Interlink_faContext _localctx = new Interlink_faContext(_ctx, getState()); 2616 enterRule(_localctx, 88, RULE_interlink_fa); 2617 try { 2618 enterOuterAlt(_localctx, 1); 2619 { 2620 setState(453); 2621 match(ROB); 2622 setState(454); 2623 fa(); 2624 setState(455); 2625 sorted_fa_separator(); 2626 setState(456); 2627 fa(); 2628 setState(457); 2629 match(RCB); 2630 } 2631 } 2632 catch (RecognitionException re) { 2633 _localctx.exception = re; 2634 _errHandler.reportError(this, re); 2635 _errHandler.recover(this, re); 2636 } 2637 finally { 2638 exitRule(); 2639 } 2640 return _localctx; 2641 } 2642 2643 public static class MediatorContext extends ParserRuleContext { 2644 public Mediator_singleContext mediator_single() { 2645 return getRuleContext(Mediator_singleContext.class,0); 2646 } 2647 public Headgroup_separatorContext headgroup_separator() { 2648 return getRuleContext(Headgroup_separatorContext.class,0); 2649 } 2650 public Med_positionsContext med_positions() { 2651 return getRuleContext(Med_positionsContext.class,0); 2652 } 2653 public MediatorContext(ParserRuleContext parent, int invokingState) { 2654 super(parent, invokingState); 2655 } 2656 @Override public int getRuleIndex() { return RULE_mediator; } 2657 @Override 2658 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2659 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitMediator(this); 2660 else return visitor.visitChildren(this); 2661 } 2662 } 2663 2664 public final MediatorContext mediator() throws RecognitionException { 2665 MediatorContext _localctx = new MediatorContext(_ctx, getState()); 2666 enterRule(_localctx, 90, RULE_mediator); 2667 try { 2668 setState(464); 2669 _errHandler.sync(this); 2670 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 2671 case 1: 2672 enterOuterAlt(_localctx, 1); 2673 { 2674 setState(459); 2675 mediator_single(0); 2676 } 2677 break; 2678 case 2: 2679 enterOuterAlt(_localctx, 2); 2680 { 2681 setState(460); 2682 mediator_single(0); 2683 setState(461); 2684 headgroup_separator(); 2685 setState(462); 2686 med_positions(); 2687 } 2688 break; 2689 } 2690 } 2691 catch (RecognitionException re) { 2692 _localctx.exception = re; 2693 _errHandler.reportError(this, re); 2694 _errHandler.recover(this, re); 2695 } 2696 finally { 2697 exitRule(); 2698 } 2699 return _localctx; 2700 } 2701 2702 public static class Mediator_singleContext extends ParserRuleContext { 2703 public Db_positionsContext db_positions() { 2704 return getRuleContext(Db_positionsContext.class,0); 2705 } 2706 public Med_positionsContext med_positions() { 2707 return getRuleContext(Med_positionsContext.class,0); 2708 } 2709 public List<Mediator_singleContext> mediator_single() { 2710 return getRuleContexts(Mediator_singleContext.class); 2711 } 2712 public Mediator_singleContext mediator_single(int i) { 2713 return getRuleContext(Mediator_singleContext.class,i); 2714 } 2715 public TerminalNode DASH() { return getToken(HMDBParser.DASH, 0); } 2716 public Mediator_singleContext(ParserRuleContext parent, int invokingState) { 2717 super(parent, invokingState); 2718 } 2719 @Override public int getRuleIndex() { return RULE_mediator_single; } 2720 @Override 2721 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2722 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitMediator_single(this); 2723 else return visitor.visitChildren(this); 2724 } 2725 } 2726 2727 public final Mediator_singleContext mediator_single() throws RecognitionException { 2728 return mediator_single(0); 2729 } 2730 2731 private Mediator_singleContext mediator_single(int _p) throws RecognitionException { 2732 ParserRuleContext _parentctx = _ctx; 2733 int _parentState = getState(); 2734 Mediator_singleContext _localctx = new Mediator_singleContext(_ctx, _parentState); 2735 Mediator_singleContext _prevctx = _localctx; 2736 int _startState = 92; 2737 enterRecursionRule(_localctx, 92, RULE_mediator_single, _p); 2738 try { 2739 int _alt; 2740 enterOuterAlt(_localctx, 1); 2741 { 2742 setState(533); 2743 _errHandler.sync(this); 2744 switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) { 2745 case 1: 2746 { 2747 setState(467); 2748 db_positions(); 2749 } 2750 break; 2751 case 2: 2752 { 2753 setState(468); 2754 med_positions(); 2755 } 2756 break; 2757 case 3: 2758 { 2759 setState(469); 2760 match(T__26); 2761 } 2762 break; 2763 case 4: 2764 { 2765 setState(470); 2766 match(T__27); 2767 } 2768 break; 2769 case 5: 2770 { 2771 setState(471); 2772 match(T__28); 2773 } 2774 break; 2775 case 6: 2776 { 2777 setState(472); 2778 match(T__29); 2779 } 2780 break; 2781 case 7: 2782 { 2783 setState(473); 2784 match(T__30); 2785 } 2786 break; 2787 case 8: 2788 { 2789 setState(474); 2790 match(T__31); 2791 } 2792 break; 2793 case 9: 2794 { 2795 setState(475); 2796 match(T__32); 2797 } 2798 break; 2799 case 10: 2800 { 2801 setState(476); 2802 match(T__33); 2803 } 2804 break; 2805 case 11: 2806 { 2807 setState(477); 2808 match(T__34); 2809 } 2810 break; 2811 case 12: 2812 { 2813 setState(478); 2814 match(T__35); 2815 } 2816 break; 2817 case 13: 2818 { 2819 setState(479); 2820 match(T__36); 2821 } 2822 break; 2823 case 14: 2824 { 2825 setState(480); 2826 match(T__37); 2827 } 2828 break; 2829 case 15: 2830 { 2831 setState(481); 2832 match(T__38); 2833 } 2834 break; 2835 case 16: 2836 { 2837 setState(482); 2838 match(T__39); 2839 } 2840 break; 2841 case 17: 2842 { 2843 setState(483); 2844 match(T__40); 2845 } 2846 break; 2847 case 18: 2848 { 2849 setState(484); 2850 match(T__41); 2851 } 2852 break; 2853 case 19: 2854 { 2855 setState(485); 2856 match(T__42); 2857 } 2858 break; 2859 case 20: 2860 { 2861 setState(486); 2862 match(T__43); 2863 } 2864 break; 2865 case 21: 2866 { 2867 setState(487); 2868 match(T__44); 2869 } 2870 break; 2871 case 22: 2872 { 2873 setState(488); 2874 match(T__45); 2875 } 2876 break; 2877 case 23: 2878 { 2879 setState(489); 2880 match(T__46); 2881 } 2882 break; 2883 case 24: 2884 { 2885 setState(490); 2886 match(T__47); 2887 } 2888 break; 2889 case 25: 2890 { 2891 setState(491); 2892 match(T__48); 2893 } 2894 break; 2895 case 26: 2896 { 2897 setState(492); 2898 match(T__49); 2899 } 2900 break; 2901 case 27: 2902 { 2903 setState(493); 2904 match(T__50); 2905 } 2906 break; 2907 case 28: 2908 { 2909 setState(494); 2910 match(T__51); 2911 } 2912 break; 2913 case 29: 2914 { 2915 setState(495); 2916 match(T__52); 2917 } 2918 break; 2919 case 30: 2920 { 2921 setState(496); 2922 match(T__53); 2923 } 2924 break; 2925 case 31: 2926 { 2927 setState(497); 2928 match(T__54); 2929 } 2930 break; 2931 case 32: 2932 { 2933 setState(498); 2934 match(T__55); 2935 } 2936 break; 2937 case 33: 2938 { 2939 setState(499); 2940 match(T__56); 2941 } 2942 break; 2943 case 34: 2944 { 2945 setState(500); 2946 match(T__57); 2947 } 2948 break; 2949 case 35: 2950 { 2951 setState(501); 2952 match(T__58); 2953 } 2954 break; 2955 case 36: 2956 { 2957 setState(502); 2958 match(T__59); 2959 } 2960 break; 2961 case 37: 2962 { 2963 setState(503); 2964 match(T__60); 2965 } 2966 break; 2967 case 38: 2968 { 2969 setState(504); 2970 match(T__61); 2971 } 2972 break; 2973 case 39: 2974 { 2975 setState(505); 2976 match(T__62); 2977 } 2978 break; 2979 case 40: 2980 { 2981 setState(506); 2982 match(T__63); 2983 } 2984 break; 2985 case 41: 2986 { 2987 setState(507); 2988 match(T__64); 2989 } 2990 break; 2991 case 42: 2992 { 2993 setState(508); 2994 match(T__65); 2995 } 2996 break; 2997 case 43: 2998 { 2999 setState(509); 3000 match(T__66); 3001 } 3002 break; 3003 case 44: 3004 { 3005 setState(510); 3006 match(T__67); 3007 } 3008 break; 3009 case 45: 3010 { 3011 setState(511); 3012 match(T__68); 3013 } 3014 break; 3015 case 46: 3016 { 3017 setState(512); 3018 match(T__69); 3019 } 3020 break; 3021 case 47: 3022 { 3023 setState(513); 3024 match(T__70); 3025 } 3026 break; 3027 case 48: 3028 { 3029 setState(514); 3030 match(T__71); 3031 } 3032 break; 3033 case 49: 3034 { 3035 setState(515); 3036 match(T__72); 3037 } 3038 break; 3039 case 50: 3040 { 3041 setState(516); 3042 match(T__73); 3043 } 3044 break; 3045 case 51: 3046 { 3047 setState(517); 3048 match(T__74); 3049 } 3050 break; 3051 case 52: 3052 { 3053 setState(518); 3054 match(T__75); 3055 } 3056 break; 3057 case 53: 3058 { 3059 setState(519); 3060 match(T__76); 3061 } 3062 break; 3063 case 54: 3064 { 3065 setState(520); 3066 match(T__77); 3067 } 3068 break; 3069 case 55: 3070 { 3071 setState(521); 3072 match(T__78); 3073 } 3074 break; 3075 case 56: 3076 { 3077 setState(522); 3078 match(T__79); 3079 } 3080 break; 3081 case 57: 3082 { 3083 setState(523); 3084 match(T__80); 3085 } 3086 break; 3087 case 58: 3088 { 3089 setState(524); 3090 match(T__81); 3091 } 3092 break; 3093 case 59: 3094 { 3095 setState(525); 3096 match(T__82); 3097 } 3098 break; 3099 case 60: 3100 { 3101 setState(526); 3102 match(T__83); 3103 } 3104 break; 3105 case 61: 3106 { 3107 setState(527); 3108 match(T__84); 3109 } 3110 break; 3111 case 62: 3112 { 3113 setState(528); 3114 match(T__85); 3115 } 3116 break; 3117 case 63: 3118 { 3119 setState(529); 3120 match(T__86); 3121 } 3122 break; 3123 case 64: 3124 { 3125 setState(530); 3126 match(T__87); 3127 } 3128 break; 3129 case 65: 3130 { 3131 setState(531); 3132 match(T__88); 3133 } 3134 break; 3135 case 66: 3136 { 3137 setState(532); 3138 match(T__89); 3139 } 3140 break; 3141 } 3142 _ctx.stop = _input.LT(-1); 3143 setState(542); 3144 _errHandler.sync(this); 3145 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 3146 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3147 if ( _alt==1 ) { 3148 if ( _parseListeners!=null ) triggerExitRuleEvent(); 3149 _prevctx = _localctx; 3150 { 3151 setState(540); 3152 _errHandler.sync(this); 3153 switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { 3154 case 1: 3155 { 3156 _localctx = new Mediator_singleContext(_parentctx, _parentState); 3157 pushNewRecursionContext(_localctx, _startState, RULE_mediator_single); 3158 setState(535); 3159 if (!(precpred(_ctx, 68))) throw new FailedPredicateException(this, "precpred(_ctx, 68)"); 3160 setState(536); 3161 mediator_single(69); 3162 } 3163 break; 3164 case 2: 3165 { 3166 _localctx = new Mediator_singleContext(_parentctx, _parentState); 3167 pushNewRecursionContext(_localctx, _startState, RULE_mediator_single); 3168 setState(537); 3169 if (!(precpred(_ctx, 67))) throw new FailedPredicateException(this, "precpred(_ctx, 67)"); 3170 setState(538); 3171 match(DASH); 3172 setState(539); 3173 mediator_single(68); 3174 } 3175 break; 3176 } 3177 } 3178 } 3179 setState(544); 3180 _errHandler.sync(this); 3181 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 3182 } 3183 } 3184 } 3185 catch (RecognitionException re) { 3186 _localctx.exception = re; 3187 _errHandler.reportError(this, re); 3188 _errHandler.recover(this, re); 3189 } 3190 finally { 3191 unrollRecursionContexts(_parentctx); 3192 } 3193 return _localctx; 3194 } 3195 3196 public static class Med_positionsContext extends ParserRuleContext { 3197 public Med_positionContext med_position() { 3198 return getRuleContext(Med_positionContext.class,0); 3199 } 3200 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 3201 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 3202 public Med_positionsContext(ParserRuleContext parent, int invokingState) { 3203 super(parent, invokingState); 3204 } 3205 @Override public int getRuleIndex() { return RULE_med_positions; } 3206 @Override 3207 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3208 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitMed_positions(this); 3209 else return visitor.visitChildren(this); 3210 } 3211 } 3212 3213 public final Med_positionsContext med_positions() throws RecognitionException { 3214 Med_positionsContext _localctx = new Med_positionsContext(_ctx, getState()); 3215 enterRule(_localctx, 94, RULE_med_positions); 3216 try { 3217 setState(550); 3218 _errHandler.sync(this); 3219 switch (_input.LA(1)) { 3220 case T__216: 3221 case T__217: 3222 case T__218: 3223 case T__219: 3224 case T__220: 3225 case T__221: 3226 case T__222: 3227 case T__223: 3228 case T__224: 3229 case T__225: 3230 enterOuterAlt(_localctx, 1); 3231 { 3232 setState(545); 3233 med_position(0); 3234 } 3235 break; 3236 case ROB: 3237 enterOuterAlt(_localctx, 2); 3238 { 3239 setState(546); 3240 match(ROB); 3241 setState(547); 3242 med_position(0); 3243 setState(548); 3244 match(RCB); 3245 } 3246 break; 3247 default: 3248 throw new NoViableAltException(this); 3249 } 3250 } 3251 catch (RecognitionException re) { 3252 _localctx.exception = re; 3253 _errHandler.reportError(this, re); 3254 _errHandler.recover(this, re); 3255 } 3256 finally { 3257 exitRule(); 3258 } 3259 return _localctx; 3260 } 3261 3262 public static class Med_positionContext extends ParserRuleContext { 3263 public NumberContext number() { 3264 return getRuleContext(NumberContext.class,0); 3265 } 3266 public Med_suffixContext med_suffix() { 3267 return getRuleContext(Med_suffixContext.class,0); 3268 } 3269 public List<Med_positionContext> med_position() { 3270 return getRuleContexts(Med_positionContext.class); 3271 } 3272 public Med_positionContext med_position(int i) { 3273 return getRuleContext(Med_positionContext.class,i); 3274 } 3275 public Med_position_separatorContext med_position_separator() { 3276 return getRuleContext(Med_position_separatorContext.class,0); 3277 } 3278 public Med_positionContext(ParserRuleContext parent, int invokingState) { 3279 super(parent, invokingState); 3280 } 3281 @Override public int getRuleIndex() { return RULE_med_position; } 3282 @Override 3283 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3284 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitMed_position(this); 3285 else return visitor.visitChildren(this); 3286 } 3287 } 3288 3289 public final Med_positionContext med_position() throws RecognitionException { 3290 return med_position(0); 3291 } 3292 3293 private Med_positionContext med_position(int _p) throws RecognitionException { 3294 ParserRuleContext _parentctx = _ctx; 3295 int _parentState = getState(); 3296 Med_positionContext _localctx = new Med_positionContext(_ctx, _parentState); 3297 Med_positionContext _prevctx = _localctx; 3298 int _startState = 96; 3299 enterRecursionRule(_localctx, 96, RULE_med_position, _p); 3300 try { 3301 int _alt; 3302 enterOuterAlt(_localctx, 1); 3303 { 3304 setState(557); 3305 _errHandler.sync(this); 3306 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 3307 case 1: 3308 { 3309 setState(553); 3310 number(); 3311 setState(554); 3312 med_suffix(); 3313 } 3314 break; 3315 case 2: 3316 { 3317 setState(556); 3318 number(); 3319 } 3320 break; 3321 } 3322 _ctx.stop = _input.LT(-1); 3323 setState(565); 3324 _errHandler.sync(this); 3325 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 3326 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3327 if ( _alt==1 ) { 3328 if ( _parseListeners!=null ) triggerExitRuleEvent(); 3329 _prevctx = _localctx; 3330 { 3331 { 3332 _localctx = new Med_positionContext(_parentctx, _parentState); 3333 pushNewRecursionContext(_localctx, _startState, RULE_med_position); 3334 setState(559); 3335 if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); 3336 setState(560); 3337 med_position_separator(); 3338 setState(561); 3339 med_position(4); 3340 } 3341 } 3342 } 3343 setState(567); 3344 _errHandler.sync(this); 3345 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 3346 } 3347 } 3348 } 3349 catch (RecognitionException re) { 3350 _localctx.exception = re; 3351 _errHandler.reportError(this, re); 3352 _errHandler.recover(this, re); 3353 } 3354 finally { 3355 unrollRecursionContexts(_parentctx); 3356 } 3357 return _localctx; 3358 } 3359 3360 public static class Med_suffixContext extends ParserRuleContext { 3361 public Med_suffixContext(ParserRuleContext parent, int invokingState) { 3362 super(parent, invokingState); 3363 } 3364 @Override public int getRuleIndex() { return RULE_med_suffix; } 3365 @Override 3366 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3367 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitMed_suffix(this); 3368 else return visitor.visitChildren(this); 3369 } 3370 } 3371 3372 public final Med_suffixContext med_suffix() throws RecognitionException { 3373 Med_suffixContext _localctx = new Med_suffixContext(_ctx, getState()); 3374 enterRule(_localctx, 98, RULE_med_suffix); 3375 int _la; 3376 try { 3377 enterOuterAlt(_localctx, 1); 3378 { 3379 setState(568); 3380 _la = _input.LA(1); 3381 if ( !(_la==T__90 || _la==T__91) ) { 3382 _errHandler.recoverInline(this); 3383 } 3384 else { 3385 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3386 _errHandler.reportMatch(this); 3387 consume(); 3388 } 3389 } 3390 } 3391 catch (RecognitionException re) { 3392 _localctx.exception = re; 3393 _errHandler.reportError(this, re); 3394 _errHandler.recover(this, re); 3395 } 3396 finally { 3397 exitRule(); 3398 } 3399 return _localctx; 3400 } 3401 3402 public static class GlContext extends ParserRuleContext { 3403 public Gl_regularContext gl_regular() { 3404 return getRuleContext(Gl_regularContext.class,0); 3405 } 3406 public Gl_monoContext gl_mono() { 3407 return getRuleContext(Gl_monoContext.class,0); 3408 } 3409 public Gl_molecularContext gl_molecular() { 3410 return getRuleContext(Gl_molecularContext.class,0); 3411 } 3412 public GlContext(ParserRuleContext parent, int invokingState) { 3413 super(parent, invokingState); 3414 } 3415 @Override public int getRuleIndex() { return RULE_gl; } 3416 @Override 3417 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3418 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl(this); 3419 else return visitor.visitChildren(this); 3420 } 3421 } 3422 3423 public final GlContext gl() throws RecognitionException { 3424 GlContext _localctx = new GlContext(_ctx, getState()); 3425 enterRule(_localctx, 100, RULE_gl); 3426 try { 3427 setState(573); 3428 _errHandler.sync(this); 3429 switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { 3430 case 1: 3431 enterOuterAlt(_localctx, 1); 3432 { 3433 setState(570); 3434 gl_regular(); 3435 } 3436 break; 3437 case 2: 3438 enterOuterAlt(_localctx, 2); 3439 { 3440 setState(571); 3441 gl_mono(); 3442 } 3443 break; 3444 case 3: 3445 enterOuterAlt(_localctx, 3); 3446 { 3447 setState(572); 3448 gl_molecular(); 3449 } 3450 break; 3451 } 3452 } 3453 catch (RecognitionException re) { 3454 _localctx.exception = re; 3455 _errHandler.reportError(this, re); 3456 _errHandler.recover(this, re); 3457 } 3458 finally { 3459 exitRule(); 3460 } 3461 return _localctx; 3462 } 3463 3464 public static class Gl_regularContext extends ParserRuleContext { 3465 public Gl_hgContext gl_hg() { 3466 return getRuleContext(Gl_hgContext.class,0); 3467 } 3468 public Gl_faContext gl_fa() { 3469 return getRuleContext(Gl_faContext.class,0); 3470 } 3471 public Headgroup_separatorContext headgroup_separator() { 3472 return getRuleContext(Headgroup_separatorContext.class,0); 3473 } 3474 public Gl_regularContext(ParserRuleContext parent, int invokingState) { 3475 super(parent, invokingState); 3476 } 3477 @Override public int getRuleIndex() { return RULE_gl_regular; } 3478 @Override 3479 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3480 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_regular(this); 3481 else return visitor.visitChildren(this); 3482 } 3483 } 3484 3485 public final Gl_regularContext gl_regular() throws RecognitionException { 3486 Gl_regularContext _localctx = new Gl_regularContext(_ctx, getState()); 3487 enterRule(_localctx, 102, RULE_gl_regular); 3488 try { 3489 setState(582); 3490 _errHandler.sync(this); 3491 switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) { 3492 case 1: 3493 enterOuterAlt(_localctx, 1); 3494 { 3495 setState(575); 3496 gl_hg(); 3497 setState(576); 3498 gl_fa(); 3499 } 3500 break; 3501 case 2: 3502 enterOuterAlt(_localctx, 2); 3503 { 3504 setState(578); 3505 gl_hg(); 3506 setState(579); 3507 headgroup_separator(); 3508 setState(580); 3509 gl_fa(); 3510 } 3511 break; 3512 } 3513 } 3514 catch (RecognitionException re) { 3515 _localctx.exception = re; 3516 _errHandler.reportError(this, re); 3517 _errHandler.recover(this, re); 3518 } 3519 finally { 3520 exitRule(); 3521 } 3522 return _localctx; 3523 } 3524 3525 public static class Gl_faContext extends ParserRuleContext { 3526 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 3527 public Fa_speciesContext fa_species() { 3528 return getRuleContext(Fa_speciesContext.class,0); 3529 } 3530 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 3531 public Fa3Context fa3() { 3532 return getRuleContext(Fa3Context.class,0); 3533 } 3534 public Gl_faContext(ParserRuleContext parent, int invokingState) { 3535 super(parent, invokingState); 3536 } 3537 @Override public int getRuleIndex() { return RULE_gl_fa; } 3538 @Override 3539 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3540 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_fa(this); 3541 else return visitor.visitChildren(this); 3542 } 3543 } 3544 3545 public final Gl_faContext gl_fa() throws RecognitionException { 3546 Gl_faContext _localctx = new Gl_faContext(_ctx, getState()); 3547 enterRule(_localctx, 104, RULE_gl_fa); 3548 try { 3549 setState(592); 3550 _errHandler.sync(this); 3551 switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) { 3552 case 1: 3553 enterOuterAlt(_localctx, 1); 3554 { 3555 setState(584); 3556 match(ROB); 3557 setState(585); 3558 fa_species(); 3559 setState(586); 3560 match(RCB); 3561 } 3562 break; 3563 case 2: 3564 enterOuterAlt(_localctx, 2); 3565 { 3566 setState(588); 3567 match(ROB); 3568 setState(589); 3569 fa3(); 3570 setState(590); 3571 match(RCB); 3572 } 3573 break; 3574 } 3575 } 3576 catch (RecognitionException re) { 3577 _localctx.exception = re; 3578 _errHandler.reportError(this, re); 3579 _errHandler.recover(this, re); 3580 } 3581 finally { 3582 exitRule(); 3583 } 3584 return _localctx; 3585 } 3586 3587 public static class Gl_hgContext extends ParserRuleContext { 3588 public Gl_hgContext(ParserRuleContext parent, int invokingState) { 3589 super(parent, invokingState); 3590 } 3591 @Override public int getRuleIndex() { return RULE_gl_hg; } 3592 @Override 3593 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3594 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_hg(this); 3595 else return visitor.visitChildren(this); 3596 } 3597 } 3598 3599 public final Gl_hgContext gl_hg() throws RecognitionException { 3600 Gl_hgContext _localctx = new Gl_hgContext(_ctx, getState()); 3601 enterRule(_localctx, 106, RULE_gl_hg); 3602 int _la; 3603 try { 3604 enterOuterAlt(_localctx, 1); 3605 { 3606 setState(594); 3607 _la = _input.LA(1); 3608 if ( !(((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (T__92 - 93)) | (1L << (T__93 - 93)) | (1L << (T__94 - 93)) | (1L << (T__95 - 93)) | (1L << (T__96 - 93)) | (1L << (T__97 - 93)))) != 0)) ) { 3609 _errHandler.recoverInline(this); 3610 } 3611 else { 3612 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3613 _errHandler.reportMatch(this); 3614 consume(); 3615 } 3616 } 3617 } 3618 catch (RecognitionException re) { 3619 _localctx.exception = re; 3620 _errHandler.reportError(this, re); 3621 _errHandler.recover(this, re); 3622 } 3623 finally { 3624 exitRule(); 3625 } 3626 return _localctx; 3627 } 3628 3629 public static class Gl_molecularContext extends ParserRuleContext { 3630 public Gl_molecular_hgContext gl_molecular_hg() { 3631 return getRuleContext(Gl_molecular_hgContext.class,0); 3632 } 3633 public Gl_molecular_faContext gl_molecular_fa() { 3634 return getRuleContext(Gl_molecular_faContext.class,0); 3635 } 3636 public Headgroup_separatorContext headgroup_separator() { 3637 return getRuleContext(Headgroup_separatorContext.class,0); 3638 } 3639 public Gl_molecularContext(ParserRuleContext parent, int invokingState) { 3640 super(parent, invokingState); 3641 } 3642 @Override public int getRuleIndex() { return RULE_gl_molecular; } 3643 @Override 3644 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3645 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_molecular(this); 3646 else return visitor.visitChildren(this); 3647 } 3648 } 3649 3650 public final Gl_molecularContext gl_molecular() throws RecognitionException { 3651 Gl_molecularContext _localctx = new Gl_molecularContext(_ctx, getState()); 3652 enterRule(_localctx, 108, RULE_gl_molecular); 3653 try { 3654 setState(603); 3655 _errHandler.sync(this); 3656 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3657 case 1: 3658 enterOuterAlt(_localctx, 1); 3659 { 3660 setState(596); 3661 gl_molecular_hg(); 3662 setState(597); 3663 gl_molecular_fa(); 3664 } 3665 break; 3666 case 2: 3667 enterOuterAlt(_localctx, 2); 3668 { 3669 setState(599); 3670 gl_molecular_hg(); 3671 setState(600); 3672 headgroup_separator(); 3673 setState(601); 3674 gl_molecular_fa(); 3675 } 3676 break; 3677 } 3678 } 3679 catch (RecognitionException re) { 3680 _localctx.exception = re; 3681 _errHandler.reportError(this, re); 3682 _errHandler.recover(this, re); 3683 } 3684 finally { 3685 exitRule(); 3686 } 3687 return _localctx; 3688 } 3689 3690 public static class Gl_molecular_faContext extends ParserRuleContext { 3691 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 3692 public Fa2Context fa2() { 3693 return getRuleContext(Fa2Context.class,0); 3694 } 3695 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 3696 public Gl_molecular_faContext(ParserRuleContext parent, int invokingState) { 3697 super(parent, invokingState); 3698 } 3699 @Override public int getRuleIndex() { return RULE_gl_molecular_fa; } 3700 @Override 3701 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3702 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_molecular_fa(this); 3703 else return visitor.visitChildren(this); 3704 } 3705 } 3706 3707 public final Gl_molecular_faContext gl_molecular_fa() throws RecognitionException { 3708 Gl_molecular_faContext _localctx = new Gl_molecular_faContext(_ctx, getState()); 3709 enterRule(_localctx, 110, RULE_gl_molecular_fa); 3710 try { 3711 enterOuterAlt(_localctx, 1); 3712 { 3713 setState(605); 3714 match(ROB); 3715 setState(606); 3716 fa2(); 3717 setState(607); 3718 match(RCB); 3719 } 3720 } 3721 catch (RecognitionException re) { 3722 _localctx.exception = re; 3723 _errHandler.reportError(this, re); 3724 _errHandler.recover(this, re); 3725 } 3726 finally { 3727 exitRule(); 3728 } 3729 return _localctx; 3730 } 3731 3732 public static class Gl_molecular_hgContext extends ParserRuleContext { 3733 public Gl_molecular_hgContext(ParserRuleContext parent, int invokingState) { 3734 super(parent, invokingState); 3735 } 3736 @Override public int getRuleIndex() { return RULE_gl_molecular_hg; } 3737 @Override 3738 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3739 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_molecular_hg(this); 3740 else return visitor.visitChildren(this); 3741 } 3742 } 3743 3744 public final Gl_molecular_hgContext gl_molecular_hg() throws RecognitionException { 3745 Gl_molecular_hgContext _localctx = new Gl_molecular_hgContext(_ctx, getState()); 3746 enterRule(_localctx, 112, RULE_gl_molecular_hg); 3747 int _la; 3748 try { 3749 enterOuterAlt(_localctx, 1); 3750 { 3751 setState(609); 3752 _la = _input.LA(1); 3753 if ( !(_la==T__93 || _la==T__96) ) { 3754 _errHandler.recoverInline(this); 3755 } 3756 else { 3757 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3758 _errHandler.reportMatch(this); 3759 consume(); 3760 } 3761 } 3762 } 3763 catch (RecognitionException re) { 3764 _localctx.exception = re; 3765 _errHandler.reportError(this, re); 3766 _errHandler.recover(this, re); 3767 } 3768 finally { 3769 exitRule(); 3770 } 3771 return _localctx; 3772 } 3773 3774 public static class Gl_monoContext extends ParserRuleContext { 3775 public Gl_mono_hgContext gl_mono_hg() { 3776 return getRuleContext(Gl_mono_hgContext.class,0); 3777 } 3778 public Gl_mono_faContext gl_mono_fa() { 3779 return getRuleContext(Gl_mono_faContext.class,0); 3780 } 3781 public Headgroup_separatorContext headgroup_separator() { 3782 return getRuleContext(Headgroup_separatorContext.class,0); 3783 } 3784 public Gl_monoContext(ParserRuleContext parent, int invokingState) { 3785 super(parent, invokingState); 3786 } 3787 @Override public int getRuleIndex() { return RULE_gl_mono; } 3788 @Override 3789 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3790 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_mono(this); 3791 else return visitor.visitChildren(this); 3792 } 3793 } 3794 3795 public final Gl_monoContext gl_mono() throws RecognitionException { 3796 Gl_monoContext _localctx = new Gl_monoContext(_ctx, getState()); 3797 enterRule(_localctx, 114, RULE_gl_mono); 3798 try { 3799 setState(618); 3800 _errHandler.sync(this); 3801 switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) { 3802 case 1: 3803 enterOuterAlt(_localctx, 1); 3804 { 3805 setState(611); 3806 gl_mono_hg(); 3807 setState(612); 3808 gl_mono_fa(); 3809 } 3810 break; 3811 case 2: 3812 enterOuterAlt(_localctx, 2); 3813 { 3814 setState(614); 3815 gl_mono_hg(); 3816 setState(615); 3817 headgroup_separator(); 3818 setState(616); 3819 gl_mono_fa(); 3820 } 3821 break; 3822 } 3823 } 3824 catch (RecognitionException re) { 3825 _localctx.exception = re; 3826 _errHandler.reportError(this, re); 3827 _errHandler.recover(this, re); 3828 } 3829 finally { 3830 exitRule(); 3831 } 3832 return _localctx; 3833 } 3834 3835 public static class Gl_mono_faContext extends ParserRuleContext { 3836 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 3837 public Fa_speciesContext fa_species() { 3838 return getRuleContext(Fa_speciesContext.class,0); 3839 } 3840 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 3841 public Fa2Context fa2() { 3842 return getRuleContext(Fa2Context.class,0); 3843 } 3844 public Gl_mono_faContext(ParserRuleContext parent, int invokingState) { 3845 super(parent, invokingState); 3846 } 3847 @Override public int getRuleIndex() { return RULE_gl_mono_fa; } 3848 @Override 3849 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3850 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_mono_fa(this); 3851 else return visitor.visitChildren(this); 3852 } 3853 } 3854 3855 public final Gl_mono_faContext gl_mono_fa() throws RecognitionException { 3856 Gl_mono_faContext _localctx = new Gl_mono_faContext(_ctx, getState()); 3857 enterRule(_localctx, 116, RULE_gl_mono_fa); 3858 try { 3859 setState(628); 3860 _errHandler.sync(this); 3861 switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { 3862 case 1: 3863 enterOuterAlt(_localctx, 1); 3864 { 3865 setState(620); 3866 match(ROB); 3867 setState(621); 3868 fa_species(); 3869 setState(622); 3870 match(RCB); 3871 } 3872 break; 3873 case 2: 3874 enterOuterAlt(_localctx, 2); 3875 { 3876 setState(624); 3877 match(ROB); 3878 setState(625); 3879 fa2(); 3880 setState(626); 3881 match(RCB); 3882 } 3883 break; 3884 } 3885 } 3886 catch (RecognitionException re) { 3887 _localctx.exception = re; 3888 _errHandler.reportError(this, re); 3889 _errHandler.recover(this, re); 3890 } 3891 finally { 3892 exitRule(); 3893 } 3894 return _localctx; 3895 } 3896 3897 public static class Gl_mono_hgContext extends ParserRuleContext { 3898 public Gl_mono_hgContext(ParserRuleContext parent, int invokingState) { 3899 super(parent, invokingState); 3900 } 3901 @Override public int getRuleIndex() { return RULE_gl_mono_hg; } 3902 @Override 3903 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3904 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGl_mono_hg(this); 3905 else return visitor.visitChildren(this); 3906 } 3907 } 3908 3909 public final Gl_mono_hgContext gl_mono_hg() throws RecognitionException { 3910 Gl_mono_hgContext _localctx = new Gl_mono_hgContext(_ctx, getState()); 3911 enterRule(_localctx, 118, RULE_gl_mono_hg); 3912 int _la; 3913 try { 3914 enterOuterAlt(_localctx, 1); 3915 { 3916 setState(630); 3917 _la = _input.LA(1); 3918 if ( !(((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (T__98 - 99)) | (1L << (T__99 - 99)) | (1L << (T__100 - 99)) | (1L << (T__101 - 99)))) != 0)) ) { 3919 _errHandler.recoverInline(this); 3920 } 3921 else { 3922 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3923 _errHandler.reportMatch(this); 3924 consume(); 3925 } 3926 } 3927 } 3928 catch (RecognitionException re) { 3929 _localctx.exception = re; 3930 _errHandler.reportError(this, re); 3931 _errHandler.recover(this, re); 3932 } 3933 finally { 3934 exitRule(); 3935 } 3936 return _localctx; 3937 } 3938 3939 public static class PlContext extends ParserRuleContext { 3940 public Pl_regularContext pl_regular() { 3941 return getRuleContext(Pl_regularContext.class,0); 3942 } 3943 public Pl_threeContext pl_three() { 3944 return getRuleContext(Pl_threeContext.class,0); 3945 } 3946 public Pl_fourContext pl_four() { 3947 return getRuleContext(Pl_fourContext.class,0); 3948 } 3949 public PlContext(ParserRuleContext parent, int invokingState) { 3950 super(parent, invokingState); 3951 } 3952 @Override public int getRuleIndex() { return RULE_pl; } 3953 @Override 3954 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3955 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl(this); 3956 else return visitor.visitChildren(this); 3957 } 3958 } 3959 3960 public final PlContext pl() throws RecognitionException { 3961 PlContext _localctx = new PlContext(_ctx, getState()); 3962 enterRule(_localctx, 120, RULE_pl); 3963 try { 3964 setState(635); 3965 _errHandler.sync(this); 3966 switch (_input.LA(1)) { 3967 case T__102: 3968 case T__103: 3969 case T__104: 3970 case T__105: 3971 case T__106: 3972 case T__107: 3973 case T__108: 3974 case T__109: 3975 case T__110: 3976 case T__111: 3977 case T__112: 3978 case T__113: 3979 case T__114: 3980 case T__115: 3981 case T__116: 3982 case T__117: 3983 case T__118: 3984 case T__119: 3985 case T__120: 3986 case T__121: 3987 case T__122: 3988 case T__123: 3989 case T__124: 3990 case T__125: 3991 case T__126: 3992 case T__127: 3993 case T__128: 3994 case T__129: 3995 case T__130: 3996 case T__131: 3997 case T__132: 3998 case T__133: 3999 case T__134: 4000 enterOuterAlt(_localctx, 1); 4001 { 4002 setState(632); 4003 pl_regular(); 4004 } 4005 break; 4006 case T__135: 4007 enterOuterAlt(_localctx, 2); 4008 { 4009 setState(633); 4010 pl_three(); 4011 } 4012 break; 4013 case T__136: 4014 case T__137: 4015 case T__138: 4016 case T__139: 4017 case T__140: 4018 case T__141: 4019 enterOuterAlt(_localctx, 3); 4020 { 4021 setState(634); 4022 pl_four(); 4023 } 4024 break; 4025 default: 4026 throw new NoViableAltException(this); 4027 } 4028 } 4029 catch (RecognitionException re) { 4030 _localctx.exception = re; 4031 _errHandler.reportError(this, re); 4032 _errHandler.recover(this, re); 4033 } 4034 finally { 4035 exitRule(); 4036 } 4037 return _localctx; 4038 } 4039 4040 public static class Pl_regularContext extends ParserRuleContext { 4041 public Pl_hgContext pl_hg() { 4042 return getRuleContext(Pl_hgContext.class,0); 4043 } 4044 public Pl_faContext pl_fa() { 4045 return getRuleContext(Pl_faContext.class,0); 4046 } 4047 public Headgroup_separatorContext headgroup_separator() { 4048 return getRuleContext(Headgroup_separatorContext.class,0); 4049 } 4050 public Pl_regularContext(ParserRuleContext parent, int invokingState) { 4051 super(parent, invokingState); 4052 } 4053 @Override public int getRuleIndex() { return RULE_pl_regular; } 4054 @Override 4055 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4056 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_regular(this); 4057 else return visitor.visitChildren(this); 4058 } 4059 } 4060 4061 public final Pl_regularContext pl_regular() throws RecognitionException { 4062 Pl_regularContext _localctx = new Pl_regularContext(_ctx, getState()); 4063 enterRule(_localctx, 122, RULE_pl_regular); 4064 try { 4065 setState(644); 4066 _errHandler.sync(this); 4067 switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) { 4068 case 1: 4069 enterOuterAlt(_localctx, 1); 4070 { 4071 setState(637); 4072 pl_hg(); 4073 setState(638); 4074 pl_fa(); 4075 } 4076 break; 4077 case 2: 4078 enterOuterAlt(_localctx, 2); 4079 { 4080 setState(640); 4081 pl_hg(); 4082 setState(641); 4083 headgroup_separator(); 4084 setState(642); 4085 pl_fa(); 4086 } 4087 break; 4088 } 4089 } 4090 catch (RecognitionException re) { 4091 _localctx.exception = re; 4092 _errHandler.reportError(this, re); 4093 _errHandler.recover(this, re); 4094 } 4095 finally { 4096 exitRule(); 4097 } 4098 return _localctx; 4099 } 4100 4101 public static class Pl_faContext extends ParserRuleContext { 4102 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 4103 public Fa_speciesContext fa_species() { 4104 return getRuleContext(Fa_speciesContext.class,0); 4105 } 4106 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 4107 public Fa2Context fa2() { 4108 return getRuleContext(Fa2Context.class,0); 4109 } 4110 public Pl_faContext(ParserRuleContext parent, int invokingState) { 4111 super(parent, invokingState); 4112 } 4113 @Override public int getRuleIndex() { return RULE_pl_fa; } 4114 @Override 4115 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4116 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_fa(this); 4117 else return visitor.visitChildren(this); 4118 } 4119 } 4120 4121 public final Pl_faContext pl_fa() throws RecognitionException { 4122 Pl_faContext _localctx = new Pl_faContext(_ctx, getState()); 4123 enterRule(_localctx, 124, RULE_pl_fa); 4124 try { 4125 setState(654); 4126 _errHandler.sync(this); 4127 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 4128 case 1: 4129 enterOuterAlt(_localctx, 1); 4130 { 4131 setState(646); 4132 match(ROB); 4133 setState(647); 4134 fa_species(); 4135 setState(648); 4136 match(RCB); 4137 } 4138 break; 4139 case 2: 4140 enterOuterAlt(_localctx, 2); 4141 { 4142 setState(650); 4143 match(ROB); 4144 setState(651); 4145 fa2(); 4146 setState(652); 4147 match(RCB); 4148 } 4149 break; 4150 } 4151 } 4152 catch (RecognitionException re) { 4153 _localctx.exception = re; 4154 _errHandler.reportError(this, re); 4155 _errHandler.recover(this, re); 4156 } 4157 finally { 4158 exitRule(); 4159 } 4160 return _localctx; 4161 } 4162 4163 public static class Pl_hgContext extends ParserRuleContext { 4164 public Pl_hgContext(ParserRuleContext parent, int invokingState) { 4165 super(parent, invokingState); 4166 } 4167 @Override public int getRuleIndex() { return RULE_pl_hg; } 4168 @Override 4169 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4170 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_hg(this); 4171 else return visitor.visitChildren(this); 4172 } 4173 } 4174 4175 public final Pl_hgContext pl_hg() throws RecognitionException { 4176 Pl_hgContext _localctx = new Pl_hgContext(_ctx, getState()); 4177 enterRule(_localctx, 126, RULE_pl_hg); 4178 int _la; 4179 try { 4180 enterOuterAlt(_localctx, 1); 4181 { 4182 setState(656); 4183 _la = _input.LA(1); 4184 if ( !(((((_la - 103)) & ~0x3f) == 0 && ((1L << (_la - 103)) & ((1L << (T__102 - 103)) | (1L << (T__103 - 103)) | (1L << (T__104 - 103)) | (1L << (T__105 - 103)) | (1L << (T__106 - 103)) | (1L << (T__107 - 103)) | (1L << (T__108 - 103)) | (1L << (T__109 - 103)) | (1L << (T__110 - 103)) | (1L << (T__111 - 103)) | (1L << (T__112 - 103)) | (1L << (T__113 - 103)) | (1L << (T__114 - 103)) | (1L << (T__115 - 103)) | (1L << (T__116 - 103)) | (1L << (T__117 - 103)) | (1L << (T__118 - 103)) | (1L << (T__119 - 103)) | (1L << (T__120 - 103)) | (1L << (T__121 - 103)) | (1L << (T__122 - 103)) | (1L << (T__123 - 103)) | (1L << (T__124 - 103)) | (1L << (T__125 - 103)) | (1L << (T__126 - 103)) | (1L << (T__127 - 103)) | (1L << (T__128 - 103)) | (1L << (T__129 - 103)) | (1L << (T__130 - 103)) | (1L << (T__131 - 103)) | (1L << (T__132 - 103)) | (1L << (T__133 - 103)) | (1L << (T__134 - 103)))) != 0)) ) { 4185 _errHandler.recoverInline(this); 4186 } 4187 else { 4188 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4189 _errHandler.reportMatch(this); 4190 consume(); 4191 } 4192 } 4193 } 4194 catch (RecognitionException re) { 4195 _localctx.exception = re; 4196 _errHandler.reportError(this, re); 4197 _errHandler.recover(this, re); 4198 } 4199 finally { 4200 exitRule(); 4201 } 4202 return _localctx; 4203 } 4204 4205 public static class Pl_threeContext extends ParserRuleContext { 4206 public Pl_three_hgContext pl_three_hg() { 4207 return getRuleContext(Pl_three_hgContext.class,0); 4208 } 4209 public Pl_three_faContext pl_three_fa() { 4210 return getRuleContext(Pl_three_faContext.class,0); 4211 } 4212 public Headgroup_separatorContext headgroup_separator() { 4213 return getRuleContext(Headgroup_separatorContext.class,0); 4214 } 4215 public Pl_threeContext(ParserRuleContext parent, int invokingState) { 4216 super(parent, invokingState); 4217 } 4218 @Override public int getRuleIndex() { return RULE_pl_three; } 4219 @Override 4220 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4221 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_three(this); 4222 else return visitor.visitChildren(this); 4223 } 4224 } 4225 4226 public final Pl_threeContext pl_three() throws RecognitionException { 4227 Pl_threeContext _localctx = new Pl_threeContext(_ctx, getState()); 4228 enterRule(_localctx, 128, RULE_pl_three); 4229 try { 4230 setState(665); 4231 _errHandler.sync(this); 4232 switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { 4233 case 1: 4234 enterOuterAlt(_localctx, 1); 4235 { 4236 setState(658); 4237 pl_three_hg(); 4238 setState(659); 4239 pl_three_fa(); 4240 } 4241 break; 4242 case 2: 4243 enterOuterAlt(_localctx, 2); 4244 { 4245 setState(661); 4246 pl_three_hg(); 4247 setState(662); 4248 headgroup_separator(); 4249 setState(663); 4250 pl_three_fa(); 4251 } 4252 break; 4253 } 4254 } 4255 catch (RecognitionException re) { 4256 _localctx.exception = re; 4257 _errHandler.reportError(this, re); 4258 _errHandler.recover(this, re); 4259 } 4260 finally { 4261 exitRule(); 4262 } 4263 return _localctx; 4264 } 4265 4266 public static class Pl_three_faContext extends ParserRuleContext { 4267 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 4268 public Fa_speciesContext fa_species() { 4269 return getRuleContext(Fa_speciesContext.class,0); 4270 } 4271 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 4272 public Fa3Context fa3() { 4273 return getRuleContext(Fa3Context.class,0); 4274 } 4275 public Pl_three_faContext(ParserRuleContext parent, int invokingState) { 4276 super(parent, invokingState); 4277 } 4278 @Override public int getRuleIndex() { return RULE_pl_three_fa; } 4279 @Override 4280 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4281 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_three_fa(this); 4282 else return visitor.visitChildren(this); 4283 } 4284 } 4285 4286 public final Pl_three_faContext pl_three_fa() throws RecognitionException { 4287 Pl_three_faContext _localctx = new Pl_three_faContext(_ctx, getState()); 4288 enterRule(_localctx, 130, RULE_pl_three_fa); 4289 try { 4290 setState(675); 4291 _errHandler.sync(this); 4292 switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { 4293 case 1: 4294 enterOuterAlt(_localctx, 1); 4295 { 4296 setState(667); 4297 match(ROB); 4298 setState(668); 4299 fa_species(); 4300 setState(669); 4301 match(RCB); 4302 } 4303 break; 4304 case 2: 4305 enterOuterAlt(_localctx, 2); 4306 { 4307 setState(671); 4308 match(ROB); 4309 setState(672); 4310 fa3(); 4311 setState(673); 4312 match(RCB); 4313 } 4314 break; 4315 } 4316 } 4317 catch (RecognitionException re) { 4318 _localctx.exception = re; 4319 _errHandler.reportError(this, re); 4320 _errHandler.recover(this, re); 4321 } 4322 finally { 4323 exitRule(); 4324 } 4325 return _localctx; 4326 } 4327 4328 public static class Pl_three_hgContext extends ParserRuleContext { 4329 public Pl_three_hgContext(ParserRuleContext parent, int invokingState) { 4330 super(parent, invokingState); 4331 } 4332 @Override public int getRuleIndex() { return RULE_pl_three_hg; } 4333 @Override 4334 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4335 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_three_hg(this); 4336 else return visitor.visitChildren(this); 4337 } 4338 } 4339 4340 public final Pl_three_hgContext pl_three_hg() throws RecognitionException { 4341 Pl_three_hgContext _localctx = new Pl_three_hgContext(_ctx, getState()); 4342 enterRule(_localctx, 132, RULE_pl_three_hg); 4343 try { 4344 enterOuterAlt(_localctx, 1); 4345 { 4346 setState(677); 4347 match(T__135); 4348 } 4349 } 4350 catch (RecognitionException re) { 4351 _localctx.exception = re; 4352 _errHandler.reportError(this, re); 4353 _errHandler.recover(this, re); 4354 } 4355 finally { 4356 exitRule(); 4357 } 4358 return _localctx; 4359 } 4360 4361 public static class Pl_fourContext extends ParserRuleContext { 4362 public Pl_four_hgContext pl_four_hg() { 4363 return getRuleContext(Pl_four_hgContext.class,0); 4364 } 4365 public Pl_four_faContext pl_four_fa() { 4366 return getRuleContext(Pl_four_faContext.class,0); 4367 } 4368 public Headgroup_separatorContext headgroup_separator() { 4369 return getRuleContext(Headgroup_separatorContext.class,0); 4370 } 4371 public Pl_fourContext(ParserRuleContext parent, int invokingState) { 4372 super(parent, invokingState); 4373 } 4374 @Override public int getRuleIndex() { return RULE_pl_four; } 4375 @Override 4376 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4377 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_four(this); 4378 else return visitor.visitChildren(this); 4379 } 4380 } 4381 4382 public final Pl_fourContext pl_four() throws RecognitionException { 4383 Pl_fourContext _localctx = new Pl_fourContext(_ctx, getState()); 4384 enterRule(_localctx, 134, RULE_pl_four); 4385 try { 4386 setState(686); 4387 _errHandler.sync(this); 4388 switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { 4389 case 1: 4390 enterOuterAlt(_localctx, 1); 4391 { 4392 setState(679); 4393 pl_four_hg(); 4394 setState(680); 4395 pl_four_fa(); 4396 } 4397 break; 4398 case 2: 4399 enterOuterAlt(_localctx, 2); 4400 { 4401 setState(682); 4402 pl_four_hg(); 4403 setState(683); 4404 headgroup_separator(); 4405 setState(684); 4406 pl_four_fa(); 4407 } 4408 break; 4409 } 4410 } 4411 catch (RecognitionException re) { 4412 _localctx.exception = re; 4413 _errHandler.reportError(this, re); 4414 _errHandler.recover(this, re); 4415 } 4416 finally { 4417 exitRule(); 4418 } 4419 return _localctx; 4420 } 4421 4422 public static class Pl_four_faContext extends ParserRuleContext { 4423 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 4424 public Fa_speciesContext fa_species() { 4425 return getRuleContext(Fa_speciesContext.class,0); 4426 } 4427 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 4428 public Fa2Context fa2() { 4429 return getRuleContext(Fa2Context.class,0); 4430 } 4431 public Fa4Context fa4() { 4432 return getRuleContext(Fa4Context.class,0); 4433 } 4434 public Pl_four_faContext(ParserRuleContext parent, int invokingState) { 4435 super(parent, invokingState); 4436 } 4437 @Override public int getRuleIndex() { return RULE_pl_four_fa; } 4438 @Override 4439 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4440 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_four_fa(this); 4441 else return visitor.visitChildren(this); 4442 } 4443 } 4444 4445 public final Pl_four_faContext pl_four_fa() throws RecognitionException { 4446 Pl_four_faContext _localctx = new Pl_four_faContext(_ctx, getState()); 4447 enterRule(_localctx, 136, RULE_pl_four_fa); 4448 try { 4449 setState(700); 4450 _errHandler.sync(this); 4451 switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { 4452 case 1: 4453 enterOuterAlt(_localctx, 1); 4454 { 4455 setState(688); 4456 match(ROB); 4457 setState(689); 4458 fa_species(); 4459 setState(690); 4460 match(RCB); 4461 } 4462 break; 4463 case 2: 4464 enterOuterAlt(_localctx, 2); 4465 { 4466 setState(692); 4467 match(ROB); 4468 setState(693); 4469 fa2(); 4470 setState(694); 4471 match(RCB); 4472 } 4473 break; 4474 case 3: 4475 enterOuterAlt(_localctx, 3); 4476 { 4477 setState(696); 4478 match(ROB); 4479 setState(697); 4480 fa4(); 4481 setState(698); 4482 match(RCB); 4483 } 4484 break; 4485 } 4486 } 4487 catch (RecognitionException re) { 4488 _localctx.exception = re; 4489 _errHandler.reportError(this, re); 4490 _errHandler.recover(this, re); 4491 } 4492 finally { 4493 exitRule(); 4494 } 4495 return _localctx; 4496 } 4497 4498 public static class Pl_four_hgContext extends ParserRuleContext { 4499 public Pl_four_hgContext(ParserRuleContext parent, int invokingState) { 4500 super(parent, invokingState); 4501 } 4502 @Override public int getRuleIndex() { return RULE_pl_four_hg; } 4503 @Override 4504 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4505 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitPl_four_hg(this); 4506 else return visitor.visitChildren(this); 4507 } 4508 } 4509 4510 public final Pl_four_hgContext pl_four_hg() throws RecognitionException { 4511 Pl_four_hgContext _localctx = new Pl_four_hgContext(_ctx, getState()); 4512 enterRule(_localctx, 138, RULE_pl_four_hg); 4513 int _la; 4514 try { 4515 enterOuterAlt(_localctx, 1); 4516 { 4517 setState(702); 4518 _la = _input.LA(1); 4519 if ( !(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (T__136 - 137)) | (1L << (T__137 - 137)) | (1L << (T__138 - 137)) | (1L << (T__139 - 137)) | (1L << (T__140 - 137)) | (1L << (T__141 - 137)))) != 0)) ) { 4520 _errHandler.recoverInline(this); 4521 } 4522 else { 4523 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4524 _errHandler.reportMatch(this); 4525 consume(); 4526 } 4527 } 4528 } 4529 catch (RecognitionException re) { 4530 _localctx.exception = re; 4531 _errHandler.reportError(this, re); 4532 _errHandler.recover(this, re); 4533 } 4534 finally { 4535 exitRule(); 4536 } 4537 return _localctx; 4538 } 4539 4540 public static class SlContext extends ParserRuleContext { 4541 public Sl_hgContext sl_hg() { 4542 return getRuleContext(Sl_hgContext.class,0); 4543 } 4544 public Sl_lcbContext sl_lcb() { 4545 return getRuleContext(Sl_lcbContext.class,0); 4546 } 4547 public Headgroup_separatorContext headgroup_separator() { 4548 return getRuleContext(Headgroup_separatorContext.class,0); 4549 } 4550 public SlContext(ParserRuleContext parent, int invokingState) { 4551 super(parent, invokingState); 4552 } 4553 @Override public int getRuleIndex() { return RULE_sl; } 4554 @Override 4555 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4556 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl(this); 4557 else return visitor.visitChildren(this); 4558 } 4559 } 4560 4561 public final SlContext sl() throws RecognitionException { 4562 SlContext _localctx = new SlContext(_ctx, getState()); 4563 enterRule(_localctx, 140, RULE_sl); 4564 try { 4565 setState(711); 4566 _errHandler.sync(this); 4567 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4568 case 1: 4569 enterOuterAlt(_localctx, 1); 4570 { 4571 setState(704); 4572 sl_hg(); 4573 setState(705); 4574 sl_lcb(); 4575 } 4576 break; 4577 case 2: 4578 enterOuterAlt(_localctx, 2); 4579 { 4580 setState(707); 4581 sl_hg(); 4582 setState(708); 4583 headgroup_separator(); 4584 setState(709); 4585 sl_lcb(); 4586 } 4587 break; 4588 } 4589 } 4590 catch (RecognitionException re) { 4591 _localctx.exception = re; 4592 _errHandler.reportError(this, re); 4593 _errHandler.recover(this, re); 4594 } 4595 finally { 4596 exitRule(); 4597 } 4598 return _localctx; 4599 } 4600 4601 public static class Sl_hgContext extends ParserRuleContext { 4602 public Sl_hg_namesContext sl_hg_names() { 4603 return getRuleContext(Sl_hg_namesContext.class,0); 4604 } 4605 public Sl_hg_prefixContext sl_hg_prefix() { 4606 return getRuleContext(Sl_hg_prefixContext.class,0); 4607 } 4608 public Sl_hg_suffixContext sl_hg_suffix() { 4609 return getRuleContext(Sl_hg_suffixContext.class,0); 4610 } 4611 public Sl_hgContext(ParserRuleContext parent, int invokingState) { 4612 super(parent, invokingState); 4613 } 4614 @Override public int getRuleIndex() { return RULE_sl_hg; } 4615 @Override 4616 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4617 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl_hg(this); 4618 else return visitor.visitChildren(this); 4619 } 4620 } 4621 4622 public final Sl_hgContext sl_hg() throws RecognitionException { 4623 Sl_hgContext _localctx = new Sl_hgContext(_ctx, getState()); 4624 enterRule(_localctx, 142, RULE_sl_hg); 4625 try { 4626 setState(724); 4627 _errHandler.sync(this); 4628 switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { 4629 case 1: 4630 enterOuterAlt(_localctx, 1); 4631 { 4632 setState(713); 4633 sl_hg_names(); 4634 } 4635 break; 4636 case 2: 4637 enterOuterAlt(_localctx, 2); 4638 { 4639 setState(714); 4640 sl_hg_prefix(0); 4641 setState(715); 4642 sl_hg_names(); 4643 } 4644 break; 4645 case 3: 4646 enterOuterAlt(_localctx, 3); 4647 { 4648 setState(717); 4649 sl_hg_names(); 4650 setState(718); 4651 sl_hg_suffix(0); 4652 } 4653 break; 4654 case 4: 4655 enterOuterAlt(_localctx, 4); 4656 { 4657 setState(720); 4658 sl_hg_prefix(0); 4659 setState(721); 4660 sl_hg_names(); 4661 setState(722); 4662 sl_hg_suffix(0); 4663 } 4664 break; 4665 } 4666 } 4667 catch (RecognitionException re) { 4668 _localctx.exception = re; 4669 _errHandler.reportError(this, re); 4670 _errHandler.recover(this, re); 4671 } 4672 finally { 4673 exitRule(); 4674 } 4675 return _localctx; 4676 } 4677 4678 public static class Sl_hg_namesContext extends ParserRuleContext { 4679 public GangliosideContext ganglioside() { 4680 return getRuleContext(GangliosideContext.class,0); 4681 } 4682 public Sl_hg_namesContext(ParserRuleContext parent, int invokingState) { 4683 super(parent, invokingState); 4684 } 4685 @Override public int getRuleIndex() { return RULE_sl_hg_names; } 4686 @Override 4687 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4688 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl_hg_names(this); 4689 else return visitor.visitChildren(this); 4690 } 4691 } 4692 4693 public final Sl_hg_namesContext sl_hg_names() throws RecognitionException { 4694 Sl_hg_namesContext _localctx = new Sl_hg_namesContext(_ctx, getState()); 4695 enterRule(_localctx, 144, RULE_sl_hg_names); 4696 try { 4697 setState(757); 4698 _errHandler.sync(this); 4699 switch (_input.LA(1)) { 4700 case T__142: 4701 enterOuterAlt(_localctx, 1); 4702 { 4703 setState(726); 4704 match(T__142); 4705 } 4706 break; 4707 case T__143: 4708 enterOuterAlt(_localctx, 2); 4709 { 4710 setState(727); 4711 match(T__143); 4712 } 4713 break; 4714 case T__144: 4715 enterOuterAlt(_localctx, 3); 4716 { 4717 setState(728); 4718 match(T__144); 4719 } 4720 break; 4721 case T__145: 4722 enterOuterAlt(_localctx, 4); 4723 { 4724 setState(729); 4725 match(T__145); 4726 } 4727 break; 4728 case T__146: 4729 enterOuterAlt(_localctx, 5); 4730 { 4731 setState(730); 4732 match(T__146); 4733 } 4734 break; 4735 case T__147: 4736 enterOuterAlt(_localctx, 6); 4737 { 4738 setState(731); 4739 match(T__147); 4740 } 4741 break; 4742 case T__148: 4743 enterOuterAlt(_localctx, 7); 4744 { 4745 setState(732); 4746 match(T__148); 4747 } 4748 break; 4749 case T__149: 4750 enterOuterAlt(_localctx, 8); 4751 { 4752 setState(733); 4753 match(T__149); 4754 } 4755 break; 4756 case T__150: 4757 enterOuterAlt(_localctx, 9); 4758 { 4759 setState(734); 4760 match(T__150); 4761 } 4762 break; 4763 case T__151: 4764 enterOuterAlt(_localctx, 10); 4765 { 4766 setState(735); 4767 match(T__151); 4768 } 4769 break; 4770 case T__152: 4771 enterOuterAlt(_localctx, 11); 4772 { 4773 setState(736); 4774 match(T__152); 4775 } 4776 break; 4777 case T__153: 4778 enterOuterAlt(_localctx, 12); 4779 { 4780 setState(737); 4781 match(T__153); 4782 } 4783 break; 4784 case T__154: 4785 enterOuterAlt(_localctx, 13); 4786 { 4787 setState(738); 4788 match(T__154); 4789 } 4790 break; 4791 case T__155: 4792 enterOuterAlt(_localctx, 14); 4793 { 4794 setState(739); 4795 match(T__155); 4796 } 4797 break; 4798 case T__156: 4799 enterOuterAlt(_localctx, 15); 4800 { 4801 setState(740); 4802 match(T__156); 4803 } 4804 break; 4805 case T__157: 4806 enterOuterAlt(_localctx, 16); 4807 { 4808 setState(741); 4809 match(T__157); 4810 } 4811 break; 4812 case T__158: 4813 enterOuterAlt(_localctx, 17); 4814 { 4815 setState(742); 4816 match(T__158); 4817 } 4818 break; 4819 case T__159: 4820 enterOuterAlt(_localctx, 18); 4821 { 4822 setState(743); 4823 match(T__159); 4824 } 4825 break; 4826 case T__160: 4827 enterOuterAlt(_localctx, 19); 4828 { 4829 setState(744); 4830 match(T__160); 4831 } 4832 break; 4833 case T__161: 4834 enterOuterAlt(_localctx, 20); 4835 { 4836 setState(745); 4837 match(T__161); 4838 } 4839 break; 4840 case T__162: 4841 enterOuterAlt(_localctx, 21); 4842 { 4843 setState(746); 4844 match(T__162); 4845 } 4846 break; 4847 case T__163: 4848 enterOuterAlt(_localctx, 22); 4849 { 4850 setState(747); 4851 match(T__163); 4852 } 4853 break; 4854 case T__164: 4855 enterOuterAlt(_localctx, 23); 4856 { 4857 setState(748); 4858 match(T__164); 4859 } 4860 break; 4861 case T__165: 4862 enterOuterAlt(_localctx, 24); 4863 { 4864 setState(749); 4865 match(T__165); 4866 } 4867 break; 4868 case T__166: 4869 enterOuterAlt(_localctx, 25); 4870 { 4871 setState(750); 4872 match(T__166); 4873 } 4874 break; 4875 case T__167: 4876 enterOuterAlt(_localctx, 26); 4877 { 4878 setState(751); 4879 match(T__167); 4880 } 4881 break; 4882 case T__168: 4883 enterOuterAlt(_localctx, 27); 4884 { 4885 setState(752); 4886 match(T__168); 4887 } 4888 break; 4889 case T__169: 4890 enterOuterAlt(_localctx, 28); 4891 { 4892 setState(753); 4893 match(T__169); 4894 } 4895 break; 4896 case T__170: 4897 enterOuterAlt(_localctx, 29); 4898 { 4899 setState(754); 4900 match(T__170); 4901 } 4902 break; 4903 case T__171: 4904 enterOuterAlt(_localctx, 30); 4905 { 4906 setState(755); 4907 match(T__171); 4908 } 4909 break; 4910 case T__172: 4911 case T__173: 4912 case T__174: 4913 case T__175: 4914 case T__176: 4915 case T__177: 4916 case T__178: 4917 case T__179: 4918 case T__180: 4919 case T__181: 4920 case T__182: 4921 case T__183: 4922 case T__184: 4923 case T__185: 4924 case T__186: 4925 case T__187: 4926 case T__188: 4927 case T__189: 4928 case T__190: 4929 case T__191: 4930 case T__192: 4931 case T__193: 4932 case T__194: 4933 case T__195: 4934 case T__196: 4935 case T__197: 4936 enterOuterAlt(_localctx, 31); 4937 { 4938 setState(756); 4939 ganglioside(); 4940 } 4941 break; 4942 default: 4943 throw new NoViableAltException(this); 4944 } 4945 } 4946 catch (RecognitionException re) { 4947 _localctx.exception = re; 4948 _errHandler.reportError(this, re); 4949 _errHandler.recover(this, re); 4950 } 4951 finally { 4952 exitRule(); 4953 } 4954 return _localctx; 4955 } 4956 4957 public static class GangliosideContext extends ParserRuleContext { 4958 public Headgroup_separatorContext headgroup_separator() { 4959 return getRuleContext(Headgroup_separatorContext.class,0); 4960 } 4961 public Ganglioside_namesContext ganglioside_names() { 4962 return getRuleContext(Ganglioside_namesContext.class,0); 4963 } 4964 public GangliosideContext(ParserRuleContext parent, int invokingState) { 4965 super(parent, invokingState); 4966 } 4967 @Override public int getRuleIndex() { return RULE_ganglioside; } 4968 @Override 4969 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4970 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGanglioside(this); 4971 else return visitor.visitChildren(this); 4972 } 4973 } 4974 4975 public final GangliosideContext ganglioside() throws RecognitionException { 4976 GangliosideContext _localctx = new GangliosideContext(_ctx, getState()); 4977 enterRule(_localctx, 146, RULE_ganglioside); 4978 try { 4979 setState(764); 4980 _errHandler.sync(this); 4981 switch (_input.LA(1)) { 4982 case T__172: 4983 enterOuterAlt(_localctx, 1); 4984 { 4985 setState(759); 4986 match(T__172); 4987 setState(760); 4988 headgroup_separator(); 4989 setState(761); 4990 ganglioside_names(); 4991 } 4992 break; 4993 case T__173: 4994 case T__174: 4995 case T__175: 4996 case T__176: 4997 case T__177: 4998 case T__178: 4999 case T__179: 5000 case T__180: 5001 case T__181: 5002 case T__182: 5003 case T__183: 5004 case T__184: 5005 case T__185: 5006 case T__186: 5007 case T__187: 5008 case T__188: 5009 case T__189: 5010 case T__190: 5011 case T__191: 5012 case T__192: 5013 case T__193: 5014 case T__194: 5015 case T__195: 5016 case T__196: 5017 case T__197: 5018 enterOuterAlt(_localctx, 2); 5019 { 5020 setState(763); 5021 ganglioside_names(); 5022 } 5023 break; 5024 default: 5025 throw new NoViableAltException(this); 5026 } 5027 } 5028 catch (RecognitionException re) { 5029 _localctx.exception = re; 5030 _errHandler.reportError(this, re); 5031 _errHandler.recover(this, re); 5032 } 5033 finally { 5034 exitRule(); 5035 } 5036 return _localctx; 5037 } 5038 5039 public static class Ganglioside_namesContext extends ParserRuleContext { 5040 public Ganglioside_namesContext(ParserRuleContext parent, int invokingState) { 5041 super(parent, invokingState); 5042 } 5043 @Override public int getRuleIndex() { return RULE_ganglioside_names; } 5044 @Override 5045 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5046 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitGanglioside_names(this); 5047 else return visitor.visitChildren(this); 5048 } 5049 } 5050 5051 public final Ganglioside_namesContext ganglioside_names() throws RecognitionException { 5052 Ganglioside_namesContext _localctx = new Ganglioside_namesContext(_ctx, getState()); 5053 enterRule(_localctx, 148, RULE_ganglioside_names); 5054 int _la; 5055 try { 5056 enterOuterAlt(_localctx, 1); 5057 { 5058 setState(766); 5059 _la = _input.LA(1); 5060 if ( !(((((_la - 174)) & ~0x3f) == 0 && ((1L << (_la - 174)) & ((1L << (T__173 - 174)) | (1L << (T__174 - 174)) | (1L << (T__175 - 174)) | (1L << (T__176 - 174)) | (1L << (T__177 - 174)) | (1L << (T__178 - 174)) | (1L << (T__179 - 174)) | (1L << (T__180 - 174)) | (1L << (T__181 - 174)) | (1L << (T__182 - 174)) | (1L << (T__183 - 174)) | (1L << (T__184 - 174)) | (1L << (T__185 - 174)) | (1L << (T__186 - 174)) | (1L << (T__187 - 174)) | (1L << (T__188 - 174)) | (1L << (T__189 - 174)) | (1L << (T__190 - 174)) | (1L << (T__191 - 174)) | (1L << (T__192 - 174)) | (1L << (T__193 - 174)) | (1L << (T__194 - 174)) | (1L << (T__195 - 174)) | (1L << (T__196 - 174)) | (1L << (T__197 - 174)))) != 0)) ) { 5061 _errHandler.recoverInline(this); 5062 } 5063 else { 5064 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5065 _errHandler.reportMatch(this); 5066 consume(); 5067 } 5068 } 5069 } 5070 catch (RecognitionException re) { 5071 _localctx.exception = re; 5072 _errHandler.reportError(this, re); 5073 _errHandler.recover(this, re); 5074 } 5075 finally { 5076 exitRule(); 5077 } 5078 return _localctx; 5079 } 5080 5081 public static class Sl_hg_prefixContext extends ParserRuleContext { 5082 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 5083 public List<Sl_hg_prefixContext> sl_hg_prefix() { 5084 return getRuleContexts(Sl_hg_prefixContext.class); 5085 } 5086 public Sl_hg_prefixContext sl_hg_prefix(int i) { 5087 return getRuleContext(Sl_hg_prefixContext.class,i); 5088 } 5089 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 5090 public TerminalNode DASH() { return getToken(HMDBParser.DASH, 0); } 5091 public Sl_hg_prefixContext(ParserRuleContext parent, int invokingState) { 5092 super(parent, invokingState); 5093 } 5094 @Override public int getRuleIndex() { return RULE_sl_hg_prefix; } 5095 @Override 5096 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5097 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl_hg_prefix(this); 5098 else return visitor.visitChildren(this); 5099 } 5100 } 5101 5102 public final Sl_hg_prefixContext sl_hg_prefix() throws RecognitionException { 5103 return sl_hg_prefix(0); 5104 } 5105 5106 private Sl_hg_prefixContext sl_hg_prefix(int _p) throws RecognitionException { 5107 ParserRuleContext _parentctx = _ctx; 5108 int _parentState = getState(); 5109 Sl_hg_prefixContext _localctx = new Sl_hg_prefixContext(_ctx, _parentState); 5110 Sl_hg_prefixContext _prevctx = _localctx; 5111 int _startState = 150; 5112 enterRecursionRule(_localctx, 150, RULE_sl_hg_prefix, _p); 5113 try { 5114 int _alt; 5115 enterOuterAlt(_localctx, 1); 5116 { 5117 setState(789); 5118 _errHandler.sync(this); 5119 switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) { 5120 case 1: 5121 { 5122 setState(769); 5123 match(ROB); 5124 setState(770); 5125 sl_hg_prefix(0); 5126 setState(771); 5127 match(RCB); 5128 } 5129 break; 5130 case 2: 5131 { 5132 setState(773); 5133 match(T__198); 5134 } 5135 break; 5136 case 3: 5137 { 5138 setState(774); 5139 match(T__199); 5140 } 5141 break; 5142 case 4: 5143 { 5144 setState(775); 5145 match(T__200); 5146 } 5147 break; 5148 case 5: 5149 { 5150 setState(776); 5151 match(T__201); 5152 } 5153 break; 5154 case 6: 5155 { 5156 setState(777); 5157 match(T__202); 5158 } 5159 break; 5160 case 7: 5161 { 5162 setState(778); 5163 match(T__203); 5164 } 5165 break; 5166 case 8: 5167 { 5168 setState(779); 5169 match(T__204); 5170 } 5171 break; 5172 case 9: 5173 { 5174 setState(780); 5175 match(T__205); 5176 } 5177 break; 5178 case 10: 5179 { 5180 setState(781); 5181 match(T__206); 5182 } 5183 break; 5184 case 11: 5185 { 5186 setState(782); 5187 match(T__207); 5188 } 5189 break; 5190 case 12: 5191 { 5192 setState(783); 5193 match(T__208); 5194 } 5195 break; 5196 case 13: 5197 { 5198 setState(784); 5199 match(T__209); 5200 } 5201 break; 5202 case 14: 5203 { 5204 setState(785); 5205 match(T__210); 5206 } 5207 break; 5208 case 15: 5209 { 5210 setState(786); 5211 match(T__211); 5212 } 5213 break; 5214 case 16: 5215 { 5216 setState(787); 5217 match(T__205); 5218 } 5219 break; 5220 case 17: 5221 { 5222 setState(788); 5223 match(T__212); 5224 } 5225 break; 5226 } 5227 _ctx.stop = _input.LT(-1); 5228 setState(797); 5229 _errHandler.sync(this); 5230 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5231 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5232 if ( _alt==1 ) { 5233 if ( _parseListeners!=null ) triggerExitRuleEvent(); 5234 _prevctx = _localctx; 5235 { 5236 setState(795); 5237 _errHandler.sync(this); 5238 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5239 case 1: 5240 { 5241 _localctx = new Sl_hg_prefixContext(_parentctx, _parentState); 5242 pushNewRecursionContext(_localctx, _startState, RULE_sl_hg_prefix); 5243 setState(791); 5244 if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); 5245 setState(792); 5246 sl_hg_prefix(19); 5247 } 5248 break; 5249 case 2: 5250 { 5251 _localctx = new Sl_hg_prefixContext(_parentctx, _parentState); 5252 pushNewRecursionContext(_localctx, _startState, RULE_sl_hg_prefix); 5253 setState(793); 5254 if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); 5255 setState(794); 5256 match(DASH); 5257 } 5258 break; 5259 } 5260 } 5261 } 5262 setState(799); 5263 _errHandler.sync(this); 5264 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5265 } 5266 } 5267 } 5268 catch (RecognitionException re) { 5269 _localctx.exception = re; 5270 _errHandler.reportError(this, re); 5271 _errHandler.recover(this, re); 5272 } 5273 finally { 5274 unrollRecursionContexts(_parentctx); 5275 } 5276 return _localctx; 5277 } 5278 5279 public static class Sl_hg_suffixContext extends ParserRuleContext { 5280 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 5281 public List<Sl_hg_suffixContext> sl_hg_suffix() { 5282 return getRuleContexts(Sl_hg_suffixContext.class); 5283 } 5284 public Sl_hg_suffixContext sl_hg_suffix(int i) { 5285 return getRuleContext(Sl_hg_suffixContext.class,i); 5286 } 5287 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 5288 public TerminalNode SLASH() { return getToken(HMDBParser.SLASH, 0); } 5289 public Sl_hg_suffixContext(ParserRuleContext parent, int invokingState) { 5290 super(parent, invokingState); 5291 } 5292 @Override public int getRuleIndex() { return RULE_sl_hg_suffix; } 5293 @Override 5294 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5295 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl_hg_suffix(this); 5296 else return visitor.visitChildren(this); 5297 } 5298 } 5299 5300 public final Sl_hg_suffixContext sl_hg_suffix() throws RecognitionException { 5301 return sl_hg_suffix(0); 5302 } 5303 5304 private Sl_hg_suffixContext sl_hg_suffix(int _p) throws RecognitionException { 5305 ParserRuleContext _parentctx = _ctx; 5306 int _parentState = getState(); 5307 Sl_hg_suffixContext _localctx = new Sl_hg_suffixContext(_ctx, _parentState); 5308 Sl_hg_suffixContext _prevctx = _localctx; 5309 int _startState = 152; 5310 enterRecursionRule(_localctx, 152, RULE_sl_hg_suffix, _p); 5311 try { 5312 int _alt; 5313 enterOuterAlt(_localctx, 1); 5314 { 5315 setState(808); 5316 _errHandler.sync(this); 5317 switch (_input.LA(1)) { 5318 case ROB: 5319 { 5320 setState(801); 5321 match(ROB); 5322 setState(802); 5323 sl_hg_suffix(0); 5324 setState(803); 5325 match(RCB); 5326 } 5327 break; 5328 case T__205: 5329 { 5330 setState(805); 5331 match(T__205); 5332 } 5333 break; 5334 case T__203: 5335 { 5336 setState(806); 5337 match(T__203); 5338 } 5339 break; 5340 case T__213: 5341 { 5342 setState(807); 5343 match(T__213); 5344 } 5345 break; 5346 default: 5347 throw new NoViableAltException(this); 5348 } 5349 _ctx.stop = _input.LT(-1); 5350 setState(816); 5351 _errHandler.sync(this); 5352 _alt = getInterpreter().adaptivePredict(_input,49,_ctx); 5353 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5354 if ( _alt==1 ) { 5355 if ( _parseListeners!=null ) triggerExitRuleEvent(); 5356 _prevctx = _localctx; 5357 { 5358 setState(814); 5359 _errHandler.sync(this); 5360 switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { 5361 case 1: 5362 { 5363 _localctx = new Sl_hg_suffixContext(_parentctx, _parentState); 5364 pushNewRecursionContext(_localctx, _startState, RULE_sl_hg_suffix); 5365 setState(810); 5366 if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); 5367 setState(811); 5368 sl_hg_suffix(7); 5369 } 5370 break; 5371 case 2: 5372 { 5373 _localctx = new Sl_hg_suffixContext(_parentctx, _parentState); 5374 pushNewRecursionContext(_localctx, _startState, RULE_sl_hg_suffix); 5375 setState(812); 5376 if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); 5377 setState(813); 5378 match(SLASH); 5379 } 5380 break; 5381 } 5382 } 5383 } 5384 setState(818); 5385 _errHandler.sync(this); 5386 _alt = getInterpreter().adaptivePredict(_input,49,_ctx); 5387 } 5388 } 5389 } 5390 catch (RecognitionException re) { 5391 _localctx.exception = re; 5392 _errHandler.reportError(this, re); 5393 _errHandler.recover(this, re); 5394 } 5395 finally { 5396 unrollRecursionContexts(_parentctx); 5397 } 5398 return _localctx; 5399 } 5400 5401 public static class Sl_lcbContext extends ParserRuleContext { 5402 public Sl_lcb_speciesContext sl_lcb_species() { 5403 return getRuleContext(Sl_lcb_speciesContext.class,0); 5404 } 5405 public Sl_lcb_subspeciesContext sl_lcb_subspecies() { 5406 return getRuleContext(Sl_lcb_subspeciesContext.class,0); 5407 } 5408 public Sl_lcbContext(ParserRuleContext parent, int invokingState) { 5409 super(parent, invokingState); 5410 } 5411 @Override public int getRuleIndex() { return RULE_sl_lcb; } 5412 @Override 5413 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5414 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl_lcb(this); 5415 else return visitor.visitChildren(this); 5416 } 5417 } 5418 5419 public final Sl_lcbContext sl_lcb() throws RecognitionException { 5420 Sl_lcbContext _localctx = new Sl_lcbContext(_ctx, getState()); 5421 enterRule(_localctx, 154, RULE_sl_lcb); 5422 try { 5423 setState(821); 5424 _errHandler.sync(this); 5425 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 5426 case 1: 5427 enterOuterAlt(_localctx, 1); 5428 { 5429 setState(819); 5430 sl_lcb_species(); 5431 } 5432 break; 5433 case 2: 5434 enterOuterAlt(_localctx, 2); 5435 { 5436 setState(820); 5437 sl_lcb_subspecies(); 5438 } 5439 break; 5440 } 5441 } 5442 catch (RecognitionException re) { 5443 _localctx.exception = re; 5444 _errHandler.reportError(this, re); 5445 _errHandler.recover(this, re); 5446 } 5447 finally { 5448 exitRule(); 5449 } 5450 return _localctx; 5451 } 5452 5453 public static class Sl_lcb_speciesContext extends ParserRuleContext { 5454 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 5455 public LcbContext lcb() { 5456 return getRuleContext(LcbContext.class,0); 5457 } 5458 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 5459 public Sl_lcb_speciesContext(ParserRuleContext parent, int invokingState) { 5460 super(parent, invokingState); 5461 } 5462 @Override public int getRuleIndex() { return RULE_sl_lcb_species; } 5463 @Override 5464 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5465 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl_lcb_species(this); 5466 else return visitor.visitChildren(this); 5467 } 5468 } 5469 5470 public final Sl_lcb_speciesContext sl_lcb_species() throws RecognitionException { 5471 Sl_lcb_speciesContext _localctx = new Sl_lcb_speciesContext(_ctx, getState()); 5472 enterRule(_localctx, 156, RULE_sl_lcb_species); 5473 try { 5474 enterOuterAlt(_localctx, 1); 5475 { 5476 setState(823); 5477 match(ROB); 5478 setState(824); 5479 lcb(); 5480 setState(825); 5481 match(RCB); 5482 } 5483 } 5484 catch (RecognitionException re) { 5485 _localctx.exception = re; 5486 _errHandler.reportError(this, re); 5487 _errHandler.recover(this, re); 5488 } 5489 finally { 5490 exitRule(); 5491 } 5492 return _localctx; 5493 } 5494 5495 public static class Sl_lcb_subspeciesContext extends ParserRuleContext { 5496 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 5497 public LcbContext lcb() { 5498 return getRuleContext(LcbContext.class,0); 5499 } 5500 public Sorted_fa_separatorContext sorted_fa_separator() { 5501 return getRuleContext(Sorted_fa_separatorContext.class,0); 5502 } 5503 public FaContext fa() { 5504 return getRuleContext(FaContext.class,0); 5505 } 5506 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 5507 public Sl_lcb_subspeciesContext(ParserRuleContext parent, int invokingState) { 5508 super(parent, invokingState); 5509 } 5510 @Override public int getRuleIndex() { return RULE_sl_lcb_subspecies; } 5511 @Override 5512 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5513 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSl_lcb_subspecies(this); 5514 else return visitor.visitChildren(this); 5515 } 5516 } 5517 5518 public final Sl_lcb_subspeciesContext sl_lcb_subspecies() throws RecognitionException { 5519 Sl_lcb_subspeciesContext _localctx = new Sl_lcb_subspeciesContext(_ctx, getState()); 5520 enterRule(_localctx, 158, RULE_sl_lcb_subspecies); 5521 try { 5522 enterOuterAlt(_localctx, 1); 5523 { 5524 setState(827); 5525 match(ROB); 5526 setState(828); 5527 lcb(); 5528 setState(829); 5529 sorted_fa_separator(); 5530 setState(830); 5531 fa(); 5532 setState(831); 5533 match(RCB); 5534 } 5535 } 5536 catch (RecognitionException re) { 5537 _localctx.exception = re; 5538 _errHandler.reportError(this, re); 5539 _errHandler.recover(this, re); 5540 } 5541 finally { 5542 exitRule(); 5543 } 5544 return _localctx; 5545 } 5546 5547 public static class StContext extends ParserRuleContext { 5548 public St_speciesContext st_species() { 5549 return getRuleContext(St_speciesContext.class,0); 5550 } 5551 public St_sub1Context st_sub1() { 5552 return getRuleContext(St_sub1Context.class,0); 5553 } 5554 public St_sub2Context st_sub2() { 5555 return getRuleContext(St_sub2Context.class,0); 5556 } 5557 public StContext(ParserRuleContext parent, int invokingState) { 5558 super(parent, invokingState); 5559 } 5560 @Override public int getRuleIndex() { return RULE_st; } 5561 @Override 5562 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5563 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt(this); 5564 else return visitor.visitChildren(this); 5565 } 5566 } 5567 5568 public final StContext st() throws RecognitionException { 5569 StContext _localctx = new StContext(_ctx, getState()); 5570 enterRule(_localctx, 160, RULE_st); 5571 try { 5572 setState(836); 5573 _errHandler.sync(this); 5574 switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) { 5575 case 1: 5576 enterOuterAlt(_localctx, 1); 5577 { 5578 setState(833); 5579 st_species(); 5580 } 5581 break; 5582 case 2: 5583 enterOuterAlt(_localctx, 2); 5584 { 5585 setState(834); 5586 st_sub1(); 5587 } 5588 break; 5589 case 3: 5590 enterOuterAlt(_localctx, 3); 5591 { 5592 setState(835); 5593 st_sub2(); 5594 } 5595 break; 5596 } 5597 } 5598 catch (RecognitionException re) { 5599 _localctx.exception = re; 5600 _errHandler.reportError(this, re); 5601 _errHandler.recover(this, re); 5602 } 5603 finally { 5604 exitRule(); 5605 } 5606 return _localctx; 5607 } 5608 5609 public static class St_speciesContext extends ParserRuleContext { 5610 public St_species_hgContext st_species_hg() { 5611 return getRuleContext(St_species_hgContext.class,0); 5612 } 5613 public St_species_faContext st_species_fa() { 5614 return getRuleContext(St_species_faContext.class,0); 5615 } 5616 public Headgroup_separatorContext headgroup_separator() { 5617 return getRuleContext(Headgroup_separatorContext.class,0); 5618 } 5619 public St_speciesContext(ParserRuleContext parent, int invokingState) { 5620 super(parent, invokingState); 5621 } 5622 @Override public int getRuleIndex() { return RULE_st_species; } 5623 @Override 5624 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5625 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_species(this); 5626 else return visitor.visitChildren(this); 5627 } 5628 } 5629 5630 public final St_speciesContext st_species() throws RecognitionException { 5631 St_speciesContext _localctx = new St_speciesContext(_ctx, getState()); 5632 enterRule(_localctx, 162, RULE_st_species); 5633 try { 5634 setState(845); 5635 _errHandler.sync(this); 5636 switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { 5637 case 1: 5638 enterOuterAlt(_localctx, 1); 5639 { 5640 setState(838); 5641 st_species_hg(); 5642 setState(839); 5643 st_species_fa(); 5644 } 5645 break; 5646 case 2: 5647 enterOuterAlt(_localctx, 2); 5648 { 5649 setState(841); 5650 st_species_hg(); 5651 setState(842); 5652 headgroup_separator(); 5653 setState(843); 5654 st_species_fa(); 5655 } 5656 break; 5657 } 5658 } 5659 catch (RecognitionException re) { 5660 _localctx.exception = re; 5661 _errHandler.reportError(this, re); 5662 _errHandler.recover(this, re); 5663 } 5664 finally { 5665 exitRule(); 5666 } 5667 return _localctx; 5668 } 5669 5670 public static class St_species_hgContext extends ParserRuleContext { 5671 public St_species_hgContext(ParserRuleContext parent, int invokingState) { 5672 super(parent, invokingState); 5673 } 5674 @Override public int getRuleIndex() { return RULE_st_species_hg; } 5675 @Override 5676 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5677 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_species_hg(this); 5678 else return visitor.visitChildren(this); 5679 } 5680 } 5681 5682 public final St_species_hgContext st_species_hg() throws RecognitionException { 5683 St_species_hgContext _localctx = new St_species_hgContext(_ctx, getState()); 5684 enterRule(_localctx, 164, RULE_st_species_hg); 5685 try { 5686 enterOuterAlt(_localctx, 1); 5687 { 5688 setState(847); 5689 match(T__214); 5690 } 5691 } 5692 catch (RecognitionException re) { 5693 _localctx.exception = re; 5694 _errHandler.reportError(this, re); 5695 _errHandler.recover(this, re); 5696 } 5697 finally { 5698 exitRule(); 5699 } 5700 return _localctx; 5701 } 5702 5703 public static class St_species_faContext extends ParserRuleContext { 5704 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 5705 public Fa_speciesContext fa_species() { 5706 return getRuleContext(Fa_speciesContext.class,0); 5707 } 5708 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 5709 public St_species_faContext(ParserRuleContext parent, int invokingState) { 5710 super(parent, invokingState); 5711 } 5712 @Override public int getRuleIndex() { return RULE_st_species_fa; } 5713 @Override 5714 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5715 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_species_fa(this); 5716 else return visitor.visitChildren(this); 5717 } 5718 } 5719 5720 public final St_species_faContext st_species_fa() throws RecognitionException { 5721 St_species_faContext _localctx = new St_species_faContext(_ctx, getState()); 5722 enterRule(_localctx, 166, RULE_st_species_fa); 5723 try { 5724 enterOuterAlt(_localctx, 1); 5725 { 5726 setState(849); 5727 match(ROB); 5728 setState(850); 5729 fa_species(); 5730 setState(851); 5731 match(RCB); 5732 } 5733 } 5734 catch (RecognitionException re) { 5735 _localctx.exception = re; 5736 _errHandler.reportError(this, re); 5737 _errHandler.recover(this, re); 5738 } 5739 finally { 5740 exitRule(); 5741 } 5742 return _localctx; 5743 } 5744 5745 public static class St_sub1Context extends ParserRuleContext { 5746 public St_sub1_hgContext st_sub1_hg() { 5747 return getRuleContext(St_sub1_hgContext.class,0); 5748 } 5749 public St_sub1_faContext st_sub1_fa() { 5750 return getRuleContext(St_sub1_faContext.class,0); 5751 } 5752 public Headgroup_separatorContext headgroup_separator() { 5753 return getRuleContext(Headgroup_separatorContext.class,0); 5754 } 5755 public St_sub1Context(ParserRuleContext parent, int invokingState) { 5756 super(parent, invokingState); 5757 } 5758 @Override public int getRuleIndex() { return RULE_st_sub1; } 5759 @Override 5760 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5761 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_sub1(this); 5762 else return visitor.visitChildren(this); 5763 } 5764 } 5765 5766 public final St_sub1Context st_sub1() throws RecognitionException { 5767 St_sub1Context _localctx = new St_sub1Context(_ctx, getState()); 5768 enterRule(_localctx, 168, RULE_st_sub1); 5769 try { 5770 setState(860); 5771 _errHandler.sync(this); 5772 switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) { 5773 case 1: 5774 enterOuterAlt(_localctx, 1); 5775 { 5776 setState(853); 5777 st_sub1_hg(); 5778 setState(854); 5779 st_sub1_fa(); 5780 } 5781 break; 5782 case 2: 5783 enterOuterAlt(_localctx, 2); 5784 { 5785 setState(856); 5786 st_sub1_hg(); 5787 setState(857); 5788 headgroup_separator(); 5789 setState(858); 5790 st_sub1_fa(); 5791 } 5792 break; 5793 } 5794 } 5795 catch (RecognitionException re) { 5796 _localctx.exception = re; 5797 _errHandler.reportError(this, re); 5798 _errHandler.recover(this, re); 5799 } 5800 finally { 5801 exitRule(); 5802 } 5803 return _localctx; 5804 } 5805 5806 public static class St_sub1_hgContext extends ParserRuleContext { 5807 public St_sub1_hgContext(ParserRuleContext parent, int invokingState) { 5808 super(parent, invokingState); 5809 } 5810 @Override public int getRuleIndex() { return RULE_st_sub1_hg; } 5811 @Override 5812 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5813 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_sub1_hg(this); 5814 else return visitor.visitChildren(this); 5815 } 5816 } 5817 5818 public final St_sub1_hgContext st_sub1_hg() throws RecognitionException { 5819 St_sub1_hgContext _localctx = new St_sub1_hgContext(_ctx, getState()); 5820 enterRule(_localctx, 170, RULE_st_sub1_hg); 5821 try { 5822 enterOuterAlt(_localctx, 1); 5823 { 5824 setState(862); 5825 match(T__215); 5826 } 5827 } 5828 catch (RecognitionException re) { 5829 _localctx.exception = re; 5830 _errHandler.reportError(this, re); 5831 _errHandler.recover(this, re); 5832 } 5833 finally { 5834 exitRule(); 5835 } 5836 return _localctx; 5837 } 5838 5839 public static class St_sub1_faContext extends ParserRuleContext { 5840 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 5841 public FaContext fa() { 5842 return getRuleContext(FaContext.class,0); 5843 } 5844 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 5845 public St_sub1_faContext(ParserRuleContext parent, int invokingState) { 5846 super(parent, invokingState); 5847 } 5848 @Override public int getRuleIndex() { return RULE_st_sub1_fa; } 5849 @Override 5850 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5851 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_sub1_fa(this); 5852 else return visitor.visitChildren(this); 5853 } 5854 } 5855 5856 public final St_sub1_faContext st_sub1_fa() throws RecognitionException { 5857 St_sub1_faContext _localctx = new St_sub1_faContext(_ctx, getState()); 5858 enterRule(_localctx, 172, RULE_st_sub1_fa); 5859 try { 5860 enterOuterAlt(_localctx, 1); 5861 { 5862 setState(864); 5863 match(ROB); 5864 setState(865); 5865 fa(); 5866 setState(866); 5867 match(RCB); 5868 } 5869 } 5870 catch (RecognitionException re) { 5871 _localctx.exception = re; 5872 _errHandler.reportError(this, re); 5873 _errHandler.recover(this, re); 5874 } 5875 finally { 5876 exitRule(); 5877 } 5878 return _localctx; 5879 } 5880 5881 public static class St_sub2Context extends ParserRuleContext { 5882 public St_sub2_hgContext st_sub2_hg() { 5883 return getRuleContext(St_sub2_hgContext.class,0); 5884 } 5885 public St_sub2_faContext st_sub2_fa() { 5886 return getRuleContext(St_sub2_faContext.class,0); 5887 } 5888 public Headgroup_separatorContext headgroup_separator() { 5889 return getRuleContext(Headgroup_separatorContext.class,0); 5890 } 5891 public St_sub2Context(ParserRuleContext parent, int invokingState) { 5892 super(parent, invokingState); 5893 } 5894 @Override public int getRuleIndex() { return RULE_st_sub2; } 5895 @Override 5896 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5897 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_sub2(this); 5898 else return visitor.visitChildren(this); 5899 } 5900 } 5901 5902 public final St_sub2Context st_sub2() throws RecognitionException { 5903 St_sub2Context _localctx = new St_sub2Context(_ctx, getState()); 5904 enterRule(_localctx, 174, RULE_st_sub2); 5905 try { 5906 setState(875); 5907 _errHandler.sync(this); 5908 switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { 5909 case 1: 5910 enterOuterAlt(_localctx, 1); 5911 { 5912 setState(868); 5913 st_sub2_hg(); 5914 setState(869); 5915 st_sub2_fa(); 5916 } 5917 break; 5918 case 2: 5919 enterOuterAlt(_localctx, 2); 5920 { 5921 setState(871); 5922 st_sub2_hg(); 5923 setState(872); 5924 headgroup_separator(); 5925 setState(873); 5926 st_sub2_fa(); 5927 } 5928 break; 5929 } 5930 } 5931 catch (RecognitionException re) { 5932 _localctx.exception = re; 5933 _errHandler.reportError(this, re); 5934 _errHandler.recover(this, re); 5935 } 5936 finally { 5937 exitRule(); 5938 } 5939 return _localctx; 5940 } 5941 5942 public static class St_sub2_hgContext extends ParserRuleContext { 5943 public St_sub2_hgContext(ParserRuleContext parent, int invokingState) { 5944 super(parent, invokingState); 5945 } 5946 @Override public int getRuleIndex() { return RULE_st_sub2_hg; } 5947 @Override 5948 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5949 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_sub2_hg(this); 5950 else return visitor.visitChildren(this); 5951 } 5952 } 5953 5954 public final St_sub2_hgContext st_sub2_hg() throws RecognitionException { 5955 St_sub2_hgContext _localctx = new St_sub2_hgContext(_ctx, getState()); 5956 enterRule(_localctx, 176, RULE_st_sub2_hg); 5957 try { 5958 enterOuterAlt(_localctx, 1); 5959 { 5960 setState(877); 5961 match(T__214); 5962 } 5963 } 5964 catch (RecognitionException re) { 5965 _localctx.exception = re; 5966 _errHandler.reportError(this, re); 5967 _errHandler.recover(this, re); 5968 } 5969 finally { 5970 exitRule(); 5971 } 5972 return _localctx; 5973 } 5974 5975 public static class St_sub2_faContext extends ParserRuleContext { 5976 public TerminalNode ROB() { return getToken(HMDBParser.ROB, 0); } 5977 public Fa2Context fa2() { 5978 return getRuleContext(Fa2Context.class,0); 5979 } 5980 public TerminalNode RCB() { return getToken(HMDBParser.RCB, 0); } 5981 public St_sub2_faContext(ParserRuleContext parent, int invokingState) { 5982 super(parent, invokingState); 5983 } 5984 @Override public int getRuleIndex() { return RULE_st_sub2_fa; } 5985 @Override 5986 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5987 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSt_sub2_fa(this); 5988 else return visitor.visitChildren(this); 5989 } 5990 } 5991 5992 public final St_sub2_faContext st_sub2_fa() throws RecognitionException { 5993 St_sub2_faContext _localctx = new St_sub2_faContext(_ctx, getState()); 5994 enterRule(_localctx, 178, RULE_st_sub2_fa); 5995 try { 5996 enterOuterAlt(_localctx, 1); 5997 { 5998 setState(879); 5999 match(ROB); 6000 setState(880); 6001 fa2(); 6002 setState(881); 6003 match(RCB); 6004 } 6005 } 6006 catch (RecognitionException re) { 6007 _localctx.exception = re; 6008 _errHandler.reportError(this, re); 6009 _errHandler.recover(this, re); 6010 } 6011 finally { 6012 exitRule(); 6013 } 6014 return _localctx; 6015 } 6016 6017 public static class Unsorted_fa_separatorContext extends ParserRuleContext { 6018 public TerminalNode UNDERSCORE() { return getToken(HMDBParser.UNDERSCORE, 0); } 6019 public Unsorted_fa_separatorContext(ParserRuleContext parent, int invokingState) { 6020 super(parent, invokingState); 6021 } 6022 @Override public int getRuleIndex() { return RULE_unsorted_fa_separator; } 6023 @Override 6024 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6025 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitUnsorted_fa_separator(this); 6026 else return visitor.visitChildren(this); 6027 } 6028 } 6029 6030 public final Unsorted_fa_separatorContext unsorted_fa_separator() throws RecognitionException { 6031 Unsorted_fa_separatorContext _localctx = new Unsorted_fa_separatorContext(_ctx, getState()); 6032 enterRule(_localctx, 180, RULE_unsorted_fa_separator); 6033 try { 6034 enterOuterAlt(_localctx, 1); 6035 { 6036 setState(883); 6037 match(UNDERSCORE); 6038 } 6039 } 6040 catch (RecognitionException re) { 6041 _localctx.exception = re; 6042 _errHandler.reportError(this, re); 6043 _errHandler.recover(this, re); 6044 } 6045 finally { 6046 exitRule(); 6047 } 6048 return _localctx; 6049 } 6050 6051 public static class Sorted_fa_separatorContext extends ParserRuleContext { 6052 public TerminalNode SLASH() { return getToken(HMDBParser.SLASH, 0); } 6053 public Sorted_fa_separatorContext(ParserRuleContext parent, int invokingState) { 6054 super(parent, invokingState); 6055 } 6056 @Override public int getRuleIndex() { return RULE_sorted_fa_separator; } 6057 @Override 6058 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6059 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitSorted_fa_separator(this); 6060 else return visitor.visitChildren(this); 6061 } 6062 } 6063 6064 public final Sorted_fa_separatorContext sorted_fa_separator() throws RecognitionException { 6065 Sorted_fa_separatorContext _localctx = new Sorted_fa_separatorContext(_ctx, getState()); 6066 enterRule(_localctx, 182, RULE_sorted_fa_separator); 6067 try { 6068 enterOuterAlt(_localctx, 1); 6069 { 6070 setState(885); 6071 match(SLASH); 6072 } 6073 } 6074 catch (RecognitionException re) { 6075 _localctx.exception = re; 6076 _errHandler.reportError(this, re); 6077 _errHandler.recover(this, re); 6078 } 6079 finally { 6080 exitRule(); 6081 } 6082 return _localctx; 6083 } 6084 6085 public static class Headgroup_separatorContext extends ParserRuleContext { 6086 public TerminalNode SPACE() { return getToken(HMDBParser.SPACE, 0); } 6087 public Headgroup_separatorContext(ParserRuleContext parent, int invokingState) { 6088 super(parent, invokingState); 6089 } 6090 @Override public int getRuleIndex() { return RULE_headgroup_separator; } 6091 @Override 6092 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6093 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitHeadgroup_separator(this); 6094 else return visitor.visitChildren(this); 6095 } 6096 } 6097 6098 public final Headgroup_separatorContext headgroup_separator() throws RecognitionException { 6099 Headgroup_separatorContext _localctx = new Headgroup_separatorContext(_ctx, getState()); 6100 enterRule(_localctx, 184, RULE_headgroup_separator); 6101 try { 6102 enterOuterAlt(_localctx, 1); 6103 { 6104 setState(887); 6105 match(SPACE); 6106 } 6107 } 6108 catch (RecognitionException re) { 6109 _localctx.exception = re; 6110 _errHandler.reportError(this, re); 6111 _errHandler.recover(this, re); 6112 } 6113 finally { 6114 exitRule(); 6115 } 6116 return _localctx; 6117 } 6118 6119 public static class Carbon_db_separatorContext extends ParserRuleContext { 6120 public TerminalNode COLON() { return getToken(HMDBParser.COLON, 0); } 6121 public Carbon_db_separatorContext(ParserRuleContext parent, int invokingState) { 6122 super(parent, invokingState); 6123 } 6124 @Override public int getRuleIndex() { return RULE_carbon_db_separator; } 6125 @Override 6126 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6127 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitCarbon_db_separator(this); 6128 else return visitor.visitChildren(this); 6129 } 6130 } 6131 6132 public final Carbon_db_separatorContext carbon_db_separator() throws RecognitionException { 6133 Carbon_db_separatorContext _localctx = new Carbon_db_separatorContext(_ctx, getState()); 6134 enterRule(_localctx, 186, RULE_carbon_db_separator); 6135 try { 6136 enterOuterAlt(_localctx, 1); 6137 { 6138 setState(889); 6139 match(COLON); 6140 } 6141 } 6142 catch (RecognitionException re) { 6143 _localctx.exception = re; 6144 _errHandler.reportError(this, re); 6145 _errHandler.recover(this, re); 6146 } 6147 finally { 6148 exitRule(); 6149 } 6150 return _localctx; 6151 } 6152 6153 public static class Db_position_separatorContext extends ParserRuleContext { 6154 public TerminalNode COMMA() { return getToken(HMDBParser.COMMA, 0); } 6155 public Db_position_separatorContext(ParserRuleContext parent, int invokingState) { 6156 super(parent, invokingState); 6157 } 6158 @Override public int getRuleIndex() { return RULE_db_position_separator; } 6159 @Override 6160 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6161 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDb_position_separator(this); 6162 else return visitor.visitChildren(this); 6163 } 6164 } 6165 6166 public final Db_position_separatorContext db_position_separator() throws RecognitionException { 6167 Db_position_separatorContext _localctx = new Db_position_separatorContext(_ctx, getState()); 6168 enterRule(_localctx, 188, RULE_db_position_separator); 6169 try { 6170 enterOuterAlt(_localctx, 1); 6171 { 6172 setState(891); 6173 match(COMMA); 6174 } 6175 } 6176 catch (RecognitionException re) { 6177 _localctx.exception = re; 6178 _errHandler.reportError(this, re); 6179 _errHandler.recover(this, re); 6180 } 6181 finally { 6182 exitRule(); 6183 } 6184 return _localctx; 6185 } 6186 6187 public static class Med_position_separatorContext extends ParserRuleContext { 6188 public TerminalNode COMMA() { return getToken(HMDBParser.COMMA, 0); } 6189 public Med_position_separatorContext(ParserRuleContext parent, int invokingState) { 6190 super(parent, invokingState); 6191 } 6192 @Override public int getRuleIndex() { return RULE_med_position_separator; } 6193 @Override 6194 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6195 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitMed_position_separator(this); 6196 else return visitor.visitChildren(this); 6197 } 6198 } 6199 6200 public final Med_position_separatorContext med_position_separator() throws RecognitionException { 6201 Med_position_separatorContext _localctx = new Med_position_separatorContext(_ctx, getState()); 6202 enterRule(_localctx, 190, RULE_med_position_separator); 6203 try { 6204 enterOuterAlt(_localctx, 1); 6205 { 6206 setState(893); 6207 match(COMMA); 6208 } 6209 } 6210 catch (RecognitionException re) { 6211 _localctx.exception = re; 6212 _errHandler.reportError(this, re); 6213 _errHandler.recover(this, re); 6214 } 6215 finally { 6216 exitRule(); 6217 } 6218 return _localctx; 6219 } 6220 6221 public static class Fa_lcb_suffix_separatorContext extends ParserRuleContext { 6222 public TerminalNode DASH() { return getToken(HMDBParser.DASH, 0); } 6223 public Fa_lcb_suffix_separatorContext(ParserRuleContext parent, int invokingState) { 6224 super(parent, invokingState); 6225 } 6226 @Override public int getRuleIndex() { return RULE_fa_lcb_suffix_separator; } 6227 @Override 6228 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6229 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_suffix_separator(this); 6230 else return visitor.visitChildren(this); 6231 } 6232 } 6233 6234 public final Fa_lcb_suffix_separatorContext fa_lcb_suffix_separator() throws RecognitionException { 6235 Fa_lcb_suffix_separatorContext _localctx = new Fa_lcb_suffix_separatorContext(_ctx, getState()); 6236 enterRule(_localctx, 192, RULE_fa_lcb_suffix_separator); 6237 try { 6238 enterOuterAlt(_localctx, 1); 6239 { 6240 setState(895); 6241 match(DASH); 6242 } 6243 } 6244 catch (RecognitionException re) { 6245 _localctx.exception = re; 6246 _errHandler.reportError(this, re); 6247 _errHandler.recover(this, re); 6248 } 6249 finally { 6250 exitRule(); 6251 } 6252 return _localctx; 6253 } 6254 6255 public static class Fa_lcb_prefix_separatorContext extends ParserRuleContext { 6256 public TerminalNode DASH() { return getToken(HMDBParser.DASH, 0); } 6257 public Fa_lcb_prefix_separatorContext(ParserRuleContext parent, int invokingState) { 6258 super(parent, invokingState); 6259 } 6260 @Override public int getRuleIndex() { return RULE_fa_lcb_prefix_separator; } 6261 @Override 6262 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6263 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitFa_lcb_prefix_separator(this); 6264 else return visitor.visitChildren(this); 6265 } 6266 } 6267 6268 public final Fa_lcb_prefix_separatorContext fa_lcb_prefix_separator() throws RecognitionException { 6269 Fa_lcb_prefix_separatorContext _localctx = new Fa_lcb_prefix_separatorContext(_ctx, getState()); 6270 enterRule(_localctx, 194, RULE_fa_lcb_prefix_separator); 6271 try { 6272 enterOuterAlt(_localctx, 1); 6273 { 6274 setState(897); 6275 match(DASH); 6276 } 6277 } 6278 catch (RecognitionException re) { 6279 _localctx.exception = re; 6280 _errHandler.reportError(this, re); 6281 _errHandler.recover(this, re); 6282 } 6283 finally { 6284 exitRule(); 6285 } 6286 return _localctx; 6287 } 6288 6289 public static class NumberContext extends ParserRuleContext { 6290 public DigitContext digit() { 6291 return getRuleContext(DigitContext.class,0); 6292 } 6293 public NumberContext(ParserRuleContext parent, int invokingState) { 6294 super(parent, invokingState); 6295 } 6296 @Override public int getRuleIndex() { return RULE_number; } 6297 @Override 6298 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6299 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitNumber(this); 6300 else return visitor.visitChildren(this); 6301 } 6302 } 6303 6304 public final NumberContext number() throws RecognitionException { 6305 NumberContext _localctx = new NumberContext(_ctx, getState()); 6306 enterRule(_localctx, 196, RULE_number); 6307 try { 6308 enterOuterAlt(_localctx, 1); 6309 { 6310 setState(899); 6311 digit(0); 6312 } 6313 } 6314 catch (RecognitionException re) { 6315 _localctx.exception = re; 6316 _errHandler.reportError(this, re); 6317 _errHandler.recover(this, re); 6318 } 6319 finally { 6320 exitRule(); 6321 } 6322 return _localctx; 6323 } 6324 6325 public static class DigitContext extends ParserRuleContext { 6326 public List<DigitContext> digit() { 6327 return getRuleContexts(DigitContext.class); 6328 } 6329 public DigitContext digit(int i) { 6330 return getRuleContext(DigitContext.class,i); 6331 } 6332 public DigitContext(ParserRuleContext parent, int invokingState) { 6333 super(parent, invokingState); 6334 } 6335 @Override public int getRuleIndex() { return RULE_digit; } 6336 @Override 6337 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6338 if ( visitor instanceof HMDBVisitor ) return ((HMDBVisitor<? extends T>)visitor).visitDigit(this); 6339 else return visitor.visitChildren(this); 6340 } 6341 } 6342 6343 public final DigitContext digit() throws RecognitionException { 6344 return digit(0); 6345 } 6346 6347 private DigitContext digit(int _p) throws RecognitionException { 6348 ParserRuleContext _parentctx = _ctx; 6349 int _parentState = getState(); 6350 DigitContext _localctx = new DigitContext(_ctx, _parentState); 6351 DigitContext _prevctx = _localctx; 6352 int _startState = 198; 6353 enterRecursionRule(_localctx, 198, RULE_digit, _p); 6354 try { 6355 int _alt; 6356 enterOuterAlt(_localctx, 1); 6357 { 6358 setState(912); 6359 _errHandler.sync(this); 6360 switch (_input.LA(1)) { 6361 case T__216: 6362 { 6363 setState(902); 6364 match(T__216); 6365 } 6366 break; 6367 case T__217: 6368 { 6369 setState(903); 6370 match(T__217); 6371 } 6372 break; 6373 case T__218: 6374 { 6375 setState(904); 6376 match(T__218); 6377 } 6378 break; 6379 case T__219: 6380 { 6381 setState(905); 6382 match(T__219); 6383 } 6384 break; 6385 case T__220: 6386 { 6387 setState(906); 6388 match(T__220); 6389 } 6390 break; 6391 case T__221: 6392 { 6393 setState(907); 6394 match(T__221); 6395 } 6396 break; 6397 case T__222: 6398 { 6399 setState(908); 6400 match(T__222); 6401 } 6402 break; 6403 case T__223: 6404 { 6405 setState(909); 6406 match(T__223); 6407 } 6408 break; 6409 case T__224: 6410 { 6411 setState(910); 6412 match(T__224); 6413 } 6414 break; 6415 case T__225: 6416 { 6417 setState(911); 6418 match(T__225); 6419 } 6420 break; 6421 default: 6422 throw new NoViableAltException(this); 6423 } 6424 _ctx.stop = _input.LT(-1); 6425 setState(918); 6426 _errHandler.sync(this); 6427 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6428 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6429 if ( _alt==1 ) { 6430 if ( _parseListeners!=null ) triggerExitRuleEvent(); 6431 _prevctx = _localctx; 6432 { 6433 { 6434 _localctx = new DigitContext(_parentctx, _parentState); 6435 pushNewRecursionContext(_localctx, _startState, RULE_digit); 6436 setState(914); 6437 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); 6438 setState(915); 6439 digit(2); 6440 } 6441 } 6442 } 6443 setState(920); 6444 _errHandler.sync(this); 6445 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6446 } 6447 } 6448 } 6449 catch (RecognitionException re) { 6450 _localctx.exception = re; 6451 _errHandler.reportError(this, re); 6452 _errHandler.recover(this, re); 6453 } 6454 finally { 6455 unrollRecursionContexts(_parentctx); 6456 } 6457 return _localctx; 6458 } 6459 6460 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 6461 switch (ruleIndex) { 6462 case 17: 6463 return db_position_sempred((Db_positionContext)_localctx, predIndex); 6464 case 46: 6465 return mediator_single_sempred((Mediator_singleContext)_localctx, predIndex); 6466 case 48: 6467 return med_position_sempred((Med_positionContext)_localctx, predIndex); 6468 case 75: 6469 return sl_hg_prefix_sempred((Sl_hg_prefixContext)_localctx, predIndex); 6470 case 76: 6471 return sl_hg_suffix_sempred((Sl_hg_suffixContext)_localctx, predIndex); 6472 case 99: 6473 return digit_sempred((DigitContext)_localctx, predIndex); 6474 } 6475 return true; 6476 } 6477 private boolean db_position_sempred(Db_positionContext _localctx, int predIndex) { 6478 switch (predIndex) { 6479 case 0: 6480 return precpred(_ctx, 1); 6481 } 6482 return true; 6483 } 6484 private boolean mediator_single_sempred(Mediator_singleContext _localctx, int predIndex) { 6485 switch (predIndex) { 6486 case 1: 6487 return precpred(_ctx, 68); 6488 case 2: 6489 return precpred(_ctx, 67); 6490 } 6491 return true; 6492 } 6493 private boolean med_position_sempred(Med_positionContext _localctx, int predIndex) { 6494 switch (predIndex) { 6495 case 3: 6496 return precpred(_ctx, 3); 6497 } 6498 return true; 6499 } 6500 private boolean sl_hg_prefix_sempred(Sl_hg_prefixContext _localctx, int predIndex) { 6501 switch (predIndex) { 6502 case 4: 6503 return precpred(_ctx, 18); 6504 case 5: 6505 return precpred(_ctx, 19); 6506 } 6507 return true; 6508 } 6509 private boolean sl_hg_suffix_sempred(Sl_hg_suffixContext _localctx, int predIndex) { 6510 switch (predIndex) { 6511 case 6: 6512 return precpred(_ctx, 6); 6513 case 7: 6514 return precpred(_ctx, 5); 6515 } 6516 return true; 6517 } 6518 private boolean digit_sempred(DigitContext _localctx, int predIndex) { 6519 switch (predIndex) { 6520 case 8: 6521 return precpred(_ctx, 1); 6522 } 6523 return true; 6524 } 6525 6526 public static final String _serializedATN = 6527 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00ee\u039c\4\2\t"+ 6528 "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ 6529 "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ 6530 "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ 6531 "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ 6532 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 6533 ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ 6534 "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ 6535 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 6536 "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ 6537 "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ 6538 "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\3\2\3\2\3\2\3\3\3\3\3\3\3\3\5\3\u00d2"+ 6539 "\n\3\3\4\3\4\3\4\3\4\3\4\5\4\u00d9\n\4\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6"+ 6540 "\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00e9\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7"+ 6541 "\3\7\5\7\u00f4\n\7\3\b\3\b\5\b\u00f8\n\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3"+ 6542 "\t\3\t\3\t\5\t\u0104\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u0110"+ 6543 "\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u011d"+ 6544 "\n\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+ 6545 "\16\3\16\3\16\3\16\5\16\u0131\n\16\3\17\3\17\3\20\3\20\3\20\5\20\u0138"+ 6546 "\n\20\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+ 6547 "\7\23\u0147\n\23\f\23\16\23\u014a\13\23\3\24\3\24\3\24\3\24\5\24\u0150"+ 6548 "\n\24\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\27\5\27\u015a\n\27\3\30\3\30"+ 6549 "\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\5\33"+ 6550 "\u016b\n\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u0175\n\34\3"+ 6551 "\35\3\35\3\36\3\36\3\37\3\37\3\37\3\37\5\37\u017f\n\37\3 \3 \3!\3!\3\""+ 6552 "\3\"\5\"\u0187\n\"\3#\3#\3#\3#\3$\3$\3$\3$\3%\3%\5%\u0193\n%\3&\3&\3&"+ 6553 "\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\5(\u01a3\n(\3)\3)\3)\3)\3)\3)"+ 6554 "\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u01c0"+ 6555 "\n+\3,\3,\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\5/\u01d3\n/\3\60"+ 6556 "\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60"+ 6557 "\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60"+ 6558 "\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60"+ 6559 "\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60"+ 6560 "\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\5\60\u0218\n\60\3\60"+ 6561 "\3\60\3\60\3\60\3\60\7\60\u021f\n\60\f\60\16\60\u0222\13\60\3\61\3\61"+ 6562 "\3\61\3\61\3\61\5\61\u0229\n\61\3\62\3\62\3\62\3\62\3\62\5\62\u0230\n"+ 6563 "\62\3\62\3\62\3\62\3\62\7\62\u0236\n\62\f\62\16\62\u0239\13\62\3\63\3"+ 6564 "\63\3\64\3\64\3\64\5\64\u0240\n\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65"+ 6565 "\5\65\u0249\n\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u0253\n"+ 6566 "\66\3\67\3\67\38\38\38\38\38\38\38\58\u025e\n8\39\39\39\39\3:\3:\3;\3"+ 6567 ";\3;\3;\3;\3;\3;\5;\u026d\n;\3<\3<\3<\3<\3<\3<\3<\3<\5<\u0277\n<\3=\3"+ 6568 "=\3>\3>\3>\5>\u027e\n>\3?\3?\3?\3?\3?\3?\3?\5?\u0287\n?\3@\3@\3@\3@\3"+ 6569 "@\3@\3@\3@\5@\u0291\n@\3A\3A\3B\3B\3B\3B\3B\3B\3B\5B\u029c\nB\3C\3C\3"+ 6570 "C\3C\3C\3C\3C\3C\5C\u02a6\nC\3D\3D\3E\3E\3E\3E\3E\3E\3E\5E\u02b1\nE\3"+ 6571 "F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u02bf\nF\3G\3G\3H\3H\3H\3H\3H\3"+ 6572 "H\3H\5H\u02ca\nH\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u02d7\nI\3J\3J\3"+ 6573 "J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3"+ 6574 "J\3J\3J\3J\3J\3J\5J\u02f8\nJ\3K\3K\3K\3K\3K\5K\u02ff\nK\3L\3L\3M\3M\3"+ 6575 "M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\5M\u0318\nM\3"+ 6576 "M\3M\3M\3M\7M\u031e\nM\fM\16M\u0321\13M\3N\3N\3N\3N\3N\3N\3N\3N\5N\u032b"+ 6577 "\nN\3N\3N\3N\3N\7N\u0331\nN\fN\16N\u0334\13N\3O\3O\5O\u0338\nO\3P\3P\3"+ 6578 "P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\5R\u0347\nR\3S\3S\3S\3S\3S\3S\3S\5S\u0350"+ 6579 "\nS\3T\3T\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\5V\u035f\nV\3W\3W\3X\3X\3X"+ 6580 "\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u036e\nY\3Z\3Z\3[\3[\3[\3[\3\\\3\\\3]\3]\3"+ 6581 "^\3^\3_\3_\3`\3`\3a\3a\3b\3b\3c\3c\3d\3d\3e\3e\3e\3e\3e\3e\3e\3e\3e\3"+ 6582 "e\3e\5e\u0393\ne\3e\3e\7e\u0397\ne\fe\16e\u039a\13e\3e\2\b$^b\u0098\u009a"+ 6583 "\u00c8f\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:"+ 6584 "<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a"+ 6585 "\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2"+ 6586 "\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba"+ 6587 "\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\2\16\3\2\n\13\3\2\f\20\3\2"+ 6588 "\21\23\3\2\24\25\3\2\27\34\3\2]^\3\2_d\4\2``cc\3\2eh\3\2i\u0089\3\2\u008b"+ 6589 "\u0090\3\2\u00b0\u00c8\2\u03fa\2\u00ca\3\2\2\2\4\u00d1\3\2\2\2\6\u00d8"+ 6590 "\3\2\2\2\b\u00da\3\2\2\2\n\u00e8\3\2\2\2\f\u00f3\3\2\2\2\16\u00f7\3\2"+ 6591 "\2\2\20\u0103\3\2\2\2\22\u010f\3\2\2\2\24\u011c\3\2\2\2\26\u011e\3\2\2"+ 6592 "\2\30\u0123\3\2\2\2\32\u0130\3\2\2\2\34\u0132\3\2\2\2\36\u0137\3\2\2\2"+ 6593 " \u0139\3\2\2\2\"\u013b\3\2\2\2$\u013f\3\2\2\2&\u014f\3\2\2\2(\u0151\3"+ 6594 "\2\2\2*\u0153\3\2\2\2,\u0159\3\2\2\2.\u015b\3\2\2\2\60\u015e\3\2\2\2\62"+ 6595 "\u0160\3\2\2\2\64\u016a\3\2\2\2\66\u0174\3\2\2\28\u0176\3\2\2\2:\u0178"+ 6596 "\3\2\2\2<\u017e\3\2\2\2>\u0180\3\2\2\2@\u0182\3\2\2\2B\u0186\3\2\2\2D"+ 6597 "\u0188\3\2\2\2F\u018c\3\2\2\2H\u0192\3\2\2\2J\u0194\3\2\2\2L\u019a\3\2"+ 6598 "\2\2N\u01a2\3\2\2\2P\u01a4\3\2\2\2R\u01ac\3\2\2\2T\u01bf\3\2\2\2V\u01c1"+ 6599 "\3\2\2\2X\u01c3\3\2\2\2Z\u01c7\3\2\2\2\\\u01d2\3\2\2\2^\u0217\3\2\2\2"+ 6600 "`\u0228\3\2\2\2b\u022f\3\2\2\2d\u023a\3\2\2\2f\u023f\3\2\2\2h\u0248\3"+ 6601 "\2\2\2j\u0252\3\2\2\2l\u0254\3\2\2\2n\u025d\3\2\2\2p\u025f\3\2\2\2r\u0263"+ 6602 "\3\2\2\2t\u026c\3\2\2\2v\u0276\3\2\2\2x\u0278\3\2\2\2z\u027d\3\2\2\2|"+ 6603 "\u0286\3\2\2\2~\u0290\3\2\2\2\u0080\u0292\3\2\2\2\u0082\u029b\3\2\2\2"+ 6604 "\u0084\u02a5\3\2\2\2\u0086\u02a7\3\2\2\2\u0088\u02b0\3\2\2\2\u008a\u02be"+ 6605 "\3\2\2\2\u008c\u02c0\3\2\2\2\u008e\u02c9\3\2\2\2\u0090\u02d6\3\2\2\2\u0092"+ 6606 "\u02f7\3\2\2\2\u0094\u02fe\3\2\2\2\u0096\u0300\3\2\2\2\u0098\u0317\3\2"+ 6607 "\2\2\u009a\u032a\3\2\2\2\u009c\u0337\3\2\2\2\u009e\u0339\3\2\2\2\u00a0"+ 6608 "\u033d\3\2\2\2\u00a2\u0346\3\2\2\2\u00a4\u034f\3\2\2\2\u00a6\u0351\3\2"+ 6609 "\2\2\u00a8\u0353\3\2\2\2\u00aa\u035e\3\2\2\2\u00ac\u0360\3\2\2\2\u00ae"+ 6610 "\u0362\3\2\2\2\u00b0\u036d\3\2\2\2\u00b2\u036f\3\2\2\2\u00b4\u0371\3\2"+ 6611 "\2\2\u00b6\u0375\3\2\2\2\u00b8\u0377\3\2\2\2\u00ba\u0379\3\2\2\2\u00bc"+ 6612 "\u037b\3\2\2\2\u00be\u037d\3\2\2\2\u00c0\u037f\3\2\2\2\u00c2\u0381\3\2"+ 6613 "\2\2\u00c4\u0383\3\2\2\2\u00c6\u0385\3\2\2\2\u00c8\u0392\3\2\2\2\u00ca"+ 6614 "\u00cb\5\4\3\2\u00cb\u00cc\7\2\2\3\u00cc\3\3\2\2\2\u00cd\u00d2\5\6\4\2"+ 6615 "\u00ce\u00cf\5\6\4\2\u00cf\u00d0\5\b\5\2\u00d0\u00d2\3\2\2\2\u00d1\u00cd"+ 6616 "\3\2\2\2\u00d1\u00ce\3\2\2\2\u00d2\5\3\2\2\2\u00d3\u00d9\5T+\2\u00d4\u00d9"+ 6617 "\5f\64\2\u00d5\u00d9\5z>\2\u00d6\u00d9\5\u008eH\2\u00d7\u00d9\5\u00a2"+ 6618 "R\2\u00d8\u00d3\3\2\2\2\u00d8\u00d4\3\2\2\2\u00d8\u00d5\3\2\2\2\u00d8"+ 6619 "\u00d6\3\2\2\2\u00d8\u00d7\3\2\2\2\u00d9\7\3\2\2\2\u00da\u00db\7\3\2\2"+ 6620 "\u00db\t\3\2\2\2\u00dc\u00e9\5\f\7\2\u00dd\u00e9\5\16\b\2\u00de\u00df"+ 6621 "\5<\37\2\u00df\u00e0\5\f\7\2\u00e0\u00e9\3\2\2\2\u00e1\u00e2\5\f\7\2\u00e2"+ 6622 "\u00e3\5\64\33\2\u00e3\u00e9\3\2\2\2\u00e4\u00e5\5<\37\2\u00e5\u00e6\5"+ 6623 "\f\7\2\u00e6\u00e7\5\64\33\2\u00e7\u00e9\3\2\2\2\u00e8\u00dc\3\2\2\2\u00e8"+ 6624 "\u00dd\3\2\2\2\u00e8\u00de\3\2\2\2\u00e8\u00e1\3\2\2\2\u00e8\u00e4\3\2"+ 6625 "\2\2\u00e9\13\3\2\2\2\u00ea\u00eb\5\30\r\2\u00eb\u00ec\5\u00bc_\2\u00ec"+ 6626 "\u00ed\5\32\16\2\u00ed\u00f4\3\2\2\2\u00ee\u00ef\5,\27\2\u00ef\u00f0\5"+ 6627 "\30\r\2\u00f0\u00f1\5\u00bc_\2\u00f1\u00f2\5\32\16\2\u00f2\u00f4\3\2\2"+ 6628 "\2\u00f3\u00ea\3\2\2\2\u00f3\u00ee\3\2\2\2\u00f4\r\3\2\2\2\u00f5\u00f8"+ 6629 "\5\20\t\2\u00f6\u00f8\5\22\n\2\u00f7\u00f5\3\2\2\2\u00f7\u00f6\3\2\2\2"+ 6630 "\u00f8\17\3\2\2\2\u00f9\u00fa\5\u00c6d\2\u00fa\u00fb\7\4\2\2\u00fb\u00fc"+ 6631 "\5\u00c6d\2\u00fc\u0104\3\2\2\2\u00fd\u00fe\7\5\2\2\u00fe\u00ff\5\u00c6"+ 6632 "d\2\u00ff\u0100\7\u00ec\2\2\u0100\u0101\5\u00c6d\2\u0101\u0102\7\u00ee"+ 6633 "\2\2\u0102\u0104\3\2\2\2\u0103\u00f9\3\2\2\2\u0103\u00fd\3\2\2\2\u0104"+ 6634 "\21\3\2\2\2\u0105\u0106\5\u00c6d\2\u0106\u0107\7\6\2\2\u0107\u0108\5\u00c6"+ 6635 "d\2\u0108\u0110\3\2\2\2\u0109\u010a\7\7\2\2\u010a\u010b\5\u00c6d\2\u010b"+ 6636 "\u010c\7\u00ec\2\2\u010c\u010d\5\u00c6d\2\u010d\u010e\7\u00ee\2\2\u010e"+ 6637 "\u0110\3\2\2\2\u010f\u0105\3\2\2\2\u010f\u0109\3\2\2\2\u0110\23\3\2\2"+ 6638 "\2\u0111\u011d\5\26\f\2\u0112\u0113\5<\37\2\u0113\u0114\5\26\f\2\u0114"+ 6639 "\u011d\3\2\2\2\u0115\u0116\5\26\f\2\u0116\u0117\5\64\33\2\u0117\u011d"+ 6640 "\3\2\2\2\u0118\u0119\5<\37\2\u0119\u011a\5\26\f\2\u011a\u011b\5\64\33"+ 6641 "\2\u011b\u011d\3\2\2\2\u011c\u0111\3\2\2\2\u011c\u0112\3\2\2\2\u011c\u0115"+ 6642 "\3\2\2\2\u011c\u0118\3\2\2\2\u011d\25\3\2\2\2\u011e\u011f\5\62\32\2\u011f"+ 6643 "\u0120\5\30\r\2\u0120\u0121\5\u00bc_\2\u0121\u0122\5\32\16\2\u0122\27"+ 6644 "\3\2\2\2\u0123\u0124\5\u00c6d\2\u0124\31\3\2\2\2\u0125\u0131\5\34\17\2"+ 6645 "\u0126\u0127\5\34\17\2\u0127\u0128\5\"\22\2\u0128\u0131\3\2\2\2\u0129"+ 6646 "\u012a\5\34\17\2\u012a\u012b\5\36\20\2\u012b\u0131\3\2\2\2\u012c\u012d"+ 6647 "\5\34\17\2\u012d\u012e\5\"\22\2\u012e\u012f\5\36\20\2\u012f\u0131\3\2"+ 6648 "\2\2\u0130\u0125\3\2\2\2\u0130\u0126\3\2\2\2\u0130\u0129\3\2\2\2\u0130"+ 6649 "\u012c\3\2\2\2\u0131\33\3\2\2\2\u0132\u0133\5\u00c6d\2\u0133\35\3\2\2"+ 6650 "\2\u0134\u0138\7\b\2\2\u0135\u0136\7\t\2\2\u0136\u0138\5 \21\2\u0137\u0134"+ 6651 "\3\2\2\2\u0137\u0135\3\2\2\2\u0138\37\3\2\2\2\u0139\u013a\5\u00c6d\2\u013a"+ 6652 "!\3\2\2\2\u013b\u013c\7\u00ed\2\2\u013c\u013d\5$\23\2\u013d\u013e\7\u00ee"+ 6653 "\2\2\u013e#\3\2\2\2\u013f\u0140\b\23\1\2\u0140\u0141\5&\24\2\u0141\u0148"+ 6654 "\3\2\2\2\u0142\u0143\f\3\2\2\u0143\u0144\5\u00be`\2\u0144\u0145\5$\23"+ 6655 "\4\u0145\u0147\3\2\2\2\u0146\u0142\3\2\2\2\u0147\u014a\3\2\2\2\u0148\u0146"+ 6656 "\3\2\2\2\u0148\u0149\3\2\2\2\u0149%\3\2\2\2\u014a\u0148\3\2\2\2\u014b"+ 6657 "\u0150\5(\25\2\u014c\u014d\5(\25\2\u014d\u014e\5*\26\2\u014e\u0150\3\2"+ 6658 "\2\2\u014f\u014b\3\2\2\2\u014f\u014c\3\2\2\2\u0150\'\3\2\2\2\u0151\u0152"+ 6659 "\5\u00c6d\2\u0152)\3\2\2\2\u0153\u0154\t\2\2\2\u0154+\3\2\2\2\u0155\u015a"+ 6660 "\5\60\31\2\u0156\u0157\5.\30\2\u0157\u0158\5\60\31\2\u0158\u015a\3\2\2"+ 6661 "\2\u0159\u0155\3\2\2\2\u0159\u0156\3\2\2\2\u015a-\3\2\2\2\u015b\u015c"+ 6662 "\5\u00c6d\2\u015c\u015d\7\u00e8\2\2\u015d/\3\2\2\2\u015e\u015f\t\3\2\2"+ 6663 "\u015f\61\3\2\2\2\u0160\u0161\t\4\2\2\u0161\63\3\2\2\2\u0162\u016b\5\66"+ 6664 "\34\2\u0163\u0164\5\u00c2b\2\u0164\u0165\5\66\34\2\u0165\u016b\3\2\2\2"+ 6665 "\u0166\u0167\7\u00ed\2\2\u0167\u0168\5\66\34\2\u0168\u0169\7\u00ee\2\2"+ 6666 "\u0169\u016b\3\2\2\2\u016a\u0162\3\2\2\2\u016a\u0163\3\2\2\2\u016a\u0166"+ 6667 "\3\2\2\2\u016b\65\3\2\2\2\u016c\u0175\58\35\2\u016d\u016e\5:\36\2\u016e"+ 6668 "\u016f\58\35\2\u016f\u0175\3\2\2\2\u0170\u0171\5:\36\2\u0171\u0172\5\u00c2"+ 6669 "b\2\u0172\u0173\58\35\2\u0173\u0175\3\2\2\2\u0174\u016c\3\2\2\2\u0174"+ 6670 "\u016d\3\2\2\2\u0174\u0170\3\2\2\2\u0175\67\3\2\2\2\u0176\u0177\t\5\2"+ 6671 "\2\u01779\3\2\2\2\u0178\u0179\5\u00c6d\2\u0179;\3\2\2\2\u017a\u017f\5"+ 6672 "> \2\u017b\u017c\5> \2\u017c\u017d\5\u00c4c\2\u017d\u017f\3\2\2\2\u017e"+ 6673 "\u017a\3\2\2\2\u017e\u017b\3\2\2\2\u017f=\3\2\2\2\u0180\u0181\7\26\2\2"+ 6674 "\u0181?\3\2\2\2\u0182\u0183\5\n\6\2\u0183A\3\2\2\2\u0184\u0187\5D#\2\u0185"+ 6675 "\u0187\5F$\2\u0186\u0184\3\2\2\2\u0186\u0185\3\2\2\2\u0187C\3\2\2\2\u0188"+ 6676 "\u0189\5\n\6\2\u0189\u018a\5\u00b8]\2\u018a\u018b\5\n\6\2\u018bE\3\2\2"+ 6677 "\2\u018c\u018d\5\n\6\2\u018d\u018e\5\u00b6\\\2\u018e\u018f\5\n\6\2\u018f"+ 6678 "G\3\2\2\2\u0190\u0193\5J&\2\u0191\u0193\5L\'\2\u0192\u0190\3\2\2\2\u0192"+ 6679 "\u0191\3\2\2\2\u0193I\3\2\2\2\u0194\u0195\5\n\6\2\u0195\u0196\5\u00b8"+ 6680 "]\2\u0196\u0197\5\n\6\2\u0197\u0198\5\u00b8]\2\u0198\u0199\5\n\6\2\u0199"+ 6681 "K\3\2\2\2\u019a\u019b\5\n\6\2\u019b\u019c\5\u00b6\\\2\u019c\u019d\5\n"+ 6682 "\6\2\u019d\u019e\5\u00b6\\\2\u019e\u019f\5\n\6\2\u019fM\3\2\2\2\u01a0"+ 6683 "\u01a3\5P)\2\u01a1\u01a3\5R*\2\u01a2\u01a0\3\2\2\2\u01a2\u01a1\3\2\2\2"+ 6684 "\u01a3O\3\2\2\2\u01a4\u01a5\5\n\6\2\u01a5\u01a6\5\u00b8]\2\u01a6\u01a7"+ 6685 "\5\n\6\2\u01a7\u01a8\5\u00b8]\2\u01a8\u01a9\5\n\6\2\u01a9\u01aa\5\u00b8"+ 6686 "]\2\u01aa\u01ab\5\n\6\2\u01abQ\3\2\2\2\u01ac\u01ad\5\n\6\2\u01ad\u01ae"+ 6687 "\5\u00b6\\\2\u01ae\u01af\5\n\6\2\u01af\u01b0\5\u00b6\\\2\u01b0\u01b1\5"+ 6688 "\n\6\2\u01b1\u01b2\5\u00b6\\\2\u01b2\u01b3\5\n\6\2\u01b3S\3\2\2\2\u01b4"+ 6689 "\u01b5\5V,\2\u01b5\u01b6\5X-\2\u01b6\u01c0\3\2\2\2\u01b7\u01b8\5V,\2\u01b8"+ 6690 "\u01b9\5Z.\2\u01b9\u01c0\3\2\2\2\u01ba\u01bb\5V,\2\u01bb\u01bc\5\u00ba"+ 6691 "^\2\u01bc\u01bd\5X-\2\u01bd\u01c0\3\2\2\2\u01be\u01c0\5\\/\2\u01bf\u01b4"+ 6692 "\3\2\2\2\u01bf\u01b7\3\2\2\2\u01bf\u01ba\3\2\2\2\u01bf\u01be\3\2\2\2\u01c0"+ 6693 "U\3\2\2\2\u01c1\u01c2\t\6\2\2\u01c2W\3\2\2\2\u01c3\u01c4\7\u00ed\2\2\u01c4"+ 6694 "\u01c5\5\n\6\2\u01c5\u01c6\7\u00ee\2\2\u01c6Y\3\2\2\2\u01c7\u01c8\7\u00ed"+ 6695 "\2\2\u01c8\u01c9\5\n\6\2\u01c9\u01ca\5\u00b8]\2\u01ca\u01cb\5\n\6\2\u01cb"+ 6696 "\u01cc\7\u00ee\2\2\u01cc[\3\2\2\2\u01cd\u01d3\5^\60\2\u01ce\u01cf\5^\60"+ 6697 "\2\u01cf\u01d0\5\u00ba^\2\u01d0\u01d1\5`\61\2\u01d1\u01d3\3\2\2\2\u01d2"+ 6698 "\u01cd\3\2\2\2\u01d2\u01ce\3\2\2\2\u01d3]\3\2\2\2\u01d4\u01d5\b\60\1\2"+ 6699 "\u01d5\u0218\5\"\22\2\u01d6\u0218\5`\61\2\u01d7\u0218\7\35\2\2\u01d8\u0218"+ 6700 "\7\36\2\2\u01d9\u0218\7\37\2\2\u01da\u0218\7 \2\2\u01db\u0218\7!\2\2\u01dc"+ 6701 "\u0218\7\"\2\2\u01dd\u0218\7#\2\2\u01de\u0218\7$\2\2\u01df\u0218\7%\2"+ 6702 "\2\u01e0\u0218\7&\2\2\u01e1\u0218\7\'\2\2\u01e2\u0218\7(\2\2\u01e3\u0218"+ 6703 "\7)\2\2\u01e4\u0218\7*\2\2\u01e5\u0218\7+\2\2\u01e6\u0218\7,\2\2\u01e7"+ 6704 "\u0218\7-\2\2\u01e8\u0218\7.\2\2\u01e9\u0218\7/\2\2\u01ea\u0218\7\60\2"+ 6705 "\2\u01eb\u0218\7\61\2\2\u01ec\u0218\7\62\2\2\u01ed\u0218\7\63\2\2\u01ee"+ 6706 "\u0218\7\64\2\2\u01ef\u0218\7\65\2\2\u01f0\u0218\7\66\2\2\u01f1\u0218"+ 6707 "\7\67\2\2\u01f2\u0218\78\2\2\u01f3\u0218\79\2\2\u01f4\u0218\7:\2\2\u01f5"+ 6708 "\u0218\7;\2\2\u01f6\u0218\7<\2\2\u01f7\u0218\7=\2\2\u01f8\u0218\7>\2\2"+ 6709 "\u01f9\u0218\7?\2\2\u01fa\u0218\7@\2\2\u01fb\u0218\7A\2\2\u01fc\u0218"+ 6710 "\7B\2\2\u01fd\u0218\7C\2\2\u01fe\u0218\7D\2\2\u01ff\u0218\7E\2\2\u0200"+ 6711 "\u0218\7F\2\2\u0201\u0218\7G\2\2\u0202\u0218\7H\2\2\u0203\u0218\7I\2\2"+ 6712 "\u0204\u0218\7J\2\2\u0205\u0218\7K\2\2\u0206\u0218\7L\2\2\u0207\u0218"+ 6713 "\7M\2\2\u0208\u0218\7N\2\2\u0209\u0218\7O\2\2\u020a\u0218\7P\2\2\u020b"+ 6714 "\u0218\7Q\2\2\u020c\u0218\7R\2\2\u020d\u0218\7S\2\2\u020e\u0218\7T\2\2"+ 6715 "\u020f\u0218\7U\2\2\u0210\u0218\7V\2\2\u0211\u0218\7W\2\2\u0212\u0218"+ 6716 "\7X\2\2\u0213\u0218\7Y\2\2\u0214\u0218\7Z\2\2\u0215\u0218\7[\2\2\u0216"+ 6717 "\u0218\7\\\2\2\u0217\u01d4\3\2\2\2\u0217\u01d6\3\2\2\2\u0217\u01d7\3\2"+ 6718 "\2\2\u0217\u01d8\3\2\2\2\u0217\u01d9\3\2\2\2\u0217\u01da\3\2\2\2\u0217"+ 6719 "\u01db\3\2\2\2\u0217\u01dc\3\2\2\2\u0217\u01dd\3\2\2\2\u0217\u01de\3\2"+ 6720 "\2\2\u0217\u01df\3\2\2\2\u0217\u01e0\3\2\2\2\u0217\u01e1\3\2\2\2\u0217"+ 6721 "\u01e2\3\2\2\2\u0217\u01e3\3\2\2\2\u0217\u01e4\3\2\2\2\u0217\u01e5\3\2"+ 6722 "\2\2\u0217\u01e6\3\2\2\2\u0217\u01e7\3\2\2\2\u0217\u01e8\3\2\2\2\u0217"+ 6723 "\u01e9\3\2\2\2\u0217\u01ea\3\2\2\2\u0217\u01eb\3\2\2\2\u0217\u01ec\3\2"+ 6724 "\2\2\u0217\u01ed\3\2\2\2\u0217\u01ee\3\2\2\2\u0217\u01ef\3\2\2\2\u0217"+ 6725 "\u01f0\3\2\2\2\u0217\u01f1\3\2\2\2\u0217\u01f2\3\2\2\2\u0217\u01f3\3\2"+ 6726 "\2\2\u0217\u01f4\3\2\2\2\u0217\u01f5\3\2\2\2\u0217\u01f6\3\2\2\2\u0217"+ 6727 "\u01f7\3\2\2\2\u0217\u01f8\3\2\2\2\u0217\u01f9\3\2\2\2\u0217\u01fa\3\2"+ 6728 "\2\2\u0217\u01fb\3\2\2\2\u0217\u01fc\3\2\2\2\u0217\u01fd\3\2\2\2\u0217"+ 6729 "\u01fe\3\2\2\2\u0217\u01ff\3\2\2\2\u0217\u0200\3\2\2\2\u0217\u0201\3\2"+ 6730 "\2\2\u0217\u0202\3\2\2\2\u0217\u0203\3\2\2\2\u0217\u0204\3\2\2\2\u0217"+ 6731 "\u0205\3\2\2\2\u0217\u0206\3\2\2\2\u0217\u0207\3\2\2\2\u0217\u0208\3\2"+ 6732 "\2\2\u0217\u0209\3\2\2\2\u0217\u020a\3\2\2\2\u0217\u020b\3\2\2\2\u0217"+ 6733 "\u020c\3\2\2\2\u0217\u020d\3\2\2\2\u0217\u020e\3\2\2\2\u0217\u020f\3\2"+ 6734 "\2\2\u0217\u0210\3\2\2\2\u0217\u0211\3\2\2\2\u0217\u0212\3\2\2\2\u0217"+ 6735 "\u0213\3\2\2\2\u0217\u0214\3\2\2\2\u0217\u0215\3\2\2\2\u0217\u0216\3\2"+ 6736 "\2\2\u0218\u0220\3\2\2\2\u0219\u021a\fF\2\2\u021a\u021f\5^\60G\u021b\u021c"+ 6737 "\fE\2\2\u021c\u021d\7\u00e8\2\2\u021d\u021f\5^\60F\u021e\u0219\3\2\2\2"+ 6738 "\u021e\u021b\3\2\2\2\u021f\u0222\3\2\2\2\u0220\u021e\3\2\2\2\u0220\u0221"+ 6739 "\3\2\2\2\u0221_\3\2\2\2\u0222\u0220\3\2\2\2\u0223\u0229\5b\62\2\u0224"+ 6740 "\u0225\7\u00ed\2\2\u0225\u0226\5b\62\2\u0226\u0227\7\u00ee\2\2\u0227\u0229"+ 6741 "\3\2\2\2\u0228\u0223\3\2\2\2\u0228\u0224\3\2\2\2\u0229a\3\2\2\2\u022a"+ 6742 "\u022b\b\62\1\2\u022b\u022c\5\u00c6d\2\u022c\u022d\5d\63\2\u022d\u0230"+ 6743 "\3\2\2\2\u022e\u0230\5\u00c6d\2\u022f\u022a\3\2\2\2\u022f\u022e\3\2\2"+ 6744 "\2\u0230\u0237\3\2\2\2\u0231\u0232\f\5\2\2\u0232\u0233\5\u00c0a\2\u0233"+ 6745 "\u0234\5b\62\6\u0234\u0236\3\2\2\2\u0235\u0231\3\2\2\2\u0236\u0239\3\2"+ 6746 "\2\2\u0237\u0235\3\2\2\2\u0237\u0238\3\2\2\2\u0238c\3\2\2\2\u0239\u0237"+ 6747 "\3\2\2\2\u023a\u023b\t\7\2\2\u023be\3\2\2\2\u023c\u0240\5h\65\2\u023d"+ 6748 "\u0240\5t;\2\u023e\u0240\5n8\2\u023f\u023c\3\2\2\2\u023f\u023d\3\2\2\2"+ 6749 "\u023f\u023e\3\2\2\2\u0240g\3\2\2\2\u0241\u0242\5l\67\2\u0242\u0243\5"+ 6750 "j\66\2\u0243\u0249\3\2\2\2\u0244\u0245\5l\67\2\u0245\u0246\5\u00ba^\2"+ 6751 "\u0246\u0247\5j\66\2\u0247\u0249\3\2\2\2\u0248\u0241\3\2\2\2\u0248\u0244"+ 6752 "\3\2\2\2\u0249i\3\2\2\2\u024a\u024b\7\u00ed\2\2\u024b\u024c\5@!\2\u024c"+ 6753 "\u024d\7\u00ee\2\2\u024d\u0253\3\2\2\2\u024e\u024f\7\u00ed\2\2\u024f\u0250"+ 6754 "\5H%\2\u0250\u0251\7\u00ee\2\2\u0251\u0253\3\2\2\2\u0252\u024a\3\2\2\2"+ 6755 "\u0252\u024e\3\2\2\2\u0253k\3\2\2\2\u0254\u0255\t\b\2\2\u0255m\3\2\2\2"+ 6756 "\u0256\u0257\5r:\2\u0257\u0258\5p9\2\u0258\u025e\3\2\2\2\u0259\u025a\5"+ 6757 "r:\2\u025a\u025b\5\u00ba^\2\u025b\u025c\5p9\2\u025c\u025e\3\2\2\2\u025d"+ 6758 "\u0256\3\2\2\2\u025d\u0259\3\2\2\2\u025eo\3\2\2\2\u025f\u0260\7\u00ed"+ 6759 "\2\2\u0260\u0261\5B\"\2\u0261\u0262\7\u00ee\2\2\u0262q\3\2\2\2\u0263\u0264"+ 6760 "\t\t\2\2\u0264s\3\2\2\2\u0265\u0266\5x=\2\u0266\u0267\5v<\2\u0267\u026d"+ 6761 "\3\2\2\2\u0268\u0269\5x=\2\u0269\u026a\5\u00ba^\2\u026a\u026b\5v<\2\u026b"+ 6762 "\u026d\3\2\2\2\u026c\u0265\3\2\2\2\u026c\u0268\3\2\2\2\u026du\3\2\2\2"+ 6763 "\u026e\u026f\7\u00ed\2\2\u026f\u0270\5@!\2\u0270\u0271\7\u00ee\2\2\u0271"+ 6764 "\u0277\3\2\2\2\u0272\u0273\7\u00ed\2\2\u0273\u0274\5B\"\2\u0274\u0275"+ 6765 "\7\u00ee\2\2\u0275\u0277\3\2\2\2\u0276\u026e\3\2\2\2\u0276\u0272\3\2\2"+ 6766 "\2\u0277w\3\2\2\2\u0278\u0279\t\n\2\2\u0279y\3\2\2\2\u027a\u027e\5|?\2"+ 6767 "\u027b\u027e\5\u0082B\2\u027c\u027e\5\u0088E\2\u027d\u027a\3\2\2\2\u027d"+ 6768 "\u027b\3\2\2\2\u027d\u027c\3\2\2\2\u027e{\3\2\2\2\u027f\u0280\5\u0080"+ 6769 "A\2\u0280\u0281\5~@\2\u0281\u0287\3\2\2\2\u0282\u0283\5\u0080A\2\u0283"+ 6770 "\u0284\5\u00ba^\2\u0284\u0285\5~@\2\u0285\u0287\3\2\2\2\u0286\u027f\3"+ 6771 "\2\2\2\u0286\u0282\3\2\2\2\u0287}\3\2\2\2\u0288\u0289\7\u00ed\2\2\u0289"+ 6772 "\u028a\5@!\2\u028a\u028b\7\u00ee\2\2\u028b\u0291\3\2\2\2\u028c\u028d\7"+ 6773 "\u00ed\2\2\u028d\u028e\5B\"\2\u028e\u028f\7\u00ee\2\2\u028f\u0291\3\2"+ 6774 "\2\2\u0290\u0288\3\2\2\2\u0290\u028c\3\2\2\2\u0291\177\3\2\2\2\u0292\u0293"+ 6775 "\t\13\2\2\u0293\u0081\3\2\2\2\u0294\u0295\5\u0086D\2\u0295\u0296\5\u0084"+ 6776 "C\2\u0296\u029c\3\2\2\2\u0297\u0298\5\u0086D\2\u0298\u0299\5\u00ba^\2"+ 6777 "\u0299\u029a\5\u0084C\2\u029a\u029c\3\2\2\2\u029b\u0294\3\2\2\2\u029b"+ 6778 "\u0297\3\2\2\2\u029c\u0083\3\2\2\2\u029d\u029e\7\u00ed\2\2\u029e\u029f"+ 6779 "\5@!\2\u029f\u02a0\7\u00ee\2\2\u02a0\u02a6\3\2\2\2\u02a1\u02a2\7\u00ed"+ 6780 "\2\2\u02a2\u02a3\5H%\2\u02a3\u02a4\7\u00ee\2\2\u02a4\u02a6\3\2\2\2\u02a5"+ 6781 "\u029d\3\2\2\2\u02a5\u02a1\3\2\2\2\u02a6\u0085\3\2\2\2\u02a7\u02a8\7\u008a"+ 6782 "\2\2\u02a8\u0087\3\2\2\2\u02a9\u02aa\5\u008cG\2\u02aa\u02ab\5\u008aF\2"+ 6783 "\u02ab\u02b1\3\2\2\2\u02ac\u02ad\5\u008cG\2\u02ad\u02ae\5\u00ba^\2\u02ae"+ 6784 "\u02af\5\u008aF\2\u02af\u02b1\3\2\2\2\u02b0\u02a9\3\2\2\2\u02b0\u02ac"+ 6785 "\3\2\2\2\u02b1\u0089\3\2\2\2\u02b2\u02b3\7\u00ed\2\2\u02b3\u02b4\5@!\2"+ 6786 "\u02b4\u02b5\7\u00ee\2\2\u02b5\u02bf\3\2\2\2\u02b6\u02b7\7\u00ed\2\2\u02b7"+ 6787 "\u02b8\5B\"\2\u02b8\u02b9\7\u00ee\2\2\u02b9\u02bf\3\2\2\2\u02ba\u02bb"+ 6788 "\7\u00ed\2\2\u02bb\u02bc\5N(\2\u02bc\u02bd\7\u00ee\2\2\u02bd\u02bf\3\2"+ 6789 "\2\2\u02be\u02b2\3\2\2\2\u02be\u02b6\3\2\2\2\u02be\u02ba\3\2\2\2\u02bf"+ 6790 "\u008b\3\2\2\2\u02c0\u02c1\t\f\2\2\u02c1\u008d\3\2\2\2\u02c2\u02c3\5\u0090"+ 6791 "I\2\u02c3\u02c4\5\u009cO\2\u02c4\u02ca\3\2\2\2\u02c5\u02c6\5\u0090I\2"+ 6792 "\u02c6\u02c7\5\u00ba^\2\u02c7\u02c8\5\u009cO\2\u02c8\u02ca\3\2\2\2\u02c9"+ 6793 "\u02c2\3\2\2\2\u02c9\u02c5\3\2\2\2\u02ca\u008f\3\2\2\2\u02cb\u02d7\5\u0092"+ 6794 "J\2\u02cc\u02cd\5\u0098M\2\u02cd\u02ce\5\u0092J\2\u02ce\u02d7\3\2\2\2"+ 6795 "\u02cf\u02d0\5\u0092J\2\u02d0\u02d1\5\u009aN\2\u02d1\u02d7\3\2\2\2\u02d2"+ 6796 "\u02d3\5\u0098M\2\u02d3\u02d4\5\u0092J\2\u02d4\u02d5\5\u009aN\2\u02d5"+ 6797 "\u02d7\3\2\2\2\u02d6\u02cb\3\2\2\2\u02d6\u02cc\3\2\2\2\u02d6\u02cf\3\2"+ 6798 "\2\2\u02d6\u02d2\3\2\2\2\u02d7\u0091\3\2\2\2\u02d8\u02f8\7\u0091\2\2\u02d9"+ 6799 "\u02f8\7\u0092\2\2\u02da\u02f8\7\u0093\2\2\u02db\u02f8\7\u0094\2\2\u02dc"+ 6800 "\u02f8\7\u0095\2\2\u02dd\u02f8\7\u0096\2\2\u02de\u02f8\7\u0097\2\2\u02df"+ 6801 "\u02f8\7\u0098\2\2\u02e0\u02f8\7\u0099\2\2\u02e1\u02f8\7\u009a\2\2\u02e2"+ 6802 "\u02f8\7\u009b\2\2\u02e3\u02f8\7\u009c\2\2\u02e4\u02f8\7\u009d\2\2\u02e5"+ 6803 "\u02f8\7\u009e\2\2\u02e6\u02f8\7\u009f\2\2\u02e7\u02f8\7\u00a0\2\2\u02e8"+ 6804 "\u02f8\7\u00a1\2\2\u02e9\u02f8\7\u00a2\2\2\u02ea\u02f8\7\u00a3\2\2\u02eb"+ 6805 "\u02f8\7\u00a4\2\2\u02ec\u02f8\7\u00a5\2\2\u02ed\u02f8\7\u00a6\2\2\u02ee"+ 6806 "\u02f8\7\u00a7\2\2\u02ef\u02f8\7\u00a8\2\2\u02f0\u02f8\7\u00a9\2\2\u02f1"+ 6807 "\u02f8\7\u00aa\2\2\u02f2\u02f8\7\u00ab\2\2\u02f3\u02f8\7\u00ac\2\2\u02f4"+ 6808 "\u02f8\7\u00ad\2\2\u02f5\u02f8\7\u00ae\2\2\u02f6\u02f8\5\u0094K\2\u02f7"+ 6809 "\u02d8\3\2\2\2\u02f7\u02d9\3\2\2\2\u02f7\u02da\3\2\2\2\u02f7\u02db\3\2"+ 6810 "\2\2\u02f7\u02dc\3\2\2\2\u02f7\u02dd\3\2\2\2\u02f7\u02de\3\2\2\2\u02f7"+ 6811 "\u02df\3\2\2\2\u02f7\u02e0\3\2\2\2\u02f7\u02e1\3\2\2\2\u02f7\u02e2\3\2"+ 6812 "\2\2\u02f7\u02e3\3\2\2\2\u02f7\u02e4\3\2\2\2\u02f7\u02e5\3\2\2\2\u02f7"+ 6813 "\u02e6\3\2\2\2\u02f7\u02e7\3\2\2\2\u02f7\u02e8\3\2\2\2\u02f7\u02e9\3\2"+ 6814 "\2\2\u02f7\u02ea\3\2\2\2\u02f7\u02eb\3\2\2\2\u02f7\u02ec\3\2\2\2\u02f7"+ 6815 "\u02ed\3\2\2\2\u02f7\u02ee\3\2\2\2\u02f7\u02ef\3\2\2\2\u02f7\u02f0\3\2"+ 6816 "\2\2\u02f7\u02f1\3\2\2\2\u02f7\u02f2\3\2\2\2\u02f7\u02f3\3\2\2\2\u02f7"+ 6817 "\u02f4\3\2\2\2\u02f7\u02f5\3\2\2\2\u02f7\u02f6\3\2\2\2\u02f8\u0093\3\2"+ 6818 "\2\2\u02f9\u02fa\7\u00af\2\2\u02fa\u02fb\5\u00ba^\2\u02fb\u02fc\5\u0096"+ 6819 "L\2\u02fc\u02ff\3\2\2\2\u02fd\u02ff\5\u0096L\2\u02fe\u02f9\3\2\2\2\u02fe"+ 6820 "\u02fd\3\2\2\2\u02ff\u0095\3\2\2\2\u0300\u0301\t\r\2\2\u0301\u0097\3\2"+ 6821 "\2\2\u0302\u0303\bM\1\2\u0303\u0304\7\u00ed\2\2\u0304\u0305\5\u0098M\2"+ 6822 "\u0305\u0306\7\u00ee\2\2\u0306\u0318\3\2\2\2\u0307\u0318\7\u00c9\2\2\u0308"+ 6823 "\u0318\7\u00ca\2\2\u0309\u0318\7\u00cb\2\2\u030a\u0318\7\u00cc\2\2\u030b"+ 6824 "\u0318\7\u00cd\2\2\u030c\u0318\7\u00ce\2\2\u030d\u0318\7\u00cf\2\2\u030e"+ 6825 "\u0318\7\u00d0\2\2\u030f\u0318\7\u00d1\2\2\u0310\u0318\7\u00d2\2\2\u0311"+ 6826 "\u0318\7\u00d3\2\2\u0312\u0318\7\u00d4\2\2\u0313\u0318\7\u00d5\2\2\u0314"+ 6827 "\u0318\7\u00d6\2\2\u0315\u0318\7\u00d0\2\2\u0316\u0318\7\u00d7\2\2\u0317"+ 6828 "\u0302\3\2\2\2\u0317\u0307\3\2\2\2\u0317\u0308\3\2\2\2\u0317\u0309\3\2"+ 6829 "\2\2\u0317\u030a\3\2\2\2\u0317\u030b\3\2\2\2\u0317\u030c\3\2\2\2\u0317"+ 6830 "\u030d\3\2\2\2\u0317\u030e\3\2\2\2\u0317\u030f\3\2\2\2\u0317\u0310\3\2"+ 6831 "\2\2\u0317\u0311\3\2\2\2\u0317\u0312\3\2\2\2\u0317\u0313\3\2\2\2\u0317"+ 6832 "\u0314\3\2\2\2\u0317\u0315\3\2\2\2\u0317\u0316\3\2\2\2\u0318\u031f\3\2"+ 6833 "\2\2\u0319\u031a\f\24\2\2\u031a\u031e\5\u0098M\25\u031b\u031c\f\25\2\2"+ 6834 "\u031c\u031e\7\u00e8\2\2\u031d\u0319\3\2\2\2\u031d\u031b\3\2\2\2\u031e"+ 6835 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0099\3\2"+ 6836 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\bN\1\2\u0323\u0324\7\u00ed\2\2\u0324"+ 6837 "\u0325\5\u009aN\2\u0325\u0326\7\u00ee\2\2\u0326\u032b\3\2\2\2\u0327\u032b"+ 6838 "\7\u00d0\2\2\u0328\u032b\7\u00ce\2\2\u0329\u032b\7\u00d8\2\2\u032a\u0322"+ 6839 "\3\2\2\2\u032a\u0327\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u0329\3\2\2\2\u032b"+ 6840 "\u0332\3\2\2\2\u032c\u032d\f\b\2\2\u032d\u0331\5\u009aN\t\u032e\u032f"+ 6841 "\f\7\2\2\u032f\u0331\7\u00ea\2\2\u0330\u032c\3\2\2\2\u0330\u032e\3\2\2"+ 6842 "\2\u0331\u0334\3\2\2\2\u0332\u0330\3\2\2\2\u0332\u0333\3\2\2\2\u0333\u009b"+ 6843 "\3\2\2\2\u0334\u0332\3\2\2\2\u0335\u0338\5\u009eP\2\u0336\u0338\5\u00a0"+ 6844 "Q\2\u0337\u0335\3\2\2\2\u0337\u0336\3\2\2\2\u0338\u009d\3\2\2\2\u0339"+ 6845 "\u033a\7\u00ed\2\2\u033a\u033b\5\24\13\2\u033b\u033c\7\u00ee\2\2\u033c"+ 6846 "\u009f\3\2\2\2\u033d\u033e\7\u00ed\2\2\u033e\u033f\5\24\13\2\u033f\u0340"+ 6847 "\5\u00b8]\2\u0340\u0341\5\n\6\2\u0341\u0342\7\u00ee\2\2\u0342\u00a1\3"+ 6848 "\2\2\2\u0343\u0347\5\u00a4S\2\u0344\u0347\5\u00aaV\2\u0345\u0347\5\u00b0"+ 6849 "Y\2\u0346\u0343\3\2\2\2\u0346\u0344\3\2\2\2\u0346\u0345\3\2\2\2\u0347"+ 6850 "\u00a3\3\2\2\2\u0348\u0349\5\u00a6T\2\u0349\u034a\5\u00a8U\2\u034a\u0350"+ 6851 "\3\2\2\2\u034b\u034c\5\u00a6T\2\u034c\u034d\5\u00ba^\2\u034d\u034e\5\u00a8"+ 6852 "U\2\u034e\u0350\3\2\2\2\u034f\u0348\3\2\2\2\u034f\u034b\3\2\2\2\u0350"+ 6853 "\u00a5\3\2\2\2\u0351\u0352\7\u00d9\2\2\u0352\u00a7\3\2\2\2\u0353\u0354"+ 6854 "\7\u00ed\2\2\u0354\u0355\5@!\2\u0355\u0356\7\u00ee\2\2\u0356\u00a9\3\2"+ 6855 "\2\2\u0357\u0358\5\u00acW\2\u0358\u0359\5\u00aeX\2\u0359\u035f\3\2\2\2"+ 6856 "\u035a\u035b\5\u00acW\2\u035b\u035c\5\u00ba^\2\u035c\u035d\5\u00aeX\2"+ 6857 "\u035d\u035f\3\2\2\2\u035e\u0357\3\2\2\2\u035e\u035a\3\2\2\2\u035f\u00ab"+ 6858 "\3\2\2\2\u0360\u0361\7\u00da\2\2\u0361\u00ad\3\2\2\2\u0362\u0363\7\u00ed"+ 6859 "\2\2\u0363\u0364\5\n\6\2\u0364\u0365\7\u00ee\2\2\u0365\u00af\3\2\2\2\u0366"+ 6860 "\u0367\5\u00b2Z\2\u0367\u0368\5\u00b4[\2\u0368\u036e\3\2\2\2\u0369\u036a"+ 6861 "\5\u00b2Z\2\u036a\u036b\5\u00ba^\2\u036b\u036c\5\u00b4[\2\u036c\u036e"+ 6862 "\3\2\2\2\u036d\u0366\3\2\2\2\u036d\u0369\3\2\2\2\u036e\u00b1\3\2\2\2\u036f"+ 6863 "\u0370\7\u00d9\2\2\u0370\u00b3\3\2\2\2\u0371\u0372\7\u00ed\2\2\u0372\u0373"+ 6864 "\5B\"\2\u0373\u0374\7\u00ee\2\2\u0374\u00b5\3\2\2\2\u0375\u0376\7\u00e9"+ 6865 "\2\2\u0376\u00b7\3\2\2\2\u0377\u0378\7\u00ea\2\2\u0378\u00b9\3\2\2\2\u0379"+ 6866 "\u037a\7\u00e5\2\2\u037a\u00bb\3\2\2\2\u037b\u037c\7\u00e6\2\2\u037c\u00bd"+ 6867 "\3\2\2\2\u037d\u037e\7\u00ec\2\2\u037e\u00bf\3\2\2\2\u037f\u0380\7\u00ec"+ 6868 "\2\2\u0380\u00c1\3\2\2\2\u0381\u0382\7\u00e8\2\2\u0382\u00c3\3\2\2\2\u0383"+ 6869 "\u0384\7\u00e8\2\2\u0384\u00c5\3\2\2\2\u0385\u0386\5\u00c8e\2\u0386\u00c7"+ 6870 "\3\2\2\2\u0387\u0388\be\1\2\u0388\u0393\7\u00db\2\2\u0389\u0393\7\u00dc"+ 6871 "\2\2\u038a\u0393\7\u00dd\2\2\u038b\u0393\7\u00de\2\2\u038c\u0393\7\u00df"+ 6872 "\2\2\u038d\u0393\7\u00e0\2\2\u038e\u0393\7\u00e1\2\2\u038f\u0393\7\u00e2"+ 6873 "\2\2\u0390\u0393\7\u00e3\2\2\u0391\u0393\7\u00e4\2\2\u0392\u0387\3\2\2"+ 6874 "\2\u0392\u0389\3\2\2\2\u0392\u038a\3\2\2\2\u0392\u038b\3\2\2\2\u0392\u038c"+ 6875 "\3\2\2\2\u0392\u038d\3\2\2\2\u0392\u038e\3\2\2\2\u0392\u038f\3\2\2\2\u0392"+ 6876 "\u0390\3\2\2\2\u0392\u0391\3\2\2\2\u0393\u0398\3\2\2\2\u0394\u0395\f\3"+ 6877 "\2\2\u0395\u0397\5\u00c8e\4\u0396\u0394\3\2\2\2\u0397\u039a\3\2\2\2\u0398"+ 6878 "\u0396\3\2\2\2\u0398\u0399\3\2\2\2\u0399\u00c9\3\2\2\2\u039a\u0398\3\2"+ 6879 "\2\2;\u00d1\u00d8\u00e8\u00f3\u00f7\u0103\u010f\u011c\u0130\u0137\u0148"+ 6880 "\u014f\u0159\u016a\u0174\u017e\u0186\u0192\u01a2\u01bf\u01d2\u0217\u021e"+ 6881 "\u0220\u0228\u022f\u0237\u023f\u0248\u0252\u025d\u026c\u0276\u027d\u0286"+ 6882 "\u0290\u029b\u02a5\u02b0\u02be\u02c9\u02d6\u02f7\u02fe\u0317\u031d\u031f"+ 6883 "\u032a\u0330\u0332\u0337\u0346\u034f\u035e\u036d\u0392\u0398"; 6884 public static final ATN _ATN = 6885 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 6886 static { 6887 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 6888 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 6889 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 6890 } 6891 } 6892}