Source code

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