001// Generated from de/isas/lipidomics/palinom/LipidMaps.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 LipidMapsParser 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, SPACE=218, COLON=219, SEMICOLON=220, DASH=221, 054 UNDERSCORE=222, SLASH=223, BACKSLASH=224, COMMA=225, ROB=226, RCB=227, 055 SOB=228, SCB=229; 056 public static final int 057 RULE_lipid = 0, RULE_lipid_rule = 1, RULE_lipid_mono = 2, RULE_lipid_pure = 3, 058 RULE_isoform = 4, RULE_isoform_inner = 5, RULE_isotope = 6, RULE_element = 7, 059 RULE_pure_fa = 8, RULE_fa_no_hg = 9, RULE_pure_fa_species = 10, RULE_hg_fa = 11, 060 RULE_fa2 = 12, RULE_fa2_unsorted = 13, RULE_fa2_sorted = 14, RULE_fa3 = 15, 061 RULE_fa3_unsorted = 16, RULE_fa3_sorted = 17, RULE_fa4 = 18, RULE_fa4_unsorted = 19, 062 RULE_fa4_sorted = 20, RULE_lcb_fa_sorted = 21, RULE_species_fa = 22, RULE_gl = 23, 063 RULE_sgl = 24, RULE_sgl_species = 25, RULE_sgl_subspecies = 26, RULE_tgl = 27, 064 RULE_tgl_species = 28, RULE_tgl_subspecies = 29, RULE_hg_sglc = 30, RULE_hg_sgl = 31, 065 RULE_hg_glc = 32, RULE_hg_gl = 33, RULE_pl = 34, RULE_lpl = 35, RULE_fa_lpl = 36, 066 RULE_dpl = 37, RULE_dpl_species = 38, RULE_dpl_subspecies = 39, RULE_cl = 40, 067 RULE_cl_species = 41, RULE_cl_subspecies = 42, RULE_fourpl = 43, RULE_threepl = 44, 068 RULE_hg_ddpl = 45, RULE_hg_clc = 46, RULE_hg_cl = 47, RULE_hg_dplc = 48, 069 RULE_hg_dpl = 49, RULE_hg_lplc = 50, RULE_hg_lpl = 51, RULE_hg_fourplc = 52, 070 RULE_hg_fourpl = 53, RULE_pip_position = 54, RULE_pip_pos = 55, RULE_hg_threeplc = 56, 071 RULE_hg_threepl = 57, RULE_sl = 58, RULE_lsl = 59, RULE_dsl = 60, RULE_dsl_species = 61, 072 RULE_dsl_subspecies = 62, RULE_sphingoxine = 63, RULE_sphingoxine_pure = 64, 073 RULE_sphingoxine_var = 65, RULE_sphingosine_name = 66, RULE_sphinganine_name = 67, 074 RULE_ctype = 68, RULE_hg_dslc = 69, RULE_hg_dsl = 70, RULE_special_cer = 71, 075 RULE_special_cer_prefix = 72, RULE_special_cer_prefix_1_O = 73, RULE_hg_lslc = 74, 076 RULE_hg_lsl = 75, RULE_pk = 76, RULE_pk_hg = 77, RULE_pk_fa = 78, RULE_sterol = 79, 077 RULE_chc = 80, RULE_ch = 81, RULE_chec = 82, RULE_che = 83, RULE_che_fa = 84, 078 RULE_hg_che = 85, RULE_mediator = 86, RULE_mediator_var = 87, RULE_mediator_prefix = 88, 079 RULE_mediator_numbers = 89, RULE_mediator_number_pure = 90, RULE_mediator_pos = 91, 080 RULE_mediator_var_names = 92, RULE_mediator_var_name = 93, RULE_mediator_const = 94, 081 RULE_mediator_oxo = 95, RULE_fa = 96, RULE_fa_unmod = 97, RULE_fa_mod = 98, 082 RULE_modification = 99, RULE_mod_text = 100, RULE_ether = 101, RULE_fa_pure = 102, 083 RULE_lcb_fa = 103, RULE_lcb_fa_unmod = 104, RULE_lcb_fa_mod = 105, RULE_lcb = 106, 084 RULE_carbon = 107, RULE_db = 108, RULE_db_count = 109, RULE_db_positions = 110, 085 RULE_db_position = 111, RULE_db_single_position = 112, RULE_db_position_number = 113, 086 RULE_cistrans = 114, RULE_hydroxyl = 115, RULE_hydroxyl_lcb = 116, RULE_number = 117, 087 RULE_fa_separator = 118, RULE_headgroup_separator = 119, RULE_fa_mod_separator = 120, 088 RULE_carbon_db_separator = 121, RULE_db_hydroxyl_separator = 122, RULE_db_position_separator = 123, 089 RULE_mediator_separator = 124, RULE_mediator_name_separator = 125, RULE_round_open_bracket = 126, 090 RULE_round_close_bracket = 127, RULE_square_open_bracket = 128, RULE_square_close_bracket = 129; 091 private static String[] makeRuleNames() { 092 return new String[] { 093 "lipid", "lipid_rule", "lipid_mono", "lipid_pure", "isoform", "isoform_inner", 094 "isotope", "element", "pure_fa", "fa_no_hg", "pure_fa_species", "hg_fa", 095 "fa2", "fa2_unsorted", "fa2_sorted", "fa3", "fa3_unsorted", "fa3_sorted", 096 "fa4", "fa4_unsorted", "fa4_sorted", "lcb_fa_sorted", "species_fa", "gl", 097 "sgl", "sgl_species", "sgl_subspecies", "tgl", "tgl_species", "tgl_subspecies", 098 "hg_sglc", "hg_sgl", "hg_glc", "hg_gl", "pl", "lpl", "fa_lpl", "dpl", 099 "dpl_species", "dpl_subspecies", "cl", "cl_species", "cl_subspecies", 100 "fourpl", "threepl", "hg_ddpl", "hg_clc", "hg_cl", "hg_dplc", "hg_dpl", 101 "hg_lplc", "hg_lpl", "hg_fourplc", "hg_fourpl", "pip_position", "pip_pos", 102 "hg_threeplc", "hg_threepl", "sl", "lsl", "dsl", "dsl_species", "dsl_subspecies", 103 "sphingoxine", "sphingoxine_pure", "sphingoxine_var", "sphingosine_name", 104 "sphinganine_name", "ctype", "hg_dslc", "hg_dsl", "special_cer", "special_cer_prefix", 105 "special_cer_prefix_1_O", "hg_lslc", "hg_lsl", "pk", "pk_hg", "pk_fa", 106 "sterol", "chc", "ch", "chec", "che", "che_fa", "hg_che", "mediator", 107 "mediator_var", "mediator_prefix", "mediator_numbers", "mediator_number_pure", 108 "mediator_pos", "mediator_var_names", "mediator_var_name", "mediator_const", 109 "mediator_oxo", "fa", "fa_unmod", "fa_mod", "modification", "mod_text", 110 "ether", "fa_pure", "lcb_fa", "lcb_fa_unmod", "lcb_fa_mod", "lcb", "carbon", 111 "db", "db_count", "db_positions", "db_position", "db_single_position", 112 "db_position_number", "cistrans", "hydroxyl", "hydroxyl_lcb", "number", 113 "fa_separator", "headgroup_separator", "fa_mod_separator", "carbon_db_separator", 114 "db_hydroxyl_separator", "db_position_separator", "mediator_separator", 115 "mediator_name_separator", "round_open_bracket", "round_close_bracket", 116 "square_open_bracket", "square_close_bracket" 117 }; 118 } 119 public static final String[] ruleNames = makeRuleNames(); 120 121 private static String[] makeLiteralNames() { 122 return new String[] { 123 null, "'rac'", "'iso'", "'R'", "'d'", "'FA'", "'WE'", "'CoA'", "'CAR'", 124 "'FAHFA'", "'MGDG'", "'DGDG'", "'SQDG'", "'SQMG'", "'DG'", "'DGCC'", 125 "'PE-GlcDG'", "'MG'", "'TG'", "'1'-'", "',3'-'", "'CL'", "'LBPA'", "'CDP-DG'", 126 "'DMPE'", "'MMPE'", "'PA'", "'PC'", "'PE'", "'PEt'", "'PG'", "'PI'", 127 "'PIP'", "'PIP2'", "'PIP3'", "'PS'", "'PIM1'", "'PIM2'", "'PIM3'", "'PIM4'", 128 "'PIM5'", "'PIM6'", "'Glc-DG'", "'PGP'", "'PE-NMe2'", "'AC2SGL'", "'DAT'", 129 "'PE-NMe'", "'PT'", "'Glc-GP'", "'PPA'", "'PnC'", "'PnE'", "'6-Ac-Glc-GP'", 130 "'LysoPC'", "'LPC'", "'LysoPE'", "'LPE'", "'LPI'", "'LPG'", "'LPS'", 131 "'LPIM1'", "'LPIM2'", "'LPIM3'", "'LPIM4'", "'LPIM5'", "'LPIM6'", "'CPA'", 132 "'LPA'", "'PAT16'", "'PAT18'", "'''", "'SLBPA'", "'PS-NAc'", "'NAPE'", 133 "'Sphingosine'", "'So'", "'Sphingosine-1-phosphate'", "'Sphinganine'", 134 "'Sa'", "'Sphinganine-1-phosphate'", "'C'", "'Cer'", "'CerP'", "'EPC'", 135 "'GB3'", "'GB4'", "'GD3'", "'GM3'", "'GM4'", "'Hex3Cer'", "'Hex2Cer'", 136 "'HexCer'", "'IPC'", "'M(IP)2C'", "'MIPC'", "'SHexCer'", "'SulfoHexCer'", 137 "'SM'", "'PE-Cer'", "'PI-Cer'", "'GlcCer'", "'FMC-5'", "'FMC-6'", "'LacCer'", 138 "'GalCer'", "'C1P'", "'-Cer'", "'1-O-'", "'(3'-sulfo)Galbeta'", "'myristoyl'", 139 "'palmitoyl'", "'stearoyl'", "'eicosanoyl'", "'behenoyl'", "'lignoceroyl'", 140 "'cerotoyl'", "'carboceroyl'", "'tricosanoyl'", "'SPH'", "'Sph'", "'S1P'", 141 "'HexSph'", "'SPC'", "'SPH-P'", "'LysoSM'", "'SIP'", "'RESORCINOL'", 142 "'ANACARD'", "'PHENOL'", "'CATECHOL'", "'Cholesterol'", "'Cholesteryl ester'", 143 "'Cholesterol ester'", "'CE'", "'(+/-)-'", "'S'", "'HHTrE'", "'EpOME'", 144 "'HODE'", "'HOTrE'", "'DHET'", "'EET'", "'EpETE'", "'HEPE'", "'HETE'", 145 "'PGJ2'", "'HDoHE'", "'HpETE'", "'ETE'", "'DiHETE'", "'LXA4'", "'Arachidonic acid'", 146 "'Arachidonic Acid'", "'alpha-LA'", "'DHA'", "'EPA'", "'Linoleic acid'", 147 "'LTB4'", "'LTC4'", "'LTD4'", "'Maresin 1'", "'Palmitic acid'", "'PGB2'", 148 "'PGD2'", "'PGE2'", "'PGF2alpha'", "'PGI2'", "'Resolvin D1'", "'Resolvin D2'", 149 "'Resolvin D3'", "'Resolvin D5'", "'tetranor-12-HETE'", "'TXB1'", "'TXB2'", 150 "'TXB3'", "'Oxo'", "'oxo'", "'OH'", "'Ke'", "'OOH'", "'My'", "'Me'", 151 "'Br'", "'CHO'", "'COOH'", "'Cp'", "'(R)'", "'Ep'", "'OH2'", "'OH3'", 152 "'OH4'", "'OH6'", "'cyclo'", "'cyclo2'", "'KE2'", "'Ke2'", "'NH2'", "'Me6'", 153 "'Me2'", "'Me3'", "'Y'", "'P-'", "'O-'", "'E'", "'Z'", "'m'", "'t'", 154 "'0'", "'1'", "'2'", "'3'", "'4'", "'5'", "'6'", "'7'", "'8'", "'9'", 155 "' '", "':'", "';'", "'-'", "'_'", "'/'", "'\\'", "','", "'('", "')'", 156 "'['", "']'" 157 }; 158 } 159 private static final String[] _LITERAL_NAMES = makeLiteralNames(); 160 private static String[] makeSymbolicNames() { 161 return new String[] { 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, null, 170 null, null, null, null, null, null, null, null, null, null, null, null, 171 null, null, null, null, null, null, null, null, null, null, null, null, 172 null, null, null, null, null, null, null, null, null, null, null, null, 173 null, null, null, null, null, null, null, null, null, null, null, null, 174 null, null, null, null, null, null, null, null, null, null, null, null, 175 null, null, null, null, null, null, null, null, null, null, null, null, 176 null, null, null, null, null, null, null, null, null, null, null, null, 177 null, null, null, null, null, null, null, null, null, null, null, null, 178 null, null, null, null, null, null, null, null, null, null, null, null, 179 null, null, null, null, null, null, null, null, null, null, null, null, 180 null, null, "SPACE", "COLON", "SEMICOLON", "DASH", "UNDERSCORE", "SLASH", 181 "BACKSLASH", "COMMA", "ROB", "RCB", "SOB", "SCB" 182 }; 183 } 184 private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 185 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 186 187 /** 188 * @deprecated Use {@link #VOCABULARY} instead. 189 */ 190 @Deprecated 191 public static final String[] tokenNames; 192 static { 193 tokenNames = new String[_SYMBOLIC_NAMES.length]; 194 for (int i = 0; i < tokenNames.length; i++) { 195 tokenNames[i] = VOCABULARY.getLiteralName(i); 196 if (tokenNames[i] == null) { 197 tokenNames[i] = VOCABULARY.getSymbolicName(i); 198 } 199 200 if (tokenNames[i] == null) { 201 tokenNames[i] = "<INVALID>"; 202 } 203 } 204 } 205 206 @Override 207 @Deprecated 208 public String[] getTokenNames() { 209 return tokenNames; 210 } 211 212 @Override 213 214 public Vocabulary getVocabulary() { 215 return VOCABULARY; 216 } 217 218 @Override 219 public String getGrammarFileName() { return "LipidMaps.g4"; } 220 221 @Override 222 public String[] getRuleNames() { return ruleNames; } 223 224 @Override 225 public String getSerializedATN() { return _serializedATN; } 226 227 @Override 228 public ATN getATN() { return _ATN; } 229 230 public LipidMapsParser(TokenStream input) { 231 super(input); 232 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 233 } 234 235 public static class LipidContext extends ParserRuleContext { 236 public Lipid_ruleContext lipid_rule() { 237 return getRuleContext(Lipid_ruleContext.class,0); 238 } 239 public TerminalNode EOF() { return getToken(LipidMapsParser.EOF, 0); } 240 public LipidContext(ParserRuleContext parent, int invokingState) { 241 super(parent, invokingState); 242 } 243 @Override public int getRuleIndex() { return RULE_lipid; } 244 @Override 245 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 246 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLipid(this); 247 else return visitor.visitChildren(this); 248 } 249 } 250 251 public final LipidContext lipid() throws RecognitionException { 252 LipidContext _localctx = new LipidContext(_ctx, getState()); 253 enterRule(_localctx, 0, RULE_lipid); 254 try { 255 enterOuterAlt(_localctx, 1); 256 { 257 setState(260); 258 lipid_rule(); 259 setState(261); 260 match(EOF); 261 } 262 } 263 catch (RecognitionException re) { 264 _localctx.exception = re; 265 _errHandler.reportError(this, re); 266 _errHandler.recover(this, re); 267 } 268 finally { 269 exitRule(); 270 } 271 return _localctx; 272 } 273 274 public static class Lipid_ruleContext extends ParserRuleContext { 275 public Lipid_monoContext lipid_mono() { 276 return getRuleContext(Lipid_monoContext.class,0); 277 } 278 public IsotopeContext isotope() { 279 return getRuleContext(IsotopeContext.class,0); 280 } 281 public Lipid_ruleContext(ParserRuleContext parent, int invokingState) { 282 super(parent, invokingState); 283 } 284 @Override public int getRuleIndex() { return RULE_lipid_rule; } 285 @Override 286 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 287 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLipid_rule(this); 288 else return visitor.visitChildren(this); 289 } 290 } 291 292 public final Lipid_ruleContext lipid_rule() throws RecognitionException { 293 Lipid_ruleContext _localctx = new Lipid_ruleContext(_ctx, getState()); 294 enterRule(_localctx, 2, RULE_lipid_rule); 295 try { 296 setState(267); 297 _errHandler.sync(this); 298 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 299 case 1: 300 enterOuterAlt(_localctx, 1); 301 { 302 setState(263); 303 lipid_mono(); 304 } 305 break; 306 case 2: 307 enterOuterAlt(_localctx, 2); 308 { 309 setState(264); 310 lipid_mono(); 311 setState(265); 312 isotope(); 313 } 314 break; 315 } 316 } 317 catch (RecognitionException re) { 318 _localctx.exception = re; 319 _errHandler.reportError(this, re); 320 _errHandler.recover(this, re); 321 } 322 finally { 323 exitRule(); 324 } 325 return _localctx; 326 } 327 328 public static class Lipid_monoContext extends ParserRuleContext { 329 public Lipid_pureContext lipid_pure() { 330 return getRuleContext(Lipid_pureContext.class,0); 331 } 332 public IsoformContext isoform() { 333 return getRuleContext(IsoformContext.class,0); 334 } 335 public Lipid_monoContext(ParserRuleContext parent, int invokingState) { 336 super(parent, invokingState); 337 } 338 @Override public int getRuleIndex() { return RULE_lipid_mono; } 339 @Override 340 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 341 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLipid_mono(this); 342 else return visitor.visitChildren(this); 343 } 344 } 345 346 public final Lipid_monoContext lipid_mono() throws RecognitionException { 347 Lipid_monoContext _localctx = new Lipid_monoContext(_ctx, getState()); 348 enterRule(_localctx, 4, RULE_lipid_mono); 349 try { 350 setState(273); 351 _errHandler.sync(this); 352 switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { 353 case 1: 354 enterOuterAlt(_localctx, 1); 355 { 356 setState(269); 357 lipid_pure(); 358 } 359 break; 360 case 2: 361 enterOuterAlt(_localctx, 2); 362 { 363 setState(270); 364 lipid_pure(); 365 setState(271); 366 isoform(); 367 } 368 break; 369 } 370 } 371 catch (RecognitionException re) { 372 _localctx.exception = re; 373 _errHandler.reportError(this, re); 374 _errHandler.recover(this, re); 375 } 376 finally { 377 exitRule(); 378 } 379 return _localctx; 380 } 381 382 public static class Lipid_pureContext extends ParserRuleContext { 383 public Pure_faContext pure_fa() { 384 return getRuleContext(Pure_faContext.class,0); 385 } 386 public GlContext gl() { 387 return getRuleContext(GlContext.class,0); 388 } 389 public PlContext pl() { 390 return getRuleContext(PlContext.class,0); 391 } 392 public SlContext sl() { 393 return getRuleContext(SlContext.class,0); 394 } 395 public PkContext pk() { 396 return getRuleContext(PkContext.class,0); 397 } 398 public SterolContext sterol() { 399 return getRuleContext(SterolContext.class,0); 400 } 401 public MediatorContext mediator() { 402 return getRuleContext(MediatorContext.class,0); 403 } 404 public Lipid_pureContext(ParserRuleContext parent, int invokingState) { 405 super(parent, invokingState); 406 } 407 @Override public int getRuleIndex() { return RULE_lipid_pure; } 408 @Override 409 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 410 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLipid_pure(this); 411 else return visitor.visitChildren(this); 412 } 413 } 414 415 public final Lipid_pureContext lipid_pure() throws RecognitionException { 416 Lipid_pureContext _localctx = new Lipid_pureContext(_ctx, getState()); 417 enterRule(_localctx, 6, RULE_lipid_pure); 418 try { 419 setState(282); 420 _errHandler.sync(this); 421 switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) { 422 case 1: 423 enterOuterAlt(_localctx, 1); 424 { 425 setState(275); 426 pure_fa(); 427 } 428 break; 429 case 2: 430 enterOuterAlt(_localctx, 2); 431 { 432 setState(276); 433 gl(); 434 } 435 break; 436 case 3: 437 enterOuterAlt(_localctx, 3); 438 { 439 setState(277); 440 pl(); 441 } 442 break; 443 case 4: 444 enterOuterAlt(_localctx, 4); 445 { 446 setState(278); 447 sl(); 448 } 449 break; 450 case 5: 451 enterOuterAlt(_localctx, 5); 452 { 453 setState(279); 454 pk(); 455 } 456 break; 457 case 6: 458 enterOuterAlt(_localctx, 6); 459 { 460 setState(280); 461 sterol(); 462 } 463 break; 464 case 7: 465 enterOuterAlt(_localctx, 7); 466 { 467 setState(281); 468 mediator(); 469 } 470 break; 471 } 472 } 473 catch (RecognitionException re) { 474 _localctx.exception = re; 475 _errHandler.reportError(this, re); 476 _errHandler.recover(this, re); 477 } 478 finally { 479 exitRule(); 480 } 481 return _localctx; 482 } 483 484 public static class IsoformContext extends ParserRuleContext { 485 public Square_open_bracketContext square_open_bracket() { 486 return getRuleContext(Square_open_bracketContext.class,0); 487 } 488 public Isoform_innerContext isoform_inner() { 489 return getRuleContext(Isoform_innerContext.class,0); 490 } 491 public Square_close_bracketContext square_close_bracket() { 492 return getRuleContext(Square_close_bracketContext.class,0); 493 } 494 public IsoformContext(ParserRuleContext parent, int invokingState) { 495 super(parent, invokingState); 496 } 497 @Override public int getRuleIndex() { return RULE_isoform; } 498 @Override 499 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 500 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitIsoform(this); 501 else return visitor.visitChildren(this); 502 } 503 } 504 505 public final IsoformContext isoform() throws RecognitionException { 506 IsoformContext _localctx = new IsoformContext(_ctx, getState()); 507 enterRule(_localctx, 8, RULE_isoform); 508 try { 509 enterOuterAlt(_localctx, 1); 510 { 511 setState(284); 512 square_open_bracket(); 513 setState(285); 514 isoform_inner(); 515 setState(286); 516 square_close_bracket(); 517 } 518 } 519 catch (RecognitionException re) { 520 _localctx.exception = re; 521 _errHandler.reportError(this, re); 522 _errHandler.recover(this, re); 523 } 524 finally { 525 exitRule(); 526 } 527 return _localctx; 528 } 529 530 public static class Isoform_innerContext extends ParserRuleContext { 531 public NumberContext number() { 532 return getRuleContext(NumberContext.class,0); 533 } 534 public Isoform_innerContext(ParserRuleContext parent, int invokingState) { 535 super(parent, invokingState); 536 } 537 @Override public int getRuleIndex() { return RULE_isoform_inner; } 538 @Override 539 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 540 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitIsoform_inner(this); 541 else return visitor.visitChildren(this); 542 } 543 } 544 545 public final Isoform_innerContext isoform_inner() throws RecognitionException { 546 Isoform_innerContext _localctx = new Isoform_innerContext(_ctx, getState()); 547 enterRule(_localctx, 10, RULE_isoform_inner); 548 try { 549 setState(293); 550 _errHandler.sync(this); 551 switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { 552 case 1: 553 enterOuterAlt(_localctx, 1); 554 { 555 setState(288); 556 match(T__0); 557 } 558 break; 559 case 2: 560 enterOuterAlt(_localctx, 2); 561 { 562 setState(289); 563 match(T__1); 564 } 565 break; 566 case 3: 567 enterOuterAlt(_localctx, 3); 568 { 569 setState(290); 570 match(T__1); 571 setState(291); 572 number(0); 573 } 574 break; 575 case 4: 576 enterOuterAlt(_localctx, 4); 577 { 578 setState(292); 579 match(T__2); 580 } 581 break; 582 } 583 } 584 catch (RecognitionException re) { 585 _localctx.exception = re; 586 _errHandler.reportError(this, re); 587 _errHandler.recover(this, re); 588 } 589 finally { 590 exitRule(); 591 } 592 return _localctx; 593 } 594 595 public static class IsotopeContext extends ParserRuleContext { 596 public TerminalNode SPACE() { return getToken(LipidMapsParser.SPACE, 0); } 597 public Round_open_bracketContext round_open_bracket() { 598 return getRuleContext(Round_open_bracketContext.class,0); 599 } 600 public ElementContext element() { 601 return getRuleContext(ElementContext.class,0); 602 } 603 public NumberContext number() { 604 return getRuleContext(NumberContext.class,0); 605 } 606 public Round_close_bracketContext round_close_bracket() { 607 return getRuleContext(Round_close_bracketContext.class,0); 608 } 609 public TerminalNode DASH() { return getToken(LipidMapsParser.DASH, 0); } 610 public IsotopeContext(ParserRuleContext parent, int invokingState) { 611 super(parent, invokingState); 612 } 613 @Override public int getRuleIndex() { return RULE_isotope; } 614 @Override 615 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 616 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitIsotope(this); 617 else return visitor.visitChildren(this); 618 } 619 } 620 621 public final IsotopeContext isotope() throws RecognitionException { 622 IsotopeContext _localctx = new IsotopeContext(_ctx, getState()); 623 enterRule(_localctx, 12, RULE_isotope); 624 try { 625 setState(311); 626 _errHandler.sync(this); 627 switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { 628 case 1: 629 enterOuterAlt(_localctx, 1); 630 { 631 setState(295); 632 match(SPACE); 633 setState(296); 634 round_open_bracket(); 635 setState(297); 636 element(); 637 setState(298); 638 number(0); 639 setState(299); 640 round_close_bracket(); 641 } 642 break; 643 case 2: 644 enterOuterAlt(_localctx, 2); 645 { 646 setState(301); 647 match(DASH); 648 setState(302); 649 round_open_bracket(); 650 setState(303); 651 element(); 652 setState(304); 653 number(0); 654 setState(305); 655 round_close_bracket(); 656 } 657 break; 658 case 3: 659 enterOuterAlt(_localctx, 3); 660 { 661 setState(307); 662 match(DASH); 663 setState(308); 664 element(); 665 setState(309); 666 number(0); 667 } 668 break; 669 } 670 } 671 catch (RecognitionException re) { 672 _localctx.exception = re; 673 _errHandler.reportError(this, re); 674 _errHandler.recover(this, re); 675 } 676 finally { 677 exitRule(); 678 } 679 return _localctx; 680 } 681 682 public static class ElementContext extends ParserRuleContext { 683 public ElementContext(ParserRuleContext parent, int invokingState) { 684 super(parent, invokingState); 685 } 686 @Override public int getRuleIndex() { return RULE_element; } 687 @Override 688 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 689 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitElement(this); 690 else return visitor.visitChildren(this); 691 } 692 } 693 694 public final ElementContext element() throws RecognitionException { 695 ElementContext _localctx = new ElementContext(_ctx, getState()); 696 enterRule(_localctx, 14, RULE_element); 697 try { 698 enterOuterAlt(_localctx, 1); 699 { 700 setState(313); 701 match(T__3); 702 } 703 } 704 catch (RecognitionException re) { 705 _localctx.exception = re; 706 _errHandler.reportError(this, re); 707 _errHandler.recover(this, re); 708 } 709 finally { 710 exitRule(); 711 } 712 return _localctx; 713 } 714 715 public static class Pure_faContext extends ParserRuleContext { 716 public Hg_faContext hg_fa() { 717 return getRuleContext(Hg_faContext.class,0); 718 } 719 public Pure_fa_speciesContext pure_fa_species() { 720 return getRuleContext(Pure_fa_speciesContext.class,0); 721 } 722 public Fa_no_hgContext fa_no_hg() { 723 return getRuleContext(Fa_no_hgContext.class,0); 724 } 725 public Pure_faContext(ParserRuleContext parent, int invokingState) { 726 super(parent, invokingState); 727 } 728 @Override public int getRuleIndex() { return RULE_pure_fa; } 729 @Override 730 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 731 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPure_fa(this); 732 else return visitor.visitChildren(this); 733 } 734 } 735 736 public final Pure_faContext pure_fa() throws RecognitionException { 737 Pure_faContext _localctx = new Pure_faContext(_ctx, getState()); 738 enterRule(_localctx, 16, RULE_pure_fa); 739 try { 740 setState(319); 741 _errHandler.sync(this); 742 switch (_input.LA(1)) { 743 case T__4: 744 case T__5: 745 case T__6: 746 case T__7: 747 case T__8: 748 enterOuterAlt(_localctx, 1); 749 { 750 setState(315); 751 hg_fa(); 752 setState(316); 753 pure_fa_species(); 754 } 755 break; 756 case T__201: 757 case T__202: 758 case T__207: 759 case T__208: 760 case T__209: 761 case T__210: 762 case T__211: 763 case T__212: 764 case T__213: 765 case T__214: 766 case T__215: 767 case T__216: 768 case ROB: 769 enterOuterAlt(_localctx, 2); 770 { 771 setState(318); 772 fa_no_hg(); 773 } 774 break; 775 default: 776 throw new NoViableAltException(this); 777 } 778 } 779 catch (RecognitionException re) { 780 _localctx.exception = re; 781 _errHandler.reportError(this, re); 782 _errHandler.recover(this, re); 783 } 784 finally { 785 exitRule(); 786 } 787 return _localctx; 788 } 789 790 public static class Fa_no_hgContext extends ParserRuleContext { 791 public FaContext fa() { 792 return getRuleContext(FaContext.class,0); 793 } 794 public Fa_no_hgContext(ParserRuleContext parent, int invokingState) { 795 super(parent, invokingState); 796 } 797 @Override public int getRuleIndex() { return RULE_fa_no_hg; } 798 @Override 799 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 800 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa_no_hg(this); 801 else return visitor.visitChildren(this); 802 } 803 } 804 805 public final Fa_no_hgContext fa_no_hg() throws RecognitionException { 806 Fa_no_hgContext _localctx = new Fa_no_hgContext(_ctx, getState()); 807 enterRule(_localctx, 18, RULE_fa_no_hg); 808 try { 809 enterOuterAlt(_localctx, 1); 810 { 811 setState(321); 812 fa(); 813 } 814 } 815 catch (RecognitionException re) { 816 _localctx.exception = re; 817 _errHandler.reportError(this, re); 818 _errHandler.recover(this, re); 819 } 820 finally { 821 exitRule(); 822 } 823 return _localctx; 824 } 825 826 public static class Pure_fa_speciesContext extends ParserRuleContext { 827 public Round_open_bracketContext round_open_bracket() { 828 return getRuleContext(Round_open_bracketContext.class,0); 829 } 830 public FaContext fa() { 831 return getRuleContext(FaContext.class,0); 832 } 833 public Round_close_bracketContext round_close_bracket() { 834 return getRuleContext(Round_close_bracketContext.class,0); 835 } 836 public Fa2Context fa2() { 837 return getRuleContext(Fa2Context.class,0); 838 } 839 public Pure_fa_speciesContext(ParserRuleContext parent, int invokingState) { 840 super(parent, invokingState); 841 } 842 @Override public int getRuleIndex() { return RULE_pure_fa_species; } 843 @Override 844 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 845 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPure_fa_species(this); 846 else return visitor.visitChildren(this); 847 } 848 } 849 850 public final Pure_fa_speciesContext pure_fa_species() throws RecognitionException { 851 Pure_fa_speciesContext _localctx = new Pure_fa_speciesContext(_ctx, getState()); 852 enterRule(_localctx, 20, RULE_pure_fa_species); 853 try { 854 setState(332); 855 _errHandler.sync(this); 856 switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { 857 case 1: 858 enterOuterAlt(_localctx, 1); 859 { 860 setState(323); 861 round_open_bracket(); 862 setState(324); 863 fa(); 864 setState(325); 865 round_close_bracket(); 866 } 867 break; 868 case 2: 869 enterOuterAlt(_localctx, 2); 870 { 871 setState(327); 872 fa(); 873 } 874 break; 875 case 3: 876 enterOuterAlt(_localctx, 3); 877 { 878 setState(328); 879 round_open_bracket(); 880 setState(329); 881 fa2(); 882 setState(330); 883 round_close_bracket(); 884 } 885 break; 886 } 887 } 888 catch (RecognitionException re) { 889 _localctx.exception = re; 890 _errHandler.reportError(this, re); 891 _errHandler.recover(this, re); 892 } 893 finally { 894 exitRule(); 895 } 896 return _localctx; 897 } 898 899 public static class Hg_faContext extends ParserRuleContext { 900 public Hg_faContext(ParserRuleContext parent, int invokingState) { 901 super(parent, invokingState); 902 } 903 @Override public int getRuleIndex() { return RULE_hg_fa; } 904 @Override 905 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 906 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_fa(this); 907 else return visitor.visitChildren(this); 908 } 909 } 910 911 public final Hg_faContext hg_fa() throws RecognitionException { 912 Hg_faContext _localctx = new Hg_faContext(_ctx, getState()); 913 enterRule(_localctx, 22, RULE_hg_fa); 914 int _la; 915 try { 916 enterOuterAlt(_localctx, 1); 917 { 918 setState(334); 919 _la = _input.LA(1); 920 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8))) != 0)) ) { 921 _errHandler.recoverInline(this); 922 } 923 else { 924 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 925 _errHandler.reportMatch(this); 926 consume(); 927 } 928 } 929 } 930 catch (RecognitionException re) { 931 _localctx.exception = re; 932 _errHandler.reportError(this, re); 933 _errHandler.recover(this, re); 934 } 935 finally { 936 exitRule(); 937 } 938 return _localctx; 939 } 940 941 public static class Fa2Context extends ParserRuleContext { 942 public Fa2_unsortedContext fa2_unsorted() { 943 return getRuleContext(Fa2_unsortedContext.class,0); 944 } 945 public Fa2_sortedContext fa2_sorted() { 946 return getRuleContext(Fa2_sortedContext.class,0); 947 } 948 public Fa2Context(ParserRuleContext parent, int invokingState) { 949 super(parent, invokingState); 950 } 951 @Override public int getRuleIndex() { return RULE_fa2; } 952 @Override 953 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 954 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa2(this); 955 else return visitor.visitChildren(this); 956 } 957 } 958 959 public final Fa2Context fa2() throws RecognitionException { 960 Fa2Context _localctx = new Fa2Context(_ctx, getState()); 961 enterRule(_localctx, 24, RULE_fa2); 962 try { 963 setState(338); 964 _errHandler.sync(this); 965 switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { 966 case 1: 967 enterOuterAlt(_localctx, 1); 968 { 969 setState(336); 970 fa2_unsorted(); 971 } 972 break; 973 case 2: 974 enterOuterAlt(_localctx, 2); 975 { 976 setState(337); 977 fa2_sorted(); 978 } 979 break; 980 } 981 } 982 catch (RecognitionException re) { 983 _localctx.exception = re; 984 _errHandler.reportError(this, re); 985 _errHandler.recover(this, re); 986 } 987 finally { 988 exitRule(); 989 } 990 return _localctx; 991 } 992 993 public static class Fa2_unsortedContext extends ParserRuleContext { 994 public List<FaContext> fa() { 995 return getRuleContexts(FaContext.class); 996 } 997 public FaContext fa(int i) { 998 return getRuleContext(FaContext.class,i); 999 } 1000 public TerminalNode DASH() { return getToken(LipidMapsParser.DASH, 0); } 1001 public TerminalNode UNDERSCORE() { return getToken(LipidMapsParser.UNDERSCORE, 0); } 1002 public Fa2_unsortedContext(ParserRuleContext parent, int invokingState) { 1003 super(parent, invokingState); 1004 } 1005 @Override public int getRuleIndex() { return RULE_fa2_unsorted; } 1006 @Override 1007 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1008 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa2_unsorted(this); 1009 else return visitor.visitChildren(this); 1010 } 1011 } 1012 1013 public final Fa2_unsortedContext fa2_unsorted() throws RecognitionException { 1014 Fa2_unsortedContext _localctx = new Fa2_unsortedContext(_ctx, getState()); 1015 enterRule(_localctx, 26, RULE_fa2_unsorted); 1016 try { 1017 setState(348); 1018 _errHandler.sync(this); 1019 switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) { 1020 case 1: 1021 enterOuterAlt(_localctx, 1); 1022 { 1023 setState(340); 1024 fa(); 1025 setState(341); 1026 match(DASH); 1027 setState(342); 1028 fa(); 1029 } 1030 break; 1031 case 2: 1032 enterOuterAlt(_localctx, 2); 1033 { 1034 setState(344); 1035 fa(); 1036 setState(345); 1037 match(UNDERSCORE); 1038 setState(346); 1039 fa(); 1040 } 1041 break; 1042 } 1043 } 1044 catch (RecognitionException re) { 1045 _localctx.exception = re; 1046 _errHandler.reportError(this, re); 1047 _errHandler.recover(this, re); 1048 } 1049 finally { 1050 exitRule(); 1051 } 1052 return _localctx; 1053 } 1054 1055 public static class Fa2_sortedContext extends ParserRuleContext { 1056 public List<FaContext> fa() { 1057 return getRuleContexts(FaContext.class); 1058 } 1059 public FaContext fa(int i) { 1060 return getRuleContext(FaContext.class,i); 1061 } 1062 public TerminalNode SLASH() { return getToken(LipidMapsParser.SLASH, 0); } 1063 public TerminalNode BACKSLASH() { return getToken(LipidMapsParser.BACKSLASH, 0); } 1064 public Fa2_sortedContext(ParserRuleContext parent, int invokingState) { 1065 super(parent, invokingState); 1066 } 1067 @Override public int getRuleIndex() { return RULE_fa2_sorted; } 1068 @Override 1069 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1070 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa2_sorted(this); 1071 else return visitor.visitChildren(this); 1072 } 1073 } 1074 1075 public final Fa2_sortedContext fa2_sorted() throws RecognitionException { 1076 Fa2_sortedContext _localctx = new Fa2_sortedContext(_ctx, getState()); 1077 enterRule(_localctx, 28, RULE_fa2_sorted); 1078 try { 1079 setState(358); 1080 _errHandler.sync(this); 1081 switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) { 1082 case 1: 1083 enterOuterAlt(_localctx, 1); 1084 { 1085 setState(350); 1086 fa(); 1087 setState(351); 1088 match(SLASH); 1089 setState(352); 1090 fa(); 1091 } 1092 break; 1093 case 2: 1094 enterOuterAlt(_localctx, 2); 1095 { 1096 setState(354); 1097 fa(); 1098 setState(355); 1099 match(BACKSLASH); 1100 setState(356); 1101 fa(); 1102 } 1103 break; 1104 } 1105 } 1106 catch (RecognitionException re) { 1107 _localctx.exception = re; 1108 _errHandler.reportError(this, re); 1109 _errHandler.recover(this, re); 1110 } 1111 finally { 1112 exitRule(); 1113 } 1114 return _localctx; 1115 } 1116 1117 public static class Fa3Context extends ParserRuleContext { 1118 public Fa3_unsortedContext fa3_unsorted() { 1119 return getRuleContext(Fa3_unsortedContext.class,0); 1120 } 1121 public Fa3_sortedContext fa3_sorted() { 1122 return getRuleContext(Fa3_sortedContext.class,0); 1123 } 1124 public Fa3Context(ParserRuleContext parent, int invokingState) { 1125 super(parent, invokingState); 1126 } 1127 @Override public int getRuleIndex() { return RULE_fa3; } 1128 @Override 1129 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1130 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa3(this); 1131 else return visitor.visitChildren(this); 1132 } 1133 } 1134 1135 public final Fa3Context fa3() throws RecognitionException { 1136 Fa3Context _localctx = new Fa3Context(_ctx, getState()); 1137 enterRule(_localctx, 30, RULE_fa3); 1138 try { 1139 setState(362); 1140 _errHandler.sync(this); 1141 switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { 1142 case 1: 1143 enterOuterAlt(_localctx, 1); 1144 { 1145 setState(360); 1146 fa3_unsorted(); 1147 } 1148 break; 1149 case 2: 1150 enterOuterAlt(_localctx, 2); 1151 { 1152 setState(361); 1153 fa3_sorted(); 1154 } 1155 break; 1156 } 1157 } 1158 catch (RecognitionException re) { 1159 _localctx.exception = re; 1160 _errHandler.reportError(this, re); 1161 _errHandler.recover(this, re); 1162 } 1163 finally { 1164 exitRule(); 1165 } 1166 return _localctx; 1167 } 1168 1169 public static class Fa3_unsortedContext extends ParserRuleContext { 1170 public List<FaContext> fa() { 1171 return getRuleContexts(FaContext.class); 1172 } 1173 public FaContext fa(int i) { 1174 return getRuleContext(FaContext.class,i); 1175 } 1176 public List<TerminalNode> DASH() { return getTokens(LipidMapsParser.DASH); } 1177 public TerminalNode DASH(int i) { 1178 return getToken(LipidMapsParser.DASH, i); 1179 } 1180 public List<TerminalNode> UNDERSCORE() { return getTokens(LipidMapsParser.UNDERSCORE); } 1181 public TerminalNode UNDERSCORE(int i) { 1182 return getToken(LipidMapsParser.UNDERSCORE, i); 1183 } 1184 public Fa3_unsortedContext(ParserRuleContext parent, int invokingState) { 1185 super(parent, invokingState); 1186 } 1187 @Override public int getRuleIndex() { return RULE_fa3_unsorted; } 1188 @Override 1189 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1190 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa3_unsorted(this); 1191 else return visitor.visitChildren(this); 1192 } 1193 } 1194 1195 public final Fa3_unsortedContext fa3_unsorted() throws RecognitionException { 1196 Fa3_unsortedContext _localctx = new Fa3_unsortedContext(_ctx, getState()); 1197 enterRule(_localctx, 32, RULE_fa3_unsorted); 1198 try { 1199 setState(376); 1200 _errHandler.sync(this); 1201 switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) { 1202 case 1: 1203 enterOuterAlt(_localctx, 1); 1204 { 1205 setState(364); 1206 fa(); 1207 setState(365); 1208 match(DASH); 1209 setState(366); 1210 fa(); 1211 setState(367); 1212 match(DASH); 1213 setState(368); 1214 fa(); 1215 } 1216 break; 1217 case 2: 1218 enterOuterAlt(_localctx, 2); 1219 { 1220 setState(370); 1221 fa(); 1222 setState(371); 1223 match(UNDERSCORE); 1224 setState(372); 1225 fa(); 1226 setState(373); 1227 match(UNDERSCORE); 1228 setState(374); 1229 fa(); 1230 } 1231 break; 1232 } 1233 } 1234 catch (RecognitionException re) { 1235 _localctx.exception = re; 1236 _errHandler.reportError(this, re); 1237 _errHandler.recover(this, re); 1238 } 1239 finally { 1240 exitRule(); 1241 } 1242 return _localctx; 1243 } 1244 1245 public static class Fa3_sortedContext extends ParserRuleContext { 1246 public List<FaContext> fa() { 1247 return getRuleContexts(FaContext.class); 1248 } 1249 public FaContext fa(int i) { 1250 return getRuleContext(FaContext.class,i); 1251 } 1252 public List<TerminalNode> SLASH() { return getTokens(LipidMapsParser.SLASH); } 1253 public TerminalNode SLASH(int i) { 1254 return getToken(LipidMapsParser.SLASH, i); 1255 } 1256 public List<TerminalNode> BACKSLASH() { return getTokens(LipidMapsParser.BACKSLASH); } 1257 public TerminalNode BACKSLASH(int i) { 1258 return getToken(LipidMapsParser.BACKSLASH, i); 1259 } 1260 public Fa3_sortedContext(ParserRuleContext parent, int invokingState) { 1261 super(parent, invokingState); 1262 } 1263 @Override public int getRuleIndex() { return RULE_fa3_sorted; } 1264 @Override 1265 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1266 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa3_sorted(this); 1267 else return visitor.visitChildren(this); 1268 } 1269 } 1270 1271 public final Fa3_sortedContext fa3_sorted() throws RecognitionException { 1272 Fa3_sortedContext _localctx = new Fa3_sortedContext(_ctx, getState()); 1273 enterRule(_localctx, 34, RULE_fa3_sorted); 1274 try { 1275 setState(390); 1276 _errHandler.sync(this); 1277 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1278 case 1: 1279 enterOuterAlt(_localctx, 1); 1280 { 1281 setState(378); 1282 fa(); 1283 setState(379); 1284 match(SLASH); 1285 setState(380); 1286 fa(); 1287 setState(381); 1288 match(SLASH); 1289 setState(382); 1290 fa(); 1291 } 1292 break; 1293 case 2: 1294 enterOuterAlt(_localctx, 2); 1295 { 1296 setState(384); 1297 fa(); 1298 setState(385); 1299 match(BACKSLASH); 1300 setState(386); 1301 fa(); 1302 setState(387); 1303 match(BACKSLASH); 1304 setState(388); 1305 fa(); 1306 } 1307 break; 1308 } 1309 } 1310 catch (RecognitionException re) { 1311 _localctx.exception = re; 1312 _errHandler.reportError(this, re); 1313 _errHandler.recover(this, re); 1314 } 1315 finally { 1316 exitRule(); 1317 } 1318 return _localctx; 1319 } 1320 1321 public static class Fa4Context extends ParserRuleContext { 1322 public Fa4_unsortedContext fa4_unsorted() { 1323 return getRuleContext(Fa4_unsortedContext.class,0); 1324 } 1325 public Fa4_sortedContext fa4_sorted() { 1326 return getRuleContext(Fa4_sortedContext.class,0); 1327 } 1328 public Fa4Context(ParserRuleContext parent, int invokingState) { 1329 super(parent, invokingState); 1330 } 1331 @Override public int getRuleIndex() { return RULE_fa4; } 1332 @Override 1333 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1334 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa4(this); 1335 else return visitor.visitChildren(this); 1336 } 1337 } 1338 1339 public final Fa4Context fa4() throws RecognitionException { 1340 Fa4Context _localctx = new Fa4Context(_ctx, getState()); 1341 enterRule(_localctx, 36, RULE_fa4); 1342 try { 1343 setState(394); 1344 _errHandler.sync(this); 1345 switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { 1346 case 1: 1347 enterOuterAlt(_localctx, 1); 1348 { 1349 setState(392); 1350 fa4_unsorted(); 1351 } 1352 break; 1353 case 2: 1354 enterOuterAlt(_localctx, 2); 1355 { 1356 setState(393); 1357 fa4_sorted(); 1358 } 1359 break; 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 Fa4_unsortedContext extends ParserRuleContext { 1374 public List<FaContext> fa() { 1375 return getRuleContexts(FaContext.class); 1376 } 1377 public FaContext fa(int i) { 1378 return getRuleContext(FaContext.class,i); 1379 } 1380 public List<TerminalNode> DASH() { return getTokens(LipidMapsParser.DASH); } 1381 public TerminalNode DASH(int i) { 1382 return getToken(LipidMapsParser.DASH, i); 1383 } 1384 public List<TerminalNode> UNDERSCORE() { return getTokens(LipidMapsParser.UNDERSCORE); } 1385 public TerminalNode UNDERSCORE(int i) { 1386 return getToken(LipidMapsParser.UNDERSCORE, i); 1387 } 1388 public Fa4_unsortedContext(ParserRuleContext parent, int invokingState) { 1389 super(parent, invokingState); 1390 } 1391 @Override public int getRuleIndex() { return RULE_fa4_unsorted; } 1392 @Override 1393 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1394 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa4_unsorted(this); 1395 else return visitor.visitChildren(this); 1396 } 1397 } 1398 1399 public final Fa4_unsortedContext fa4_unsorted() throws RecognitionException { 1400 Fa4_unsortedContext _localctx = new Fa4_unsortedContext(_ctx, getState()); 1401 enterRule(_localctx, 38, RULE_fa4_unsorted); 1402 try { 1403 setState(412); 1404 _errHandler.sync(this); 1405 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1406 case 1: 1407 enterOuterAlt(_localctx, 1); 1408 { 1409 setState(396); 1410 fa(); 1411 setState(397); 1412 match(DASH); 1413 setState(398); 1414 fa(); 1415 setState(399); 1416 match(DASH); 1417 setState(400); 1418 fa(); 1419 setState(401); 1420 match(DASH); 1421 setState(402); 1422 fa(); 1423 } 1424 break; 1425 case 2: 1426 enterOuterAlt(_localctx, 2); 1427 { 1428 setState(404); 1429 fa(); 1430 setState(405); 1431 match(UNDERSCORE); 1432 setState(406); 1433 fa(); 1434 setState(407); 1435 match(UNDERSCORE); 1436 setState(408); 1437 fa(); 1438 setState(409); 1439 match(UNDERSCORE); 1440 setState(410); 1441 fa(); 1442 } 1443 break; 1444 } 1445 } 1446 catch (RecognitionException re) { 1447 _localctx.exception = re; 1448 _errHandler.reportError(this, re); 1449 _errHandler.recover(this, re); 1450 } 1451 finally { 1452 exitRule(); 1453 } 1454 return _localctx; 1455 } 1456 1457 public static class Fa4_sortedContext extends ParserRuleContext { 1458 public List<FaContext> fa() { 1459 return getRuleContexts(FaContext.class); 1460 } 1461 public FaContext fa(int i) { 1462 return getRuleContext(FaContext.class,i); 1463 } 1464 public List<TerminalNode> SLASH() { return getTokens(LipidMapsParser.SLASH); } 1465 public TerminalNode SLASH(int i) { 1466 return getToken(LipidMapsParser.SLASH, i); 1467 } 1468 public List<TerminalNode> BACKSLASH() { return getTokens(LipidMapsParser.BACKSLASH); } 1469 public TerminalNode BACKSLASH(int i) { 1470 return getToken(LipidMapsParser.BACKSLASH, i); 1471 } 1472 public Fa4_sortedContext(ParserRuleContext parent, int invokingState) { 1473 super(parent, invokingState); 1474 } 1475 @Override public int getRuleIndex() { return RULE_fa4_sorted; } 1476 @Override 1477 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1478 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa4_sorted(this); 1479 else return visitor.visitChildren(this); 1480 } 1481 } 1482 1483 public final Fa4_sortedContext fa4_sorted() throws RecognitionException { 1484 Fa4_sortedContext _localctx = new Fa4_sortedContext(_ctx, getState()); 1485 enterRule(_localctx, 40, RULE_fa4_sorted); 1486 try { 1487 setState(430); 1488 _errHandler.sync(this); 1489 switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { 1490 case 1: 1491 enterOuterAlt(_localctx, 1); 1492 { 1493 setState(414); 1494 fa(); 1495 setState(415); 1496 match(SLASH); 1497 setState(416); 1498 fa(); 1499 setState(417); 1500 match(SLASH); 1501 setState(418); 1502 fa(); 1503 setState(419); 1504 match(SLASH); 1505 setState(420); 1506 fa(); 1507 } 1508 break; 1509 case 2: 1510 enterOuterAlt(_localctx, 2); 1511 { 1512 setState(422); 1513 fa(); 1514 setState(423); 1515 match(BACKSLASH); 1516 setState(424); 1517 fa(); 1518 setState(425); 1519 match(BACKSLASH); 1520 setState(426); 1521 fa(); 1522 setState(427); 1523 match(BACKSLASH); 1524 setState(428); 1525 fa(); 1526 } 1527 break; 1528 } 1529 } 1530 catch (RecognitionException re) { 1531 _localctx.exception = re; 1532 _errHandler.reportError(this, re); 1533 _errHandler.recover(this, re); 1534 } 1535 finally { 1536 exitRule(); 1537 } 1538 return _localctx; 1539 } 1540 1541 public static class Lcb_fa_sortedContext extends ParserRuleContext { 1542 public LcbContext lcb() { 1543 return getRuleContext(LcbContext.class,0); 1544 } 1545 public TerminalNode SLASH() { return getToken(LipidMapsParser.SLASH, 0); } 1546 public FaContext fa() { 1547 return getRuleContext(FaContext.class,0); 1548 } 1549 public TerminalNode BACKSLASH() { return getToken(LipidMapsParser.BACKSLASH, 0); } 1550 public Lcb_fa_sortedContext(ParserRuleContext parent, int invokingState) { 1551 super(parent, invokingState); 1552 } 1553 @Override public int getRuleIndex() { return RULE_lcb_fa_sorted; } 1554 @Override 1555 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1556 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLcb_fa_sorted(this); 1557 else return visitor.visitChildren(this); 1558 } 1559 } 1560 1561 public final Lcb_fa_sortedContext lcb_fa_sorted() throws RecognitionException { 1562 Lcb_fa_sortedContext _localctx = new Lcb_fa_sortedContext(_ctx, getState()); 1563 enterRule(_localctx, 42, RULE_lcb_fa_sorted); 1564 try { 1565 setState(440); 1566 _errHandler.sync(this); 1567 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1568 case 1: 1569 enterOuterAlt(_localctx, 1); 1570 { 1571 setState(432); 1572 lcb(); 1573 setState(433); 1574 match(SLASH); 1575 setState(434); 1576 fa(); 1577 } 1578 break; 1579 case 2: 1580 enterOuterAlt(_localctx, 2); 1581 { 1582 setState(436); 1583 lcb(); 1584 setState(437); 1585 match(BACKSLASH); 1586 setState(438); 1587 fa(); 1588 } 1589 break; 1590 } 1591 } 1592 catch (RecognitionException re) { 1593 _localctx.exception = re; 1594 _errHandler.reportError(this, re); 1595 _errHandler.recover(this, re); 1596 } 1597 finally { 1598 exitRule(); 1599 } 1600 return _localctx; 1601 } 1602 1603 public static class Species_faContext extends ParserRuleContext { 1604 public FaContext fa() { 1605 return getRuleContext(FaContext.class,0); 1606 } 1607 public Species_faContext(ParserRuleContext parent, int invokingState) { 1608 super(parent, invokingState); 1609 } 1610 @Override public int getRuleIndex() { return RULE_species_fa; } 1611 @Override 1612 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1613 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSpecies_fa(this); 1614 else return visitor.visitChildren(this); 1615 } 1616 } 1617 1618 public final Species_faContext species_fa() throws RecognitionException { 1619 Species_faContext _localctx = new Species_faContext(_ctx, getState()); 1620 enterRule(_localctx, 44, RULE_species_fa); 1621 try { 1622 enterOuterAlt(_localctx, 1); 1623 { 1624 setState(442); 1625 fa(); 1626 } 1627 } 1628 catch (RecognitionException re) { 1629 _localctx.exception = re; 1630 _errHandler.reportError(this, re); 1631 _errHandler.recover(this, re); 1632 } 1633 finally { 1634 exitRule(); 1635 } 1636 return _localctx; 1637 } 1638 1639 public static class GlContext extends ParserRuleContext { 1640 public SglContext sgl() { 1641 return getRuleContext(SglContext.class,0); 1642 } 1643 public TglContext tgl() { 1644 return getRuleContext(TglContext.class,0); 1645 } 1646 public GlContext(ParserRuleContext parent, int invokingState) { 1647 super(parent, invokingState); 1648 } 1649 @Override public int getRuleIndex() { return RULE_gl; } 1650 @Override 1651 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1652 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitGl(this); 1653 else return visitor.visitChildren(this); 1654 } 1655 } 1656 1657 public final GlContext gl() throws RecognitionException { 1658 GlContext _localctx = new GlContext(_ctx, getState()); 1659 enterRule(_localctx, 46, RULE_gl); 1660 try { 1661 setState(446); 1662 _errHandler.sync(this); 1663 switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { 1664 case 1: 1665 enterOuterAlt(_localctx, 1); 1666 { 1667 setState(444); 1668 sgl(); 1669 } 1670 break; 1671 case 2: 1672 enterOuterAlt(_localctx, 2); 1673 { 1674 setState(445); 1675 tgl(); 1676 } 1677 break; 1678 } 1679 } 1680 catch (RecognitionException re) { 1681 _localctx.exception = re; 1682 _errHandler.reportError(this, re); 1683 _errHandler.recover(this, re); 1684 } 1685 finally { 1686 exitRule(); 1687 } 1688 return _localctx; 1689 } 1690 1691 public static class SglContext extends ParserRuleContext { 1692 public Hg_sglcContext hg_sglc() { 1693 return getRuleContext(Hg_sglcContext.class,0); 1694 } 1695 public Sgl_speciesContext sgl_species() { 1696 return getRuleContext(Sgl_speciesContext.class,0); 1697 } 1698 public Sgl_subspeciesContext sgl_subspecies() { 1699 return getRuleContext(Sgl_subspeciesContext.class,0); 1700 } 1701 public SglContext(ParserRuleContext parent, int invokingState) { 1702 super(parent, invokingState); 1703 } 1704 @Override public int getRuleIndex() { return RULE_sgl; } 1705 @Override 1706 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1707 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSgl(this); 1708 else return visitor.visitChildren(this); 1709 } 1710 } 1711 1712 public final SglContext sgl() throws RecognitionException { 1713 SglContext _localctx = new SglContext(_ctx, getState()); 1714 enterRule(_localctx, 48, RULE_sgl); 1715 try { 1716 setState(454); 1717 _errHandler.sync(this); 1718 switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) { 1719 case 1: 1720 enterOuterAlt(_localctx, 1); 1721 { 1722 setState(448); 1723 hg_sglc(); 1724 setState(449); 1725 sgl_species(); 1726 } 1727 break; 1728 case 2: 1729 enterOuterAlt(_localctx, 2); 1730 { 1731 setState(451); 1732 hg_sglc(); 1733 setState(452); 1734 sgl_subspecies(); 1735 } 1736 break; 1737 } 1738 } 1739 catch (RecognitionException re) { 1740 _localctx.exception = re; 1741 _errHandler.reportError(this, re); 1742 _errHandler.recover(this, re); 1743 } 1744 finally { 1745 exitRule(); 1746 } 1747 return _localctx; 1748 } 1749 1750 public static class Sgl_speciesContext extends ParserRuleContext { 1751 public Round_open_bracketContext round_open_bracket() { 1752 return getRuleContext(Round_open_bracketContext.class,0); 1753 } 1754 public FaContext fa() { 1755 return getRuleContext(FaContext.class,0); 1756 } 1757 public Round_close_bracketContext round_close_bracket() { 1758 return getRuleContext(Round_close_bracketContext.class,0); 1759 } 1760 public Sgl_speciesContext(ParserRuleContext parent, int invokingState) { 1761 super(parent, invokingState); 1762 } 1763 @Override public int getRuleIndex() { return RULE_sgl_species; } 1764 @Override 1765 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1766 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSgl_species(this); 1767 else return visitor.visitChildren(this); 1768 } 1769 } 1770 1771 public final Sgl_speciesContext sgl_species() throws RecognitionException { 1772 Sgl_speciesContext _localctx = new Sgl_speciesContext(_ctx, getState()); 1773 enterRule(_localctx, 50, RULE_sgl_species); 1774 try { 1775 setState(461); 1776 _errHandler.sync(this); 1777 switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { 1778 case 1: 1779 enterOuterAlt(_localctx, 1); 1780 { 1781 setState(456); 1782 round_open_bracket(); 1783 setState(457); 1784 fa(); 1785 setState(458); 1786 round_close_bracket(); 1787 } 1788 break; 1789 case 2: 1790 enterOuterAlt(_localctx, 2); 1791 { 1792 setState(460); 1793 fa(); 1794 } 1795 break; 1796 } 1797 } 1798 catch (RecognitionException re) { 1799 _localctx.exception = re; 1800 _errHandler.reportError(this, re); 1801 _errHandler.recover(this, re); 1802 } 1803 finally { 1804 exitRule(); 1805 } 1806 return _localctx; 1807 } 1808 1809 public static class Sgl_subspeciesContext extends ParserRuleContext { 1810 public Round_open_bracketContext round_open_bracket() { 1811 return getRuleContext(Round_open_bracketContext.class,0); 1812 } 1813 public Fa2Context fa2() { 1814 return getRuleContext(Fa2Context.class,0); 1815 } 1816 public Round_close_bracketContext round_close_bracket() { 1817 return getRuleContext(Round_close_bracketContext.class,0); 1818 } 1819 public Sgl_subspeciesContext(ParserRuleContext parent, int invokingState) { 1820 super(parent, invokingState); 1821 } 1822 @Override public int getRuleIndex() { return RULE_sgl_subspecies; } 1823 @Override 1824 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1825 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSgl_subspecies(this); 1826 else return visitor.visitChildren(this); 1827 } 1828 } 1829 1830 public final Sgl_subspeciesContext sgl_subspecies() throws RecognitionException { 1831 Sgl_subspeciesContext _localctx = new Sgl_subspeciesContext(_ctx, getState()); 1832 enterRule(_localctx, 52, RULE_sgl_subspecies); 1833 try { 1834 setState(468); 1835 _errHandler.sync(this); 1836 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1837 case 1: 1838 enterOuterAlt(_localctx, 1); 1839 { 1840 setState(463); 1841 round_open_bracket(); 1842 setState(464); 1843 fa2(); 1844 setState(465); 1845 round_close_bracket(); 1846 } 1847 break; 1848 case 2: 1849 enterOuterAlt(_localctx, 2); 1850 { 1851 setState(467); 1852 fa2(); 1853 } 1854 break; 1855 } 1856 } 1857 catch (RecognitionException re) { 1858 _localctx.exception = re; 1859 _errHandler.reportError(this, re); 1860 _errHandler.recover(this, re); 1861 } 1862 finally { 1863 exitRule(); 1864 } 1865 return _localctx; 1866 } 1867 1868 public static class TglContext extends ParserRuleContext { 1869 public Hg_glcContext hg_glc() { 1870 return getRuleContext(Hg_glcContext.class,0); 1871 } 1872 public Tgl_speciesContext tgl_species() { 1873 return getRuleContext(Tgl_speciesContext.class,0); 1874 } 1875 public Tgl_subspeciesContext tgl_subspecies() { 1876 return getRuleContext(Tgl_subspeciesContext.class,0); 1877 } 1878 public TglContext(ParserRuleContext parent, int invokingState) { 1879 super(parent, invokingState); 1880 } 1881 @Override public int getRuleIndex() { return RULE_tgl; } 1882 @Override 1883 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1884 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitTgl(this); 1885 else return visitor.visitChildren(this); 1886 } 1887 } 1888 1889 public final TglContext tgl() throws RecognitionException { 1890 TglContext _localctx = new TglContext(_ctx, getState()); 1891 enterRule(_localctx, 54, RULE_tgl); 1892 try { 1893 setState(476); 1894 _errHandler.sync(this); 1895 switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) { 1896 case 1: 1897 enterOuterAlt(_localctx, 1); 1898 { 1899 setState(470); 1900 hg_glc(); 1901 setState(471); 1902 tgl_species(); 1903 } 1904 break; 1905 case 2: 1906 enterOuterAlt(_localctx, 2); 1907 { 1908 setState(473); 1909 hg_glc(); 1910 setState(474); 1911 tgl_subspecies(); 1912 } 1913 break; 1914 } 1915 } 1916 catch (RecognitionException re) { 1917 _localctx.exception = re; 1918 _errHandler.reportError(this, re); 1919 _errHandler.recover(this, re); 1920 } 1921 finally { 1922 exitRule(); 1923 } 1924 return _localctx; 1925 } 1926 1927 public static class Tgl_speciesContext extends ParserRuleContext { 1928 public Round_open_bracketContext round_open_bracket() { 1929 return getRuleContext(Round_open_bracketContext.class,0); 1930 } 1931 public FaContext fa() { 1932 return getRuleContext(FaContext.class,0); 1933 } 1934 public Round_close_bracketContext round_close_bracket() { 1935 return getRuleContext(Round_close_bracketContext.class,0); 1936 } 1937 public Tgl_speciesContext(ParserRuleContext parent, int invokingState) { 1938 super(parent, invokingState); 1939 } 1940 @Override public int getRuleIndex() { return RULE_tgl_species; } 1941 @Override 1942 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1943 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitTgl_species(this); 1944 else return visitor.visitChildren(this); 1945 } 1946 } 1947 1948 public final Tgl_speciesContext tgl_species() throws RecognitionException { 1949 Tgl_speciesContext _localctx = new Tgl_speciesContext(_ctx, getState()); 1950 enterRule(_localctx, 56, RULE_tgl_species); 1951 try { 1952 setState(483); 1953 _errHandler.sync(this); 1954 switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { 1955 case 1: 1956 enterOuterAlt(_localctx, 1); 1957 { 1958 setState(478); 1959 round_open_bracket(); 1960 setState(479); 1961 fa(); 1962 setState(480); 1963 round_close_bracket(); 1964 } 1965 break; 1966 case 2: 1967 enterOuterAlt(_localctx, 2); 1968 { 1969 setState(482); 1970 fa(); 1971 } 1972 break; 1973 } 1974 } 1975 catch (RecognitionException re) { 1976 _localctx.exception = re; 1977 _errHandler.reportError(this, re); 1978 _errHandler.recover(this, re); 1979 } 1980 finally { 1981 exitRule(); 1982 } 1983 return _localctx; 1984 } 1985 1986 public static class Tgl_subspeciesContext extends ParserRuleContext { 1987 public Round_open_bracketContext round_open_bracket() { 1988 return getRuleContext(Round_open_bracketContext.class,0); 1989 } 1990 public Fa3Context fa3() { 1991 return getRuleContext(Fa3Context.class,0); 1992 } 1993 public Round_close_bracketContext round_close_bracket() { 1994 return getRuleContext(Round_close_bracketContext.class,0); 1995 } 1996 public Tgl_subspeciesContext(ParserRuleContext parent, int invokingState) { 1997 super(parent, invokingState); 1998 } 1999 @Override public int getRuleIndex() { return RULE_tgl_subspecies; } 2000 @Override 2001 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2002 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitTgl_subspecies(this); 2003 else return visitor.visitChildren(this); 2004 } 2005 } 2006 2007 public final Tgl_subspeciesContext tgl_subspecies() throws RecognitionException { 2008 Tgl_subspeciesContext _localctx = new Tgl_subspeciesContext(_ctx, getState()); 2009 enterRule(_localctx, 58, RULE_tgl_subspecies); 2010 try { 2011 setState(490); 2012 _errHandler.sync(this); 2013 switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) { 2014 case 1: 2015 enterOuterAlt(_localctx, 1); 2016 { 2017 setState(485); 2018 round_open_bracket(); 2019 setState(486); 2020 fa3(); 2021 setState(487); 2022 round_close_bracket(); 2023 } 2024 break; 2025 case 2: 2026 enterOuterAlt(_localctx, 2); 2027 { 2028 setState(489); 2029 fa3(); 2030 } 2031 break; 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 Hg_sglcContext extends ParserRuleContext { 2046 public Hg_sglContext hg_sgl() { 2047 return getRuleContext(Hg_sglContext.class,0); 2048 } 2049 public Headgroup_separatorContext headgroup_separator() { 2050 return getRuleContext(Headgroup_separatorContext.class,0); 2051 } 2052 public Hg_sglcContext(ParserRuleContext parent, int invokingState) { 2053 super(parent, invokingState); 2054 } 2055 @Override public int getRuleIndex() { return RULE_hg_sglc; } 2056 @Override 2057 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2058 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_sglc(this); 2059 else return visitor.visitChildren(this); 2060 } 2061 } 2062 2063 public final Hg_sglcContext hg_sglc() throws RecognitionException { 2064 Hg_sglcContext _localctx = new Hg_sglcContext(_ctx, getState()); 2065 enterRule(_localctx, 60, RULE_hg_sglc); 2066 try { 2067 setState(496); 2068 _errHandler.sync(this); 2069 switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) { 2070 case 1: 2071 enterOuterAlt(_localctx, 1); 2072 { 2073 setState(492); 2074 hg_sgl(); 2075 } 2076 break; 2077 case 2: 2078 enterOuterAlt(_localctx, 2); 2079 { 2080 setState(493); 2081 hg_sgl(); 2082 setState(494); 2083 headgroup_separator(); 2084 } 2085 break; 2086 } 2087 } 2088 catch (RecognitionException re) { 2089 _localctx.exception = re; 2090 _errHandler.reportError(this, re); 2091 _errHandler.recover(this, re); 2092 } 2093 finally { 2094 exitRule(); 2095 } 2096 return _localctx; 2097 } 2098 2099 public static class Hg_sglContext extends ParserRuleContext { 2100 public Hg_sglContext(ParserRuleContext parent, int invokingState) { 2101 super(parent, invokingState); 2102 } 2103 @Override public int getRuleIndex() { return RULE_hg_sgl; } 2104 @Override 2105 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2106 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_sgl(this); 2107 else return visitor.visitChildren(this); 2108 } 2109 } 2110 2111 public final Hg_sglContext hg_sgl() throws RecognitionException { 2112 Hg_sglContext _localctx = new Hg_sglContext(_ctx, getState()); 2113 enterRule(_localctx, 62, RULE_hg_sgl); 2114 int _la; 2115 try { 2116 enterOuterAlt(_localctx, 1); 2117 { 2118 setState(498); 2119 _la = _input.LA(1); 2120 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15))) != 0)) ) { 2121 _errHandler.recoverInline(this); 2122 } 2123 else { 2124 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2125 _errHandler.reportMatch(this); 2126 consume(); 2127 } 2128 } 2129 } 2130 catch (RecognitionException re) { 2131 _localctx.exception = re; 2132 _errHandler.reportError(this, re); 2133 _errHandler.recover(this, re); 2134 } 2135 finally { 2136 exitRule(); 2137 } 2138 return _localctx; 2139 } 2140 2141 public static class Hg_glcContext extends ParserRuleContext { 2142 public Hg_glContext hg_gl() { 2143 return getRuleContext(Hg_glContext.class,0); 2144 } 2145 public Headgroup_separatorContext headgroup_separator() { 2146 return getRuleContext(Headgroup_separatorContext.class,0); 2147 } 2148 public Hg_glcContext(ParserRuleContext parent, int invokingState) { 2149 super(parent, invokingState); 2150 } 2151 @Override public int getRuleIndex() { return RULE_hg_glc; } 2152 @Override 2153 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2154 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_glc(this); 2155 else return visitor.visitChildren(this); 2156 } 2157 } 2158 2159 public final Hg_glcContext hg_glc() throws RecognitionException { 2160 Hg_glcContext _localctx = new Hg_glcContext(_ctx, getState()); 2161 enterRule(_localctx, 64, RULE_hg_glc); 2162 try { 2163 setState(504); 2164 _errHandler.sync(this); 2165 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2166 case 1: 2167 enterOuterAlt(_localctx, 1); 2168 { 2169 setState(500); 2170 hg_gl(); 2171 } 2172 break; 2173 case 2: 2174 enterOuterAlt(_localctx, 2); 2175 { 2176 setState(501); 2177 hg_gl(); 2178 setState(502); 2179 headgroup_separator(); 2180 } 2181 break; 2182 } 2183 } 2184 catch (RecognitionException re) { 2185 _localctx.exception = re; 2186 _errHandler.reportError(this, re); 2187 _errHandler.recover(this, re); 2188 } 2189 finally { 2190 exitRule(); 2191 } 2192 return _localctx; 2193 } 2194 2195 public static class Hg_glContext extends ParserRuleContext { 2196 public Hg_glContext(ParserRuleContext parent, int invokingState) { 2197 super(parent, invokingState); 2198 } 2199 @Override public int getRuleIndex() { return RULE_hg_gl; } 2200 @Override 2201 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2202 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_gl(this); 2203 else return visitor.visitChildren(this); 2204 } 2205 } 2206 2207 public final Hg_glContext hg_gl() throws RecognitionException { 2208 Hg_glContext _localctx = new Hg_glContext(_ctx, getState()); 2209 enterRule(_localctx, 66, RULE_hg_gl); 2210 int _la; 2211 try { 2212 enterOuterAlt(_localctx, 1); 2213 { 2214 setState(506); 2215 _la = _input.LA(1); 2216 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__13) | (1L << T__16) | (1L << T__17))) != 0)) ) { 2217 _errHandler.recoverInline(this); 2218 } 2219 else { 2220 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2221 _errHandler.reportMatch(this); 2222 consume(); 2223 } 2224 } 2225 } 2226 catch (RecognitionException re) { 2227 _localctx.exception = re; 2228 _errHandler.reportError(this, re); 2229 _errHandler.recover(this, re); 2230 } 2231 finally { 2232 exitRule(); 2233 } 2234 return _localctx; 2235 } 2236 2237 public static class PlContext extends ParserRuleContext { 2238 public LplContext lpl() { 2239 return getRuleContext(LplContext.class,0); 2240 } 2241 public DplContext dpl() { 2242 return getRuleContext(DplContext.class,0); 2243 } 2244 public ClContext cl() { 2245 return getRuleContext(ClContext.class,0); 2246 } 2247 public FourplContext fourpl() { 2248 return getRuleContext(FourplContext.class,0); 2249 } 2250 public ThreeplContext threepl() { 2251 return getRuleContext(ThreeplContext.class,0); 2252 } 2253 public PlContext(ParserRuleContext parent, int invokingState) { 2254 super(parent, invokingState); 2255 } 2256 @Override public int getRuleIndex() { return RULE_pl; } 2257 @Override 2258 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2259 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPl(this); 2260 else return visitor.visitChildren(this); 2261 } 2262 } 2263 2264 public final PlContext pl() throws RecognitionException { 2265 PlContext _localctx = new PlContext(_ctx, getState()); 2266 enterRule(_localctx, 68, RULE_pl); 2267 try { 2268 setState(513); 2269 _errHandler.sync(this); 2270 switch (_input.LA(1)) { 2271 case T__53: 2272 case T__54: 2273 case T__55: 2274 case T__56: 2275 case T__57: 2276 case T__58: 2277 case T__59: 2278 case T__60: 2279 case T__61: 2280 case T__62: 2281 case T__63: 2282 case T__64: 2283 case T__65: 2284 case T__66: 2285 case T__67: 2286 enterOuterAlt(_localctx, 1); 2287 { 2288 setState(508); 2289 lpl(); 2290 } 2291 break; 2292 case T__21: 2293 case T__22: 2294 case T__23: 2295 case T__24: 2296 case T__25: 2297 case T__26: 2298 case T__27: 2299 case T__28: 2300 case T__29: 2301 case T__30: 2302 case T__31: 2303 case T__32: 2304 case T__33: 2305 case T__34: 2306 case T__35: 2307 case T__36: 2308 case T__37: 2309 case T__38: 2310 case T__39: 2311 case T__40: 2312 case T__41: 2313 case T__42: 2314 case T__43: 2315 case T__44: 2316 case T__45: 2317 case T__46: 2318 case T__47: 2319 case T__48: 2320 case T__49: 2321 case T__50: 2322 case T__51: 2323 case T__52: 2324 enterOuterAlt(_localctx, 2); 2325 { 2326 setState(509); 2327 dpl(); 2328 } 2329 break; 2330 case T__20: 2331 enterOuterAlt(_localctx, 3); 2332 { 2333 setState(510); 2334 cl(); 2335 } 2336 break; 2337 case T__68: 2338 case T__69: 2339 enterOuterAlt(_localctx, 4); 2340 { 2341 setState(511); 2342 fourpl(); 2343 } 2344 break; 2345 case T__71: 2346 case T__72: 2347 case T__73: 2348 enterOuterAlt(_localctx, 5); 2349 { 2350 setState(512); 2351 threepl(); 2352 } 2353 break; 2354 default: 2355 throw new NoViableAltException(this); 2356 } 2357 } 2358 catch (RecognitionException re) { 2359 _localctx.exception = re; 2360 _errHandler.reportError(this, re); 2361 _errHandler.recover(this, re); 2362 } 2363 finally { 2364 exitRule(); 2365 } 2366 return _localctx; 2367 } 2368 2369 public static class LplContext extends ParserRuleContext { 2370 public Hg_lplcContext hg_lplc() { 2371 return getRuleContext(Hg_lplcContext.class,0); 2372 } 2373 public Round_open_bracketContext round_open_bracket() { 2374 return getRuleContext(Round_open_bracketContext.class,0); 2375 } 2376 public Fa_lplContext fa_lpl() { 2377 return getRuleContext(Fa_lplContext.class,0); 2378 } 2379 public Round_close_bracketContext round_close_bracket() { 2380 return getRuleContext(Round_close_bracketContext.class,0); 2381 } 2382 public LplContext(ParserRuleContext parent, int invokingState) { 2383 super(parent, invokingState); 2384 } 2385 @Override public int getRuleIndex() { return RULE_lpl; } 2386 @Override 2387 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2388 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLpl(this); 2389 else return visitor.visitChildren(this); 2390 } 2391 } 2392 2393 public final LplContext lpl() throws RecognitionException { 2394 LplContext _localctx = new LplContext(_ctx, getState()); 2395 enterRule(_localctx, 70, RULE_lpl); 2396 try { 2397 setState(523); 2398 _errHandler.sync(this); 2399 switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { 2400 case 1: 2401 enterOuterAlt(_localctx, 1); 2402 { 2403 setState(515); 2404 hg_lplc(); 2405 setState(516); 2406 round_open_bracket(); 2407 setState(517); 2408 fa_lpl(); 2409 setState(518); 2410 round_close_bracket(); 2411 } 2412 break; 2413 case 2: 2414 enterOuterAlt(_localctx, 2); 2415 { 2416 setState(520); 2417 hg_lplc(); 2418 setState(521); 2419 fa_lpl(); 2420 } 2421 break; 2422 } 2423 } 2424 catch (RecognitionException re) { 2425 _localctx.exception = re; 2426 _errHandler.reportError(this, re); 2427 _errHandler.recover(this, re); 2428 } 2429 finally { 2430 exitRule(); 2431 } 2432 return _localctx; 2433 } 2434 2435 public static class Fa_lplContext extends ParserRuleContext { 2436 public FaContext fa() { 2437 return getRuleContext(FaContext.class,0); 2438 } 2439 public Fa2Context fa2() { 2440 return getRuleContext(Fa2Context.class,0); 2441 } 2442 public Fa_lplContext(ParserRuleContext parent, int invokingState) { 2443 super(parent, invokingState); 2444 } 2445 @Override public int getRuleIndex() { return RULE_fa_lpl; } 2446 @Override 2447 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2448 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa_lpl(this); 2449 else return visitor.visitChildren(this); 2450 } 2451 } 2452 2453 public final Fa_lplContext fa_lpl() throws RecognitionException { 2454 Fa_lplContext _localctx = new Fa_lplContext(_ctx, getState()); 2455 enterRule(_localctx, 72, RULE_fa_lpl); 2456 try { 2457 setState(527); 2458 _errHandler.sync(this); 2459 switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) { 2460 case 1: 2461 enterOuterAlt(_localctx, 1); 2462 { 2463 setState(525); 2464 fa(); 2465 } 2466 break; 2467 case 2: 2468 enterOuterAlt(_localctx, 2); 2469 { 2470 setState(526); 2471 fa2(); 2472 } 2473 break; 2474 } 2475 } 2476 catch (RecognitionException re) { 2477 _localctx.exception = re; 2478 _errHandler.reportError(this, re); 2479 _errHandler.recover(this, re); 2480 } 2481 finally { 2482 exitRule(); 2483 } 2484 return _localctx; 2485 } 2486 2487 public static class DplContext extends ParserRuleContext { 2488 public Hg_ddplContext hg_ddpl() { 2489 return getRuleContext(Hg_ddplContext.class,0); 2490 } 2491 public Dpl_speciesContext dpl_species() { 2492 return getRuleContext(Dpl_speciesContext.class,0); 2493 } 2494 public Dpl_subspeciesContext dpl_subspecies() { 2495 return getRuleContext(Dpl_subspeciesContext.class,0); 2496 } 2497 public DplContext(ParserRuleContext parent, int invokingState) { 2498 super(parent, invokingState); 2499 } 2500 @Override public int getRuleIndex() { return RULE_dpl; } 2501 @Override 2502 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2503 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDpl(this); 2504 else return visitor.visitChildren(this); 2505 } 2506 } 2507 2508 public final DplContext dpl() throws RecognitionException { 2509 DplContext _localctx = new DplContext(_ctx, getState()); 2510 enterRule(_localctx, 74, RULE_dpl); 2511 try { 2512 setState(535); 2513 _errHandler.sync(this); 2514 switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) { 2515 case 1: 2516 enterOuterAlt(_localctx, 1); 2517 { 2518 setState(529); 2519 hg_ddpl(); 2520 setState(530); 2521 dpl_species(); 2522 } 2523 break; 2524 case 2: 2525 enterOuterAlt(_localctx, 2); 2526 { 2527 setState(532); 2528 hg_ddpl(); 2529 setState(533); 2530 dpl_subspecies(); 2531 } 2532 break; 2533 } 2534 } 2535 catch (RecognitionException re) { 2536 _localctx.exception = re; 2537 _errHandler.reportError(this, re); 2538 _errHandler.recover(this, re); 2539 } 2540 finally { 2541 exitRule(); 2542 } 2543 return _localctx; 2544 } 2545 2546 public static class Dpl_speciesContext extends ParserRuleContext { 2547 public Round_open_bracketContext round_open_bracket() { 2548 return getRuleContext(Round_open_bracketContext.class,0); 2549 } 2550 public FaContext fa() { 2551 return getRuleContext(FaContext.class,0); 2552 } 2553 public Round_close_bracketContext round_close_bracket() { 2554 return getRuleContext(Round_close_bracketContext.class,0); 2555 } 2556 public Dpl_speciesContext(ParserRuleContext parent, int invokingState) { 2557 super(parent, invokingState); 2558 } 2559 @Override public int getRuleIndex() { return RULE_dpl_species; } 2560 @Override 2561 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2562 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDpl_species(this); 2563 else return visitor.visitChildren(this); 2564 } 2565 } 2566 2567 public final Dpl_speciesContext dpl_species() throws RecognitionException { 2568 Dpl_speciesContext _localctx = new Dpl_speciesContext(_ctx, getState()); 2569 enterRule(_localctx, 76, RULE_dpl_species); 2570 try { 2571 setState(542); 2572 _errHandler.sync(this); 2573 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 2574 case 1: 2575 enterOuterAlt(_localctx, 1); 2576 { 2577 setState(537); 2578 round_open_bracket(); 2579 setState(538); 2580 fa(); 2581 setState(539); 2582 round_close_bracket(); 2583 } 2584 break; 2585 case 2: 2586 enterOuterAlt(_localctx, 2); 2587 { 2588 setState(541); 2589 fa(); 2590 } 2591 break; 2592 } 2593 } 2594 catch (RecognitionException re) { 2595 _localctx.exception = re; 2596 _errHandler.reportError(this, re); 2597 _errHandler.recover(this, re); 2598 } 2599 finally { 2600 exitRule(); 2601 } 2602 return _localctx; 2603 } 2604 2605 public static class Dpl_subspeciesContext extends ParserRuleContext { 2606 public Round_open_bracketContext round_open_bracket() { 2607 return getRuleContext(Round_open_bracketContext.class,0); 2608 } 2609 public Fa2Context fa2() { 2610 return getRuleContext(Fa2Context.class,0); 2611 } 2612 public Round_close_bracketContext round_close_bracket() { 2613 return getRuleContext(Round_close_bracketContext.class,0); 2614 } 2615 public Dpl_subspeciesContext(ParserRuleContext parent, int invokingState) { 2616 super(parent, invokingState); 2617 } 2618 @Override public int getRuleIndex() { return RULE_dpl_subspecies; } 2619 @Override 2620 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2621 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDpl_subspecies(this); 2622 else return visitor.visitChildren(this); 2623 } 2624 } 2625 2626 public final Dpl_subspeciesContext dpl_subspecies() throws RecognitionException { 2627 Dpl_subspeciesContext _localctx = new Dpl_subspeciesContext(_ctx, getState()); 2628 enterRule(_localctx, 78, RULE_dpl_subspecies); 2629 try { 2630 setState(549); 2631 _errHandler.sync(this); 2632 switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) { 2633 case 1: 2634 enterOuterAlt(_localctx, 1); 2635 { 2636 setState(544); 2637 round_open_bracket(); 2638 setState(545); 2639 fa2(); 2640 setState(546); 2641 round_close_bracket(); 2642 } 2643 break; 2644 case 2: 2645 enterOuterAlt(_localctx, 2); 2646 { 2647 setState(548); 2648 fa2(); 2649 } 2650 break; 2651 } 2652 } 2653 catch (RecognitionException re) { 2654 _localctx.exception = re; 2655 _errHandler.reportError(this, re); 2656 _errHandler.recover(this, re); 2657 } 2658 finally { 2659 exitRule(); 2660 } 2661 return _localctx; 2662 } 2663 2664 public static class ClContext extends ParserRuleContext { 2665 public Hg_clcContext hg_clc() { 2666 return getRuleContext(Hg_clcContext.class,0); 2667 } 2668 public Cl_speciesContext cl_species() { 2669 return getRuleContext(Cl_speciesContext.class,0); 2670 } 2671 public Cl_subspeciesContext cl_subspecies() { 2672 return getRuleContext(Cl_subspeciesContext.class,0); 2673 } 2674 public ClContext(ParserRuleContext parent, int invokingState) { 2675 super(parent, invokingState); 2676 } 2677 @Override public int getRuleIndex() { return RULE_cl; } 2678 @Override 2679 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2680 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCl(this); 2681 else return visitor.visitChildren(this); 2682 } 2683 } 2684 2685 public final ClContext cl() throws RecognitionException { 2686 ClContext _localctx = new ClContext(_ctx, getState()); 2687 enterRule(_localctx, 80, RULE_cl); 2688 try { 2689 setState(557); 2690 _errHandler.sync(this); 2691 switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { 2692 case 1: 2693 enterOuterAlt(_localctx, 1); 2694 { 2695 setState(551); 2696 hg_clc(); 2697 setState(552); 2698 cl_species(); 2699 } 2700 break; 2701 case 2: 2702 enterOuterAlt(_localctx, 2); 2703 { 2704 setState(554); 2705 hg_clc(); 2706 setState(555); 2707 cl_subspecies(); 2708 } 2709 break; 2710 } 2711 } 2712 catch (RecognitionException re) { 2713 _localctx.exception = re; 2714 _errHandler.reportError(this, re); 2715 _errHandler.recover(this, re); 2716 } 2717 finally { 2718 exitRule(); 2719 } 2720 return _localctx; 2721 } 2722 2723 public static class Cl_speciesContext extends ParserRuleContext { 2724 public Round_open_bracketContext round_open_bracket() { 2725 return getRuleContext(Round_open_bracketContext.class,0); 2726 } 2727 public FaContext fa() { 2728 return getRuleContext(FaContext.class,0); 2729 } 2730 public Round_close_bracketContext round_close_bracket() { 2731 return getRuleContext(Round_close_bracketContext.class,0); 2732 } 2733 public Cl_speciesContext(ParserRuleContext parent, int invokingState) { 2734 super(parent, invokingState); 2735 } 2736 @Override public int getRuleIndex() { return RULE_cl_species; } 2737 @Override 2738 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2739 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCl_species(this); 2740 else return visitor.visitChildren(this); 2741 } 2742 } 2743 2744 public final Cl_speciesContext cl_species() throws RecognitionException { 2745 Cl_speciesContext _localctx = new Cl_speciesContext(_ctx, getState()); 2746 enterRule(_localctx, 82, RULE_cl_species); 2747 try { 2748 setState(564); 2749 _errHandler.sync(this); 2750 switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) { 2751 case 1: 2752 enterOuterAlt(_localctx, 1); 2753 { 2754 setState(559); 2755 round_open_bracket(); 2756 setState(560); 2757 fa(); 2758 setState(561); 2759 round_close_bracket(); 2760 } 2761 break; 2762 case 2: 2763 enterOuterAlt(_localctx, 2); 2764 { 2765 setState(563); 2766 fa(); 2767 } 2768 break; 2769 } 2770 } 2771 catch (RecognitionException re) { 2772 _localctx.exception = re; 2773 _errHandler.reportError(this, re); 2774 _errHandler.recover(this, re); 2775 } 2776 finally { 2777 exitRule(); 2778 } 2779 return _localctx; 2780 } 2781 2782 public static class Cl_subspeciesContext extends ParserRuleContext { 2783 public Round_open_bracketContext round_open_bracket() { 2784 return getRuleContext(Round_open_bracketContext.class,0); 2785 } 2786 public List<Square_open_bracketContext> square_open_bracket() { 2787 return getRuleContexts(Square_open_bracketContext.class); 2788 } 2789 public Square_open_bracketContext square_open_bracket(int i) { 2790 return getRuleContext(Square_open_bracketContext.class,i); 2791 } 2792 public List<Fa2Context> fa2() { 2793 return getRuleContexts(Fa2Context.class); 2794 } 2795 public Fa2Context fa2(int i) { 2796 return getRuleContext(Fa2Context.class,i); 2797 } 2798 public List<Square_close_bracketContext> square_close_bracket() { 2799 return getRuleContexts(Square_close_bracketContext.class); 2800 } 2801 public Square_close_bracketContext square_close_bracket(int i) { 2802 return getRuleContext(Square_close_bracketContext.class,i); 2803 } 2804 public Round_close_bracketContext round_close_bracket() { 2805 return getRuleContext(Round_close_bracketContext.class,0); 2806 } 2807 public Hg_clcContext hg_clc() { 2808 return getRuleContext(Hg_clcContext.class,0); 2809 } 2810 public Cl_subspeciesContext(ParserRuleContext parent, int invokingState) { 2811 super(parent, invokingState); 2812 } 2813 @Override public int getRuleIndex() { return RULE_cl_subspecies; } 2814 @Override 2815 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2816 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCl_subspecies(this); 2817 else return visitor.visitChildren(this); 2818 } 2819 } 2820 2821 public final Cl_subspeciesContext cl_subspecies() throws RecognitionException { 2822 Cl_subspeciesContext _localctx = new Cl_subspeciesContext(_ctx, getState()); 2823 enterRule(_localctx, 84, RULE_cl_subspecies); 2824 try { 2825 setState(587); 2826 _errHandler.sync(this); 2827 switch (_input.LA(1)) { 2828 case ROB: 2829 enterOuterAlt(_localctx, 1); 2830 { 2831 setState(566); 2832 round_open_bracket(); 2833 setState(567); 2834 match(T__18); 2835 setState(568); 2836 square_open_bracket(); 2837 setState(569); 2838 fa2(); 2839 setState(570); 2840 square_close_bracket(); 2841 setState(571); 2842 match(T__19); 2843 setState(572); 2844 square_open_bracket(); 2845 setState(573); 2846 fa2(); 2847 setState(574); 2848 square_close_bracket(); 2849 setState(575); 2850 round_close_bracket(); 2851 } 2852 break; 2853 case T__20: 2854 enterOuterAlt(_localctx, 2); 2855 { 2856 setState(577); 2857 hg_clc(); 2858 setState(578); 2859 match(T__18); 2860 setState(579); 2861 square_open_bracket(); 2862 setState(580); 2863 fa2(); 2864 setState(581); 2865 square_close_bracket(); 2866 setState(582); 2867 match(T__19); 2868 setState(583); 2869 square_open_bracket(); 2870 setState(584); 2871 fa2(); 2872 setState(585); 2873 square_close_bracket(); 2874 } 2875 break; 2876 default: 2877 throw new NoViableAltException(this); 2878 } 2879 } 2880 catch (RecognitionException re) { 2881 _localctx.exception = re; 2882 _errHandler.reportError(this, re); 2883 _errHandler.recover(this, re); 2884 } 2885 finally { 2886 exitRule(); 2887 } 2888 return _localctx; 2889 } 2890 2891 public static class FourplContext extends ParserRuleContext { 2892 public Hg_fourplcContext hg_fourplc() { 2893 return getRuleContext(Hg_fourplcContext.class,0); 2894 } 2895 public Round_open_bracketContext round_open_bracket() { 2896 return getRuleContext(Round_open_bracketContext.class,0); 2897 } 2898 public Fa4Context fa4() { 2899 return getRuleContext(Fa4Context.class,0); 2900 } 2901 public Round_close_bracketContext round_close_bracket() { 2902 return getRuleContext(Round_close_bracketContext.class,0); 2903 } 2904 public Species_faContext species_fa() { 2905 return getRuleContext(Species_faContext.class,0); 2906 } 2907 public FourplContext(ParserRuleContext parent, int invokingState) { 2908 super(parent, invokingState); 2909 } 2910 @Override public int getRuleIndex() { return RULE_fourpl; } 2911 @Override 2912 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2913 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFourpl(this); 2914 else return visitor.visitChildren(this); 2915 } 2916 } 2917 2918 public final FourplContext fourpl() throws RecognitionException { 2919 FourplContext _localctx = new FourplContext(_ctx, getState()); 2920 enterRule(_localctx, 86, RULE_fourpl); 2921 try { 2922 setState(605); 2923 _errHandler.sync(this); 2924 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 2925 case 1: 2926 enterOuterAlt(_localctx, 1); 2927 { 2928 setState(589); 2929 hg_fourplc(); 2930 setState(590); 2931 round_open_bracket(); 2932 setState(591); 2933 fa4(); 2934 setState(592); 2935 round_close_bracket(); 2936 } 2937 break; 2938 case 2: 2939 enterOuterAlt(_localctx, 2); 2940 { 2941 setState(594); 2942 hg_fourplc(); 2943 setState(595); 2944 fa4(); 2945 } 2946 break; 2947 case 3: 2948 enterOuterAlt(_localctx, 3); 2949 { 2950 setState(597); 2951 hg_fourplc(); 2952 setState(598); 2953 round_open_bracket(); 2954 setState(599); 2955 species_fa(); 2956 setState(600); 2957 round_close_bracket(); 2958 } 2959 break; 2960 case 4: 2961 enterOuterAlt(_localctx, 4); 2962 { 2963 setState(602); 2964 hg_fourplc(); 2965 setState(603); 2966 species_fa(); 2967 } 2968 break; 2969 } 2970 } 2971 catch (RecognitionException re) { 2972 _localctx.exception = re; 2973 _errHandler.reportError(this, re); 2974 _errHandler.recover(this, re); 2975 } 2976 finally { 2977 exitRule(); 2978 } 2979 return _localctx; 2980 } 2981 2982 public static class ThreeplContext extends ParserRuleContext { 2983 public Hg_threeplcContext hg_threeplc() { 2984 return getRuleContext(Hg_threeplcContext.class,0); 2985 } 2986 public Round_open_bracketContext round_open_bracket() { 2987 return getRuleContext(Round_open_bracketContext.class,0); 2988 } 2989 public Fa3Context fa3() { 2990 return getRuleContext(Fa3Context.class,0); 2991 } 2992 public Round_close_bracketContext round_close_bracket() { 2993 return getRuleContext(Round_close_bracketContext.class,0); 2994 } 2995 public Species_faContext species_fa() { 2996 return getRuleContext(Species_faContext.class,0); 2997 } 2998 public ThreeplContext(ParserRuleContext parent, int invokingState) { 2999 super(parent, invokingState); 3000 } 3001 @Override public int getRuleIndex() { return RULE_threepl; } 3002 @Override 3003 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3004 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitThreepl(this); 3005 else return visitor.visitChildren(this); 3006 } 3007 } 3008 3009 public final ThreeplContext threepl() throws RecognitionException { 3010 ThreeplContext _localctx = new ThreeplContext(_ctx, getState()); 3011 enterRule(_localctx, 88, RULE_threepl); 3012 try { 3013 setState(623); 3014 _errHandler.sync(this); 3015 switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { 3016 case 1: 3017 enterOuterAlt(_localctx, 1); 3018 { 3019 setState(607); 3020 hg_threeplc(); 3021 setState(608); 3022 round_open_bracket(); 3023 setState(609); 3024 fa3(); 3025 setState(610); 3026 round_close_bracket(); 3027 } 3028 break; 3029 case 2: 3030 enterOuterAlt(_localctx, 2); 3031 { 3032 setState(612); 3033 hg_threeplc(); 3034 setState(613); 3035 fa3(); 3036 } 3037 break; 3038 case 3: 3039 enterOuterAlt(_localctx, 3); 3040 { 3041 setState(615); 3042 hg_threeplc(); 3043 setState(616); 3044 round_open_bracket(); 3045 setState(617); 3046 species_fa(); 3047 setState(618); 3048 round_close_bracket(); 3049 } 3050 break; 3051 case 4: 3052 enterOuterAlt(_localctx, 4); 3053 { 3054 setState(620); 3055 hg_threeplc(); 3056 setState(621); 3057 species_fa(); 3058 } 3059 break; 3060 } 3061 } 3062 catch (RecognitionException re) { 3063 _localctx.exception = re; 3064 _errHandler.reportError(this, re); 3065 _errHandler.recover(this, re); 3066 } 3067 finally { 3068 exitRule(); 3069 } 3070 return _localctx; 3071 } 3072 3073 public static class Hg_ddplContext extends ParserRuleContext { 3074 public Hg_dplcContext hg_dplc() { 3075 return getRuleContext(Hg_dplcContext.class,0); 3076 } 3077 public Pip_positionContext pip_position() { 3078 return getRuleContext(Pip_positionContext.class,0); 3079 } 3080 public Hg_ddplContext(ParserRuleContext parent, int invokingState) { 3081 super(parent, invokingState); 3082 } 3083 @Override public int getRuleIndex() { return RULE_hg_ddpl; } 3084 @Override 3085 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3086 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_ddpl(this); 3087 else return visitor.visitChildren(this); 3088 } 3089 } 3090 3091 public final Hg_ddplContext hg_ddpl() throws RecognitionException { 3092 Hg_ddplContext _localctx = new Hg_ddplContext(_ctx, getState()); 3093 enterRule(_localctx, 90, RULE_hg_ddpl); 3094 try { 3095 setState(629); 3096 _errHandler.sync(this); 3097 switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { 3098 case 1: 3099 enterOuterAlt(_localctx, 1); 3100 { 3101 setState(625); 3102 hg_dplc(); 3103 setState(626); 3104 pip_position(); 3105 } 3106 break; 3107 case 2: 3108 enterOuterAlt(_localctx, 2); 3109 { 3110 setState(628); 3111 hg_dplc(); 3112 } 3113 break; 3114 } 3115 } 3116 catch (RecognitionException re) { 3117 _localctx.exception = re; 3118 _errHandler.reportError(this, re); 3119 _errHandler.recover(this, re); 3120 } 3121 finally { 3122 exitRule(); 3123 } 3124 return _localctx; 3125 } 3126 3127 public static class Hg_clcContext extends ParserRuleContext { 3128 public Hg_clContext hg_cl() { 3129 return getRuleContext(Hg_clContext.class,0); 3130 } 3131 public Headgroup_separatorContext headgroup_separator() { 3132 return getRuleContext(Headgroup_separatorContext.class,0); 3133 } 3134 public Hg_clcContext(ParserRuleContext parent, int invokingState) { 3135 super(parent, invokingState); 3136 } 3137 @Override public int getRuleIndex() { return RULE_hg_clc; } 3138 @Override 3139 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3140 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_clc(this); 3141 else return visitor.visitChildren(this); 3142 } 3143 } 3144 3145 public final Hg_clcContext hg_clc() throws RecognitionException { 3146 Hg_clcContext _localctx = new Hg_clcContext(_ctx, getState()); 3147 enterRule(_localctx, 92, RULE_hg_clc); 3148 try { 3149 setState(635); 3150 _errHandler.sync(this); 3151 switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { 3152 case 1: 3153 enterOuterAlt(_localctx, 1); 3154 { 3155 setState(631); 3156 hg_cl(); 3157 } 3158 break; 3159 case 2: 3160 enterOuterAlt(_localctx, 2); 3161 { 3162 setState(632); 3163 hg_cl(); 3164 setState(633); 3165 headgroup_separator(); 3166 } 3167 break; 3168 } 3169 } 3170 catch (RecognitionException re) { 3171 _localctx.exception = re; 3172 _errHandler.reportError(this, re); 3173 _errHandler.recover(this, re); 3174 } 3175 finally { 3176 exitRule(); 3177 } 3178 return _localctx; 3179 } 3180 3181 public static class Hg_clContext extends ParserRuleContext { 3182 public Hg_clContext(ParserRuleContext parent, int invokingState) { 3183 super(parent, invokingState); 3184 } 3185 @Override public int getRuleIndex() { return RULE_hg_cl; } 3186 @Override 3187 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3188 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_cl(this); 3189 else return visitor.visitChildren(this); 3190 } 3191 } 3192 3193 public final Hg_clContext hg_cl() throws RecognitionException { 3194 Hg_clContext _localctx = new Hg_clContext(_ctx, getState()); 3195 enterRule(_localctx, 94, RULE_hg_cl); 3196 try { 3197 enterOuterAlt(_localctx, 1); 3198 { 3199 setState(637); 3200 match(T__20); 3201 } 3202 } 3203 catch (RecognitionException re) { 3204 _localctx.exception = re; 3205 _errHandler.reportError(this, re); 3206 _errHandler.recover(this, re); 3207 } 3208 finally { 3209 exitRule(); 3210 } 3211 return _localctx; 3212 } 3213 3214 public static class Hg_dplcContext extends ParserRuleContext { 3215 public Hg_dplContext hg_dpl() { 3216 return getRuleContext(Hg_dplContext.class,0); 3217 } 3218 public Headgroup_separatorContext headgroup_separator() { 3219 return getRuleContext(Headgroup_separatorContext.class,0); 3220 } 3221 public Hg_dplcContext(ParserRuleContext parent, int invokingState) { 3222 super(parent, invokingState); 3223 } 3224 @Override public int getRuleIndex() { return RULE_hg_dplc; } 3225 @Override 3226 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3227 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_dplc(this); 3228 else return visitor.visitChildren(this); 3229 } 3230 } 3231 3232 public final Hg_dplcContext hg_dplc() throws RecognitionException { 3233 Hg_dplcContext _localctx = new Hg_dplcContext(_ctx, getState()); 3234 enterRule(_localctx, 96, RULE_hg_dplc); 3235 try { 3236 setState(643); 3237 _errHandler.sync(this); 3238 switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { 3239 case 1: 3240 enterOuterAlt(_localctx, 1); 3241 { 3242 setState(639); 3243 hg_dpl(); 3244 } 3245 break; 3246 case 2: 3247 enterOuterAlt(_localctx, 2); 3248 { 3249 setState(640); 3250 hg_dpl(); 3251 setState(641); 3252 headgroup_separator(); 3253 } 3254 break; 3255 } 3256 } 3257 catch (RecognitionException re) { 3258 _localctx.exception = re; 3259 _errHandler.reportError(this, re); 3260 _errHandler.recover(this, re); 3261 } 3262 finally { 3263 exitRule(); 3264 } 3265 return _localctx; 3266 } 3267 3268 public static class Hg_dplContext extends ParserRuleContext { 3269 public Hg_dplContext(ParserRuleContext parent, int invokingState) { 3270 super(parent, invokingState); 3271 } 3272 @Override public int getRuleIndex() { return RULE_hg_dpl; } 3273 @Override 3274 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3275 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_dpl(this); 3276 else return visitor.visitChildren(this); 3277 } 3278 } 3279 3280 public final Hg_dplContext hg_dpl() throws RecognitionException { 3281 Hg_dplContext _localctx = new Hg_dplContext(_ctx, getState()); 3282 enterRule(_localctx, 98, RULE_hg_dpl); 3283 int _la; 3284 try { 3285 enterOuterAlt(_localctx, 1); 3286 { 3287 setState(645); 3288 _la = _input.LA(1); 3289 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52))) != 0)) ) { 3290 _errHandler.recoverInline(this); 3291 } 3292 else { 3293 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3294 _errHandler.reportMatch(this); 3295 consume(); 3296 } 3297 } 3298 } 3299 catch (RecognitionException re) { 3300 _localctx.exception = re; 3301 _errHandler.reportError(this, re); 3302 _errHandler.recover(this, re); 3303 } 3304 finally { 3305 exitRule(); 3306 } 3307 return _localctx; 3308 } 3309 3310 public static class Hg_lplcContext extends ParserRuleContext { 3311 public Hg_lplContext hg_lpl() { 3312 return getRuleContext(Hg_lplContext.class,0); 3313 } 3314 public Headgroup_separatorContext headgroup_separator() { 3315 return getRuleContext(Headgroup_separatorContext.class,0); 3316 } 3317 public Hg_lplcContext(ParserRuleContext parent, int invokingState) { 3318 super(parent, invokingState); 3319 } 3320 @Override public int getRuleIndex() { return RULE_hg_lplc; } 3321 @Override 3322 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3323 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_lplc(this); 3324 else return visitor.visitChildren(this); 3325 } 3326 } 3327 3328 public final Hg_lplcContext hg_lplc() throws RecognitionException { 3329 Hg_lplcContext _localctx = new Hg_lplcContext(_ctx, getState()); 3330 enterRule(_localctx, 100, RULE_hg_lplc); 3331 try { 3332 setState(651); 3333 _errHandler.sync(this); 3334 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 3335 case 1: 3336 enterOuterAlt(_localctx, 1); 3337 { 3338 setState(647); 3339 hg_lpl(); 3340 } 3341 break; 3342 case 2: 3343 enterOuterAlt(_localctx, 2); 3344 { 3345 setState(648); 3346 hg_lpl(); 3347 setState(649); 3348 headgroup_separator(); 3349 } 3350 break; 3351 } 3352 } 3353 catch (RecognitionException re) { 3354 _localctx.exception = re; 3355 _errHandler.reportError(this, re); 3356 _errHandler.recover(this, re); 3357 } 3358 finally { 3359 exitRule(); 3360 } 3361 return _localctx; 3362 } 3363 3364 public static class Hg_lplContext extends ParserRuleContext { 3365 public Hg_lplContext(ParserRuleContext parent, int invokingState) { 3366 super(parent, invokingState); 3367 } 3368 @Override public int getRuleIndex() { return RULE_hg_lpl; } 3369 @Override 3370 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3371 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_lpl(this); 3372 else return visitor.visitChildren(this); 3373 } 3374 } 3375 3376 public final Hg_lplContext hg_lpl() throws RecognitionException { 3377 Hg_lplContext _localctx = new Hg_lplContext(_ctx, getState()); 3378 enterRule(_localctx, 102, RULE_hg_lpl); 3379 int _la; 3380 try { 3381 enterOuterAlt(_localctx, 1); 3382 { 3383 setState(653); 3384 _la = _input.LA(1); 3385 if ( !(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (T__53 - 54)) | (1L << (T__54 - 54)) | (1L << (T__55 - 54)) | (1L << (T__56 - 54)) | (1L << (T__57 - 54)) | (1L << (T__58 - 54)) | (1L << (T__59 - 54)) | (1L << (T__60 - 54)) | (1L << (T__61 - 54)) | (1L << (T__62 - 54)) | (1L << (T__63 - 54)) | (1L << (T__64 - 54)) | (1L << (T__65 - 54)) | (1L << (T__66 - 54)) | (1L << (T__67 - 54)))) != 0)) ) { 3386 _errHandler.recoverInline(this); 3387 } 3388 else { 3389 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3390 _errHandler.reportMatch(this); 3391 consume(); 3392 } 3393 } 3394 } 3395 catch (RecognitionException re) { 3396 _localctx.exception = re; 3397 _errHandler.reportError(this, re); 3398 _errHandler.recover(this, re); 3399 } 3400 finally { 3401 exitRule(); 3402 } 3403 return _localctx; 3404 } 3405 3406 public static class Hg_fourplcContext extends ParserRuleContext { 3407 public Hg_fourplContext hg_fourpl() { 3408 return getRuleContext(Hg_fourplContext.class,0); 3409 } 3410 public Headgroup_separatorContext headgroup_separator() { 3411 return getRuleContext(Headgroup_separatorContext.class,0); 3412 } 3413 public Hg_fourplcContext(ParserRuleContext parent, int invokingState) { 3414 super(parent, invokingState); 3415 } 3416 @Override public int getRuleIndex() { return RULE_hg_fourplc; } 3417 @Override 3418 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3419 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_fourplc(this); 3420 else return visitor.visitChildren(this); 3421 } 3422 } 3423 3424 public final Hg_fourplcContext hg_fourplc() throws RecognitionException { 3425 Hg_fourplcContext _localctx = new Hg_fourplcContext(_ctx, getState()); 3426 enterRule(_localctx, 104, RULE_hg_fourplc); 3427 try { 3428 setState(659); 3429 _errHandler.sync(this); 3430 switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { 3431 case 1: 3432 enterOuterAlt(_localctx, 1); 3433 { 3434 setState(655); 3435 hg_fourpl(); 3436 } 3437 break; 3438 case 2: 3439 enterOuterAlt(_localctx, 2); 3440 { 3441 setState(656); 3442 hg_fourpl(); 3443 setState(657); 3444 headgroup_separator(); 3445 } 3446 break; 3447 } 3448 } 3449 catch (RecognitionException re) { 3450 _localctx.exception = re; 3451 _errHandler.reportError(this, re); 3452 _errHandler.recover(this, re); 3453 } 3454 finally { 3455 exitRule(); 3456 } 3457 return _localctx; 3458 } 3459 3460 public static class Hg_fourplContext extends ParserRuleContext { 3461 public Hg_fourplContext(ParserRuleContext parent, int invokingState) { 3462 super(parent, invokingState); 3463 } 3464 @Override public int getRuleIndex() { return RULE_hg_fourpl; } 3465 @Override 3466 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3467 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_fourpl(this); 3468 else return visitor.visitChildren(this); 3469 } 3470 } 3471 3472 public final Hg_fourplContext hg_fourpl() throws RecognitionException { 3473 Hg_fourplContext _localctx = new Hg_fourplContext(_ctx, getState()); 3474 enterRule(_localctx, 106, RULE_hg_fourpl); 3475 int _la; 3476 try { 3477 enterOuterAlt(_localctx, 1); 3478 { 3479 setState(661); 3480 _la = _input.LA(1); 3481 if ( !(_la==T__68 || _la==T__69) ) { 3482 _errHandler.recoverInline(this); 3483 } 3484 else { 3485 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3486 _errHandler.reportMatch(this); 3487 consume(); 3488 } 3489 } 3490 } 3491 catch (RecognitionException re) { 3492 _localctx.exception = re; 3493 _errHandler.reportError(this, re); 3494 _errHandler.recover(this, re); 3495 } 3496 finally { 3497 exitRule(); 3498 } 3499 return _localctx; 3500 } 3501 3502 public static class Pip_positionContext extends ParserRuleContext { 3503 public Square_open_bracketContext square_open_bracket() { 3504 return getRuleContext(Square_open_bracketContext.class,0); 3505 } 3506 public Pip_posContext pip_pos() { 3507 return getRuleContext(Pip_posContext.class,0); 3508 } 3509 public Square_close_bracketContext square_close_bracket() { 3510 return getRuleContext(Square_close_bracketContext.class,0); 3511 } 3512 public Pip_positionContext(ParserRuleContext parent, int invokingState) { 3513 super(parent, invokingState); 3514 } 3515 @Override public int getRuleIndex() { return RULE_pip_position; } 3516 @Override 3517 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3518 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPip_position(this); 3519 else return visitor.visitChildren(this); 3520 } 3521 } 3522 3523 public final Pip_positionContext pip_position() throws RecognitionException { 3524 Pip_positionContext _localctx = new Pip_positionContext(_ctx, getState()); 3525 enterRule(_localctx, 108, RULE_pip_position); 3526 try { 3527 enterOuterAlt(_localctx, 1); 3528 { 3529 setState(663); 3530 square_open_bracket(); 3531 setState(664); 3532 pip_pos(0); 3533 setState(665); 3534 square_close_bracket(); 3535 } 3536 } 3537 catch (RecognitionException re) { 3538 _localctx.exception = re; 3539 _errHandler.reportError(this, re); 3540 _errHandler.recover(this, re); 3541 } 3542 finally { 3543 exitRule(); 3544 } 3545 return _localctx; 3546 } 3547 3548 public static class Pip_posContext extends ParserRuleContext { 3549 public NumberContext number() { 3550 return getRuleContext(NumberContext.class,0); 3551 } 3552 public List<Pip_posContext> pip_pos() { 3553 return getRuleContexts(Pip_posContext.class); 3554 } 3555 public Pip_posContext pip_pos(int i) { 3556 return getRuleContext(Pip_posContext.class,i); 3557 } 3558 public TerminalNode COMMA() { return getToken(LipidMapsParser.COMMA, 0); } 3559 public Pip_posContext(ParserRuleContext parent, int invokingState) { 3560 super(parent, invokingState); 3561 } 3562 @Override public int getRuleIndex() { return RULE_pip_pos; } 3563 @Override 3564 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3565 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPip_pos(this); 3566 else return visitor.visitChildren(this); 3567 } 3568 } 3569 3570 public final Pip_posContext pip_pos() throws RecognitionException { 3571 return pip_pos(0); 3572 } 3573 3574 private Pip_posContext pip_pos(int _p) throws RecognitionException { 3575 ParserRuleContext _parentctx = _ctx; 3576 int _parentState = getState(); 3577 Pip_posContext _localctx = new Pip_posContext(_ctx, _parentState); 3578 Pip_posContext _prevctx = _localctx; 3579 int _startState = 110; 3580 enterRecursionRule(_localctx, 110, RULE_pip_pos, _p); 3581 try { 3582 int _alt; 3583 enterOuterAlt(_localctx, 1); 3584 { 3585 { 3586 setState(668); 3587 number(0); 3588 setState(669); 3589 match(T__70); 3590 } 3591 _ctx.stop = _input.LT(-1); 3592 setState(676); 3593 _errHandler.sync(this); 3594 _alt = getInterpreter().adaptivePredict(_input,42,_ctx); 3595 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3596 if ( _alt==1 ) { 3597 if ( _parseListeners!=null ) triggerExitRuleEvent(); 3598 _prevctx = _localctx; 3599 { 3600 { 3601 _localctx = new Pip_posContext(_parentctx, _parentState); 3602 pushNewRecursionContext(_localctx, _startState, RULE_pip_pos); 3603 setState(671); 3604 if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); 3605 setState(672); 3606 match(COMMA); 3607 setState(673); 3608 pip_pos(3); 3609 } 3610 } 3611 } 3612 setState(678); 3613 _errHandler.sync(this); 3614 _alt = getInterpreter().adaptivePredict(_input,42,_ctx); 3615 } 3616 } 3617 } 3618 catch (RecognitionException re) { 3619 _localctx.exception = re; 3620 _errHandler.reportError(this, re); 3621 _errHandler.recover(this, re); 3622 } 3623 finally { 3624 unrollRecursionContexts(_parentctx); 3625 } 3626 return _localctx; 3627 } 3628 3629 public static class Hg_threeplcContext extends ParserRuleContext { 3630 public Hg_threeplContext hg_threepl() { 3631 return getRuleContext(Hg_threeplContext.class,0); 3632 } 3633 public Headgroup_separatorContext headgroup_separator() { 3634 return getRuleContext(Headgroup_separatorContext.class,0); 3635 } 3636 public Hg_threeplcContext(ParserRuleContext parent, int invokingState) { 3637 super(parent, invokingState); 3638 } 3639 @Override public int getRuleIndex() { return RULE_hg_threeplc; } 3640 @Override 3641 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3642 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_threeplc(this); 3643 else return visitor.visitChildren(this); 3644 } 3645 } 3646 3647 public final Hg_threeplcContext hg_threeplc() throws RecognitionException { 3648 Hg_threeplcContext _localctx = new Hg_threeplcContext(_ctx, getState()); 3649 enterRule(_localctx, 112, RULE_hg_threeplc); 3650 try { 3651 setState(683); 3652 _errHandler.sync(this); 3653 switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { 3654 case 1: 3655 enterOuterAlt(_localctx, 1); 3656 { 3657 setState(679); 3658 hg_threepl(); 3659 } 3660 break; 3661 case 2: 3662 enterOuterAlt(_localctx, 2); 3663 { 3664 setState(680); 3665 hg_threepl(); 3666 setState(681); 3667 headgroup_separator(); 3668 } 3669 break; 3670 } 3671 } 3672 catch (RecognitionException re) { 3673 _localctx.exception = re; 3674 _errHandler.reportError(this, re); 3675 _errHandler.recover(this, re); 3676 } 3677 finally { 3678 exitRule(); 3679 } 3680 return _localctx; 3681 } 3682 3683 public static class Hg_threeplContext extends ParserRuleContext { 3684 public Hg_threeplContext(ParserRuleContext parent, int invokingState) { 3685 super(parent, invokingState); 3686 } 3687 @Override public int getRuleIndex() { return RULE_hg_threepl; } 3688 @Override 3689 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3690 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_threepl(this); 3691 else return visitor.visitChildren(this); 3692 } 3693 } 3694 3695 public final Hg_threeplContext hg_threepl() throws RecognitionException { 3696 Hg_threeplContext _localctx = new Hg_threeplContext(_ctx, getState()); 3697 enterRule(_localctx, 114, RULE_hg_threepl); 3698 int _la; 3699 try { 3700 enterOuterAlt(_localctx, 1); 3701 { 3702 setState(685); 3703 _la = _input.LA(1); 3704 if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (T__71 - 72)) | (1L << (T__72 - 72)) | (1L << (T__73 - 72)))) != 0)) ) { 3705 _errHandler.recoverInline(this); 3706 } 3707 else { 3708 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3709 _errHandler.reportMatch(this); 3710 consume(); 3711 } 3712 } 3713 } 3714 catch (RecognitionException re) { 3715 _localctx.exception = re; 3716 _errHandler.reportError(this, re); 3717 _errHandler.recover(this, re); 3718 } 3719 finally { 3720 exitRule(); 3721 } 3722 return _localctx; 3723 } 3724 3725 public static class SlContext extends ParserRuleContext { 3726 public LslContext lsl() { 3727 return getRuleContext(LslContext.class,0); 3728 } 3729 public DslContext dsl() { 3730 return getRuleContext(DslContext.class,0); 3731 } 3732 public SphingoxineContext sphingoxine() { 3733 return getRuleContext(SphingoxineContext.class,0); 3734 } 3735 public SlContext(ParserRuleContext parent, int invokingState) { 3736 super(parent, invokingState); 3737 } 3738 @Override public int getRuleIndex() { return RULE_sl; } 3739 @Override 3740 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3741 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSl(this); 3742 else return visitor.visitChildren(this); 3743 } 3744 } 3745 3746 public final SlContext sl() throws RecognitionException { 3747 SlContext _localctx = new SlContext(_ctx, getState()); 3748 enterRule(_localctx, 116, RULE_sl); 3749 try { 3750 setState(690); 3751 _errHandler.sync(this); 3752 switch (_input.LA(1)) { 3753 case T__118: 3754 case T__119: 3755 case T__120: 3756 case T__121: 3757 case T__122: 3758 case T__123: 3759 case T__124: 3760 case T__125: 3761 enterOuterAlt(_localctx, 1); 3762 { 3763 setState(687); 3764 lsl(); 3765 } 3766 break; 3767 case T__81: 3768 case T__82: 3769 case T__83: 3770 case T__84: 3771 case T__85: 3772 case T__86: 3773 case T__87: 3774 case T__88: 3775 case T__89: 3776 case T__90: 3777 case T__91: 3778 case T__92: 3779 case T__93: 3780 case T__94: 3781 case T__95: 3782 case T__96: 3783 case T__97: 3784 case T__98: 3785 case T__99: 3786 case T__100: 3787 case T__101: 3788 case T__102: 3789 case T__103: 3790 case T__104: 3791 case T__105: 3792 case T__107: 3793 case T__108: 3794 enterOuterAlt(_localctx, 2); 3795 { 3796 setState(688); 3797 dsl(); 3798 } 3799 break; 3800 case T__74: 3801 case T__75: 3802 case T__76: 3803 case T__77: 3804 case T__78: 3805 case T__79: 3806 case T__80: 3807 enterOuterAlt(_localctx, 3); 3808 { 3809 setState(689); 3810 sphingoxine(); 3811 } 3812 break; 3813 default: 3814 throw new NoViableAltException(this); 3815 } 3816 } 3817 catch (RecognitionException re) { 3818 _localctx.exception = re; 3819 _errHandler.reportError(this, re); 3820 _errHandler.recover(this, re); 3821 } 3822 finally { 3823 exitRule(); 3824 } 3825 return _localctx; 3826 } 3827 3828 public static class LslContext extends ParserRuleContext { 3829 public Hg_lslcContext hg_lslc() { 3830 return getRuleContext(Hg_lslcContext.class,0); 3831 } 3832 public Round_open_bracketContext round_open_bracket() { 3833 return getRuleContext(Round_open_bracketContext.class,0); 3834 } 3835 public LcbContext lcb() { 3836 return getRuleContext(LcbContext.class,0); 3837 } 3838 public Round_close_bracketContext round_close_bracket() { 3839 return getRuleContext(Round_close_bracketContext.class,0); 3840 } 3841 public LslContext(ParserRuleContext parent, int invokingState) { 3842 super(parent, invokingState); 3843 } 3844 @Override public int getRuleIndex() { return RULE_lsl; } 3845 @Override 3846 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3847 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLsl(this); 3848 else return visitor.visitChildren(this); 3849 } 3850 } 3851 3852 public final LslContext lsl() throws RecognitionException { 3853 LslContext _localctx = new LslContext(_ctx, getState()); 3854 enterRule(_localctx, 118, RULE_lsl); 3855 try { 3856 setState(700); 3857 _errHandler.sync(this); 3858 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 3859 case 1: 3860 enterOuterAlt(_localctx, 1); 3861 { 3862 setState(692); 3863 hg_lslc(); 3864 setState(693); 3865 round_open_bracket(); 3866 setState(694); 3867 lcb(); 3868 setState(695); 3869 round_close_bracket(); 3870 } 3871 break; 3872 case 2: 3873 enterOuterAlt(_localctx, 2); 3874 { 3875 setState(697); 3876 hg_lslc(); 3877 setState(698); 3878 lcb(); 3879 } 3880 break; 3881 } 3882 } 3883 catch (RecognitionException re) { 3884 _localctx.exception = re; 3885 _errHandler.reportError(this, re); 3886 _errHandler.recover(this, re); 3887 } 3888 finally { 3889 exitRule(); 3890 } 3891 return _localctx; 3892 } 3893 3894 public static class DslContext extends ParserRuleContext { 3895 public Hg_dslcContext hg_dslc() { 3896 return getRuleContext(Hg_dslcContext.class,0); 3897 } 3898 public Dsl_speciesContext dsl_species() { 3899 return getRuleContext(Dsl_speciesContext.class,0); 3900 } 3901 public Dsl_subspeciesContext dsl_subspecies() { 3902 return getRuleContext(Dsl_subspeciesContext.class,0); 3903 } 3904 public DslContext(ParserRuleContext parent, int invokingState) { 3905 super(parent, invokingState); 3906 } 3907 @Override public int getRuleIndex() { return RULE_dsl; } 3908 @Override 3909 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3910 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDsl(this); 3911 else return visitor.visitChildren(this); 3912 } 3913 } 3914 3915 public final DslContext dsl() throws RecognitionException { 3916 DslContext _localctx = new DslContext(_ctx, getState()); 3917 enterRule(_localctx, 120, RULE_dsl); 3918 try { 3919 setState(708); 3920 _errHandler.sync(this); 3921 switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) { 3922 case 1: 3923 enterOuterAlt(_localctx, 1); 3924 { 3925 setState(702); 3926 hg_dslc(); 3927 setState(703); 3928 dsl_species(); 3929 } 3930 break; 3931 case 2: 3932 enterOuterAlt(_localctx, 2); 3933 { 3934 setState(705); 3935 hg_dslc(); 3936 setState(706); 3937 dsl_subspecies(); 3938 } 3939 break; 3940 } 3941 } 3942 catch (RecognitionException re) { 3943 _localctx.exception = re; 3944 _errHandler.reportError(this, re); 3945 _errHandler.recover(this, re); 3946 } 3947 finally { 3948 exitRule(); 3949 } 3950 return _localctx; 3951 } 3952 3953 public static class Dsl_speciesContext extends ParserRuleContext { 3954 public Round_open_bracketContext round_open_bracket() { 3955 return getRuleContext(Round_open_bracketContext.class,0); 3956 } 3957 public LcbContext lcb() { 3958 return getRuleContext(LcbContext.class,0); 3959 } 3960 public Round_close_bracketContext round_close_bracket() { 3961 return getRuleContext(Round_close_bracketContext.class,0); 3962 } 3963 public Dsl_speciesContext(ParserRuleContext parent, int invokingState) { 3964 super(parent, invokingState); 3965 } 3966 @Override public int getRuleIndex() { return RULE_dsl_species; } 3967 @Override 3968 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3969 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDsl_species(this); 3970 else return visitor.visitChildren(this); 3971 } 3972 } 3973 3974 public final Dsl_speciesContext dsl_species() throws RecognitionException { 3975 Dsl_speciesContext _localctx = new Dsl_speciesContext(_ctx, getState()); 3976 enterRule(_localctx, 122, RULE_dsl_species); 3977 try { 3978 setState(715); 3979 _errHandler.sync(this); 3980 switch (_input.LA(1)) { 3981 case ROB: 3982 enterOuterAlt(_localctx, 1); 3983 { 3984 setState(710); 3985 round_open_bracket(); 3986 setState(711); 3987 lcb(); 3988 setState(712); 3989 round_close_bracket(); 3990 } 3991 break; 3992 case T__3: 3993 case T__205: 3994 case T__206: 3995 case T__207: 3996 case T__208: 3997 case T__209: 3998 case T__210: 3999 case T__211: 4000 case T__212: 4001 case T__213: 4002 case T__214: 4003 case T__215: 4004 case T__216: 4005 enterOuterAlt(_localctx, 2); 4006 { 4007 setState(714); 4008 lcb(); 4009 } 4010 break; 4011 default: 4012 throw new NoViableAltException(this); 4013 } 4014 } 4015 catch (RecognitionException re) { 4016 _localctx.exception = re; 4017 _errHandler.reportError(this, re); 4018 _errHandler.recover(this, re); 4019 } 4020 finally { 4021 exitRule(); 4022 } 4023 return _localctx; 4024 } 4025 4026 public static class Dsl_subspeciesContext extends ParserRuleContext { 4027 public Round_open_bracketContext round_open_bracket() { 4028 return getRuleContext(Round_open_bracketContext.class,0); 4029 } 4030 public Lcb_fa_sortedContext lcb_fa_sorted() { 4031 return getRuleContext(Lcb_fa_sortedContext.class,0); 4032 } 4033 public Round_close_bracketContext round_close_bracket() { 4034 return getRuleContext(Round_close_bracketContext.class,0); 4035 } 4036 public Dsl_subspeciesContext(ParserRuleContext parent, int invokingState) { 4037 super(parent, invokingState); 4038 } 4039 @Override public int getRuleIndex() { return RULE_dsl_subspecies; } 4040 @Override 4041 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4042 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDsl_subspecies(this); 4043 else return visitor.visitChildren(this); 4044 } 4045 } 4046 4047 public final Dsl_subspeciesContext dsl_subspecies() throws RecognitionException { 4048 Dsl_subspeciesContext _localctx = new Dsl_subspeciesContext(_ctx, getState()); 4049 enterRule(_localctx, 124, RULE_dsl_subspecies); 4050 try { 4051 setState(722); 4052 _errHandler.sync(this); 4053 switch (_input.LA(1)) { 4054 case ROB: 4055 enterOuterAlt(_localctx, 1); 4056 { 4057 setState(717); 4058 round_open_bracket(); 4059 setState(718); 4060 lcb_fa_sorted(); 4061 setState(719); 4062 round_close_bracket(); 4063 } 4064 break; 4065 case T__3: 4066 case T__205: 4067 case T__206: 4068 case T__207: 4069 case T__208: 4070 case T__209: 4071 case T__210: 4072 case T__211: 4073 case T__212: 4074 case T__213: 4075 case T__214: 4076 case T__215: 4077 case T__216: 4078 enterOuterAlt(_localctx, 2); 4079 { 4080 setState(721); 4081 lcb_fa_sorted(); 4082 } 4083 break; 4084 default: 4085 throw new NoViableAltException(this); 4086 } 4087 } 4088 catch (RecognitionException re) { 4089 _localctx.exception = re; 4090 _errHandler.reportError(this, re); 4091 _errHandler.recover(this, re); 4092 } 4093 finally { 4094 exitRule(); 4095 } 4096 return _localctx; 4097 } 4098 4099 public static class SphingoxineContext extends ParserRuleContext { 4100 public Sphingoxine_pureContext sphingoxine_pure() { 4101 return getRuleContext(Sphingoxine_pureContext.class,0); 4102 } 4103 public Sphingoxine_varContext sphingoxine_var() { 4104 return getRuleContext(Sphingoxine_varContext.class,0); 4105 } 4106 public SphingoxineContext(ParserRuleContext parent, int invokingState) { 4107 super(parent, invokingState); 4108 } 4109 @Override public int getRuleIndex() { return RULE_sphingoxine; } 4110 @Override 4111 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4112 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSphingoxine(this); 4113 else return visitor.visitChildren(this); 4114 } 4115 } 4116 4117 public final SphingoxineContext sphingoxine() throws RecognitionException { 4118 SphingoxineContext _localctx = new SphingoxineContext(_ctx, getState()); 4119 enterRule(_localctx, 126, RULE_sphingoxine); 4120 try { 4121 setState(726); 4122 _errHandler.sync(this); 4123 switch (_input.LA(1)) { 4124 case T__74: 4125 case T__75: 4126 case T__76: 4127 case T__77: 4128 case T__78: 4129 case T__79: 4130 enterOuterAlt(_localctx, 1); 4131 { 4132 setState(724); 4133 sphingoxine_pure(); 4134 } 4135 break; 4136 case T__80: 4137 enterOuterAlt(_localctx, 2); 4138 { 4139 setState(725); 4140 sphingoxine_var(); 4141 } 4142 break; 4143 default: 4144 throw new NoViableAltException(this); 4145 } 4146 } 4147 catch (RecognitionException re) { 4148 _localctx.exception = re; 4149 _errHandler.reportError(this, re); 4150 _errHandler.recover(this, re); 4151 } 4152 finally { 4153 exitRule(); 4154 } 4155 return _localctx; 4156 } 4157 4158 public static class Sphingoxine_pureContext extends ParserRuleContext { 4159 public Sphingosine_nameContext sphingosine_name() { 4160 return getRuleContext(Sphingosine_nameContext.class,0); 4161 } 4162 public Sphinganine_nameContext sphinganine_name() { 4163 return getRuleContext(Sphinganine_nameContext.class,0); 4164 } 4165 public Sphingoxine_pureContext(ParserRuleContext parent, int invokingState) { 4166 super(parent, invokingState); 4167 } 4168 @Override public int getRuleIndex() { return RULE_sphingoxine_pure; } 4169 @Override 4170 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4171 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSphingoxine_pure(this); 4172 else return visitor.visitChildren(this); 4173 } 4174 } 4175 4176 public final Sphingoxine_pureContext sphingoxine_pure() throws RecognitionException { 4177 Sphingoxine_pureContext _localctx = new Sphingoxine_pureContext(_ctx, getState()); 4178 enterRule(_localctx, 128, RULE_sphingoxine_pure); 4179 try { 4180 setState(730); 4181 _errHandler.sync(this); 4182 switch (_input.LA(1)) { 4183 case T__74: 4184 case T__75: 4185 case T__76: 4186 enterOuterAlt(_localctx, 1); 4187 { 4188 setState(728); 4189 sphingosine_name(); 4190 } 4191 break; 4192 case T__77: 4193 case T__78: 4194 case T__79: 4195 enterOuterAlt(_localctx, 2); 4196 { 4197 setState(729); 4198 sphinganine_name(); 4199 } 4200 break; 4201 default: 4202 throw new NoViableAltException(this); 4203 } 4204 } 4205 catch (RecognitionException re) { 4206 _localctx.exception = re; 4207 _errHandler.reportError(this, re); 4208 _errHandler.recover(this, re); 4209 } 4210 finally { 4211 exitRule(); 4212 } 4213 return _localctx; 4214 } 4215 4216 public static class Sphingoxine_varContext extends ParserRuleContext { 4217 public CtypeContext ctype() { 4218 return getRuleContext(CtypeContext.class,0); 4219 } 4220 public Headgroup_separatorContext headgroup_separator() { 4221 return getRuleContext(Headgroup_separatorContext.class,0); 4222 } 4223 public Sphingosine_nameContext sphingosine_name() { 4224 return getRuleContext(Sphingosine_nameContext.class,0); 4225 } 4226 public Sphinganine_nameContext sphinganine_name() { 4227 return getRuleContext(Sphinganine_nameContext.class,0); 4228 } 4229 public Sphingoxine_varContext(ParserRuleContext parent, int invokingState) { 4230 super(parent, invokingState); 4231 } 4232 @Override public int getRuleIndex() { return RULE_sphingoxine_var; } 4233 @Override 4234 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4235 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSphingoxine_var(this); 4236 else return visitor.visitChildren(this); 4237 } 4238 } 4239 4240 public final Sphingoxine_varContext sphingoxine_var() throws RecognitionException { 4241 Sphingoxine_varContext _localctx = new Sphingoxine_varContext(_ctx, getState()); 4242 enterRule(_localctx, 130, RULE_sphingoxine_var); 4243 try { 4244 setState(740); 4245 _errHandler.sync(this); 4246 switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) { 4247 case 1: 4248 enterOuterAlt(_localctx, 1); 4249 { 4250 setState(732); 4251 ctype(); 4252 setState(733); 4253 headgroup_separator(); 4254 setState(734); 4255 sphingosine_name(); 4256 } 4257 break; 4258 case 2: 4259 enterOuterAlt(_localctx, 2); 4260 { 4261 setState(736); 4262 ctype(); 4263 setState(737); 4264 headgroup_separator(); 4265 setState(738); 4266 sphinganine_name(); 4267 } 4268 break; 4269 } 4270 } 4271 catch (RecognitionException re) { 4272 _localctx.exception = re; 4273 _errHandler.reportError(this, re); 4274 _errHandler.recover(this, re); 4275 } 4276 finally { 4277 exitRule(); 4278 } 4279 return _localctx; 4280 } 4281 4282 public static class Sphingosine_nameContext extends ParserRuleContext { 4283 public Sphingosine_nameContext(ParserRuleContext parent, int invokingState) { 4284 super(parent, invokingState); 4285 } 4286 @Override public int getRuleIndex() { return RULE_sphingosine_name; } 4287 @Override 4288 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4289 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSphingosine_name(this); 4290 else return visitor.visitChildren(this); 4291 } 4292 } 4293 4294 public final Sphingosine_nameContext sphingosine_name() throws RecognitionException { 4295 Sphingosine_nameContext _localctx = new Sphingosine_nameContext(_ctx, getState()); 4296 enterRule(_localctx, 132, RULE_sphingosine_name); 4297 int _la; 4298 try { 4299 enterOuterAlt(_localctx, 1); 4300 { 4301 setState(742); 4302 _la = _input.LA(1); 4303 if ( !(((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (T__74 - 75)) | (1L << (T__75 - 75)) | (1L << (T__76 - 75)))) != 0)) ) { 4304 _errHandler.recoverInline(this); 4305 } 4306 else { 4307 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4308 _errHandler.reportMatch(this); 4309 consume(); 4310 } 4311 } 4312 } 4313 catch (RecognitionException re) { 4314 _localctx.exception = re; 4315 _errHandler.reportError(this, re); 4316 _errHandler.recover(this, re); 4317 } 4318 finally { 4319 exitRule(); 4320 } 4321 return _localctx; 4322 } 4323 4324 public static class Sphinganine_nameContext extends ParserRuleContext { 4325 public Sphinganine_nameContext(ParserRuleContext parent, int invokingState) { 4326 super(parent, invokingState); 4327 } 4328 @Override public int getRuleIndex() { return RULE_sphinganine_name; } 4329 @Override 4330 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4331 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSphinganine_name(this); 4332 else return visitor.visitChildren(this); 4333 } 4334 } 4335 4336 public final Sphinganine_nameContext sphinganine_name() throws RecognitionException { 4337 Sphinganine_nameContext _localctx = new Sphinganine_nameContext(_ctx, getState()); 4338 enterRule(_localctx, 134, RULE_sphinganine_name); 4339 int _la; 4340 try { 4341 enterOuterAlt(_localctx, 1); 4342 { 4343 setState(744); 4344 _la = _input.LA(1); 4345 if ( !(((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & ((1L << (T__77 - 78)) | (1L << (T__78 - 78)) | (1L << (T__79 - 78)))) != 0)) ) { 4346 _errHandler.recoverInline(this); 4347 } 4348 else { 4349 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4350 _errHandler.reportMatch(this); 4351 consume(); 4352 } 4353 } 4354 } 4355 catch (RecognitionException re) { 4356 _localctx.exception = re; 4357 _errHandler.reportError(this, re); 4358 _errHandler.recover(this, re); 4359 } 4360 finally { 4361 exitRule(); 4362 } 4363 return _localctx; 4364 } 4365 4366 public static class CtypeContext extends ParserRuleContext { 4367 public NumberContext number() { 4368 return getRuleContext(NumberContext.class,0); 4369 } 4370 public CtypeContext(ParserRuleContext parent, int invokingState) { 4371 super(parent, invokingState); 4372 } 4373 @Override public int getRuleIndex() { return RULE_ctype; } 4374 @Override 4375 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4376 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCtype(this); 4377 else return visitor.visitChildren(this); 4378 } 4379 } 4380 4381 public final CtypeContext ctype() throws RecognitionException { 4382 CtypeContext _localctx = new CtypeContext(_ctx, getState()); 4383 enterRule(_localctx, 136, RULE_ctype); 4384 try { 4385 enterOuterAlt(_localctx, 1); 4386 { 4387 setState(746); 4388 match(T__80); 4389 setState(747); 4390 number(0); 4391 } 4392 } 4393 catch (RecognitionException re) { 4394 _localctx.exception = re; 4395 _errHandler.reportError(this, re); 4396 _errHandler.recover(this, re); 4397 } 4398 finally { 4399 exitRule(); 4400 } 4401 return _localctx; 4402 } 4403 4404 public static class Hg_dslcContext extends ParserRuleContext { 4405 public Hg_dslContext hg_dsl() { 4406 return getRuleContext(Hg_dslContext.class,0); 4407 } 4408 public Headgroup_separatorContext headgroup_separator() { 4409 return getRuleContext(Headgroup_separatorContext.class,0); 4410 } 4411 public Hg_dslcContext(ParserRuleContext parent, int invokingState) { 4412 super(parent, invokingState); 4413 } 4414 @Override public int getRuleIndex() { return RULE_hg_dslc; } 4415 @Override 4416 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4417 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_dslc(this); 4418 else return visitor.visitChildren(this); 4419 } 4420 } 4421 4422 public final Hg_dslcContext hg_dslc() throws RecognitionException { 4423 Hg_dslcContext _localctx = new Hg_dslcContext(_ctx, getState()); 4424 enterRule(_localctx, 138, RULE_hg_dslc); 4425 try { 4426 setState(753); 4427 _errHandler.sync(this); 4428 switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { 4429 case 1: 4430 enterOuterAlt(_localctx, 1); 4431 { 4432 setState(749); 4433 hg_dsl(); 4434 } 4435 break; 4436 case 2: 4437 enterOuterAlt(_localctx, 2); 4438 { 4439 setState(750); 4440 hg_dsl(); 4441 setState(751); 4442 headgroup_separator(); 4443 } 4444 break; 4445 } 4446 } 4447 catch (RecognitionException re) { 4448 _localctx.exception = re; 4449 _errHandler.reportError(this, re); 4450 _errHandler.recover(this, re); 4451 } 4452 finally { 4453 exitRule(); 4454 } 4455 return _localctx; 4456 } 4457 4458 public static class Hg_dslContext extends ParserRuleContext { 4459 public Special_cerContext special_cer() { 4460 return getRuleContext(Special_cerContext.class,0); 4461 } 4462 public Hg_dslContext(ParserRuleContext parent, int invokingState) { 4463 super(parent, invokingState); 4464 } 4465 @Override public int getRuleIndex() { return RULE_hg_dsl; } 4466 @Override 4467 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4468 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_dsl(this); 4469 else return visitor.visitChildren(this); 4470 } 4471 } 4472 4473 public final Hg_dslContext hg_dsl() throws RecognitionException { 4474 Hg_dslContext _localctx = new Hg_dslContext(_ctx, getState()); 4475 enterRule(_localctx, 140, RULE_hg_dsl); 4476 try { 4477 setState(781); 4478 _errHandler.sync(this); 4479 switch (_input.LA(1)) { 4480 case T__81: 4481 enterOuterAlt(_localctx, 1); 4482 { 4483 setState(755); 4484 match(T__81); 4485 } 4486 break; 4487 case T__82: 4488 enterOuterAlt(_localctx, 2); 4489 { 4490 setState(756); 4491 match(T__82); 4492 } 4493 break; 4494 case T__83: 4495 enterOuterAlt(_localctx, 3); 4496 { 4497 setState(757); 4498 match(T__83); 4499 } 4500 break; 4501 case T__84: 4502 enterOuterAlt(_localctx, 4); 4503 { 4504 setState(758); 4505 match(T__84); 4506 } 4507 break; 4508 case T__85: 4509 enterOuterAlt(_localctx, 5); 4510 { 4511 setState(759); 4512 match(T__85); 4513 } 4514 break; 4515 case T__86: 4516 enterOuterAlt(_localctx, 6); 4517 { 4518 setState(760); 4519 match(T__86); 4520 } 4521 break; 4522 case T__87: 4523 enterOuterAlt(_localctx, 7); 4524 { 4525 setState(761); 4526 match(T__87); 4527 } 4528 break; 4529 case T__88: 4530 enterOuterAlt(_localctx, 8); 4531 { 4532 setState(762); 4533 match(T__88); 4534 } 4535 break; 4536 case T__89: 4537 enterOuterAlt(_localctx, 9); 4538 { 4539 setState(763); 4540 match(T__89); 4541 } 4542 break; 4543 case T__90: 4544 enterOuterAlt(_localctx, 10); 4545 { 4546 setState(764); 4547 match(T__90); 4548 } 4549 break; 4550 case T__91: 4551 enterOuterAlt(_localctx, 11); 4552 { 4553 setState(765); 4554 match(T__91); 4555 } 4556 break; 4557 case T__92: 4558 enterOuterAlt(_localctx, 12); 4559 { 4560 setState(766); 4561 match(T__92); 4562 } 4563 break; 4564 case T__93: 4565 enterOuterAlt(_localctx, 13); 4566 { 4567 setState(767); 4568 match(T__93); 4569 } 4570 break; 4571 case T__94: 4572 enterOuterAlt(_localctx, 14); 4573 { 4574 setState(768); 4575 match(T__94); 4576 } 4577 break; 4578 case T__95: 4579 enterOuterAlt(_localctx, 15); 4580 { 4581 setState(769); 4582 match(T__95); 4583 } 4584 break; 4585 case T__96: 4586 enterOuterAlt(_localctx, 16); 4587 { 4588 setState(770); 4589 match(T__96); 4590 } 4591 break; 4592 case T__97: 4593 enterOuterAlt(_localctx, 17); 4594 { 4595 setState(771); 4596 match(T__97); 4597 } 4598 break; 4599 case T__98: 4600 enterOuterAlt(_localctx, 18); 4601 { 4602 setState(772); 4603 match(T__98); 4604 } 4605 break; 4606 case T__99: 4607 enterOuterAlt(_localctx, 19); 4608 { 4609 setState(773); 4610 match(T__99); 4611 } 4612 break; 4613 case T__100: 4614 enterOuterAlt(_localctx, 20); 4615 { 4616 setState(774); 4617 match(T__100); 4618 } 4619 break; 4620 case T__101: 4621 enterOuterAlt(_localctx, 21); 4622 { 4623 setState(775); 4624 match(T__101); 4625 } 4626 break; 4627 case T__102: 4628 enterOuterAlt(_localctx, 22); 4629 { 4630 setState(776); 4631 match(T__102); 4632 } 4633 break; 4634 case T__103: 4635 enterOuterAlt(_localctx, 23); 4636 { 4637 setState(777); 4638 match(T__103); 4639 } 4640 break; 4641 case T__104: 4642 enterOuterAlt(_localctx, 24); 4643 { 4644 setState(778); 4645 match(T__104); 4646 } 4647 break; 4648 case T__105: 4649 enterOuterAlt(_localctx, 25); 4650 { 4651 setState(779); 4652 match(T__105); 4653 } 4654 break; 4655 case T__107: 4656 case T__108: 4657 enterOuterAlt(_localctx, 26); 4658 { 4659 setState(780); 4660 special_cer(); 4661 } 4662 break; 4663 default: 4664 throw new NoViableAltException(this); 4665 } 4666 } 4667 catch (RecognitionException re) { 4668 _localctx.exception = re; 4669 _errHandler.reportError(this, re); 4670 _errHandler.recover(this, re); 4671 } 4672 finally { 4673 exitRule(); 4674 } 4675 return _localctx; 4676 } 4677 4678 public static class Special_cerContext extends ParserRuleContext { 4679 public Special_cer_prefixContext special_cer_prefix() { 4680 return getRuleContext(Special_cer_prefixContext.class,0); 4681 } 4682 public Special_cerContext(ParserRuleContext parent, int invokingState) { 4683 super(parent, invokingState); 4684 } 4685 @Override public int getRuleIndex() { return RULE_special_cer; } 4686 @Override 4687 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4688 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSpecial_cer(this); 4689 else return visitor.visitChildren(this); 4690 } 4691 } 4692 4693 public final Special_cerContext special_cer() throws RecognitionException { 4694 Special_cerContext _localctx = new Special_cerContext(_ctx, getState()); 4695 enterRule(_localctx, 142, RULE_special_cer); 4696 try { 4697 enterOuterAlt(_localctx, 1); 4698 { 4699 setState(783); 4700 special_cer_prefix(); 4701 setState(784); 4702 match(T__106); 4703 } 4704 } 4705 catch (RecognitionException re) { 4706 _localctx.exception = re; 4707 _errHandler.reportError(this, re); 4708 _errHandler.recover(this, re); 4709 } 4710 finally { 4711 exitRule(); 4712 } 4713 return _localctx; 4714 } 4715 4716 public static class Special_cer_prefixContext extends ParserRuleContext { 4717 public Special_cer_prefix_1_OContext special_cer_prefix_1_O() { 4718 return getRuleContext(Special_cer_prefix_1_OContext.class,0); 4719 } 4720 public Special_cer_prefixContext(ParserRuleContext parent, int invokingState) { 4721 super(parent, invokingState); 4722 } 4723 @Override public int getRuleIndex() { return RULE_special_cer_prefix; } 4724 @Override 4725 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4726 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSpecial_cer_prefix(this); 4727 else return visitor.visitChildren(this); 4728 } 4729 } 4730 4731 public final Special_cer_prefixContext special_cer_prefix() throws RecognitionException { 4732 Special_cer_prefixContext _localctx = new Special_cer_prefixContext(_ctx, getState()); 4733 enterRule(_localctx, 144, RULE_special_cer_prefix); 4734 try { 4735 setState(789); 4736 _errHandler.sync(this); 4737 switch (_input.LA(1)) { 4738 case T__107: 4739 enterOuterAlt(_localctx, 1); 4740 { 4741 setState(786); 4742 match(T__107); 4743 setState(787); 4744 special_cer_prefix_1_O(); 4745 } 4746 break; 4747 case T__108: 4748 enterOuterAlt(_localctx, 2); 4749 { 4750 setState(788); 4751 match(T__108); 4752 } 4753 break; 4754 default: 4755 throw new NoViableAltException(this); 4756 } 4757 } 4758 catch (RecognitionException re) { 4759 _localctx.exception = re; 4760 _errHandler.reportError(this, re); 4761 _errHandler.recover(this, re); 4762 } 4763 finally { 4764 exitRule(); 4765 } 4766 return _localctx; 4767 } 4768 4769 public static class Special_cer_prefix_1_OContext extends ParserRuleContext { 4770 public Special_cer_prefix_1_OContext(ParserRuleContext parent, int invokingState) { 4771 super(parent, invokingState); 4772 } 4773 @Override public int getRuleIndex() { return RULE_special_cer_prefix_1_O; } 4774 @Override 4775 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4776 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSpecial_cer_prefix_1_O(this); 4777 else return visitor.visitChildren(this); 4778 } 4779 } 4780 4781 public final Special_cer_prefix_1_OContext special_cer_prefix_1_O() throws RecognitionException { 4782 Special_cer_prefix_1_OContext _localctx = new Special_cer_prefix_1_OContext(_ctx, getState()); 4783 enterRule(_localctx, 146, RULE_special_cer_prefix_1_O); 4784 int _la; 4785 try { 4786 enterOuterAlt(_localctx, 1); 4787 { 4788 setState(791); 4789 _la = _input.LA(1); 4790 if ( !(((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (T__109 - 110)) | (1L << (T__110 - 110)) | (1L << (T__111 - 110)) | (1L << (T__112 - 110)) | (1L << (T__113 - 110)) | (1L << (T__114 - 110)) | (1L << (T__115 - 110)) | (1L << (T__116 - 110)) | (1L << (T__117 - 110)))) != 0)) ) { 4791 _errHandler.recoverInline(this); 4792 } 4793 else { 4794 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4795 _errHandler.reportMatch(this); 4796 consume(); 4797 } 4798 } 4799 } 4800 catch (RecognitionException re) { 4801 _localctx.exception = re; 4802 _errHandler.reportError(this, re); 4803 _errHandler.recover(this, re); 4804 } 4805 finally { 4806 exitRule(); 4807 } 4808 return _localctx; 4809 } 4810 4811 public static class Hg_lslcContext extends ParserRuleContext { 4812 public Hg_lslContext hg_lsl() { 4813 return getRuleContext(Hg_lslContext.class,0); 4814 } 4815 public Headgroup_separatorContext headgroup_separator() { 4816 return getRuleContext(Headgroup_separatorContext.class,0); 4817 } 4818 public Hg_lslcContext(ParserRuleContext parent, int invokingState) { 4819 super(parent, invokingState); 4820 } 4821 @Override public int getRuleIndex() { return RULE_hg_lslc; } 4822 @Override 4823 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4824 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_lslc(this); 4825 else return visitor.visitChildren(this); 4826 } 4827 } 4828 4829 public final Hg_lslcContext hg_lslc() throws RecognitionException { 4830 Hg_lslcContext _localctx = new Hg_lslcContext(_ctx, getState()); 4831 enterRule(_localctx, 148, RULE_hg_lslc); 4832 try { 4833 setState(797); 4834 _errHandler.sync(this); 4835 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 4836 case 1: 4837 enterOuterAlt(_localctx, 1); 4838 { 4839 setState(793); 4840 hg_lsl(); 4841 } 4842 break; 4843 case 2: 4844 enterOuterAlt(_localctx, 2); 4845 { 4846 setState(794); 4847 hg_lsl(); 4848 setState(795); 4849 headgroup_separator(); 4850 } 4851 break; 4852 } 4853 } 4854 catch (RecognitionException re) { 4855 _localctx.exception = re; 4856 _errHandler.reportError(this, re); 4857 _errHandler.recover(this, re); 4858 } 4859 finally { 4860 exitRule(); 4861 } 4862 return _localctx; 4863 } 4864 4865 public static class Hg_lslContext extends ParserRuleContext { 4866 public Hg_lslContext(ParserRuleContext parent, int invokingState) { 4867 super(parent, invokingState); 4868 } 4869 @Override public int getRuleIndex() { return RULE_hg_lsl; } 4870 @Override 4871 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4872 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_lsl(this); 4873 else return visitor.visitChildren(this); 4874 } 4875 } 4876 4877 public final Hg_lslContext hg_lsl() throws RecognitionException { 4878 Hg_lslContext _localctx = new Hg_lslContext(_ctx, getState()); 4879 enterRule(_localctx, 150, RULE_hg_lsl); 4880 int _la; 4881 try { 4882 enterOuterAlt(_localctx, 1); 4883 { 4884 setState(799); 4885 _la = _input.LA(1); 4886 if ( !(((((_la - 119)) & ~0x3f) == 0 && ((1L << (_la - 119)) & ((1L << (T__118 - 119)) | (1L << (T__119 - 119)) | (1L << (T__120 - 119)) | (1L << (T__121 - 119)) | (1L << (T__122 - 119)) | (1L << (T__123 - 119)) | (1L << (T__124 - 119)) | (1L << (T__125 - 119)))) != 0)) ) { 4887 _errHandler.recoverInline(this); 4888 } 4889 else { 4890 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4891 _errHandler.reportMatch(this); 4892 consume(); 4893 } 4894 } 4895 } 4896 catch (RecognitionException re) { 4897 _localctx.exception = re; 4898 _errHandler.reportError(this, re); 4899 _errHandler.recover(this, re); 4900 } 4901 finally { 4902 exitRule(); 4903 } 4904 return _localctx; 4905 } 4906 4907 public static class PkContext extends ParserRuleContext { 4908 public Pk_hgContext pk_hg() { 4909 return getRuleContext(Pk_hgContext.class,0); 4910 } 4911 public Pk_faContext pk_fa() { 4912 return getRuleContext(Pk_faContext.class,0); 4913 } 4914 public PkContext(ParserRuleContext parent, int invokingState) { 4915 super(parent, invokingState); 4916 } 4917 @Override public int getRuleIndex() { return RULE_pk; } 4918 @Override 4919 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4920 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPk(this); 4921 else return visitor.visitChildren(this); 4922 } 4923 } 4924 4925 public final PkContext pk() throws RecognitionException { 4926 PkContext _localctx = new PkContext(_ctx, getState()); 4927 enterRule(_localctx, 152, RULE_pk); 4928 try { 4929 enterOuterAlt(_localctx, 1); 4930 { 4931 setState(801); 4932 pk_hg(); 4933 setState(802); 4934 pk_fa(); 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 Pk_hgContext extends ParserRuleContext { 4949 public Pk_hgContext(ParserRuleContext parent, int invokingState) { 4950 super(parent, invokingState); 4951 } 4952 @Override public int getRuleIndex() { return RULE_pk_hg; } 4953 @Override 4954 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4955 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPk_hg(this); 4956 else return visitor.visitChildren(this); 4957 } 4958 } 4959 4960 public final Pk_hgContext pk_hg() throws RecognitionException { 4961 Pk_hgContext _localctx = new Pk_hgContext(_ctx, getState()); 4962 enterRule(_localctx, 154, RULE_pk_hg); 4963 int _la; 4964 try { 4965 enterOuterAlt(_localctx, 1); 4966 { 4967 setState(804); 4968 _la = _input.LA(1); 4969 if ( !(((((_la - 127)) & ~0x3f) == 0 && ((1L << (_la - 127)) & ((1L << (T__126 - 127)) | (1L << (T__127 - 127)) | (1L << (T__128 - 127)) | (1L << (T__129 - 127)))) != 0)) ) { 4970 _errHandler.recoverInline(this); 4971 } 4972 else { 4973 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4974 _errHandler.reportMatch(this); 4975 consume(); 4976 } 4977 } 4978 } 4979 catch (RecognitionException re) { 4980 _localctx.exception = re; 4981 _errHandler.reportError(this, re); 4982 _errHandler.recover(this, re); 4983 } 4984 finally { 4985 exitRule(); 4986 } 4987 return _localctx; 4988 } 4989 4990 public static class Pk_faContext extends ParserRuleContext { 4991 public Round_open_bracketContext round_open_bracket() { 4992 return getRuleContext(Round_open_bracketContext.class,0); 4993 } 4994 public FaContext fa() { 4995 return getRuleContext(FaContext.class,0); 4996 } 4997 public Round_close_bracketContext round_close_bracket() { 4998 return getRuleContext(Round_close_bracketContext.class,0); 4999 } 5000 public Pk_faContext(ParserRuleContext parent, int invokingState) { 5001 super(parent, invokingState); 5002 } 5003 @Override public int getRuleIndex() { return RULE_pk_fa; } 5004 @Override 5005 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5006 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitPk_fa(this); 5007 else return visitor.visitChildren(this); 5008 } 5009 } 5010 5011 public final Pk_faContext pk_fa() throws RecognitionException { 5012 Pk_faContext _localctx = new Pk_faContext(_ctx, getState()); 5013 enterRule(_localctx, 156, RULE_pk_fa); 5014 try { 5015 enterOuterAlt(_localctx, 1); 5016 { 5017 setState(806); 5018 round_open_bracket(); 5019 setState(807); 5020 fa(); 5021 setState(808); 5022 round_close_bracket(); 5023 } 5024 } 5025 catch (RecognitionException re) { 5026 _localctx.exception = re; 5027 _errHandler.reportError(this, re); 5028 _errHandler.recover(this, re); 5029 } 5030 finally { 5031 exitRule(); 5032 } 5033 return _localctx; 5034 } 5035 5036 public static class SterolContext extends ParserRuleContext { 5037 public ChcContext chc() { 5038 return getRuleContext(ChcContext.class,0); 5039 } 5040 public ChecContext chec() { 5041 return getRuleContext(ChecContext.class,0); 5042 } 5043 public SterolContext(ParserRuleContext parent, int invokingState) { 5044 super(parent, invokingState); 5045 } 5046 @Override public int getRuleIndex() { return RULE_sterol; } 5047 @Override 5048 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5049 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSterol(this); 5050 else return visitor.visitChildren(this); 5051 } 5052 } 5053 5054 public final SterolContext sterol() throws RecognitionException { 5055 SterolContext _localctx = new SterolContext(_ctx, getState()); 5056 enterRule(_localctx, 158, RULE_sterol); 5057 try { 5058 setState(812); 5059 _errHandler.sync(this); 5060 switch (_input.LA(1)) { 5061 case T__130: 5062 enterOuterAlt(_localctx, 1); 5063 { 5064 setState(810); 5065 chc(); 5066 } 5067 break; 5068 case T__131: 5069 case T__132: 5070 case T__133: 5071 case T__201: 5072 case T__202: 5073 case T__207: 5074 case T__208: 5075 case T__209: 5076 case T__210: 5077 case T__211: 5078 case T__212: 5079 case T__213: 5080 case T__214: 5081 case T__215: 5082 case T__216: 5083 case ROB: 5084 enterOuterAlt(_localctx, 2); 5085 { 5086 setState(811); 5087 chec(); 5088 } 5089 break; 5090 default: 5091 throw new NoViableAltException(this); 5092 } 5093 } 5094 catch (RecognitionException re) { 5095 _localctx.exception = re; 5096 _errHandler.reportError(this, re); 5097 _errHandler.recover(this, re); 5098 } 5099 finally { 5100 exitRule(); 5101 } 5102 return _localctx; 5103 } 5104 5105 public static class ChcContext extends ParserRuleContext { 5106 public ChContext ch() { 5107 return getRuleContext(ChContext.class,0); 5108 } 5109 public Headgroup_separatorContext headgroup_separator() { 5110 return getRuleContext(Headgroup_separatorContext.class,0); 5111 } 5112 public ChcContext(ParserRuleContext parent, int invokingState) { 5113 super(parent, invokingState); 5114 } 5115 @Override public int getRuleIndex() { return RULE_chc; } 5116 @Override 5117 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5118 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitChc(this); 5119 else return visitor.visitChildren(this); 5120 } 5121 } 5122 5123 public final ChcContext chc() throws RecognitionException { 5124 ChcContext _localctx = new ChcContext(_ctx, getState()); 5125 enterRule(_localctx, 160, RULE_chc); 5126 try { 5127 setState(818); 5128 _errHandler.sync(this); 5129 switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { 5130 case 1: 5131 enterOuterAlt(_localctx, 1); 5132 { 5133 setState(814); 5134 ch(); 5135 } 5136 break; 5137 case 2: 5138 enterOuterAlt(_localctx, 2); 5139 { 5140 setState(815); 5141 ch(); 5142 setState(816); 5143 headgroup_separator(); 5144 } 5145 break; 5146 } 5147 } 5148 catch (RecognitionException re) { 5149 _localctx.exception = re; 5150 _errHandler.reportError(this, re); 5151 _errHandler.recover(this, re); 5152 } 5153 finally { 5154 exitRule(); 5155 } 5156 return _localctx; 5157 } 5158 5159 public static class ChContext extends ParserRuleContext { 5160 public ChContext(ParserRuleContext parent, int invokingState) { 5161 super(parent, invokingState); 5162 } 5163 @Override public int getRuleIndex() { return RULE_ch; } 5164 @Override 5165 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5166 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCh(this); 5167 else return visitor.visitChildren(this); 5168 } 5169 } 5170 5171 public final ChContext ch() throws RecognitionException { 5172 ChContext _localctx = new ChContext(_ctx, getState()); 5173 enterRule(_localctx, 162, RULE_ch); 5174 try { 5175 enterOuterAlt(_localctx, 1); 5176 { 5177 setState(820); 5178 match(T__130); 5179 } 5180 } 5181 catch (RecognitionException re) { 5182 _localctx.exception = re; 5183 _errHandler.reportError(this, re); 5184 _errHandler.recover(this, re); 5185 } 5186 finally { 5187 exitRule(); 5188 } 5189 return _localctx; 5190 } 5191 5192 public static class ChecContext extends ParserRuleContext { 5193 public CheContext che() { 5194 return getRuleContext(CheContext.class,0); 5195 } 5196 public Headgroup_separatorContext headgroup_separator() { 5197 return getRuleContext(Headgroup_separatorContext.class,0); 5198 } 5199 public Che_faContext che_fa() { 5200 return getRuleContext(Che_faContext.class,0); 5201 } 5202 public ChecContext(ParserRuleContext parent, int invokingState) { 5203 super(parent, invokingState); 5204 } 5205 @Override public int getRuleIndex() { return RULE_chec; } 5206 @Override 5207 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5208 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitChec(this); 5209 else return visitor.visitChildren(this); 5210 } 5211 } 5212 5213 public final ChecContext chec() throws RecognitionException { 5214 ChecContext _localctx = new ChecContext(_ctx, getState()); 5215 enterRule(_localctx, 164, RULE_chec); 5216 try { 5217 setState(827); 5218 _errHandler.sync(this); 5219 switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) { 5220 case 1: 5221 enterOuterAlt(_localctx, 1); 5222 { 5223 setState(822); 5224 che(); 5225 } 5226 break; 5227 case 2: 5228 enterOuterAlt(_localctx, 2); 5229 { 5230 setState(823); 5231 che(); 5232 setState(824); 5233 headgroup_separator(); 5234 } 5235 break; 5236 case 3: 5237 enterOuterAlt(_localctx, 3); 5238 { 5239 setState(826); 5240 che_fa(); 5241 } 5242 break; 5243 } 5244 } 5245 catch (RecognitionException re) { 5246 _localctx.exception = re; 5247 _errHandler.reportError(this, re); 5248 _errHandler.recover(this, re); 5249 } 5250 finally { 5251 exitRule(); 5252 } 5253 return _localctx; 5254 } 5255 5256 public static class CheContext extends ParserRuleContext { 5257 public FaContext fa() { 5258 return getRuleContext(FaContext.class,0); 5259 } 5260 public Headgroup_separatorContext headgroup_separator() { 5261 return getRuleContext(Headgroup_separatorContext.class,0); 5262 } 5263 public Hg_cheContext hg_che() { 5264 return getRuleContext(Hg_cheContext.class,0); 5265 } 5266 public CheContext(ParserRuleContext parent, int invokingState) { 5267 super(parent, invokingState); 5268 } 5269 @Override public int getRuleIndex() { return RULE_che; } 5270 @Override 5271 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5272 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitChe(this); 5273 else return visitor.visitChildren(this); 5274 } 5275 } 5276 5277 public final CheContext che() throws RecognitionException { 5278 CheContext _localctx = new CheContext(_ctx, getState()); 5279 enterRule(_localctx, 166, RULE_che); 5280 try { 5281 enterOuterAlt(_localctx, 1); 5282 { 5283 setState(829); 5284 fa(); 5285 setState(830); 5286 headgroup_separator(); 5287 setState(831); 5288 hg_che(); 5289 } 5290 } 5291 catch (RecognitionException re) { 5292 _localctx.exception = re; 5293 _errHandler.reportError(this, re); 5294 _errHandler.recover(this, re); 5295 } 5296 finally { 5297 exitRule(); 5298 } 5299 return _localctx; 5300 } 5301 5302 public static class Che_faContext extends ParserRuleContext { 5303 public Hg_cheContext hg_che() { 5304 return getRuleContext(Hg_cheContext.class,0); 5305 } 5306 public Round_open_bracketContext round_open_bracket() { 5307 return getRuleContext(Round_open_bracketContext.class,0); 5308 } 5309 public FaContext fa() { 5310 return getRuleContext(FaContext.class,0); 5311 } 5312 public Round_close_bracketContext round_close_bracket() { 5313 return getRuleContext(Round_close_bracketContext.class,0); 5314 } 5315 public Che_faContext(ParserRuleContext parent, int invokingState) { 5316 super(parent, invokingState); 5317 } 5318 @Override public int getRuleIndex() { return RULE_che_fa; } 5319 @Override 5320 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5321 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitChe_fa(this); 5322 else return visitor.visitChildren(this); 5323 } 5324 } 5325 5326 public final Che_faContext che_fa() throws RecognitionException { 5327 Che_faContext _localctx = new Che_faContext(_ctx, getState()); 5328 enterRule(_localctx, 168, RULE_che_fa); 5329 try { 5330 enterOuterAlt(_localctx, 1); 5331 { 5332 setState(833); 5333 hg_che(); 5334 setState(834); 5335 round_open_bracket(); 5336 setState(835); 5337 fa(); 5338 setState(836); 5339 round_close_bracket(); 5340 } 5341 } 5342 catch (RecognitionException re) { 5343 _localctx.exception = re; 5344 _errHandler.reportError(this, re); 5345 _errHandler.recover(this, re); 5346 } 5347 finally { 5348 exitRule(); 5349 } 5350 return _localctx; 5351 } 5352 5353 public static class Hg_cheContext extends ParserRuleContext { 5354 public Hg_cheContext(ParserRuleContext parent, int invokingState) { 5355 super(parent, invokingState); 5356 } 5357 @Override public int getRuleIndex() { return RULE_hg_che; } 5358 @Override 5359 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5360 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHg_che(this); 5361 else return visitor.visitChildren(this); 5362 } 5363 } 5364 5365 public final Hg_cheContext hg_che() throws RecognitionException { 5366 Hg_cheContext _localctx = new Hg_cheContext(_ctx, getState()); 5367 enterRule(_localctx, 170, RULE_hg_che); 5368 int _la; 5369 try { 5370 enterOuterAlt(_localctx, 1); 5371 { 5372 setState(838); 5373 _la = _input.LA(1); 5374 if ( !(((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (T__131 - 132)) | (1L << (T__132 - 132)) | (1L << (T__133 - 132)))) != 0)) ) { 5375 _errHandler.recoverInline(this); 5376 } 5377 else { 5378 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5379 _errHandler.reportMatch(this); 5380 consume(); 5381 } 5382 } 5383 } 5384 catch (RecognitionException re) { 5385 _localctx.exception = re; 5386 _errHandler.reportError(this, re); 5387 _errHandler.recover(this, re); 5388 } 5389 finally { 5390 exitRule(); 5391 } 5392 return _localctx; 5393 } 5394 5395 public static class MediatorContext extends ParserRuleContext { 5396 public Mediator_varContext mediator_var() { 5397 return getRuleContext(Mediator_varContext.class,0); 5398 } 5399 public Mediator_constContext mediator_const() { 5400 return getRuleContext(Mediator_constContext.class,0); 5401 } 5402 public MediatorContext(ParserRuleContext parent, int invokingState) { 5403 super(parent, invokingState); 5404 } 5405 @Override public int getRuleIndex() { return RULE_mediator; } 5406 @Override 5407 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5408 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator(this); 5409 else return visitor.visitChildren(this); 5410 } 5411 } 5412 5413 public final MediatorContext mediator() throws RecognitionException { 5414 MediatorContext _localctx = new MediatorContext(_ctx, getState()); 5415 enterRule(_localctx, 172, RULE_mediator); 5416 try { 5417 setState(842); 5418 _errHandler.sync(this); 5419 switch (_input.LA(1)) { 5420 case T__134: 5421 case T__207: 5422 case T__208: 5423 case T__209: 5424 case T__210: 5425 case T__211: 5426 case T__212: 5427 case T__213: 5428 case T__214: 5429 case T__215: 5430 case T__216: 5431 case ROB: 5432 enterOuterAlt(_localctx, 1); 5433 { 5434 setState(840); 5435 mediator_var(); 5436 } 5437 break; 5438 case T__151: 5439 case T__152: 5440 case T__153: 5441 case T__154: 5442 case T__155: 5443 case T__156: 5444 case T__157: 5445 case T__158: 5446 case T__159: 5447 case T__160: 5448 case T__161: 5449 case T__162: 5450 case T__163: 5451 case T__164: 5452 case T__165: 5453 case T__166: 5454 case T__167: 5455 case T__168: 5456 case T__169: 5457 case T__170: 5458 case T__171: 5459 case T__172: 5460 case T__173: 5461 case T__174: 5462 enterOuterAlt(_localctx, 2); 5463 { 5464 setState(841); 5465 mediator_const(); 5466 } 5467 break; 5468 default: 5469 throw new NoViableAltException(this); 5470 } 5471 } 5472 catch (RecognitionException re) { 5473 _localctx.exception = re; 5474 _errHandler.reportError(this, re); 5475 _errHandler.recover(this, re); 5476 } 5477 finally { 5478 exitRule(); 5479 } 5480 return _localctx; 5481 } 5482 5483 public static class Mediator_varContext extends ParserRuleContext { 5484 public Mediator_prefixContext mediator_prefix() { 5485 return getRuleContext(Mediator_prefixContext.class,0); 5486 } 5487 public Mediator_name_separatorContext mediator_name_separator() { 5488 return getRuleContext(Mediator_name_separatorContext.class,0); 5489 } 5490 public Mediator_var_namesContext mediator_var_names() { 5491 return getRuleContext(Mediator_var_namesContext.class,0); 5492 } 5493 public Mediator_varContext(ParserRuleContext parent, int invokingState) { 5494 super(parent, invokingState); 5495 } 5496 @Override public int getRuleIndex() { return RULE_mediator_var; } 5497 @Override 5498 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5499 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_var(this); 5500 else return visitor.visitChildren(this); 5501 } 5502 } 5503 5504 public final Mediator_varContext mediator_var() throws RecognitionException { 5505 Mediator_varContext _localctx = new Mediator_varContext(_ctx, getState()); 5506 enterRule(_localctx, 174, RULE_mediator_var); 5507 try { 5508 setState(853); 5509 _errHandler.sync(this); 5510 switch (_input.LA(1)) { 5511 case T__207: 5512 case T__208: 5513 case T__209: 5514 case T__210: 5515 case T__211: 5516 case T__212: 5517 case T__213: 5518 case T__214: 5519 case T__215: 5520 case T__216: 5521 case ROB: 5522 enterOuterAlt(_localctx, 1); 5523 { 5524 setState(844); 5525 mediator_prefix(0); 5526 setState(845); 5527 mediator_name_separator(); 5528 setState(846); 5529 mediator_var_names(); 5530 } 5531 break; 5532 case T__134: 5533 enterOuterAlt(_localctx, 2); 5534 { 5535 setState(848); 5536 match(T__134); 5537 setState(849); 5538 mediator_prefix(0); 5539 setState(850); 5540 mediator_name_separator(); 5541 setState(851); 5542 mediator_var_names(); 5543 } 5544 break; 5545 default: 5546 throw new NoViableAltException(this); 5547 } 5548 } 5549 catch (RecognitionException re) { 5550 _localctx.exception = re; 5551 _errHandler.reportError(this, re); 5552 _errHandler.recover(this, re); 5553 } 5554 finally { 5555 exitRule(); 5556 } 5557 return _localctx; 5558 } 5559 5560 public static class Mediator_prefixContext extends ParserRuleContext { 5561 public Mediator_numbersContext mediator_numbers() { 5562 return getRuleContext(Mediator_numbersContext.class,0); 5563 } 5564 public List<Mediator_prefixContext> mediator_prefix() { 5565 return getRuleContexts(Mediator_prefixContext.class); 5566 } 5567 public Mediator_prefixContext mediator_prefix(int i) { 5568 return getRuleContext(Mediator_prefixContext.class,i); 5569 } 5570 public Mediator_prefixContext(ParserRuleContext parent, int invokingState) { 5571 super(parent, invokingState); 5572 } 5573 @Override public int getRuleIndex() { return RULE_mediator_prefix; } 5574 @Override 5575 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5576 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_prefix(this); 5577 else return visitor.visitChildren(this); 5578 } 5579 } 5580 5581 public final Mediator_prefixContext mediator_prefix() throws RecognitionException { 5582 return mediator_prefix(0); 5583 } 5584 5585 private Mediator_prefixContext mediator_prefix(int _p) throws RecognitionException { 5586 ParserRuleContext _parentctx = _ctx; 5587 int _parentState = getState(); 5588 Mediator_prefixContext _localctx = new Mediator_prefixContext(_ctx, _parentState); 5589 Mediator_prefixContext _prevctx = _localctx; 5590 int _startState = 176; 5591 enterRecursionRule(_localctx, 176, RULE_mediator_prefix, _p); 5592 try { 5593 int _alt; 5594 enterOuterAlt(_localctx, 1); 5595 { 5596 { 5597 setState(856); 5598 mediator_numbers(0); 5599 } 5600 _ctx.stop = _input.LT(-1); 5601 setState(862); 5602 _errHandler.sync(this); 5603 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 5604 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5605 if ( _alt==1 ) { 5606 if ( _parseListeners!=null ) triggerExitRuleEvent(); 5607 _prevctx = _localctx; 5608 { 5609 { 5610 _localctx = new Mediator_prefixContext(_parentctx, _parentState); 5611 pushNewRecursionContext(_localctx, _startState, RULE_mediator_prefix); 5612 setState(858); 5613 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); 5614 setState(859); 5615 mediator_prefix(2); 5616 } 5617 } 5618 } 5619 setState(864); 5620 _errHandler.sync(this); 5621 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 5622 } 5623 } 5624 } 5625 catch (RecognitionException re) { 5626 _localctx.exception = re; 5627 _errHandler.reportError(this, re); 5628 _errHandler.recover(this, re); 5629 } 5630 finally { 5631 unrollRecursionContexts(_parentctx); 5632 } 5633 return _localctx; 5634 } 5635 5636 public static class Mediator_numbersContext extends ParserRuleContext { 5637 public Mediator_number_pureContext mediator_number_pure() { 5638 return getRuleContext(Mediator_number_pureContext.class,0); 5639 } 5640 public Mediator_posContext mediator_pos() { 5641 return getRuleContext(Mediator_posContext.class,0); 5642 } 5643 public List<Mediator_numbersContext> mediator_numbers() { 5644 return getRuleContexts(Mediator_numbersContext.class); 5645 } 5646 public Mediator_numbersContext mediator_numbers(int i) { 5647 return getRuleContext(Mediator_numbersContext.class,i); 5648 } 5649 public Mediator_separatorContext mediator_separator() { 5650 return getRuleContext(Mediator_separatorContext.class,0); 5651 } 5652 public Mediator_numbersContext(ParserRuleContext parent, int invokingState) { 5653 super(parent, invokingState); 5654 } 5655 @Override public int getRuleIndex() { return RULE_mediator_numbers; } 5656 @Override 5657 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5658 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_numbers(this); 5659 else return visitor.visitChildren(this); 5660 } 5661 } 5662 5663 public final Mediator_numbersContext mediator_numbers() throws RecognitionException { 5664 return mediator_numbers(0); 5665 } 5666 5667 private Mediator_numbersContext mediator_numbers(int _p) throws RecognitionException { 5668 ParserRuleContext _parentctx = _ctx; 5669 int _parentState = getState(); 5670 Mediator_numbersContext _localctx = new Mediator_numbersContext(_ctx, _parentState); 5671 Mediator_numbersContext _prevctx = _localctx; 5672 int _startState = 178; 5673 enterRecursionRule(_localctx, 178, RULE_mediator_numbers, _p); 5674 try { 5675 int _alt; 5676 enterOuterAlt(_localctx, 1); 5677 { 5678 setState(870); 5679 _errHandler.sync(this); 5680 switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { 5681 case 1: 5682 { 5683 setState(866); 5684 mediator_number_pure(); 5685 } 5686 break; 5687 case 2: 5688 { 5689 setState(867); 5690 mediator_number_pure(); 5691 setState(868); 5692 mediator_pos(); 5693 } 5694 break; 5695 } 5696 _ctx.stop = _input.LT(-1); 5697 setState(878); 5698 _errHandler.sync(this); 5699 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 5700 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5701 if ( _alt==1 ) { 5702 if ( _parseListeners!=null ) triggerExitRuleEvent(); 5703 _prevctx = _localctx; 5704 { 5705 { 5706 _localctx = new Mediator_numbersContext(_parentctx, _parentState); 5707 pushNewRecursionContext(_localctx, _startState, RULE_mediator_numbers); 5708 setState(872); 5709 if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); 5710 setState(873); 5711 mediator_separator(); 5712 setState(874); 5713 mediator_numbers(4); 5714 } 5715 } 5716 } 5717 setState(880); 5718 _errHandler.sync(this); 5719 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 5720 } 5721 } 5722 } 5723 catch (RecognitionException re) { 5724 _localctx.exception = re; 5725 _errHandler.reportError(this, re); 5726 _errHandler.recover(this, re); 5727 } 5728 finally { 5729 unrollRecursionContexts(_parentctx); 5730 } 5731 return _localctx; 5732 } 5733 5734 public static class Mediator_number_pureContext extends ParserRuleContext { 5735 public NumberContext number() { 5736 return getRuleContext(NumberContext.class,0); 5737 } 5738 public Round_open_bracketContext round_open_bracket() { 5739 return getRuleContext(Round_open_bracketContext.class,0); 5740 } 5741 public Round_close_bracketContext round_close_bracket() { 5742 return getRuleContext(Round_close_bracketContext.class,0); 5743 } 5744 public Mediator_number_pureContext(ParserRuleContext parent, int invokingState) { 5745 super(parent, invokingState); 5746 } 5747 @Override public int getRuleIndex() { return RULE_mediator_number_pure; } 5748 @Override 5749 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5750 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_number_pure(this); 5751 else return visitor.visitChildren(this); 5752 } 5753 } 5754 5755 public final Mediator_number_pureContext mediator_number_pure() throws RecognitionException { 5756 Mediator_number_pureContext _localctx = new Mediator_number_pureContext(_ctx, getState()); 5757 enterRule(_localctx, 180, RULE_mediator_number_pure); 5758 try { 5759 setState(886); 5760 _errHandler.sync(this); 5761 switch (_input.LA(1)) { 5762 case T__207: 5763 case T__208: 5764 case T__209: 5765 case T__210: 5766 case T__211: 5767 case T__212: 5768 case T__213: 5769 case T__214: 5770 case T__215: 5771 case T__216: 5772 enterOuterAlt(_localctx, 1); 5773 { 5774 setState(881); 5775 number(0); 5776 } 5777 break; 5778 case ROB: 5779 enterOuterAlt(_localctx, 2); 5780 { 5781 setState(882); 5782 round_open_bracket(); 5783 setState(883); 5784 number(0); 5785 setState(884); 5786 round_close_bracket(); 5787 } 5788 break; 5789 default: 5790 throw new NoViableAltException(this); 5791 } 5792 } 5793 catch (RecognitionException re) { 5794 _localctx.exception = re; 5795 _errHandler.reportError(this, re); 5796 _errHandler.recover(this, re); 5797 } 5798 finally { 5799 exitRule(); 5800 } 5801 return _localctx; 5802 } 5803 5804 public static class Mediator_posContext extends ParserRuleContext { 5805 public Mediator_posContext(ParserRuleContext parent, int invokingState) { 5806 super(parent, invokingState); 5807 } 5808 @Override public int getRuleIndex() { return RULE_mediator_pos; } 5809 @Override 5810 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5811 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_pos(this); 5812 else return visitor.visitChildren(this); 5813 } 5814 } 5815 5816 public final Mediator_posContext mediator_pos() throws RecognitionException { 5817 Mediator_posContext _localctx = new Mediator_posContext(_ctx, getState()); 5818 enterRule(_localctx, 182, RULE_mediator_pos); 5819 int _la; 5820 try { 5821 enterOuterAlt(_localctx, 1); 5822 { 5823 setState(888); 5824 _la = _input.LA(1); 5825 if ( !(_la==T__2 || _la==T__135) ) { 5826 _errHandler.recoverInline(this); 5827 } 5828 else { 5829 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5830 _errHandler.reportMatch(this); 5831 consume(); 5832 } 5833 } 5834 } 5835 catch (RecognitionException re) { 5836 _localctx.exception = re; 5837 _errHandler.reportError(this, re); 5838 _errHandler.recover(this, re); 5839 } 5840 finally { 5841 exitRule(); 5842 } 5843 return _localctx; 5844 } 5845 5846 public static class Mediator_var_namesContext extends ParserRuleContext { 5847 public Mediator_var_nameContext mediator_var_name() { 5848 return getRuleContext(Mediator_var_nameContext.class,0); 5849 } 5850 public Mediator_oxoContext mediator_oxo() { 5851 return getRuleContext(Mediator_oxoContext.class,0); 5852 } 5853 public TerminalNode DASH() { return getToken(LipidMapsParser.DASH, 0); } 5854 public Mediator_var_namesContext(ParserRuleContext parent, int invokingState) { 5855 super(parent, invokingState); 5856 } 5857 @Override public int getRuleIndex() { return RULE_mediator_var_names; } 5858 @Override 5859 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5860 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_var_names(this); 5861 else return visitor.visitChildren(this); 5862 } 5863 } 5864 5865 public final Mediator_var_namesContext mediator_var_names() throws RecognitionException { 5866 Mediator_var_namesContext _localctx = new Mediator_var_namesContext(_ctx, getState()); 5867 enterRule(_localctx, 184, RULE_mediator_var_names); 5868 try { 5869 setState(895); 5870 _errHandler.sync(this); 5871 switch (_input.LA(1)) { 5872 case T__136: 5873 case T__137: 5874 case T__138: 5875 case T__139: 5876 case T__140: 5877 case T__141: 5878 case T__142: 5879 case T__143: 5880 case T__144: 5881 case T__145: 5882 case T__146: 5883 case T__147: 5884 case T__148: 5885 case T__149: 5886 case T__150: 5887 enterOuterAlt(_localctx, 1); 5888 { 5889 setState(890); 5890 mediator_var_name(); 5891 } 5892 break; 5893 case T__175: 5894 case T__176: 5895 enterOuterAlt(_localctx, 2); 5896 { 5897 setState(891); 5898 mediator_oxo(); 5899 setState(892); 5900 match(DASH); 5901 setState(893); 5902 mediator_var_name(); 5903 } 5904 break; 5905 default: 5906 throw new NoViableAltException(this); 5907 } 5908 } 5909 catch (RecognitionException re) { 5910 _localctx.exception = re; 5911 _errHandler.reportError(this, re); 5912 _errHandler.recover(this, re); 5913 } 5914 finally { 5915 exitRule(); 5916 } 5917 return _localctx; 5918 } 5919 5920 public static class Mediator_var_nameContext extends ParserRuleContext { 5921 public Mediator_var_nameContext(ParserRuleContext parent, int invokingState) { 5922 super(parent, invokingState); 5923 } 5924 @Override public int getRuleIndex() { return RULE_mediator_var_name; } 5925 @Override 5926 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5927 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_var_name(this); 5928 else return visitor.visitChildren(this); 5929 } 5930 } 5931 5932 public final Mediator_var_nameContext mediator_var_name() throws RecognitionException { 5933 Mediator_var_nameContext _localctx = new Mediator_var_nameContext(_ctx, getState()); 5934 enterRule(_localctx, 186, RULE_mediator_var_name); 5935 int _la; 5936 try { 5937 enterOuterAlt(_localctx, 1); 5938 { 5939 setState(897); 5940 _la = _input.LA(1); 5941 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)) | (1L << (T__142 - 137)) | (1L << (T__143 - 137)) | (1L << (T__144 - 137)) | (1L << (T__145 - 137)) | (1L << (T__146 - 137)) | (1L << (T__147 - 137)) | (1L << (T__148 - 137)) | (1L << (T__149 - 137)) | (1L << (T__150 - 137)))) != 0)) ) { 5942 _errHandler.recoverInline(this); 5943 } 5944 else { 5945 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5946 _errHandler.reportMatch(this); 5947 consume(); 5948 } 5949 } 5950 } 5951 catch (RecognitionException re) { 5952 _localctx.exception = re; 5953 _errHandler.reportError(this, re); 5954 _errHandler.recover(this, re); 5955 } 5956 finally { 5957 exitRule(); 5958 } 5959 return _localctx; 5960 } 5961 5962 public static class Mediator_constContext extends ParserRuleContext { 5963 public Mediator_constContext(ParserRuleContext parent, int invokingState) { 5964 super(parent, invokingState); 5965 } 5966 @Override public int getRuleIndex() { return RULE_mediator_const; } 5967 @Override 5968 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5969 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_const(this); 5970 else return visitor.visitChildren(this); 5971 } 5972 } 5973 5974 public final Mediator_constContext mediator_const() throws RecognitionException { 5975 Mediator_constContext _localctx = new Mediator_constContext(_ctx, getState()); 5976 enterRule(_localctx, 188, RULE_mediator_const); 5977 int _la; 5978 try { 5979 enterOuterAlt(_localctx, 1); 5980 { 5981 setState(899); 5982 _la = _input.LA(1); 5983 if ( !(((((_la - 152)) & ~0x3f) == 0 && ((1L << (_la - 152)) & ((1L << (T__151 - 152)) | (1L << (T__152 - 152)) | (1L << (T__153 - 152)) | (1L << (T__154 - 152)) | (1L << (T__155 - 152)) | (1L << (T__156 - 152)) | (1L << (T__157 - 152)) | (1L << (T__158 - 152)) | (1L << (T__159 - 152)) | (1L << (T__160 - 152)) | (1L << (T__161 - 152)) | (1L << (T__162 - 152)) | (1L << (T__163 - 152)) | (1L << (T__164 - 152)) | (1L << (T__165 - 152)) | (1L << (T__166 - 152)) | (1L << (T__167 - 152)) | (1L << (T__168 - 152)) | (1L << (T__169 - 152)) | (1L << (T__170 - 152)) | (1L << (T__171 - 152)) | (1L << (T__172 - 152)) | (1L << (T__173 - 152)) | (1L << (T__174 - 152)))) != 0)) ) { 5984 _errHandler.recoverInline(this); 5985 } 5986 else { 5987 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5988 _errHandler.reportMatch(this); 5989 consume(); 5990 } 5991 } 5992 } 5993 catch (RecognitionException re) { 5994 _localctx.exception = re; 5995 _errHandler.reportError(this, re); 5996 _errHandler.recover(this, re); 5997 } 5998 finally { 5999 exitRule(); 6000 } 6001 return _localctx; 6002 } 6003 6004 public static class Mediator_oxoContext extends ParserRuleContext { 6005 public Mediator_oxoContext(ParserRuleContext parent, int invokingState) { 6006 super(parent, invokingState); 6007 } 6008 @Override public int getRuleIndex() { return RULE_mediator_oxo; } 6009 @Override 6010 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6011 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_oxo(this); 6012 else return visitor.visitChildren(this); 6013 } 6014 } 6015 6016 public final Mediator_oxoContext mediator_oxo() throws RecognitionException { 6017 Mediator_oxoContext _localctx = new Mediator_oxoContext(_ctx, getState()); 6018 enterRule(_localctx, 190, RULE_mediator_oxo); 6019 int _la; 6020 try { 6021 enterOuterAlt(_localctx, 1); 6022 { 6023 setState(901); 6024 _la = _input.LA(1); 6025 if ( !(_la==T__175 || _la==T__176) ) { 6026 _errHandler.recoverInline(this); 6027 } 6028 else { 6029 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6030 _errHandler.reportMatch(this); 6031 consume(); 6032 } 6033 } 6034 } 6035 catch (RecognitionException re) { 6036 _localctx.exception = re; 6037 _errHandler.reportError(this, re); 6038 _errHandler.recover(this, re); 6039 } 6040 finally { 6041 exitRule(); 6042 } 6043 return _localctx; 6044 } 6045 6046 public static class FaContext extends ParserRuleContext { 6047 public Fa_unmodContext fa_unmod() { 6048 return getRuleContext(Fa_unmodContext.class,0); 6049 } 6050 public Fa_modContext fa_mod() { 6051 return getRuleContext(Fa_modContext.class,0); 6052 } 6053 public Fa_mod_separatorContext fa_mod_separator() { 6054 return getRuleContext(Fa_mod_separatorContext.class,0); 6055 } 6056 public FaContext(ParserRuleContext parent, int invokingState) { 6057 super(parent, invokingState); 6058 } 6059 @Override public int getRuleIndex() { return RULE_fa; } 6060 @Override 6061 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6062 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa(this); 6063 else return visitor.visitChildren(this); 6064 } 6065 } 6066 6067 public final FaContext fa() throws RecognitionException { 6068 FaContext _localctx = new FaContext(_ctx, getState()); 6069 enterRule(_localctx, 192, RULE_fa); 6070 try { 6071 setState(911); 6072 _errHandler.sync(this); 6073 switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) { 6074 case 1: 6075 enterOuterAlt(_localctx, 1); 6076 { 6077 setState(903); 6078 fa_unmod(); 6079 } 6080 break; 6081 case 2: 6082 enterOuterAlt(_localctx, 2); 6083 { 6084 setState(904); 6085 fa_unmod(); 6086 setState(905); 6087 fa_mod(); 6088 } 6089 break; 6090 case 3: 6091 enterOuterAlt(_localctx, 3); 6092 { 6093 setState(907); 6094 fa_unmod(); 6095 setState(908); 6096 fa_mod_separator(); 6097 setState(909); 6098 fa_mod(); 6099 } 6100 break; 6101 } 6102 } 6103 catch (RecognitionException re) { 6104 _localctx.exception = re; 6105 _errHandler.reportError(this, re); 6106 _errHandler.recover(this, re); 6107 } 6108 finally { 6109 exitRule(); 6110 } 6111 return _localctx; 6112 } 6113 6114 public static class Fa_unmodContext extends ParserRuleContext { 6115 public Round_open_bracketContext round_open_bracket() { 6116 return getRuleContext(Round_open_bracketContext.class,0); 6117 } 6118 public EtherContext ether() { 6119 return getRuleContext(EtherContext.class,0); 6120 } 6121 public Fa_pureContext fa_pure() { 6122 return getRuleContext(Fa_pureContext.class,0); 6123 } 6124 public Round_close_bracketContext round_close_bracket() { 6125 return getRuleContext(Round_close_bracketContext.class,0); 6126 } 6127 public Fa_unmodContext(ParserRuleContext parent, int invokingState) { 6128 super(parent, invokingState); 6129 } 6130 @Override public int getRuleIndex() { return RULE_fa_unmod; } 6131 @Override 6132 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6133 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa_unmod(this); 6134 else return visitor.visitChildren(this); 6135 } 6136 } 6137 6138 public final Fa_unmodContext fa_unmod() throws RecognitionException { 6139 Fa_unmodContext _localctx = new Fa_unmodContext(_ctx, getState()); 6140 enterRule(_localctx, 194, RULE_fa_unmod); 6141 try { 6142 setState(926); 6143 _errHandler.sync(this); 6144 switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { 6145 case 1: 6146 enterOuterAlt(_localctx, 1); 6147 { 6148 setState(913); 6149 round_open_bracket(); 6150 setState(914); 6151 ether(); 6152 setState(915); 6153 fa_pure(); 6154 setState(916); 6155 round_close_bracket(); 6156 } 6157 break; 6158 case 2: 6159 enterOuterAlt(_localctx, 2); 6160 { 6161 setState(918); 6162 round_open_bracket(); 6163 setState(919); 6164 fa_pure(); 6165 setState(920); 6166 round_close_bracket(); 6167 } 6168 break; 6169 case 3: 6170 enterOuterAlt(_localctx, 3); 6171 { 6172 setState(922); 6173 ether(); 6174 setState(923); 6175 fa_pure(); 6176 } 6177 break; 6178 case 4: 6179 enterOuterAlt(_localctx, 4); 6180 { 6181 setState(925); 6182 fa_pure(); 6183 } 6184 break; 6185 } 6186 } 6187 catch (RecognitionException re) { 6188 _localctx.exception = re; 6189 _errHandler.reportError(this, re); 6190 _errHandler.recover(this, re); 6191 } 6192 finally { 6193 exitRule(); 6194 } 6195 return _localctx; 6196 } 6197 6198 public static class Fa_modContext extends ParserRuleContext { 6199 public Round_open_bracketContext round_open_bracket() { 6200 return getRuleContext(Round_open_bracketContext.class,0); 6201 } 6202 public ModificationContext modification() { 6203 return getRuleContext(ModificationContext.class,0); 6204 } 6205 public Round_close_bracketContext round_close_bracket() { 6206 return getRuleContext(Round_close_bracketContext.class,0); 6207 } 6208 public Fa_modContext(ParserRuleContext parent, int invokingState) { 6209 super(parent, invokingState); 6210 } 6211 @Override public int getRuleIndex() { return RULE_fa_mod; } 6212 @Override 6213 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6214 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa_mod(this); 6215 else return visitor.visitChildren(this); 6216 } 6217 } 6218 6219 public final Fa_modContext fa_mod() throws RecognitionException { 6220 Fa_modContext _localctx = new Fa_modContext(_ctx, getState()); 6221 enterRule(_localctx, 196, RULE_fa_mod); 6222 try { 6223 enterOuterAlt(_localctx, 1); 6224 { 6225 setState(928); 6226 round_open_bracket(); 6227 setState(929); 6228 modification(0); 6229 setState(930); 6230 round_close_bracket(); 6231 } 6232 } 6233 catch (RecognitionException re) { 6234 _localctx.exception = re; 6235 _errHandler.reportError(this, re); 6236 _errHandler.recover(this, re); 6237 } 6238 finally { 6239 exitRule(); 6240 } 6241 return _localctx; 6242 } 6243 6244 public static class ModificationContext extends ParserRuleContext { 6245 public NumberContext number() { 6246 return getRuleContext(NumberContext.class,0); 6247 } 6248 public Mod_textContext mod_text() { 6249 return getRuleContext(Mod_textContext.class,0); 6250 } 6251 public List<ModificationContext> modification() { 6252 return getRuleContexts(ModificationContext.class); 6253 } 6254 public ModificationContext modification(int i) { 6255 return getRuleContext(ModificationContext.class,i); 6256 } 6257 public TerminalNode COMMA() { return getToken(LipidMapsParser.COMMA, 0); } 6258 public ModificationContext(ParserRuleContext parent, int invokingState) { 6259 super(parent, invokingState); 6260 } 6261 @Override public int getRuleIndex() { return RULE_modification; } 6262 @Override 6263 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6264 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitModification(this); 6265 else return visitor.visitChildren(this); 6266 } 6267 } 6268 6269 public final ModificationContext modification() throws RecognitionException { 6270 return modification(0); 6271 } 6272 6273 private ModificationContext modification(int _p) throws RecognitionException { 6274 ParserRuleContext _parentctx = _ctx; 6275 int _parentState = getState(); 6276 ModificationContext _localctx = new ModificationContext(_ctx, _parentState); 6277 ModificationContext _prevctx = _localctx; 6278 int _startState = 198; 6279 enterRecursionRule(_localctx, 198, RULE_modification, _p); 6280 try { 6281 int _alt; 6282 enterOuterAlt(_localctx, 1); 6283 { 6284 setState(937); 6285 _errHandler.sync(this); 6286 switch (_input.LA(1)) { 6287 case T__207: 6288 case T__208: 6289 case T__209: 6290 case T__210: 6291 case T__211: 6292 case T__212: 6293 case T__213: 6294 case T__214: 6295 case T__215: 6296 case T__216: 6297 { 6298 setState(933); 6299 number(0); 6300 setState(934); 6301 mod_text(0); 6302 } 6303 break; 6304 case T__2: 6305 case T__135: 6306 case T__177: 6307 case T__178: 6308 case T__179: 6309 case T__180: 6310 case T__181: 6311 case T__182: 6312 case T__183: 6313 case T__184: 6314 case T__185: 6315 case T__186: 6316 case T__187: 6317 case T__188: 6318 case T__189: 6319 case T__190: 6320 case T__191: 6321 case T__192: 6322 case T__193: 6323 case T__194: 6324 case T__195: 6325 case T__196: 6326 case T__197: 6327 case T__198: 6328 case T__199: 6329 case T__200: 6330 case SOB: 6331 { 6332 setState(936); 6333 mod_text(0); 6334 } 6335 break; 6336 default: 6337 throw new NoViableAltException(this); 6338 } 6339 _ctx.stop = _input.LT(-1); 6340 setState(944); 6341 _errHandler.sync(this); 6342 _alt = getInterpreter().adaptivePredict(_input,69,_ctx); 6343 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6344 if ( _alt==1 ) { 6345 if ( _parseListeners!=null ) triggerExitRuleEvent(); 6346 _prevctx = _localctx; 6347 { 6348 { 6349 _localctx = new ModificationContext(_parentctx, _parentState); 6350 pushNewRecursionContext(_localctx, _startState, RULE_modification); 6351 setState(939); 6352 if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); 6353 setState(940); 6354 match(COMMA); 6355 setState(941); 6356 modification(4); 6357 } 6358 } 6359 } 6360 setState(946); 6361 _errHandler.sync(this); 6362 _alt = getInterpreter().adaptivePredict(_input,69,_ctx); 6363 } 6364 } 6365 } 6366 catch (RecognitionException re) { 6367 _localctx.exception = re; 6368 _errHandler.reportError(this, re); 6369 _errHandler.recover(this, re); 6370 } 6371 finally { 6372 unrollRecursionContexts(_parentctx); 6373 } 6374 return _localctx; 6375 } 6376 6377 public static class Mod_textContext extends ParserRuleContext { 6378 public Square_open_bracketContext square_open_bracket() { 6379 return getRuleContext(Square_open_bracketContext.class,0); 6380 } 6381 public List<Mod_textContext> mod_text() { 6382 return getRuleContexts(Mod_textContext.class); 6383 } 6384 public Mod_textContext mod_text(int i) { 6385 return getRuleContext(Mod_textContext.class,i); 6386 } 6387 public Square_close_bracketContext square_close_bracket() { 6388 return getRuleContext(Square_close_bracketContext.class,0); 6389 } 6390 public Mod_textContext(ParserRuleContext parent, int invokingState) { 6391 super(parent, invokingState); 6392 } 6393 @Override public int getRuleIndex() { return RULE_mod_text; } 6394 @Override 6395 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6396 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMod_text(this); 6397 else return visitor.visitChildren(this); 6398 } 6399 } 6400 6401 public final Mod_textContext mod_text() throws RecognitionException { 6402 return mod_text(0); 6403 } 6404 6405 private Mod_textContext mod_text(int _p) throws RecognitionException { 6406 ParserRuleContext _parentctx = _ctx; 6407 int _parentState = getState(); 6408 Mod_textContext _localctx = new Mod_textContext(_ctx, _parentState); 6409 Mod_textContext _prevctx = _localctx; 6410 int _startState = 200; 6411 enterRecursionRule(_localctx, 200, RULE_mod_text, _p); 6412 try { 6413 int _alt; 6414 enterOuterAlt(_localctx, 1); 6415 { 6416 setState(978); 6417 _errHandler.sync(this); 6418 switch (_input.LA(1)) { 6419 case SOB: 6420 { 6421 setState(948); 6422 square_open_bracket(); 6423 setState(949); 6424 mod_text(0); 6425 setState(950); 6426 square_close_bracket(); 6427 } 6428 break; 6429 case T__177: 6430 { 6431 setState(952); 6432 match(T__177); 6433 } 6434 break; 6435 case T__178: 6436 { 6437 setState(953); 6438 match(T__178); 6439 } 6440 break; 6441 case T__135: 6442 { 6443 setState(954); 6444 match(T__135); 6445 } 6446 break; 6447 case T__179: 6448 { 6449 setState(955); 6450 match(T__179); 6451 } 6452 break; 6453 case T__180: 6454 { 6455 setState(956); 6456 match(T__180); 6457 } 6458 break; 6459 case T__181: 6460 { 6461 setState(957); 6462 match(T__181); 6463 } 6464 break; 6465 case T__2: 6466 { 6467 setState(958); 6468 match(T__2); 6469 } 6470 break; 6471 case T__182: 6472 { 6473 setState(959); 6474 match(T__182); 6475 } 6476 break; 6477 case T__183: 6478 { 6479 setState(960); 6480 match(T__183); 6481 } 6482 break; 6483 case T__184: 6484 { 6485 setState(961); 6486 match(T__184); 6487 } 6488 break; 6489 case T__185: 6490 { 6491 setState(962); 6492 match(T__185); 6493 } 6494 break; 6495 case T__186: 6496 { 6497 setState(963); 6498 match(T__186); 6499 } 6500 break; 6501 case T__187: 6502 { 6503 setState(964); 6504 match(T__187); 6505 } 6506 break; 6507 case T__188: 6508 { 6509 setState(965); 6510 match(T__188); 6511 } 6512 break; 6513 case T__189: 6514 { 6515 setState(966); 6516 match(T__189); 6517 } 6518 break; 6519 case T__190: 6520 { 6521 setState(967); 6522 match(T__190); 6523 } 6524 break; 6525 case T__191: 6526 { 6527 setState(968); 6528 match(T__191); 6529 } 6530 break; 6531 case T__192: 6532 { 6533 setState(969); 6534 match(T__192); 6535 } 6536 break; 6537 case T__193: 6538 { 6539 setState(970); 6540 match(T__193); 6541 } 6542 break; 6543 case T__194: 6544 { 6545 setState(971); 6546 match(T__194); 6547 } 6548 break; 6549 case T__195: 6550 { 6551 setState(972); 6552 match(T__195); 6553 } 6554 break; 6555 case T__196: 6556 { 6557 setState(973); 6558 match(T__196); 6559 } 6560 break; 6561 case T__197: 6562 { 6563 setState(974); 6564 match(T__197); 6565 } 6566 break; 6567 case T__198: 6568 { 6569 setState(975); 6570 match(T__198); 6571 } 6572 break; 6573 case T__199: 6574 { 6575 setState(976); 6576 match(T__199); 6577 } 6578 break; 6579 case T__200: 6580 { 6581 setState(977); 6582 match(T__200); 6583 } 6584 break; 6585 default: 6586 throw new NoViableAltException(this); 6587 } 6588 _ctx.stop = _input.LT(-1); 6589 setState(984); 6590 _errHandler.sync(this); 6591 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 6592 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6593 if ( _alt==1 ) { 6594 if ( _parseListeners!=null ) triggerExitRuleEvent(); 6595 _prevctx = _localctx; 6596 { 6597 { 6598 _localctx = new Mod_textContext(_parentctx, _parentState); 6599 pushNewRecursionContext(_localctx, _startState, RULE_mod_text); 6600 setState(980); 6601 if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)"); 6602 setState(981); 6603 mod_text(29); 6604 } 6605 } 6606 } 6607 setState(986); 6608 _errHandler.sync(this); 6609 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 6610 } 6611 } 6612 } 6613 catch (RecognitionException re) { 6614 _localctx.exception = re; 6615 _errHandler.reportError(this, re); 6616 _errHandler.recover(this, re); 6617 } 6618 finally { 6619 unrollRecursionContexts(_parentctx); 6620 } 6621 return _localctx; 6622 } 6623 6624 public static class EtherContext extends ParserRuleContext { 6625 public EtherContext(ParserRuleContext parent, int invokingState) { 6626 super(parent, invokingState); 6627 } 6628 @Override public int getRuleIndex() { return RULE_ether; } 6629 @Override 6630 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6631 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitEther(this); 6632 else return visitor.visitChildren(this); 6633 } 6634 } 6635 6636 public final EtherContext ether() throws RecognitionException { 6637 EtherContext _localctx = new EtherContext(_ctx, getState()); 6638 enterRule(_localctx, 202, RULE_ether); 6639 int _la; 6640 try { 6641 enterOuterAlt(_localctx, 1); 6642 { 6643 setState(987); 6644 _la = _input.LA(1); 6645 if ( !(_la==T__201 || _la==T__202) ) { 6646 _errHandler.recoverInline(this); 6647 } 6648 else { 6649 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6650 _errHandler.reportMatch(this); 6651 consume(); 6652 } 6653 } 6654 } 6655 catch (RecognitionException re) { 6656 _localctx.exception = re; 6657 _errHandler.reportError(this, re); 6658 _errHandler.recover(this, re); 6659 } 6660 finally { 6661 exitRule(); 6662 } 6663 return _localctx; 6664 } 6665 6666 public static class Fa_pureContext extends ParserRuleContext { 6667 public CarbonContext carbon() { 6668 return getRuleContext(CarbonContext.class,0); 6669 } 6670 public Carbon_db_separatorContext carbon_db_separator() { 6671 return getRuleContext(Carbon_db_separatorContext.class,0); 6672 } 6673 public DbContext db() { 6674 return getRuleContext(DbContext.class,0); 6675 } 6676 public Db_hydroxyl_separatorContext db_hydroxyl_separator() { 6677 return getRuleContext(Db_hydroxyl_separatorContext.class,0); 6678 } 6679 public HydroxylContext hydroxyl() { 6680 return getRuleContext(HydroxylContext.class,0); 6681 } 6682 public Fa_pureContext(ParserRuleContext parent, int invokingState) { 6683 super(parent, invokingState); 6684 } 6685 @Override public int getRuleIndex() { return RULE_fa_pure; } 6686 @Override 6687 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6688 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa_pure(this); 6689 else return visitor.visitChildren(this); 6690 } 6691 } 6692 6693 public final Fa_pureContext fa_pure() throws RecognitionException { 6694 Fa_pureContext _localctx = new Fa_pureContext(_ctx, getState()); 6695 enterRule(_localctx, 204, RULE_fa_pure); 6696 try { 6697 setState(999); 6698 _errHandler.sync(this); 6699 switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { 6700 case 1: 6701 enterOuterAlt(_localctx, 1); 6702 { 6703 setState(989); 6704 carbon(); 6705 setState(990); 6706 carbon_db_separator(); 6707 setState(991); 6708 db(); 6709 } 6710 break; 6711 case 2: 6712 enterOuterAlt(_localctx, 2); 6713 { 6714 setState(993); 6715 carbon(); 6716 setState(994); 6717 carbon_db_separator(); 6718 setState(995); 6719 db(); 6720 setState(996); 6721 db_hydroxyl_separator(); 6722 setState(997); 6723 hydroxyl(); 6724 } 6725 break; 6726 } 6727 } 6728 catch (RecognitionException re) { 6729 _localctx.exception = re; 6730 _errHandler.reportError(this, re); 6731 _errHandler.recover(this, re); 6732 } 6733 finally { 6734 exitRule(); 6735 } 6736 return _localctx; 6737 } 6738 6739 public static class Lcb_faContext extends ParserRuleContext { 6740 public Lcb_fa_unmodContext lcb_fa_unmod() { 6741 return getRuleContext(Lcb_fa_unmodContext.class,0); 6742 } 6743 public Lcb_fa_modContext lcb_fa_mod() { 6744 return getRuleContext(Lcb_fa_modContext.class,0); 6745 } 6746 public Lcb_faContext(ParserRuleContext parent, int invokingState) { 6747 super(parent, invokingState); 6748 } 6749 @Override public int getRuleIndex() { return RULE_lcb_fa; } 6750 @Override 6751 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6752 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLcb_fa(this); 6753 else return visitor.visitChildren(this); 6754 } 6755 } 6756 6757 public final Lcb_faContext lcb_fa() throws RecognitionException { 6758 Lcb_faContext _localctx = new Lcb_faContext(_ctx, getState()); 6759 enterRule(_localctx, 206, RULE_lcb_fa); 6760 try { 6761 setState(1005); 6762 _errHandler.sync(this); 6763 switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { 6764 case 1: 6765 enterOuterAlt(_localctx, 1); 6766 { 6767 setState(1001); 6768 lcb_fa_unmod(); 6769 } 6770 break; 6771 case 2: 6772 enterOuterAlt(_localctx, 2); 6773 { 6774 setState(1002); 6775 lcb_fa_unmod(); 6776 setState(1003); 6777 lcb_fa_mod(); 6778 } 6779 break; 6780 } 6781 } 6782 catch (RecognitionException re) { 6783 _localctx.exception = re; 6784 _errHandler.reportError(this, re); 6785 _errHandler.recover(this, re); 6786 } 6787 finally { 6788 exitRule(); 6789 } 6790 return _localctx; 6791 } 6792 6793 public static class Lcb_fa_unmodContext extends ParserRuleContext { 6794 public CarbonContext carbon() { 6795 return getRuleContext(CarbonContext.class,0); 6796 } 6797 public Carbon_db_separatorContext carbon_db_separator() { 6798 return getRuleContext(Carbon_db_separatorContext.class,0); 6799 } 6800 public DbContext db() { 6801 return getRuleContext(DbContext.class,0); 6802 } 6803 public Lcb_fa_unmodContext(ParserRuleContext parent, int invokingState) { 6804 super(parent, invokingState); 6805 } 6806 @Override public int getRuleIndex() { return RULE_lcb_fa_unmod; } 6807 @Override 6808 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6809 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLcb_fa_unmod(this); 6810 else return visitor.visitChildren(this); 6811 } 6812 } 6813 6814 public final Lcb_fa_unmodContext lcb_fa_unmod() throws RecognitionException { 6815 Lcb_fa_unmodContext _localctx = new Lcb_fa_unmodContext(_ctx, getState()); 6816 enterRule(_localctx, 208, RULE_lcb_fa_unmod); 6817 try { 6818 enterOuterAlt(_localctx, 1); 6819 { 6820 setState(1007); 6821 carbon(); 6822 setState(1008); 6823 carbon_db_separator(); 6824 setState(1009); 6825 db(); 6826 } 6827 } 6828 catch (RecognitionException re) { 6829 _localctx.exception = re; 6830 _errHandler.reportError(this, re); 6831 _errHandler.recover(this, re); 6832 } 6833 finally { 6834 exitRule(); 6835 } 6836 return _localctx; 6837 } 6838 6839 public static class Lcb_fa_modContext extends ParserRuleContext { 6840 public Round_open_bracketContext round_open_bracket() { 6841 return getRuleContext(Round_open_bracketContext.class,0); 6842 } 6843 public ModificationContext modification() { 6844 return getRuleContext(ModificationContext.class,0); 6845 } 6846 public Round_close_bracketContext round_close_bracket() { 6847 return getRuleContext(Round_close_bracketContext.class,0); 6848 } 6849 public Lcb_fa_modContext(ParserRuleContext parent, int invokingState) { 6850 super(parent, invokingState); 6851 } 6852 @Override public int getRuleIndex() { return RULE_lcb_fa_mod; } 6853 @Override 6854 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6855 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLcb_fa_mod(this); 6856 else return visitor.visitChildren(this); 6857 } 6858 } 6859 6860 public final Lcb_fa_modContext lcb_fa_mod() throws RecognitionException { 6861 Lcb_fa_modContext _localctx = new Lcb_fa_modContext(_ctx, getState()); 6862 enterRule(_localctx, 210, RULE_lcb_fa_mod); 6863 try { 6864 enterOuterAlt(_localctx, 1); 6865 { 6866 setState(1011); 6867 round_open_bracket(); 6868 setState(1012); 6869 modification(0); 6870 setState(1013); 6871 round_close_bracket(); 6872 } 6873 } 6874 catch (RecognitionException re) { 6875 _localctx.exception = re; 6876 _errHandler.reportError(this, re); 6877 _errHandler.recover(this, re); 6878 } 6879 finally { 6880 exitRule(); 6881 } 6882 return _localctx; 6883 } 6884 6885 public static class LcbContext extends ParserRuleContext { 6886 public Hydroxyl_lcbContext hydroxyl_lcb() { 6887 return getRuleContext(Hydroxyl_lcbContext.class,0); 6888 } 6889 public Lcb_faContext lcb_fa() { 6890 return getRuleContext(Lcb_faContext.class,0); 6891 } 6892 public LcbContext(ParserRuleContext parent, int invokingState) { 6893 super(parent, invokingState); 6894 } 6895 @Override public int getRuleIndex() { return RULE_lcb; } 6896 @Override 6897 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6898 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitLcb(this); 6899 else return visitor.visitChildren(this); 6900 } 6901 } 6902 6903 public final LcbContext lcb() throws RecognitionException { 6904 LcbContext _localctx = new LcbContext(_ctx, getState()); 6905 enterRule(_localctx, 212, RULE_lcb); 6906 try { 6907 setState(1019); 6908 _errHandler.sync(this); 6909 switch (_input.LA(1)) { 6910 case T__3: 6911 case T__205: 6912 case T__206: 6913 enterOuterAlt(_localctx, 1); 6914 { 6915 setState(1015); 6916 hydroxyl_lcb(); 6917 setState(1016); 6918 lcb_fa(); 6919 } 6920 break; 6921 case T__207: 6922 case T__208: 6923 case T__209: 6924 case T__210: 6925 case T__211: 6926 case T__212: 6927 case T__213: 6928 case T__214: 6929 case T__215: 6930 case T__216: 6931 enterOuterAlt(_localctx, 2); 6932 { 6933 setState(1018); 6934 lcb_fa(); 6935 } 6936 break; 6937 default: 6938 throw new NoViableAltException(this); 6939 } 6940 } 6941 catch (RecognitionException re) { 6942 _localctx.exception = re; 6943 _errHandler.reportError(this, re); 6944 _errHandler.recover(this, re); 6945 } 6946 finally { 6947 exitRule(); 6948 } 6949 return _localctx; 6950 } 6951 6952 public static class CarbonContext extends ParserRuleContext { 6953 public NumberContext number() { 6954 return getRuleContext(NumberContext.class,0); 6955 } 6956 public CarbonContext(ParserRuleContext parent, int invokingState) { 6957 super(parent, invokingState); 6958 } 6959 @Override public int getRuleIndex() { return RULE_carbon; } 6960 @Override 6961 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6962 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCarbon(this); 6963 else return visitor.visitChildren(this); 6964 } 6965 } 6966 6967 public final CarbonContext carbon() throws RecognitionException { 6968 CarbonContext _localctx = new CarbonContext(_ctx, getState()); 6969 enterRule(_localctx, 214, RULE_carbon); 6970 try { 6971 enterOuterAlt(_localctx, 1); 6972 { 6973 setState(1021); 6974 number(0); 6975 } 6976 } 6977 catch (RecognitionException re) { 6978 _localctx.exception = re; 6979 _errHandler.reportError(this, re); 6980 _errHandler.recover(this, re); 6981 } 6982 finally { 6983 exitRule(); 6984 } 6985 return _localctx; 6986 } 6987 6988 public static class DbContext extends ParserRuleContext { 6989 public Db_countContext db_count() { 6990 return getRuleContext(Db_countContext.class,0); 6991 } 6992 public Db_positionsContext db_positions() { 6993 return getRuleContext(Db_positionsContext.class,0); 6994 } 6995 public DbContext(ParserRuleContext parent, int invokingState) { 6996 super(parent, invokingState); 6997 } 6998 @Override public int getRuleIndex() { return RULE_db; } 6999 @Override 7000 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7001 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb(this); 7002 else return visitor.visitChildren(this); 7003 } 7004 } 7005 7006 public final DbContext db() throws RecognitionException { 7007 DbContext _localctx = new DbContext(_ctx, getState()); 7008 enterRule(_localctx, 216, RULE_db); 7009 try { 7010 setState(1027); 7011 _errHandler.sync(this); 7012 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 7013 case 1: 7014 enterOuterAlt(_localctx, 1); 7015 { 7016 setState(1023); 7017 db_count(); 7018 } 7019 break; 7020 case 2: 7021 enterOuterAlt(_localctx, 2); 7022 { 7023 setState(1024); 7024 db_count(); 7025 setState(1025); 7026 db_positions(); 7027 } 7028 break; 7029 } 7030 } 7031 catch (RecognitionException re) { 7032 _localctx.exception = re; 7033 _errHandler.reportError(this, re); 7034 _errHandler.recover(this, re); 7035 } 7036 finally { 7037 exitRule(); 7038 } 7039 return _localctx; 7040 } 7041 7042 public static class Db_countContext extends ParserRuleContext { 7043 public NumberContext number() { 7044 return getRuleContext(NumberContext.class,0); 7045 } 7046 public Db_countContext(ParserRuleContext parent, int invokingState) { 7047 super(parent, invokingState); 7048 } 7049 @Override public int getRuleIndex() { return RULE_db_count; } 7050 @Override 7051 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7052 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb_count(this); 7053 else return visitor.visitChildren(this); 7054 } 7055 } 7056 7057 public final Db_countContext db_count() throws RecognitionException { 7058 Db_countContext _localctx = new Db_countContext(_ctx, getState()); 7059 enterRule(_localctx, 218, RULE_db_count); 7060 try { 7061 enterOuterAlt(_localctx, 1); 7062 { 7063 setState(1029); 7064 number(0); 7065 } 7066 } 7067 catch (RecognitionException re) { 7068 _localctx.exception = re; 7069 _errHandler.reportError(this, re); 7070 _errHandler.recover(this, re); 7071 } 7072 finally { 7073 exitRule(); 7074 } 7075 return _localctx; 7076 } 7077 7078 public static class Db_positionsContext extends ParserRuleContext { 7079 public TerminalNode ROB() { return getToken(LipidMapsParser.ROB, 0); } 7080 public Db_positionContext db_position() { 7081 return getRuleContext(Db_positionContext.class,0); 7082 } 7083 public TerminalNode RCB() { return getToken(LipidMapsParser.RCB, 0); } 7084 public Db_positionsContext(ParserRuleContext parent, int invokingState) { 7085 super(parent, invokingState); 7086 } 7087 @Override public int getRuleIndex() { return RULE_db_positions; } 7088 @Override 7089 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7090 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb_positions(this); 7091 else return visitor.visitChildren(this); 7092 } 7093 } 7094 7095 public final Db_positionsContext db_positions() throws RecognitionException { 7096 Db_positionsContext _localctx = new Db_positionsContext(_ctx, getState()); 7097 enterRule(_localctx, 220, RULE_db_positions); 7098 try { 7099 enterOuterAlt(_localctx, 1); 7100 { 7101 setState(1031); 7102 match(ROB); 7103 setState(1032); 7104 db_position(0); 7105 setState(1033); 7106 match(RCB); 7107 } 7108 } 7109 catch (RecognitionException re) { 7110 _localctx.exception = re; 7111 _errHandler.reportError(this, re); 7112 _errHandler.recover(this, re); 7113 } 7114 finally { 7115 exitRule(); 7116 } 7117 return _localctx; 7118 } 7119 7120 public static class Db_positionContext extends ParserRuleContext { 7121 public Db_single_positionContext db_single_position() { 7122 return getRuleContext(Db_single_positionContext.class,0); 7123 } 7124 public List<Db_positionContext> db_position() { 7125 return getRuleContexts(Db_positionContext.class); 7126 } 7127 public Db_positionContext db_position(int i) { 7128 return getRuleContext(Db_positionContext.class,i); 7129 } 7130 public Db_position_separatorContext db_position_separator() { 7131 return getRuleContext(Db_position_separatorContext.class,0); 7132 } 7133 public Db_positionContext(ParserRuleContext parent, int invokingState) { 7134 super(parent, invokingState); 7135 } 7136 @Override public int getRuleIndex() { return RULE_db_position; } 7137 @Override 7138 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7139 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb_position(this); 7140 else return visitor.visitChildren(this); 7141 } 7142 } 7143 7144 public final Db_positionContext db_position() throws RecognitionException { 7145 return db_position(0); 7146 } 7147 7148 private Db_positionContext db_position(int _p) throws RecognitionException { 7149 ParserRuleContext _parentctx = _ctx; 7150 int _parentState = getState(); 7151 Db_positionContext _localctx = new Db_positionContext(_ctx, _parentState); 7152 Db_positionContext _prevctx = _localctx; 7153 int _startState = 222; 7154 enterRecursionRule(_localctx, 222, RULE_db_position, _p); 7155 try { 7156 int _alt; 7157 enterOuterAlt(_localctx, 1); 7158 { 7159 { 7160 setState(1036); 7161 db_single_position(); 7162 } 7163 _ctx.stop = _input.LT(-1); 7164 setState(1044); 7165 _errHandler.sync(this); 7166 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 7167 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7168 if ( _alt==1 ) { 7169 if ( _parseListeners!=null ) triggerExitRuleEvent(); 7170 _prevctx = _localctx; 7171 { 7172 { 7173 _localctx = new Db_positionContext(_parentctx, _parentState); 7174 pushNewRecursionContext(_localctx, _startState, RULE_db_position); 7175 setState(1038); 7176 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); 7177 setState(1039); 7178 db_position_separator(); 7179 setState(1040); 7180 db_position(2); 7181 } 7182 } 7183 } 7184 setState(1046); 7185 _errHandler.sync(this); 7186 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 7187 } 7188 } 7189 } 7190 catch (RecognitionException re) { 7191 _localctx.exception = re; 7192 _errHandler.reportError(this, re); 7193 _errHandler.recover(this, re); 7194 } 7195 finally { 7196 unrollRecursionContexts(_parentctx); 7197 } 7198 return _localctx; 7199 } 7200 7201 public static class Db_single_positionContext extends ParserRuleContext { 7202 public Db_position_numberContext db_position_number() { 7203 return getRuleContext(Db_position_numberContext.class,0); 7204 } 7205 public CistransContext cistrans() { 7206 return getRuleContext(CistransContext.class,0); 7207 } 7208 public Db_single_positionContext(ParserRuleContext parent, int invokingState) { 7209 super(parent, invokingState); 7210 } 7211 @Override public int getRuleIndex() { return RULE_db_single_position; } 7212 @Override 7213 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7214 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb_single_position(this); 7215 else return visitor.visitChildren(this); 7216 } 7217 } 7218 7219 public final Db_single_positionContext db_single_position() throws RecognitionException { 7220 Db_single_positionContext _localctx = new Db_single_positionContext(_ctx, getState()); 7221 enterRule(_localctx, 224, RULE_db_single_position); 7222 try { 7223 setState(1051); 7224 _errHandler.sync(this); 7225 switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { 7226 case 1: 7227 enterOuterAlt(_localctx, 1); 7228 { 7229 setState(1047); 7230 db_position_number(); 7231 } 7232 break; 7233 case 2: 7234 enterOuterAlt(_localctx, 2); 7235 { 7236 setState(1048); 7237 db_position_number(); 7238 setState(1049); 7239 cistrans(); 7240 } 7241 break; 7242 } 7243 } 7244 catch (RecognitionException re) { 7245 _localctx.exception = re; 7246 _errHandler.reportError(this, re); 7247 _errHandler.recover(this, re); 7248 } 7249 finally { 7250 exitRule(); 7251 } 7252 return _localctx; 7253 } 7254 7255 public static class Db_position_numberContext extends ParserRuleContext { 7256 public NumberContext number() { 7257 return getRuleContext(NumberContext.class,0); 7258 } 7259 public Db_position_numberContext(ParserRuleContext parent, int invokingState) { 7260 super(parent, invokingState); 7261 } 7262 @Override public int getRuleIndex() { return RULE_db_position_number; } 7263 @Override 7264 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7265 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb_position_number(this); 7266 else return visitor.visitChildren(this); 7267 } 7268 } 7269 7270 public final Db_position_numberContext db_position_number() throws RecognitionException { 7271 Db_position_numberContext _localctx = new Db_position_numberContext(_ctx, getState()); 7272 enterRule(_localctx, 226, RULE_db_position_number); 7273 try { 7274 enterOuterAlt(_localctx, 1); 7275 { 7276 setState(1053); 7277 number(0); 7278 } 7279 } 7280 catch (RecognitionException re) { 7281 _localctx.exception = re; 7282 _errHandler.reportError(this, re); 7283 _errHandler.recover(this, re); 7284 } 7285 finally { 7286 exitRule(); 7287 } 7288 return _localctx; 7289 } 7290 7291 public static class CistransContext extends ParserRuleContext { 7292 public CistransContext(ParserRuleContext parent, int invokingState) { 7293 super(parent, invokingState); 7294 } 7295 @Override public int getRuleIndex() { return RULE_cistrans; } 7296 @Override 7297 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7298 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCistrans(this); 7299 else return visitor.visitChildren(this); 7300 } 7301 } 7302 7303 public final CistransContext cistrans() throws RecognitionException { 7304 CistransContext _localctx = new CistransContext(_ctx, getState()); 7305 enterRule(_localctx, 228, RULE_cistrans); 7306 int _la; 7307 try { 7308 enterOuterAlt(_localctx, 1); 7309 { 7310 setState(1055); 7311 _la = _input.LA(1); 7312 if ( !(_la==T__203 || _la==T__204) ) { 7313 _errHandler.recoverInline(this); 7314 } 7315 else { 7316 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7317 _errHandler.reportMatch(this); 7318 consume(); 7319 } 7320 } 7321 } 7322 catch (RecognitionException re) { 7323 _localctx.exception = re; 7324 _errHandler.reportError(this, re); 7325 _errHandler.recover(this, re); 7326 } 7327 finally { 7328 exitRule(); 7329 } 7330 return _localctx; 7331 } 7332 7333 public static class HydroxylContext extends ParserRuleContext { 7334 public NumberContext number() { 7335 return getRuleContext(NumberContext.class,0); 7336 } 7337 public HydroxylContext(ParserRuleContext parent, int invokingState) { 7338 super(parent, invokingState); 7339 } 7340 @Override public int getRuleIndex() { return RULE_hydroxyl; } 7341 @Override 7342 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7343 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHydroxyl(this); 7344 else return visitor.visitChildren(this); 7345 } 7346 } 7347 7348 public final HydroxylContext hydroxyl() throws RecognitionException { 7349 HydroxylContext _localctx = new HydroxylContext(_ctx, getState()); 7350 enterRule(_localctx, 230, RULE_hydroxyl); 7351 try { 7352 enterOuterAlt(_localctx, 1); 7353 { 7354 setState(1057); 7355 number(0); 7356 } 7357 } 7358 catch (RecognitionException re) { 7359 _localctx.exception = re; 7360 _errHandler.reportError(this, re); 7361 _errHandler.recover(this, re); 7362 } 7363 finally { 7364 exitRule(); 7365 } 7366 return _localctx; 7367 } 7368 7369 public static class Hydroxyl_lcbContext extends ParserRuleContext { 7370 public Hydroxyl_lcbContext(ParserRuleContext parent, int invokingState) { 7371 super(parent, invokingState); 7372 } 7373 @Override public int getRuleIndex() { return RULE_hydroxyl_lcb; } 7374 @Override 7375 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7376 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHydroxyl_lcb(this); 7377 else return visitor.visitChildren(this); 7378 } 7379 } 7380 7381 public final Hydroxyl_lcbContext hydroxyl_lcb() throws RecognitionException { 7382 Hydroxyl_lcbContext _localctx = new Hydroxyl_lcbContext(_ctx, getState()); 7383 enterRule(_localctx, 232, RULE_hydroxyl_lcb); 7384 int _la; 7385 try { 7386 enterOuterAlt(_localctx, 1); 7387 { 7388 setState(1059); 7389 _la = _input.LA(1); 7390 if ( !(_la==T__3 || _la==T__205 || _la==T__206) ) { 7391 _errHandler.recoverInline(this); 7392 } 7393 else { 7394 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7395 _errHandler.reportMatch(this); 7396 consume(); 7397 } 7398 } 7399 } 7400 catch (RecognitionException re) { 7401 _localctx.exception = re; 7402 _errHandler.reportError(this, re); 7403 _errHandler.recover(this, re); 7404 } 7405 finally { 7406 exitRule(); 7407 } 7408 return _localctx; 7409 } 7410 7411 public static class NumberContext extends ParserRuleContext { 7412 public List<NumberContext> number() { 7413 return getRuleContexts(NumberContext.class); 7414 } 7415 public NumberContext number(int i) { 7416 return getRuleContext(NumberContext.class,i); 7417 } 7418 public NumberContext(ParserRuleContext parent, int invokingState) { 7419 super(parent, invokingState); 7420 } 7421 @Override public int getRuleIndex() { return RULE_number; } 7422 @Override 7423 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7424 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitNumber(this); 7425 else return visitor.visitChildren(this); 7426 } 7427 } 7428 7429 public final NumberContext number() throws RecognitionException { 7430 return number(0); 7431 } 7432 7433 private NumberContext number(int _p) throws RecognitionException { 7434 ParserRuleContext _parentctx = _ctx; 7435 int _parentState = getState(); 7436 NumberContext _localctx = new NumberContext(_ctx, _parentState); 7437 NumberContext _prevctx = _localctx; 7438 int _startState = 234; 7439 enterRecursionRule(_localctx, 234, RULE_number, _p); 7440 try { 7441 int _alt; 7442 enterOuterAlt(_localctx, 1); 7443 { 7444 setState(1072); 7445 _errHandler.sync(this); 7446 switch (_input.LA(1)) { 7447 case T__207: 7448 { 7449 setState(1062); 7450 match(T__207); 7451 } 7452 break; 7453 case T__208: 7454 { 7455 setState(1063); 7456 match(T__208); 7457 } 7458 break; 7459 case T__209: 7460 { 7461 setState(1064); 7462 match(T__209); 7463 } 7464 break; 7465 case T__210: 7466 { 7467 setState(1065); 7468 match(T__210); 7469 } 7470 break; 7471 case T__211: 7472 { 7473 setState(1066); 7474 match(T__211); 7475 } 7476 break; 7477 case T__212: 7478 { 7479 setState(1067); 7480 match(T__212); 7481 } 7482 break; 7483 case T__213: 7484 { 7485 setState(1068); 7486 match(T__213); 7487 } 7488 break; 7489 case T__214: 7490 { 7491 setState(1069); 7492 match(T__214); 7493 } 7494 break; 7495 case T__215: 7496 { 7497 setState(1070); 7498 match(T__215); 7499 } 7500 break; 7501 case T__216: 7502 { 7503 setState(1071); 7504 match(T__216); 7505 } 7506 break; 7507 default: 7508 throw new NoViableAltException(this); 7509 } 7510 _ctx.stop = _input.LT(-1); 7511 setState(1078); 7512 _errHandler.sync(this); 7513 _alt = getInterpreter().adaptivePredict(_input,79,_ctx); 7514 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7515 if ( _alt==1 ) { 7516 if ( _parseListeners!=null ) triggerExitRuleEvent(); 7517 _prevctx = _localctx; 7518 { 7519 { 7520 _localctx = new NumberContext(_parentctx, _parentState); 7521 pushNewRecursionContext(_localctx, _startState, RULE_number); 7522 setState(1074); 7523 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); 7524 setState(1075); 7525 number(2); 7526 } 7527 } 7528 } 7529 setState(1080); 7530 _errHandler.sync(this); 7531 _alt = getInterpreter().adaptivePredict(_input,79,_ctx); 7532 } 7533 } 7534 } 7535 catch (RecognitionException re) { 7536 _localctx.exception = re; 7537 _errHandler.reportError(this, re); 7538 _errHandler.recover(this, re); 7539 } 7540 finally { 7541 unrollRecursionContexts(_parentctx); 7542 } 7543 return _localctx; 7544 } 7545 7546 public static class Fa_separatorContext extends ParserRuleContext { 7547 public TerminalNode UNDERSCORE() { return getToken(LipidMapsParser.UNDERSCORE, 0); } 7548 public TerminalNode SLASH() { return getToken(LipidMapsParser.SLASH, 0); } 7549 public TerminalNode BACKSLASH() { return getToken(LipidMapsParser.BACKSLASH, 0); } 7550 public TerminalNode DASH() { return getToken(LipidMapsParser.DASH, 0); } 7551 public Fa_separatorContext(ParserRuleContext parent, int invokingState) { 7552 super(parent, invokingState); 7553 } 7554 @Override public int getRuleIndex() { return RULE_fa_separator; } 7555 @Override 7556 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7557 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa_separator(this); 7558 else return visitor.visitChildren(this); 7559 } 7560 } 7561 7562 public final Fa_separatorContext fa_separator() throws RecognitionException { 7563 Fa_separatorContext _localctx = new Fa_separatorContext(_ctx, getState()); 7564 enterRule(_localctx, 236, RULE_fa_separator); 7565 int _la; 7566 try { 7567 enterOuterAlt(_localctx, 1); 7568 { 7569 setState(1081); 7570 _la = _input.LA(1); 7571 if ( !(((((_la - 221)) & ~0x3f) == 0 && ((1L << (_la - 221)) & ((1L << (DASH - 221)) | (1L << (UNDERSCORE - 221)) | (1L << (SLASH - 221)) | (1L << (BACKSLASH - 221)))) != 0)) ) { 7572 _errHandler.recoverInline(this); 7573 } 7574 else { 7575 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7576 _errHandler.reportMatch(this); 7577 consume(); 7578 } 7579 } 7580 } 7581 catch (RecognitionException re) { 7582 _localctx.exception = re; 7583 _errHandler.reportError(this, re); 7584 _errHandler.recover(this, re); 7585 } 7586 finally { 7587 exitRule(); 7588 } 7589 return _localctx; 7590 } 7591 7592 public static class Headgroup_separatorContext extends ParserRuleContext { 7593 public TerminalNode SPACE() { return getToken(LipidMapsParser.SPACE, 0); } 7594 public Headgroup_separatorContext(ParserRuleContext parent, int invokingState) { 7595 super(parent, invokingState); 7596 } 7597 @Override public int getRuleIndex() { return RULE_headgroup_separator; } 7598 @Override 7599 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7600 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitHeadgroup_separator(this); 7601 else return visitor.visitChildren(this); 7602 } 7603 } 7604 7605 public final Headgroup_separatorContext headgroup_separator() throws RecognitionException { 7606 Headgroup_separatorContext _localctx = new Headgroup_separatorContext(_ctx, getState()); 7607 enterRule(_localctx, 238, RULE_headgroup_separator); 7608 try { 7609 enterOuterAlt(_localctx, 1); 7610 { 7611 setState(1083); 7612 match(SPACE); 7613 } 7614 } 7615 catch (RecognitionException re) { 7616 _localctx.exception = re; 7617 _errHandler.reportError(this, re); 7618 _errHandler.recover(this, re); 7619 } 7620 finally { 7621 exitRule(); 7622 } 7623 return _localctx; 7624 } 7625 7626 public static class Fa_mod_separatorContext extends ParserRuleContext { 7627 public TerminalNode SPACE() { return getToken(LipidMapsParser.SPACE, 0); } 7628 public Fa_mod_separatorContext(ParserRuleContext parent, int invokingState) { 7629 super(parent, invokingState); 7630 } 7631 @Override public int getRuleIndex() { return RULE_fa_mod_separator; } 7632 @Override 7633 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7634 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitFa_mod_separator(this); 7635 else return visitor.visitChildren(this); 7636 } 7637 } 7638 7639 public final Fa_mod_separatorContext fa_mod_separator() throws RecognitionException { 7640 Fa_mod_separatorContext _localctx = new Fa_mod_separatorContext(_ctx, getState()); 7641 enterRule(_localctx, 240, RULE_fa_mod_separator); 7642 try { 7643 enterOuterAlt(_localctx, 1); 7644 { 7645 setState(1085); 7646 match(SPACE); 7647 } 7648 } 7649 catch (RecognitionException re) { 7650 _localctx.exception = re; 7651 _errHandler.reportError(this, re); 7652 _errHandler.recover(this, re); 7653 } 7654 finally { 7655 exitRule(); 7656 } 7657 return _localctx; 7658 } 7659 7660 public static class Carbon_db_separatorContext extends ParserRuleContext { 7661 public TerminalNode COLON() { return getToken(LipidMapsParser.COLON, 0); } 7662 public Carbon_db_separatorContext(ParserRuleContext parent, int invokingState) { 7663 super(parent, invokingState); 7664 } 7665 @Override public int getRuleIndex() { return RULE_carbon_db_separator; } 7666 @Override 7667 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7668 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitCarbon_db_separator(this); 7669 else return visitor.visitChildren(this); 7670 } 7671 } 7672 7673 public final Carbon_db_separatorContext carbon_db_separator() throws RecognitionException { 7674 Carbon_db_separatorContext _localctx = new Carbon_db_separatorContext(_ctx, getState()); 7675 enterRule(_localctx, 242, RULE_carbon_db_separator); 7676 try { 7677 enterOuterAlt(_localctx, 1); 7678 { 7679 setState(1087); 7680 match(COLON); 7681 } 7682 } 7683 catch (RecognitionException re) { 7684 _localctx.exception = re; 7685 _errHandler.reportError(this, re); 7686 _errHandler.recover(this, re); 7687 } 7688 finally { 7689 exitRule(); 7690 } 7691 return _localctx; 7692 } 7693 7694 public static class Db_hydroxyl_separatorContext extends ParserRuleContext { 7695 public TerminalNode SEMICOLON() { return getToken(LipidMapsParser.SEMICOLON, 0); } 7696 public Db_hydroxyl_separatorContext(ParserRuleContext parent, int invokingState) { 7697 super(parent, invokingState); 7698 } 7699 @Override public int getRuleIndex() { return RULE_db_hydroxyl_separator; } 7700 @Override 7701 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7702 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb_hydroxyl_separator(this); 7703 else return visitor.visitChildren(this); 7704 } 7705 } 7706 7707 public final Db_hydroxyl_separatorContext db_hydroxyl_separator() throws RecognitionException { 7708 Db_hydroxyl_separatorContext _localctx = new Db_hydroxyl_separatorContext(_ctx, getState()); 7709 enterRule(_localctx, 244, RULE_db_hydroxyl_separator); 7710 try { 7711 enterOuterAlt(_localctx, 1); 7712 { 7713 setState(1089); 7714 match(SEMICOLON); 7715 } 7716 } 7717 catch (RecognitionException re) { 7718 _localctx.exception = re; 7719 _errHandler.reportError(this, re); 7720 _errHandler.recover(this, re); 7721 } 7722 finally { 7723 exitRule(); 7724 } 7725 return _localctx; 7726 } 7727 7728 public static class Db_position_separatorContext extends ParserRuleContext { 7729 public TerminalNode COMMA() { return getToken(LipidMapsParser.COMMA, 0); } 7730 public Db_position_separatorContext(ParserRuleContext parent, int invokingState) { 7731 super(parent, invokingState); 7732 } 7733 @Override public int getRuleIndex() { return RULE_db_position_separator; } 7734 @Override 7735 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7736 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitDb_position_separator(this); 7737 else return visitor.visitChildren(this); 7738 } 7739 } 7740 7741 public final Db_position_separatorContext db_position_separator() throws RecognitionException { 7742 Db_position_separatorContext _localctx = new Db_position_separatorContext(_ctx, getState()); 7743 enterRule(_localctx, 246, RULE_db_position_separator); 7744 try { 7745 enterOuterAlt(_localctx, 1); 7746 { 7747 setState(1091); 7748 match(COMMA); 7749 } 7750 } 7751 catch (RecognitionException re) { 7752 _localctx.exception = re; 7753 _errHandler.reportError(this, re); 7754 _errHandler.recover(this, re); 7755 } 7756 finally { 7757 exitRule(); 7758 } 7759 return _localctx; 7760 } 7761 7762 public static class Mediator_separatorContext extends ParserRuleContext { 7763 public TerminalNode COMMA() { return getToken(LipidMapsParser.COMMA, 0); } 7764 public Mediator_separatorContext(ParserRuleContext parent, int invokingState) { 7765 super(parent, invokingState); 7766 } 7767 @Override public int getRuleIndex() { return RULE_mediator_separator; } 7768 @Override 7769 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7770 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_separator(this); 7771 else return visitor.visitChildren(this); 7772 } 7773 } 7774 7775 public final Mediator_separatorContext mediator_separator() throws RecognitionException { 7776 Mediator_separatorContext _localctx = new Mediator_separatorContext(_ctx, getState()); 7777 enterRule(_localctx, 248, RULE_mediator_separator); 7778 try { 7779 enterOuterAlt(_localctx, 1); 7780 { 7781 setState(1093); 7782 match(COMMA); 7783 } 7784 } 7785 catch (RecognitionException re) { 7786 _localctx.exception = re; 7787 _errHandler.reportError(this, re); 7788 _errHandler.recover(this, re); 7789 } 7790 finally { 7791 exitRule(); 7792 } 7793 return _localctx; 7794 } 7795 7796 public static class Mediator_name_separatorContext extends ParserRuleContext { 7797 public TerminalNode DASH() { return getToken(LipidMapsParser.DASH, 0); } 7798 public Mediator_name_separatorContext(ParserRuleContext parent, int invokingState) { 7799 super(parent, invokingState); 7800 } 7801 @Override public int getRuleIndex() { return RULE_mediator_name_separator; } 7802 @Override 7803 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7804 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitMediator_name_separator(this); 7805 else return visitor.visitChildren(this); 7806 } 7807 } 7808 7809 public final Mediator_name_separatorContext mediator_name_separator() throws RecognitionException { 7810 Mediator_name_separatorContext _localctx = new Mediator_name_separatorContext(_ctx, getState()); 7811 enterRule(_localctx, 250, RULE_mediator_name_separator); 7812 try { 7813 enterOuterAlt(_localctx, 1); 7814 { 7815 setState(1095); 7816 match(DASH); 7817 } 7818 } 7819 catch (RecognitionException re) { 7820 _localctx.exception = re; 7821 _errHandler.reportError(this, re); 7822 _errHandler.recover(this, re); 7823 } 7824 finally { 7825 exitRule(); 7826 } 7827 return _localctx; 7828 } 7829 7830 public static class Round_open_bracketContext extends ParserRuleContext { 7831 public TerminalNode ROB() { return getToken(LipidMapsParser.ROB, 0); } 7832 public Round_open_bracketContext(ParserRuleContext parent, int invokingState) { 7833 super(parent, invokingState); 7834 } 7835 @Override public int getRuleIndex() { return RULE_round_open_bracket; } 7836 @Override 7837 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7838 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitRound_open_bracket(this); 7839 else return visitor.visitChildren(this); 7840 } 7841 } 7842 7843 public final Round_open_bracketContext round_open_bracket() throws RecognitionException { 7844 Round_open_bracketContext _localctx = new Round_open_bracketContext(_ctx, getState()); 7845 enterRule(_localctx, 252, RULE_round_open_bracket); 7846 try { 7847 enterOuterAlt(_localctx, 1); 7848 { 7849 setState(1097); 7850 match(ROB); 7851 } 7852 } 7853 catch (RecognitionException re) { 7854 _localctx.exception = re; 7855 _errHandler.reportError(this, re); 7856 _errHandler.recover(this, re); 7857 } 7858 finally { 7859 exitRule(); 7860 } 7861 return _localctx; 7862 } 7863 7864 public static class Round_close_bracketContext extends ParserRuleContext { 7865 public TerminalNode RCB() { return getToken(LipidMapsParser.RCB, 0); } 7866 public Round_close_bracketContext(ParserRuleContext parent, int invokingState) { 7867 super(parent, invokingState); 7868 } 7869 @Override public int getRuleIndex() { return RULE_round_close_bracket; } 7870 @Override 7871 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7872 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitRound_close_bracket(this); 7873 else return visitor.visitChildren(this); 7874 } 7875 } 7876 7877 public final Round_close_bracketContext round_close_bracket() throws RecognitionException { 7878 Round_close_bracketContext _localctx = new Round_close_bracketContext(_ctx, getState()); 7879 enterRule(_localctx, 254, RULE_round_close_bracket); 7880 try { 7881 enterOuterAlt(_localctx, 1); 7882 { 7883 setState(1099); 7884 match(RCB); 7885 } 7886 } 7887 catch (RecognitionException re) { 7888 _localctx.exception = re; 7889 _errHandler.reportError(this, re); 7890 _errHandler.recover(this, re); 7891 } 7892 finally { 7893 exitRule(); 7894 } 7895 return _localctx; 7896 } 7897 7898 public static class Square_open_bracketContext extends ParserRuleContext { 7899 public TerminalNode SOB() { return getToken(LipidMapsParser.SOB, 0); } 7900 public Square_open_bracketContext(ParserRuleContext parent, int invokingState) { 7901 super(parent, invokingState); 7902 } 7903 @Override public int getRuleIndex() { return RULE_square_open_bracket; } 7904 @Override 7905 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7906 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSquare_open_bracket(this); 7907 else return visitor.visitChildren(this); 7908 } 7909 } 7910 7911 public final Square_open_bracketContext square_open_bracket() throws RecognitionException { 7912 Square_open_bracketContext _localctx = new Square_open_bracketContext(_ctx, getState()); 7913 enterRule(_localctx, 256, RULE_square_open_bracket); 7914 try { 7915 enterOuterAlt(_localctx, 1); 7916 { 7917 setState(1101); 7918 match(SOB); 7919 } 7920 } 7921 catch (RecognitionException re) { 7922 _localctx.exception = re; 7923 _errHandler.reportError(this, re); 7924 _errHandler.recover(this, re); 7925 } 7926 finally { 7927 exitRule(); 7928 } 7929 return _localctx; 7930 } 7931 7932 public static class Square_close_bracketContext extends ParserRuleContext { 7933 public TerminalNode SCB() { return getToken(LipidMapsParser.SCB, 0); } 7934 public Square_close_bracketContext(ParserRuleContext parent, int invokingState) { 7935 super(parent, invokingState); 7936 } 7937 @Override public int getRuleIndex() { return RULE_square_close_bracket; } 7938 @Override 7939 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7940 if ( visitor instanceof LipidMapsVisitor ) return ((LipidMapsVisitor<? extends T>)visitor).visitSquare_close_bracket(this); 7941 else return visitor.visitChildren(this); 7942 } 7943 } 7944 7945 public final Square_close_bracketContext square_close_bracket() throws RecognitionException { 7946 Square_close_bracketContext _localctx = new Square_close_bracketContext(_ctx, getState()); 7947 enterRule(_localctx, 258, RULE_square_close_bracket); 7948 try { 7949 enterOuterAlt(_localctx, 1); 7950 { 7951 setState(1103); 7952 match(SCB); 7953 } 7954 } 7955 catch (RecognitionException re) { 7956 _localctx.exception = re; 7957 _errHandler.reportError(this, re); 7958 _errHandler.recover(this, re); 7959 } 7960 finally { 7961 exitRule(); 7962 } 7963 return _localctx; 7964 } 7965 7966 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 7967 switch (ruleIndex) { 7968 case 55: 7969 return pip_pos_sempred((Pip_posContext)_localctx, predIndex); 7970 case 88: 7971 return mediator_prefix_sempred((Mediator_prefixContext)_localctx, predIndex); 7972 case 89: 7973 return mediator_numbers_sempred((Mediator_numbersContext)_localctx, predIndex); 7974 case 99: 7975 return modification_sempred((ModificationContext)_localctx, predIndex); 7976 case 100: 7977 return mod_text_sempred((Mod_textContext)_localctx, predIndex); 7978 case 111: 7979 return db_position_sempred((Db_positionContext)_localctx, predIndex); 7980 case 117: 7981 return number_sempred((NumberContext)_localctx, predIndex); 7982 } 7983 return true; 7984 } 7985 private boolean pip_pos_sempred(Pip_posContext _localctx, int predIndex) { 7986 switch (predIndex) { 7987 case 0: 7988 return precpred(_ctx, 2); 7989 } 7990 return true; 7991 } 7992 private boolean mediator_prefix_sempred(Mediator_prefixContext _localctx, int predIndex) { 7993 switch (predIndex) { 7994 case 1: 7995 return precpred(_ctx, 1); 7996 } 7997 return true; 7998 } 7999 private boolean mediator_numbers_sempred(Mediator_numbersContext _localctx, int predIndex) { 8000 switch (predIndex) { 8001 case 2: 8002 return precpred(_ctx, 3); 8003 } 8004 return true; 8005 } 8006 private boolean modification_sempred(ModificationContext _localctx, int predIndex) { 8007 switch (predIndex) { 8008 case 3: 8009 return precpred(_ctx, 3); 8010 } 8011 return true; 8012 } 8013 private boolean mod_text_sempred(Mod_textContext _localctx, int predIndex) { 8014 switch (predIndex) { 8015 case 4: 8016 return precpred(_ctx, 28); 8017 } 8018 return true; 8019 } 8020 private boolean db_position_sempred(Db_positionContext _localctx, int predIndex) { 8021 switch (predIndex) { 8022 case 5: 8023 return precpred(_ctx, 1); 8024 } 8025 return true; 8026 } 8027 private boolean number_sempred(NumberContext _localctx, int predIndex) { 8028 switch (predIndex) { 8029 case 6: 8030 return precpred(_ctx, 1); 8031 } 8032 return true; 8033 } 8034 8035 public static final String _serializedATN = 8036 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00e7\u0454\4\2\t"+ 8037 "\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"+ 8038 "\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"+ 8039 "\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"+ 8040 "\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!"+ 8041 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 8042 ",\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"+ 8043 "\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="+ 8044 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 8045 "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ 8046 "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ 8047 "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ 8048 "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ 8049 "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ 8050 "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\3\2\3\2\3\2\3\3\3\3\3"+ 8051 "\3\3\3\5\3\u010e\n\3\3\4\3\4\3\4\3\4\5\4\u0114\n\4\3\5\3\5\3\5\3\5\3\5"+ 8052 "\3\5\3\5\5\5\u011d\n\5\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\5\7\u0128\n"+ 8053 "\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b"+ 8054 "\u013a\n\b\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u0142\n\n\3\13\3\13\3\f\3\f\3\f"+ 8055 "\3\f\3\f\3\f\3\f\3\f\3\f\5\f\u014f\n\f\3\r\3\r\3\16\3\16\5\16\u0155\n"+ 8056 "\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u015f\n\17\3\20\3\20"+ 8057 "\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u0169\n\20\3\21\3\21\5\21\u016d\n"+ 8058 "\21\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u017b"+ 8059 "\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23"+ 8060 "\u0189\n\23\3\24\3\24\5\24\u018d\n\24\3\25\3\25\3\25\3\25\3\25\3\25\3"+ 8061 "\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u019f\n\25\3\26"+ 8062 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+ 8063 "\3\26\5\26\u01b1\n\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u01bb"+ 8064 "\n\27\3\30\3\30\3\31\3\31\5\31\u01c1\n\31\3\32\3\32\3\32\3\32\3\32\3\32"+ 8065 "\5\32\u01c9\n\32\3\33\3\33\3\33\3\33\3\33\5\33\u01d0\n\33\3\34\3\34\3"+ 8066 "\34\3\34\3\34\5\34\u01d7\n\34\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u01df"+ 8067 "\n\35\3\36\3\36\3\36\3\36\3\36\5\36\u01e6\n\36\3\37\3\37\3\37\3\37\3\37"+ 8068 "\5\37\u01ed\n\37\3 \3 \3 \3 \5 \u01f3\n \3!\3!\3\"\3\"\3\"\3\"\5\"\u01fb"+ 8069 "\n\"\3#\3#\3$\3$\3$\3$\3$\5$\u0204\n$\3%\3%\3%\3%\3%\3%\3%\3%\5%\u020e"+ 8070 "\n%\3&\3&\5&\u0212\n&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u021a\n\'\3(\3(\3(\3"+ 8071 "(\3(\5(\u0221\n(\3)\3)\3)\3)\3)\5)\u0228\n)\3*\3*\3*\3*\3*\3*\5*\u0230"+ 8072 "\n*\3+\3+\3+\3+\3+\5+\u0237\n+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,"+ 8073 "\3,\3,\3,\3,\3,\3,\3,\3,\5,\u024e\n,\3-\3-\3-\3-\3-\3-\3-\3-\3-\3-\3-"+ 8074 "\3-\3-\3-\3-\3-\5-\u0260\n-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 8075 "\3.\3.\5.\u0272\n.\3/\3/\3/\3/\5/\u0278\n/\3\60\3\60\3\60\3\60\5\60\u027e"+ 8076 "\n\60\3\61\3\61\3\62\3\62\3\62\3\62\5\62\u0286\n\62\3\63\3\63\3\64\3\64"+ 8077 "\3\64\3\64\5\64\u028e\n\64\3\65\3\65\3\66\3\66\3\66\3\66\5\66\u0296\n"+ 8078 "\66\3\67\3\67\38\38\38\38\39\39\39\39\39\39\39\79\u02a5\n9\f9\169\u02a8"+ 8079 "\139\3:\3:\3:\3:\5:\u02ae\n:\3;\3;\3<\3<\3<\5<\u02b5\n<\3=\3=\3=\3=\3"+ 8080 "=\3=\3=\3=\5=\u02bf\n=\3>\3>\3>\3>\3>\3>\5>\u02c7\n>\3?\3?\3?\3?\3?\5"+ 8081 "?\u02ce\n?\3@\3@\3@\3@\3@\5@\u02d5\n@\3A\3A\5A\u02d9\nA\3B\3B\5B\u02dd"+ 8082 "\nB\3C\3C\3C\3C\3C\3C\3C\3C\5C\u02e7\nC\3D\3D\3E\3E\3F\3F\3F\3G\3G\3G"+ 8083 "\3G\5G\u02f4\nG\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H"+ 8084 "\3H\3H\3H\3H\3H\3H\3H\3H\5H\u0310\nH\3I\3I\3I\3J\3J\3J\5J\u0318\nJ\3K"+ 8085 "\3K\3L\3L\3L\3L\5L\u0320\nL\3M\3M\3N\3N\3N\3O\3O\3P\3P\3P\3P\3Q\3Q\5Q"+ 8086 "\u032f\nQ\3R\3R\3R\3R\5R\u0335\nR\3S\3S\3T\3T\3T\3T\3T\5T\u033e\nT\3U"+ 8087 "\3U\3U\3U\3V\3V\3V\3V\3V\3W\3W\3X\3X\5X\u034d\nX\3Y\3Y\3Y\3Y\3Y\3Y\3Y"+ 8088 "\3Y\3Y\5Y\u0358\nY\3Z\3Z\3Z\3Z\3Z\7Z\u035f\nZ\fZ\16Z\u0362\13Z\3[\3[\3"+ 8089 "[\3[\3[\5[\u0369\n[\3[\3[\3[\3[\7[\u036f\n[\f[\16[\u0372\13[\3\\\3\\\3"+ 8090 "\\\3\\\3\\\5\\\u0379\n\\\3]\3]\3^\3^\3^\3^\3^\5^\u0382\n^\3_\3_\3`\3`"+ 8091 "\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\5b\u0392\nb\3c\3c\3c\3c\3c\3c\3c\3c\3c"+ 8092 "\3c\3c\3c\3c\5c\u03a1\nc\3d\3d\3d\3d\3e\3e\3e\3e\3e\5e\u03ac\ne\3e\3e"+ 8093 "\3e\7e\u03b1\ne\fe\16e\u03b4\13e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3"+ 8094 "f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\5f\u03d5\nf\3"+ 8095 "f\3f\7f\u03d9\nf\ff\16f\u03dc\13f\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h"+ 8096 "\5h\u03ea\nh\3i\3i\3i\3i\5i\u03f0\ni\3j\3j\3j\3j\3k\3k\3k\3k\3l\3l\3l"+ 8097 "\3l\5l\u03fe\nl\3m\3m\3n\3n\3n\3n\5n\u0406\nn\3o\3o\3p\3p\3p\3p\3q\3q"+ 8098 "\3q\3q\3q\3q\3q\7q\u0415\nq\fq\16q\u0418\13q\3r\3r\3r\3r\5r\u041e\nr\3"+ 8099 "s\3s\3t\3t\3u\3u\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\5w\u0433\nw\3"+ 8100 "w\3w\7w\u0437\nw\fw\16w\u043a\13w\3x\3x\3y\3y\3z\3z\3{\3{\3|\3|\3}\3}"+ 8101 "\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081\3\u0082\3\u0082\3\u0083"+ 8102 "\3\u0083\3\u0083\2\tp\u00b2\u00b4\u00c8\u00ca\u00e0\u00ec\u0084\2\4\6"+ 8103 "\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRT"+ 8104 "VXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e"+ 8105 "\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6"+ 8106 "\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be"+ 8107 "\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6"+ 8108 "\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee"+ 8109 "\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\2\27"+ 8110 "\3\2\7\13\3\2\f\22\4\2\20\20\23\24\3\2\30\67\3\28F\3\2GH\3\2JL\3\2MO\3"+ 8111 "\2PR\3\2px\3\2y\u0080\3\2\u0081\u0084\3\2\u0086\u0088\4\2\5\5\u008a\u008a"+ 8112 "\3\2\u008b\u0099\3\2\u009a\u00b1\3\2\u00b2\u00b3\3\2\u00cc\u00cd\3\2\u00ce"+ 8113 "\u00cf\4\2\6\6\u00d0\u00d1\3\2\u00df\u00e2\2\u046f\2\u0106\3\2\2\2\4\u010d"+ 8114 "\3\2\2\2\6\u0113\3\2\2\2\b\u011c\3\2\2\2\n\u011e\3\2\2\2\f\u0127\3\2\2"+ 8115 "\2\16\u0139\3\2\2\2\20\u013b\3\2\2\2\22\u0141\3\2\2\2\24\u0143\3\2\2\2"+ 8116 "\26\u014e\3\2\2\2\30\u0150\3\2\2\2\32\u0154\3\2\2\2\34\u015e\3\2\2\2\36"+ 8117 "\u0168\3\2\2\2 \u016c\3\2\2\2\"\u017a\3\2\2\2$\u0188\3\2\2\2&\u018c\3"+ 8118 "\2\2\2(\u019e\3\2\2\2*\u01b0\3\2\2\2,\u01ba\3\2\2\2.\u01bc\3\2\2\2\60"+ 8119 "\u01c0\3\2\2\2\62\u01c8\3\2\2\2\64\u01cf\3\2\2\2\66\u01d6\3\2\2\28\u01de"+ 8120 "\3\2\2\2:\u01e5\3\2\2\2<\u01ec\3\2\2\2>\u01f2\3\2\2\2@\u01f4\3\2\2\2B"+ 8121 "\u01fa\3\2\2\2D\u01fc\3\2\2\2F\u0203\3\2\2\2H\u020d\3\2\2\2J\u0211\3\2"+ 8122 "\2\2L\u0219\3\2\2\2N\u0220\3\2\2\2P\u0227\3\2\2\2R\u022f\3\2\2\2T\u0236"+ 8123 "\3\2\2\2V\u024d\3\2\2\2X\u025f\3\2\2\2Z\u0271\3\2\2\2\\\u0277\3\2\2\2"+ 8124 "^\u027d\3\2\2\2`\u027f\3\2\2\2b\u0285\3\2\2\2d\u0287\3\2\2\2f\u028d\3"+ 8125 "\2\2\2h\u028f\3\2\2\2j\u0295\3\2\2\2l\u0297\3\2\2\2n\u0299\3\2\2\2p\u029d"+ 8126 "\3\2\2\2r\u02ad\3\2\2\2t\u02af\3\2\2\2v\u02b4\3\2\2\2x\u02be\3\2\2\2z"+ 8127 "\u02c6\3\2\2\2|\u02cd\3\2\2\2~\u02d4\3\2\2\2\u0080\u02d8\3\2\2\2\u0082"+ 8128 "\u02dc\3\2\2\2\u0084\u02e6\3\2\2\2\u0086\u02e8\3\2\2\2\u0088\u02ea\3\2"+ 8129 "\2\2\u008a\u02ec\3\2\2\2\u008c\u02f3\3\2\2\2\u008e\u030f\3\2\2\2\u0090"+ 8130 "\u0311\3\2\2\2\u0092\u0317\3\2\2\2\u0094\u0319\3\2\2\2\u0096\u031f\3\2"+ 8131 "\2\2\u0098\u0321\3\2\2\2\u009a\u0323\3\2\2\2\u009c\u0326\3\2\2\2\u009e"+ 8132 "\u0328\3\2\2\2\u00a0\u032e\3\2\2\2\u00a2\u0334\3\2\2\2\u00a4\u0336\3\2"+ 8133 "\2\2\u00a6\u033d\3\2\2\2\u00a8\u033f\3\2\2\2\u00aa\u0343\3\2\2\2\u00ac"+ 8134 "\u0348\3\2\2\2\u00ae\u034c\3\2\2\2\u00b0\u0357\3\2\2\2\u00b2\u0359\3\2"+ 8135 "\2\2\u00b4\u0368\3\2\2\2\u00b6\u0378\3\2\2\2\u00b8\u037a\3\2\2\2\u00ba"+ 8136 "\u0381\3\2\2\2\u00bc\u0383\3\2\2\2\u00be\u0385\3\2\2\2\u00c0\u0387\3\2"+ 8137 "\2\2\u00c2\u0391\3\2\2\2\u00c4\u03a0\3\2\2\2\u00c6\u03a2\3\2\2\2\u00c8"+ 8138 "\u03ab\3\2\2\2\u00ca\u03d4\3\2\2\2\u00cc\u03dd\3\2\2\2\u00ce\u03e9\3\2"+ 8139 "\2\2\u00d0\u03ef\3\2\2\2\u00d2\u03f1\3\2\2\2\u00d4\u03f5\3\2\2\2\u00d6"+ 8140 "\u03fd\3\2\2\2\u00d8\u03ff\3\2\2\2\u00da\u0405\3\2\2\2\u00dc\u0407\3\2"+ 8141 "\2\2\u00de\u0409\3\2\2\2\u00e0\u040d\3\2\2\2\u00e2\u041d\3\2\2\2\u00e4"+ 8142 "\u041f\3\2\2\2\u00e6\u0421\3\2\2\2\u00e8\u0423\3\2\2\2\u00ea\u0425\3\2"+ 8143 "\2\2\u00ec\u0432\3\2\2\2\u00ee\u043b\3\2\2\2\u00f0\u043d\3\2\2\2\u00f2"+ 8144 "\u043f\3\2\2\2\u00f4\u0441\3\2\2\2\u00f6\u0443\3\2\2\2\u00f8\u0445\3\2"+ 8145 "\2\2\u00fa\u0447\3\2\2\2\u00fc\u0449\3\2\2\2\u00fe\u044b\3\2\2\2\u0100"+ 8146 "\u044d\3\2\2\2\u0102\u044f\3\2\2\2\u0104\u0451\3\2\2\2\u0106\u0107\5\4"+ 8147 "\3\2\u0107\u0108\7\2\2\3\u0108\3\3\2\2\2\u0109\u010e\5\6\4\2\u010a\u010b"+ 8148 "\5\6\4\2\u010b\u010c\5\16\b\2\u010c\u010e\3\2\2\2\u010d\u0109\3\2\2\2"+ 8149 "\u010d\u010a\3\2\2\2\u010e\5\3\2\2\2\u010f\u0114\5\b\5\2\u0110\u0111\5"+ 8150 "\b\5\2\u0111\u0112\5\n\6\2\u0112\u0114\3\2\2\2\u0113\u010f\3\2\2\2\u0113"+ 8151 "\u0110\3\2\2\2\u0114\7\3\2\2\2\u0115\u011d\5\22\n\2\u0116\u011d\5\60\31"+ 8152 "\2\u0117\u011d\5F$\2\u0118\u011d\5v<\2\u0119\u011d\5\u009aN\2\u011a\u011d"+ 8153 "\5\u00a0Q\2\u011b\u011d\5\u00aeX\2\u011c\u0115\3\2\2\2\u011c\u0116\3\2"+ 8154 "\2\2\u011c\u0117\3\2\2\2\u011c\u0118\3\2\2\2\u011c\u0119\3\2\2\2\u011c"+ 8155 "\u011a\3\2\2\2\u011c\u011b\3\2\2\2\u011d\t\3\2\2\2\u011e\u011f\5\u0102"+ 8156 "\u0082\2\u011f\u0120\5\f\7\2\u0120\u0121\5\u0104\u0083\2\u0121\13\3\2"+ 8157 "\2\2\u0122\u0128\7\3\2\2\u0123\u0128\7\4\2\2\u0124\u0125\7\4\2\2\u0125"+ 8158 "\u0128\5\u00ecw\2\u0126\u0128\7\5\2\2\u0127\u0122\3\2\2\2\u0127\u0123"+ 8159 "\3\2\2\2\u0127\u0124\3\2\2\2\u0127\u0126\3\2\2\2\u0128\r\3\2\2\2\u0129"+ 8160 "\u012a\7\u00dc\2\2\u012a\u012b\5\u00fe\u0080\2\u012b\u012c\5\20\t\2\u012c"+ 8161 "\u012d\5\u00ecw\2\u012d\u012e\5\u0100\u0081\2\u012e\u013a\3\2\2\2\u012f"+ 8162 "\u0130\7\u00df\2\2\u0130\u0131\5\u00fe\u0080\2\u0131\u0132\5\20\t\2\u0132"+ 8163 "\u0133\5\u00ecw\2\u0133\u0134\5\u0100\u0081\2\u0134\u013a\3\2\2\2\u0135"+ 8164 "\u0136\7\u00df\2\2\u0136\u0137\5\20\t\2\u0137\u0138\5\u00ecw\2\u0138\u013a"+ 8165 "\3\2\2\2\u0139\u0129\3\2\2\2\u0139\u012f\3\2\2\2\u0139\u0135\3\2\2\2\u013a"+ 8166 "\17\3\2\2\2\u013b\u013c\7\6\2\2\u013c\21\3\2\2\2\u013d\u013e\5\30\r\2"+ 8167 "\u013e\u013f\5\26\f\2\u013f\u0142\3\2\2\2\u0140\u0142\5\24\13\2\u0141"+ 8168 "\u013d\3\2\2\2\u0141\u0140\3\2\2\2\u0142\23\3\2\2\2\u0143\u0144\5\u00c2"+ 8169 "b\2\u0144\25\3\2\2\2\u0145\u0146\5\u00fe\u0080\2\u0146\u0147\5\u00c2b"+ 8170 "\2\u0147\u0148\5\u0100\u0081\2\u0148\u014f\3\2\2\2\u0149\u014f\5\u00c2"+ 8171 "b\2\u014a\u014b\5\u00fe\u0080\2\u014b\u014c\5\32\16\2\u014c\u014d\5\u0100"+ 8172 "\u0081\2\u014d\u014f\3\2\2\2\u014e\u0145\3\2\2\2\u014e\u0149\3\2\2\2\u014e"+ 8173 "\u014a\3\2\2\2\u014f\27\3\2\2\2\u0150\u0151\t\2\2\2\u0151\31\3\2\2\2\u0152"+ 8174 "\u0155\5\34\17\2\u0153\u0155\5\36\20\2\u0154\u0152\3\2\2\2\u0154\u0153"+ 8175 "\3\2\2\2\u0155\33\3\2\2\2\u0156\u0157\5\u00c2b\2\u0157\u0158\7\u00df\2"+ 8176 "\2\u0158\u0159\5\u00c2b\2\u0159\u015f\3\2\2\2\u015a\u015b\5\u00c2b\2\u015b"+ 8177 "\u015c\7\u00e0\2\2\u015c\u015d\5\u00c2b\2\u015d\u015f\3\2\2\2\u015e\u0156"+ 8178 "\3\2\2\2\u015e\u015a\3\2\2\2\u015f\35\3\2\2\2\u0160\u0161\5\u00c2b\2\u0161"+ 8179 "\u0162\7\u00e1\2\2\u0162\u0163\5\u00c2b\2\u0163\u0169\3\2\2\2\u0164\u0165"+ 8180 "\5\u00c2b\2\u0165\u0166\7\u00e2\2\2\u0166\u0167\5\u00c2b\2\u0167\u0169"+ 8181 "\3\2\2\2\u0168\u0160\3\2\2\2\u0168\u0164\3\2\2\2\u0169\37\3\2\2\2\u016a"+ 8182 "\u016d\5\"\22\2\u016b\u016d\5$\23\2\u016c\u016a\3\2\2\2\u016c\u016b\3"+ 8183 "\2\2\2\u016d!\3\2\2\2\u016e\u016f\5\u00c2b\2\u016f\u0170\7\u00df\2\2\u0170"+ 8184 "\u0171\5\u00c2b\2\u0171\u0172\7\u00df\2\2\u0172\u0173\5\u00c2b\2\u0173"+ 8185 "\u017b\3\2\2\2\u0174\u0175\5\u00c2b\2\u0175\u0176\7\u00e0\2\2\u0176\u0177"+ 8186 "\5\u00c2b\2\u0177\u0178\7\u00e0\2\2\u0178\u0179\5\u00c2b\2\u0179\u017b"+ 8187 "\3\2\2\2\u017a\u016e\3\2\2\2\u017a\u0174\3\2\2\2\u017b#\3\2\2\2\u017c"+ 8188 "\u017d\5\u00c2b\2\u017d\u017e\7\u00e1\2\2\u017e\u017f\5\u00c2b\2\u017f"+ 8189 "\u0180\7\u00e1\2\2\u0180\u0181\5\u00c2b\2\u0181\u0189\3\2\2\2\u0182\u0183"+ 8190 "\5\u00c2b\2\u0183\u0184\7\u00e2\2\2\u0184\u0185\5\u00c2b\2\u0185\u0186"+ 8191 "\7\u00e2\2\2\u0186\u0187\5\u00c2b\2\u0187\u0189\3\2\2\2\u0188\u017c\3"+ 8192 "\2\2\2\u0188\u0182\3\2\2\2\u0189%\3\2\2\2\u018a\u018d\5(\25\2\u018b\u018d"+ 8193 "\5*\26\2\u018c\u018a\3\2\2\2\u018c\u018b\3\2\2\2\u018d\'\3\2\2\2\u018e"+ 8194 "\u018f\5\u00c2b\2\u018f\u0190\7\u00df\2\2\u0190\u0191\5\u00c2b\2\u0191"+ 8195 "\u0192\7\u00df\2\2\u0192\u0193\5\u00c2b\2\u0193\u0194\7\u00df\2\2\u0194"+ 8196 "\u0195\5\u00c2b\2\u0195\u019f\3\2\2\2\u0196\u0197\5\u00c2b\2\u0197\u0198"+ 8197 "\7\u00e0\2\2\u0198\u0199\5\u00c2b\2\u0199\u019a\7\u00e0\2\2\u019a\u019b"+ 8198 "\5\u00c2b\2\u019b\u019c\7\u00e0\2\2\u019c\u019d\5\u00c2b\2\u019d\u019f"+ 8199 "\3\2\2\2\u019e\u018e\3\2\2\2\u019e\u0196\3\2\2\2\u019f)\3\2\2\2\u01a0"+ 8200 "\u01a1\5\u00c2b\2\u01a1\u01a2\7\u00e1\2\2\u01a2\u01a3\5\u00c2b\2\u01a3"+ 8201 "\u01a4\7\u00e1\2\2\u01a4\u01a5\5\u00c2b\2\u01a5\u01a6\7\u00e1\2\2\u01a6"+ 8202 "\u01a7\5\u00c2b\2\u01a7\u01b1\3\2\2\2\u01a8\u01a9\5\u00c2b\2\u01a9\u01aa"+ 8203 "\7\u00e2\2\2\u01aa\u01ab\5\u00c2b\2\u01ab\u01ac\7\u00e2\2\2\u01ac\u01ad"+ 8204 "\5\u00c2b\2\u01ad\u01ae\7\u00e2\2\2\u01ae\u01af\5\u00c2b\2\u01af\u01b1"+ 8205 "\3\2\2\2\u01b0\u01a0\3\2\2\2\u01b0\u01a8\3\2\2\2\u01b1+\3\2\2\2\u01b2"+ 8206 "\u01b3\5\u00d6l\2\u01b3\u01b4\7\u00e1\2\2\u01b4\u01b5\5\u00c2b\2\u01b5"+ 8207 "\u01bb\3\2\2\2\u01b6\u01b7\5\u00d6l\2\u01b7\u01b8\7\u00e2\2\2\u01b8\u01b9"+ 8208 "\5\u00c2b\2\u01b9\u01bb\3\2\2\2\u01ba\u01b2\3\2\2\2\u01ba\u01b6\3\2\2"+ 8209 "\2\u01bb-\3\2\2\2\u01bc\u01bd\5\u00c2b\2\u01bd/\3\2\2\2\u01be\u01c1\5"+ 8210 "\62\32\2\u01bf\u01c1\58\35\2\u01c0\u01be\3\2\2\2\u01c0\u01bf\3\2\2\2\u01c1"+ 8211 "\61\3\2\2\2\u01c2\u01c3\5> \2\u01c3\u01c4\5\64\33\2\u01c4\u01c9\3\2\2"+ 8212 "\2\u01c5\u01c6\5> \2\u01c6\u01c7\5\66\34\2\u01c7\u01c9\3\2\2\2\u01c8\u01c2"+ 8213 "\3\2\2\2\u01c8\u01c5\3\2\2\2\u01c9\63\3\2\2\2\u01ca\u01cb\5\u00fe\u0080"+ 8214 "\2\u01cb\u01cc\5\u00c2b\2\u01cc\u01cd\5\u0100\u0081\2\u01cd\u01d0\3\2"+ 8215 "\2\2\u01ce\u01d0\5\u00c2b\2\u01cf\u01ca\3\2\2\2\u01cf\u01ce\3\2\2\2\u01d0"+ 8216 "\65\3\2\2\2\u01d1\u01d2\5\u00fe\u0080\2\u01d2\u01d3\5\32\16\2\u01d3\u01d4"+ 8217 "\5\u0100\u0081\2\u01d4\u01d7\3\2\2\2\u01d5\u01d7\5\32\16\2\u01d6\u01d1"+ 8218 "\3\2\2\2\u01d6\u01d5\3\2\2\2\u01d7\67\3\2\2\2\u01d8\u01d9\5B\"\2\u01d9"+ 8219 "\u01da\5:\36\2\u01da\u01df\3\2\2\2\u01db\u01dc\5B\"\2\u01dc\u01dd\5<\37"+ 8220 "\2\u01dd\u01df\3\2\2\2\u01de\u01d8\3\2\2\2\u01de\u01db\3\2\2\2\u01df9"+ 8221 "\3\2\2\2\u01e0\u01e1\5\u00fe\u0080\2\u01e1\u01e2\5\u00c2b\2\u01e2\u01e3"+ 8222 "\5\u0100\u0081\2\u01e3\u01e6\3\2\2\2\u01e4\u01e6\5\u00c2b\2\u01e5\u01e0"+ 8223 "\3\2\2\2\u01e5\u01e4\3\2\2\2\u01e6;\3\2\2\2\u01e7\u01e8\5\u00fe\u0080"+ 8224 "\2\u01e8\u01e9\5 \21\2\u01e9\u01ea\5\u0100\u0081\2\u01ea\u01ed\3\2\2\2"+ 8225 "\u01eb\u01ed\5 \21\2\u01ec\u01e7\3\2\2\2\u01ec\u01eb\3\2\2\2\u01ed=\3"+ 8226 "\2\2\2\u01ee\u01f3\5@!\2\u01ef\u01f0\5@!\2\u01f0\u01f1\5\u00f0y\2\u01f1"+ 8227 "\u01f3\3\2\2\2\u01f2\u01ee\3\2\2\2\u01f2\u01ef\3\2\2\2\u01f3?\3\2\2\2"+ 8228 "\u01f4\u01f5\t\3\2\2\u01f5A\3\2\2\2\u01f6\u01fb\5D#\2\u01f7\u01f8\5D#"+ 8229 "\2\u01f8\u01f9\5\u00f0y\2\u01f9\u01fb\3\2\2\2\u01fa\u01f6\3\2\2\2\u01fa"+ 8230 "\u01f7\3\2\2\2\u01fbC\3\2\2\2\u01fc\u01fd\t\4\2\2\u01fdE\3\2\2\2\u01fe"+ 8231 "\u0204\5H%\2\u01ff\u0204\5L\'\2\u0200\u0204\5R*\2\u0201\u0204\5X-\2\u0202"+ 8232 "\u0204\5Z.\2\u0203\u01fe\3\2\2\2\u0203\u01ff\3\2\2\2\u0203\u0200\3\2\2"+ 8233 "\2\u0203\u0201\3\2\2\2\u0203\u0202\3\2\2\2\u0204G\3\2\2\2\u0205\u0206"+ 8234 "\5f\64\2\u0206\u0207\5\u00fe\u0080\2\u0207\u0208\5J&\2\u0208\u0209\5\u0100"+ 8235 "\u0081\2\u0209\u020e\3\2\2\2\u020a\u020b\5f\64\2\u020b\u020c\5J&\2\u020c"+ 8236 "\u020e\3\2\2\2\u020d\u0205\3\2\2\2\u020d\u020a\3\2\2\2\u020eI\3\2\2\2"+ 8237 "\u020f\u0212\5\u00c2b\2\u0210\u0212\5\32\16\2\u0211\u020f\3\2\2\2\u0211"+ 8238 "\u0210\3\2\2\2\u0212K\3\2\2\2\u0213\u0214\5\\/\2\u0214\u0215\5N(\2\u0215"+ 8239 "\u021a\3\2\2\2\u0216\u0217\5\\/\2\u0217\u0218\5P)\2\u0218\u021a\3\2\2"+ 8240 "\2\u0219\u0213\3\2\2\2\u0219\u0216\3\2\2\2\u021aM\3\2\2\2\u021b\u021c"+ 8241 "\5\u00fe\u0080\2\u021c\u021d\5\u00c2b\2\u021d\u021e\5\u0100\u0081\2\u021e"+ 8242 "\u0221\3\2\2\2\u021f\u0221\5\u00c2b\2\u0220\u021b\3\2\2\2\u0220\u021f"+ 8243 "\3\2\2\2\u0221O\3\2\2\2\u0222\u0223\5\u00fe\u0080\2\u0223\u0224\5\32\16"+ 8244 "\2\u0224\u0225\5\u0100\u0081\2\u0225\u0228\3\2\2\2\u0226\u0228\5\32\16"+ 8245 "\2\u0227\u0222\3\2\2\2\u0227\u0226\3\2\2\2\u0228Q\3\2\2\2\u0229\u022a"+ 8246 "\5^\60\2\u022a\u022b\5T+\2\u022b\u0230\3\2\2\2\u022c\u022d\5^\60\2\u022d"+ 8247 "\u022e\5V,\2\u022e\u0230\3\2\2\2\u022f\u0229\3\2\2\2\u022f\u022c\3\2\2"+ 8248 "\2\u0230S\3\2\2\2\u0231\u0232\5\u00fe\u0080\2\u0232\u0233\5\u00c2b\2\u0233"+ 8249 "\u0234\5\u0100\u0081\2\u0234\u0237\3\2\2\2\u0235\u0237\5\u00c2b\2\u0236"+ 8250 "\u0231\3\2\2\2\u0236\u0235\3\2\2\2\u0237U\3\2\2\2\u0238\u0239\5\u00fe"+ 8251 "\u0080\2\u0239\u023a\7\25\2\2\u023a\u023b\5\u0102\u0082\2\u023b\u023c"+ 8252 "\5\32\16\2\u023c\u023d\5\u0104\u0083\2\u023d\u023e\7\26\2\2\u023e\u023f"+ 8253 "\5\u0102\u0082\2\u023f\u0240\5\32\16\2\u0240\u0241\5\u0104\u0083\2\u0241"+ 8254 "\u0242\5\u0100\u0081\2\u0242\u024e\3\2\2\2\u0243\u0244\5^\60\2\u0244\u0245"+ 8255 "\7\25\2\2\u0245\u0246\5\u0102\u0082\2\u0246\u0247\5\32\16\2\u0247\u0248"+ 8256 "\5\u0104\u0083\2\u0248\u0249\7\26\2\2\u0249\u024a\5\u0102\u0082\2\u024a"+ 8257 "\u024b\5\32\16\2\u024b\u024c\5\u0104\u0083\2\u024c\u024e\3\2\2\2\u024d"+ 8258 "\u0238\3\2\2\2\u024d\u0243\3\2\2\2\u024eW\3\2\2\2\u024f\u0250\5j\66\2"+ 8259 "\u0250\u0251\5\u00fe\u0080\2\u0251\u0252\5&\24\2\u0252\u0253\5\u0100\u0081"+ 8260 "\2\u0253\u0260\3\2\2\2\u0254\u0255\5j\66\2\u0255\u0256\5&\24\2\u0256\u0260"+ 8261 "\3\2\2\2\u0257\u0258\5j\66\2\u0258\u0259\5\u00fe\u0080\2\u0259\u025a\5"+ 8262 ".\30\2\u025a\u025b\5\u0100\u0081\2\u025b\u0260\3\2\2\2\u025c\u025d\5j"+ 8263 "\66\2\u025d\u025e\5.\30\2\u025e\u0260\3\2\2\2\u025f\u024f\3\2\2\2\u025f"+ 8264 "\u0254\3\2\2\2\u025f\u0257\3\2\2\2\u025f\u025c\3\2\2\2\u0260Y\3\2\2\2"+ 8265 "\u0261\u0262\5r:\2\u0262\u0263\5\u00fe\u0080\2\u0263\u0264\5 \21\2\u0264"+ 8266 "\u0265\5\u0100\u0081\2\u0265\u0272\3\2\2\2\u0266\u0267\5r:\2\u0267\u0268"+ 8267 "\5 \21\2\u0268\u0272\3\2\2\2\u0269\u026a\5r:\2\u026a\u026b\5\u00fe\u0080"+ 8268 "\2\u026b\u026c\5.\30\2\u026c\u026d\5\u0100\u0081\2\u026d\u0272\3\2\2\2"+ 8269 "\u026e\u026f\5r:\2\u026f\u0270\5.\30\2\u0270\u0272\3\2\2\2\u0271\u0261"+ 8270 "\3\2\2\2\u0271\u0266\3\2\2\2\u0271\u0269\3\2\2\2\u0271\u026e\3\2\2\2\u0272"+ 8271 "[\3\2\2\2\u0273\u0274\5b\62\2\u0274\u0275\5n8\2\u0275\u0278\3\2\2\2\u0276"+ 8272 "\u0278\5b\62\2\u0277\u0273\3\2\2\2\u0277\u0276\3\2\2\2\u0278]\3\2\2\2"+ 8273 "\u0279\u027e\5`\61\2\u027a\u027b\5`\61\2\u027b\u027c\5\u00f0y\2\u027c"+ 8274 "\u027e\3\2\2\2\u027d\u0279\3\2\2\2\u027d\u027a\3\2\2\2\u027e_\3\2\2\2"+ 8275 "\u027f\u0280\7\27\2\2\u0280a\3\2\2\2\u0281\u0286\5d\63\2\u0282\u0283\5"+ 8276 "d\63\2\u0283\u0284\5\u00f0y\2\u0284\u0286\3\2\2\2\u0285\u0281\3\2\2\2"+ 8277 "\u0285\u0282\3\2\2\2\u0286c\3\2\2\2\u0287\u0288\t\5\2\2\u0288e\3\2\2\2"+ 8278 "\u0289\u028e\5h\65\2\u028a\u028b\5h\65\2\u028b\u028c\5\u00f0y\2\u028c"+ 8279 "\u028e\3\2\2\2\u028d\u0289\3\2\2\2\u028d\u028a\3\2\2\2\u028eg\3\2\2\2"+ 8280 "\u028f\u0290\t\6\2\2\u0290i\3\2\2\2\u0291\u0296\5l\67\2\u0292\u0293\5"+ 8281 "l\67\2\u0293\u0294\5\u00f0y\2\u0294\u0296\3\2\2\2\u0295\u0291\3\2\2\2"+ 8282 "\u0295\u0292\3\2\2\2\u0296k\3\2\2\2\u0297\u0298\t\7\2\2\u0298m\3\2\2\2"+ 8283 "\u0299\u029a\5\u0102\u0082\2\u029a\u029b\5p9\2\u029b\u029c\5\u0104\u0083"+ 8284 "\2\u029co\3\2\2\2\u029d\u029e\b9\1\2\u029e\u029f\5\u00ecw\2\u029f\u02a0"+ 8285 "\7I\2\2\u02a0\u02a6\3\2\2\2\u02a1\u02a2\f\4\2\2\u02a2\u02a3\7\u00e3\2"+ 8286 "\2\u02a3\u02a5\5p9\5\u02a4\u02a1\3\2\2\2\u02a5\u02a8\3\2\2\2\u02a6\u02a4"+ 8287 "\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7q\3\2\2\2\u02a8\u02a6\3\2\2\2\u02a9"+ 8288 "\u02ae\5t;\2\u02aa\u02ab\5t;\2\u02ab\u02ac\5\u00f0y\2\u02ac\u02ae\3\2"+ 8289 "\2\2\u02ad\u02a9\3\2\2\2\u02ad\u02aa\3\2\2\2\u02aes\3\2\2\2\u02af\u02b0"+ 8290 "\t\b\2\2\u02b0u\3\2\2\2\u02b1\u02b5\5x=\2\u02b2\u02b5\5z>\2\u02b3\u02b5"+ 8291 "\5\u0080A\2\u02b4\u02b1\3\2\2\2\u02b4\u02b2\3\2\2\2\u02b4\u02b3\3\2\2"+ 8292 "\2\u02b5w\3\2\2\2\u02b6\u02b7\5\u0096L\2\u02b7\u02b8\5\u00fe\u0080\2\u02b8"+ 8293 "\u02b9\5\u00d6l\2\u02b9\u02ba\5\u0100\u0081\2\u02ba\u02bf\3\2\2\2\u02bb"+ 8294 "\u02bc\5\u0096L\2\u02bc\u02bd\5\u00d6l\2\u02bd\u02bf\3\2\2\2\u02be\u02b6"+ 8295 "\3\2\2\2\u02be\u02bb\3\2\2\2\u02bfy\3\2\2\2\u02c0\u02c1\5\u008cG\2\u02c1"+ 8296 "\u02c2\5|?\2\u02c2\u02c7\3\2\2\2\u02c3\u02c4\5\u008cG\2\u02c4\u02c5\5"+ 8297 "~@\2\u02c5\u02c7\3\2\2\2\u02c6\u02c0\3\2\2\2\u02c6\u02c3\3\2\2\2\u02c7"+ 8298 "{\3\2\2\2\u02c8\u02c9\5\u00fe\u0080\2\u02c9\u02ca\5\u00d6l\2\u02ca\u02cb"+ 8299 "\5\u0100\u0081\2\u02cb\u02ce\3\2\2\2\u02cc\u02ce\5\u00d6l\2\u02cd\u02c8"+ 8300 "\3\2\2\2\u02cd\u02cc\3\2\2\2\u02ce}\3\2\2\2\u02cf\u02d0\5\u00fe\u0080"+ 8301 "\2\u02d0\u02d1\5,\27\2\u02d1\u02d2\5\u0100\u0081\2\u02d2\u02d5\3\2\2\2"+ 8302 "\u02d3\u02d5\5,\27\2\u02d4\u02cf\3\2\2\2\u02d4\u02d3\3\2\2\2\u02d5\177"+ 8303 "\3\2\2\2\u02d6\u02d9\5\u0082B\2\u02d7\u02d9\5\u0084C\2\u02d8\u02d6\3\2"+ 8304 "\2\2\u02d8\u02d7\3\2\2\2\u02d9\u0081\3\2\2\2\u02da\u02dd\5\u0086D\2\u02db"+ 8305 "\u02dd\5\u0088E\2\u02dc\u02da\3\2\2\2\u02dc\u02db\3\2\2\2\u02dd\u0083"+ 8306 "\3\2\2\2\u02de\u02df\5\u008aF\2\u02df\u02e0\5\u00f0y\2\u02e0\u02e1\5\u0086"+ 8307 "D\2\u02e1\u02e7\3\2\2\2\u02e2\u02e3\5\u008aF\2\u02e3\u02e4\5\u00f0y\2"+ 8308 "\u02e4\u02e5\5\u0088E\2\u02e5\u02e7\3\2\2\2\u02e6\u02de\3\2\2\2\u02e6"+ 8309 "\u02e2\3\2\2\2\u02e7\u0085\3\2\2\2\u02e8\u02e9\t\t\2\2\u02e9\u0087\3\2"+ 8310 "\2\2\u02ea\u02eb\t\n\2\2\u02eb\u0089\3\2\2\2\u02ec\u02ed\7S\2\2\u02ed"+ 8311 "\u02ee\5\u00ecw\2\u02ee\u008b\3\2\2\2\u02ef\u02f4\5\u008eH\2\u02f0\u02f1"+ 8312 "\5\u008eH\2\u02f1\u02f2\5\u00f0y\2\u02f2\u02f4\3\2\2\2\u02f3\u02ef\3\2"+ 8313 "\2\2\u02f3\u02f0\3\2\2\2\u02f4\u008d\3\2\2\2\u02f5\u0310\7T\2\2\u02f6"+ 8314 "\u0310\7U\2\2\u02f7\u0310\7V\2\2\u02f8\u0310\7W\2\2\u02f9\u0310\7X\2\2"+ 8315 "\u02fa\u0310\7Y\2\2\u02fb\u0310\7Z\2\2\u02fc\u0310\7[\2\2\u02fd\u0310"+ 8316 "\7\\\2\2\u02fe\u0310\7]\2\2\u02ff\u0310\7^\2\2\u0300\u0310\7_\2\2\u0301"+ 8317 "\u0310\7`\2\2\u0302\u0310\7a\2\2\u0303\u0310\7b\2\2\u0304\u0310\7c\2\2"+ 8318 "\u0305\u0310\7d\2\2\u0306\u0310\7e\2\2\u0307\u0310\7f\2\2\u0308\u0310"+ 8319 "\7g\2\2\u0309\u0310\7h\2\2\u030a\u0310\7i\2\2\u030b\u0310\7j\2\2\u030c"+ 8320 "\u0310\7k\2\2\u030d\u0310\7l\2\2\u030e\u0310\5\u0090I\2\u030f\u02f5\3"+ 8321 "\2\2\2\u030f\u02f6\3\2\2\2\u030f\u02f7\3\2\2\2\u030f\u02f8\3\2\2\2\u030f"+ 8322 "\u02f9\3\2\2\2\u030f\u02fa\3\2\2\2\u030f\u02fb\3\2\2\2\u030f\u02fc\3\2"+ 8323 "\2\2\u030f\u02fd\3\2\2\2\u030f\u02fe\3\2\2\2\u030f\u02ff\3\2\2\2\u030f"+ 8324 "\u0300\3\2\2\2\u030f\u0301\3\2\2\2\u030f\u0302\3\2\2\2\u030f\u0303\3\2"+ 8325 "\2\2\u030f\u0304\3\2\2\2\u030f\u0305\3\2\2\2\u030f\u0306\3\2\2\2\u030f"+ 8326 "\u0307\3\2\2\2\u030f\u0308\3\2\2\2\u030f\u0309\3\2\2\2\u030f\u030a\3\2"+ 8327 "\2\2\u030f\u030b\3\2\2\2\u030f\u030c\3\2\2\2\u030f\u030d\3\2\2\2\u030f"+ 8328 "\u030e\3\2\2\2\u0310\u008f\3\2\2\2\u0311\u0312\5\u0092J\2\u0312\u0313"+ 8329 "\7m\2\2\u0313\u0091\3\2\2\2\u0314\u0315\7n\2\2\u0315\u0318\5\u0094K\2"+ 8330 "\u0316\u0318\7o\2\2\u0317\u0314\3\2\2\2\u0317\u0316\3\2\2\2\u0318\u0093"+ 8331 "\3\2\2\2\u0319\u031a\t\13\2\2\u031a\u0095\3\2\2\2\u031b\u0320\5\u0098"+ 8332 "M\2\u031c\u031d\5\u0098M\2\u031d\u031e\5\u00f0y\2\u031e\u0320\3\2\2\2"+ 8333 "\u031f\u031b\3\2\2\2\u031f\u031c\3\2\2\2\u0320\u0097\3\2\2\2\u0321\u0322"+ 8334 "\t\f\2\2\u0322\u0099\3\2\2\2\u0323\u0324\5\u009cO\2\u0324\u0325\5\u009e"+ 8335 "P\2\u0325\u009b\3\2\2\2\u0326\u0327\t\r\2\2\u0327\u009d\3\2\2\2\u0328"+ 8336 "\u0329\5\u00fe\u0080\2\u0329\u032a\5\u00c2b\2\u032a\u032b\5\u0100\u0081"+ 8337 "\2\u032b\u009f\3\2\2\2\u032c\u032f\5\u00a2R\2\u032d\u032f\5\u00a6T\2\u032e"+ 8338 "\u032c\3\2\2\2\u032e\u032d\3\2\2\2\u032f\u00a1\3\2\2\2\u0330\u0335\5\u00a4"+ 8339 "S\2\u0331\u0332\5\u00a4S\2\u0332\u0333\5\u00f0y\2\u0333\u0335\3\2\2\2"+ 8340 "\u0334\u0330\3\2\2\2\u0334\u0331\3\2\2\2\u0335\u00a3\3\2\2\2\u0336\u0337"+ 8341 "\7\u0085\2\2\u0337\u00a5\3\2\2\2\u0338\u033e\5\u00a8U\2\u0339\u033a\5"+ 8342 "\u00a8U\2\u033a\u033b\5\u00f0y\2\u033b\u033e\3\2\2\2\u033c\u033e\5\u00aa"+ 8343 "V\2\u033d\u0338\3\2\2\2\u033d\u0339\3\2\2\2\u033d\u033c\3\2\2\2\u033e"+ 8344 "\u00a7\3\2\2\2\u033f\u0340\5\u00c2b\2\u0340\u0341\5\u00f0y\2\u0341\u0342"+ 8345 "\5\u00acW\2\u0342\u00a9\3\2\2\2\u0343\u0344\5\u00acW\2\u0344\u0345\5\u00fe"+ 8346 "\u0080\2\u0345\u0346\5\u00c2b\2\u0346\u0347\5\u0100\u0081\2\u0347\u00ab"+ 8347 "\3\2\2\2\u0348\u0349\t\16\2\2\u0349\u00ad\3\2\2\2\u034a\u034d\5\u00b0"+ 8348 "Y\2\u034b\u034d\5\u00be`\2\u034c\u034a\3\2\2\2\u034c\u034b\3\2\2\2\u034d"+ 8349 "\u00af\3\2\2\2\u034e\u034f\5\u00b2Z\2\u034f\u0350\5\u00fc\177\2\u0350"+ 8350 "\u0351\5\u00ba^\2\u0351\u0358\3\2\2\2\u0352\u0353\7\u0089\2\2\u0353\u0354"+ 8351 "\5\u00b2Z\2\u0354\u0355\5\u00fc\177\2\u0355\u0356\5\u00ba^\2\u0356\u0358"+ 8352 "\3\2\2\2\u0357\u034e\3\2\2\2\u0357\u0352\3\2\2\2\u0358\u00b1\3\2\2\2\u0359"+ 8353 "\u035a\bZ\1\2\u035a\u035b\5\u00b4[\2\u035b\u0360\3\2\2\2\u035c\u035d\f"+ 8354 "\3\2\2\u035d\u035f\5\u00b2Z\4\u035e\u035c\3\2\2\2\u035f\u0362\3\2\2\2"+ 8355 "\u0360\u035e\3\2\2\2\u0360\u0361\3\2\2\2\u0361\u00b3\3\2\2\2\u0362\u0360"+ 8356 "\3\2\2\2\u0363\u0364\b[\1\2\u0364\u0369\5\u00b6\\\2\u0365\u0366\5\u00b6"+ 8357 "\\\2\u0366\u0367\5\u00b8]\2\u0367\u0369\3\2\2\2\u0368\u0363\3\2\2\2\u0368"+ 8358 "\u0365\3\2\2\2\u0369\u0370\3\2\2\2\u036a\u036b\f\5\2\2\u036b\u036c\5\u00fa"+ 8359 "~\2\u036c\u036d\5\u00b4[\6\u036d\u036f\3\2\2\2\u036e\u036a\3\2\2\2\u036f"+ 8360 "\u0372\3\2\2\2\u0370\u036e\3\2\2\2\u0370\u0371\3\2\2\2\u0371\u00b5\3\2"+ 8361 "\2\2\u0372\u0370\3\2\2\2\u0373\u0379\5\u00ecw\2\u0374\u0375\5\u00fe\u0080"+ 8362 "\2\u0375\u0376\5\u00ecw\2\u0376\u0377\5\u0100\u0081\2\u0377\u0379\3\2"+ 8363 "\2\2\u0378\u0373\3\2\2\2\u0378\u0374\3\2\2\2\u0379\u00b7\3\2\2\2\u037a"+ 8364 "\u037b\t\17\2\2\u037b\u00b9\3\2\2\2\u037c\u0382\5\u00bc_\2\u037d\u037e"+ 8365 "\5\u00c0a\2\u037e\u037f\7\u00df\2\2\u037f\u0380\5\u00bc_\2\u0380\u0382"+ 8366 "\3\2\2\2\u0381\u037c\3\2\2\2\u0381\u037d\3\2\2\2\u0382\u00bb\3\2\2\2\u0383"+ 8367 "\u0384\t\20\2\2\u0384\u00bd\3\2\2\2\u0385\u0386\t\21\2\2\u0386\u00bf\3"+ 8368 "\2\2\2\u0387\u0388\t\22\2\2\u0388\u00c1\3\2\2\2\u0389\u0392\5\u00c4c\2"+ 8369 "\u038a\u038b\5\u00c4c\2\u038b\u038c\5\u00c6d\2\u038c\u0392\3\2\2\2\u038d"+ 8370 "\u038e\5\u00c4c\2\u038e\u038f\5\u00f2z\2\u038f\u0390\5\u00c6d\2\u0390"+ 8371 "\u0392\3\2\2\2\u0391\u0389\3\2\2\2\u0391\u038a\3\2\2\2\u0391\u038d\3\2"+ 8372 "\2\2\u0392\u00c3\3\2\2\2\u0393\u0394\5\u00fe\u0080\2\u0394\u0395\5\u00cc"+ 8373 "g\2\u0395\u0396\5\u00ceh\2\u0396\u0397\5\u0100\u0081\2\u0397\u03a1\3\2"+ 8374 "\2\2\u0398\u0399\5\u00fe\u0080\2\u0399\u039a\5\u00ceh\2\u039a\u039b\5"+ 8375 "\u0100\u0081\2\u039b\u03a1\3\2\2\2\u039c\u039d\5\u00ccg\2\u039d\u039e"+ 8376 "\5\u00ceh\2\u039e\u03a1\3\2\2\2\u039f\u03a1\5\u00ceh\2\u03a0\u0393\3\2"+ 8377 "\2\2\u03a0\u0398\3\2\2\2\u03a0\u039c\3\2\2\2\u03a0\u039f\3\2\2\2\u03a1"+ 8378 "\u00c5\3\2\2\2\u03a2\u03a3\5\u00fe\u0080\2\u03a3\u03a4\5\u00c8e\2\u03a4"+ 8379 "\u03a5\5\u0100\u0081\2\u03a5\u00c7\3\2\2\2\u03a6\u03a7\be\1\2\u03a7\u03a8"+ 8380 "\5\u00ecw\2\u03a8\u03a9\5\u00caf\2\u03a9\u03ac\3\2\2\2\u03aa\u03ac\5\u00ca"+ 8381 "f\2\u03ab\u03a6\3\2\2\2\u03ab\u03aa\3\2\2\2\u03ac\u03b2\3\2\2\2\u03ad"+ 8382 "\u03ae\f\5\2\2\u03ae\u03af\7\u00e3\2\2\u03af\u03b1\5\u00c8e\6\u03b0\u03ad"+ 8383 "\3\2\2\2\u03b1\u03b4\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3"+ 8384 "\u00c9\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b5\u03b6\bf\1\2\u03b6\u03b7\5\u0102"+ 8385 "\u0082\2\u03b7\u03b8\5\u00caf\2\u03b8\u03b9\5\u0104\u0083\2\u03b9\u03d5"+ 8386 "\3\2\2\2\u03ba\u03d5\7\u00b4\2\2\u03bb\u03d5\7\u00b5\2\2\u03bc\u03d5\7"+ 8387 "\u008a\2\2\u03bd\u03d5\7\u00b6\2\2\u03be\u03d5\7\u00b7\2\2\u03bf\u03d5"+ 8388 "\7\u00b8\2\2\u03c0\u03d5\7\5\2\2\u03c1\u03d5\7\u00b9\2\2\u03c2\u03d5\7"+ 8389 "\u00ba\2\2\u03c3\u03d5\7\u00bb\2\2\u03c4\u03d5\7\u00bc\2\2\u03c5\u03d5"+ 8390 "\7\u00bd\2\2\u03c6\u03d5\7\u00be\2\2\u03c7\u03d5\7\u00bf\2\2\u03c8\u03d5"+ 8391 "\7\u00c0\2\2\u03c9\u03d5\7\u00c1\2\2\u03ca\u03d5\7\u00c2\2\2\u03cb\u03d5"+ 8392 "\7\u00c3\2\2\u03cc\u03d5\7\u00c4\2\2\u03cd\u03d5\7\u00c5\2\2\u03ce\u03d5"+ 8393 "\7\u00c6\2\2\u03cf\u03d5\7\u00c7\2\2\u03d0\u03d5\7\u00c8\2\2\u03d1\u03d5"+ 8394 "\7\u00c9\2\2\u03d2\u03d5\7\u00ca\2\2\u03d3\u03d5\7\u00cb\2\2\u03d4\u03b5"+ 8395 "\3\2\2\2\u03d4\u03ba\3\2\2\2\u03d4\u03bb\3\2\2\2\u03d4\u03bc\3\2\2\2\u03d4"+ 8396 "\u03bd\3\2\2\2\u03d4\u03be\3\2\2\2\u03d4\u03bf\3\2\2\2\u03d4\u03c0\3\2"+ 8397 "\2\2\u03d4\u03c1\3\2\2\2\u03d4\u03c2\3\2\2\2\u03d4\u03c3\3\2\2\2\u03d4"+ 8398 "\u03c4\3\2\2\2\u03d4\u03c5\3\2\2\2\u03d4\u03c6\3\2\2\2\u03d4\u03c7\3\2"+ 8399 "\2\2\u03d4\u03c8\3\2\2\2\u03d4\u03c9\3\2\2\2\u03d4\u03ca\3\2\2\2\u03d4"+ 8400 "\u03cb\3\2\2\2\u03d4\u03cc\3\2\2\2\u03d4\u03cd\3\2\2\2\u03d4\u03ce\3\2"+ 8401 "\2\2\u03d4\u03cf\3\2\2\2\u03d4\u03d0\3\2\2\2\u03d4\u03d1\3\2\2\2\u03d4"+ 8402 "\u03d2\3\2\2\2\u03d4\u03d3\3\2\2\2\u03d5\u03da\3\2\2\2\u03d6\u03d7\f\36"+ 8403 "\2\2\u03d7\u03d9\5\u00caf\37\u03d8\u03d6\3\2\2\2\u03d9\u03dc\3\2\2\2\u03da"+ 8404 "\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u00cb\3\2\2\2\u03dc\u03da\3\2"+ 8405 "\2\2\u03dd\u03de\t\23\2\2\u03de\u00cd\3\2\2\2\u03df\u03e0\5\u00d8m\2\u03e0"+ 8406 "\u03e1\5\u00f4{\2\u03e1\u03e2\5\u00dan\2\u03e2\u03ea\3\2\2\2\u03e3\u03e4"+ 8407 "\5\u00d8m\2\u03e4\u03e5\5\u00f4{\2\u03e5\u03e6\5\u00dan\2\u03e6\u03e7"+ 8408 "\5\u00f6|\2\u03e7\u03e8\5\u00e8u\2\u03e8\u03ea\3\2\2\2\u03e9\u03df\3\2"+ 8409 "\2\2\u03e9\u03e3\3\2\2\2\u03ea\u00cf\3\2\2\2\u03eb\u03f0\5\u00d2j\2\u03ec"+ 8410 "\u03ed\5\u00d2j\2\u03ed\u03ee\5\u00d4k\2\u03ee\u03f0\3\2\2\2\u03ef\u03eb"+ 8411 "\3\2\2\2\u03ef\u03ec\3\2\2\2\u03f0\u00d1\3\2\2\2\u03f1\u03f2\5\u00d8m"+ 8412 "\2\u03f2\u03f3\5\u00f4{\2\u03f3\u03f4\5\u00dan\2\u03f4\u00d3\3\2\2\2\u03f5"+ 8413 "\u03f6\5\u00fe\u0080\2\u03f6\u03f7\5\u00c8e\2\u03f7\u03f8\5\u0100\u0081"+ 8414 "\2\u03f8\u00d5\3\2\2\2\u03f9\u03fa\5\u00eav\2\u03fa\u03fb\5\u00d0i\2\u03fb"+ 8415 "\u03fe\3\2\2\2\u03fc\u03fe\5\u00d0i\2\u03fd\u03f9\3\2\2\2\u03fd\u03fc"+ 8416 "\3\2\2\2\u03fe\u00d7\3\2\2\2\u03ff\u0400\5\u00ecw\2\u0400\u00d9\3\2\2"+ 8417 "\2\u0401\u0406\5\u00dco\2\u0402\u0403\5\u00dco\2\u0403\u0404\5\u00dep"+ 8418 "\2\u0404\u0406\3\2\2\2\u0405\u0401\3\2\2\2\u0405\u0402\3\2\2\2\u0406\u00db"+ 8419 "\3\2\2\2\u0407\u0408\5\u00ecw\2\u0408\u00dd\3\2\2\2\u0409\u040a\7\u00e4"+ 8420 "\2\2\u040a\u040b\5\u00e0q\2\u040b\u040c\7\u00e5\2\2\u040c\u00df\3\2\2"+ 8421 "\2\u040d\u040e\bq\1\2\u040e\u040f\5\u00e2r\2\u040f\u0416\3\2\2\2\u0410"+ 8422 "\u0411\f\3\2\2\u0411\u0412\5\u00f8}\2\u0412\u0413\5\u00e0q\4\u0413\u0415"+ 8423 "\3\2\2\2\u0414\u0410\3\2\2\2\u0415\u0418\3\2\2\2\u0416\u0414\3\2\2\2\u0416"+ 8424 "\u0417\3\2\2\2\u0417\u00e1\3\2\2\2\u0418\u0416\3\2\2\2\u0419\u041e\5\u00e4"+ 8425 "s\2\u041a\u041b\5\u00e4s\2\u041b\u041c\5\u00e6t\2\u041c\u041e\3\2\2\2"+ 8426 "\u041d\u0419\3\2\2\2\u041d\u041a\3\2\2\2\u041e\u00e3\3\2\2\2\u041f\u0420"+ 8427 "\5\u00ecw\2\u0420\u00e5\3\2\2\2\u0421\u0422\t\24\2\2\u0422\u00e7\3\2\2"+ 8428 "\2\u0423\u0424\5\u00ecw\2\u0424\u00e9\3\2\2\2\u0425\u0426\t\25\2\2\u0426"+ 8429 "\u00eb\3\2\2\2\u0427\u0428\bw\1\2\u0428\u0433\7\u00d2\2\2\u0429\u0433"+ 8430 "\7\u00d3\2\2\u042a\u0433\7\u00d4\2\2\u042b\u0433\7\u00d5\2\2\u042c\u0433"+ 8431 "\7\u00d6\2\2\u042d\u0433\7\u00d7\2\2\u042e\u0433\7\u00d8\2\2\u042f\u0433"+ 8432 "\7\u00d9\2\2\u0430\u0433\7\u00da\2\2\u0431\u0433\7\u00db\2\2\u0432\u0427"+ 8433 "\3\2\2\2\u0432\u0429\3\2\2\2\u0432\u042a\3\2\2\2\u0432\u042b\3\2\2\2\u0432"+ 8434 "\u042c\3\2\2\2\u0432\u042d\3\2\2\2\u0432\u042e\3\2\2\2\u0432\u042f\3\2"+ 8435 "\2\2\u0432\u0430\3\2\2\2\u0432\u0431\3\2\2\2\u0433\u0438\3\2\2\2\u0434"+ 8436 "\u0435\f\3\2\2\u0435\u0437\5\u00ecw\4\u0436\u0434\3\2\2\2\u0437\u043a"+ 8437 "\3\2\2\2\u0438\u0436\3\2\2\2\u0438\u0439\3\2\2\2\u0439\u00ed\3\2\2\2\u043a"+ 8438 "\u0438\3\2\2\2\u043b\u043c\t\26\2\2\u043c\u00ef\3\2\2\2\u043d\u043e\7"+ 8439 "\u00dc\2\2\u043e\u00f1\3\2\2\2\u043f\u0440\7\u00dc\2\2\u0440\u00f3\3\2"+ 8440 "\2\2\u0441\u0442\7\u00dd\2\2\u0442\u00f5\3\2\2\2\u0443\u0444\7\u00de\2"+ 8441 "\2\u0444\u00f7\3\2\2\2\u0445\u0446\7\u00e3\2\2\u0446\u00f9\3\2\2\2\u0447"+ 8442 "\u0448\7\u00e3\2\2\u0448\u00fb\3\2\2\2\u0449\u044a\7\u00df\2\2\u044a\u00fd"+ 8443 "\3\2\2\2\u044b\u044c\7\u00e4\2\2\u044c\u00ff\3\2\2\2\u044d\u044e\7\u00e5"+ 8444 "\2\2\u044e\u0101\3\2\2\2\u044f\u0450\7\u00e6\2\2\u0450\u0103\3\2\2\2\u0451"+ 8445 "\u0452\7\u00e7\2\2\u0452\u0105\3\2\2\2R\u010d\u0113\u011c\u0127\u0139"+ 8446 "\u0141\u014e\u0154\u015e\u0168\u016c\u017a\u0188\u018c\u019e\u01b0\u01ba"+ 8447 "\u01c0\u01c8\u01cf\u01d6\u01de\u01e5\u01ec\u01f2\u01fa\u0203\u020d\u0211"+ 8448 "\u0219\u0220\u0227\u022f\u0236\u024d\u025f\u0271\u0277\u027d\u0285\u028d"+ 8449 "\u0295\u02a6\u02ad\u02b4\u02be\u02c6\u02cd\u02d4\u02d8\u02dc\u02e6\u02f3"+ 8450 "\u030f\u0317\u031f\u032e\u0334\u033d\u034c\u0357\u0360\u0368\u0370\u0378"+ 8451 "\u0381\u0391\u03a0\u03ab\u03b2\u03d4\u03da\u03e9\u03ef\u03fd\u0405\u0416"+ 8452 "\u041d\u0432\u0438"; 8453 public static final ATN _ATN = 8454 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 8455 static { 8456 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 8457 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 8458 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 8459 } 8460 } 8461}