JavaParser/com/github/javaparser/GeneratedJavaParserTokenManager.java

1	/* GeneratedJavaParserTokenManager.java */
2	/* Generated by: ParserGeneratorCC: Do not edit this line. GeneratedJavaParserTokenManager.java */
3	/*
4	* Copyright (C) 2007-2010 Júlio Vilmar Gesser.
5	* Copyright (C) 2011, 2013-2020 The JavaParser Team.
6	*
7	* This file is part of JavaParser.
8	*
9	* JavaParser can be used either under the terms of
10	* a) the GNU Lesser General Public License as published by
11	* the Free Software Foundation, either version 3 of the License, or
12	* (at your option) any later version.
13	* b) the terms of the Apache License
14	*
15	* You should have received a copy of both licenses in LICENCE.LGPL and
16	* LICENCE.APACHE. Please refer to those files for details.
17	*
18	* JavaParser is distributed in the hope that it will be useful,
19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	* GNU Lesser General Public License for more details.
22	*/
23	package com.github.javaparser;
24	import java.io.*;
25	import java.util.*;
26	import com.github.javaparser.ast.*;
27	import com.github.javaparser.ast.body.*;
28	import com.github.javaparser.ast.comments.*;
29	import com.github.javaparser.ast.modules.*;
30	import com.github.javaparser.ast.expr.*;
31	import com.github.javaparser.ast.stmt.*;
32	import com.github.javaparser.ast.type.*;
33	import com.github.javaparser.utils.*;
34	import static com.github.javaparser.JavaToken.INVALID;
35	import static com.github.javaparser.ast.Node.Parsedness.UNPARSABLE;
36	import static com.github.javaparser.utils.Utils.*;
37	import static com.github.javaparser.ast.NodeList.*;
38	import static com.github.javaparser.GeneratedJavaParser.*;
39	import static com.github.javaparser.Range.*;
40	import static com.github.javaparser.Position.*;
41	import static com.github.javaparser.ast.type.ArrayType.*;
42	import static com.github.javaparser.GeneratedJavaParserTokenManagerBase.*;
43	import static com.github.javaparser.ast.stmt.SwitchEntry.Type.*;
44
45	/** Token Manager. */
46	@SuppressWarnings ("unused")
47	public class GeneratedJavaParserTokenManager implements GeneratedJavaParserConstants {
48	private List<JavaToken> tokens = new ArrayList<JavaToken>();
49	private CommentsCollection commentsCollection = new CommentsCollection();
50	private JavaToken homeToken;
51	private Stack<Token> tokenWorkStack = new Stack<Token>();
52	private boolean storeTokens;
53	private boolean yieldSupported = false;
54
55	void reset() {
56	tokens = new ArrayList<JavaToken>();
57	commentsCollection = new CommentsCollection();
58	homeToken = null;
59	}
60
61	List<JavaToken> getTokens() {
62	if(storeTokens) {
63	return tokens;
64	}
65	return null;
66	}
67
68	CommentsCollection getCommentsCollection() {
69	return commentsCollection;
70	}
71
72	/* Get the very first token in the file */
73	JavaToken getHomeToken() {
74	return homeToken;
75	}
76
77	/* Makes the parser keep a list of tokens */
78	public void setStoreTokens(boolean storeTokens) {
79	this.storeTokens = storeTokens;
80	}
81
82	public void setYieldSupported() {
83	yieldSupported = true;
84	}
85
86	private void CommonTokenAction(Token token) {
87	// Use an intermediary stack to avoid recursion, see issue 1003
88	do {
89	tokenWorkStack.push(token);
90	token = token.specialToken;
91	} while (token != null);
92
93	// The stack is now filled with tokens in left-to-right order. Process them.
94	while(!tokenWorkStack.empty()) {
95	token = tokenWorkStack.pop();
96	token.javaToken = new JavaToken(token, tokens);
97
98	if(storeTokens) {
99	tokens.add(token.javaToken);
100	}
101
102	if (homeToken == null) {
103	homeToken = token.javaToken;
104	}
105
106	if(TokenTypes.isComment(token.kind)) {
107	Comment comment = createCommentFromToken(token);
108	commentsCollection.addComment(comment);
109	}
110	}
111	}
112	private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2){
113	switch (pos)
114	{
115	case 0:
116	if ((active1 & 0x4000000L) != 0x0L)
117	return 141;
118	if ((active0 & 0xfffffffffffff800L) != 0x0L \|\| (active1 & 0x7ffL) != 0x0L)
119	{
120	jjmatchedKind = 93;
121	return 142;
122	}
123	if ((active1 & 0x10000000000L) != 0x0L \|\| (active2 & 0x2000L) != 0x0L)
124	return 2;
125	if ((active0 & 0x80L) != 0x0L \|\| (active1 & 0x1000000000000000L) != 0x0L \|\| (active2 & 0x20L) != 0x0L)
126	return 56;
127	return -1;
128	case 1:
129	if ((active1 & 0x4000000L) != 0x0L)
130	{
131	if (jjmatchedPos != 1)
132	{
133	jjmatchedKind = 89;
134	jjmatchedPos = 1;
135	}
136	return -1;
137	}
138	if ((active0 & 0x401800000L) != 0x0L \|\| (active1 & 0x4L) != 0x0L)
139	return 142;
140	if ((active0 & 0x80L) != 0x0L)
141	return 58;
142	if ((active0 & 0xfffffffbfe7ff800L) != 0x0L \|\| (active1 & 0x7fbL) != 0x0L)
143	{
144	if (jjmatchedPos != 1)
145	{
146	jjmatchedKind = 93;
147	jjmatchedPos = 1;
148	}
149	return 142;
150	}
151	return -1;
152	case 2:
153	if ((active0 & 0xeffffb3aff7ff800L) != 0x0L \|\| (active1 & 0x7fbL) != 0x0L)
154	{
155	if (jjmatchedPos != 2)
156	{
157	jjmatchedKind = 93;
158	jjmatchedPos = 2;
159	}
160	return 142;
161	}
162	if ((active1 & 0x4000000L) != 0x0L)
163	{
164	if (jjmatchedPos < 1)
165	{
166	jjmatchedKind = 89;
167	jjmatchedPos = 1;
168	}
169	return -1;
170	}
171	if ((active0 & 0x100004c100000000L) != 0x0L)
172	return 142;
173	return -1;
174	case 3:
175	if ((active0 & 0x2880090206058000L) != 0x0L \|\| (active1 & 0x78L) != 0x0L)
176	return 142;
177	if ((active0 & 0xc77ff2b8f97a7800L) != 0x0L \|\| (active1 & 0x783L) != 0x0L)
178	{
179	if (jjmatchedPos != 3)
180	{
181	jjmatchedKind = 93;
182	jjmatchedPos = 3;
183	}
184	return 142;
185	}
186	return -1;
187	case 4:
188	if ((active0 & 0x446df2b809603800L) != 0x0L \|\| (active1 & 0x782L) != 0x0L)
189	{
190	if (jjmatchedPos != 4)
191	{
192	jjmatchedKind = 93;
193	jjmatchedPos = 4;
194	}
195	return 142;
196	}
197	if ((active0 & 0x83120000f01a4000L) != 0x0L \|\| (active1 & 0x21L) != 0x0L)
198	return 142;
199	return -1;
200	case 5:
201	if ((active0 & 0x225821001001000L) != 0x0L \|\| (active1 & 0x80L) != 0x0L)
202	return 142;
203	if ((active0 & 0x444870a848602800L) != 0x0L \|\| (active1 & 0x702L) != 0x0L)
204	{
205	jjmatchedKind = 93;
206	jjmatchedPos = 5;
207	return 142;
208	}
209	return -1;
210	case 6:
211	if ((active0 & 0x300048402000L) != 0x0L \|\| (active1 & 0x100L) != 0x0L)
212	return 142;
213	if ((active0 & 0x444840a800200800L) != 0x0L \|\| (active1 & 0x602L) != 0x0L)
214	{
215	jjmatchedKind = 93;
216	jjmatchedPos = 6;
217	return 142;
218	}
219	return -1;
220	case 7:
221	if ((active0 & 0x44040a800000000L) != 0x0L \|\| (active1 & 0x400L) != 0x0L)
222	{
223	jjmatchedKind = 93;
224	jjmatchedPos = 7;
225	return 142;
226	}
227	if ((active0 & 0x4008000000200800L) != 0x0L \|\| (active1 & 0x202L) != 0x0L)
228	return 142;
229	return -1;
230	case 8:
231	if ((active0 & 0x40002800000000L) != 0x0L \|\| (active1 & 0x400L) != 0x0L)
232	{
233	jjmatchedKind = 93;
234	jjmatchedPos = 8;
235	return 142;
236	}
237	if ((active0 & 0x400408000000000L) != 0x0L)
238	return 142;
239	return -1;
240	case 9:
241	if ((active0 & 0x2800000000L) != 0x0L \|\| (active1 & 0x400L) != 0x0L)
242	return 142;
243	if ((active0 & 0x40000000000000L) != 0x0L)
244	{
245	jjmatchedKind = 93;
246	jjmatchedPos = 9;
247	return 142;
248	}
249	return -1;
250	case 10:
251	if ((active0 & 0x40000000000000L) != 0x0L)
252	{
253	jjmatchedKind = 93;
254	jjmatchedPos = 10;
255	return 142;
256	}
257	return -1;
258	default :
259	return -1;
260	}
261	}
262	private final int jjStartNfa_0(int pos, long active0, long active1, long active2){
263	return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
264	}
265	private int jjStopAtPos(int pos, int kind)
266	{
267	jjmatchedKind = kind;
268	jjmatchedPos = pos;
269	return pos + 1;
270	}
271	private int jjMoveStringLiteralDfa0_0(){
272	switch(curChar)
273	{
274	case 10:
275	return jjStopAtPos(0, 3);
276	case 13:
277	jjmatchedKind = 4;
278	return jjMoveStringLiteralDfa1_0(0x4L, 0x0L, 0x0L);
279	case 26:
280	return jjStopAtPos(0, 146);
281	case '!':
282	jjmatchedKind = 108;
283	return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L, 0x0L);
284	case '"':
285	return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L, 0x0L);
286	case '%':
287	jjmatchedKind = 128;
288	return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x200L);
289	case '&':
290	jjmatchedKind = 125;
291	return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L, 0x40L);
292	case '(':
293	return jjStopAtPos(0, 96);
294	case ')':
295	return jjStopAtPos(0, 97);
296	case '*':
297	jjmatchedKind = 123;
298	return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x10L);
299	case '+':
300	jjmatchedKind = 121;
301	return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L, 0x4L);
302	case ',':
303	return jjStopAtPos(0, 103);
304	case '-':
305	jjmatchedKind = 122;
306	return jjMoveStringLiteralDfa1_0(0x0L, 0x101000000000000L, 0x8L);
307	case '.':
308	jjmatchedKind = 104;
309	return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x2000L);
310	case '/':
311	jjmatchedKind = 124;
312	return jjMoveStringLiteralDfa1_0(0x80L, 0x0L, 0x20L);
313	case ':':
314	jjmatchedKind = 111;
315	return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x4000L);
316	case ';':
317	return jjStopAtPos(0, 102);
318	case '<':
319	jjmatchedKind = 107;
320	return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L, 0x402L);
321	case '=':
322	jjmatchedKind = 106;
323	return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L, 0x0L);
324	case '>':
325	jjmatchedKind = 145;
326	return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L, 0x19800L);
327	case '?':
328	return jjStopAtPos(0, 110);
329	case '@':
330	return jjStopAtPos(0, 105);
331	case '[':
332	return jjStopAtPos(0, 100);
333	case ']':
334	return jjStopAtPos(0, 101);
335	case '^':
336	jjmatchedKind = 127;
337	return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x100L);
338	case 'a':
339	return jjMoveStringLiteralDfa1_0(0x1800L, 0x0L, 0x0L);
340	case 'b':
341	return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L, 0x0L);
342	case 'c':
343	return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L, 0x0L);
344	case 'd':
345	return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L, 0x0L);
346	case 'e':
347	return jjMoveStringLiteralDfa1_0(0xe000000L, 0x100L, 0x0L);
348	case 'f':
349	return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L, 0x0L);
350	case 'g':
351	return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L, 0x0L);
352	case 'i':
353	return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L, 0x0L);
354	case 'l':
355	return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L, 0x0L);
356	case 'm':
357	return jjMoveStringLiteralDfa1_0(0x0L, 0x80L, 0x0L);
358	case 'n':
359	return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L, 0x0L);
360	case 'o':
361	return jjMoveStringLiteralDfa1_0(0x0L, 0x30L, 0x0L);
362	case 'p':
363	return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x200L, 0x0L);
364	case 'r':
365	return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x2L, 0x0L);
366	case 's':
367	return jjMoveStringLiteralDfa1_0(0x7e000000000000L, 0x0L, 0x0L);
368	case 't':
369	return jjMoveStringLiteralDfa1_0(0x1f80000000000000L, 0x404L, 0x0L);
370	case 'u':
371	return jjMoveStringLiteralDfa1_0(0x0L, 0x40L, 0x0L);
372	case 'v':
373	return jjMoveStringLiteralDfa1_0(0x6000000000000000L, 0x0L, 0x0L);
374	case 'w':
375	return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x8L, 0x0L);
376	case 'y':
377	return jjMoveStringLiteralDfa1_0(0x0L, 0x1L, 0x0L);
378	case '{':
379	return jjStopAtPos(0, 98);
380	case '\|':
381	jjmatchedKind = 126;
382	return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L, 0x80L);
383	case '}':
384	return jjStopAtPos(0, 99);
385	case '~':
386	return jjStopAtPos(0, 109);
387	default :
388	return jjMoveNfa_0(0, 0);
389	}
390	}
391	private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2){
392	try { curChar = input_stream.readChar(); }
393	catch(java.io.IOException e) {
394	jjStopStringLiteralDfa_0(0, active0, active1, active2);
395	return 1;
396	}
397	switch(curChar)
398	{
399	case 10:
400	if ((active0 & 0x4L) != 0x0L)
401	return jjStopAtPos(1, 2);
402	break;
403	case '"':
404	return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x4000000L, active2, 0x0L);
405	case '&':
406	if ((active1 & 0x20000000000000L) != 0x0L)
407	return jjStopAtPos(1, 117);
408	break;
409	case '*':
410	if ((active0 & 0x80L) != 0x0L)
411	return jjStartNfaWithStates_0(1, 7, 58);
412	break;
413	case '+':
414	if ((active1 & 0x80000000000000L) != 0x0L)
415	return jjStopAtPos(1, 119);
416	break;
417	case '-':
418	if ((active1 & 0x100000000000000L) != 0x0L)
419	return jjStopAtPos(1, 120);
420	break;
421	case '.':
422	return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
423	case ':':
424	if ((active2 & 0x4000L) != 0x0L)
425	return jjStopAtPos(1, 142);
426	break;
427	case '<':
428	if ((active2 & 0x2L) != 0x0L)
429	{
430	jjmatchedKind = 129;
431	jjmatchedPos = 1;
432	}
433	return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
434	case '=':
435	if ((active1 & 0x2000000000000L) != 0x0L)
436	return jjStopAtPos(1, 113);
437	else if ((active1 & 0x4000000000000L) != 0x0L)
438	return jjStopAtPos(1, 114);
439	else if ((active1 & 0x8000000000000L) != 0x0L)
440	return jjStopAtPos(1, 115);
441	else if ((active1 & 0x10000000000000L) != 0x0L)
442	return jjStopAtPos(1, 116);
443	else if ((active2 & 0x4L) != 0x0L)
444	return jjStopAtPos(1, 130);
445	else if ((active2 & 0x8L) != 0x0L)
446	return jjStopAtPos(1, 131);
447	else if ((active2 & 0x10L) != 0x0L)
448	return jjStopAtPos(1, 132);
449	else if ((active2 & 0x20L) != 0x0L)
450	return jjStopAtPos(1, 133);
451	else if ((active2 & 0x40L) != 0x0L)
452	return jjStopAtPos(1, 134);
453	else if ((active2 & 0x80L) != 0x0L)
454	return jjStopAtPos(1, 135);
455	else if ((active2 & 0x100L) != 0x0L)
456	return jjStopAtPos(1, 136);
457	else if ((active2 & 0x200L) != 0x0L)
458	return jjStopAtPos(1, 137);
459	break;
460	case '>':
461	if ((active1 & 0x1000000000000L) != 0x0L)
462	return jjStopAtPos(1, 112);
463	else if ((active2 & 0x10000L) != 0x0L)
464	{
465	jjmatchedKind = 144;
466	jjmatchedPos = 1;
467	}
468	return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x9800L);
469	case 'a':
470	return jjMoveStringLiteralDfa2_0(active0, 0x120010030000L, active1, 0x0L, active2, 0x0L);
471	case 'b':
472	return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x0L, active2, 0x0L);
473	case 'e':
474	return jjMoveStringLiteralDfa2_0(active0, 0x1040000400000L, active1, 0x2L, active2, 0x0L);
475	case 'f':
476	if ((active0 & 0x400000000L) != 0x0L)
477	return jjStartNfaWithStates_0(1, 34, 142);
478	break;
479	case 'h':
480	return jjMoveStringLiteralDfa2_0(active0, 0x8382000000040000L, active1, 0x0L, active2, 0x0L);
481	case 'i':
482	return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0x9L, active2, 0x0L);
483	case 'l':
484	return jjMoveStringLiteralDfa2_0(active0, 0x82080000L, active1, 0x0L, active2, 0x0L);
485	case 'm':
486	return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0x0L, active2, 0x0L);
487	case 'n':
488	return jjMoveStringLiteralDfa2_0(active0, 0xe004000000L, active1, 0x0L, active2, 0x0L);
489	case 'o':
490	if ((active0 & 0x800000L) != 0x0L)
491	{
492	jjmatchedKind = 23;
493	jjmatchedPos = 1;
494	}
495	else if ((active1 & 0x4L) != 0x0L)
496	return jjStartNfaWithStates_0(1, 66, 142);
497	return jjMoveStringLiteralDfa2_0(active0, 0x6000010301302000L, active1, 0x80L, active2, 0x0L);
498	case 'p':
499	return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x30L, active2, 0x0L);
500	case 'r':
501	return jjMoveStringLiteralDfa2_0(active0, 0x1c00600000004000L, active1, 0x600L, active2, 0x0L);
502	case 's':
503	return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0x40L, active2, 0x0L);
504	case 't':
505	return jjMoveStringLiteralDfa2_0(active0, 0xc000000000000L, active1, 0x0L, active2, 0x0L);
506	case 'u':
507	return jjMoveStringLiteralDfa2_0(active0, 0x10880000000000L, active1, 0x0L, active2, 0x0L);
508	case 'w':
509	return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
510	case 'x':
511	return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0x100L, active2, 0x0L);
512	case 'y':
513	return jjMoveStringLiteralDfa2_0(active0, 0x40000000008000L, active1, 0x0L, active2, 0x0L);
514	case '\|':
515	if ((active1 & 0x40000000000000L) != 0x0L)
516	return jjStopAtPos(1, 118);
517	break;
518	default :
519	break;
520	}
521	return jjStartNfa_0(0, active0, active1, active2);
522	}
523	private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2){
524	if (((active0 &= old0) \| (active1 &= old1) \| (active2 &= old2)) == 0L)
525	return jjStartNfa_0(0, old0, old1, old2);
526	try { curChar = input_stream.readChar(); }
527	catch(java.io.IOException e) {
528	jjStopStringLiteralDfa_0(1, active0, active1, active2);
529	return 2;
530	}
531	switch(curChar)
532	{
533	case '"':
534	if ((active1 & 0x4000000L) != 0x0L)
535	return jjStopAtPos(2, 90);
536	break;
537	case '.':
538	if ((active2 & 0x2000L) != 0x0L)
539	return jjStopAtPos(2, 141);
540	break;
541	case '=':
542	if ((active2 & 0x400L) != 0x0L)
543	return jjStopAtPos(2, 138);
544	else if ((active2 & 0x800L) != 0x0L)
545	return jjStopAtPos(2, 139);
546	break;
547	case '>':
548	if ((active2 & 0x8000L) != 0x0L)
549	{
550	jjmatchedKind = 143;
551	jjmatchedPos = 2;
552	}
553	return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
554	case 'a':
555	return jjMoveStringLiteralDfa3_0(active0, 0x4040000000c0000L, active1, 0x400L, active2, 0x0L);
556	case 'b':
557	return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x0L);
558	case 'c':
559	return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
560	case 'd':
561	return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x80L, active2, 0x0L);
562	case 'e':
563	return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0x71L, active2, 0x0L);
564	case 'f':
565	return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0x0L, active2, 0x0L);
566	case 'i':
567	return jjMoveStringLiteralDfa3_0(active0, 0xa0a0200000000000L, active1, 0x0L, active2, 0x0L);
568	case 'l':
569	return jjMoveStringLiteralDfa3_0(active0, 0x4000080010000000L, active1, 0x0L, active2, 0x0L);
570	case 'n':
571	return jjMoveStringLiteralDfa3_0(active0, 0x40010060300000L, active1, 0x0L, active2, 0x0L);
572	case 'o':
573	return jjMoveStringLiteralDfa3_0(active0, 0x2400080002000L, active1, 0x200L, active2, 0x0L);
574	case 'p':
575	return jjMoveStringLiteralDfa3_0(active0, 0x10001800000000L, active1, 0x100L, active2, 0x0L);
576	case 'q':
577	return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x2L, active2, 0x0L);
578	case 'r':
579	if ((active0 & 0x100000000L) != 0x0L)
580	return jjStartNfaWithStates_0(2, 32, 142);
581	return jjMoveStringLiteralDfa3_0(active0, 0x308000000000000L, active1, 0x0L, active2, 0x0L);
582	case 's':
583	return jjMoveStringLiteralDfa3_0(active0, 0x2002011800L, active1, 0x0L, active2, 0x0L);
584	case 't':
585	if ((active0 & 0x4000000000L) != 0x0L)
586	{
587	jjmatchedKind = 38;
588	jjmatchedPos = 2;
589	}
590	return jjMoveStringLiteralDfa3_0(active0, 0x1028208028000L, active1, 0x8L, active2, 0x0L);
591	case 'u':
592	return jjMoveStringLiteralDfa3_0(active0, 0x800000005000000L, active1, 0x0L, active2, 0x0L);
593	case 'w':
594	if ((active0 & 0x40000000000L) != 0x0L)
595	return jjStartNfaWithStates_0(2, 42, 142);
596	break;
597	case 'y':
598	if ((active0 & 0x1000000000000000L) != 0x0L)
599	return jjStartNfaWithStates_0(2, 60, 142);
600	break;
601	default :
602	break;
603	}
604	return jjStartNfa_0(1, active0, active1, active2);
605	}
606	private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2){
607	if (((active0 &= old0) \| (active1 &= old1) \| (active2 &= old2)) == 0L)
608	return jjStartNfa_0(1, old0, old1, old2);
609	try { curChar = input_stream.readChar(); }
610	catch(java.io.IOException e) {
611	jjStopStringLiteralDfa_0(2, active0, active1, active2);
612	return 3;
613	}
614	switch(curChar)
615	{
616	case '=':
617	if ((active2 & 0x1000L) != 0x0L)
618	return jjStopAtPos(3, 140);
619	break;
620	case 'a':
621	return jjMoveStringLiteralDfa4_0(active0, 0x40000000e0404000L, active1, 0x0L, active2, 0x0L);
622	case 'b':
623	return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0x0L, active2, 0x0L);
624	case 'c':
625	return jjMoveStringLiteralDfa4_0(active0, 0x40000000020000L, active1, 0x0L, active2, 0x0L);
626	case 'd':
627	if ((active0 & 0x2000000000000000L) != 0x0L)
628	return jjStartNfaWithStates_0(3, 61, 142);
629	break;
630	case 'e':
631	if ((active0 & 0x8000L) != 0x0L)
632	return jjStartNfaWithStates_0(3, 15, 142);
633	else if ((active0 & 0x10000L) != 0x0L)
634	return jjStartNfaWithStates_0(3, 16, 142);
635	else if ((active0 & 0x2000000L) != 0x0L)
636	return jjStartNfaWithStates_0(3, 25, 142);
637	else if ((active0 & 0x800000000000000L) != 0x0L)
638	return jjStartNfaWithStates_0(3, 59, 142);
639	return jjMoveStringLiteralDfa4_0(active0, 0x10008008001000L, active1, 0x0L, active2, 0x0L);
640	case 'g':
641	if ((active0 & 0x10000000000L) != 0x0L)
642	return jjStartNfaWithStates_0(3, 40, 142);
643	break;
644	case 'h':
645	if ((active1 & 0x8L) != 0x0L)
646	return jjStartNfaWithStates_0(3, 67, 142);
647	break;
648	case 'i':
649	return jjMoveStringLiteralDfa4_0(active0, 0x8020000000000L, active1, 0x0L, active2, 0x0L);
650	case 'k':
651	return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
652	case 'l':
653	if ((active0 & 0x80000000000L) != 0x0L)
654	return jjStartNfaWithStates_0(3, 43, 142);
655	return jjMoveStringLiteralDfa4_0(active0, 0x8000800800002000L, active1, 0x1L, active2, 0x0L);
656	case 'm':
657	if ((active0 & 0x4000000L) != 0x0L)
658	return jjStartNfaWithStates_0(3, 26, 142);
659	break;
660	case 'n':
661	if ((active1 & 0x10L) != 0x0L)
662	{
663	jjmatchedKind = 68;
664	jjmatchedPos = 3;
665	}
666	return jjMoveStringLiteralDfa4_0(active0, 0x400000000000000L, active1, 0x420L, active2, 0x0L);
667	case 'o':
668	if ((active0 & 0x200000000L) != 0x0L)
669	return jjStartNfaWithStates_0(3, 33, 142);
670	return jjMoveStringLiteralDfa4_0(active0, 0x300001000000000L, active1, 0x100L, active2, 0x0L);
671	case 'r':
672	if ((active0 & 0x40000L) != 0x0L)
673	return jjStartNfaWithStates_0(3, 18, 142);
674	return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0x0L, active2, 0x0L);
675	case 's':
676	if ((active0 & 0x80000000000000L) != 0x0L)
677	return jjStartNfaWithStates_0(3, 55, 142);
678	else if ((active1 & 0x40L) != 0x0L)
679	return jjStartNfaWithStates_0(3, 70, 142);
680	return jjMoveStringLiteralDfa4_0(active0, 0x10180000L, active1, 0x0L, active2, 0x0L);
681	case 't':
682	return jjMoveStringLiteralDfa4_0(active0, 0x24402000200800L, active1, 0x0L, active2, 0x0L);
683	case 'u':
684	return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0x82L, active2, 0x0L);
685	case 'v':
686	return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0x200L, active2, 0x0L);
687	default :
688	break;
689	}
690	return jjStartNfa_0(2, active0, active1, active2);
691	}
692	private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2){
693	if (((active0 &= old0) \| (active1 &= old1) \| (active2 &= old2)) == 0L)
694	return jjStartNfa_0(2, old0, old1, old2);
695	try { curChar = input_stream.readChar(); }
696	catch(java.io.IOException e) {
697	jjStopStringLiteralDfa_0(3, active0, active1, 0L);
698	return 4;
699	}
700	switch(curChar)
701	{
702	case 'a':
703	return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0x0L);
704	case 'c':
705	return jjMoveStringLiteralDfa5_0(active0, 0x28000000000000L, active1, 0x0L);
706	case 'd':
707	if ((active1 & 0x1L) != 0x0L)
708	return jjStartNfaWithStates_0(4, 64, 142);
709	break;
710	case 'e':
711	if ((active0 & 0x10000000L) != 0x0L)
712	return jjStartNfaWithStates_0(4, 28, 142);
713	else if ((active0 & 0x8000000000000000L) != 0x0L)
714	return jjStartNfaWithStates_0(4, 63, 142);
715	return jjMoveStringLiteralDfa5_0(active0, 0x400800002000L, active1, 0x0L);
716	case 'h':
717	if ((active0 & 0x20000L) != 0x0L)
718	return jjStartNfaWithStates_0(4, 17, 142);
719	return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x0L);
720	case 'i':
721	return jjMoveStringLiteralDfa5_0(active0, 0x4800000200000L, active1, 0x202L);
722	case 'k':
723	if ((active0 & 0x4000L) != 0x0L)
724	return jjStartNfaWithStates_0(4, 14, 142);
725	break;
726	case 'l':
727	if ((active0 & 0x20000000L) != 0x0L)
728	{
729	jjmatchedKind = 29;
730	jjmatchedPos = 4;
731	}
732	return jjMoveStringLiteralDfa5_0(active0, 0x41000000L, active1, 0x80L);
733	case 'n':
734	return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0x0L);
735	case 'r':
736	if ((active0 & 0x10000000000000L) != 0x0L)
737	return jjStartNfaWithStates_0(4, 52, 142);
738	return jjMoveStringLiteralDfa5_0(active0, 0x1009000001800L, active1, 0x100L);
739	case 's':
740	if ((active0 & 0x80000L) != 0x0L)
741	return jjStartNfaWithStates_0(4, 19, 142);
742	else if ((active1 & 0x20L) != 0x0L)
743	return jjStartNfaWithStates_0(4, 69, 142);
744	return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0x400L);
745	case 't':
746	if ((active0 & 0x100000L) != 0x0L)
747	return jjStartNfaWithStates_0(4, 20, 142);
748	else if ((active0 & 0x80000000L) != 0x0L)
749	return jjStartNfaWithStates_0(4, 31, 142);
750	else if ((active0 & 0x2000000000000L) != 0x0L)
751	return jjStartNfaWithStates_0(4, 49, 142);
752	return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000000L, active1, 0x0L);
753	case 'u':
754	return jjMoveStringLiteralDfa5_0(active0, 0x400000L, active1, 0x0L);
755	case 'v':
756	return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0x0L);
757	case 'w':
758	if ((active0 & 0x100000000000000L) != 0x0L)
759	{
760	jjmatchedKind = 56;
761	jjmatchedPos = 4;
762	}
763	return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0x0L);
764	default :
765	break;
766	}
767	return jjStartNfa_0(3, active0, active1, 0L);
768	}
769	private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1){
770	if (((active0 &= old0) \| (active1 &= old1)) == 0L)
771	return jjStartNfa_0(3, old0, old1, 0L);
772	try { curChar = input_stream.readChar(); }
773	catch(java.io.IOException e) {
774	jjStopStringLiteralDfa_0(4, active0, active1, 0L);
775	return 5;
776	}
777	switch(curChar)
778	{
779	case 'a':
780	return jjMoveStringLiteralDfa6_0(active0, 0x2800L, active1, 0x0L);
781	case 'c':
782	if ((active0 & 0x800000000000L) != 0x0L)
783	return jjStartNfaWithStates_0(5, 47, 142);
784	else if ((active0 & 0x4000000000000L) != 0x0L)
785	return jjStartNfaWithStates_0(5, 50, 142);
786	return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0x0L);
787	case 'd':
788	return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0x200L);
789	case 'e':
790	if ((active0 & 0x1000000L) != 0x0L)
791	return jjStartNfaWithStates_0(5, 24, 142);
792	else if ((active0 & 0x20000000000L) != 0x0L)
793	return jjStartNfaWithStates_0(5, 41, 142);
794	else if ((active1 & 0x80L) != 0x0L)
795	return jjStartNfaWithStates_0(5, 71, 142);
796	break;
797	case 'f':
798	return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0x0L);
799	case 'g':
800	return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0x0L);
801	case 'h':
802	if ((active0 & 0x20000000000000L) != 0x0L)
803	return jjStartNfaWithStates_0(5, 53, 142);
804	break;
805	case 'i':
806	return jjMoveStringLiteralDfa6_0(active0, 0x4400000000000000L, active1, 0x400L);
807	case 'l':
808	return jjMoveStringLiteralDfa6_0(active0, 0x40400000L, active1, 0x0L);
809	case 'm':
810	return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0x0L);
811	case 'n':
812	if ((active0 & 0x1000000000000L) != 0x0L)
813	return jjStartNfaWithStates_0(5, 48, 142);
814	return jjMoveStringLiteralDfa6_0(active0, 0x2000200000L, active1, 0x0L);
815	case 'r':
816	return jjMoveStringLiteralDfa6_0(active0, 0x40000000000000L, active1, 0x2L);
817	case 's':
818	if ((active0 & 0x200000000000000L) != 0x0L)
819	return jjStartNfaWithStates_0(5, 57, 142);
820	break;
821	case 't':
822	if ((active0 & 0x1000L) != 0x0L)
823	return jjStartNfaWithStates_0(5, 12, 142);
824	else if ((active0 & 0x1000000000L) != 0x0L)
825	return jjStartNfaWithStates_0(5, 36, 142);
826	return jjMoveStringLiteralDfa6_0(active0, 0x8200000000000L, active1, 0x100L);
827	default :
828	break;
829	}
830	return jjStartNfa_0(4, active0, active1, 0L);
831	}
832	private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1){
833	if (((active0 &= old0) \| (active1 &= old1)) == 0L)
834	return jjStartNfa_0(4, old0, old1, 0L);
835	try { curChar = input_stream.readChar(); }
836	catch(java.io.IOException e) {
837	jjStopStringLiteralDfa_0(5, active0, active1, 0L);
838	return 6;
839	}
840	switch(curChar)
841	{
842	case 'a':
843	return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0x0L);
844	case 'c':
845	return jjMoveStringLiteralDfa7_0(active0, 0x2000000800L, active1, 0x0L);
846	case 'e':
847	if ((active0 & 0x100000000000L) != 0x0L)
848	return jjStartNfaWithStates_0(6, 44, 142);
849	else if ((active0 & 0x200000000000L) != 0x0L)
850	return jjStartNfaWithStates_0(6, 45, 142);
851	return jjMoveStringLiteralDfa7_0(active0, 0x400000800000000L, active1, 0x202L);
852	case 'f':
853	return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L, active1, 0x0L);
854	case 'l':
855	return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L, active1, 0x0L);
856	case 'n':
857	if ((active0 & 0x2000L) != 0x0L)
858	return jjStartNfaWithStates_0(6, 13, 142);
859	break;
860	case 'o':
861	return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000L, active1, 0x0L);
862	case 's':
863	if ((active0 & 0x8000000L) != 0x0L)
864	return jjStartNfaWithStates_0(6, 27, 142);
865	else if ((active1 & 0x100L) != 0x0L)
866	return jjStartNfaWithStates_0(6, 72, 142);
867	break;
868	case 't':
869	if ((active0 & 0x400000L) != 0x0L)
870	return jjStartNfaWithStates_0(6, 22, 142);
871	return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x400L);
872	case 'u':
873	return jjMoveStringLiteralDfa7_0(active0, 0x200000L, active1, 0x0L);
874	case 'y':
875	if ((active0 & 0x40000000L) != 0x0L)
876	return jjStartNfaWithStates_0(6, 30, 142);
877	break;
878	default :
879	break;
880	}
881	return jjStartNfa_0(5, active0, active1, 0L);
882	}
883	private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1){
884	if (((active0 &= old0) \| (active1 &= old1)) == 0L)
885	return jjStartNfa_0(5, old0, old1, 0L);
886	try { curChar = input_stream.readChar(); }
887	catch(java.io.IOException e) {
888	jjStopStringLiteralDfa_0(6, active0, active1, 0L);
889	return 7;
890	}
891	switch(curChar)
892	{
893	case 'c':
894	return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0x0L);
895	case 'e':
896	if ((active0 & 0x200000L) != 0x0L)
897	return jjStartNfaWithStates_0(7, 21, 142);
898	else if ((active0 & 0x4000000000000000L) != 0x0L)
899	return jjStartNfaWithStates_0(7, 62, 142);
900	return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L, active1, 0x0L);
901	case 'i':
902	return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x400L);
903	case 'n':
904	return jjMoveStringLiteralDfa8_0(active0, 0x440000800000000L, active1, 0x0L);
905	case 'p':
906	if ((active0 & 0x8000000000000L) != 0x0L)
907	return jjStartNfaWithStates_0(7, 51, 142);
908	break;
909	case 's':
910	if ((active1 & 0x2L) != 0x0L)
911	return jjStartNfaWithStates_0(7, 65, 142);
912	else if ((active1 & 0x200L) != 0x0L)
913	return jjStartNfaWithStates_0(7, 73, 142);
914	break;
915	case 't':
916	if ((active0 & 0x800L) != 0x0L)
917	return jjStartNfaWithStates_0(7, 11, 142);
918	break;
919	default :
920	break;
921	}
922	return jjStartNfa_0(6, active0, active1, 0L);
923	}
924	private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1){
925	if (((active0 &= old0) \| (active1 &= old1)) == 0L)
926	return jjStartNfa_0(6, old0, old1, 0L);
927	try { curChar = input_stream.readChar(); }
928	catch(java.io.IOException e) {
929	jjStopStringLiteralDfa_0(7, active0, active1, 0L);
930	return 8;
931	}
932	switch(curChar)
933	{
934	case 'd':
935	if ((active0 & 0x400000000000L) != 0x0L)
936	return jjStartNfaWithStates_0(8, 46, 142);
937	break;
938	case 'e':
939	if ((active0 & 0x8000000000L) != 0x0L)
940	return jjStartNfaWithStates_0(8, 39, 142);
941	break;
942	case 'i':
943	return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L, active1, 0x0L);
944	case 'o':
945	return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L, active1, 0x0L);
946	case 't':
947	if ((active0 & 0x400000000000000L) != 0x0L)
948	return jjStartNfaWithStates_0(8, 58, 142);
949	return jjMoveStringLiteralDfa9_0(active0, 0x800000000L, active1, 0x0L);
950	case 'v':
951	return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x400L);
952	default :
953	break;
954	}
955	return jjStartNfa_0(7, active0, active1, 0L);
956	}
957	private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1){
958	if (((active0 &= old0) \| (active1 &= old1)) == 0L)
959	return jjStartNfa_0(7, old0, old1, 0L);
960	try { curChar = input_stream.readChar(); }
961	catch(java.io.IOException e) {
962	jjStopStringLiteralDfa_0(8, active0, active1, 0L);
963	return 9;
964	}
965	switch(curChar)
966	{
967	case 'e':
968	if ((active1 & 0x400L) != 0x0L)
969	return jjStartNfaWithStates_0(9, 74, 142);
970	break;
971	case 'f':
972	if ((active0 & 0x2000000000L) != 0x0L)
973	return jjStartNfaWithStates_0(9, 37, 142);
974	break;
975	case 's':
976	if ((active0 & 0x800000000L) != 0x0L)
977	return jjStartNfaWithStates_0(9, 35, 142);
978	break;
979	case 'z':
980	return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000L, active1, 0x0L);
981	default :
982	break;
983	}
984	return jjStartNfa_0(8, active0, active1, 0L);
985	}
986	private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1){
987	if (((active0 &= old0) \| (active1 &= old1)) == 0L)
988	return jjStartNfa_0(8, old0, old1, 0L);
989	try { curChar = input_stream.readChar(); }
990	catch(java.io.IOException e) {
991	jjStopStringLiteralDfa_0(9, active0, 0L, 0L);
992	return 10;
993	}
994	switch(curChar)
995	{
996	case 'e':
997	return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L);
998	default :
999	break;
1000	}
1001	return jjStartNfa_0(9, active0, 0L, 0L);
1002	}
1003	private int jjMoveStringLiteralDfa11_0(long old0, long active0){
1004	if (((active0 &= old0)) == 0L)
1005	return jjStartNfa_0(9, old0, 0L, 0L);
1006	try { curChar = input_stream.readChar(); }
1007	catch(java.io.IOException e) {
1008	jjStopStringLiteralDfa_0(10, active0, 0L, 0L);
1009	return 11;
1010	}
1011	switch(curChar)
1012	{
1013	case 'd':
1014	if ((active0 & 0x40000000000000L) != 0x0L)
1015	return jjStartNfaWithStates_0(11, 54, 142);
1016	break;
1017	default :
1018	break;
1019	}
1020	return jjStartNfa_0(10, active0, 0L, 0L);
1021	}
1022	private int jjStartNfaWithStates_0(int pos, int kind, int state)
1023	{
1024	jjmatchedKind = kind;
1025	jjmatchedPos = pos;
1026	try { curChar = input_stream.readChar(); }
1027	catch(java.io.IOException e) { return pos + 1; }
1028	return jjMoveNfa_0(state, pos + 1);
1029	}
1030	static final long[] jjbitVec0 = {
1031	0x0L, 0x0L, 0x100000020L, 0x0L
1032	};
1033	static final long[] jjbitVec1 = {
1034	0x0L, 0x0L, 0x1L, 0x0L
1035	};
1036	static final long[] jjbitVec2 = {
1037	0x4000L, 0x0L, 0x0L, 0x0L
1038	};
1039	static final long[] jjbitVec3 = {
1040	0x830000003fffL, 0x180000000L, 0x0L, 0x0L
1041	};
1042	static final long[] jjbitVec4 = {
1043	0x1L, 0x0L, 0x0L, 0x0L
1044	};
1045	static final long[] jjbitVec5 = {
1046	0x0L, 0x0L, 0x0L, 0x8000000000000000L
1047	};
1048	static final long[] jjbitVec6 = {
1049	0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1050	};
1051	static final long[] jjbitVec8 = {
1052	0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1053	};
1054	static final long[] jjbitVec9 = {
1055	0xfff0000040220002L, 0xffffffffffffdfffL, 0xfffff02f7fffffffL, 0x12000000ff7fffffL
1056	};
1057	static final long[] jjbitVec10 = {
1058	0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
1059	};
1060	static final long[] jjbitVec11 = {
1061	0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x501f0003ffc3L
1062	};
1063	static final long[] jjbitVec12 = {
1064	0x0L, 0xbcdf000000000000L, 0xfffffffbffffd740L, 0xffbfffffffffffffL
1065	};
1066	static final long[] jjbitVec13 = {
1067	0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffc03L, 0xffffffffffffffffL
1068	};
1069	static final long[] jjbitVec14 = {
1070	0xfffeffffffffffffL, 0xfffffffe027fffffL, 0x80ffL, 0x707ffffff0000L
1071	};
1072	static final long[] jjbitVec15 = {
1073	0xffffffff00000800L, 0xfffec000000007ffL, 0xffffffffffffffffL, 0x9c00c060002fffffL
1074	};
1075	static final long[] jjbitVec16 = {
1076	0xfffffffd0000L, 0xffffffffffffe000L, 0x2003fffffffffL, 0x43007fffffffc00L
1077	};
1078	static final long[] jjbitVec17 = {
1079	0x110043fffffL, 0x7ff01ffffffL, 0x3fdfffff00000000L, 0x0L
1080	};
1081	static final long[] jjbitVec18 = {
1082	0x23fffffffffffff0L, 0xfffe0003ff010000L, 0x23c5fdfffff99fe1L, 0x180f0003b0004000L
1083	};
1084	static final long[] jjbitVec19 = {
1085	0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbbfe0L, 0x202000300010000L
1086	};
1087	static final long[] jjbitVec20 = {
1088	0x23edfdfffff99fe0L, 0x20003b0000000L, 0x3ffc718d63dc7e8L, 0x200000000010000L
1089	};
1090	static final long[] jjbitVec21 = {
1091	0x23fffdfffffddfe0L, 0x307000000L, 0x23effdfffffddfe1L, 0x6000340000000L
1092	};
1093	static final long[] jjbitVec22 = {
1094	0x27fffffffffddfe0L, 0xfc00000380704000L, 0x2ffbfffffc7fffe0L, 0x7fL
1095	};
1096	static final long[] jjbitVec23 = {
1097	0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0xf000005fL
1098	};
1099	static final long[] jjbitVec24 = {
1100	0x1L, 0x1ffffffffeffL, 0x1f00L, 0x0L
1101	};
1102	static final long[] jjbitVec25 = {
1103	0x800007ffffffffffL, 0xffe1c0623c3f0000L, 0xffffffff00004003L, 0xf7ffffffffff20bfL
1104	};
1105	static final long[] jjbitVec26 = {
1106	0xffffffffffffffffL, 0xffffffff3d7f3dffL, 0x7f3dffffffff3dffL, 0xffffffffff7fff3dL
1107	};
1108	static final long[] jjbitVec27 = {
1109	0xffffffffff3dffffL, 0x7ffffffL, 0xffffffff0000ffffL, 0x3f3fffffffffffffL
1110	};
1111	static final long[] jjbitVec28 = {
1112	0xffffffffffffffffL, 0xffff9fffffffffffL, 0xffffffff07fffffeL, 0x1ffc7ffffffffffL
1113	};
1114	static final long[] jjbitVec29 = {
1115	0x3ffff0003dfffL, 0x1dfff0003ffffL, 0xfffffffffffffL, 0x18800000L
1116	};
1117	static final long[] jjbitVec30 = {
1118	0xffffffff00000000L, 0xffffffffffffffL, 0xffff05ffffffff9fL, 0x3fffffffffffffL
1119	};
1120	static final long[] jjbitVec31 = {
1121	0x7fffffffL, 0x1f3fffffff0000L, 0xffff0fffffffffffL, 0x3ffL
1122	};
1123	static final long[] jjbitVec32 = {
1124	0xffffffff007fffffL, 0x1fffffL, 0x8000000000L, 0x0L
1125	};
1126	static final long[] jjbitVec33 = {
1127	0xfffffffffffe0L, 0xfe0L, 0xfc00c001fffffff8L, 0x3fffffffffL
1128	};
1129	static final long[] jjbitVec34 = {
1130	0xfffffffffL, 0x3ffffffffc00e000L, 0x1ffL, 0x63de0000000000L
1131	};
1132	static final long[] jjbitVec35 = {
1133	0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L
1134	};
1135	static final long[] jjbitVec36 = {
1136	0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
1137	};
1138	static final long[] jjbitVec37 = {
1139	0x8000000000000000L, 0x8002000000100001L, 0xffffffff1fff0000L, 0x0L
1140	};
1141	static final long[] jjbitVec38 = {
1142	0xf3ffbd503e2ffc84L, 0xffffffff000043e0L, 0x1ffL, 0x0L
1143	};
1144	static final long[] jjbitVec39 = {
1145	0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xc781fffffffffL
1146	};
1147	static final long[] jjbitVec40 = {
1148	0xffff20bfffffffffL, 0x80ffffffffffL, 0x7f7f7f7f007fffffL, 0x7f7f7f7fL
1149	};
1150	static final long[] jjbitVec41 = {
1151	0x800000000000L, 0x0L, 0x0L, 0x0L
1152	};
1153	static final long[] jjbitVec42 = {
1154	0x1f3e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffee07fffffL, 0xf7ffffffffffffffL
1155	};
1156	static final long[] jjbitVec43 = {
1157	0xfffe7fffffffffe0L, 0xffffffffffffffffL, 0x7ffffff00007fffL, 0xffff000000000000L
1158	};
1159	static final long[] jjbitVec44 = {
1160	0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
1161	};
1162	static final long[] jjbitVec45 = {
1163	0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x7ffffffffffL
1164	};
1165	static final long[] jjbitVec46 = {
1166	0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x3fffffffffff0000L
1167	};
1168	static final long[] jjbitVec47 = {
1169	0xc00ffff1fffL, 0x80007fffffffffffL, 0xffffffff3fffffffL, 0xffffffffffffL
1170	};
1171	static final long[] jjbitVec48 = {
1172	0xfffffffcff800000L, 0xffffffffffffffffL, 0xff7ffffffff9ffL, 0xff80000000000000L
1173	};
1174	static final long[] jjbitVec49 = {
1175	0x1000007fffff7bbL, 0xfffffffffffffL, 0xffffffffffffcL, 0x28fc000000000000L
1176	};
1177	static final long[] jjbitVec50 = {
1178	0xffff003ffffffc00L, 0x1fffffff0000007fL, 0x7fffffffffff0L, 0x7c00ffdf00008000L
1179	};
1180	static final long[] jjbitVec51 = {
1181	0x1ffffffffffL, 0xc47fffff00000ff7L, 0x3e62ffffffffffffL, 0x1c07ff38000005L
1182	};
1183	static final long[] jjbitVec52 = {
1184	0xffff7f7f007e7e7eL, 0xffff003ff7ffffffL, 0xffffffffffffffffL, 0x7ffffffffL
1185	};
1186	static final long[] jjbitVec53 = {
1187	0xffffffffffffffffL, 0xffffffffffffffffL, 0xffff000fffffffffL, 0xffffffffffff87fL
1188	};
1189	static final long[] jjbitVec54 = {
1190	0xffffffffffffffffL, 0xffff3fffffffffffL, 0xffffffffffffffffL, 0x3ffffffL
1191	};
1192	static final long[] jjbitVec55 = {
1193	0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1194	};
1195	static final long[] jjbitVec56 = {
1196	0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0x1fff0000000000ffL
1197	};
1198	static final long[] jjbitVec57 = {
1199	0x18000000000000L, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
1200	};
1201	static final long[] jjbitVec58 = {
1202	0x87fffffe00000010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
1203	};
1204	static final long[] jjbitVec59 = {
1205	0x0L, 0x0L, 0x420243cffffffffL, 0xff7fffffff7fffffL
1206	};
1207	static final long[] jjbitVec60 = {
1208	0xffffffffffffffffL, 0xbcdfffffffffffffL, 0xfffffffbffffd740L, 0xffbfffffffffffffL
1209	};
1210	static final long[] jjbitVec61 = {
1211	0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffcfbL, 0xffffffffffffffffL
1212	};
1213	static final long[] jjbitVec62 = {
1214	0xfffeffffffffffffL, 0xfffffffe027fffffL, 0xbffffffffffe80ffL, 0x707ffffff00b6L
1215	};
1216	static final long[] jjbitVec63 = {
1217	0xffffffff17ff083fL, 0xffffc3ffffffffffL, 0xffffffffffffffffL, 0x9ffffdffbfefffffL
1218	};
1219	static final long[] jjbitVec64 = {
1220	0xffffffffffff8000L, 0xffffffffffffe7ffL, 0x3ffffffffffffL, 0x43fffffffffffffL
1221	};
1222	static final long[] jjbitVec65 = {
1223	0x3fffffffffffL, 0x7ff0fffffffL, 0x3fdfffff00000000L, 0xfffffffffff00000L
1224	};
1225	static final long[] jjbitVec66 = {
1226	0xffffffffffffffffL, 0xfffeffcfffffffffL, 0xf3c5fdfffff99fefL, 0x180fffcfb080799fL
1227	};
1228	static final long[] jjbitVec67 = {
1229	0xd36dfdfffff987eeL, 0x3fffc05e023987L, 0xf3edfdfffffbbfeeL, 0xfe02ffcf00013bbfL
1230	};
1231	static final long[] jjbitVec68 = {
1232	0xf3edfdfffff99feeL, 0x2ffcfb0c0399fL, 0xc3ffc718d63dc7ecL, 0x200ffc000813dc7L
1233	};
1234	static final long[] jjbitVec69 = {
1235	0xe3fffdfffffddfefL, 0xffcf07603ddfL, 0xf3effdfffffddfefL, 0x6ffcf40603ddfL
1236	};
1237	static final long[] jjbitVec70 = {
1238	0xfffffffffffddfefL, 0xfc00ffcf80f07ddfL, 0x2ffbfffffc7fffecL, 0xcffc0ff5f847fL
1239	};
1240	static final long[] jjbitVec71 = {
1241	0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0xf3ff3f5fL
1242	};
1243	static final long[] jjbitVec72 = {
1244	0xc2a003ff03000001L, 0xfffe1ffffffffeffL, 0x1ffffffffeffffdfL, 0x40L
1245	};
1246	static final long[] jjbitVec73 = {
1247	0xffffffffffffffffL, 0xffffffffffff03ffL, 0xffffffff3fffffffL, 0xf7ffffffffff20bfL
1248	};
1249	static final long[] jjbitVec74 = {
1250	0xffffffffff3dffffL, 0xe7ffffffL, 0xffffffff0000ffffL, 0x3f3fffffffffffffL
1251	};
1252	static final long[] jjbitVec75 = {
1253	0x1fffff001fdfffL, 0xddfff000fffffL, 0xffffffffffffffffL, 0x3ff388fffffL
1254	};
1255	static final long[] jjbitVec76 = {
1256	0xffffffff03ff7800L, 0xffffffffffffffL, 0xffff07ffffffffffL, 0x3fffffffffffffL
1257	};
1258	static final long[] jjbitVec77 = {
1259	0xfff0fff7fffffffL, 0x1f3fffffffffc0L, 0xffff0fffffffffffL, 0x3ff03ffL
1260	};
1261	static final long[] jjbitVec78 = {
1262	0xffffffff0fffffffL, 0x9fffffff7fffffffL, 0x3fff008003ff03ffL, 0x0L
1263	};
1264	static final long[] jjbitVec79 = {
1265	0xffffffffffffffffL, 0xff80003ff0fffL, 0xffffffffffffffffL, 0xfffffffffffffL
1266	};
1267	static final long[] jjbitVec80 = {
1268	0xffffffffffffffL, 0x3fffffffffffe3ffL, 0x1ffL, 0x3fffffffff70000L
1269	};
1270	static final long[] jjbitVec81 = {
1271	0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfbffffffffffffffL
1272	};
1273	static final long[] jjbitVec82 = {
1274	0x80007c000000f800L, 0x8002ffdf00100001L, 0xffffffff1fff0000L, 0x1ffe21fff0000L
1275	};
1276	static final long[] jjbitVec83 = {
1277	0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xff81fffffffffL
1278	};
1279	static final long[] jjbitVec84 = {
1280	0xffff20bfffffffffL, 0x800080ffffffffffL, 0x7f7f7f7f007fffffL, 0xffffffff7f7f7f7fL
1281	};
1282	static final long[] jjbitVec85 = {
1283	0x1f3efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffee67fffffL, 0xf7ffffffffffffffL
1284	};
1285	static final long[] jjbitVec86 = {
1286	0xfffffff1fffL, 0xbff0ffffffffffffL, 0xffffffffffffffffL, 0x3ffffffffffffL
1287	};
1288	static final long[] jjbitVec87 = {
1289	0x10000ffffffffffL, 0xfffffffffffffL, 0xffffffffffffffffL, 0x28ffffff03ff003fL
1290	};
1291	static final long[] jjbitVec88 = {
1292	0xffff3fffffffffffL, 0x1fffffff000fffffL, 0xffffffffffffffffL, 0x7fffffff03ff8001L
1293	};
1294	static final long[] jjbitVec89 = {
1295	0x7fffffffffffffL, 0xfc7fffff03ff3fffL, 0xffffffffffffffffL, 0x7cffff38000007L
1296	};
1297	static final long[] jjbitVec90 = {
1298	0xffff7f7f007e7e7eL, 0xffff003ff7ffffffL, 0xffffffffffffffffL, 0x3ff37ffffffffffL
1299	};
1300	static final long[] jjbitVec91 = {
1301	0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1302	};
1303	static final long[] jjbitVec92 = {
1304	0x18ffff0000ffffL, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
1305	};
1306	static final long[] jjbitVec93 = {
1307	0x87fffffe03ff0010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
1308	};
1309	private int jjMoveNfa_0(int startState, int curPos)
1310	{
1311	int startsAt = 0;
1312	jjnewStateCnt = 141;
1313	int i = 1;
1314	jjstateSet[0] = startState;
1315	int kind = 0x7fffffff;
1316	for (;;)
1317	{
1318	if (++jjround == 0x7fffffff)
1319	ReInitRounds();
1320	if (curChar < 64)
1321	{
1322	long l = 1L << curChar;
1323	do
1324	{
1325	switch(jjstateSet[--i])
1326	{
1327	case 0:
1328	if ((0x3ff000000000000L & l) != 0x0L)
1329	{
1330	if (kind > 76)
1331	kind = 76;
1332	{ jjCheckNAddStates(0, 14); }
1333	}
1334	else if ((0x100001200L & l) != 0x0L)
1335	{
1336	if (kind > 1)
1337	kind = 1;
1338	}
1339	else if (curChar == 47)
1340	{ jjAddStates(15, 16); }
1341	else if (curChar == 36)
1342	{
1343	if (kind > 93)
1344	kind = 93;
1345	{ jjCheckNAddTwoStates(43, 49); }
1346	}
1347	else if (curChar == 34)
1348	{ jjCheckNAddStates(17, 20); }
1349	else if (curChar == 39)
1350	{ jjAddStates(21, 23); }
1351	else if (curChar == 46)
1352	jjstateSet[jjnewStateCnt++] = 2;
1353	if (curChar == 48)
1354	{ jjAddStates(24, 31); }
1355	break;
1356	case 142:
1357	case 43:
1358	if ((0x3ff00100fffc1ffL & l) == 0x0L)
1359	break;
1360	if (kind > 93)
1361	kind = 93;
1362	{ jjCheckNAddTwoStates(43, 49); }
1363	break;
1364	case 141:
1365	if ((0xfffffffbffffdbffL & l) != 0x0L)
1366	{ jjCheckNAddStates(17, 20); }
1367	else if (curChar == 34)
1368	{
1369	if (kind > 89)
1370	kind = 89;
1371	}
1372	break;
1373	case 56:
1374	if (curChar == 42)
1375	jjstateSet[jjnewStateCnt++] = 58;
1376	else if (curChar == 47)
1377	{
1378	if (kind > 5)
1379	kind = 5;
1380	{ jjCheckNAdd(57); }
1381	}
1382	break;
1383	case 1:
1384	if (curChar == 46)
1385	jjstateSet[jjnewStateCnt++] = 2;
1386	break;
1387	case 2:
1388	if ((0x3ff000000000000L & l) == 0x0L)
1389	break;
1390	if (kind > 81)
1391	kind = 81;
1392	{ jjCheckNAddStates(32, 35); }
1393	break;
1394	case 3:
1395	if ((0x3ff000000000000L & l) != 0x0L)
1396	{ jjCheckNAddTwoStates(3, 4); }
1397	break;
1398	case 4:
1399	if ((0x3ff000000000000L & l) == 0x0L)
1400	break;
1401	if (kind > 81)
1402	kind = 81;
1403	{ jjCheckNAddTwoStates(5, 10); }
1404	break;
1405	case 6:
1406	if ((0x280000000000L & l) != 0x0L)
1407	{ jjCheckNAdd(7); }
1408	break;
1409	case 7:
1410	if ((0x3ff000000000000L & l) == 0x0L)
1411	break;
1412	if (kind > 81)
1413	kind = 81;
1414	{ jjCheckNAddStates(36, 38); }
1415	break;
1416	case 8:
1417	if ((0x3ff000000000000L & l) != 0x0L)
1418	{ jjCheckNAddTwoStates(8, 9); }
1419	break;
1420	case 9:
1421	if ((0x3ff000000000000L & l) == 0x0L)
1422	break;
1423	if (kind > 81)
1424	kind = 81;
1425	{ jjCheckNAddTwoStates(7, 10); }
1426	break;
1427	case 11:
1428	if ((0x3ff000000000000L & l) == 0x0L)
1429	break;
1430	if (kind > 81)
1431	kind = 81;
1432	{ jjCheckNAddStates(39, 42); }
1433	break;
1434	case 12:
1435	if (curChar == 39)
1436	{ jjAddStates(21, 23); }
1437	break;
1438	case 13:
1439	if ((0xffffff7fffffdbffL & l) != 0x0L)
1440	{ jjCheckNAdd(14); }
1441	break;
1442	case 14:
1443	if (curChar == 39 && kind > 88)
1444	kind = 88;
1445	break;
1446	case 16:
1447	if ((0x8400000000L & l) != 0x0L)
1448	{ jjCheckNAdd(14); }
1449	break;
1450	case 17:
1451	if ((0xff000000000000L & l) != 0x0L)
1452	{ jjCheckNAddTwoStates(18, 14); }
1453	break;
1454	case 18:
1455	if ((0xff000000000000L & l) != 0x0L)
1456	{ jjCheckNAdd(14); }
1457	break;
1458	case 19:
1459	if ((0xf000000000000L & l) != 0x0L)
1460	jjstateSet[jjnewStateCnt++] = 20;
1461	break;
1462	case 20:
1463	if ((0xff000000000000L & l) != 0x0L)
1464	{ jjCheckNAdd(18); }
1465	break;
1466	case 22:
1467	if ((0x3ff000000000000L & l) != 0x0L)
1468	jjstateSet[jjnewStateCnt++] = 23;
1469	break;
1470	case 23:
1471	if ((0x3ff000000000000L & l) != 0x0L)
1472	jjstateSet[jjnewStateCnt++] = 24;
1473	break;
1474	case 24:
1475	if ((0x3ff000000000000L & l) != 0x0L)
1476	jjstateSet[jjnewStateCnt++] = 25;
1477	break;
1478	case 25:
1479	if ((0x3ff000000000000L & l) != 0x0L)
1480	{ jjCheckNAdd(14); }
1481	break;
1482	case 27:
1483	if (curChar == 34)
1484	{ jjCheckNAddStates(17, 20); }
1485	break;
1486	case 28:
1487	if ((0xfffffffbffffdbffL & l) != 0x0L)
1488	{ jjCheckNAddStates(17, 20); }
1489	break;
1490	case 30:
1491	if ((0x8400000000L & l) != 0x0L)
1492	{ jjCheckNAddStates(17, 20); }
1493	break;
1494	case 32:
1495	if ((0x3ff000000000000L & l) != 0x0L)
1496	jjstateSet[jjnewStateCnt++] = 33;
1497	break;
1498	case 33:
1499	if ((0x3ff000000000000L & l) != 0x0L)
1500	jjstateSet[jjnewStateCnt++] = 34;
1501	break;
1502	case 34:
1503	if ((0x3ff000000000000L & l) != 0x0L)
1504	jjstateSet[jjnewStateCnt++] = 35;
1505	break;
1506	case 35:
1507	if ((0x3ff000000000000L & l) != 0x0L)
1508	{ jjCheckNAddStates(17, 20); }
1509	break;
1510	case 37:
1511	if (curChar == 34 && kind > 89)
1512	kind = 89;
1513	break;
1514	case 38:
1515	if ((0xff000000000000L & l) != 0x0L)
1516	{ jjCheckNAddStates(43, 47); }
1517	break;
1518	case 39:
1519	if ((0xff000000000000L & l) != 0x0L)
1520	{ jjCheckNAddStates(17, 20); }
1521	break;
1522	case 40:
1523	if ((0xf000000000000L & l) != 0x0L)
1524	jjstateSet[jjnewStateCnt++] = 41;
1525	break;
1526	case 41:
1527	if ((0xff000000000000L & l) != 0x0L)
1528	{ jjCheckNAdd(39); }
1529	break;
1530	case 42:
1531	if (curChar != 36)
1532	break;
1533	if (kind > 93)
1534	kind = 93;
1535	{ jjCheckNAddTwoStates(43, 49); }
1536	break;
1537	case 45:
1538	if ((0x3ff000000000000L & l) != 0x0L)
1539	jjstateSet[jjnewStateCnt++] = 46;
1540	break;
1541	case 46:
1542	if ((0x3ff000000000000L & l) != 0x0L)
1543	jjstateSet[jjnewStateCnt++] = 47;
1544	break;
1545	case 47:
1546	case 53:
1547	if ((0x3ff000000000000L & l) != 0x0L)
1548	{ jjCheckNAdd(48); }
1549	break;
1550	case 48:
1551	if ((0x3ff000000000000L & l) == 0x0L)
1552	break;
1553	if (kind > 93)
1554	kind = 93;
1555	{ jjCheckNAddTwoStates(43, 49); }
1556	break;
1557	case 51:
1558	if ((0x3ff000000000000L & l) != 0x0L)
1559	jjstateSet[jjnewStateCnt++] = 52;
1560	break;
1561	case 52:
1562	if ((0x3ff000000000000L & l) != 0x0L)
1563	jjstateSet[jjnewStateCnt++] = 53;
1564	break;
1565	case 55:
1566	if (curChar == 47)
1567	{ jjAddStates(15, 16); }
1568	break;
1569	case 57:
1570	if ((0xffffffffffffdbffL & l) == 0x0L)
1571	break;
1572	if (kind > 5)
1573	kind = 5;
1574	{ jjCheckNAdd(57); }
1575	break;
1576	case 58:
1577	if (curChar == 42)
1578	jjstateSet[jjnewStateCnt++] = 59;
1579	break;
1580	case 59:
1581	if ((0xffff7fffffffffffL & l) != 0x0L && kind > 6)
1582	kind = 6;
1583	break;
1584	case 60:
1585	if (curChar == 42)
1586	jjstateSet[jjnewStateCnt++] = 58;
1587	break;
1588	case 61:
1589	if ((0x3ff000000000000L & l) == 0x0L)
1590	break;
1591	if (kind > 76)
1592	kind = 76;
1593	{ jjCheckNAddStates(0, 14); }
1594	break;
1595	case 62:
1596	if ((0x3ff000000000000L & l) != 0x0L)
1597	{ jjCheckNAddTwoStates(62, 63); }
1598	break;
1599	case 63:
1600	case 99:
1601	if ((0x3ff000000000000L & l) != 0x0L)
1602	{ jjCheckNAdd(64); }
1603	break;
1604	case 65:
1605	if ((0x3ff000000000000L & l) != 0x0L)
1606	{ jjCheckNAddTwoStates(65, 66); }
1607	break;
1608	case 66:
1609	case 110:
1610	if ((0x3ff000000000000L & l) != 0x0L && kind > 76)
1611	kind = 76;
1612	break;
1613	case 67:
1614	if ((0x3ff000000000000L & l) != 0x0L)
1615	{ jjCheckNAddTwoStates(67, 68); }
1616	break;
1617	case 68:
1618	if ((0x3ff000000000000L & l) != 0x0L)
1619	{ jjCheckNAddTwoStates(69, 10); }
1620	break;
1621	case 70:
1622	if ((0x280000000000L & l) != 0x0L)
1623	{ jjCheckNAdd(71); }
1624	break;
1625	case 71:
1626	if ((0x3ff000000000000L & l) != 0x0L)
1627	{ jjCheckNAddStates(48, 50); }
1628	break;
1629	case 72:
1630	if ((0x3ff000000000000L & l) != 0x0L)
1631	{ jjCheckNAddTwoStates(72, 73); }
1632	break;
1633	case 73:
1634	if ((0x3ff000000000000L & l) != 0x0L)
1635	{ jjCheckNAddTwoStates(71, 10); }
1636	break;
1637	case 74:
1638	if ((0x3ff000000000000L & l) != 0x0L)
1639	{ jjCheckNAddStates(51, 54); }
1640	break;
1641	case 75:
1642	if ((0x3ff000000000000L & l) != 0x0L)
1643	{ jjCheckNAddTwoStates(75, 76); }
1644	break;
1645	case 76:
1646	if ((0x3ff000000000000L & l) != 0x0L)
1647	{ jjCheckNAdd(77); }
1648	break;
1649	case 78:
1650	if ((0x280000000000L & l) != 0x0L)
1651	{ jjCheckNAdd(79); }
1652	break;
1653	case 79:
1654	if ((0x3ff000000000000L & l) == 0x0L)
1655	break;
1656	if (kind > 81)
1657	kind = 81;
1658	{ jjCheckNAddStates(55, 57); }
1659	break;
1660	case 80:
1661	if ((0x3ff000000000000L & l) != 0x0L)
1662	{ jjCheckNAddTwoStates(80, 81); }
1663	break;
1664	case 81:
1665	if ((0x3ff000000000000L & l) == 0x0L)
1666	break;
1667	if (kind > 81)
1668	kind = 81;
1669	{ jjCheckNAddTwoStates(79, 10); }
1670	break;
1671	case 82:
1672	if ((0x3ff000000000000L & l) == 0x0L)
1673	break;
1674	if (kind > 81)
1675	kind = 81;
1676	{ jjCheckNAddStates(58, 61); }
1677	break;
1678	case 83:
1679	if ((0x3ff000000000000L & l) != 0x0L)
1680	{ jjCheckNAddTwoStates(83, 84); }
1681	break;
1682	case 84:
1683	if ((0x3ff000000000000L & l) != 0x0L)
1684	{ jjCheckNAdd(85); }
1685	break;
1686	case 85:
1687	if (curChar != 46)
1688	break;
1689	if (kind > 81)
1690	kind = 81;
1691	{ jjCheckNAddStates(62, 64); }
1692	break;
1693	case 86:
1694	if ((0x3ff000000000000L & l) == 0x0L)
1695	break;
1696	if (kind > 81)
1697	kind = 81;
1698	{ jjCheckNAddStates(65, 68); }
1699	break;
1700	case 87:
1701	if ((0x3ff000000000000L & l) != 0x0L)
1702	{ jjCheckNAddTwoStates(87, 88); }
1703	break;
1704	case 88:
1705	if ((0x3ff000000000000L & l) == 0x0L)
1706	break;
1707	if (kind > 81)
1708	kind = 81;
1709	{ jjCheckNAddTwoStates(89, 10); }
1710	break;
1711	case 90:
1712	if ((0x280000000000L & l) != 0x0L)
1713	{ jjCheckNAdd(91); }
1714	break;
1715	case 91:
1716	if ((0x3ff000000000000L & l) == 0x0L)
1717	break;
1718	if (kind > 81)
1719	kind = 81;
1720	{ jjCheckNAddStates(69, 71); }
1721	break;
1722	case 92:
1723	if ((0x3ff000000000000L & l) != 0x0L)
1724	{ jjCheckNAddTwoStates(92, 93); }
1725	break;
1726	case 93:
1727	if ((0x3ff000000000000L & l) == 0x0L)
1728	break;
1729	if (kind > 81)
1730	kind = 81;
1731	{ jjCheckNAddTwoStates(91, 10); }
1732	break;
1733	case 94:
1734	if ((0x3ff000000000000L & l) == 0x0L)
1735	break;
1736	if (kind > 81)
1737	kind = 81;
1738	{ jjCheckNAddStates(72, 75); }
1739	break;
1740	case 95:
1741	if (curChar == 48)
1742	{ jjAddStates(24, 31); }
1743	break;
1744	case 97:
1745	if ((0x3ff000000000000L & l) != 0x0L)
1746	{ jjCheckNAddStates(76, 78); }
1747	break;
1748	case 98:
1749	if ((0x3ff000000000000L & l) != 0x0L)
1750	{ jjCheckNAddTwoStates(98, 99); }
1751	break;
1752	case 100:
1753	if ((0xff000000000000L & l) != 0x0L)
1754	{ jjCheckNAddStates(79, 81); }
1755	break;
1756	case 101:
1757	if ((0xff000000000000L & l) != 0x0L)
1758	{ jjCheckNAddTwoStates(101, 102); }
1759	break;
1760	case 102:
1761	if ((0xff000000000000L & l) != 0x0L)
1762	{ jjCheckNAdd(64); }
1763	break;
1764	case 104:
1765	if ((0x3000000000000L & l) != 0x0L)
1766	{ jjCheckNAddStates(82, 84); }
1767	break;
1768	case 105:
1769	if ((0x3000000000000L & l) != 0x0L)
1770	{ jjCheckNAddTwoStates(105, 106); }
1771	break;
1772	case 106:
1773	if ((0x3000000000000L & l) != 0x0L)
1774	{ jjCheckNAdd(64); }
1775	break;
1776	case 108:
1777	if ((0x3ff000000000000L & l) == 0x0L)
1778	break;
1779	if (kind > 76)
1780	kind = 76;
1781	{ jjCheckNAddTwoStates(109, 110); }
1782	break;
1783	case 109:
1784	if ((0x3ff000000000000L & l) != 0x0L)
1785	{ jjCheckNAddTwoStates(109, 110); }
1786	break;
1787	case 111:
1788	if ((0xff000000000000L & l) == 0x0L)
1789	break;
1790	if (kind > 76)
1791	kind = 76;
1792	{ jjCheckNAddTwoStates(112, 113); }
1793	break;
1794	case 112:
1795	if ((0xff000000000000L & l) != 0x0L)
1796	{ jjCheckNAddTwoStates(112, 113); }
1797	break;
1798	case 113:
1799	if ((0xff000000000000L & l) != 0x0L && kind > 76)
1800	kind = 76;
1801	break;
1802	case 115:
1803	if ((0x3000000000000L & l) == 0x0L)
1804	break;
1805	if (kind > 76)
1806	kind = 76;
1807	{ jjCheckNAddTwoStates(116, 117); }
1808	break;
1809	case 116:
1810	if ((0x3000000000000L & l) != 0x0L)
1811	{ jjCheckNAddTwoStates(116, 117); }
1812	break;
1813	case 117:
1814	if ((0x3000000000000L & l) != 0x0L && kind > 76)
1815	kind = 76;
1816	break;
1817	case 119:
1818	if ((0x3ff000000000000L & l) != 0x0L)
1819	{ jjCheckNAddStates(85, 87); }
1820	break;
1821	case 120:
1822	if ((0x3ff000000000000L & l) != 0x0L)
1823	{ jjCheckNAddTwoStates(120, 121); }
1824	break;
1825	case 121:
1826	if ((0x3ff000000000000L & l) != 0x0L)
1827	{ jjCheckNAdd(122); }
1828	break;
1829	case 122:
1830	if (curChar == 46)
1831	jjstateSet[jjnewStateCnt++] = 123;
1832	break;
1833	case 123:
1834	if ((0x3ff000000000000L & l) != 0x0L)
1835	{ jjCheckNAddStates(88, 90); }
1836	break;
1837	case 124:
1838	if ((0x3ff000000000000L & l) != 0x0L)
1839	{ jjCheckNAddTwoStates(124, 125); }
1840	break;
1841	case 125:
1842	if ((0x3ff000000000000L & l) != 0x0L)
1843	{ jjCheckNAdd(126); }
1844	break;
1845	case 127:
1846	if ((0x280000000000L & l) != 0x0L)
1847	jjstateSet[jjnewStateCnt++] = 128;
1848	break;
1849	case 128:
1850	if ((0x3ff000000000000L & l) == 0x0L)
1851	break;
1852	if (kind > 81)
1853	kind = 81;
1854	{ jjCheckNAddStates(91, 93); }
1855	break;
1856	case 129:
1857	if ((0x3ff000000000000L & l) != 0x0L)
1858	{ jjCheckNAddTwoStates(129, 130); }
1859	break;
1860	case 130:
1861	case 140:
1862	if ((0x3ff000000000000L & l) == 0x0L)
1863	break;
1864	if (kind > 81)
1865	kind = 81;
1866	{ jjCheckNAdd(10); }
1867	break;
1868	case 132:
1869	if ((0x3ff000000000000L & l) != 0x0L)
1870	{ jjCheckNAddStates(94, 97); }
1871	break;
1872	case 133:
1873	if ((0x3ff000000000000L & l) != 0x0L)
1874	{ jjCheckNAddTwoStates(133, 134); }
1875	break;
1876	case 134:
1877	if ((0x3ff000000000000L & l) != 0x0L)
1878	{ jjCheckNAddTwoStates(135, 136); }
1879	break;
1880	case 135:
1881	if (curChar == 46)
1882	{ jjCheckNAdd(136); }
1883	break;
1884	case 137:
1885	if ((0x280000000000L & l) != 0x0L)
1886	jjstateSet[jjnewStateCnt++] = 138;
1887	break;
1888	case 138:
1889	if ((0x3ff000000000000L & l) == 0x0L)
1890	break;
1891	if (kind > 81)
1892	kind = 81;
1893	{ jjCheckNAddStates(98, 100); }
1894	break;
1895	case 139:
1896	if ((0x3ff000000000000L & l) != 0x0L)
1897	{ jjCheckNAddTwoStates(139, 140); }
1898	break;
1899	default : break;
1900	}
1901	} while(i != startsAt);
1902	}
1903	else if (curChar < 128)
1904	{
1905	long l = 1L << (curChar & 077);
1906	do
1907	{
1908	switch(jjstateSet[--i])
1909	{
1910	case 0:
1911	if ((0x7fffffe87fffffeL & l) != 0x0L)
1912	{
1913	if (kind > 93)
1914	kind = 93;
1915	{ jjCheckNAddTwoStates(43, 49); }
1916	}
1917	else if (curChar == 92)
1918	jjstateSet[jjnewStateCnt++] = 50;
1919	break;
1920	case 142:
1921	if ((0x87fffffe87fffffeL & l) != 0x0L)
1922	{
1923	if (kind > 93)
1924	kind = 93;
1925	{ jjCheckNAddTwoStates(43, 49); }
1926	}
1927	else if (curChar == 92)
1928	jjstateSet[jjnewStateCnt++] = 44;
1929	break;
1930	case 141:
1931	if ((0xffffffffefffffffL & l) != 0x0L)
1932	{ jjCheckNAddStates(17, 20); }
1933	else if (curChar == 92)
1934	jjstateSet[jjnewStateCnt++] = 31;
1935	if (curChar == 92)
1936	{ jjAddStates(101, 103); }
1937	break;
1938	case 3:
1939	if (curChar == 95)
1940	{ jjAddStates(104, 105); }
1941	break;
1942	case 5:
1943	if ((0x2000000020L & l) != 0x0L)
1944	{ jjAddStates(106, 107); }
1945	break;
1946	case 8:
1947	if (curChar == 95)
1948	{ jjAddStates(108, 109); }
1949	break;
1950	case 10:
1951	if ((0x5000000050L & l) != 0x0L && kind > 81)
1952	kind = 81;
1953	break;
1954	case 13:
1955	if ((0xffffffffefffffffL & l) != 0x0L)
1956	{ jjCheckNAdd(14); }
1957	break;
1958	case 15:
1959	if (curChar == 92)
1960	{ jjAddStates(110, 112); }
1961	break;
1962	case 16:
1963	if ((0x14404410000000L & l) != 0x0L)
1964	{ jjCheckNAdd(14); }
1965	break;
1966	case 21:
1967	if (curChar == 117)
1968	jjstateSet[jjnewStateCnt++] = 22;
1969	break;
1970	case 22:
1971	if ((0x7e0000007eL & l) != 0x0L)
1972	jjstateSet[jjnewStateCnt++] = 23;
1973	break;
1974	case 23:
1975	if ((0x7e0000007eL & l) != 0x0L)
1976	jjstateSet[jjnewStateCnt++] = 24;
1977	break;
1978	case 24:
1979	if ((0x7e0000007eL & l) != 0x0L)
1980	jjstateSet[jjnewStateCnt++] = 25;
1981	break;
1982	case 25:
1983	if ((0x7e0000007eL & l) != 0x0L)
1984	{ jjCheckNAdd(14); }
1985	break;
1986	case 26:
1987	if (curChar == 92)
1988	jjstateSet[jjnewStateCnt++] = 21;
1989	break;
1990	case 28:
1991	if ((0xffffffffefffffffL & l) != 0x0L)
1992	{ jjCheckNAddStates(17, 20); }
1993	break;
1994	case 29:
1995	if (curChar == 92)
1996	{ jjAddStates(101, 103); }
1997	break;
1998	case 30:
1999	if ((0x14404410000000L & l) != 0x0L)
2000	{ jjCheckNAddStates(17, 20); }
2001	break;
2002	case 31:
2003	if (curChar == 117)
2004	jjstateSet[jjnewStateCnt++] = 32;
2005	break;
2006	case 32:
2007	if ((0x7e0000007eL & l) != 0x0L)
2008	jjstateSet[jjnewStateCnt++] = 33;
2009	break;
2010	case 33:
2011	if ((0x7e0000007eL & l) != 0x0L)
2012	jjstateSet[jjnewStateCnt++] = 34;
2013	break;
2014	case 34:
2015	if ((0x7e0000007eL & l) != 0x0L)
2016	jjstateSet[jjnewStateCnt++] = 35;
2017	break;
2018	case 35:
2019	if ((0x7e0000007eL & l) != 0x0L)
2020	{ jjCheckNAddStates(17, 20); }
2021	break;
2022	case 36:
2023	if (curChar == 92)
2024	jjstateSet[jjnewStateCnt++] = 31;
2025	break;
2026	case 42:
2027	if ((0x7fffffe87fffffeL & l) == 0x0L)
2028	break;
2029	if (kind > 93)
2030	kind = 93;
2031	{ jjCheckNAddTwoStates(43, 49); }
2032	break;
2033	case 43:
2034	if ((0x87fffffe87fffffeL & l) == 0x0L)
2035	break;
2036	if (kind > 93)
2037	kind = 93;
2038	{ jjCheckNAddTwoStates(43, 49); }
2039	break;
2040	case 44:
2041	if (curChar == 117)
2042	jjstateSet[jjnewStateCnt++] = 45;
2043	break;
2044	case 45:
2045	if ((0x7e0000007eL & l) != 0x0L)
2046	jjstateSet[jjnewStateCnt++] = 46;
2047	break;
2048	case 46:
2049	if ((0x7e0000007eL & l) != 0x0L)
2050	jjstateSet[jjnewStateCnt++] = 47;
2051	break;
2052	case 47:
2053	case 53:
2054	if ((0x7e0000007eL & l) != 0x0L)
2055	{ jjCheckNAdd(48); }
2056	break;
2057	case 48:
2058	if ((0x7e0000007eL & l) == 0x0L)
2059	break;
2060	if (kind > 93)
2061	kind = 93;
2062	{ jjCheckNAddTwoStates(43, 49); }
2063	break;
2064	case 49:
2065	if (curChar == 92)
2066	jjstateSet[jjnewStateCnt++] = 44;
2067	break;
2068	case 50:
2069	if (curChar == 117)
2070	jjstateSet[jjnewStateCnt++] = 51;
2071	break;
2072	case 51:
2073	if ((0x7e0000007eL & l) != 0x0L)
2074	jjstateSet[jjnewStateCnt++] = 52;
2075	break;
2076	case 52:
2077	if ((0x7e0000007eL & l) != 0x0L)
2078	jjstateSet[jjnewStateCnt++] = 53;
2079	break;
2080	case 54:
2081	if (curChar == 92)
2082	jjstateSet[jjnewStateCnt++] = 50;
2083	break;
2084	case 57:
2085	if (kind > 5)
2086	kind = 5;
2087	jjstateSet[jjnewStateCnt++] = 57;
2088	break;
2089	case 59:
2090	if (kind > 6)
2091	kind = 6;
2092	break;
2093	case 62:
2094	if (curChar == 95)
2095	{ jjAddStates(113, 114); }
2096	break;
2097	case 64:
2098	if ((0x100000001000L & l) != 0x0L && kind > 75)
2099	kind = 75;
2100	break;
2101	case 65:
2102	if (curChar == 95)
2103	{ jjAddStates(115, 116); }
2104	break;
2105	case 67:
2106	if (curChar == 95)
2107	{ jjAddStates(117, 118); }
2108	break;
2109	case 69:
2110	if ((0x2000000020L & l) != 0x0L)
2111	{ jjAddStates(119, 120); }
2112	break;
2113	case 72:
2114	if (curChar == 95)
2115	{ jjAddStates(121, 122); }
2116	break;
2117	case 75:
2118	if (curChar == 95)
2119	{ jjAddStates(123, 124); }
2120	break;
2121	case 77:
2122	if ((0x2000000020L & l) != 0x0L)
2123	{ jjAddStates(125, 126); }
2124	break;
2125	case 80:
2126	if (curChar == 95)
2127	{ jjAddStates(127, 128); }
2128	break;
2129	case 83:
2130	if (curChar == 95)
2131	{ jjAddStates(129, 130); }
2132	break;
2133	case 87:
2134	if (curChar == 95)
2135	{ jjAddStates(131, 132); }
2136	break;
2137	case 89:
2138	if ((0x2000000020L & l) != 0x0L)
2139	{ jjAddStates(133, 134); }
2140	break;
2141	case 92:
2142	if (curChar == 95)
2143	{ jjAddStates(135, 136); }
2144	break;
2145	case 96:
2146	if ((0x100000001000000L & l) != 0x0L)
2147	jjstateSet[jjnewStateCnt++] = 97;
2148	break;
2149	case 97:
2150	if ((0x7e0000007eL & l) != 0x0L)
2151	{ jjCheckNAddStates(76, 78); }
2152	break;
2153	case 98:
2154	if ((0x7e8000007eL & l) != 0x0L)
2155	{ jjCheckNAddTwoStates(98, 99); }
2156	break;
2157	case 99:
2158	if ((0x7e0000007eL & l) != 0x0L)
2159	{ jjCheckNAdd(64); }
2160	break;
2161	case 101:
2162	if (curChar == 95)
2163	{ jjAddStates(137, 138); }
2164	break;
2165	case 103:
2166	if ((0x400000004L & l) != 0x0L)
2167	jjstateSet[jjnewStateCnt++] = 104;
2168	break;
2169	case 105:
2170	if (curChar == 95)
2171	{ jjAddStates(139, 140); }
2172	break;
2173	case 107:
2174	if ((0x100000001000000L & l) != 0x0L)
2175	jjstateSet[jjnewStateCnt++] = 108;
2176	break;
2177	case 108:
2178	if ((0x7e0000007eL & l) == 0x0L)
2179	break;
2180	if (kind > 76)
2181	kind = 76;
2182	{ jjCheckNAddTwoStates(109, 110); }
2183	break;
2184	case 109:
2185	if ((0x7e8000007eL & l) != 0x0L)
2186	{ jjCheckNAddTwoStates(109, 110); }
2187	break;
2188	case 110:
2189	if ((0x7e0000007eL & l) != 0x0L && kind > 76)
2190	kind = 76;
2191	break;
2192	case 112:
2193	if (curChar == 95)
2194	{ jjAddStates(141, 142); }
2195	break;
2196	case 114:
2197	if ((0x400000004L & l) != 0x0L)
2198	jjstateSet[jjnewStateCnt++] = 115;
2199	break;
2200	case 116:
2201	if (curChar == 95)
2202	{ jjAddStates(143, 144); }
2203	break;
2204	case 118:
2205	if ((0x100000001000000L & l) != 0x0L)
2206	{ jjCheckNAddTwoStates(119, 122); }
2207	break;
2208	case 119:
2209	if ((0x7e0000007eL & l) != 0x0L)
2210	{ jjCheckNAddStates(85, 87); }
2211	break;
2212	case 120:
2213	if ((0x7e8000007eL & l) != 0x0L)
2214	{ jjCheckNAddTwoStates(120, 121); }
2215	break;
2216	case 121:
2217	if ((0x7e0000007eL & l) != 0x0L)
2218	{ jjCheckNAdd(122); }
2219	break;
2220	case 123:
2221	if ((0x7e0000007eL & l) != 0x0L)
2222	{ jjCheckNAddStates(88, 90); }
2223	break;
2224	case 124:
2225	if ((0x7e8000007eL & l) != 0x0L)
2226	{ jjCheckNAddTwoStates(124, 125); }
2227	break;
2228	case 125:
2229	if ((0x7e0000007eL & l) != 0x0L)
2230	{ jjCheckNAdd(126); }
2231	break;
2232	case 126:
2233	if ((0x1000000010000L & l) != 0x0L)
2234	{ jjAddStates(145, 146); }
2235	break;
2236	case 129:
2237	if (curChar == 95)
2238	{ jjAddStates(147, 148); }
2239	break;
2240	case 131:
2241	if ((0x100000001000000L & l) != 0x0L)
2242	jjstateSet[jjnewStateCnt++] = 132;
2243	break;
2244	case 132:
2245	if ((0x7e0000007eL & l) != 0x0L)
2246	{ jjCheckNAddStates(94, 97); }
2247	break;
2248	case 133:
2249	if ((0x7e8000007eL & l) != 0x0L)
2250	{ jjCheckNAddTwoStates(133, 134); }
2251	break;
2252	case 134:
2253	if ((0x7e0000007eL & l) != 0x0L)
2254	{ jjCheckNAddTwoStates(135, 136); }
2255	break;
2256	case 136:
2257	if ((0x1000000010000L & l) != 0x0L)
2258	{ jjAddStates(149, 150); }
2259	break;
2260	case 139:
2261	if (curChar == 95)
2262	{ jjAddStates(151, 152); }
2263	break;
2264	default : break;
2265	}
2266	} while(i != startsAt);
2267	}
2268	else
2269	{
2270	int hiByte = (curChar >> 8);
2271	int i1 = hiByte >> 6;
2272	long l1 = 1L << (hiByte & 077);
2273	int i2 = (curChar & 0xff) >> 6;
2274	long l2 = 1L << (curChar & 077);
2275	do
2276	{
2277	switch(jjstateSet[--i])
2278	{
2279	case 0:
2280	if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2281	{
2282	if (kind > 1)
2283	kind = 1;
2284	}
2285	if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2286	{
2287	if (kind > 93)
2288	kind = 93;
2289	{ jjCheckNAddTwoStates(43, 49); }
2290	}
2291	break;
2292	case 142:
2293	case 43:
2294	if (!jjCanMove_3(hiByte, i1, i2, l1, l2))
2295	break;
2296	if (kind > 93)
2297	kind = 93;
2298	{ jjCheckNAddTwoStates(43, 49); }
2299	break;
2300	case 141:
2301	case 28:
2302	if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2303	{ jjCheckNAddStates(17, 20); }
2304	break;
2305	case 13:
2306	if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2307	jjstateSet[jjnewStateCnt++] = 14;
2308	break;
2309	case 42:
2310	if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2311	break;
2312	if (kind > 93)
2313	kind = 93;
2314	{ jjCheckNAddTwoStates(43, 49); }
2315	break;
2316	case 57:
2317	if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
2318	break;
2319	if (kind > 5)
2320	kind = 5;
2321	jjstateSet[jjnewStateCnt++] = 57;
2322	break;
2323	case 59:
2324	if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 6)
2325	kind = 6;
2326	break;
2327	default : if (i1 == 0 \|\| l1 == 0 \|\| i2 == 0 \|\| l2 == 0) break; else break;
2328	}
2329	} while(i != startsAt);
2330	}
2331	if (kind != 0x7fffffff)
2332	{
2333	jjmatchedKind = kind;
2334	jjmatchedPos = curPos;
2335	kind = 0x7fffffff;
2336	}
2337	++curPos;
2338	i = jjnewStateCnt;
2339	jjnewStateCnt = startsAt;
2340	startsAt = 141 - jjnewStateCnt;
2341	if (i == startsAt)
2342	return curPos;
2343	try { curChar = input_stream.readChar(); }
2344	catch(java.io.IOException e) { return curPos; }
2345	}
2346	}
2347	private int jjMoveStringLiteralDfa0_1(){
2348	switch(curChar)
2349	{
2350	case '*':
2351	return jjMoveStringLiteralDfa1_1(0x100L);
2352	default :
2353	return 1;
2354	}
2355	}
2356	private int jjMoveStringLiteralDfa1_1(long active0){
2357	try { curChar = input_stream.readChar(); }
2358	catch(java.io.IOException e) {
2359	return 1;
2360	}
2361	switch(curChar)
2362	{
2363	case '/':
2364	if ((active0 & 0x100L) != 0x0L)
2365	return jjStopAtPos(1, 8);
2366	break;
2367	default :
2368	return 2;
2369	}
2370	return 2;
2371	}
2372	private int jjMoveStringLiteralDfa0_2(){
2373	switch(curChar)
2374	{
2375	case '*':
2376	return jjMoveStringLiteralDfa1_2(0x200L);
2377	default :
2378	return 1;
2379	}
2380	}
2381	private int jjMoveStringLiteralDfa1_2(long active0){
2382	try { curChar = input_stream.readChar(); }
2383	catch(java.io.IOException e) {
2384	return 1;
2385	}
2386	switch(curChar)
2387	{
2388	case '/':
2389	if ((active0 & 0x200L) != 0x0L)
2390	return jjStopAtPos(1, 9);
2391	break;
2392	default :
2393	return 2;
2394	}
2395	return 2;
2396	}
2397	private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1){
2398	switch (pos)
2399	{
2400	case 0:
2401	if ((active1 & 0x8000000L) != 0x0L)
2402	{
2403	jjmatchedKind = 92;
2404	return -1;
2405	}
2406	return -1;
2407	case 1:
2408	if ((active1 & 0x8000000L) != 0x0L)
2409	{
2410	if (jjmatchedPos == 0)
2411	{
2412	jjmatchedKind = 92;
2413	jjmatchedPos = 0;
2414	}
2415	return -1;
2416	}
2417	return -1;
2418	default :
2419	return -1;
2420	}
2421	}
2422	private final int jjStartNfa_3(int pos, long active0, long active1){
2423	return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1);
2424	}
2425	private int jjMoveStringLiteralDfa0_3(){
2426	switch(curChar)
2427	{
2428	case '"':
2429	return jjMoveStringLiteralDfa1_3(0x8000000L);
2430	default :
2431	return jjMoveNfa_3(0, 0);
2432	}
2433	}
2434	private int jjMoveStringLiteralDfa1_3(long active1){
2435	try { curChar = input_stream.readChar(); }
2436	catch(java.io.IOException e) {
2437	jjStopStringLiteralDfa_3(0, 0L, active1);
2438	return 1;
2439	}
2440	switch(curChar)
2441	{
2442	case '"':
2443	return jjMoveStringLiteralDfa2_3(active1, 0x8000000L);
2444	default :
2445	break;
2446	}
2447	return jjStartNfa_3(0, 0L, active1);
2448	}
2449	private int jjMoveStringLiteralDfa2_3(long old1, long active1){
2450	if (((active1 &= old1)) == 0L)
2451	return jjStartNfa_3(0, 0L, old1);
2452	try { curChar = input_stream.readChar(); }
2453	catch(java.io.IOException e) {
2454	jjStopStringLiteralDfa_3(1, 0L, active1);
2455	return 2;
2456	}
2457	switch(curChar)
2458	{
2459	case '"':
2460	if ((active1 & 0x8000000L) != 0x0L)
2461	return jjStopAtPos(2, 91);
2462	break;
2463	default :
2464	break;
2465	}
2466	return jjStartNfa_3(1, 0L, active1);
2467	}
2468	private int jjMoveNfa_3(int startState, int curPos)
2469	{
2470	int startsAt = 0;
2471	jjnewStateCnt = 3;
2472	int i = 1;
2473	jjstateSet[0] = startState;
2474	int kind = 0x7fffffff;
2475	for (;;)
2476	{
2477	if (++jjround == 0x7fffffff)
2478	ReInitRounds();
2479	if (curChar < 64)
2480	{
2481	long l = 1L << curChar;
2482	do
2483	{
2484	switch(jjstateSet[--i])
2485	{
2486	case 0:
2487	if (kind > 92)
2488	kind = 92;
2489	break;
2490	case 1:
2491	if (curChar == 34 && kind > 92)
2492	kind = 92;
2493	break;
2494	default : break;
2495	}
2496	} while(i != startsAt);
2497	}
2498	else if (curChar < 128)
2499	{
2500	long l = 1L << (curChar & 077);
2501	do
2502	{
2503	switch(jjstateSet[--i])
2504	{
2505	case 0:
2506	if (kind > 92)
2507	kind = 92;
2508	if (curChar == 92)
2509	jjstateSet[jjnewStateCnt++] = 1;
2510	break;
2511	case 2:
2512	if (kind > 92)
2513	kind = 92;
2514	break;
2515	default : break;
2516	}
2517	} while(i != startsAt);
2518	}
2519	else
2520	{
2521	int hiByte = (curChar >> 8);
2522	int i1 = hiByte >> 6;
2523	long l1 = 1L << (hiByte & 077);
2524	int i2 = (curChar & 0xff) >> 6;
2525	long l2 = 1L << (curChar & 077);
2526	do
2527	{
2528	switch(jjstateSet[--i])
2529	{
2530	case 0:
2531	if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 92)
2532	kind = 92;
2533	break;
2534	default : if (i1 == 0 \|\| l1 == 0 \|\| i2 == 0 \|\| l2 == 0) break; else break;
2535	}
2536	} while(i != startsAt);
2537	}
2538	if (kind != 0x7fffffff)
2539	{
2540	jjmatchedKind = kind;
2541	jjmatchedPos = curPos;
2542	kind = 0x7fffffff;
2543	}
2544	++curPos;
2545	i = jjnewStateCnt;
2546	jjnewStateCnt = startsAt;
2547	startsAt = 3 - jjnewStateCnt;
2548	if (i == startsAt)
2549	return curPos;
2550	try { curChar = input_stream.readChar(); }
2551	catch(java.io.IOException e) { return curPos; }
2552	}
2553	}
2554
2555	/** Token literal values. */
2556	public static final String[] jjstrLiteralImages = {
2557	"", null, null, null, null, null, null, null, null, null, null,
2558	"\141\142\163\164\162\141\143\164", "\141\163\163\145\162\164", "\142\157\157\154\145\141\156",
2559	"\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150",
2560	"\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164",
2561	"\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145",
2562	"\145\154\163\145", "\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145",
2563	"\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162",
2564	"\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163",
2565	"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
2566	"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167",
2567	"\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145",
2568	"\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156", "\163\150\157\162\164",
2569	"\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", "\163\165\160\145\162",
2570	"\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
2571	"\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
2572	"\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
2573	"\167\150\151\154\145", "\171\151\145\154\144", "\162\145\161\165\151\162\145\163", "\164\157",
2574	"\167\151\164\150", "\157\160\145\156", "\157\160\145\156\163", "\165\163\145\163",
2575	"\155\157\144\165\154\145", "\145\170\160\157\162\164\163", "\160\162\157\166\151\144\145\163",
2576	"\164\162\141\156\163\151\164\151\166\145", null, null, null, null, null, null, null, null, null, null, null, null, null,
2577	null, null, null, null, null, null, null, null, "\50", "\51", "\173", "\175", "\133",
2578	"\135", "\73", "\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72",
2579	"\55\76", "\75\75", "\76\75", "\74\75", "\41\75", "\46\46", "\174\174", "\53\53",
2580	"\55\55", "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75",
2581	"\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75",
2582	"\76\76\75", "\76\76\76\75", "\56\56\56", "\72\72", "\76\76\76", "\76\76", "\76", "\32", };
2583	protected Token jjFillToken()
2584	{
2585	final Token t;
2586	final String curTokenImage;
2587	final int beginLine;
2588	final int endLine;
2589	final int beginColumn;
2590	final int endColumn;
2591	String im = jjstrLiteralImages[jjmatchedKind];
2592	curTokenImage = im == null ? input_stream.getImage() : im;
2593	beginLine = input_stream.getBeginLine();
2594	beginColumn = input_stream.getBeginColumn();
2595	endLine = input_stream.getEndLine();
2596	endColumn = input_stream.getEndColumn();
2597	t = Token.newToken(jjmatchedKind);
2598	t.kind = jjmatchedKind;
2599	t.image = curTokenImage;
2600
2601	t.beginLine = beginLine;
2602	t.endLine = endLine;
2603	t.beginColumn = beginColumn;
2604	t.endColumn = endColumn;
2605
2606	return t;
2607	}
2608	static final int[] jjnextStates = {
2609	62, 63, 64, 65, 66, 67, 68, 69, 10, 75, 76, 77, 83, 84, 85, 56,
2610	60, 28, 29, 36, 37, 13, 15, 26, 96, 100, 103, 107, 111, 114, 118, 131,
2611	3, 4, 5, 10, 8, 10, 11, 7, 8, 10, 11, 28, 29, 39, 36, 37,
2612	72, 10, 74, 71, 72, 10, 74, 80, 10, 82, 79, 80, 10, 82, 86, 89,
2613	10, 87, 88, 89, 10, 92, 10, 94, 91, 92, 10, 94, 98, 99, 64, 101,
2614	102, 64, 105, 106, 64, 120, 121, 122, 124, 125, 126, 129, 130, 10, 133, 134,
2615	135, 136, 139, 140, 10, 30, 38, 40, 3, 4, 6, 7, 8, 9, 16, 17,
2616	19, 62, 63, 65, 66, 67, 68, 70, 71, 72, 73, 75, 76, 78, 79, 80,
2617	81, 83, 84, 87, 88, 90, 91, 92, 93, 101, 102, 105, 106, 112, 113, 116,
2618	117, 127, 128, 129, 130, 137, 138, 139, 140,
2619	};
2620	private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
2621	{
2622	switch(hiByte)
2623	{
2624	case 0:
2625	return ((jjbitVec0[i2] & l2) != 0L);
2626	case 22:
2627	return ((jjbitVec1[i2] & l2) != 0L);
2628	case 24:
2629	return ((jjbitVec2[i2] & l2) != 0L);
2630	case 32:
2631	return ((jjbitVec3[i2] & l2) != 0L);
2632	case 48:
2633	return ((jjbitVec4[i2] & l2) != 0L);
2634	case 254:
2635	return ((jjbitVec5[i2] & l2) != 0L);
2636	default :
2637	return false;
2638	}
2639	}
2640	private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
2641	{
2642	switch(hiByte)
2643	{
2644	case 0:
2645	return ((jjbitVec8[i2] & l2) != 0L);
2646	default :
2647	if ((jjbitVec6[i1] & l1) != 0L)
2648	return true;
2649	return false;
2650	}
2651	}
2652	private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
2653	{
2654	switch(hiByte)
2655	{
2656	case 0:
2657	return ((jjbitVec10[i2] & l2) != 0L);
2658	case 2:
2659	return ((jjbitVec11[i2] & l2) != 0L);
2660	case 3:
2661	return ((jjbitVec12[i2] & l2) != 0L);
2662	case 4:
2663	return ((jjbitVec13[i2] & l2) != 0L);
2664	case 5:
2665	return ((jjbitVec14[i2] & l2) != 0L);
2666	case 6:
2667	return ((jjbitVec15[i2] & l2) != 0L);
2668	case 7:
2669	return ((jjbitVec16[i2] & l2) != 0L);
2670	case 8:
2671	return ((jjbitVec17[i2] & l2) != 0L);
2672	case 9:
2673	return ((jjbitVec18[i2] & l2) != 0L);
2674	case 10:
2675	return ((jjbitVec19[i2] & l2) != 0L);
2676	case 11:
2677	return ((jjbitVec20[i2] & l2) != 0L);
2678	case 12:
2679	return ((jjbitVec21[i2] & l2) != 0L);
2680	case 13:
2681	return ((jjbitVec22[i2] & l2) != 0L);
2682	case 14:
2683	return ((jjbitVec23[i2] & l2) != 0L);
2684	case 15:
2685	return ((jjbitVec24[i2] & l2) != 0L);
2686	case 16:
2687	return ((jjbitVec25[i2] & l2) != 0L);
2688	case 18:
2689	return ((jjbitVec26[i2] & l2) != 0L);
2690	case 19:
2691	return ((jjbitVec27[i2] & l2) != 0L);
2692	case 20:
2693	return ((jjbitVec6[i2] & l2) != 0L);
2694	case 22:
2695	return ((jjbitVec28[i2] & l2) != 0L);
2696	case 23:
2697	return ((jjbitVec29[i2] & l2) != 0L);
2698	case 24:
2699	return ((jjbitVec30[i2] & l2) != 0L);
2700	case 25:
2701	return ((jjbitVec31[i2] & l2) != 0L);
2702	case 26:
2703	return ((jjbitVec32[i2] & l2) != 0L);
2704	case 27:
2705	return ((jjbitVec33[i2] & l2) != 0L);
2706	case 28:
2707	return ((jjbitVec34[i2] & l2) != 0L);
2708	case 29:
2709	return ((jjbitVec35[i2] & l2) != 0L);
2710	case 31:
2711	return ((jjbitVec36[i2] & l2) != 0L);
2712	case 32:
2713	return ((jjbitVec37[i2] & l2) != 0L);
2714	case 33:
2715	return ((jjbitVec38[i2] & l2) != 0L);
2716	case 44:
2717	return ((jjbitVec39[i2] & l2) != 0L);
2718	case 45:
2719	return ((jjbitVec40[i2] & l2) != 0L);
2720	case 46:
2721	return ((jjbitVec41[i2] & l2) != 0L);
2722	case 48:
2723	return ((jjbitVec42[i2] & l2) != 0L);
2724	case 49:
2725	return ((jjbitVec43[i2] & l2) != 0L);
2726	case 77:
2727	return ((jjbitVec44[i2] & l2) != 0L);
2728	case 159:
2729	return ((jjbitVec45[i2] & l2) != 0L);
2730	case 164:
2731	return ((jjbitVec46[i2] & l2) != 0L);
2732	case 166:
2733	return ((jjbitVec47[i2] & l2) != 0L);
2734	case 167:
2735	return ((jjbitVec48[i2] & l2) != 0L);
2736	case 168:
2737	return ((jjbitVec49[i2] & l2) != 0L);
2738	case 169:
2739	return ((jjbitVec50[i2] & l2) != 0L);
2740	case 170:
2741	return ((jjbitVec51[i2] & l2) != 0L);
2742	case 171:
2743	return ((jjbitVec52[i2] & l2) != 0L);
2744	case 215:
2745	return ((jjbitVec53[i2] & l2) != 0L);
2746	case 250:
2747	return ((jjbitVec54[i2] & l2) != 0L);
2748	case 251:
2749	return ((jjbitVec55[i2] & l2) != 0L);
2750	case 253:
2751	return ((jjbitVec56[i2] & l2) != 0L);
2752	case 254:
2753	return ((jjbitVec57[i2] & l2) != 0L);
2754	case 255:
2755	return ((jjbitVec58[i2] & l2) != 0L);
2756	default :
2757	if ((jjbitVec9[i1] & l1) != 0L)
2758	return true;
2759	return false;
2760	}
2761	}
2762	private static final boolean jjCanMove_3(int hiByte, int i1, int i2, long l1, long l2)
2763	{
2764	switch(hiByte)
2765	{
2766	case 0:
2767	return ((jjbitVec59[i2] & l2) != 0L);
2768	case 2:
2769	return ((jjbitVec11[i2] & l2) != 0L);
2770	case 3:
2771	return ((jjbitVec60[i2] & l2) != 0L);
2772	case 4:
2773	return ((jjbitVec61[i2] & l2) != 0L);
2774	case 5:
2775	return ((jjbitVec62[i2] & l2) != 0L);
2776	case 6:
2777	return ((jjbitVec63[i2] & l2) != 0L);
2778	case 7:
2779	return ((jjbitVec64[i2] & l2) != 0L);
2780	case 8:
2781	return ((jjbitVec65[i2] & l2) != 0L);
2782	case 9:
2783	return ((jjbitVec66[i2] & l2) != 0L);
2784	case 10:
2785	return ((jjbitVec67[i2] & l2) != 0L);
2786	case 11:
2787	return ((jjbitVec68[i2] & l2) != 0L);
2788	case 12:
2789	return ((jjbitVec69[i2] & l2) != 0L);
2790	case 13:
2791	return ((jjbitVec70[i2] & l2) != 0L);
2792	case 14:
2793	return ((jjbitVec71[i2] & l2) != 0L);
2794	case 15:
2795	return ((jjbitVec72[i2] & l2) != 0L);
2796	case 16:
2797	return ((jjbitVec73[i2] & l2) != 0L);
2798	case 18:
2799	return ((jjbitVec26[i2] & l2) != 0L);
2800	case 19:
2801	return ((jjbitVec74[i2] & l2) != 0L);
2802	case 20:
2803	return ((jjbitVec6[i2] & l2) != 0L);
2804	case 22:
2805	return ((jjbitVec28[i2] & l2) != 0L);
2806	case 23:
2807	return ((jjbitVec75[i2] & l2) != 0L);
2808	case 24:
2809	return ((jjbitVec76[i2] & l2) != 0L);
2810	case 25:
2811	return ((jjbitVec77[i2] & l2) != 0L);
2812	case 26:
2813	return ((jjbitVec78[i2] & l2) != 0L);
2814	case 27:
2815	return ((jjbitVec79[i2] & l2) != 0L);
2816	case 28:
2817	return ((jjbitVec80[i2] & l2) != 0L);
2818	case 29:
2819	return ((jjbitVec81[i2] & l2) != 0L);
2820	case 31:
2821	return ((jjbitVec36[i2] & l2) != 0L);
2822	case 32:
2823	return ((jjbitVec82[i2] & l2) != 0L);
2824	case 33:
2825	return ((jjbitVec38[i2] & l2) != 0L);
2826	case 44:
2827	return ((jjbitVec83[i2] & l2) != 0L);
2828	case 45:
2829	return ((jjbitVec84[i2] & l2) != 0L);
2830	case 46:
2831	return ((jjbitVec41[i2] & l2) != 0L);
2832	case 48:
2833	return ((jjbitVec85[i2] & l2) != 0L);
2834	case 49:
2835	return ((jjbitVec43[i2] & l2) != 0L);
2836	case 77:
2837	return ((jjbitVec44[i2] & l2) != 0L);
2838	case 159:
2839	return ((jjbitVec45[i2] & l2) != 0L);
2840	case 164:
2841	return ((jjbitVec46[i2] & l2) != 0L);
2842	case 166:
2843	return ((jjbitVec86[i2] & l2) != 0L);
2844	case 167:
2845	return ((jjbitVec48[i2] & l2) != 0L);
2846	case 168:
2847	return ((jjbitVec87[i2] & l2) != 0L);
2848	case 169:
2849	return ((jjbitVec88[i2] & l2) != 0L);
2850	case 170:
2851	return ((jjbitVec89[i2] & l2) != 0L);
2852	case 171:
2853	return ((jjbitVec90[i2] & l2) != 0L);
2854	case 215:
2855	return ((jjbitVec53[i2] & l2) != 0L);
2856	case 250:
2857	return ((jjbitVec54[i2] & l2) != 0L);
2858	case 251:
2859	return ((jjbitVec91[i2] & l2) != 0L);
2860	case 253:
2861	return ((jjbitVec56[i2] & l2) != 0L);
2862	case 254:
2863	return ((jjbitVec92[i2] & l2) != 0L);
2864	case 255:
2865	return ((jjbitVec93[i2] & l2) != 0L);
2866	default :
2867	if ((jjbitVec9[i1] & l1) != 0L)
2868	return true;
2869	return false;
2870	}
2871	}
2872
2873	int curLexState = 0;
2874	int defaultLexState = 0;
2875	int jjnewStateCnt;
2876	int jjround;
2877	int jjmatchedPos;
2878	int jjmatchedKind;
2879
2880	/** Get the next Token. */
2881	public Token getNextToken()
2882	{
2883	Token specialToken = null;
2884	Token matchedToken;
2885	int curPos = 0;
2886
2887	EOFLoop:
2888	for (;;)
2889	{
2890	try
2891	{
2892	curChar = input_stream.beginToken();
2893	}
2894	catch(final Exception e)
2895	{
2896	jjmatchedKind = 0;
2897	jjmatchedPos = -1;
2898	matchedToken = jjFillToken();
2899	matchedToken.specialToken = specialToken;
2900	CommonTokenAction(matchedToken);
2901	return matchedToken;
2902	}
2903	image = jjimage;
2904	image.setLength(0);
2905	jjimageLen = 0;
2906
2907	for (;;)
2908	{
2909	switch(curLexState)
2910	{
2911	case 0:
2912	jjmatchedKind = 0x7fffffff;
2913	jjmatchedPos = 0;
2914	curPos = jjMoveStringLiteralDfa0_0();
2915	break;
2916	case 1:
2917	jjmatchedKind = 0x7fffffff;
2918	jjmatchedPos = 0;
2919	curPos = jjMoveStringLiteralDfa0_1();
2920	if (jjmatchedPos == 0 && jjmatchedKind > 10)
2921	{
2922	jjmatchedKind = 10;
2923	}
2924	break;
2925	case 2:
2926	jjmatchedKind = 0x7fffffff;
2927	jjmatchedPos = 0;
2928	curPos = jjMoveStringLiteralDfa0_2();
2929	if (jjmatchedPos == 0 && jjmatchedKind > 10)
2930	{
2931	jjmatchedKind = 10;
2932	}
2933	break;
2934	case 3:
2935	jjmatchedKind = 0x7fffffff;
2936	jjmatchedPos = 0;
2937	curPos = jjMoveStringLiteralDfa0_3();
2938	break;
2939	}
2940	if (jjmatchedKind != 0x7fffffff)
2941	{
2942	if (jjmatchedPos + 1 < curPos)
2943	input_stream.backup(curPos - jjmatchedPos - 1);
2944	if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2945	{
2946	matchedToken = jjFillToken();
2947	matchedToken.specialToken = specialToken;
2948	TokenLexicalActions(matchedToken);
2949	if (jjnewLexState[jjmatchedKind] != -1)
2950	curLexState = jjnewLexState[jjmatchedKind];
2951	CommonTokenAction(matchedToken);
2952	return matchedToken;
2953	}
2954	else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2955	{
2956	if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2957	{
2958	matchedToken = jjFillToken();
2959	if (specialToken == null)
2960	specialToken = matchedToken;
2961	else
2962	{
2963	matchedToken.specialToken = specialToken;
2964	specialToken = (specialToken.next = matchedToken);
2965	}
2966	SkipLexicalActions(matchedToken);
2967	}
2968	else
2969	SkipLexicalActions(null);
2970	if (jjnewLexState[jjmatchedKind] != -1)
2971	curLexState = jjnewLexState[jjmatchedKind];
2972	continue EOFLoop;
2973	}
2974	MoreLexicalActions();
2975	if (jjnewLexState[jjmatchedKind] != -1)
2976	curLexState = jjnewLexState[jjmatchedKind];
2977	curPos = 0;
2978	jjmatchedKind = 0x7fffffff;
2979	try {
2980	curChar = input_stream.readChar();
2981	continue;
2982	}
2983	catch (final java.io.IOException e1) { }
2984	}
2985	int error_line = input_stream.getEndLine();
2986	int error_column = input_stream.getEndColumn();
2987	String error_after = null;
2988	boolean EOFSeen = false;
2989	try {
2990	input_stream.readChar();
2991	input_stream.backup(1);
2992	}
2993	catch (final java.io.IOException e1) {
2994	EOFSeen = true;
2995	error_after = curPos <= 1 ? "" : input_stream.getImage();
2996	if (curChar == '\n' \|\| curChar == '\r') {
2997	error_line++;
2998	error_column = 0;
2999	}
3000	else
3001	error_column++;
3002	}
3003	if (!EOFSeen) {
3004	input_stream.backup(1);
3005	error_after = curPos <= 1 ? "" : input_stream.getImage();
3006	}
3007	throw new TokenMgrException(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrException.LEXICAL_ERROR);
3008	}
3009	}
3010	}
3011
3012	void SkipLexicalActions(Token matchedToken)
3013	{
3014	switch(jjmatchedKind)
3015	{
3016	default :
3017	break;
3018	}
3019	}
3020	void MoreLexicalActions()
3021	{
3022	jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
3023	switch(jjmatchedKind)
3024	{
3025	case 6 :
3026	image.append(input_stream.getSuffix(jjimageLen));
3027	jjimageLen = 0;
3028	input_stream.backup(1);
3029	break;
3030	default :
3031	break;
3032	}
3033	}
3034	void TokenLexicalActions(Token matchedToken)
3035	{
3036	switch(jjmatchedKind)
3037	{
3038	case 64 :
3039	image.append(jjstrLiteralImages[64]);
3040	lengthOfMatch = jjstrLiteralImages[64].length();
3041	if(!yieldSupported)matchedToken.kind=IDENTIFIER;
3042	break;
3043	case 143 :
3044	image.append(jjstrLiteralImages[143]);
3045	lengthOfMatch = jjstrLiteralImages[143].length();
3046	matchedToken.kind = GT;
3047	matchedToken.realKind = RUNSIGNEDSHIFT;
3048	input_stream.backup(2);
3049	break;
3050	case 144 :
3051	image.append(jjstrLiteralImages[144]);
3052	lengthOfMatch = jjstrLiteralImages[144].length();
3053	matchedToken.kind = GT;
3054	matchedToken.realKind = RSIGNEDSHIFT;
3055	input_stream.backup(1);
3056	break;
3057	default :
3058	break;
3059	}
3060	}
3061	private void jjCheckNAdd(int state)
3062	{
3063	if (jjrounds[state] != jjround)
3064	{
3065	jjstateSet[jjnewStateCnt++] = state;
3066	jjrounds[state] = jjround;
3067	}
3068	}
3069	private void jjAddStates(int start, int end)
3070	{
3071	do {
3072	jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3073	} while (start++ != end);
3074	}
3075	private void jjCheckNAddTwoStates(int state1, int state2)
3076	{
3077	jjCheckNAdd(state1);
3078	jjCheckNAdd(state2);
3079	}
3080
3081	private void jjCheckNAddStates(int start, int end)
3082	{
3083	do {
3084	jjCheckNAdd(jjnextStates[start]);
3085	} while (start++ != end);
3086	}
3087
3088	/** Constructor. */
3089	public GeneratedJavaParserTokenManager(SimpleCharStream stream){
3090	input_stream = stream;
3091	}
3092
3093	/** Constructor. */
3094	public GeneratedJavaParserTokenManager (SimpleCharStream stream, int lexState){
3095	ReInit(stream);
3096	SwitchTo(lexState);
3097	}
3098
3099	/** Reinitialise parser. */
3100
3101	public void ReInit(SimpleCharStream stream)
3102	{
3103
3104
3105	jjmatchedPos =
3106	jjnewStateCnt =
3107	0;
3108	curLexState = defaultLexState;
3109	input_stream = stream;
3110	ReInitRounds();
3111	}
3112
3113	private void ReInitRounds()
3114	{
3115	int i;
3116	jjround = 0x80000001;
3117	for (i = 141; i-- > 0;)
3118	jjrounds[i] = 0x80000000;
3119	}
3120
3121	/** Reinitialise parser. */
3122	public void ReInit(SimpleCharStream stream, int lexState)
3123	{
3124	ReInit(stream);
3125	SwitchTo(lexState);
3126	}
3127
3128	/** Switch to specified lex state. */
3129	public void SwitchTo(int lexState)
3130	{
3131	if (lexState >= 4 \|\| lexState < 0)
3132	throw new TokenMgrException("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrException.INVALID_LEXICAL_STATE);
3133	else
3134	curLexState = lexState;
3135	}
3136
3137
3138	/** Lexer state names. */
3139	public static final String[] lexStateNames = {
3140	"DEFAULT",
3141	"IN_JAVADOC_COMMENT",
3142	"IN_MULTI_LINE_COMMENT",
3143	"IN_TEXT_BLOCK",
3144	};
3145
3146	/** Lex State array. */
3147	public static final int[] jjnewLexState = {
3148	-1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3149	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3150	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3151	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 0, -1, -1, -1, -1, -1, -1, -1, -1,
3152	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3153	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3154	};
3155	static final long[] jjtoToken = {
3156	0xfffffffffffff801L, 0xffffffff2b021fffL, 0x7ffffL,
3157	};
3158	static final long[] jjtoSkip = {
3159	0x33eL, 0x0L, 0x0L,
3160	};
3161	static final long[] jjtoSpecial = {
3162	0x33eL, 0x0L, 0x0L,
3163	};
3164	static final long[] jjtoMore = {
3165	0x4c0L, 0x14000000L, 0x0L,
3166	};
3167	protected SimpleCharStream input_stream;
3168
3169	private final int[] jjrounds = new int[141];
3170	private final int[] jjstateSet = new int[2 * 141];
3171	private final StringBuilder jjimage = new StringBuilder();
3172	private StringBuilder image = jjimage;
3173	private int jjimageLen;
3174	private int lengthOfMatch;
3175	protected int curChar;
3176	}
3177