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