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