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