GCC Code Coverage Report
Directory: . Exec Total Coverage
File: build-coverage/src/parser/tptp/TptpLexer.c Lines: 1415 1837 77.0 %
Date: 2021-03-23 Branches: 521 941 55.4 %

Line Exec Source
1
/** \file
2
 *  This C source file was generated by $ANTLR version 3.4
3
 *
4
 *     -  From the grammar source file : /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g
5
 *     -                            On : 2021-03-23 01:05:33
6
 *     -                 for the lexer : TptpLexerLexer
7
 *
8
 * Editing it, at least manually, is not wise.
9
 *
10
 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
11
 *
12
 *
13
*/
14
// [The "BSD license"]
15
// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
16
// http://www.temporal-wave.com
17
// http://www.linkedin.com/in/jimidle
18
//
19
// All rights reserved.
20
//
21
// Redistribution and use in source and binary forms, with or without
22
// modification, are permitted provided that the following conditions
23
// are met:
24
// 1. Redistributions of source code must retain the above copyright
25
//    notice, this list of conditions and the following disclaimer.
26
// 2. Redistributions in binary form must reproduce the above copyright
27
//    notice, this list of conditions and the following disclaimer in the
28
//    documentation and/or other materials provided with the distribution.
29
// 3. The name of the author may not be used to endorse or promote products
30
//    derived from this software without specific prior written permission.
31
//
32
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
33
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
34
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
35
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
36
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
37
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
38
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
39
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
41
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42
43
/* -----------------------------------------
44
 * Include the ANTLR3 generated header file.
45
 */
46
#include    "TptpLexer.h"
47
48
49
#include "parser/tptp/tptp.h"
50
#include "parser/antlr_input.h"
51
52
using namespace CVC4;
53
using namespace CVC4::parser;
54
55
/* These need to be macros so they can refer to the PARSER macro, which will be defined
56
 * by ANTLR *after* this section. (If they were functions, PARSER would be undefined.) */
57
#undef PARSER_STATE
58
#define PARSER_STATE ((Tptp*)LEXER->super)
59
#undef SOLVER
60
#define SOLVER PARSER_STATE->getSolver()
61
#undef MK_TERM
62
#define MK_TERM SOLVER->mkTerm
63
#undef MK_TERM
64
#define MK_TERM SOLVER->mkTerm
65
#define UNSUPPORTED PARSER_STATE->unimplementedFeature
66
67
68
/* ----------------------------------------- */
69
70
71
/** String literals used by TptpLexer that we must do things like MATCHS() with.
72
 *  C will normally just lay down 8 bit characters, and you can use L"xxx" to
73
 *  get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
74
 *  we perform this little trick of defining the literals as arrays of UINT32
75
 *  and passing in the address of these.
76
 */
77
static ANTLR3_UCHAR	lit_1[]  = { 0x24, 0x63, 0x65, 0x69, 0x6C, 0x69, 0x6E, 0x67,  ANTLR3_STRING_TERMINATOR};
78
static ANTLR3_UCHAR	lit_2[]  = { 0x24, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6E, 0x63, 0x65,  ANTLR3_STRING_TERMINATOR};
79
static ANTLR3_UCHAR	lit_3[]  = { 0x24, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6E, 0x63, 0x74,  ANTLR3_STRING_TERMINATOR};
80
static ANTLR3_UCHAR	lit_4[]  = { 0x24, 0x66, 0x6C, 0x6F, 0x6F, 0x72,  ANTLR3_STRING_TERMINATOR};
81
static ANTLR3_UCHAR	lit_5[]  = { 0x24, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72,  ANTLR3_STRING_TERMINATOR};
82
static ANTLR3_UCHAR	lit_6[]  = { 0x24, 0x67, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x65, 0x71,  ANTLR3_STRING_TERMINATOR};
83
static ANTLR3_UCHAR	lit_7[]  = { 0x24, 0x69, 0x73, 0x5F, 0x69, 0x6E, 0x74,  ANTLR3_STRING_TERMINATOR};
84
static ANTLR3_UCHAR	lit_8[]  = { 0x24, 0x69, 0x73, 0x5F, 0x72, 0x61, 0x74,  ANTLR3_STRING_TERMINATOR};
85
static ANTLR3_UCHAR	lit_9[]  = { 0x24, 0x69, 0x74, 0x65, 0x5F, 0x66,  ANTLR3_STRING_TERMINATOR};
86
static ANTLR3_UCHAR	lit_10[]  = { 0x24, 0x69, 0x74, 0x65, 0x5F, 0x74,  ANTLR3_STRING_TERMINATOR};
87
static ANTLR3_UCHAR	lit_11[]  = { 0x24, 0x6C, 0x65, 0x73, 0x73,  ANTLR3_STRING_TERMINATOR};
88
static ANTLR3_UCHAR	lit_12[]  = { 0x24, 0x6C, 0x65, 0x73, 0x73, 0x65, 0x71,  ANTLR3_STRING_TERMINATOR};
89
static ANTLR3_UCHAR	lit_13[]  = { 0x24, 0x6C, 0x65, 0x74, 0x5F, 0x66, 0x66,  ANTLR3_STRING_TERMINATOR};
90
static ANTLR3_UCHAR	lit_14[]  = { 0x24, 0x6C, 0x65, 0x74, 0x5F, 0x66, 0x74,  ANTLR3_STRING_TERMINATOR};
91
static ANTLR3_UCHAR	lit_15[]  = { 0x24, 0x6C, 0x65, 0x74, 0x5F, 0x74, 0x66,  ANTLR3_STRING_TERMINATOR};
92
static ANTLR3_UCHAR	lit_16[]  = { 0x24, 0x6C, 0x65, 0x74, 0x5F, 0x74, 0x74,  ANTLR3_STRING_TERMINATOR};
93
static ANTLR3_UCHAR	lit_17[]  = { 0x24, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 0x74,  ANTLR3_STRING_TERMINATOR};
94
static ANTLR3_UCHAR	lit_18[]  = { 0x24, 0x71, 0x75, 0x6F, 0x74, 0x69, 0x65, 0x6E, 0x74,  ANTLR3_STRING_TERMINATOR};
95
static ANTLR3_UCHAR	lit_19[]  = { 0x24, 0x71, 0x75, 0x6F, 0x74, 0x69, 0x65, 0x6E, 0x74, 0x5F, 0x65,  ANTLR3_STRING_TERMINATOR};
96
static ANTLR3_UCHAR	lit_20[]  = { 0x24, 0x71, 0x75, 0x6F, 0x74, 0x69, 0x65, 0x6E, 0x74, 0x5F, 0x66,  ANTLR3_STRING_TERMINATOR};
97
static ANTLR3_UCHAR	lit_21[]  = { 0x24, 0x71, 0x75, 0x6F, 0x74, 0x69, 0x65, 0x6E, 0x74, 0x5F, 0x74,  ANTLR3_STRING_TERMINATOR};
98
static ANTLR3_UCHAR	lit_22[]  = { 0x24, 0x72, 0x65, 0x6D, 0x61, 0x69, 0x6E, 0x64, 0x65, 0x72, 0x5F, 0x65,  ANTLR3_STRING_TERMINATOR};
99
static ANTLR3_UCHAR	lit_23[]  = { 0x24, 0x72, 0x65, 0x6D, 0x61, 0x69, 0x6E, 0x64, 0x65, 0x72, 0x5F, 0x66,  ANTLR3_STRING_TERMINATOR};
100
static ANTLR3_UCHAR	lit_24[]  = { 0x24, 0x72, 0x65, 0x6D, 0x61, 0x69, 0x6E, 0x64, 0x65, 0x72, 0x5F, 0x74,  ANTLR3_STRING_TERMINATOR};
101
static ANTLR3_UCHAR	lit_25[]  = { 0x24, 0x72, 0x6F, 0x75, 0x6E, 0x64,  ANTLR3_STRING_TERMINATOR};
102
static ANTLR3_UCHAR	lit_26[]  = { 0x24, 0x73, 0x75, 0x6D,  ANTLR3_STRING_TERMINATOR};
103
static ANTLR3_UCHAR	lit_27[]  = { 0x24, 0x74, 0x54, 0x79, 0x70, 0x65,  ANTLR3_STRING_TERMINATOR};
104
static ANTLR3_UCHAR	lit_28[]  = { 0x24, 0x74, 0x6F, 0x5F, 0x69, 0x6E, 0x74,  ANTLR3_STRING_TERMINATOR};
105
static ANTLR3_UCHAR	lit_29[]  = { 0x24, 0x74, 0x6F, 0x5F, 0x72, 0x61, 0x74,  ANTLR3_STRING_TERMINATOR};
106
static ANTLR3_UCHAR	lit_30[]  = { 0x24, 0x74, 0x6F, 0x5F, 0x72, 0x65, 0x61, 0x6C,  ANTLR3_STRING_TERMINATOR};
107
static ANTLR3_UCHAR	lit_31[]  = { 0x24, 0x74, 0x72, 0x75, 0x6E, 0x63, 0x61, 0x74, 0x65,  ANTLR3_STRING_TERMINATOR};
108
static ANTLR3_UCHAR	lit_32[]  = { 0x24, 0x75, 0x6D, 0x69, 0x6E, 0x75, 0x73,  ANTLR3_STRING_TERMINATOR};
109
static ANTLR3_UCHAR	lit_33[]  = { 0x3E, 0x3E,  ANTLR3_STRING_TERMINATOR};
110
static ANTLR3_UCHAR	lit_34[]  = { 0x40, 0x2B,  ANTLR3_STRING_TERMINATOR};
111
static ANTLR3_UCHAR	lit_35[]  = { 0x40, 0x2D,  ANTLR3_STRING_TERMINATOR};
112
static ANTLR3_UCHAR	lit_36[]  = { 0x3C, 0x3D, 0x3E,  ANTLR3_STRING_TERMINATOR};
113
static ANTLR3_UCHAR	lit_37[]  = { 0x3D, 0x3E,  ANTLR3_STRING_TERMINATOR};
114
static ANTLR3_UCHAR	lit_38[]  = { 0x3C, 0x3D,  ANTLR3_STRING_TERMINATOR};
115
static ANTLR3_UCHAR	lit_39[]  = { 0x3C, 0x7E, 0x3E,  ANTLR3_STRING_TERMINATOR};
116
static ANTLR3_UCHAR	lit_40[]  = { 0x7E, 0x7C,  ANTLR3_STRING_TERMINATOR};
117
static ANTLR3_UCHAR	lit_41[]  = { 0x7E, 0x26,  ANTLR3_STRING_TERMINATOR};
118
static ANTLR3_UCHAR	lit_42[]  = { 0x21, 0x21,  ANTLR3_STRING_TERMINATOR};
119
static ANTLR3_UCHAR	lit_43[]  = { 0x3F, 0x3F,  ANTLR3_STRING_TERMINATOR};
120
static ANTLR3_UCHAR	lit_44[]  = { 0x24, 0x74, 0x72, 0x75, 0x65,  ANTLR3_STRING_TERMINATOR};
121
static ANTLR3_UCHAR	lit_45[]  = { 0x24, 0x66, 0x61, 0x6C, 0x73, 0x65,  ANTLR3_STRING_TERMINATOR};
122
static ANTLR3_UCHAR	lit_46[]  = { 0x21, 0x3D,  ANTLR3_STRING_TERMINATOR};
123
static ANTLR3_UCHAR	lit_47[]  = { 0x63, 0x6E, 0x66,  ANTLR3_STRING_TERMINATOR};
124
static ANTLR3_UCHAR	lit_48[]  = { 0x66, 0x6F, 0x66,  ANTLR3_STRING_TERMINATOR};
125
static ANTLR3_UCHAR	lit_49[]  = { 0x74, 0x68, 0x66,  ANTLR3_STRING_TERMINATOR};
126
static ANTLR3_UCHAR	lit_50[]  = { 0x74, 0x66, 0x66,  ANTLR3_STRING_TERMINATOR};
127
static ANTLR3_UCHAR	lit_51[]  = { 0x74, 0x79, 0x70, 0x65,  ANTLR3_STRING_TERMINATOR};
128
static ANTLR3_UCHAR	lit_52[]  = { 0x69, 0x6E, 0x63, 0x6C, 0x75, 0x64, 0x65,  ANTLR3_STRING_TERMINATOR};
129
static ANTLR3_UCHAR	lit_53[]  = { 0x5C, 0x22,  ANTLR3_STRING_TERMINATOR};
130
static ANTLR3_UCHAR	lit_54[]  = { 0x5C, 0x5C,  ANTLR3_STRING_TERMINATOR};
131
static ANTLR3_UCHAR	lit_55[]  = { 0x5C, 0x27,  ANTLR3_STRING_TERMINATOR};
132
static ANTLR3_UCHAR	lit_56[]  = { 0x2F, 0x2A,  ANTLR3_STRING_TERMINATOR};
133
static ANTLR3_UCHAR	lit_57[]  = { 0x2A, 0x2F,  ANTLR3_STRING_TERMINATOR};
134
135
136
137
138
139
/* MACROS that hide the C interface implementations from the
140
 * generated code, which makes it a little more understandable to the human eye.
141
 * I am very much against using C pre-processor macros for function calls and bits
142
 * of code as you cannot see what is happening when single stepping in debuggers
143
 * and so on. The exception (in my book at least) is for generated code, where you are
144
 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
145
 * hides some indirect calls, but is always referring to the input stream. This is
146
 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
147
 * the runtime interfaces without changing the generated code too often, without
148
 * confusing the reader of the generated output, who may not wish to know the gory
149
 * details of the interface inheritance.
150
 */
151
152
#define		CTX	ctx
153
154
/* Aids in accessing scopes for grammar programmers
155
 */
156
#undef	SCOPE_TYPE
157
#undef	SCOPE_STACK
158
#undef	SCOPE_TOP
159
#define	SCOPE_TYPE(scope)   pTptpLexer_##scope##_SCOPE
160
#define SCOPE_STACK(scope)  pTptpLexer_##scope##Stack
161
#define	SCOPE_TOP(scope)    ctx->pTptpLexer_##scope##Top
162
#define	SCOPE_SIZE(scope)		ctx->pTptpLexer_##scope##Stack_limit
163
#define SCOPE_INSTANCE(scope, i)	(ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
164
165
166
/* Macros for accessing things in a lexer
167
 */
168
#undef	    LEXER
169
#undef	    RECOGNIZER
170
#undef	    RULEMEMO
171
#undef	    GETCHARINDEX
172
#undef	    GETLINE
173
#undef	    GETCHARPOSITIONINLINE
174
#undef	    EMIT
175
#undef	    EMITNEW
176
#undef	    MATCHC
177
#undef	    MATCHS
178
#undef	    MATCHRANGE
179
#undef	    LTOKEN
180
#undef	    HASFAILED
181
#undef	    FAILEDFLAG
182
#undef	    INPUT
183
#undef	    STRSTREAM
184
#undef	    LA
185
#undef	    HASEXCEPTION
186
#undef	    EXCEPTION
187
#undef	    CONSTRUCTEX
188
#undef	    CONSUME
189
#undef	    LRECOVER
190
#undef	    MARK
191
#undef	    REWIND
192
#undef	    REWINDLAST
193
#undef	    BACKTRACKING
194
#undef		MATCHANY
195
#undef		MEMOIZE
196
#undef		HAVEPARSEDRULE
197
#undef		GETTEXT
198
#undef		INDEX
199
#undef		SEEK
200
#undef		PUSHSTREAM
201
#undef		POPSTREAM
202
#undef		SETTEXT
203
#undef		SETTEXT8
204
205
#define	    LEXER					ctx->pLexer
206
#define	    RECOGNIZER			    LEXER->rec
207
#define		LEXSTATE				RECOGNIZER->state
208
#define		TOKSOURCE				LEXSTATE->tokSource
209
#define	    GETCHARINDEX()			LEXER->getCharIndex(LEXER)
210
#define	    GETLINE()				LEXER->getLine(LEXER)
211
#define	    GETTEXT()				LEXER->getText(LEXER)
212
#define	    GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)
213
#define	    EMIT()					LEXSTATE->type = _type; LEXER->emit(LEXER)
214
#define	    EMITNEW(t)				LEXER->emitNew(LEXER, t)
215
#define	    MATCHC(c)				LEXER->matchc(LEXER, c)
216
#define	    MATCHS(s)				LEXER->matchs(LEXER, s)
217
#define	    MATCHRANGE(c1,c2)	    LEXER->matchRange(LEXER, c1, c2)
218
#define	    MATCHANY()				LEXER->matchAny(LEXER)
219
#define	    LTOKEN  				LEXSTATE->token
220
#define	    HASFAILED()				(LEXSTATE->failed == ANTLR3_TRUE)
221
#define	    BACKTRACKING			LEXSTATE->backtracking
222
#define	    FAILEDFLAG				LEXSTATE->failed
223
#define	    INPUT					LEXER->input
224
#define	    STRSTREAM				INPUT
225
#define		ISTREAM					INPUT->istream
226
#define		INDEX()					ISTREAM->index(ISTREAM)
227
#define		SEEK(n)					ISTREAM->seek(ISTREAM, n)
228
#define	    EOF_TOKEN				&(LEXSTATE->tokSource->eofToken)
229
#define	    HASEXCEPTION()			(LEXSTATE->error == ANTLR3_TRUE)
230
#define	    EXCEPTION				LEXSTATE->exception
231
#define	    CONSTRUCTEX()			RECOGNIZER->exConstruct(RECOGNIZER)
232
#define	    LRECOVER()				LEXER->recover(LEXER)
233
#define	    MARK()					ISTREAM->mark(ISTREAM)
234
#define	    REWIND(m)				ISTREAM->rewind(ISTREAM, m)
235
#define	    REWINDLAST()			ISTREAM->rewindLast(ISTREAM)
236
#define		MEMOIZE(ri,si)			RECOGNIZER->memoize(RECOGNIZER, ri, si)
237
#define		HAVEPARSEDRULE(r)		RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
238
#define		PUSHSTREAM(str)			LEXER->pushCharStream(LEXER, str)
239
#define		POPSTREAM()				LEXER->popCharStream(LEXER)
240
#define		SETTEXT(str)			LEXSTATE->text = str
241
#define		SKIP()					LEXSTATE->token = &(TOKSOURCE->skipToken)
242
#define		USER1					LEXSTATE->user1
243
#define		USER2					LEXSTATE->user2
244
#define		USER3					LEXSTATE->user3
245
#define		CUSTOM					LEXSTATE->custom
246
#define		RULEMEMO				LEXSTATE->ruleMemo
247
#define		DBG						RECOGNIZER->debugger
248
249
/* If we have been told we can rely on the standard 8 bit or UTF16 input
250
 * stream, then we can define our macros to use the direct pointers
251
 * in the input object, which is much faster than indirect calls. This
252
 * is really only significant to lexers with a lot of fragment rules (which
253
 * do not place LA(1) in a temporary at the moment) and even then
254
 * only if there is a lot of input (order of say 1M or so).
255
 */
256
#if	defined(ANTLR3_INLINE_INPUT_8BIT) || defined(ANTLR3_INLINE_INPUT_UTF16)
257
258
# ifdef	ANTLR3_INLINE_INPUT_8BIT
259
260
/* 8 bit character set */
261
262
#  define	    NEXTCHAR	((pANTLR3_UINT8)(INPUT->nextChar))
263
#  define	    DATAP	((pANTLR3_UINT8)(INPUT->data))
264
265
# else
266
267
#  define	    NEXTCHAR	((pANTLR3_UINT16)(INPUT->nextChar))
268
#  define	    DATAP	((pANTLR3_UINT16)(INPUT->data))
269
270
# endif
271
272
# define	    LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
273
# define            CONSUME()                                           \
274
{                                                                       \
275
    if        (NEXTCHAR < (DATAP + INPUT->sizeBuf))                     \
276
    {                                                                   \
277
        INPUT->charPositionInLine++;                                    \
278
        if  ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar)           \
279
        {                                                               \
280
            INPUT->line++;                                              \
281
            INPUT->charPositionInLine        = 0;                       \
282
            INPUT->currentLine                = (void *)(NEXTCHAR + 1); \
283
        }                                                               \
284
        INPUT->nextChar = (void *)(NEXTCHAR + 1);                       \
285
    }                                                                   \
286
}
287
288
#else
289
290
// Pick up the input character by calling the input stream implementation.
291
//
292
#define	    CONSUME()   INPUT->istream->consume(INPUT->istream)
293
#define	    LA(n)       INPUT->istream->_LA(INPUT->istream, n)
294
295
#endif
296
297
#define		TOKTEXT(tok, txt)				tok, (pANTLR3_UINT8)txt
298
299
/* The 4 tokens defined below may well clash with your own #defines or token types. If so
300
 * then for the present you must use different names for your defines as these are hard coded
301
 * in the code generator. It would be better not to use such names internally, and maybe
302
 * we can change this in a forthcoming release. I deliberately do not #undef these
303
 * here as this will at least give you a redefined error somewhere if they clash.
304
 */
305
#define	    UP	    ANTLR3_TOKEN_UP
306
#define	    DOWN    ANTLR3_TOKEN_DOWN
307
#define	    EOR	    ANTLR3_TOKEN_EOR
308
#define	    INVALID ANTLR3_TOKEN_INVALID
309
310
311
/* =============================================================================
312
 * Functions to create and destroy scopes. First come the rule scopes, followed
313
 * by the global declared scopes.
314
 */
315
316
317
318
/* ============================================================================= */
319
320
/* =============================================================================
321
 * Start of recognizer
322
 */
323
324
/* Forward declare the locally static matching functions we have generated and any predicate functions.
325
 */
326
static ANTLR3_INLINE
327
 void
328
	mT__63    (pTptpLexer ctx);
329
static ANTLR3_INLINE
330
 void
331
	mT__64    (pTptpLexer ctx);
332
static ANTLR3_INLINE
333
 void
334
	mT__65    (pTptpLexer ctx);
335
static ANTLR3_INLINE
336
 void
337
	mT__66    (pTptpLexer ctx);
338
static ANTLR3_INLINE
339
 void
340
	mT__67    (pTptpLexer ctx);
341
static ANTLR3_INLINE
342
 void
343
	mT__68    (pTptpLexer ctx);
344
static ANTLR3_INLINE
345
 void
346
	mT__69    (pTptpLexer ctx);
347
static ANTLR3_INLINE
348
 void
349
	mT__70    (pTptpLexer ctx);
350
static ANTLR3_INLINE
351
 void
352
	mT__71    (pTptpLexer ctx);
353
static ANTLR3_INLINE
354
 void
355
	mT__72    (pTptpLexer ctx);
356
static ANTLR3_INLINE
357
 void
358
	mT__73    (pTptpLexer ctx);
359
static ANTLR3_INLINE
360
 void
361
	mT__74    (pTptpLexer ctx);
362
static ANTLR3_INLINE
363
 void
364
	mT__75    (pTptpLexer ctx);
365
static ANTLR3_INLINE
366
 void
367
	mT__76    (pTptpLexer ctx);
368
static ANTLR3_INLINE
369
 void
370
	mT__77    (pTptpLexer ctx);
371
static ANTLR3_INLINE
372
 void
373
	mT__78    (pTptpLexer ctx);
374
static ANTLR3_INLINE
375
 void
376
	mT__79    (pTptpLexer ctx);
377
static ANTLR3_INLINE
378
 void
379
	mT__80    (pTptpLexer ctx);
380
static ANTLR3_INLINE
381
 void
382
	mT__81    (pTptpLexer ctx);
383
static ANTLR3_INLINE
384
 void
385
	mT__82    (pTptpLexer ctx);
386
static ANTLR3_INLINE
387
 void
388
	mT__83    (pTptpLexer ctx);
389
static ANTLR3_INLINE
390
 void
391
	mT__84    (pTptpLexer ctx);
392
static ANTLR3_INLINE
393
 void
394
	mT__85    (pTptpLexer ctx);
395
static ANTLR3_INLINE
396
 void
397
	mT__86    (pTptpLexer ctx);
398
static ANTLR3_INLINE
399
 void
400
	mT__87    (pTptpLexer ctx);
401
static ANTLR3_INLINE
402
 void
403
	mT__88    (pTptpLexer ctx);
404
static ANTLR3_INLINE
405
 void
406
	mT__89    (pTptpLexer ctx);
407
static ANTLR3_INLINE
408
 void
409
	mT__90    (pTptpLexer ctx);
410
static ANTLR3_INLINE
411
 void
412
	mT__91    (pTptpLexer ctx);
413
static ANTLR3_INLINE
414
 void
415
	mT__92    (pTptpLexer ctx);
416
static ANTLR3_INLINE
417
 void
418
	mT__93    (pTptpLexer ctx);
419
static ANTLR3_INLINE
420
 void
421
	mT__94    (pTptpLexer ctx);
422
static ANTLR3_INLINE
423
 void
424
	mCOMMA_TOK    (pTptpLexer ctx);
425
static ANTLR3_INLINE
426
 void
427
	mDOT_TOK    (pTptpLexer ctx);
428
static ANTLR3_INLINE
429
 void
430
	mLPAREN_TOK    (pTptpLexer ctx);
431
static ANTLR3_INLINE
432
 void
433
	mRPAREN_TOK    (pTptpLexer ctx);
434
static ANTLR3_INLINE
435
 void
436
	mLBRACK_TOK    (pTptpLexer ctx);
437
static ANTLR3_INLINE
438
 void
439
	mRBRACK_TOK    (pTptpLexer ctx);
440
static ANTLR3_INLINE
441
 void
442
	mCOLON_TOK    (pTptpLexer ctx);
443
static ANTLR3_INLINE
444
 void
445
	mARROW_TOK    (pTptpLexer ctx);
446
static ANTLR3_INLINE
447
 void
448
	mSUBTYPE_TOK    (pTptpLexer ctx);
449
static ANTLR3_INLINE
450
 void
451
	mOR_TOK    (pTptpLexer ctx);
452
static ANTLR3_INLINE
453
 void
454
	mNOT_TOK    (pTptpLexer ctx);
455
static ANTLR3_INLINE
456
 void
457
	mFORALL_TOK    (pTptpLexer ctx);
458
static ANTLR3_INLINE
459
 void
460
	mEXISTS_TOK    (pTptpLexer ctx);
461
static ANTLR3_INLINE
462
 void
463
	mLAMBDA_TOK    (pTptpLexer ctx);
464
static ANTLR3_INLINE
465
 void
466
	mCHOICE_TOK    (pTptpLexer ctx);
467
static ANTLR3_INLINE
468
 void
469
	mDEF_DESC_TOK    (pTptpLexer ctx);
470
static ANTLR3_INLINE
471
 void
472
	mAND_TOK    (pTptpLexer ctx);
473
static ANTLR3_INLINE
474
 void
475
	mIFF_TOK    (pTptpLexer ctx);
476
static ANTLR3_INLINE
477
 void
478
	mIMPLIES_TOK    (pTptpLexer ctx);
479
static ANTLR3_INLINE
480
 void
481
	mREVIMPLIES_TOK    (pTptpLexer ctx);
482
static ANTLR3_INLINE
483
 void
484
	mREVIFF_TOK    (pTptpLexer ctx);
485
static ANTLR3_INLINE
486
 void
487
	mREVOR_TOK    (pTptpLexer ctx);
488
static ANTLR3_INLINE
489
 void
490
	mREVAND_TOK    (pTptpLexer ctx);
491
static ANTLR3_INLINE
492
 void
493
	mTIMES_TOK    (pTptpLexer ctx);
494
static ANTLR3_INLINE
495
 void
496
	mPLUS_TOK    (pTptpLexer ctx);
497
static ANTLR3_INLINE
498
 void
499
	mMINUS_TOK    (pTptpLexer ctx);
500
static ANTLR3_INLINE
501
 void
502
	mAPP_TOK    (pTptpLexer ctx);
503
static ANTLR3_INLINE
504
 void
505
	mTH1_UN_A    (pTptpLexer ctx);
506
static ANTLR3_INLINE
507
 void
508
	mTH1_UN_E    (pTptpLexer ctx);
509
static ANTLR3_INLINE
510
 void
511
	mTRUE_TOK    (pTptpLexer ctx);
512
static ANTLR3_INLINE
513
 void
514
	mFALSE_TOK    (pTptpLexer ctx);
515
static ANTLR3_INLINE
516
 void
517
	mEQUAL_TOK    (pTptpLexer ctx);
518
static ANTLR3_INLINE
519
 void
520
	mDISEQUAL_TOK    (pTptpLexer ctx);
521
static ANTLR3_INLINE
522
 void
523
	mCNF_TOK    (pTptpLexer ctx);
524
static ANTLR3_INLINE
525
 void
526
	mFOF_TOK    (pTptpLexer ctx);
527
static ANTLR3_INLINE
528
 void
529
	mTHF_TOK    (pTptpLexer ctx);
530
static ANTLR3_INLINE
531
 void
532
	mTFF_TOK    (pTptpLexer ctx);
533
static ANTLR3_INLINE
534
 void
535
	mTYPE_TOK    (pTptpLexer ctx);
536
static ANTLR3_INLINE
537
 void
538
	mINCLUDE_TOK    (pTptpLexer ctx);
539
static ANTLR3_INLINE
540
 void
541
	mDEFINED_SYMBOL    (pTptpLexer ctx);
542
static ANTLR3_INLINE
543
 void
544
	mWHITESPACE    (pTptpLexer ctx);
545
static ANTLR3_INLINE
546
 void
547
	mDISTINCT_OBJECT    (pTptpLexer ctx);
548
static ANTLR3_INLINE
549
 void
550
	mDO_CHAR    (pTptpLexer ctx);
551
static ANTLR3_INLINE
552
 void
553
	mLOWER_WORD_SINGLE_QUOTED    (pTptpLexer ctx);
554
static ANTLR3_INLINE
555
 void
556
	mSINGLE_QUOTED    (pTptpLexer ctx);
557
static ANTLR3_INLINE
558
 void
559
	mSQ_CHAR    (pTptpLexer ctx);
560
static ANTLR3_INLINE
561
 void
562
	mNUMERIC    (pTptpLexer ctx);
563
static ANTLR3_INLINE
564
 void
565
	mLOWER_ALPHA    (pTptpLexer ctx);
566
static ANTLR3_INLINE
567
 void
568
	mUPPER_ALPHA    (pTptpLexer ctx);
569
static ANTLR3_INLINE
570
 void
571
	mALPHA_NUMERIC    (pTptpLexer ctx);
572
static ANTLR3_INLINE
573
 void
574
	mUPPER_WORD    (pTptpLexer ctx);
575
static ANTLR3_INLINE
576
 void
577
	mLOWER_WORD    (pTptpLexer ctx);
578
static ANTLR3_INLINE
579
 void
580
	mDOT    (pTptpLexer ctx);
581
static ANTLR3_INLINE
582
 void
583
	mEXPONENT    (pTptpLexer ctx);
584
static ANTLR3_INLINE
585
 void
586
	mSLASH    (pTptpLexer ctx);
587
static ANTLR3_INLINE
588
 void
589
	mDECIMAL    (pTptpLexer ctx);
590
static ANTLR3_INLINE
591
 void
592
	mSIGN    (pTptpLexer ctx, bool& pos);
593
static ANTLR3_INLINE
594
 void
595
	mNUMBER    (pTptpLexer ctx);
596
static ANTLR3_INLINE
597
 void
598
	mCOMMENT    (pTptpLexer ctx);
599
static ANTLR3_INLINE
600
 void
601
	mTokens    (pTptpLexer ctx);
602
static void	TptpLexerFree(pTptpLexer ctx);
603
604
/* =========================================================================
605
 * Lexer matching rules end.
606
 * =========================================================================
607
 */
608
609
610
611
static void
612
42
TptpLexerFree  (pTptpLexer ctx)
613
{
614
42
    LEXER->free(LEXER);
615
616
42
    ANTLR3_FREE(ctx);
617
42
}
618
619
static void
620
TptpLexerReset (pTptpLexer ctx)
621
{
622
    RECOGNIZER->reset(RECOGNIZER);
623
}
624
625
/** \brief Name of the grammar file that generated this code
626
 */
627
static const char fileName[] = "/barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g";
628
629
/** \brief Return the name of the grammar file that generated this code.
630
 */
631
static const char * getGrammarFileName()
632
{
633
	return fileName;
634
}
635
636
/** \brief Create a new lexer called TptpLexer
637
 *
638
 * \param[in]    instream Pointer to an initialized input stream
639
 * \return
640
 *     - Success pTptpLexer initialized for the lex start
641
 *     - Fail NULL
642
 */
643
42
ANTLR3_API pTptpLexer TptpLexerNew
644
(
645
pANTLR3_INPUT_STREAM
646
 instream)
647
{
648
	// See if we can create a new lexer with the standard constructor
649
	//
650
42
	return TptpLexerNewSSD(instream, NULL);
651
}
652
653
/** \brief Create a new lexer called TptpLexer
654
 *
655
 * \param[in]    instream Pointer to an initialized input stream
656
 * \param[state] state Previously created shared recognizer stat
657
 * \return
658
 *     - Success pTptpLexer initialized for the lex start
659
 *     - Fail NULL
660
 */
661
42
ANTLR3_API pTptpLexer TptpLexerNewSSD
662
(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
663
{
664
    pTptpLexer ctx; // Context structure we will build and return
665
666
42
    ctx = (pTptpLexer) ANTLR3_CALLOC(1, sizeof(TptpLexer));
667
668
42
    if  (ctx == NULL)
669
    {
670
        // Failed to allocate memory for lexer context
671
        return  NULL;
672
    }
673
674
    /* -------------------------------------------------------------------
675
     * Memory for basic structure is allocated, now to fill in
676
     * in base ANTLR3 structures. We initialize the function pointers
677
     * for the standard ANTLR3 lexer function set, but upon return
678
     * from here, the programmer may set the pointers to provide custom
679
     * implementations of each function.
680
     *
681
     * We don't use the macros defined in TptpLexer.h here so you can get a sense
682
     * of what goes where.
683
     */
684
685
    /* Create a base lexer, using the supplied input stream
686
     */
687
42
    ctx->pLexer	= antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);
688
689
    /* Check that we allocated the memory correctly
690
     */
691
42
    if	(ctx->pLexer == NULL)
692
    {
693
		ANTLR3_FREE(ctx);
694
		return  NULL;
695
    }
696
    /* Install the implementation of our TptpLexer interface
697
     */
698
42
    ctx->mT__63	= mT__63;
699
42
    ctx->mT__64	= mT__64;
700
42
    ctx->mT__65	= mT__65;
701
42
    ctx->mT__66	= mT__66;
702
42
    ctx->mT__67	= mT__67;
703
42
    ctx->mT__68	= mT__68;
704
42
    ctx->mT__69	= mT__69;
705
42
    ctx->mT__70	= mT__70;
706
42
    ctx->mT__71	= mT__71;
707
42
    ctx->mT__72	= mT__72;
708
42
    ctx->mT__73	= mT__73;
709
42
    ctx->mT__74	= mT__74;
710
42
    ctx->mT__75	= mT__75;
711
42
    ctx->mT__76	= mT__76;
712
42
    ctx->mT__77	= mT__77;
713
42
    ctx->mT__78	= mT__78;
714
42
    ctx->mT__79	= mT__79;
715
42
    ctx->mT__80	= mT__80;
716
42
    ctx->mT__81	= mT__81;
717
42
    ctx->mT__82	= mT__82;
718
42
    ctx->mT__83	= mT__83;
719
42
    ctx->mT__84	= mT__84;
720
42
    ctx->mT__85	= mT__85;
721
42
    ctx->mT__86	= mT__86;
722
42
    ctx->mT__87	= mT__87;
723
42
    ctx->mT__88	= mT__88;
724
42
    ctx->mT__89	= mT__89;
725
42
    ctx->mT__90	= mT__90;
726
42
    ctx->mT__91	= mT__91;
727
42
    ctx->mT__92	= mT__92;
728
42
    ctx->mT__93	= mT__93;
729
42
    ctx->mT__94	= mT__94;
730
42
    ctx->mCOMMA_TOK	= mCOMMA_TOK;
731
42
    ctx->mDOT_TOK	= mDOT_TOK;
732
42
    ctx->mLPAREN_TOK	= mLPAREN_TOK;
733
42
    ctx->mRPAREN_TOK	= mRPAREN_TOK;
734
42
    ctx->mLBRACK_TOK	= mLBRACK_TOK;
735
42
    ctx->mRBRACK_TOK	= mRBRACK_TOK;
736
42
    ctx->mCOLON_TOK	= mCOLON_TOK;
737
42
    ctx->mARROW_TOK	= mARROW_TOK;
738
42
    ctx->mSUBTYPE_TOK	= mSUBTYPE_TOK;
739
42
    ctx->mOR_TOK	= mOR_TOK;
740
42
    ctx->mNOT_TOK	= mNOT_TOK;
741
42
    ctx->mFORALL_TOK	= mFORALL_TOK;
742
42
    ctx->mEXISTS_TOK	= mEXISTS_TOK;
743
42
    ctx->mLAMBDA_TOK	= mLAMBDA_TOK;
744
42
    ctx->mCHOICE_TOK	= mCHOICE_TOK;
745
42
    ctx->mDEF_DESC_TOK	= mDEF_DESC_TOK;
746
42
    ctx->mAND_TOK	= mAND_TOK;
747
42
    ctx->mIFF_TOK	= mIFF_TOK;
748
42
    ctx->mIMPLIES_TOK	= mIMPLIES_TOK;
749
42
    ctx->mREVIMPLIES_TOK	= mREVIMPLIES_TOK;
750
42
    ctx->mREVIFF_TOK	= mREVIFF_TOK;
751
42
    ctx->mREVOR_TOK	= mREVOR_TOK;
752
42
    ctx->mREVAND_TOK	= mREVAND_TOK;
753
42
    ctx->mTIMES_TOK	= mTIMES_TOK;
754
42
    ctx->mPLUS_TOK	= mPLUS_TOK;
755
42
    ctx->mMINUS_TOK	= mMINUS_TOK;
756
42
    ctx->mAPP_TOK	= mAPP_TOK;
757
42
    ctx->mTH1_UN_A	= mTH1_UN_A;
758
42
    ctx->mTH1_UN_E	= mTH1_UN_E;
759
42
    ctx->mTRUE_TOK	= mTRUE_TOK;
760
42
    ctx->mFALSE_TOK	= mFALSE_TOK;
761
42
    ctx->mEQUAL_TOK	= mEQUAL_TOK;
762
42
    ctx->mDISEQUAL_TOK	= mDISEQUAL_TOK;
763
42
    ctx->mCNF_TOK	= mCNF_TOK;
764
42
    ctx->mFOF_TOK	= mFOF_TOK;
765
42
    ctx->mTHF_TOK	= mTHF_TOK;
766
42
    ctx->mTFF_TOK	= mTFF_TOK;
767
42
    ctx->mTYPE_TOK	= mTYPE_TOK;
768
42
    ctx->mINCLUDE_TOK	= mINCLUDE_TOK;
769
42
    ctx->mDEFINED_SYMBOL	= mDEFINED_SYMBOL;
770
42
    ctx->mWHITESPACE	= mWHITESPACE;
771
42
    ctx->mDISTINCT_OBJECT	= mDISTINCT_OBJECT;
772
42
    ctx->mDO_CHAR	= mDO_CHAR;
773
42
    ctx->mLOWER_WORD_SINGLE_QUOTED	= mLOWER_WORD_SINGLE_QUOTED;
774
42
    ctx->mSINGLE_QUOTED	= mSINGLE_QUOTED;
775
42
    ctx->mSQ_CHAR	= mSQ_CHAR;
776
42
    ctx->mNUMERIC	= mNUMERIC;
777
42
    ctx->mLOWER_ALPHA	= mLOWER_ALPHA;
778
42
    ctx->mUPPER_ALPHA	= mUPPER_ALPHA;
779
42
    ctx->mALPHA_NUMERIC	= mALPHA_NUMERIC;
780
42
    ctx->mUPPER_WORD	= mUPPER_WORD;
781
42
    ctx->mLOWER_WORD	= mLOWER_WORD;
782
42
    ctx->mDOT	= mDOT;
783
42
    ctx->mEXPONENT	= mEXPONENT;
784
42
    ctx->mSLASH	= mSLASH;
785
42
    ctx->mDECIMAL	= mDECIMAL;
786
42
    ctx->mSIGN	= mSIGN;
787
42
    ctx->mNUMBER	= mNUMBER;
788
42
    ctx->mCOMMENT	= mCOMMENT;
789
42
    ctx->mTokens	= mTokens;
790
791
    /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
792
     *  it will call mTokens() in this generated code, and will pass it the ctx
793
     * pointer of this lexer, not the context of the base lexer, so store that now.
794
     */
795
42
    ctx->pLexer->ctx	    = ctx;
796
797
    /**Install the token matching function
798
     */
799
42
    ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
800
801
42
    ctx->getGrammarFileName	= getGrammarFileName;
802
42
    ctx->free		= TptpLexerFree;
803
42
    ctx->reset          = TptpLexerReset;
804
805
806
    /* Return the newly built lexer to the caller
807
     */
808
42
    return  ctx;
809
}
810
811
/* =========================================================================
812
 * DFA tables for the lexer
813
 */
814
/** Static dfa state tables for Cyclic dfa:
815
 *    1745:5: ( ( SIGN[pos] )? num= DECIMAL | ( SIGN[pos] )? num= DECIMAL DOT den= DECIMAL ( EXPONENT ( SIGN[posE] )? e= DECIMAL )? | ( SIGN[pos] )? num= DECIMAL SLASH den= DECIMAL )
816
 */
817
static const ANTLR3_INT32 dfa15_eot[7] =
818
    {
819
	-1, -1, -1, 4, -1, -1, -1
820
    };
821
static const ANTLR3_INT32 dfa15_eof[7] =
822
    {
823
	-1, -1, -1, -1, -1, -1, -1
824
    };
825
static const ANTLR3_INT32 dfa15_min[7] =
826
    {
827
	43, 48, 48, 46, -1, -1, -1
828
    };
829
static const ANTLR3_INT32 dfa15_max[7] =
830
    {
831
	57, 57, 57, 57, -1, -1, -1
832
    };
833
static const ANTLR3_INT32 dfa15_accept[7] =
834
    {
835
	-1, -1, -1, -1, 1, 2, 3
836
    };
837
static const ANTLR3_INT32 dfa15_special[7] =
838
    {
839
	-1, -1, -1, -1, -1, -1, -1
840
    };
841
842
/** Used when there is no transition table entry for a particular state */
843
#define dfa15_T_empty	    NULL
844
845
static const ANTLR3_INT32 dfa15_T0[] =
846
    {
847
	1, -1, 2, -1, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
848
    };
849
850
static const ANTLR3_INT32 dfa15_T1[] =
851
    {
852
	5, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
853
    };
854
855
static const ANTLR3_INT32 dfa15_T2[] =
856
    {
857
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3
858
    };
859
860
861
/* Transition tables are a table of sub tables, with some tables
862
 * reused for efficiency.
863
 */
864
static const ANTLR3_INT32 * const dfa15_transitions[] =
865
{
866
    dfa15_T0, dfa15_T2, dfa15_T2, dfa15_T1, NULL, NULL, NULL
867
};
868
869
870
/* Declare tracking structure for Cyclic DFA 15
871
 */
872
static
873
ANTLR3_CYCLIC_DFA cdfa15
874
    =	{
875
	    15,		    /* Decision number of this dfa	    */
876
	    /* Which decision this represents:   */
877
	    (const pANTLR3_UCHAR)"1745:5: ( ( SIGN[pos] )? num= DECIMAL | ( SIGN[pos] )? num= DECIMAL DOT den= DECIMAL ( EXPONENT ( SIGN[posE] )? e= DECIMAL )? | ( SIGN[pos] )? num= DECIMAL SLASH den= DECIMAL )",
878
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/
879
880
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
881
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
882
	    dfa15_eot,	    /* EOT table			    */
883
	    dfa15_eof,	    /* EOF table			    */
884
	    dfa15_min,	    /* Minimum tokens for each state    */
885
	    dfa15_max,	    /* Maximum tokens for each state    */
886
	    dfa15_accept,	/* Accept table			    */
887
	    dfa15_special,	/* Special transition states	    */
888
	    dfa15_transitions	/* Table of transition tables	    */
889
890
	};
891
/* End of Cyclic DFA 15
892
 * ---------------------
893
 *//** Static dfa state tables for Cyclic dfa:
894
 *    1:1: Tokens : ( T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | COMMA_TOK | DOT_TOK | LPAREN_TOK | RPAREN_TOK | LBRACK_TOK | RBRACK_TOK | COLON_TOK | ARROW_TOK | SUBTYPE_TOK | OR_TOK | NOT_TOK | FORALL_TOK | EXISTS_TOK | LAMBDA_TOK | CHOICE_TOK | DEF_DESC_TOK | AND_TOK | IFF_TOK | IMPLIES_TOK | REVIMPLIES_TOK | REVIFF_TOK | REVOR_TOK | REVAND_TOK | TIMES_TOK | PLUS_TOK | MINUS_TOK | APP_TOK | TH1_UN_A | TH1_UN_E | TRUE_TOK | FALSE_TOK | EQUAL_TOK | DISEQUAL_TOK | CNF_TOK | FOF_TOK | THF_TOK | TFF_TOK | TYPE_TOK | INCLUDE_TOK | DEFINED_SYMBOL | WHITESPACE | DISTINCT_OBJECT | LOWER_WORD_SINGLE_QUOTED | SINGLE_QUOTED | UPPER_WORD | LOWER_WORD | NUMBER | COMMENT );
895
 */
896
static const ANTLR3_INT32 dfa19_eot[256] =
897
    {
898
	-1, -1, -1, -1, -1, -1, -1, -1, -1, 47, -1, 50, 53, 55, -1, 58, -1, -1,
899
	62, -1, 63, 64, 30, 30, 30, 30, -1, -1, -1, -1, -1, -1, -1, 45, 45, 45,
900
	45, 45, 45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, -1, -1, -1, -1, -1,
901
	-1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, 30, 30, 30, 30, 30, 30, -1,
902
	-1, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
903
	-1, -1, 120, 121, 122, 123, 30, 30, -1, -1, -1, 45, 45, 45, 45, 45, 45,
904
	45, 45, 45, 45, 45, 45, 45, 45, 142, 45, 45, 45, 45, -1, -1, -1, -1, 149,
905
	30, -1, 45, 45, 45, 45, 45, 45, 45, 45, 45, 162, 45, 45, 45, 45, 45, -1,
906
	45, 45, 45, 45, 174, 45, -1, 30, 45, 45, 45, 180, 181, 45, 45, 45, 185,
907
	186, 45, -1, 45, 45, 45, 45, 45, 195, 196, 45, 45, 45, 45, -1, 45, 30,
908
	45, 45, 45, -1, -1, 45, 207, 208, -1, -1, 209, 210, 211, 212, 213, 45,
909
	45, 45, -1, -1, 217, 218, 45, 45, 221, 222, 223, 45, 45, 227, -1, -1, -1,
910
	-1, -1, -1, -1, 228, 45, 45, -1, -1, 231, 45, -1, -1, -1, 45, 234, 45,
911
	-1, -1, 237, 45, -1, 239, 45, -1, 241, 45, -1, 45, -1, 246, -1, 247, 248,
912
	249, 45, -1, -1, -1, -1, 253, 254, 255, -1, -1, -1
913
    };
914
static const ANTLR3_INT32 dfa19_eof[256] =
915
    {
916
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
917
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
918
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
919
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
920
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
921
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
922
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
923
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
924
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
925
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
926
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
927
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
928
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
929
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
930
	-1, -1, -1, -1
931
    };
932
static const ANTLR3_INT32 dfa19_min[256] =
933
    {
934
	9, 97, -1, -1, -1, -1, -1, -1, -1, 62, -1, 38, 33, 63, -1, 43, -1, 61,
935
	62, -1, 48, 48, 110, 111, 102, 110, -1, -1, 32, -1, -1, -1, -1, 101, 105,
936
	97, 114, 115, 101, 114, 117, 101, 117, 84, 109, -1, -1, -1, -1, -1, -1,
937
	-1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, -1, -1, 102, 102, 102,
938
	102, 112, 99, 32, -1, 105, 102, 111, 108, 101, 95, 101, 115, 111, 111,
939
	109, 117, 109, 121, 95, 117, 105, -1, -1, 48, 48, 48, 48, 101, 108, 32,
940
	-1, 32, 108, 102, 116, 111, 115, 97, 105, 95, 115, 95, 100, 116, 97, 110,
941
	48, 112, 105, 101, 110, -1, -1, -1, -1, 48, 117, -1, 105, 101, 105, 114,
942
	101, 116, 110, 97, 102, 48, 102, 117, 105, 105, 100, -1, 101, 110, 97,
943
	99, 48, 117, -1, 100, 110, 114, 110, 48, 48, 101, 116, 116, 48, 48, 113,
944
	-1, 102, 102, 99, 101, 110, 48, 48, 116, 116, 97, 97, -1, 115, 101, 103,
945
	101, 99, -1, -1, 114, 48, 48, -1, -1, 48, 48, 48, 48, 48, 116, 110, 100,
946
	-1, -1, 48, 48, 108, 116, 48, 48, 48, 110, 116, 48, -1, -1, -1, -1, -1,
947
	-1, -1, 48, 116, 101, -1, -1, 48, 101, -1, -1, -1, 99, 48, 113, -1, -1,
948
	48, 114, -1, 48, 101, -1, 48, 101, -1, 95, -1, 48, -1, 48, 48, 48, 101,
949
	-1, -1, -1, -1, 48, 48, 48, -1, -1, -1
950
    };
951
static const ANTLR3_INT32 dfa19_max[256] =
952
    {
953
	126, 122, -1, -1, -1, -1, -1, -1, -1, 62, -1, 124, 61, 63, -1, 45, -1,
954
	126, 62, -1, 57, 57, 110, 111, 121, 110, -1, -1, 126, -1, -1, -1, -1, 101,
955
	105, 108, 114, 116, 101, 114, 117, 111, 117, 114, 109, -1, -1, -1, -1,
956
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, -1, -1, 102, 102,
957
	102, 102, 112, 99, 126, -1, 105, 115, 111, 108, 101, 95, 101, 116, 111,
958
	111, 109, 117, 109, 121, 95, 117, 105, -1, -1, 122, 122, 122, 122, 101,
959
	108, 126, -1, 126, 108, 102, 116, 111, 115, 97, 114, 95, 115, 95, 100,
960
	116, 97, 110, 122, 112, 114, 110, 110, -1, -1, -1, -1, 122, 117, -1, 105,
961
	101, 105, 114, 101, 116, 110, 97, 116, 122, 116, 117, 105, 105, 100, -1,
962
	101, 110, 101, 99, 122, 117, -1, 100, 110, 114, 110, 122, 122, 101, 116,
963
	116, 122, 122, 113, -1, 116, 116, 99, 101, 110, 122, 122, 116, 116, 97,
964
	97, -1, 115, 101, 103, 101, 99, -1, -1, 114, 122, 122, -1, -1, 122, 122,
965
	122, 122, 122, 116, 110, 100, -1, -1, 122, 122, 108, 116, 122, 122, 122,
966
	110, 116, 122, -1, -1, -1, -1, -1, -1, -1, 122, 116, 101, -1, -1, 122,
967
	101, -1, -1, -1, 99, 122, 113, -1, -1, 122, 114, -1, 122, 101, -1, 122,
968
	116, -1, 95, -1, 122, -1, 122, 122, 122, 116, -1, -1, -1, -1, 122, 122,
969
	122, -1, -1, -1
970
    };
971
static const ANTLR3_INT32 dfa19_accept[256] =
972
    {
973
	-1, -1, 33, 34, 35, 36, 37, 38, 39, -1, 42, -1, -1, -1, 46, -1, 49, -1,
974
	-1, 56, -1, -1, -1, -1, -1, -1, 73, 74, -1, 77, 78, 79, 80, -1, -1, -1,
975
	-1, -1, -1, -1, -1, -1, -1, -1, -1, 72, 41, 40, 54, 55, 43, 60, 65, 44,
976
	61, 45, 47, 48, 59, -1, 53, 51, 64, 57, 58, -1, -1, -1, -1, -1, -1, -1,
977
	76, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
978
	50, 52, -1, -1, -1, -1, -1, -1, -1, 75, -1, -1, -1, -1, -1, -1, -1, -1,
979
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, 68, 69, -1, -1,
980
	75, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, -1,
981
	-1, -1, -1, -1, -1, 70, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
982
	11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, -1, -1,
983
	4, 63, -1, -1, -1, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, 25, 27, -1, -1,
984
	-1, -1, -1, -1, -1, -1, -1, -1, 7, 8, 12, 13, 14, 15, 16, -1, -1, -1, 28,
985
	29, -1, -1, 32, 71, 1, -1, -1, -1, 5, 17, -1, -1, 30, -1, -1, 3, -1, -1,
986
	18, -1, 31, -1, 6, -1, -1, -1, -1, 2, 19, 20, 21, -1, -1, -1, 22, 23, 24
987
    };
988
static const ANTLR3_INT32 dfa19_special[256] =
989
    {
990
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
991
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
992
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
993
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
994
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
995
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
996
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
997
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
998
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
999
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1000
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1001
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1002
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1003
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1004
	-1, -1, -1, -1
1005
    };
1006
1007
/** Used when there is no transition table entry for a particular state */
1008
#define dfa19_T_empty	    NULL
1009
1010
static const ANTLR3_INT32 dfa19_T0[] =
1011
    {
1012
	82
1013
    };
1014
1015
static const ANTLR3_INT32 dfa19_T1[] =
1016
    {
1017
	105
1018
    };
1019
1020
static const ANTLR3_INT32 dfa19_T2[] =
1021
    {
1022
	118
1023
    };
1024
1025
static const ANTLR3_INT32 dfa19_T3[] =
1026
    {
1027
	131
1028
    };
1029
1030
static const ANTLR3_INT32 dfa19_T4[] =
1031
    {
1032
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, -1, -1, -1, 45,
1033
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1034
	45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, 45, -1, 45, 45, 45, 45, 45,
1035
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1036
	45, 45, 45
1037
    };
1038
1039
static const ANTLR3_INT32 dfa19_T5[] =
1040
    {
1041
	147, -1, -1, -1, -1, -1, -1, -1, -1, 146
1042
    };
1043
1044
static const ANTLR3_INT32 dfa19_T6[] =
1045
    {
1046
	155
1047
    };
1048
1049
static const ANTLR3_INT32 dfa19_T7[] =
1050
    {
1051
	242, 243, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 244
1052
    };
1053
1054
static const ANTLR3_INT32 dfa19_T8[] =
1055
    {
1056
	190, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 191
1057
    };
1058
1059
static const ANTLR3_INT32 dfa19_T9[] =
1060
    {
1061
	89
1062
    };
1063
1064
static const ANTLR3_INT32 dfa19_T10[] =
1065
    {
1066
	101
1067
    };
1068
1069
static const ANTLR3_INT32 dfa19_T11[] =
1070
    {
1071
	127
1072
    };
1073
1074
static const ANTLR3_INT32 dfa19_T12[] =
1075
    {
1076
	151
1077
    };
1078
1079
static const ANTLR3_INT32 dfa19_T13[] =
1080
    {
1081
	177
1082
    };
1083
1084
static const ANTLR3_INT32 dfa19_T14[] =
1085
    {
1086
	203
1087
    };
1088
1089
static const ANTLR3_INT32 dfa19_T15[] =
1090
    {
1091
	128
1092
    };
1093
1094
static const ANTLR3_INT32 dfa19_T16[] =
1095
    {
1096
	152
1097
    };
1098
1099
static const ANTLR3_INT32 dfa19_T17[] =
1100
    {
1101
	178
1102
    };
1103
1104
static const ANTLR3_INT32 dfa19_T18[] =
1105
    {
1106
	204
1107
    };
1108
1109
static const ANTLR3_INT32 dfa19_T19[] =
1110
    {
1111
	224
1112
    };
1113
1114
static const ANTLR3_INT32 dfa19_T20[] =
1115
    {
1116
	233
1117
    };
1118
1119
static const ANTLR3_INT32 dfa19_T21[] =
1120
    {
1121
	240
1122
    };
1123
1124
static const ANTLR3_INT32 dfa19_T22[] =
1125
    {
1126
	129
1127
    };
1128
1129
static const ANTLR3_INT32 dfa19_T23[] =
1130
    {
1131
	153
1132
    };
1133
1134
static const ANTLR3_INT32 dfa19_T24[] =
1135
    {
1136
	179
1137
    };
1138
1139
static const ANTLR3_INT32 dfa19_T25[] =
1140
    {
1141
	205
1142
    };
1143
1144
static const ANTLR3_INT32 dfa19_T26[] =
1145
    {
1146
	225
1147
    };
1148
1149
static const ANTLR3_INT32 dfa19_T27[] =
1150
    {
1151
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, -1, -1, -1, 45,
1152
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1153
	45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, 236, -1, 45, 45, 45, 45, 45,
1154
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1155
	45, 45, 45
1156
    };
1157
1158
static const ANTLR3_INT32 dfa19_T28[] =
1159
    {
1160
	104
1161
    };
1162
1163
static const ANTLR3_INT32 dfa19_T29[] =
1164
    {
1165
	130
1166
    };
1167
1168
static const ANTLR3_INT32 dfa19_T30[] =
1169
    {
1170
	26, 26, -1, 26, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1171
	-1, -1, -1, -1, -1, 26, 12, 27, -1, 1, 32, 16, 28, 4, 5, 19, 20, 2, 21,
1172
	3, 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 8, -1, 17, 18, 9, 13, 15,
1173
	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1174
	29, 29, 29, 29, 29, 29, 29, 29, 6, -1, 7, 14, -1, -1, 30, 30, 22, 30, 30,
1175
	23, 30, 30, 25, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 24, 30, 30, 30,
1176
	30, 30, 30, -1, 10, -1, 11
1177
    };
1178
1179
static const ANTLR3_INT32 dfa19_T31[] =
1180
    {
1181
	154
1182
    };
1183
1184
static const ANTLR3_INT32 dfa19_T32[] =
1185
    {
1186
	78, 79
1187
    };
1188
1189
static const ANTLR3_INT32 dfa19_T33[] =
1190
    {
1191
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, -1, -1, -1, 45,
1192
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1193
	45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, 45, -1, 45, 45, 45, 45, 161,
1194
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1195
	45, 45, 45
1196
    };
1197
1198
static const ANTLR3_INT32 dfa19_T34[] =
1199
    {
1200
	235
1201
    };
1202
1203
static const ANTLR3_INT32 dfa19_T35[] =
1204
    {
1205
	86, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1206
	-1, -1, -1, -1, -1, -1, -1, -1, -1, 87, -1, -1, 88
1207
    };
1208
1209
static const ANTLR3_INT32 dfa19_T36[] =
1210
    {
1211
	157
1212
    };
1213
1214
static const ANTLR3_INT32 dfa19_T37[] =
1215
    {
1216
	183
1217
    };
1218
1219
static const ANTLR3_INT32 dfa19_T38[] =
1220
    {
1221
	158
1222
    };
1223
1224
static const ANTLR3_INT32 dfa19_T39[] =
1225
    {
1226
	184
1227
    };
1228
1229
static const ANTLR3_INT32 dfa19_T40[] =
1230
    {
1231
	31, 31, 31, 31, 31, 31, 31, 31, 31, 31
1232
    };
1233
1234
static const ANTLR3_INT32 dfa19_T41[] =
1235
    {
1236
	113
1237
    };
1238
1239
static const ANTLR3_INT32 dfa19_T42[] =
1240
    {
1241
	140
1242
    };
1243
1244
static const ANTLR3_INT32 dfa19_T43[] =
1245
    {
1246
	167
1247
    };
1248
1249
static const ANTLR3_INT32 dfa19_T44[] =
1250
    {
1251
	194
1252
    };
1253
1254
static const ANTLR3_INT32 dfa19_T45[] =
1255
    {
1256
	216
1257
    };
1258
1259
static const ANTLR3_INT32 dfa19_T46[] =
1260
    {
1261
	54
1262
    };
1263
1264
static const ANTLR3_INT32 dfa19_T47[] =
1265
    {
1266
	230
1267
    };
1268
1269
static const ANTLR3_INT32 dfa19_T48[] =
1270
    {
1271
	137
1272
    };
1273
1274
static const ANTLR3_INT32 dfa19_T49[] =
1275
    {
1276
	238
1277
    };
1278
1279
static const ANTLR3_INT32 dfa19_T50[] =
1280
    {
1281
	245
1282
    };
1283
1284
static const ANTLR3_INT32 dfa19_T51[] =
1285
    {
1286
	163, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 164
1287
    };
1288
1289
static const ANTLR3_INT32 dfa19_T52[] =
1290
    {
1291
	250, 251, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 252
1292
    };
1293
1294
static const ANTLR3_INT32 dfa19_T53[] =
1295
    {
1296
	187
1297
    };
1298
1299
static const ANTLR3_INT32 dfa19_T54[] =
1300
    {
1301
	92
1302
    };
1303
1304
static const ANTLR3_INT32 dfa19_T55[] =
1305
    {
1306
	93
1307
    };
1308
1309
static const ANTLR3_INT32 dfa19_T56[] =
1310
    {
1311
	94
1312
    };
1313
1314
static const ANTLR3_INT32 dfa19_T57[] =
1315
    {
1316
	90
1317
    };
1318
1319
static const ANTLR3_INT32 dfa19_T58[] =
1320
    {
1321
	95
1322
    };
1323
1324
static const ANTLR3_INT32 dfa19_T59[] =
1325
    {
1326
	96
1327
    };
1328
1329
static const ANTLR3_INT32 dfa19_T60[] =
1330
    {
1331
	124
1332
    };
1333
1334
static const ANTLR3_INT32 dfa19_T61[] =
1335
    {
1336
	97
1337
    };
1338
1339
static const ANTLR3_INT32 dfa19_T62[] =
1340
    {
1341
	125
1342
    };
1343
1344
static const ANTLR3_INT32 dfa19_T63[] =
1345
    {
1346
	150
1347
    };
1348
1349
static const ANTLR3_INT32 dfa19_T64[] =
1350
    {
1351
	176
1352
    };
1353
1354
static const ANTLR3_INT32 dfa19_T65[] =
1355
    {
1356
	202
1357
    };
1358
1359
static const ANTLR3_INT32 dfa19_T66[] =
1360
    {
1361
	73
1362
    };
1363
1364
static const ANTLR3_INT32 dfa19_T67[] =
1365
    {
1366
	111
1367
    };
1368
1369
static const ANTLR3_INT32 dfa19_T68[] =
1370
    {
1371
	138
1372
    };
1373
1374
static const ANTLR3_INT32 dfa19_T69[] =
1375
    {
1376
	165
1377
    };
1378
1379
static const ANTLR3_INT32 dfa19_T70[] =
1380
    {
1381
	192
1382
    };
1383
1384
static const ANTLR3_INT32 dfa19_T71[] =
1385
    {
1386
	214
1387
    };
1388
1389
static const ANTLR3_INT32 dfa19_T72[] =
1390
    {
1391
	49, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1392
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1393
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1394
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1395
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 48
1396
    };
1397
1398
static const ANTLR3_INT32 dfa19_T73[] =
1399
    {
1400
	109, 110
1401
    };
1402
1403
static const ANTLR3_INT32 dfa19_T74[] =
1404
    {
1405
	30, 30, 30, 30, 30, 30, 30, 30, 30, 30, -1, -1, -1, -1, -1, -1, -1, 30,
1406
	30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
1407
	30, 30, 30, 30, 30, 30, 30, -1, -1, -1, -1, 30, -1, 30, 30, 30, 30, 30,
1408
	30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
1409
	30, 30, 30
1410
    };
1411
1412
static const ANTLR3_INT32 dfa19_T75[] =
1413
    {
1414
	83, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84
1415
    };
1416
1417
static const ANTLR3_INT32 dfa19_T76[] =
1418
    {
1419
	72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
1420
	72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
1421
	72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
1422
	72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 71, 71, 71, 71, 71, 71, 71,
1423
	71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
1424
	71, 72, 72, 72, 72
1425
    };
1426
1427
static const ANTLR3_INT32 dfa19_T77[] =
1428
    {
1429
	68, -1, 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1430
	-1, 69
1431
    };
1432
1433
static const ANTLR3_INT32 dfa19_T78[] =
1434
    {
1435
	102, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 103
1436
    };
1437
1438
static const ANTLR3_INT32 dfa19_T79[] =
1439
    {
1440
	51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1441
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 52
1442
    };
1443
1444
static const ANTLR3_INT32 dfa19_T80[] =
1445
    {
1446
	114
1447
    };
1448
1449
static const ANTLR3_INT32 dfa19_T81[] =
1450
    {
1451
	141
1452
    };
1453
1454
static const ANTLR3_INT32 dfa19_T82[] =
1455
    {
1456
	168
1457
    };
1458
1459
static const ANTLR3_INT32 dfa19_T83[] =
1460
    {
1461
	72, 72, 72, 72, 72, 72, 72, 99, 72, 72, 72, 72, 72, 72, 72, 72, 98, 98,
1462
	98, 98, 98, 98, 98, 98, 98, 98, 72, 72, 72, 72, 72, 72, 72, 98, 98, 98,
1463
	98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
1464
	98, 98, 98, 98, 98, 72, 72, 72, 72, 100, 72, 100, 100, 100, 100, 100, 100,
1465
	100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
1466
	100, 100, 100, 100, 100, 72, 72, 72, 72
1467
    };
1468
1469
static const ANTLR3_INT32 dfa19_T84[] =
1470
    {
1471
	115
1472
    };
1473
1474
static const ANTLR3_INT32 dfa19_T85[] =
1475
    {
1476
	117
1477
    };
1478
1479
static const ANTLR3_INT32 dfa19_T86[] =
1480
    {
1481
	144, -1, -1, -1, -1, -1, -1, -1, -1, 145
1482
    };
1483
1484
static const ANTLR3_INT32 dfa19_T87[] =
1485
    {
1486
	106
1487
    };
1488
1489
static const ANTLR3_INT32 dfa19_T88[] =
1490
    {
1491
	116
1492
    };
1493
1494
static const ANTLR3_INT32 dfa19_T89[] =
1495
    {
1496
	132
1497
    };
1498
1499
static const ANTLR3_INT32 dfa19_T90[] =
1500
    {
1501
	143
1502
    };
1503
1504
static const ANTLR3_INT32 dfa19_T91[] =
1505
    {
1506
	169
1507
    };
1508
1509
static const ANTLR3_INT32 dfa19_T92[] =
1510
    {
1511
	156
1512
    };
1513
1514
static const ANTLR3_INT32 dfa19_T93[] =
1515
    {
1516
	182
1517
    };
1518
1519
static const ANTLR3_INT32 dfa19_T94[] =
1520
    {
1521
	59, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1522
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1523
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1524
	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 60
1525
    };
1526
1527
static const ANTLR3_INT32 dfa19_T95[] =
1528
    {
1529
	206
1530
    };
1531
1532
static const ANTLR3_INT32 dfa19_T96[] =
1533
    {
1534
	170
1535
    };
1536
1537
static const ANTLR3_INT32 dfa19_T97[] =
1538
    {
1539
	197
1540
    };
1541
1542
static const ANTLR3_INT32 dfa19_T98[] =
1543
    {
1544
	56, -1, 57
1545
    };
1546
1547
static const ANTLR3_INT32 dfa19_T99[] =
1548
    {
1549
	61
1550
    };
1551
1552
static const ANTLR3_INT32 dfa19_T100[] =
1553
    {
1554
	171, -1, -1, -1, 172
1555
    };
1556
1557
static const ANTLR3_INT32 dfa19_T101[] =
1558
    {
1559
	198
1560
    };
1561
1562
static const ANTLR3_INT32 dfa19_T102[] =
1563
    {
1564
	65
1565
    };
1566
1567
static const ANTLR3_INT32 dfa19_T103[] =
1568
    {
1569
	66
1570
    };
1571
1572
static const ANTLR3_INT32 dfa19_T104[] =
1573
    {
1574
	199
1575
    };
1576
1577
static const ANTLR3_INT32 dfa19_T105[] =
1578
    {
1579
	219
1580
    };
1581
1582
static const ANTLR3_INT32 dfa19_T106[] =
1583
    {
1584
	112
1585
    };
1586
1587
static const ANTLR3_INT32 dfa19_T107[] =
1588
    {
1589
	81
1590
    };
1591
1592
static const ANTLR3_INT32 dfa19_T108[] =
1593
    {
1594
	139
1595
    };
1596
1597
static const ANTLR3_INT32 dfa19_T109[] =
1598
    {
1599
	166
1600
    };
1601
1602
static const ANTLR3_INT32 dfa19_T110[] =
1603
    {
1604
	173
1605
    };
1606
1607
static const ANTLR3_INT32 dfa19_T111[] =
1608
    {
1609
	200
1610
    };
1611
1612
static const ANTLR3_INT32 dfa19_T112[] =
1613
    {
1614
	220
1615
    };
1616
1617
static const ANTLR3_INT32 dfa19_T113[] =
1618
    {
1619
	232
1620
    };
1621
1622
static const ANTLR3_INT32 dfa19_T114[] =
1623
    {
1624
	107
1625
    };
1626
1627
static const ANTLR3_INT32 dfa19_T115[] =
1628
    {
1629
	193
1630
    };
1631
1632
static const ANTLR3_INT32 dfa19_T116[] =
1633
    {
1634
	133, -1, -1, -1, -1, -1, -1, -1, -1, 134
1635
    };
1636
1637
static const ANTLR3_INT32 dfa19_T117[] =
1638
    {
1639
	215
1640
    };
1641
1642
static const ANTLR3_INT32 dfa19_T118[] =
1643
    {
1644
	119
1645
    };
1646
1647
static const ANTLR3_INT32 dfa19_T119[] =
1648
    {
1649
	45, 45, 33, 34, 45, 35, 36, 45, 37, 45, 45, 38, 45, 45, 45, 39, 40, 41,
1650
	42, 43, 44, 45, 45, 45, 45, 45
1651
    };
1652
1653
static const ANTLR3_INT32 dfa19_T120[] =
1654
    {
1655
	148
1656
    };
1657
1658
static const ANTLR3_INT32 dfa19_T121[] =
1659
    {
1660
	70
1661
    };
1662
1663
static const ANTLR3_INT32 dfa19_T122[] =
1664
    {
1665
	175
1666
    };
1667
1668
static const ANTLR3_INT32 dfa19_T123[] =
1669
    {
1670
	229
1671
    };
1672
1673
static const ANTLR3_INT32 dfa19_T124[] =
1674
    {
1675
	201
1676
    };
1677
1678
static const ANTLR3_INT32 dfa19_T125[] =
1679
    {
1680
	80
1681
    };
1682
1683
static const ANTLR3_INT32 dfa19_T126[] =
1684
    {
1685
	76, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 75
1686
    };
1687
1688
static const ANTLR3_INT32 dfa19_T127[] =
1689
    {
1690
	108
1691
    };
1692
1693
static const ANTLR3_INT32 dfa19_T128[] =
1694
    {
1695
	135
1696
    };
1697
1698
static const ANTLR3_INT32 dfa19_T129[] =
1699
    {
1700
	159, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 160
1701
    };
1702
1703
static const ANTLR3_INT32 dfa19_T130[] =
1704
    {
1705
	74
1706
    };
1707
1708
static const ANTLR3_INT32 dfa19_T131[] =
1709
    {
1710
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, -1, -1, -1, 45,
1711
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1712
	45, 45, 45, 45, 45, 45, 45, -1, -1, -1, -1, 45, -1, 45, 45, 45, 45, 226,
1713
	45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1714
	45, 45, 45
1715
    };
1716
1717
static const ANTLR3_INT32 dfa19_T132[] =
1718
    {
1719
	136
1720
    };
1721
1722
static const ANTLR3_INT32 dfa19_T133[] =
1723
    {
1724
	85
1725
    };
1726
1727
static const ANTLR3_INT32 dfa19_T134[] =
1728
    {
1729
	77
1730
    };
1731
1732
static const ANTLR3_INT32 dfa19_T135[] =
1733
    {
1734
	188, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 189
1735
    };
1736
1737
static const ANTLR3_INT32 dfa19_T136[] =
1738
    {
1739
	46
1740
    };
1741
1742
1743
/* Transition tables are a table of sub tables, with some tables
1744
 * reused for efficiency.
1745
 */
1746
static const ANTLR3_INT32 * const dfa19_transitions[] =
1747
{
1748
    dfa19_T30, dfa19_T119, NULL, NULL, NULL, NULL, NULL, NULL, NULL, dfa19_T136,
1749
    NULL, dfa19_T72, dfa19_T79, dfa19_T46, NULL, dfa19_T98, NULL, dfa19_T94,
1750
    dfa19_T99, NULL, dfa19_T40, dfa19_T40, dfa19_T102, dfa19_T103, dfa19_T77,
1751
    dfa19_T121, NULL, NULL, dfa19_T76, NULL, NULL, NULL, NULL, dfa19_T66,
1752
    dfa19_T130, dfa19_T126, dfa19_T134, dfa19_T32, dfa19_T125, dfa19_T107,
1753
    dfa19_T0, dfa19_T75, dfa19_T133, dfa19_T35, dfa19_T9, NULL, NULL, NULL,
1754
    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, dfa19_T57,
1755
    NULL, NULL, NULL, NULL, NULL, dfa19_T54, dfa19_T55, dfa19_T56, dfa19_T58,
1756
    dfa19_T59, dfa19_T61, dfa19_T83, NULL, dfa19_T10, dfa19_T78, dfa19_T28,
1757
    dfa19_T1, dfa19_T87, dfa19_T114, dfa19_T127, dfa19_T73, dfa19_T67, dfa19_T106,
1758
    dfa19_T41, dfa19_T80, dfa19_T84, dfa19_T88, dfa19_T85, dfa19_T2, dfa19_T118,
1759
    NULL, NULL, dfa19_T74, dfa19_T74, dfa19_T74, dfa19_T74, dfa19_T60, dfa19_T62,
1760
    dfa19_T83, NULL, dfa19_T83, dfa19_T11, dfa19_T15, dfa19_T22, dfa19_T29,
1761
    dfa19_T3, dfa19_T89, dfa19_T116, dfa19_T128, dfa19_T132, dfa19_T48,
1762
    dfa19_T68, dfa19_T108, dfa19_T42, dfa19_T81, dfa19_T4, dfa19_T90, dfa19_T86,
1763
    dfa19_T5, dfa19_T120, NULL, NULL, NULL, NULL, dfa19_T74, dfa19_T63,
1764
    NULL, dfa19_T12, dfa19_T16, dfa19_T23, dfa19_T31, dfa19_T6, dfa19_T92,
1765
    dfa19_T36, dfa19_T38, dfa19_T129, dfa19_T33, dfa19_T51, dfa19_T69, dfa19_T109,
1766
    dfa19_T43, dfa19_T82, NULL, dfa19_T91, dfa19_T96, dfa19_T100, dfa19_T110,
1767
    dfa19_T4, dfa19_T122, NULL, dfa19_T64, dfa19_T13, dfa19_T17, dfa19_T24,
1768
    dfa19_T4, dfa19_T4, dfa19_T93, dfa19_T37, dfa19_T39, dfa19_T4, dfa19_T4,
1769
    dfa19_T53, NULL, dfa19_T135, dfa19_T8, dfa19_T70, dfa19_T115, dfa19_T44,
1770
    dfa19_T4, dfa19_T4, dfa19_T97, dfa19_T101, dfa19_T104, dfa19_T111, NULL,
1771
    dfa19_T124, dfa19_T65, dfa19_T14, dfa19_T18, dfa19_T25, NULL, NULL,
1772
    dfa19_T95, dfa19_T4, dfa19_T4, NULL, NULL, dfa19_T4, dfa19_T4, dfa19_T4,
1773
    dfa19_T4, dfa19_T4, dfa19_T71, dfa19_T117, dfa19_T45, NULL, NULL, dfa19_T4,
1774
    dfa19_T4, dfa19_T105, dfa19_T112, dfa19_T4, dfa19_T74, dfa19_T4, dfa19_T19,
1775
    dfa19_T26, dfa19_T131, NULL, NULL, NULL, NULL, NULL, NULL, NULL, dfa19_T4,
1776
    dfa19_T123, dfa19_T47, NULL, NULL, dfa19_T4, dfa19_T113, NULL, NULL,
1777
    NULL, dfa19_T20, dfa19_T4, dfa19_T34, NULL, NULL, dfa19_T27, dfa19_T49,
1778
    NULL, dfa19_T4, dfa19_T21, NULL, dfa19_T4, dfa19_T7, NULL, dfa19_T50,
1779
    NULL, dfa19_T4, NULL, dfa19_T4, dfa19_T4, dfa19_T4, dfa19_T52, NULL,
1780
    NULL, NULL, NULL, dfa19_T4, dfa19_T4, dfa19_T4, NULL, NULL, NULL
1781
};
1782
1783
1784
/* Declare tracking structure for Cyclic DFA 19
1785
 */
1786
static
1787
ANTLR3_CYCLIC_DFA cdfa19
1788
    =	{
1789
	    19,		    /* Decision number of this dfa	    */
1790
	    /* Which decision this represents:   */
1791
	    (const pANTLR3_UCHAR)"1:1: Tokens : ( T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | COMMA_TOK | DOT_TOK | LPAREN_TOK | RPAREN_TOK | LBRACK_TOK | RBRACK_TOK | COLON_TOK | ARROW_TOK | SUBTYPE_TOK | OR_TOK | NOT_TOK | FORALL_TOK | EXISTS_TOK | LAMBDA_TOK | CHOICE_TOK | DEF_DESC_TOK | AND_TOK | IFF_TOK | IMPLIES_TOK | REVIMPLIES_TOK | REVIFF_TOK | REVOR_TOK | REVAND_TOK | TIMES_TOK | PLUS_TOK | MINUS_TOK | APP_TOK | TH1_UN_A | TH1_UN_E | TRUE_TOK | FALSE_TOK | EQUAL_TOK | DISEQUAL_TOK | CNF_TOK | FOF_TOK | THF_TOK | TFF_TOK | TYPE_TOK | INCLUDE_TOK | DEFINED_SYMBOL | WHITESPACE | DISTINCT_OBJECT | LOWER_WORD_SINGLE_QUOTED | SINGLE_QUOTED | UPPER_WORD | LOWER_WORD | NUMBER | COMMENT );",
1792
	    (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,	/* Default special state transition function	*/
1793
1794
	    antlr3dfaspecialTransition,		/* DFA specialTransition is currently just a default function in the runtime */
1795
	    antlr3dfapredict,			/* DFA simulator function is in the runtime */
1796
	    dfa19_eot,	    /* EOT table			    */
1797
	    dfa19_eof,	    /* EOF table			    */
1798
	    dfa19_min,	    /* Minimum tokens for each state    */
1799
	    dfa19_max,	    /* Maximum tokens for each state    */
1800
	    dfa19_accept,	/* Accept table			    */
1801
	    dfa19_special,	/* Special transition states	    */
1802
	    dfa19_transitions	/* Table of transition tables	    */
1803
1804
	};
1805
/* End of Cyclic DFA 19
1806
 * ---------------------
1807
 */
1808
/* =========================================================================
1809
 * End of DFA tables for the lexer
1810
 */
1811
1812
/* =========================================================================
1813
 * Functions to match the lexer grammar defined tokens from the input stream
1814
 */
1815
1816
//   Comes from: 48:7: ( '$ceiling' )
1817
/** \brief Lexer rule generated by ANTLR3
1818
 *
1819
 * $ANTLR start T__63
1820
 *
1821
 * Looks to match the characters the constitute the token T__63
1822
 * from the attached input stream.
1823
 *
1824
 *
1825
 * \remark
1826
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1827
 */
1828
static ANTLR3_INLINE
1829
3
void mT__63(pTptpLexer ctx)
1830
{
1831
	ANTLR3_UINT32	_type;
1832
1833
3
    _type	    = T__63;
1834
1835
1836
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:48:7: ( '$ceiling' )
1837
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:48:9: '$ceiling'
1838
    {
1839
3
        MATCHS(lit_1);
1840
3
        if  (HASEXCEPTION())
1841
        {
1842
            goto ruleT__63Ex;
1843
        }
1844
1845
1846
1847
1848
    }
1849
1850
3
	LEXSTATE->type = _type;
1851
    // This is where rules clean up and exit
1852
    //
1853
3
    goto ruleT__63Ex; /* Prevent compiler warnings */
1854
3
    ruleT__63Ex: ;
1855
1856
3
}
1857
// $ANTLR end T__63
1858
1859
//   Comes from: 49:7: ( '$difference' )
1860
/** \brief Lexer rule generated by ANTLR3
1861
 *
1862
 * $ANTLR start T__64
1863
 *
1864
 * Looks to match the characters the constitute the token T__64
1865
 * from the attached input stream.
1866
 *
1867
 *
1868
 * \remark
1869
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1870
 */
1871
static ANTLR3_INLINE
1872
3
void mT__64(pTptpLexer ctx)
1873
{
1874
	ANTLR3_UINT32	_type;
1875
1876
3
    _type	    = T__64;
1877
1878
1879
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:49:7: ( '$difference' )
1880
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:49:9: '$difference'
1881
    {
1882
3
        MATCHS(lit_2);
1883
3
        if  (HASEXCEPTION())
1884
        {
1885
            goto ruleT__64Ex;
1886
        }
1887
1888
1889
1890
1891
    }
1892
1893
3
	LEXSTATE->type = _type;
1894
    // This is where rules clean up and exit
1895
    //
1896
3
    goto ruleT__64Ex; /* Prevent compiler warnings */
1897
3
    ruleT__64Ex: ;
1898
1899
3
}
1900
// $ANTLR end T__64
1901
1902
//   Comes from: 50:7: ( '$distinct' )
1903
/** \brief Lexer rule generated by ANTLR3
1904
 *
1905
 * $ANTLR start T__65
1906
 *
1907
 * Looks to match the characters the constitute the token T__65
1908
 * from the attached input stream.
1909
 *
1910
 *
1911
 * \remark
1912
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1913
 */
1914
static ANTLR3_INLINE
1915
void mT__65(pTptpLexer ctx)
1916
{
1917
	ANTLR3_UINT32	_type;
1918
1919
    _type	    = T__65;
1920
1921
1922
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:50:7: ( '$distinct' )
1923
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:50:9: '$distinct'
1924
    {
1925
        MATCHS(lit_3);
1926
        if  (HASEXCEPTION())
1927
        {
1928
            goto ruleT__65Ex;
1929
        }
1930
1931
1932
1933
1934
    }
1935
1936
	LEXSTATE->type = _type;
1937
    // This is where rules clean up and exit
1938
    //
1939
    goto ruleT__65Ex; /* Prevent compiler warnings */
1940
    ruleT__65Ex: ;
1941
1942
}
1943
// $ANTLR end T__65
1944
1945
//   Comes from: 51:7: ( '$floor' )
1946
/** \brief Lexer rule generated by ANTLR3
1947
 *
1948
 * $ANTLR start T__66
1949
 *
1950
 * Looks to match the characters the constitute the token T__66
1951
 * from the attached input stream.
1952
 *
1953
 *
1954
 * \remark
1955
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1956
 */
1957
static ANTLR3_INLINE
1958
3
void mT__66(pTptpLexer ctx)
1959
{
1960
	ANTLR3_UINT32	_type;
1961
1962
3
    _type	    = T__66;
1963
1964
1965
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:51:7: ( '$floor' )
1966
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:51:9: '$floor'
1967
    {
1968
3
        MATCHS(lit_4);
1969
3
        if  (HASEXCEPTION())
1970
        {
1971
            goto ruleT__66Ex;
1972
        }
1973
1974
1975
1976
1977
    }
1978
1979
3
	LEXSTATE->type = _type;
1980
    // This is where rules clean up and exit
1981
    //
1982
3
    goto ruleT__66Ex; /* Prevent compiler warnings */
1983
3
    ruleT__66Ex: ;
1984
1985
3
}
1986
// $ANTLR end T__66
1987
1988
//   Comes from: 52:7: ( '$greater' )
1989
/** \brief Lexer rule generated by ANTLR3
1990
 *
1991
 * $ANTLR start T__67
1992
 *
1993
 * Looks to match the characters the constitute the token T__67
1994
 * from the attached input stream.
1995
 *
1996
 *
1997
 * \remark
1998
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
1999
 */
2000
static ANTLR3_INLINE
2001
4
void mT__67(pTptpLexer ctx)
2002
{
2003
	ANTLR3_UINT32	_type;
2004
2005
4
    _type	    = T__67;
2006
2007
2008
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:52:7: ( '$greater' )
2009
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:52:9: '$greater'
2010
    {
2011
4
        MATCHS(lit_5);
2012
4
        if  (HASEXCEPTION())
2013
        {
2014
            goto ruleT__67Ex;
2015
        }
2016
2017
2018
2019
2020
    }
2021
2022
4
	LEXSTATE->type = _type;
2023
    // This is where rules clean up and exit
2024
    //
2025
4
    goto ruleT__67Ex; /* Prevent compiler warnings */
2026
4
    ruleT__67Ex: ;
2027
2028
4
}
2029
// $ANTLR end T__67
2030
2031
//   Comes from: 53:7: ( '$greatereq' )
2032
/** \brief Lexer rule generated by ANTLR3
2033
 *
2034
 * $ANTLR start T__68
2035
 *
2036
 * Looks to match the characters the constitute the token T__68
2037
 * from the attached input stream.
2038
 *
2039
 *
2040
 * \remark
2041
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2042
 */
2043
static ANTLR3_INLINE
2044
4
void mT__68(pTptpLexer ctx)
2045
{
2046
	ANTLR3_UINT32	_type;
2047
2048
4
    _type	    = T__68;
2049
2050
2051
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:53:7: ( '$greatereq' )
2052
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:53:9: '$greatereq'
2053
    {
2054
4
        MATCHS(lit_6);
2055
4
        if  (HASEXCEPTION())
2056
        {
2057
            goto ruleT__68Ex;
2058
        }
2059
2060
2061
2062
2063
    }
2064
2065
4
	LEXSTATE->type = _type;
2066
    // This is where rules clean up and exit
2067
    //
2068
4
    goto ruleT__68Ex; /* Prevent compiler warnings */
2069
4
    ruleT__68Ex: ;
2070
2071
4
}
2072
// $ANTLR end T__68
2073
2074
//   Comes from: 54:7: ( '$is_int' )
2075
/** \brief Lexer rule generated by ANTLR3
2076
 *
2077
 * $ANTLR start T__69
2078
 *
2079
 * Looks to match the characters the constitute the token T__69
2080
 * from the attached input stream.
2081
 *
2082
 *
2083
 * \remark
2084
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2085
 */
2086
static ANTLR3_INLINE
2087
3
void mT__69(pTptpLexer ctx)
2088
{
2089
	ANTLR3_UINT32	_type;
2090
2091
3
    _type	    = T__69;
2092
2093
2094
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:54:7: ( '$is_int' )
2095
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:54:9: '$is_int'
2096
    {
2097
3
        MATCHS(lit_7);
2098
3
        if  (HASEXCEPTION())
2099
        {
2100
            goto ruleT__69Ex;
2101
        }
2102
2103
2104
2105
2106
    }
2107
2108
3
	LEXSTATE->type = _type;
2109
    // This is where rules clean up and exit
2110
    //
2111
3
    goto ruleT__69Ex; /* Prevent compiler warnings */
2112
3
    ruleT__69Ex: ;
2113
2114
3
}
2115
// $ANTLR end T__69
2116
2117
//   Comes from: 55:7: ( '$is_rat' )
2118
/** \brief Lexer rule generated by ANTLR3
2119
 *
2120
 * $ANTLR start T__70
2121
 *
2122
 * Looks to match the characters the constitute the token T__70
2123
 * from the attached input stream.
2124
 *
2125
 *
2126
 * \remark
2127
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2128
 */
2129
static ANTLR3_INLINE
2130
3
void mT__70(pTptpLexer ctx)
2131
{
2132
	ANTLR3_UINT32	_type;
2133
2134
3
    _type	    = T__70;
2135
2136
2137
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:55:7: ( '$is_rat' )
2138
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:55:9: '$is_rat'
2139
    {
2140
3
        MATCHS(lit_8);
2141
3
        if  (HASEXCEPTION())
2142
        {
2143
            goto ruleT__70Ex;
2144
        }
2145
2146
2147
2148
2149
    }
2150
2151
3
	LEXSTATE->type = _type;
2152
    // This is where rules clean up and exit
2153
    //
2154
3
    goto ruleT__70Ex; /* Prevent compiler warnings */
2155
3
    ruleT__70Ex: ;
2156
2157
3
}
2158
// $ANTLR end T__70
2159
2160
//   Comes from: 56:7: ( '$ite_f' )
2161
/** \brief Lexer rule generated by ANTLR3
2162
 *
2163
 * $ANTLR start T__71
2164
 *
2165
 * Looks to match the characters the constitute the token T__71
2166
 * from the attached input stream.
2167
 *
2168
 *
2169
 * \remark
2170
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2171
 */
2172
static ANTLR3_INLINE
2173
2
void mT__71(pTptpLexer ctx)
2174
{
2175
	ANTLR3_UINT32	_type;
2176
2177
2
    _type	    = T__71;
2178
2179
2180
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:56:7: ( '$ite_f' )
2181
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:56:9: '$ite_f'
2182
    {
2183
2
        MATCHS(lit_9);
2184
2
        if  (HASEXCEPTION())
2185
        {
2186
            goto ruleT__71Ex;
2187
        }
2188
2189
2190
2191
2192
    }
2193
2194
2
	LEXSTATE->type = _type;
2195
    // This is where rules clean up and exit
2196
    //
2197
2
    goto ruleT__71Ex; /* Prevent compiler warnings */
2198
2
    ruleT__71Ex: ;
2199
2200
2
}
2201
// $ANTLR end T__71
2202
2203
//   Comes from: 57:7: ( '$ite_t' )
2204
/** \brief Lexer rule generated by ANTLR3
2205
 *
2206
 * $ANTLR start T__72
2207
 *
2208
 * Looks to match the characters the constitute the token T__72
2209
 * from the attached input stream.
2210
 *
2211
 *
2212
 * \remark
2213
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2214
 */
2215
static ANTLR3_INLINE
2216
2
void mT__72(pTptpLexer ctx)
2217
{
2218
	ANTLR3_UINT32	_type;
2219
2220
2
    _type	    = T__72;
2221
2222
2223
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:57:7: ( '$ite_t' )
2224
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:57:9: '$ite_t'
2225
    {
2226
2
        MATCHS(lit_10);
2227
2
        if  (HASEXCEPTION())
2228
        {
2229
            goto ruleT__72Ex;
2230
        }
2231
2232
2233
2234
2235
    }
2236
2237
2
	LEXSTATE->type = _type;
2238
    // This is where rules clean up and exit
2239
    //
2240
2
    goto ruleT__72Ex; /* Prevent compiler warnings */
2241
2
    ruleT__72Ex: ;
2242
2243
2
}
2244
// $ANTLR end T__72
2245
2246
//   Comes from: 58:7: ( '$less' )
2247
/** \brief Lexer rule generated by ANTLR3
2248
 *
2249
 * $ANTLR start T__73
2250
 *
2251
 * Looks to match the characters the constitute the token T__73
2252
 * from the attached input stream.
2253
 *
2254
 *
2255
 * \remark
2256
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2257
 */
2258
static ANTLR3_INLINE
2259
7
void mT__73(pTptpLexer ctx)
2260
{
2261
	ANTLR3_UINT32	_type;
2262
2263
7
    _type	    = T__73;
2264
2265
2266
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:58:7: ( '$less' )
2267
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:58:9: '$less'
2268
    {
2269
7
        MATCHS(lit_11);
2270
7
        if  (HASEXCEPTION())
2271
        {
2272
            goto ruleT__73Ex;
2273
        }
2274
2275
2276
2277
2278
    }
2279
2280
7
	LEXSTATE->type = _type;
2281
    // This is where rules clean up and exit
2282
    //
2283
7
    goto ruleT__73Ex; /* Prevent compiler warnings */
2284
7
    ruleT__73Ex: ;
2285
2286
7
}
2287
// $ANTLR end T__73
2288
2289
//   Comes from: 59:7: ( '$lesseq' )
2290
/** \brief Lexer rule generated by ANTLR3
2291
 *
2292
 * $ANTLR start T__74
2293
 *
2294
 * Looks to match the characters the constitute the token T__74
2295
 * from the attached input stream.
2296
 *
2297
 *
2298
 * \remark
2299
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2300
 */
2301
static ANTLR3_INLINE
2302
3
void mT__74(pTptpLexer ctx)
2303
{
2304
	ANTLR3_UINT32	_type;
2305
2306
3
    _type	    = T__74;
2307
2308
2309
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:59:7: ( '$lesseq' )
2310
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:59:9: '$lesseq'
2311
    {
2312
3
        MATCHS(lit_12);
2313
3
        if  (HASEXCEPTION())
2314
        {
2315
            goto ruleT__74Ex;
2316
        }
2317
2318
2319
2320
2321
    }
2322
2323
3
	LEXSTATE->type = _type;
2324
    // This is where rules clean up and exit
2325
    //
2326
3
    goto ruleT__74Ex; /* Prevent compiler warnings */
2327
3
    ruleT__74Ex: ;
2328
2329
3
}
2330
// $ANTLR end T__74
2331
2332
//   Comes from: 60:7: ( '$let_ff' )
2333
/** \brief Lexer rule generated by ANTLR3
2334
 *
2335
 * $ANTLR start T__75
2336
 *
2337
 * Looks to match the characters the constitute the token T__75
2338
 * from the attached input stream.
2339
 *
2340
 *
2341
 * \remark
2342
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2343
 */
2344
static ANTLR3_INLINE
2345
1
void mT__75(pTptpLexer ctx)
2346
{
2347
	ANTLR3_UINT32	_type;
2348
2349
1
    _type	    = T__75;
2350
2351
2352
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:60:7: ( '$let_ff' )
2353
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:60:9: '$let_ff'
2354
    {
2355
1
        MATCHS(lit_13);
2356
1
        if  (HASEXCEPTION())
2357
        {
2358
            goto ruleT__75Ex;
2359
        }
2360
2361
2362
2363
2364
    }
2365
2366
1
	LEXSTATE->type = _type;
2367
    // This is where rules clean up and exit
2368
    //
2369
1
    goto ruleT__75Ex; /* Prevent compiler warnings */
2370
1
    ruleT__75Ex: ;
2371
2372
1
}
2373
// $ANTLR end T__75
2374
2375
//   Comes from: 61:7: ( '$let_ft' )
2376
/** \brief Lexer rule generated by ANTLR3
2377
 *
2378
 * $ANTLR start T__76
2379
 *
2380
 * Looks to match the characters the constitute the token T__76
2381
 * from the attached input stream.
2382
 *
2383
 *
2384
 * \remark
2385
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2386
 */
2387
static ANTLR3_INLINE
2388
1
void mT__76(pTptpLexer ctx)
2389
{
2390
	ANTLR3_UINT32	_type;
2391
2392
1
    _type	    = T__76;
2393
2394
2395
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:61:7: ( '$let_ft' )
2396
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:61:9: '$let_ft'
2397
    {
2398
1
        MATCHS(lit_14);
2399
1
        if  (HASEXCEPTION())
2400
        {
2401
            goto ruleT__76Ex;
2402
        }
2403
2404
2405
2406
2407
    }
2408
2409
1
	LEXSTATE->type = _type;
2410
    // This is where rules clean up and exit
2411
    //
2412
1
    goto ruleT__76Ex; /* Prevent compiler warnings */
2413
1
    ruleT__76Ex: ;
2414
2415
1
}
2416
// $ANTLR end T__76
2417
2418
//   Comes from: 62:7: ( '$let_tf' )
2419
/** \brief Lexer rule generated by ANTLR3
2420
 *
2421
 * $ANTLR start T__77
2422
 *
2423
 * Looks to match the characters the constitute the token T__77
2424
 * from the attached input stream.
2425
 *
2426
 *
2427
 * \remark
2428
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2429
 */
2430
static ANTLR3_INLINE
2431
void mT__77(pTptpLexer ctx)
2432
{
2433
	ANTLR3_UINT32	_type;
2434
2435
    _type	    = T__77;
2436
2437
2438
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:62:7: ( '$let_tf' )
2439
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:62:9: '$let_tf'
2440
    {
2441
        MATCHS(lit_15);
2442
        if  (HASEXCEPTION())
2443
        {
2444
            goto ruleT__77Ex;
2445
        }
2446
2447
2448
2449
2450
    }
2451
2452
	LEXSTATE->type = _type;
2453
    // This is where rules clean up and exit
2454
    //
2455
    goto ruleT__77Ex; /* Prevent compiler warnings */
2456
    ruleT__77Ex: ;
2457
2458
}
2459
// $ANTLR end T__77
2460
2461
//   Comes from: 63:7: ( '$let_tt' )
2462
/** \brief Lexer rule generated by ANTLR3
2463
 *
2464
 * $ANTLR start T__78
2465
 *
2466
 * Looks to match the characters the constitute the token T__78
2467
 * from the attached input stream.
2468
 *
2469
 *
2470
 * \remark
2471
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2472
 */
2473
static ANTLR3_INLINE
2474
1
void mT__78(pTptpLexer ctx)
2475
{
2476
	ANTLR3_UINT32	_type;
2477
2478
1
    _type	    = T__78;
2479
2480
2481
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:63:7: ( '$let_tt' )
2482
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:63:9: '$let_tt'
2483
    {
2484
1
        MATCHS(lit_16);
2485
1
        if  (HASEXCEPTION())
2486
        {
2487
            goto ruleT__78Ex;
2488
        }
2489
2490
2491
2492
2493
    }
2494
2495
1
	LEXSTATE->type = _type;
2496
    // This is where rules clean up and exit
2497
    //
2498
1
    goto ruleT__78Ex; /* Prevent compiler warnings */
2499
1
    ruleT__78Ex: ;
2500
2501
1
}
2502
// $ANTLR end T__78
2503
2504
//   Comes from: 64:7: ( '$product' )
2505
/** \brief Lexer rule generated by ANTLR3
2506
 *
2507
 * $ANTLR start T__79
2508
 *
2509
 * Looks to match the characters the constitute the token T__79
2510
 * from the attached input stream.
2511
 *
2512
 *
2513
 * \remark
2514
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2515
 */
2516
static ANTLR3_INLINE
2517
3
void mT__79(pTptpLexer ctx)
2518
{
2519
	ANTLR3_UINT32	_type;
2520
2521
3
    _type	    = T__79;
2522
2523
2524
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:64:7: ( '$product' )
2525
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:64:9: '$product'
2526
    {
2527
3
        MATCHS(lit_17);
2528
3
        if  (HASEXCEPTION())
2529
        {
2530
            goto ruleT__79Ex;
2531
        }
2532
2533
2534
2535
2536
    }
2537
2538
3
	LEXSTATE->type = _type;
2539
    // This is where rules clean up and exit
2540
    //
2541
3
    goto ruleT__79Ex; /* Prevent compiler warnings */
2542
3
    ruleT__79Ex: ;
2543
2544
3
}
2545
// $ANTLR end T__79
2546
2547
//   Comes from: 65:7: ( '$quotient' )
2548
/** \brief Lexer rule generated by ANTLR3
2549
 *
2550
 * $ANTLR start T__80
2551
 *
2552
 * Looks to match the characters the constitute the token T__80
2553
 * from the attached input stream.
2554
 *
2555
 *
2556
 * \remark
2557
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2558
 */
2559
static ANTLR3_INLINE
2560
3
void mT__80(pTptpLexer ctx)
2561
{
2562
	ANTLR3_UINT32	_type;
2563
2564
3
    _type	    = T__80;
2565
2566
2567
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:65:7: ( '$quotient' )
2568
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:65:9: '$quotient'
2569
    {
2570
3
        MATCHS(lit_18);
2571
3
        if  (HASEXCEPTION())
2572
        {
2573
            goto ruleT__80Ex;
2574
        }
2575
2576
2577
2578
2579
    }
2580
2581
3
	LEXSTATE->type = _type;
2582
    // This is where rules clean up and exit
2583
    //
2584
3
    goto ruleT__80Ex; /* Prevent compiler warnings */
2585
3
    ruleT__80Ex: ;
2586
2587
3
}
2588
// $ANTLR end T__80
2589
2590
//   Comes from: 66:7: ( '$quotient_e' )
2591
/** \brief Lexer rule generated by ANTLR3
2592
 *
2593
 * $ANTLR start T__81
2594
 *
2595
 * Looks to match the characters the constitute the token T__81
2596
 * from the attached input stream.
2597
 *
2598
 *
2599
 * \remark
2600
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2601
 */
2602
static ANTLR3_INLINE
2603
3
void mT__81(pTptpLexer ctx)
2604
{
2605
	ANTLR3_UINT32	_type;
2606
2607
3
    _type	    = T__81;
2608
2609
2610
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:66:7: ( '$quotient_e' )
2611
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:66:9: '$quotient_e'
2612
    {
2613
3
        MATCHS(lit_19);
2614
3
        if  (HASEXCEPTION())
2615
        {
2616
            goto ruleT__81Ex;
2617
        }
2618
2619
2620
2621
2622
    }
2623
2624
3
	LEXSTATE->type = _type;
2625
    // This is where rules clean up and exit
2626
    //
2627
3
    goto ruleT__81Ex; /* Prevent compiler warnings */
2628
3
    ruleT__81Ex: ;
2629
2630
3
}
2631
// $ANTLR end T__81
2632
2633
//   Comes from: 67:7: ( '$quotient_f' )
2634
/** \brief Lexer rule generated by ANTLR3
2635
 *
2636
 * $ANTLR start T__82
2637
 *
2638
 * Looks to match the characters the constitute the token T__82
2639
 * from the attached input stream.
2640
 *
2641
 *
2642
 * \remark
2643
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2644
 */
2645
static ANTLR3_INLINE
2646
3
void mT__82(pTptpLexer ctx)
2647
{
2648
	ANTLR3_UINT32	_type;
2649
2650
3
    _type	    = T__82;
2651
2652
2653
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:67:7: ( '$quotient_f' )
2654
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:67:9: '$quotient_f'
2655
    {
2656
3
        MATCHS(lit_20);
2657
3
        if  (HASEXCEPTION())
2658
        {
2659
            goto ruleT__82Ex;
2660
        }
2661
2662
2663
2664
2665
    }
2666
2667
3
	LEXSTATE->type = _type;
2668
    // This is where rules clean up and exit
2669
    //
2670
3
    goto ruleT__82Ex; /* Prevent compiler warnings */
2671
3
    ruleT__82Ex: ;
2672
2673
3
}
2674
// $ANTLR end T__82
2675
2676
//   Comes from: 68:7: ( '$quotient_t' )
2677
/** \brief Lexer rule generated by ANTLR3
2678
 *
2679
 * $ANTLR start T__83
2680
 *
2681
 * Looks to match the characters the constitute the token T__83
2682
 * from the attached input stream.
2683
 *
2684
 *
2685
 * \remark
2686
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2687
 */
2688
static ANTLR3_INLINE
2689
3
void mT__83(pTptpLexer ctx)
2690
{
2691
	ANTLR3_UINT32	_type;
2692
2693
3
    _type	    = T__83;
2694
2695
2696
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:68:7: ( '$quotient_t' )
2697
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:68:9: '$quotient_t'
2698
    {
2699
3
        MATCHS(lit_21);
2700
3
        if  (HASEXCEPTION())
2701
        {
2702
            goto ruleT__83Ex;
2703
        }
2704
2705
2706
2707
2708
    }
2709
2710
3
	LEXSTATE->type = _type;
2711
    // This is where rules clean up and exit
2712
    //
2713
3
    goto ruleT__83Ex; /* Prevent compiler warnings */
2714
3
    ruleT__83Ex: ;
2715
2716
3
}
2717
// $ANTLR end T__83
2718
2719
//   Comes from: 69:7: ( '$remainder_e' )
2720
/** \brief Lexer rule generated by ANTLR3
2721
 *
2722
 * $ANTLR start T__84
2723
 *
2724
 * Looks to match the characters the constitute the token T__84
2725
 * from the attached input stream.
2726
 *
2727
 *
2728
 * \remark
2729
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2730
 */
2731
static ANTLR3_INLINE
2732
3
void mT__84(pTptpLexer ctx)
2733
{
2734
	ANTLR3_UINT32	_type;
2735
2736
3
    _type	    = T__84;
2737
2738
2739
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:69:7: ( '$remainder_e' )
2740
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:69:9: '$remainder_e'
2741
    {
2742
3
        MATCHS(lit_22);
2743
3
        if  (HASEXCEPTION())
2744
        {
2745
            goto ruleT__84Ex;
2746
        }
2747
2748
2749
2750
2751
    }
2752
2753
3
	LEXSTATE->type = _type;
2754
    // This is where rules clean up and exit
2755
    //
2756
3
    goto ruleT__84Ex; /* Prevent compiler warnings */
2757
3
    ruleT__84Ex: ;
2758
2759
3
}
2760
// $ANTLR end T__84
2761
2762
//   Comes from: 70:7: ( '$remainder_f' )
2763
/** \brief Lexer rule generated by ANTLR3
2764
 *
2765
 * $ANTLR start T__85
2766
 *
2767
 * Looks to match the characters the constitute the token T__85
2768
 * from the attached input stream.
2769
 *
2770
 *
2771
 * \remark
2772
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2773
 */
2774
static ANTLR3_INLINE
2775
3
void mT__85(pTptpLexer ctx)
2776
{
2777
	ANTLR3_UINT32	_type;
2778
2779
3
    _type	    = T__85;
2780
2781
2782
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:70:7: ( '$remainder_f' )
2783
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:70:9: '$remainder_f'
2784
    {
2785
3
        MATCHS(lit_23);
2786
3
        if  (HASEXCEPTION())
2787
        {
2788
            goto ruleT__85Ex;
2789
        }
2790
2791
2792
2793
2794
    }
2795
2796
3
	LEXSTATE->type = _type;
2797
    // This is where rules clean up and exit
2798
    //
2799
3
    goto ruleT__85Ex; /* Prevent compiler warnings */
2800
3
    ruleT__85Ex: ;
2801
2802
3
}
2803
// $ANTLR end T__85
2804
2805
//   Comes from: 71:7: ( '$remainder_t' )
2806
/** \brief Lexer rule generated by ANTLR3
2807
 *
2808
 * $ANTLR start T__86
2809
 *
2810
 * Looks to match the characters the constitute the token T__86
2811
 * from the attached input stream.
2812
 *
2813
 *
2814
 * \remark
2815
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2816
 */
2817
static ANTLR3_INLINE
2818
3
void mT__86(pTptpLexer ctx)
2819
{
2820
	ANTLR3_UINT32	_type;
2821
2822
3
    _type	    = T__86;
2823
2824
2825
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:71:7: ( '$remainder_t' )
2826
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:71:9: '$remainder_t'
2827
    {
2828
3
        MATCHS(lit_24);
2829
3
        if  (HASEXCEPTION())
2830
        {
2831
            goto ruleT__86Ex;
2832
        }
2833
2834
2835
2836
2837
    }
2838
2839
3
	LEXSTATE->type = _type;
2840
    // This is where rules clean up and exit
2841
    //
2842
3
    goto ruleT__86Ex; /* Prevent compiler warnings */
2843
3
    ruleT__86Ex: ;
2844
2845
3
}
2846
// $ANTLR end T__86
2847
2848
//   Comes from: 72:7: ( '$round' )
2849
/** \brief Lexer rule generated by ANTLR3
2850
 *
2851
 * $ANTLR start T__87
2852
 *
2853
 * Looks to match the characters the constitute the token T__87
2854
 * from the attached input stream.
2855
 *
2856
 *
2857
 * \remark
2858
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2859
 */
2860
static ANTLR3_INLINE
2861
void mT__87(pTptpLexer ctx)
2862
{
2863
	ANTLR3_UINT32	_type;
2864
2865
    _type	    = T__87;
2866
2867
2868
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:72:7: ( '$round' )
2869
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:72:9: '$round'
2870
    {
2871
        MATCHS(lit_25);
2872
        if  (HASEXCEPTION())
2873
        {
2874
            goto ruleT__87Ex;
2875
        }
2876
2877
2878
2879
2880
    }
2881
2882
	LEXSTATE->type = _type;
2883
    // This is where rules clean up and exit
2884
    //
2885
    goto ruleT__87Ex; /* Prevent compiler warnings */
2886
    ruleT__87Ex: ;
2887
2888
}
2889
// $ANTLR end T__87
2890
2891
//   Comes from: 73:7: ( '$sum' )
2892
/** \brief Lexer rule generated by ANTLR3
2893
 *
2894
 * $ANTLR start T__88
2895
 *
2896
 * Looks to match the characters the constitute the token T__88
2897
 * from the attached input stream.
2898
 *
2899
 *
2900
 * \remark
2901
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2902
 */
2903
static ANTLR3_INLINE
2904
6
void mT__88(pTptpLexer ctx)
2905
{
2906
	ANTLR3_UINT32	_type;
2907
2908
6
    _type	    = T__88;
2909
2910
2911
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:73:7: ( '$sum' )
2912
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:73:9: '$sum'
2913
    {
2914
6
        MATCHS(lit_26);
2915
6
        if  (HASEXCEPTION())
2916
        {
2917
            goto ruleT__88Ex;
2918
        }
2919
2920
2921
2922
2923
    }
2924
2925
6
	LEXSTATE->type = _type;
2926
    // This is where rules clean up and exit
2927
    //
2928
6
    goto ruleT__88Ex; /* Prevent compiler warnings */
2929
6
    ruleT__88Ex: ;
2930
2931
6
}
2932
// $ANTLR end T__88
2933
2934
//   Comes from: 74:7: ( '$tType' )
2935
/** \brief Lexer rule generated by ANTLR3
2936
 *
2937
 * $ANTLR start T__89
2938
 *
2939
 * Looks to match the characters the constitute the token T__89
2940
 * from the attached input stream.
2941
 *
2942
 *
2943
 * \remark
2944
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2945
 */
2946
static ANTLR3_INLINE
2947
31
void mT__89(pTptpLexer ctx)
2948
{
2949
	ANTLR3_UINT32	_type;
2950
2951
31
    _type	    = T__89;
2952
2953
2954
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:74:7: ( '$tType' )
2955
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:74:9: '$tType'
2956
    {
2957
31
        MATCHS(lit_27);
2958
31
        if  (HASEXCEPTION())
2959
        {
2960
            goto ruleT__89Ex;
2961
        }
2962
2963
2964
2965
2966
    }
2967
2968
31
	LEXSTATE->type = _type;
2969
    // This is where rules clean up and exit
2970
    //
2971
31
    goto ruleT__89Ex; /* Prevent compiler warnings */
2972
31
    ruleT__89Ex: ;
2973
2974
31
}
2975
// $ANTLR end T__89
2976
2977
//   Comes from: 75:7: ( '$to_int' )
2978
/** \brief Lexer rule generated by ANTLR3
2979
 *
2980
 * $ANTLR start T__90
2981
 *
2982
 * Looks to match the characters the constitute the token T__90
2983
 * from the attached input stream.
2984
 *
2985
 *
2986
 * \remark
2987
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
2988
 */
2989
static ANTLR3_INLINE
2990
4
void mT__90(pTptpLexer ctx)
2991
{
2992
	ANTLR3_UINT32	_type;
2993
2994
4
    _type	    = T__90;
2995
2996
2997
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:75:7: ( '$to_int' )
2998
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:75:9: '$to_int'
2999
    {
3000
4
        MATCHS(lit_28);
3001
4
        if  (HASEXCEPTION())
3002
        {
3003
            goto ruleT__90Ex;
3004
        }
3005
3006
3007
3008
3009
    }
3010
3011
4
	LEXSTATE->type = _type;
3012
    // This is where rules clean up and exit
3013
    //
3014
4
    goto ruleT__90Ex; /* Prevent compiler warnings */
3015
4
    ruleT__90Ex: ;
3016
3017
4
}
3018
// $ANTLR end T__90
3019
3020
//   Comes from: 76:7: ( '$to_rat' )
3021
/** \brief Lexer rule generated by ANTLR3
3022
 *
3023
 * $ANTLR start T__91
3024
 *
3025
 * Looks to match the characters the constitute the token T__91
3026
 * from the attached input stream.
3027
 *
3028
 *
3029
 * \remark
3030
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3031
 */
3032
static ANTLR3_INLINE
3033
4
void mT__91(pTptpLexer ctx)
3034
{
3035
	ANTLR3_UINT32	_type;
3036
3037
4
    _type	    = T__91;
3038
3039
3040
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:76:7: ( '$to_rat' )
3041
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:76:9: '$to_rat'
3042
    {
3043
4
        MATCHS(lit_29);
3044
4
        if  (HASEXCEPTION())
3045
        {
3046
            goto ruleT__91Ex;
3047
        }
3048
3049
3050
3051
3052
    }
3053
3054
4
	LEXSTATE->type = _type;
3055
    // This is where rules clean up and exit
3056
    //
3057
4
    goto ruleT__91Ex; /* Prevent compiler warnings */
3058
4
    ruleT__91Ex: ;
3059
3060
4
}
3061
// $ANTLR end T__91
3062
3063
//   Comes from: 77:7: ( '$to_real' )
3064
/** \brief Lexer rule generated by ANTLR3
3065
 *
3066
 * $ANTLR start T__92
3067
 *
3068
 * Looks to match the characters the constitute the token T__92
3069
 * from the attached input stream.
3070
 *
3071
 *
3072
 * \remark
3073
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3074
 */
3075
static ANTLR3_INLINE
3076
4
void mT__92(pTptpLexer ctx)
3077
{
3078
	ANTLR3_UINT32	_type;
3079
3080
4
    _type	    = T__92;
3081
3082
3083
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:77:7: ( '$to_real' )
3084
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:77:9: '$to_real'
3085
    {
3086
4
        MATCHS(lit_30);
3087
4
        if  (HASEXCEPTION())
3088
        {
3089
            goto ruleT__92Ex;
3090
        }
3091
3092
3093
3094
3095
    }
3096
3097
4
	LEXSTATE->type = _type;
3098
    // This is where rules clean up and exit
3099
    //
3100
4
    goto ruleT__92Ex; /* Prevent compiler warnings */
3101
4
    ruleT__92Ex: ;
3102
3103
4
}
3104
// $ANTLR end T__92
3105
3106
//   Comes from: 78:7: ( '$truncate' )
3107
/** \brief Lexer rule generated by ANTLR3
3108
 *
3109
 * $ANTLR start T__93
3110
 *
3111
 * Looks to match the characters the constitute the token T__93
3112
 * from the attached input stream.
3113
 *
3114
 *
3115
 * \remark
3116
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3117
 */
3118
static ANTLR3_INLINE
3119
3
void mT__93(pTptpLexer ctx)
3120
{
3121
	ANTLR3_UINT32	_type;
3122
3123
3
    _type	    = T__93;
3124
3125
3126
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:78:7: ( '$truncate' )
3127
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:78:9: '$truncate'
3128
    {
3129
3
        MATCHS(lit_31);
3130
3
        if  (HASEXCEPTION())
3131
        {
3132
            goto ruleT__93Ex;
3133
        }
3134
3135
3136
3137
3138
    }
3139
3140
3
	LEXSTATE->type = _type;
3141
    // This is where rules clean up and exit
3142
    //
3143
3
    goto ruleT__93Ex; /* Prevent compiler warnings */
3144
3
    ruleT__93Ex: ;
3145
3146
3
}
3147
// $ANTLR end T__93
3148
3149
//   Comes from: 79:7: ( '$uminus' )
3150
/** \brief Lexer rule generated by ANTLR3
3151
 *
3152
 * $ANTLR start T__94
3153
 *
3154
 * Looks to match the characters the constitute the token T__94
3155
 * from the attached input stream.
3156
 *
3157
 *
3158
 * \remark
3159
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3160
 */
3161
static ANTLR3_INLINE
3162
3
void mT__94(pTptpLexer ctx)
3163
{
3164
	ANTLR3_UINT32	_type;
3165
3166
3
    _type	    = T__94;
3167
3168
3169
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:79:7: ( '$uminus' )
3170
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:79:9: '$uminus'
3171
    {
3172
3
        MATCHS(lit_32);
3173
3
        if  (HASEXCEPTION())
3174
        {
3175
            goto ruleT__94Ex;
3176
        }
3177
3178
3179
3180
3181
    }
3182
3183
3
	LEXSTATE->type = _type;
3184
    // This is where rules clean up and exit
3185
    //
3186
3
    goto ruleT__94Ex; /* Prevent compiler warnings */
3187
3
    ruleT__94Ex: ;
3188
3189
3
}
3190
// $ANTLR end T__94
3191
3192
//   Comes from: 1614:12: ( ',' )
3193
/** \brief Lexer rule generated by ANTLR3
3194
 *
3195
 * $ANTLR start COMMA_TOK
3196
 *
3197
 * Looks to match the characters the constitute the token COMMA_TOK
3198
 * from the attached input stream.
3199
 *
3200
 *
3201
 * \remark
3202
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3203
 */
3204
static ANTLR3_INLINE
3205
5149
void mCOMMA_TOK(pTptpLexer ctx)
3206
{
3207
	ANTLR3_UINT32	_type;
3208
3209
5149
    _type	    = COMMA_TOK;
3210
3211
3212
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1614:12: ( ',' )
3213
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1614:14: ','
3214
    {
3215
5149
        MATCHC(',');
3216
5149
        if  (HASEXCEPTION())
3217
        {
3218
            goto ruleCOMMA_TOKEx;
3219
        }
3220
3221
3222
    }
3223
3224
5149
	LEXSTATE->type = _type;
3225
    // This is where rules clean up and exit
3226
    //
3227
5149
    goto ruleCOMMA_TOKEx; /* Prevent compiler warnings */
3228
5149
    ruleCOMMA_TOKEx: ;
3229
3230
5149
}
3231
// $ANTLR end COMMA_TOK
3232
3233
//   Comes from: 1612:12: ( '.' )
3234
/** \brief Lexer rule generated by ANTLR3
3235
 *
3236
 * $ANTLR start DOT_TOK
3237
 *
3238
 * Looks to match the characters the constitute the token DOT_TOK
3239
 * from the attached input stream.
3240
 *
3241
 *
3242
 * \remark
3243
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3244
 */
3245
static ANTLR3_INLINE
3246
1706
void mDOT_TOK(pTptpLexer ctx)
3247
{
3248
	ANTLR3_UINT32	_type;
3249
3250
1706
    _type	    = DOT_TOK;
3251
3252
3253
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1612:12: ( '.' )
3254
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1612:14: '.'
3255
    {
3256
1706
        MATCHC('.');
3257
1706
        if  (HASEXCEPTION())
3258
        {
3259
            goto ruleDOT_TOKEx;
3260
        }
3261
3262
3263
    }
3264
3265
1706
	LEXSTATE->type = _type;
3266
    // This is where rules clean up and exit
3267
    //
3268
1706
    goto ruleDOT_TOKEx; /* Prevent compiler warnings */
3269
1706
    ruleDOT_TOKEx: ;
3270
3271
1706
}
3272
// $ANTLR end DOT_TOK
3273
3274
//   Comes from: 1613:12: ( '(' )
3275
/** \brief Lexer rule generated by ANTLR3
3276
 *
3277
 * $ANTLR start LPAREN_TOK
3278
 *
3279
 * Looks to match the characters the constitute the token LPAREN_TOK
3280
 * from the attached input stream.
3281
 *
3282
 *
3283
 * \remark
3284
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3285
 */
3286
static ANTLR3_INLINE
3287
11788
void mLPAREN_TOK(pTptpLexer ctx)
3288
{
3289
	ANTLR3_UINT32	_type;
3290
3291
11788
    _type	    = LPAREN_TOK;
3292
3293
3294
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1613:12: ( '(' )
3295
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1613:14: '('
3296
    {
3297
11788
        MATCHC('(');
3298
11788
        if  (HASEXCEPTION())
3299
        {
3300
            goto ruleLPAREN_TOKEx;
3301
        }
3302
3303
3304
    }
3305
3306
11788
	LEXSTATE->type = _type;
3307
    // This is where rules clean up and exit
3308
    //
3309
11788
    goto ruleLPAREN_TOKEx; /* Prevent compiler warnings */
3310
11788
    ruleLPAREN_TOKEx: ;
3311
3312
11788
}
3313
// $ANTLR end LPAREN_TOK
3314
3315
//   Comes from: 1614:12: ( ')' )
3316
/** \brief Lexer rule generated by ANTLR3
3317
 *
3318
 * $ANTLR start RPAREN_TOK
3319
 *
3320
 * Looks to match the characters the constitute the token RPAREN_TOK
3321
 * from the attached input stream.
3322
 *
3323
 *
3324
 * \remark
3325
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3326
 */
3327
static ANTLR3_INLINE
3328
11788
void mRPAREN_TOK(pTptpLexer ctx)
3329
{
3330
	ANTLR3_UINT32	_type;
3331
3332
11788
    _type	    = RPAREN_TOK;
3333
3334
3335
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1614:12: ( ')' )
3336
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1614:14: ')'
3337
    {
3338
11788
        MATCHC(')');
3339
11788
        if  (HASEXCEPTION())
3340
        {
3341
            goto ruleRPAREN_TOKEx;
3342
        }
3343
3344
3345
    }
3346
3347
11788
	LEXSTATE->type = _type;
3348
    // This is where rules clean up and exit
3349
    //
3350
11788
    goto ruleRPAREN_TOKEx; /* Prevent compiler warnings */
3351
11788
    ruleRPAREN_TOKEx: ;
3352
3353
11788
}
3354
// $ANTLR end RPAREN_TOK
3355
3356
//   Comes from: 1615:12: ( '[' )
3357
/** \brief Lexer rule generated by ANTLR3
3358
 *
3359
 * $ANTLR start LBRACK_TOK
3360
 *
3361
 * Looks to match the characters the constitute the token LBRACK_TOK
3362
 * from the attached input stream.
3363
 *
3364
 *
3365
 * \remark
3366
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3367
 */
3368
static ANTLR3_INLINE
3369
1460
void mLBRACK_TOK(pTptpLexer ctx)
3370
{
3371
	ANTLR3_UINT32	_type;
3372
3373
1460
    _type	    = LBRACK_TOK;
3374
3375
3376
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1615:12: ( '[' )
3377
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1615:14: '['
3378
    {
3379
1460
        MATCHC('[');
3380
1460
        if  (HASEXCEPTION())
3381
        {
3382
            goto ruleLBRACK_TOKEx;
3383
        }
3384
3385
3386
    }
3387
3388
1460
	LEXSTATE->type = _type;
3389
    // This is where rules clean up and exit
3390
    //
3391
1460
    goto ruleLBRACK_TOKEx; /* Prevent compiler warnings */
3392
1460
    ruleLBRACK_TOKEx: ;
3393
3394
1460
}
3395
// $ANTLR end LBRACK_TOK
3396
3397
//   Comes from: 1616:12: ( ']' )
3398
/** \brief Lexer rule generated by ANTLR3
3399
 *
3400
 * $ANTLR start RBRACK_TOK
3401
 *
3402
 * Looks to match the characters the constitute the token RBRACK_TOK
3403
 * from the attached input stream.
3404
 *
3405
 *
3406
 * \remark
3407
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3408
 */
3409
static ANTLR3_INLINE
3410
1460
void mRBRACK_TOK(pTptpLexer ctx)
3411
{
3412
	ANTLR3_UINT32	_type;
3413
3414
1460
    _type	    = RBRACK_TOK;
3415
3416
3417
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1616:12: ( ']' )
3418
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1616:14: ']'
3419
    {
3420
1460
        MATCHC(']');
3421
1460
        if  (HASEXCEPTION())
3422
        {
3423
            goto ruleRBRACK_TOKEx;
3424
        }
3425
3426
3427
    }
3428
3429
1460
	LEXSTATE->type = _type;
3430
    // This is where rules clean up and exit
3431
    //
3432
1460
    goto ruleRBRACK_TOKEx; /* Prevent compiler warnings */
3433
1460
    ruleRBRACK_TOKEx: ;
3434
3435
1460
}
3436
// $ANTLR end RBRACK_TOK
3437
3438
//   Comes from: 1617:12: ( ':' )
3439
/** \brief Lexer rule generated by ANTLR3
3440
 *
3441
 * $ANTLR start COLON_TOK
3442
 *
3443
 * Looks to match the characters the constitute the token COLON_TOK
3444
 * from the attached input stream.
3445
 *
3446
 *
3447
 * \remark
3448
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3449
 */
3450
static ANTLR3_INLINE
3451
4500
void mCOLON_TOK(pTptpLexer ctx)
3452
{
3453
	ANTLR3_UINT32	_type;
3454
3455
4500
    _type	    = COLON_TOK;
3456
3457
3458
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1617:12: ( ':' )
3459
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1617:14: ':'
3460
    {
3461
4500
        MATCHC(':');
3462
4500
        if  (HASEXCEPTION())
3463
        {
3464
            goto ruleCOLON_TOKEx;
3465
        }
3466
3467
3468
    }
3469
3470
4500
	LEXSTATE->type = _type;
3471
    // This is where rules clean up and exit
3472
    //
3473
4500
    goto ruleCOLON_TOKEx; /* Prevent compiler warnings */
3474
4500
    ruleCOLON_TOKEx: ;
3475
3476
4500
}
3477
// $ANTLR end COLON_TOK
3478
3479
//   Comes from: 1620:13: ( '>' )
3480
/** \brief Lexer rule generated by ANTLR3
3481
 *
3482
 * $ANTLR start ARROW_TOK
3483
 *
3484
 * Looks to match the characters the constitute the token ARROW_TOK
3485
 * from the attached input stream.
3486
 *
3487
 *
3488
 * \remark
3489
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3490
 */
3491
static ANTLR3_INLINE
3492
2683
void mARROW_TOK(pTptpLexer ctx)
3493
{
3494
	ANTLR3_UINT32	_type;
3495
3496
2683
    _type	    = ARROW_TOK;
3497
3498
3499
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1620:13: ( '>' )
3500
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1620:15: '>'
3501
    {
3502
2683
        MATCHC('>');
3503
2683
        if  (HASEXCEPTION())
3504
        {
3505
            goto ruleARROW_TOKEx;
3506
        }
3507
3508
3509
    }
3510
3511
2683
	LEXSTATE->type = _type;
3512
    // This is where rules clean up and exit
3513
    //
3514
2683
    goto ruleARROW_TOKEx; /* Prevent compiler warnings */
3515
2683
    ruleARROW_TOKEx: ;
3516
3517
2683
}
3518
// $ANTLR end ARROW_TOK
3519
3520
//   Comes from: 1621:13: ( '>>' )
3521
/** \brief Lexer rule generated by ANTLR3
3522
 *
3523
 * $ANTLR start SUBTYPE_TOK
3524
 *
3525
 * Looks to match the characters the constitute the token SUBTYPE_TOK
3526
 * from the attached input stream.
3527
 *
3528
 *
3529
 * \remark
3530
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3531
 */
3532
static ANTLR3_INLINE
3533
void mSUBTYPE_TOK(pTptpLexer ctx)
3534
{
3535
	ANTLR3_UINT32	_type;
3536
3537
    _type	    = SUBTYPE_TOK;
3538
3539
3540
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1621:13: ( '>>' )
3541
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1621:15: '>>'
3542
    {
3543
        MATCHS(lit_33);
3544
        if  (HASEXCEPTION())
3545
        {
3546
            goto ruleSUBTYPE_TOKEx;
3547
        }
3548
3549
3550
3551
3552
    }
3553
3554
	LEXSTATE->type = _type;
3555
    // This is where rules clean up and exit
3556
    //
3557
    goto ruleSUBTYPE_TOKEx; /* Prevent compiler warnings */
3558
    ruleSUBTYPE_TOKEx: ;
3559
3560
}
3561
// $ANTLR end SUBTYPE_TOK
3562
3563
//   Comes from: 1624:16: ( '|' )
3564
/** \brief Lexer rule generated by ANTLR3
3565
 *
3566
 * $ANTLR start OR_TOK
3567
 *
3568
 * Looks to match the characters the constitute the token OR_TOK
3569
 * from the attached input stream.
3570
 *
3571
 *
3572
 * \remark
3573
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3574
 */
3575
static ANTLR3_INLINE
3576
197
void mOR_TOK(pTptpLexer ctx)
3577
{
3578
	ANTLR3_UINT32	_type;
3579
3580
197
    _type	    = OR_TOK;
3581
3582
3583
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1624:16: ( '|' )
3584
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1624:18: '|'
3585
    {
3586
197
        MATCHC('|');
3587
197
        if  (HASEXCEPTION())
3588
        {
3589
            goto ruleOR_TOKEx;
3590
        }
3591
3592
3593
    }
3594
3595
197
	LEXSTATE->type = _type;
3596
    // This is where rules clean up and exit
3597
    //
3598
197
    goto ruleOR_TOKEx; /* Prevent compiler warnings */
3599
197
    ruleOR_TOKEx: ;
3600
3601
197
}
3602
// $ANTLR end OR_TOK
3603
3604
//   Comes from: 1625:16: ( '~' )
3605
/** \brief Lexer rule generated by ANTLR3
3606
 *
3607
 * $ANTLR start NOT_TOK
3608
 *
3609
 * Looks to match the characters the constitute the token NOT_TOK
3610
 * from the attached input stream.
3611
 *
3612
 *
3613
 * \remark
3614
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3615
 */
3616
static ANTLR3_INLINE
3617
252
void mNOT_TOK(pTptpLexer ctx)
3618
{
3619
	ANTLR3_UINT32	_type;
3620
3621
252
    _type	    = NOT_TOK;
3622
3623
3624
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1625:16: ( '~' )
3625
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1625:18: '~'
3626
    {
3627
252
        MATCHC('~');
3628
252
        if  (HASEXCEPTION())
3629
        {
3630
            goto ruleNOT_TOKEx;
3631
        }
3632
3633
3634
    }
3635
3636
252
	LEXSTATE->type = _type;
3637
    // This is where rules clean up and exit
3638
    //
3639
252
    goto ruleNOT_TOKEx; /* Prevent compiler warnings */
3640
252
    ruleNOT_TOKEx: ;
3641
3642
252
}
3643
// $ANTLR end NOT_TOK
3644
3645
//   Comes from: 1626:16: ( '!' )
3646
/** \brief Lexer rule generated by ANTLR3
3647
 *
3648
 * $ANTLR start FORALL_TOK
3649
 *
3650
 * Looks to match the characters the constitute the token FORALL_TOK
3651
 * from the attached input stream.
3652
 *
3653
 *
3654
 * \remark
3655
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3656
 */
3657
static ANTLR3_INLINE
3658
1170
void mFORALL_TOK(pTptpLexer ctx)
3659
{
3660
	ANTLR3_UINT32	_type;
3661
3662
1170
    _type	    = FORALL_TOK;
3663
3664
3665
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1626:16: ( '!' )
3666
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1626:18: '!'
3667
    {
3668
1170
        MATCHC('!');
3669
1170
        if  (HASEXCEPTION())
3670
        {
3671
            goto ruleFORALL_TOKEx;
3672
        }
3673
3674
3675
    }
3676
3677
1170
	LEXSTATE->type = _type;
3678
    // This is where rules clean up and exit
3679
    //
3680
1170
    goto ruleFORALL_TOKEx; /* Prevent compiler warnings */
3681
1170
    ruleFORALL_TOKEx: ;
3682
3683
1170
}
3684
// $ANTLR end FORALL_TOK
3685
3686
//   Comes from: 1627:16: ( '?' )
3687
/** \brief Lexer rule generated by ANTLR3
3688
 *
3689
 * $ANTLR start EXISTS_TOK
3690
 *
3691
 * Looks to match the characters the constitute the token EXISTS_TOK
3692
 * from the attached input stream.
3693
 *
3694
 *
3695
 * \remark
3696
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3697
 */
3698
static ANTLR3_INLINE
3699
89
void mEXISTS_TOK(pTptpLexer ctx)
3700
{
3701
	ANTLR3_UINT32	_type;
3702
3703
89
    _type	    = EXISTS_TOK;
3704
3705
3706
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1627:16: ( '?' )
3707
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1627:18: '?'
3708
    {
3709
89
        MATCHC('?');
3710
89
        if  (HASEXCEPTION())
3711
        {
3712
            goto ruleEXISTS_TOKEx;
3713
        }
3714
3715
3716
    }
3717
3718
89
	LEXSTATE->type = _type;
3719
    // This is where rules clean up and exit
3720
    //
3721
89
    goto ruleEXISTS_TOKEx; /* Prevent compiler warnings */
3722
89
    ruleEXISTS_TOKEx: ;
3723
3724
89
}
3725
// $ANTLR end EXISTS_TOK
3726
3727
//   Comes from: 1628:16: ( '^' )
3728
/** \brief Lexer rule generated by ANTLR3
3729
 *
3730
 * $ANTLR start LAMBDA_TOK
3731
 *
3732
 * Looks to match the characters the constitute the token LAMBDA_TOK
3733
 * from the attached input stream.
3734
 *
3735
 *
3736
 * \remark
3737
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3738
 */
3739
static ANTLR3_INLINE
3740
162
void mLAMBDA_TOK(pTptpLexer ctx)
3741
{
3742
	ANTLR3_UINT32	_type;
3743
3744
162
    _type	    = LAMBDA_TOK;
3745
3746
3747
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1628:16: ( '^' )
3748
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1628:18: '^'
3749
    {
3750
162
        MATCHC('^');
3751
162
        if  (HASEXCEPTION())
3752
        {
3753
            goto ruleLAMBDA_TOKEx;
3754
        }
3755
3756
3757
    }
3758
3759
162
	LEXSTATE->type = _type;
3760
    // This is where rules clean up and exit
3761
    //
3762
162
    goto ruleLAMBDA_TOKEx; /* Prevent compiler warnings */
3763
162
    ruleLAMBDA_TOKEx: ;
3764
3765
162
}
3766
// $ANTLR end LAMBDA_TOK
3767
3768
//   Comes from: 1629:16: ( '@+' )
3769
/** \brief Lexer rule generated by ANTLR3
3770
 *
3771
 * $ANTLR start CHOICE_TOK
3772
 *
3773
 * Looks to match the characters the constitute the token CHOICE_TOK
3774
 * from the attached input stream.
3775
 *
3776
 *
3777
 * \remark
3778
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3779
 */
3780
static ANTLR3_INLINE
3781
void mCHOICE_TOK(pTptpLexer ctx)
3782
{
3783
	ANTLR3_UINT32	_type;
3784
3785
    _type	    = CHOICE_TOK;
3786
3787
3788
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1629:16: ( '@+' )
3789
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1629:18: '@+'
3790
    {
3791
        MATCHS(lit_34);
3792
        if  (HASEXCEPTION())
3793
        {
3794
            goto ruleCHOICE_TOKEx;
3795
        }
3796
3797
3798
3799
3800
    }
3801
3802
	LEXSTATE->type = _type;
3803
    // This is where rules clean up and exit
3804
    //
3805
    goto ruleCHOICE_TOKEx; /* Prevent compiler warnings */
3806
    ruleCHOICE_TOKEx: ;
3807
3808
}
3809
// $ANTLR end CHOICE_TOK
3810
3811
//   Comes from: 1630:16: ( '@-' )
3812
/** \brief Lexer rule generated by ANTLR3
3813
 *
3814
 * $ANTLR start DEF_DESC_TOK
3815
 *
3816
 * Looks to match the characters the constitute the token DEF_DESC_TOK
3817
 * from the attached input stream.
3818
 *
3819
 *
3820
 * \remark
3821
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3822
 */
3823
static ANTLR3_INLINE
3824
void mDEF_DESC_TOK(pTptpLexer ctx)
3825
{
3826
	ANTLR3_UINT32	_type;
3827
3828
    _type	    = DEF_DESC_TOK;
3829
3830
3831
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1630:16: ( '@-' )
3832
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1630:18: '@-'
3833
    {
3834
        MATCHS(lit_35);
3835
        if  (HASEXCEPTION())
3836
        {
3837
            goto ruleDEF_DESC_TOKEx;
3838
        }
3839
3840
3841
3842
3843
    }
3844
3845
	LEXSTATE->type = _type;
3846
    // This is where rules clean up and exit
3847
    //
3848
    goto ruleDEF_DESC_TOKEx; /* Prevent compiler warnings */
3849
    ruleDEF_DESC_TOKEx: ;
3850
3851
}
3852
// $ANTLR end DEF_DESC_TOK
3853
3854
//   Comes from: 1631:16: ( '&' )
3855
/** \brief Lexer rule generated by ANTLR3
3856
 *
3857
 * $ANTLR start AND_TOK
3858
 *
3859
 * Looks to match the characters the constitute the token AND_TOK
3860
 * from the attached input stream.
3861
 *
3862
 *
3863
 * \remark
3864
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3865
 */
3866
static ANTLR3_INLINE
3867
207
void mAND_TOK(pTptpLexer ctx)
3868
{
3869
	ANTLR3_UINT32	_type;
3870
3871
207
    _type	    = AND_TOK;
3872
3873
3874
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1631:16: ( '&' )
3875
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1631:18: '&'
3876
    {
3877
207
        MATCHC('&');
3878
207
        if  (HASEXCEPTION())
3879
        {
3880
            goto ruleAND_TOKEx;
3881
        }
3882
3883
3884
    }
3885
3886
207
	LEXSTATE->type = _type;
3887
    // This is where rules clean up and exit
3888
    //
3889
207
    goto ruleAND_TOKEx; /* Prevent compiler warnings */
3890
207
    ruleAND_TOKEx: ;
3891
3892
207
}
3893
// $ANTLR end AND_TOK
3894
3895
//   Comes from: 1632:16: ( '<=>' )
3896
/** \brief Lexer rule generated by ANTLR3
3897
 *
3898
 * $ANTLR start IFF_TOK
3899
 *
3900
 * Looks to match the characters the constitute the token IFF_TOK
3901
 * from the attached input stream.
3902
 *
3903
 *
3904
 * \remark
3905
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3906
 */
3907
static ANTLR3_INLINE
3908
196
void mIFF_TOK(pTptpLexer ctx)
3909
{
3910
	ANTLR3_UINT32	_type;
3911
3912
196
    _type	    = IFF_TOK;
3913
3914
3915
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1632:16: ( '<=>' )
3916
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1632:18: '<=>'
3917
    {
3918
196
        MATCHS(lit_36);
3919
196
        if  (HASEXCEPTION())
3920
        {
3921
            goto ruleIFF_TOKEx;
3922
        }
3923
3924
3925
3926
3927
    }
3928
3929
196
	LEXSTATE->type = _type;
3930
    // This is where rules clean up and exit
3931
    //
3932
196
    goto ruleIFF_TOKEx; /* Prevent compiler warnings */
3933
196
    ruleIFF_TOKEx: ;
3934
3935
196
}
3936
// $ANTLR end IFF_TOK
3937
3938
//   Comes from: 1633:16: ( '=>' )
3939
/** \brief Lexer rule generated by ANTLR3
3940
 *
3941
 * $ANTLR start IMPLIES_TOK
3942
 *
3943
 * Looks to match the characters the constitute the token IMPLIES_TOK
3944
 * from the attached input stream.
3945
 *
3946
 *
3947
 * \remark
3948
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3949
 */
3950
static ANTLR3_INLINE
3951
1917
void mIMPLIES_TOK(pTptpLexer ctx)
3952
{
3953
	ANTLR3_UINT32	_type;
3954
3955
1917
    _type	    = IMPLIES_TOK;
3956
3957
3958
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1633:16: ( '=>' )
3959
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1633:18: '=>'
3960
    {
3961
1917
        MATCHS(lit_37);
3962
1917
        if  (HASEXCEPTION())
3963
        {
3964
            goto ruleIMPLIES_TOKEx;
3965
        }
3966
3967
3968
3969
3970
    }
3971
3972
1917
	LEXSTATE->type = _type;
3973
    // This is where rules clean up and exit
3974
    //
3975
1917
    goto ruleIMPLIES_TOKEx; /* Prevent compiler warnings */
3976
1917
    ruleIMPLIES_TOKEx: ;
3977
3978
1917
}
3979
// $ANTLR end IMPLIES_TOK
3980
3981
//   Comes from: 1634:16: ( '<=' )
3982
/** \brief Lexer rule generated by ANTLR3
3983
 *
3984
 * $ANTLR start REVIMPLIES_TOK
3985
 *
3986
 * Looks to match the characters the constitute the token REVIMPLIES_TOK
3987
 * from the attached input stream.
3988
 *
3989
 *
3990
 * \remark
3991
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
3992
 */
3993
static ANTLR3_INLINE
3994
2
void mREVIMPLIES_TOK(pTptpLexer ctx)
3995
{
3996
	ANTLR3_UINT32	_type;
3997
3998
2
    _type	    = REVIMPLIES_TOK;
3999
4000
4001
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1634:16: ( '<=' )
4002
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1634:18: '<='
4003
    {
4004
2
        MATCHS(lit_38);
4005
2
        if  (HASEXCEPTION())
4006
        {
4007
            goto ruleREVIMPLIES_TOKEx;
4008
        }
4009
4010
4011
4012
4013
    }
4014
4015
2
	LEXSTATE->type = _type;
4016
    // This is where rules clean up and exit
4017
    //
4018
2
    goto ruleREVIMPLIES_TOKEx; /* Prevent compiler warnings */
4019
2
    ruleREVIMPLIES_TOKEx: ;
4020
4021
2
}
4022
// $ANTLR end REVIMPLIES_TOK
4023
4024
//   Comes from: 1635:16: ( '<~>' )
4025
/** \brief Lexer rule generated by ANTLR3
4026
 *
4027
 * $ANTLR start REVIFF_TOK
4028
 *
4029
 * Looks to match the characters the constitute the token REVIFF_TOK
4030
 * from the attached input stream.
4031
 *
4032
 *
4033
 * \remark
4034
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4035
 */
4036
static ANTLR3_INLINE
4037
2
void mREVIFF_TOK(pTptpLexer ctx)
4038
{
4039
	ANTLR3_UINT32	_type;
4040
4041
2
    _type	    = REVIFF_TOK;
4042
4043
4044
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1635:16: ( '<~>' )
4045
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1635:18: '<~>'
4046
    {
4047
2
        MATCHS(lit_39);
4048
2
        if  (HASEXCEPTION())
4049
        {
4050
            goto ruleREVIFF_TOKEx;
4051
        }
4052
4053
4054
4055
4056
    }
4057
4058
2
	LEXSTATE->type = _type;
4059
    // This is where rules clean up and exit
4060
    //
4061
2
    goto ruleREVIFF_TOKEx; /* Prevent compiler warnings */
4062
2
    ruleREVIFF_TOKEx: ;
4063
4064
2
}
4065
// $ANTLR end REVIFF_TOK
4066
4067
//   Comes from: 1636:16: ( '~|' )
4068
/** \brief Lexer rule generated by ANTLR3
4069
 *
4070
 * $ANTLR start REVOR_TOK
4071
 *
4072
 * Looks to match the characters the constitute the token REVOR_TOK
4073
 * from the attached input stream.
4074
 *
4075
 *
4076
 * \remark
4077
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4078
 */
4079
static ANTLR3_INLINE
4080
2
void mREVOR_TOK(pTptpLexer ctx)
4081
{
4082
	ANTLR3_UINT32	_type;
4083
4084
2
    _type	    = REVOR_TOK;
4085
4086
4087
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1636:16: ( '~|' )
4088
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1636:18: '~|'
4089
    {
4090
2
        MATCHS(lit_40);
4091
2
        if  (HASEXCEPTION())
4092
        {
4093
            goto ruleREVOR_TOKEx;
4094
        }
4095
4096
4097
4098
4099
    }
4100
4101
2
	LEXSTATE->type = _type;
4102
    // This is where rules clean up and exit
4103
    //
4104
2
    goto ruleREVOR_TOKEx; /* Prevent compiler warnings */
4105
2
    ruleREVOR_TOKEx: ;
4106
4107
2
}
4108
// $ANTLR end REVOR_TOK
4109
4110
//   Comes from: 1637:16: ( '~&' )
4111
/** \brief Lexer rule generated by ANTLR3
4112
 *
4113
 * $ANTLR start REVAND_TOK
4114
 *
4115
 * Looks to match the characters the constitute the token REVAND_TOK
4116
 * from the attached input stream.
4117
 *
4118
 *
4119
 * \remark
4120
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4121
 */
4122
static ANTLR3_INLINE
4123
2
void mREVAND_TOK(pTptpLexer ctx)
4124
{
4125
	ANTLR3_UINT32	_type;
4126
4127
2
    _type	    = REVAND_TOK;
4128
4129
4130
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1637:16: ( '~&' )
4131
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1637:18: '~&'
4132
    {
4133
2
        MATCHS(lit_41);
4134
2
        if  (HASEXCEPTION())
4135
        {
4136
            goto ruleREVAND_TOKEx;
4137
        }
4138
4139
4140
4141
4142
    }
4143
4144
2
	LEXSTATE->type = _type;
4145
    // This is where rules clean up and exit
4146
    //
4147
2
    goto ruleREVAND_TOKEx; /* Prevent compiler warnings */
4148
2
    ruleREVAND_TOKEx: ;
4149
4150
2
}
4151
// $ANTLR end REVAND_TOK
4152
4153
//   Comes from: 1638:16: ( '*' )
4154
/** \brief Lexer rule generated by ANTLR3
4155
 *
4156
 * $ANTLR start TIMES_TOK
4157
 *
4158
 * Looks to match the characters the constitute the token TIMES_TOK
4159
 * from the attached input stream.
4160
 *
4161
 *
4162
 * \remark
4163
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4164
 */
4165
static ANTLR3_INLINE
4166
19
void mTIMES_TOK(pTptpLexer ctx)
4167
{
4168
	ANTLR3_UINT32	_type;
4169
4170
19
    _type	    = TIMES_TOK;
4171
4172
4173
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1638:16: ( '*' )
4174
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1638:18: '*'
4175
    {
4176
19
        MATCHC('*');
4177
19
        if  (HASEXCEPTION())
4178
        {
4179
            goto ruleTIMES_TOKEx;
4180
        }
4181
4182
4183
    }
4184
4185
19
	LEXSTATE->type = _type;
4186
    // This is where rules clean up and exit
4187
    //
4188
19
    goto ruleTIMES_TOKEx; /* Prevent compiler warnings */
4189
19
    ruleTIMES_TOKEx: ;
4190
4191
19
}
4192
// $ANTLR end TIMES_TOK
4193
4194
//   Comes from: 1639:16: ( '+' )
4195
/** \brief Lexer rule generated by ANTLR3
4196
 *
4197
 * $ANTLR start PLUS_TOK
4198
 *
4199
 * Looks to match the characters the constitute the token PLUS_TOK
4200
 * from the attached input stream.
4201
 *
4202
 *
4203
 * \remark
4204
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4205
 */
4206
static ANTLR3_INLINE
4207
2
void mPLUS_TOK(pTptpLexer ctx)
4208
{
4209
	ANTLR3_UINT32	_type;
4210
4211
2
    _type	    = PLUS_TOK;
4212
4213
4214
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1639:16: ( '+' )
4215
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1639:18: '+'
4216
    {
4217
2
        MATCHC('+');
4218
2
        if  (HASEXCEPTION())
4219
        {
4220
            goto rulePLUS_TOKEx;
4221
        }
4222
4223
4224
    }
4225
4226
2
	LEXSTATE->type = _type;
4227
    // This is where rules clean up and exit
4228
    //
4229
2
    goto rulePLUS_TOKEx; /* Prevent compiler warnings */
4230
2
    rulePLUS_TOKEx: ;
4231
4232
2
}
4233
// $ANTLR end PLUS_TOK
4234
4235
//   Comes from: 1640:16: ( '-' )
4236
/** \brief Lexer rule generated by ANTLR3
4237
 *
4238
 * $ANTLR start MINUS_TOK
4239
 *
4240
 * Looks to match the characters the constitute the token MINUS_TOK
4241
 * from the attached input stream.
4242
 *
4243
 *
4244
 * \remark
4245
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4246
 */
4247
static ANTLR3_INLINE
4248
27
void mMINUS_TOK(pTptpLexer ctx)
4249
{
4250
	ANTLR3_UINT32	_type;
4251
4252
27
    _type	    = MINUS_TOK;
4253
4254
4255
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1640:16: ( '-' )
4256
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1640:18: '-'
4257
    {
4258
27
        MATCHC('-');
4259
27
        if  (HASEXCEPTION())
4260
        {
4261
            goto ruleMINUS_TOKEx;
4262
        }
4263
4264
4265
    }
4266
4267
27
	LEXSTATE->type = _type;
4268
    // This is where rules clean up and exit
4269
    //
4270
27
    goto ruleMINUS_TOKEx; /* Prevent compiler warnings */
4271
27
    ruleMINUS_TOKEx: ;
4272
4273
27
}
4274
// $ANTLR end MINUS_TOK
4275
4276
//   Comes from: 1641:16: ( '@' )
4277
/** \brief Lexer rule generated by ANTLR3
4278
 *
4279
 * $ANTLR start APP_TOK
4280
 *
4281
 * Looks to match the characters the constitute the token APP_TOK
4282
 * from the attached input stream.
4283
 *
4284
 *
4285
 * \remark
4286
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4287
 */
4288
static ANTLR3_INLINE
4289
6652
void mAPP_TOK(pTptpLexer ctx)
4290
{
4291
	ANTLR3_UINT32	_type;
4292
4293
6652
    _type	    = APP_TOK;
4294
4295
4296
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1641:16: ( '@' )
4297
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1641:18: '@'
4298
    {
4299
6652
        MATCHC('@');
4300
6652
        if  (HASEXCEPTION())
4301
        {
4302
            goto ruleAPP_TOKEx;
4303
        }
4304
4305
4306
    }
4307
4308
6652
	LEXSTATE->type = _type;
4309
    // This is where rules clean up and exit
4310
    //
4311
6652
    goto ruleAPP_TOKEx; /* Prevent compiler warnings */
4312
6652
    ruleAPP_TOKEx: ;
4313
4314
6652
}
4315
// $ANTLR end APP_TOK
4316
4317
//   Comes from: 1643:16: ( '!!' )
4318
/** \brief Lexer rule generated by ANTLR3
4319
 *
4320
 * $ANTLR start TH1_UN_A
4321
 *
4322
 * Looks to match the characters the constitute the token TH1_UN_A
4323
 * from the attached input stream.
4324
 *
4325
 *
4326
 * \remark
4327
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4328
 */
4329
static ANTLR3_INLINE
4330
void mTH1_UN_A(pTptpLexer ctx)
4331
{
4332
	ANTLR3_UINT32	_type;
4333
4334
    _type	    = TH1_UN_A;
4335
4336
4337
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1643:16: ( '!!' )
4338
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1643:18: '!!'
4339
    {
4340
        MATCHS(lit_42);
4341
        if  (HASEXCEPTION())
4342
        {
4343
            goto ruleTH1_UN_AEx;
4344
        }
4345
4346
4347
4348
4349
    }
4350
4351
	LEXSTATE->type = _type;
4352
    // This is where rules clean up and exit
4353
    //
4354
    goto ruleTH1_UN_AEx; /* Prevent compiler warnings */
4355
    ruleTH1_UN_AEx: ;
4356
4357
}
4358
// $ANTLR end TH1_UN_A
4359
4360
//   Comes from: 1644:16: ( '??' )
4361
/** \brief Lexer rule generated by ANTLR3
4362
 *
4363
 * $ANTLR start TH1_UN_E
4364
 *
4365
 * Looks to match the characters the constitute the token TH1_UN_E
4366
 * from the attached input stream.
4367
 *
4368
 *
4369
 * \remark
4370
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4371
 */
4372
static ANTLR3_INLINE
4373
void mTH1_UN_E(pTptpLexer ctx)
4374
{
4375
	ANTLR3_UINT32	_type;
4376
4377
    _type	    = TH1_UN_E;
4378
4379
4380
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1644:16: ( '??' )
4381
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1644:18: '??'
4382
    {
4383
        MATCHS(lit_43);
4384
        if  (HASEXCEPTION())
4385
        {
4386
            goto ruleTH1_UN_EEx;
4387
        }
4388
4389
4390
4391
4392
    }
4393
4394
	LEXSTATE->type = _type;
4395
    // This is where rules clean up and exit
4396
    //
4397
    goto ruleTH1_UN_EEx; /* Prevent compiler warnings */
4398
    ruleTH1_UN_EEx: ;
4399
4400
}
4401
// $ANTLR end TH1_UN_E
4402
4403
//   Comes from: 1647:14: ( '$true' )
4404
/** \brief Lexer rule generated by ANTLR3
4405
 *
4406
 * $ANTLR start TRUE_TOK
4407
 *
4408
 * Looks to match the characters the constitute the token TRUE_TOK
4409
 * from the attached input stream.
4410
 *
4411
 *
4412
 * \remark
4413
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4414
 */
4415
static ANTLR3_INLINE
4416
7
void mTRUE_TOK(pTptpLexer ctx)
4417
{
4418
	ANTLR3_UINT32	_type;
4419
4420
7
    _type	    = TRUE_TOK;
4421
4422
4423
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1647:14: ( '$true' )
4424
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1647:16: '$true'
4425
    {
4426
7
        MATCHS(lit_44);
4427
7
        if  (HASEXCEPTION())
4428
        {
4429
            goto ruleTRUE_TOKEx;
4430
        }
4431
4432
4433
4434
4435
    }
4436
4437
7
	LEXSTATE->type = _type;
4438
    // This is where rules clean up and exit
4439
    //
4440
7
    goto ruleTRUE_TOKEx; /* Prevent compiler warnings */
4441
7
    ruleTRUE_TOKEx: ;
4442
4443
7
}
4444
// $ANTLR end TRUE_TOK
4445
4446
//   Comes from: 1648:14: ( '$false' )
4447
/** \brief Lexer rule generated by ANTLR3
4448
 *
4449
 * $ANTLR start FALSE_TOK
4450
 *
4451
 * Looks to match the characters the constitute the token FALSE_TOK
4452
 * from the attached input stream.
4453
 *
4454
 *
4455
 * \remark
4456
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4457
 */
4458
static ANTLR3_INLINE
4459
17
void mFALSE_TOK(pTptpLexer ctx)
4460
{
4461
	ANTLR3_UINT32	_type;
4462
4463
17
    _type	    = FALSE_TOK;
4464
4465
4466
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1648:14: ( '$false' )
4467
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1648:16: '$false'
4468
    {
4469
17
        MATCHS(lit_45);
4470
17
        if  (HASEXCEPTION())
4471
        {
4472
            goto ruleFALSE_TOKEx;
4473
        }
4474
4475
4476
4477
4478
    }
4479
4480
17
	LEXSTATE->type = _type;
4481
    // This is where rules clean up and exit
4482
    //
4483
17
    goto ruleFALSE_TOKEx; /* Prevent compiler warnings */
4484
17
    ruleFALSE_TOKEx: ;
4485
4486
17
}
4487
// $ANTLR end FALSE_TOK
4488
4489
//   Comes from: 1649:14: ( '=' )
4490
/** \brief Lexer rule generated by ANTLR3
4491
 *
4492
 * $ANTLR start EQUAL_TOK
4493
 *
4494
 * Looks to match the characters the constitute the token EQUAL_TOK
4495
 * from the attached input stream.
4496
 *
4497
 *
4498
 * \remark
4499
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4500
 */
4501
static ANTLR3_INLINE
4502
904
void mEQUAL_TOK(pTptpLexer ctx)
4503
{
4504
	ANTLR3_UINT32	_type;
4505
4506
904
    _type	    = EQUAL_TOK;
4507
4508
4509
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1649:14: ( '=' )
4510
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1649:16: '='
4511
    {
4512
904
        MATCHC('=');
4513
904
        if  (HASEXCEPTION())
4514
        {
4515
            goto ruleEQUAL_TOKEx;
4516
        }
4517
4518
4519
    }
4520
4521
904
	LEXSTATE->type = _type;
4522
    // This is where rules clean up and exit
4523
    //
4524
904
    goto ruleEQUAL_TOKEx; /* Prevent compiler warnings */
4525
904
    ruleEQUAL_TOKEx: ;
4526
4527
904
}
4528
// $ANTLR end EQUAL_TOK
4529
4530
//   Comes from: 1650:14: ( '!=' )
4531
/** \brief Lexer rule generated by ANTLR3
4532
 *
4533
 * $ANTLR start DISEQUAL_TOK
4534
 *
4535
 * Looks to match the characters the constitute the token DISEQUAL_TOK
4536
 * from the attached input stream.
4537
 *
4538
 *
4539
 * \remark
4540
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4541
 */
4542
static ANTLR3_INLINE
4543
130
void mDISEQUAL_TOK(pTptpLexer ctx)
4544
{
4545
	ANTLR3_UINT32	_type;
4546
4547
130
    _type	    = DISEQUAL_TOK;
4548
4549
4550
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1650:14: ( '!=' )
4551
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1650:16: '!='
4552
    {
4553
130
        MATCHS(lit_46);
4554
130
        if  (HASEXCEPTION())
4555
        {
4556
            goto ruleDISEQUAL_TOKEx;
4557
        }
4558
4559
4560
4561
4562
    }
4563
4564
130
	LEXSTATE->type = _type;
4565
    // This is where rules clean up and exit
4566
    //
4567
130
    goto ruleDISEQUAL_TOKEx; /* Prevent compiler warnings */
4568
130
    ruleDISEQUAL_TOKEx: ;
4569
4570
130
}
4571
// $ANTLR end DISEQUAL_TOK
4572
4573
//   Comes from: 1653:13: ( 'cnf' )
4574
/** \brief Lexer rule generated by ANTLR3
4575
 *
4576
 * $ANTLR start CNF_TOK
4577
 *
4578
 * Looks to match the characters the constitute the token CNF_TOK
4579
 * from the attached input stream.
4580
 *
4581
 *
4582
 * \remark
4583
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4584
 */
4585
static ANTLR3_INLINE
4586
88
void mCNF_TOK(pTptpLexer ctx)
4587
{
4588
	ANTLR3_UINT32	_type;
4589
4590
88
    _type	    = CNF_TOK;
4591
4592
4593
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1653:13: ( 'cnf' )
4594
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1653:15: 'cnf'
4595
    {
4596
88
        MATCHS(lit_47);
4597
88
        if  (HASEXCEPTION())
4598
        {
4599
            goto ruleCNF_TOKEx;
4600
        }
4601
4602
4603
4604
4605
    }
4606
4607
88
	LEXSTATE->type = _type;
4608
    // This is where rules clean up and exit
4609
    //
4610
88
    goto ruleCNF_TOKEx; /* Prevent compiler warnings */
4611
88
    ruleCNF_TOKEx: ;
4612
4613
88
}
4614
// $ANTLR end CNF_TOK
4615
4616
//   Comes from: 1654:13: ( 'fof' )
4617
/** \brief Lexer rule generated by ANTLR3
4618
 *
4619
 * $ANTLR start FOF_TOK
4620
 *
4621
 * Looks to match the characters the constitute the token FOF_TOK
4622
 * from the attached input stream.
4623
 *
4624
 *
4625
 * \remark
4626
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4627
 */
4628
static ANTLR3_INLINE
4629
75
void mFOF_TOK(pTptpLexer ctx)
4630
{
4631
	ANTLR3_UINT32	_type;
4632
4633
75
    _type	    = FOF_TOK;
4634
4635
4636
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1654:13: ( 'fof' )
4637
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1654:15: 'fof'
4638
    {
4639
75
        MATCHS(lit_48);
4640
75
        if  (HASEXCEPTION())
4641
        {
4642
            goto ruleFOF_TOKEx;
4643
        }
4644
4645
4646
4647
4648
    }
4649
4650
75
	LEXSTATE->type = _type;
4651
    // This is where rules clean up and exit
4652
    //
4653
75
    goto ruleFOF_TOKEx; /* Prevent compiler warnings */
4654
75
    ruleFOF_TOKEx: ;
4655
4656
75
}
4657
// $ANTLR end FOF_TOK
4658
4659
//   Comes from: 1655:13: ( 'thf' )
4660
/** \brief Lexer rule generated by ANTLR3
4661
 *
4662
 * $ANTLR start THF_TOK
4663
 *
4664
 * Looks to match the characters the constitute the token THF_TOK
4665
 * from the attached input stream.
4666
 *
4667
 *
4668
 * \remark
4669
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4670
 */
4671
static ANTLR3_INLINE
4672
1330
void mTHF_TOK(pTptpLexer ctx)
4673
{
4674
	ANTLR3_UINT32	_type;
4675
4676
1330
    _type	    = THF_TOK;
4677
4678
4679
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1655:13: ( 'thf' )
4680
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1655:15: 'thf'
4681
    {
4682
1330
        MATCHS(lit_49);
4683
1330
        if  (HASEXCEPTION())
4684
        {
4685
            goto ruleTHF_TOKEx;
4686
        }
4687
4688
4689
4690
4691
    }
4692
4693
1330
	LEXSTATE->type = _type;
4694
    // This is where rules clean up and exit
4695
    //
4696
1330
    goto ruleTHF_TOKEx; /* Prevent compiler warnings */
4697
1330
    ruleTHF_TOKEx: ;
4698
4699
1330
}
4700
// $ANTLR end THF_TOK
4701
4702
//   Comes from: 1656:13: ( 'tff' )
4703
/** \brief Lexer rule generated by ANTLR3
4704
 *
4705
 * $ANTLR start TFF_TOK
4706
 *
4707
 * Looks to match the characters the constitute the token TFF_TOK
4708
 * from the attached input stream.
4709
 *
4710
 *
4711
 * \remark
4712
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4713
 */
4714
static ANTLR3_INLINE
4715
209
void mTFF_TOK(pTptpLexer ctx)
4716
{
4717
	ANTLR3_UINT32	_type;
4718
4719
209
    _type	    = TFF_TOK;
4720
4721
4722
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1656:13: ( 'tff' )
4723
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1656:15: 'tff'
4724
    {
4725
209
        MATCHS(lit_50);
4726
209
        if  (HASEXCEPTION())
4727
        {
4728
            goto ruleTFF_TOKEx;
4729
        }
4730
4731
4732
4733
4734
    }
4735
4736
209
	LEXSTATE->type = _type;
4737
    // This is where rules clean up and exit
4738
    //
4739
209
    goto ruleTFF_TOKEx; /* Prevent compiler warnings */
4740
209
    ruleTFF_TOKEx: ;
4741
4742
209
}
4743
// $ANTLR end TFF_TOK
4744
4745
//   Comes from: 1657:13: ( 'type' )
4746
/** \brief Lexer rule generated by ANTLR3
4747
 *
4748
 * $ANTLR start TYPE_TOK
4749
 *
4750
 * Looks to match the characters the constitute the token TYPE_TOK
4751
 * from the attached input stream.
4752
 *
4753
 *
4754
 * \remark
4755
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4756
 */
4757
static ANTLR3_INLINE
4758
381
void mTYPE_TOK(pTptpLexer ctx)
4759
{
4760
	ANTLR3_UINT32	_type;
4761
4762
381
    _type	    = TYPE_TOK;
4763
4764
4765
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1657:13: ( 'type' )
4766
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1657:15: 'type'
4767
    {
4768
381
        MATCHS(lit_51);
4769
381
        if  (HASEXCEPTION())
4770
        {
4771
            goto ruleTYPE_TOKEx;
4772
        }
4773
4774
4775
4776
4777
    }
4778
4779
381
	LEXSTATE->type = _type;
4780
    // This is where rules clean up and exit
4781
    //
4782
381
    goto ruleTYPE_TOKEx; /* Prevent compiler warnings */
4783
381
    ruleTYPE_TOKEx: ;
4784
4785
381
}
4786
// $ANTLR end TYPE_TOK
4787
4788
//   Comes from: 1658:13: ( 'include' )
4789
/** \brief Lexer rule generated by ANTLR3
4790
 *
4791
 * $ANTLR start INCLUDE_TOK
4792
 *
4793
 * Looks to match the characters the constitute the token INCLUDE_TOK
4794
 * from the attached input stream.
4795
 *
4796
 *
4797
 * \remark
4798
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4799
 */
4800
static ANTLR3_INLINE
4801
9
void mINCLUDE_TOK(pTptpLexer ctx)
4802
{
4803
	ANTLR3_UINT32	_type;
4804
4805
9
    _type	    = INCLUDE_TOK;
4806
4807
4808
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1658:13: ( 'include' )
4809
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1658:15: 'include'
4810
    {
4811
9
        MATCHS(lit_52);
4812
9
        if  (HASEXCEPTION())
4813
        {
4814
            goto ruleINCLUDE_TOKEx;
4815
        }
4816
4817
4818
4819
4820
    }
4821
4822
9
	LEXSTATE->type = _type;
4823
    // This is where rules clean up and exit
4824
    //
4825
9
    goto ruleINCLUDE_TOKEx; /* Prevent compiler warnings */
4826
9
    ruleINCLUDE_TOKEx: ;
4827
4828
9
}
4829
// $ANTLR end INCLUDE_TOK
4830
4831
//   Comes from: 1661:16: ( '$' LOWER_WORD )
4832
/** \brief Lexer rule generated by ANTLR3
4833
 *
4834
 * $ANTLR start DEFINED_SYMBOL
4835
 *
4836
 * Looks to match the characters the constitute the token DEFINED_SYMBOL
4837
 * from the attached input stream.
4838
 *
4839
 *
4840
 * \remark
4841
 *  - lexer->error == ANTLR3_TRUE if an exception was thrown.
4842
 */
4843
static ANTLR3_INLINE
4844
2399
void mDEFINED_SYMBOL(pTptpLexer ctx)
4845
{
4846
	ANTLR3_UINT32	_type;
4847
4848
2399
    _type	    = DEFINED_SYMBOL;
4849
4850
4851
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1661:16: ( '$' LOWER_WORD )
4852
    // /barrett/scratch/cvc4-nightly/src/cvc4-2021-03-23/src/parser/tptp/Tptp.g:1661:18: '$' LOWER_WORD
4853
    {
4854
2399
        MATCHC('$');
4855
2399
        if  (HASEXCEPTION())
4856
        {
4857
            goto ruleDEFINED_SYMBOLEx;
4858
        }
4859
4860
4861
        /* 1661:18: '$' LOWER_WORD */
4862
2399
        mLOWER_WORD(ctx );
4863
<