1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.commons.jxpath.ri.parser;
20
21 public class XPathParserTokenManager implements XPathParserConstants {
22
23 static final long[] jjbitVec0 = { 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL };
24 static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL };
25 static final long[] jjbitVec3 = { 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL };
26 static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL };
27 static final long[] jjbitVec5 = { 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL };
28 static final long[] jjbitVec6 = { 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L };
29 static final long[] jjbitVec7 = { 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL };
30 static final long[] jjbitVec8 = { 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL };
31 static final long[] jjbitVec9 = { 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L };
32 static final long[] jjbitVec10 = { 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL };
33 static final long[] jjbitVec11 = { 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L };
34 static final long[] jjbitVec12 = { 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L };
35 static final long[] jjbitVec13 = { 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L };
36 static final long[] jjbitVec14 = { 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L };
37 static final long[] jjbitVec15 = { 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L };
38 static final long[] jjbitVec16 = { 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL };
39 static final long[] jjbitVec17 = { 0x0L, 0x3fffffffeffL, 0x0L, 0x0L };
40 static final long[] jjbitVec18 = { 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL };
41 static final long[] jjbitVec19 = { 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L };
42 static final long[] jjbitVec20 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL };
43 static final long[] jjbitVec21 = { 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL };
44 static final long[] jjbitVec22 = { 0x4c4000000000L, 0x0L, 0x7L, 0x0L };
45 static final long[] jjbitVec23 = { 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL };
46 static final long[] jjbitVec24 = { 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L };
47 static final long[] jjbitVec25 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L };
48 static final long[] jjbitVec26 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L };
49 static final long[] jjbitVec27 = { 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL };
50 static final long[] jjbitVec28 = { 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L };
51 static final long[] jjbitVec29 = { 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL };
52 static final long[] jjbitVec30 = { 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL };
53 static final long[] jjbitVec31 = { 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L };
54 static final long[] jjbitVec32 = { 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL };
55 static final long[] jjbitVec33 = { 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL };
56 static final long[] jjbitVec34 = { 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL };
57 static final long[] jjbitVec35 = { 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L };
58 static final long[] jjbitVec36 = { 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL };
59 static final long[] jjbitVec37 = { 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L };
60 static final long[] jjbitVec38 = { 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL };
61 static final long[] jjbitVec39 = { 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L };
62 static final long[] jjbitVec40 = { 0x0L, 0x0L, 0x0L, 0x21fff0000L };
63 static final long[] jjbitVec41 = { 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL };
64 static final int[] jjnextStates = { 1, 2, 4, 5, };
65 public static final String[] jjstrLiteralImages = { "", null, null, null, null, null, "\57", "\57\57", "\174", "\53", "\55", "\75", "\41\75", "\74",
66 "\74\75", "\76", "\76\75", "\44", null, null, null, null, null, null, null, null, null, "\157\162", "\141\156\144", "\155\157\144", "\144\151\166",
67 "\156\157\144\145", "\164\145\170\164", "\143\157\155\155\145\156\164",
68 "\160\162\157\143\145\163\163\151\156\147\55\151\156\163\164\162\165\143\164\151\157\156", "\163\145\154\146\72\72", "\143\150\151\154\144\72\72",
69 "\160\141\162\145\156\164\72\72", "\141\156\143\145\163\164\157\162\72\72", "\141\164\164\162\151\142\165\164\145\72\72",
70 "\156\141\155\145\163\160\141\143\145\72\72", "\160\162\145\143\145\144\151\156\147\72\72", "\146\157\154\154\157\167\151\156\147\72\72",
71 "\144\145\163\143\145\156\144\141\156\164\72\72", "\141\156\143\145\163\164\157\162\55\157\162\55\163\145\154\146\72\72",
72 "\146\157\154\154\157\167\151\156\147\55\163\151\142\154\151\156\147\72\72",
73 "\160\162\145\143\145\144\151\156\147\55\163\151\142\154\151\156\147\72\72",
74 "\144\145\163\143\145\156\144\141\156\164\55\157\162\55\163\145\154\146\72\72", "\154\141\163\164", "\160\157\163\151\164\151\157\156",
75 "\143\157\165\156\164", "\151\144", "\153\145\171", "\154\157\143\141\154\55\156\141\155\145",
76 "\156\141\155\145\163\160\141\143\145\55\165\162\151", "\156\141\155\145", "\163\164\162\151\156\147", "\143\157\156\143\141\164",
77 "\163\164\141\162\164\163\55\167\151\164\150", "\145\156\144\163\55\167\151\164\150", "\143\157\156\164\141\151\156\163",
78 "\163\165\142\163\164\162\151\156\147\55\142\145\146\157\162\145", "\163\165\142\163\164\162\151\156\147\55\141\146\164\145\162",
79 "\163\165\142\163\164\162\151\156\147", "\163\164\162\151\156\147\55\154\145\156\147\164\150",
80 "\156\157\162\155\141\154\151\172\145\55\163\160\141\143\145", "\164\162\141\156\163\154\141\164\145", "\142\157\157\154\145\141\156",
81 "\156\157\164", "\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154", "\154\141\156\147", "\156\165\155\142\145\162", "\163\165\155",
82 "\146\154\157\157\162", "\143\145\151\154\151\156\147", "\162\157\165\156\144", "\146\157\162\155\141\164\55\156\165\155\142\145\162", null, "\72",
83 "\50", "\51", "\56", "\56\56", "\133", "\135", "\100", "\54", "\52", };
84 public static final String[] lexStateNames = { "DEFAULT", };
85 static final long[] jjtoToken = { 0xfffffffff817ffc1L, 0x3ffffffL, };
86 static final long[] jjtoSkip = { 0x3eL, 0x0L, };
87
88 private static boolean jjCanMove_0(final int hiByte, final int i1, final int i2, final long l1, final long l2) {
89 switch (hiByte) {
90 case 0:
91 return (jjbitVec2[i2] & l2) != 0L;
92 default:
93 if ((jjbitVec0[i1] & l1) != 0L) {
94 return true;
95 }
96 return false;
97 }
98 }
99
100 private static boolean jjCanMove_1(final int hiByte, final int i1, final int i2, final long l1, final long l2) {
101 switch (hiByte) {
102 case 0:
103 return (jjbitVec4[i2] & l2) != 0L;
104 case 1:
105 return (jjbitVec5[i2] & l2) != 0L;
106 case 2:
107 return (jjbitVec6[i2] & l2) != 0L;
108 case 3:
109 return (jjbitVec7[i2] & l2) != 0L;
110 case 4:
111 return (jjbitVec8[i2] & l2) != 0L;
112 case 5:
113 return (jjbitVec9[i2] & l2) != 0L;
114 case 6:
115 return (jjbitVec10[i2] & l2) != 0L;
116 case 9:
117 return (jjbitVec11[i2] & l2) != 0L;
118 case 10:
119 return (jjbitVec12[i2] & l2) != 0L;
120 case 11:
121 return (jjbitVec13[i2] & l2) != 0L;
122 case 12:
123 return (jjbitVec14[i2] & l2) != 0L;
124 case 13:
125 return (jjbitVec15[i2] & l2) != 0L;
126 case 14:
127 return (jjbitVec16[i2] & l2) != 0L;
128 case 15:
129 return (jjbitVec17[i2] & l2) != 0L;
130 case 16:
131 return (jjbitVec18[i2] & l2) != 0L;
132 case 17:
133 return (jjbitVec19[i2] & l2) != 0L;
134 case 30:
135 return (jjbitVec20[i2] & l2) != 0L;
136 case 31:
137 return (jjbitVec21[i2] & l2) != 0L;
138 case 33:
139 return (jjbitVec22[i2] & l2) != 0L;
140 case 48:
141 return (jjbitVec23[i2] & l2) != 0L;
142 case 49:
143 return (jjbitVec24[i2] & l2) != 0L;
144 case 159:
145 return (jjbitVec25[i2] & l2) != 0L;
146 case 215:
147 return (jjbitVec26[i2] & l2) != 0L;
148 default:
149 if ((jjbitVec3[i1] & l1) != 0L) {
150 return true;
151 }
152 return false;
153 }
154 }
155
156 private static boolean jjCanMove_2(final int hiByte, final int i1, final int i2, final long l1, final long l2) {
157 switch (hiByte) {
158 case 0:
159 return (jjbitVec27[i2] & l2) != 0L;
160 case 1:
161 return (jjbitVec5[i2] & l2) != 0L;
162 case 2:
163 return (jjbitVec28[i2] & l2) != 0L;
164 case 3:
165 return (jjbitVec29[i2] & l2) != 0L;
166 case 4:
167 return (jjbitVec30[i2] & l2) != 0L;
168 case 5:
169 return (jjbitVec31[i2] & l2) != 0L;
170 case 6:
171 return (jjbitVec32[i2] & l2) != 0L;
172 case 9:
173 return (jjbitVec33[i2] & l2) != 0L;
174 case 10:
175 return (jjbitVec34[i2] & l2) != 0L;
176 case 11:
177 return (jjbitVec35[i2] & l2) != 0L;
178 case 12:
179 return (jjbitVec36[i2] & l2) != 0L;
180 case 13:
181 return (jjbitVec37[i2] & l2) != 0L;
182 case 14:
183 return (jjbitVec38[i2] & l2) != 0L;
184 case 15:
185 return (jjbitVec39[i2] & l2) != 0L;
186 case 16:
187 return (jjbitVec18[i2] & l2) != 0L;
188 case 17:
189 return (jjbitVec19[i2] & l2) != 0L;
190 case 30:
191 return (jjbitVec20[i2] & l2) != 0L;
192 case 31:
193 return (jjbitVec21[i2] & l2) != 0L;
194 case 32:
195 return (jjbitVec40[i2] & l2) != 0L;
196 case 33:
197 return (jjbitVec22[i2] & l2) != 0L;
198 case 48:
199 return (jjbitVec41[i2] & l2) != 0L;
200 case 49:
201 return (jjbitVec24[i2] & l2) != 0L;
202 case 159:
203 return (jjbitVec25[i2] & l2) != 0L;
204 case 215:
205 return (jjbitVec26[i2] & l2) != 0L;
206 default:
207 if ((jjbitVec3[i1] & l1) != 0L) {
208 return true;
209 }
210 return false;
211 }
212 }
213
214 public java.io.PrintStream debugStream = System.out;
215 protected SimpleCharStream input_stream;
216 private final int[] jjrounds = new int[13];
217 private final int[] jjstateSet = new int[26];
218 protected char curChar;
219 int curLexState = 0;
220 int defaultLexState = 0;
221 int jjnewStateCnt;
222 int jjround;
223 int jjmatchedPos;
224 int jjmatchedKind;
225
226 public XPathParserTokenManager(final SimpleCharStream stream) {
227 if (SimpleCharStream.staticFlag) {
228 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
229 }
230 input_stream = stream;
231 }
232
233 public XPathParserTokenManager(final SimpleCharStream stream, final int lexState) {
234 this(stream);
235 SwitchTo(lexState);
236 }
237
238 public Token getNextToken() {
239 Token matchedToken;
240 int curPos = 0;
241 EOFLoop: for (;;) {
242 try {
243 curChar = input_stream.BeginToken();
244 } catch (final java.io.IOException e) {
245 jjmatchedKind = 0;
246 matchedToken = jjFillToken();
247 return matchedToken;
248 }
249 try {
250 input_stream.backup(0);
251 while (curChar <= 32 && (0x100003600L & 1L << curChar) != 0L) {
252 curChar = input_stream.BeginToken();
253 }
254 } catch (final java.io.IOException e1) {
255 continue EOFLoop;
256 }
257 jjmatchedKind = 0x7fffffff;
258 jjmatchedPos = 0;
259 curPos = jjMoveStringLiteralDfa0_0();
260 if (jjmatchedKind != 0x7fffffff) {
261 if (jjmatchedPos + 1 < curPos) {
262 input_stream.backup(curPos - jjmatchedPos - 1);
263 }
264 if ((jjtoToken[jjmatchedKind >> 6] & 1L << (jjmatchedKind & 077)) != 0L) {
265 matchedToken = jjFillToken();
266 return matchedToken;
267 }
268 continue EOFLoop;
269 }
270 int error_line = input_stream.getEndLine();
271 int error_column = input_stream.getEndColumn();
272 String error_after = null;
273 boolean EOFSeen = false;
274 try {
275 input_stream.readChar();
276 input_stream.backup(1);
277 } catch (final java.io.IOException e1) {
278 EOFSeen = true;
279 error_after = curPos <= 1 ? "" : input_stream.GetImage();
280 if (curChar == '\n' || curChar == '\r') {
281 error_line++;
282 error_column = 0;
283 } else {
284 error_column++;
285 }
286 }
287 if (!EOFSeen) {
288 input_stream.backup(1);
289 error_after = curPos <= 1 ? "" : input_stream.GetImage();
290 }
291 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
292 }
293 }
294
295 private void jjAddStates(int start, final int end) {
296 do {
297 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
298 } while (start++ != end);
299 }
300
301 private void jjCheckNAdd(final int state) {
302 if (jjrounds[state] != jjround) {
303 jjstateSet[jjnewStateCnt++] = state;
304 jjrounds[state] = jjround;
305 }
306 }
307
308 private void jjCheckNAddTwoStates(final int state1, final int state2) {
309 jjCheckNAdd(state1);
310 jjCheckNAdd(state2);
311 }
312
313 protected Token jjFillToken() {
314 final Token t = Token.newToken(jjmatchedKind);
315 t.kind = jjmatchedKind;
316 final String im = jjstrLiteralImages[jjmatchedKind];
317 t.image = im == null ? input_stream.GetImage() : im;
318 t.beginLine = input_stream.getBeginLine();
319 t.beginColumn = input_stream.getBeginColumn();
320 t.endLine = input_stream.getEndLine();
321 t.endColumn = input_stream.getEndColumn();
322 return t;
323 }
324
325 private int jjMoveNfa_0(final int startState, int curPos) {
326 int startsAt = 0;
327 jjnewStateCnt = 13;
328 int i = 1;
329 jjstateSet[0] = startState;
330 int kind = 0x7fffffff;
331 for (;;) {
332 if (++jjround == 0x7fffffff) {
333 ReInitRounds();
334 }
335 if (curChar < 64) {
336 final long l = 1L << curChar;
337 MatchLoop: do {
338 switch (jjstateSet[--i]) {
339 case 0:
340 if ((0x3ff000000000000L & l) != 0L) {
341 if (kind > 20) {
342 kind = 20;
343 }
344 jjCheckNAddTwoStates(6, 7);
345 } else {
346 switch (curChar) {
347 case 46:
348 jjCheckNAdd(10);
349 break;
350 case 39:
351 jjCheckNAddTwoStates(4, 5);
352 break;
353 case 34:
354 jjCheckNAddTwoStates(1, 2);
355 break;
356 default:
357 break;
358 }
359 }
360 break;
361 case 1:
362 if ((0xfffffffbffffffffL & l) != 0L) {
363 jjCheckNAddTwoStates(1, 2);
364 }
365 break;
366 case 2:
367 if (curChar == 34 && kind > 18) {
368 kind = 18;
369 }
370 break;
371 case 3:
372 if (curChar == 39) {
373 jjCheckNAddTwoStates(4, 5);
374 }
375 break;
376 case 4:
377 if ((0xffffff7fffffffffL & l) != 0L) {
378 jjCheckNAddTwoStates(4, 5);
379 }
380 break;
381 case 5:
382 if (curChar == 39 && kind > 18) {
383 kind = 18;
384 }
385 break;
386 case 6:
387 if ((0x3ff000000000000L & l) == 0L) {
388 break;
389 }
390 if (kind > 20) {
391 kind = 20;
392 }
393 jjCheckNAddTwoStates(6, 7);
394 break;
395 case 7:
396 if (curChar != 46) {
397 break;
398 }
399 if (kind > 20) {
400 kind = 20;
401 }
402 jjCheckNAdd(8);
403 break;
404 case 8:
405 if ((0x3ff000000000000L & l) == 0L) {
406 break;
407 }
408 if (kind > 20) {
409 kind = 20;
410 }
411 jjCheckNAdd(8);
412 break;
413 case 9:
414 if (curChar == 46) {
415 jjCheckNAdd(10);
416 }
417 break;
418 case 10:
419 if ((0x3ff000000000000L & l) == 0L) {
420 break;
421 }
422 if (kind > 20) {
423 kind = 20;
424 }
425 jjCheckNAdd(10);
426 break;
427 case 12:
428 if ((0x3ff600000000000L & l) == 0L) {
429 break;
430 }
431 if (kind > 79) {
432 kind = 79;
433 }
434 jjstateSet[jjnewStateCnt++] = 12;
435 break;
436 default:
437 break;
438 }
439 } while (i != startsAt);
440 } else if (curChar < 128) {
441 final long l = 1L << (curChar & 077);
442 MatchLoop: do {
443 switch (jjstateSet[--i]) {
444 case 0:
445 case 12:
446 if ((0x7fffffe87fffffeL & l) == 0L) {
447 break;
448 }
449 if (kind > 79) {
450 kind = 79;
451 }
452 jjCheckNAdd(12);
453 break;
454 case 1:
455 jjAddStates(0, 1);
456 break;
457 case 4:
458 jjAddStates(2, 3);
459 break;
460 default:
461 break;
462 }
463 } while (i != startsAt);
464 } else {
465 final int hiByte = curChar >> 8;
466 final int i1 = hiByte >> 6;
467 final long l1 = 1L << (hiByte & 077);
468 final int i2 = (curChar & 0xff) >> 6;
469 final long l2 = 1L << (curChar & 077);
470 MatchLoop: do {
471 switch (jjstateSet[--i]) {
472 case 0:
473 if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) {
474 break;
475 }
476 if (kind > 79) {
477 kind = 79;
478 }
479 jjCheckNAdd(12);
480 break;
481 case 1:
482 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
483 jjAddStates(0, 1);
484 }
485 break;
486 case 4:
487 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
488 jjAddStates(2, 3);
489 }
490 break;
491 case 12:
492 if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) {
493 break;
494 }
495 if (kind > 79) {
496 kind = 79;
497 }
498 jjCheckNAdd(12);
499 break;
500 default:
501 break;
502 }
503 } while (i != startsAt);
504 }
505 if (kind != 0x7fffffff) {
506 jjmatchedKind = kind;
507 jjmatchedPos = curPos;
508 kind = 0x7fffffff;
509 }
510 ++curPos;
511 if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt))) {
512 return curPos;
513 }
514 try {
515 curChar = input_stream.readChar();
516 } catch (final java.io.IOException e) {
517 return curPos;
518 }
519 }
520 }
521
522 private int jjMoveStringLiteralDfa0_0() {
523 switch (curChar) {
524 case 33:
525 return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
526 case 36:
527 return jjStopAtPos(0, 17);
528 case 40:
529 return jjStopAtPos(0, 81);
530 case 41:
531 return jjStopAtPos(0, 82);
532 case 42:
533 return jjStopAtPos(0, 89);
534 case 43:
535 return jjStopAtPos(0, 9);
536 case 44:
537 return jjStopAtPos(0, 88);
538 case 45:
539 return jjStopAtPos(0, 10);
540 case 46:
541 jjmatchedKind = 83;
542 return jjMoveStringLiteralDfa1_0(0x0L, 0x100000L);
543 case 47:
544 jjmatchedKind = 6;
545 return jjMoveStringLiteralDfa1_0(0x80L, 0x0L);
546 case 58:
547 return jjStopAtPos(0, 80);
548 case 60:
549 jjmatchedKind = 13;
550 return jjMoveStringLiteralDfa1_0(0x4000L, 0x0L);
551 case 61:
552 return jjStopAtPos(0, 11);
553 case 62:
554 jjmatchedKind = 15;
555 return jjMoveStringLiteralDfa1_0(0x10000L, 0x0L);
556 case 64:
557 return jjStopAtPos(0, 87);
558 case 91:
559 return jjStopAtPos(0, 85);
560 case 93:
561 return jjStopAtPos(0, 86);
562 case 97:
563 return jjMoveStringLiteralDfa1_0(0x10c010000000L, 0x0L);
564 case 98:
565 return jjMoveStringLiteralDfa1_0(0x0L, 0x8L);
566 case 99:
567 return jjMoveStringLiteralDfa1_0(0x1204001200000000L, 0x1000L);
568 case 100:
569 return jjMoveStringLiteralDfa1_0(0x880040000000L, 0x0L);
570 case 101:
571 return jjMoveStringLiteralDfa1_0(0x800000000000000L, 0x0L);
572 case 102:
573 return jjMoveStringLiteralDfa1_0(0x240000000000L, 0x4840L);
574 case 105:
575 return jjMoveStringLiteralDfa1_0(0x8000000000000L, 0x0L);
576 case 107:
577 return jjMoveStringLiteralDfa1_0(0x10000000000000L, 0x0L);
578 case 108:
579 return jjMoveStringLiteralDfa1_0(0x21000000000000L, 0x100L);
580 case 109:
581 return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
582 case 110:
583 return jjMoveStringLiteralDfa1_0(0xc0010080000000L, 0x292L);
584 case 111:
585 return jjMoveStringLiteralDfa1_0(0x8000000L, 0x0L);
586 case 112:
587 return jjMoveStringLiteralDfa1_0(0x2422400000000L, 0x0L);
588 case 114:
589 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000L);
590 case 115:
591 return jjMoveStringLiteralDfa1_0(0xe500000800000000L, 0x401L);
592 case 116:
593 return jjMoveStringLiteralDfa1_0(0x100000000L, 0x24L);
594 case 124:
595 return jjStopAtPos(0, 8);
596 default:
597 return jjMoveNfa_0(0, 0);
598 }
599 }
600
601 private int jjMoveStringLiteralDfa1_0(final long active0, final long active1) {
602 try {
603 curChar = input_stream.readChar();
604 } catch (final java.io.IOException e) {
605 jjStopStringLiteralDfa_0(0, active0, active1);
606 return 1;
607 }
608 switch (curChar) {
609 case 46:
610 if ((active1 & 0x100000L) != 0L) {
611 return jjStopAtPos(1, 84);
612 }
613 break;
614 case 47:
615 if ((active0 & 0x80L) != 0L) {
616 return jjStopAtPos(1, 7);
617 }
618 break;
619 case 61:
620 if ((active0 & 0x1000L) != 0L) {
621 return jjStopAtPos(1, 12);
622 } else if ((active0 & 0x4000L) != 0L) {
623 return jjStopAtPos(1, 14);
624 } else if ((active0 & 0x10000L) != 0L) {
625 return jjStopAtPos(1, 16);
626 }
627 break;
628 case 97:
629 return jjMoveStringLiteralDfa2_0(active0, 0xc1012000000000L, active1, 0x140L);
630 case 100:
631 if ((active0 & 0x8000000000000L) != 0L) {
632 return jjStartNfaWithStates_0(1, 51, 12);
633 }
634 break;
635 case 101:
636 return jjMoveStringLiteralDfa2_0(active0, 0x10880900000000L, active1, 0x1000L);
637 case 104:
638 return jjMoveStringLiteralDfa2_0(active0, 0x1000000000L, active1, 0L);
639 case 105:
640 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
641 case 108:
642 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800L);
643 case 110:
644 return jjMoveStringLiteralDfa2_0(active0, 0x800104010000000L, active1, 0L);
645 case 111:
646 return jjMoveStringLiteralDfa2_0(active0, 0x12262402a0000000L, active1, 0x601aL);
647 case 114:
648 if ((active0 & 0x8000000L) != 0L) {
649 return jjStartNfaWithStates_0(1, 27, 12);
650 }
651 return jjMoveStringLiteralDfa2_0(active0, 0x420400000000L, active1, 0x24L);
652 case 116:
653 return jjMoveStringLiteralDfa2_0(active0, 0x500008000000000L, active1, 0x1L);
654 case 117:
655 return jjMoveStringLiteralDfa2_0(active0, 0xe000000000000000L, active1, 0x680L);
656 default:
657 break;
658 }
659 return jjStartNfa_0(0, active0, active1);
660 }
661
662 private int jjMoveStringLiteralDfa10_0(final long old0, long active0, final long old1, long active1) {
663 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
664 return jjStartNfa_0(8, old0, old1);
665 }
666 try {
667 curChar = input_stream.readChar();
668 } catch (final java.io.IOException e) {
669 jjStopStringLiteralDfa_0(9, active0, active1);
670 return 10;
671 }
672 switch (curChar) {
673 case 45:
674 return jjMoveStringLiteralDfa11_0(active0, 0x800400000000L, active1, 0L);
675 case 58:
676 if ((active0 & 0x8000000000L) != 0L) {
677 return jjStopAtPos(10, 39);
678 } else if ((active0 & 0x10000000000L) != 0L) {
679 return jjStopAtPos(10, 40);
680 } else if ((active0 & 0x20000000000L) != 0L) {
681 return jjStopAtPos(10, 41);
682 } else if ((active0 & 0x40000000000L) != 0L) {
683 return jjStopAtPos(10, 42);
684 }
685 return jjMoveStringLiteralDfa11_0(active0, 0x80000000000L, active1, 0L);
686 case 97:
687 return jjMoveStringLiteralDfa11_0(active0, 0x4000000000000000L, active1, 0L);
688 case 98:
689 return jjMoveStringLiteralDfa11_0(active0, 0x2000000000000000L, active1, 0x4000L);
690 case 103:
691 return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x1L);
692 case 104:
693 if ((active0 & 0x400000000000000L) != 0L) {
694 return jjStartNfaWithStates_0(10, 58, 12);
695 }
696 break;
697 case 114:
698 return jjMoveStringLiteralDfa11_0(active0, 0x100000000000L, active1, 0L);
699 case 115:
700 return jjMoveStringLiteralDfa11_0(active0, 0x600000000000L, active1, 0x2L);
701 case 117:
702 return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L, active1, 0L);
703 default:
704 break;
705 }
706 return jjStartNfa_0(9, active0, active1);
707 }
708
709 private int jjMoveStringLiteralDfa11_0(final long old0, long active0, final long old1, long active1) {
710 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
711 return jjStartNfa_0(9, old0, old1);
712 }
713 try {
714 curChar = input_stream.readChar();
715 } catch (final java.io.IOException e) {
716 jjStopStringLiteralDfa_0(10, active0, active1);
717 return 11;
718 }
719 switch (curChar) {
720 case 45:
721 return jjMoveStringLiteralDfa12_0(active0, 0x100000000000L, active1, 0L);
722 case 58:
723 if ((active0 & 0x80000000000L) != 0L) {
724 return jjStopAtPos(11, 43);
725 }
726 break;
727 case 101:
728 return jjMoveStringLiteralDfa12_0(active0, 0x2000000000000000L, active1, 0x4000L);
729 case 102:
730 return jjMoveStringLiteralDfa12_0(active0, 0x4000000000000000L, active1, 0L);
731 case 105:
732 return jjMoveStringLiteralDfa12_0(active0, 0x600400000000L, active1, 0L);
733 case 111:
734 return jjMoveStringLiteralDfa12_0(active0, 0x800000000000L, active1, 0L);
735 case 112:
736 return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x2L);
737 case 114:
738 return jjMoveStringLiteralDfa12_0(active0, 0x40000000000000L, active1, 0L);
739 case 116:
740 return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x1L);
741 default:
742 break;
743 }
744 return jjStartNfa_0(10, active0, active1);
745 }
746
747 private int jjMoveStringLiteralDfa12_0(final long old0, long active0, final long old1, long active1) {
748 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
749 return jjStartNfa_0(10, old0, old1);
750 }
751 try {
752 curChar = input_stream.readChar();
753 } catch (final java.io.IOException e) {
754 jjStopStringLiteralDfa_0(11, active0, active1);
755 return 12;
756 }
757 switch (curChar) {
758 case 97:
759 return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x2L);
760 case 98:
761 return jjMoveStringLiteralDfa13_0(active0, 0x600000000000L, active1, 0L);
762 case 102:
763 return jjMoveStringLiteralDfa13_0(active0, 0x2000000000000000L, active1, 0L);
764 case 104:
765 if ((active1 & 0x1L) != 0L) {
766 return jjStartNfaWithStates_0(12, 64, 12);
767 }
768 break;
769 case 105:
770 if ((active0 & 0x40000000000000L) != 0L) {
771 return jjStartNfaWithStates_0(12, 54, 12);
772 }
773 break;
774 case 110:
775 return jjMoveStringLiteralDfa13_0(active0, 0x400000000L, active1, 0L);
776 case 114:
777 if ((active1 & 0x4000L) != 0L) {
778 return jjStartNfaWithStates_0(12, 78, 12);
779 }
780 return jjMoveStringLiteralDfa13_0(active0, 0x800000000000L, active1, 0L);
781 case 115:
782 return jjMoveStringLiteralDfa13_0(active0, 0x100000000000L, active1, 0L);
783 case 116:
784 return jjMoveStringLiteralDfa13_0(active0, 0x4000000000000000L, active1, 0L);
785 default:
786 break;
787 }
788 return jjStartNfa_0(11, active0, active1);
789 }
790
791 private int jjMoveStringLiteralDfa13_0(final long old0, long active0, final long old1, long active1) {
792 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
793 return jjStartNfa_0(11, old0, old1);
794 }
795 try {
796 curChar = input_stream.readChar();
797 } catch (final java.io.IOException e) {
798 jjStopStringLiteralDfa_0(12, active0, active1);
799 return 13;
800 }
801 switch (curChar) {
802 case 45:
803 return jjMoveStringLiteralDfa14_0(active0, 0x800000000000L, active1, 0L);
804 case 99:
805 return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x2L);
806 case 101:
807 return jjMoveStringLiteralDfa14_0(active0, 0x4000100000000000L, active1, 0L);
808 case 108:
809 return jjMoveStringLiteralDfa14_0(active0, 0x600000000000L, active1, 0L);
810 case 111:
811 return jjMoveStringLiteralDfa14_0(active0, 0x2000000000000000L, active1, 0L);
812 case 115:
813 return jjMoveStringLiteralDfa14_0(active0, 0x400000000L, active1, 0L);
814 default:
815 break;
816 }
817 return jjStartNfa_0(12, active0, active1);
818 }
819
820 private int jjMoveStringLiteralDfa14_0(final long old0, long active0, final long old1, long active1) {
821 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
822 return jjStartNfa_0(12, old0, old1);
823 }
824 try {
825 curChar = input_stream.readChar();
826 } catch (final java.io.IOException e) {
827 jjStopStringLiteralDfa_0(13, active0, active1);
828 return 14;
829 }
830 switch (curChar) {
831 case 101:
832 if ((active1 & 0x2L) != 0L) {
833 return jjStartNfaWithStates_0(14, 65, 12);
834 }
835 break;
836 case 105:
837 return jjMoveStringLiteralDfa15_0(active0, 0x600000000000L, active1, 0L);
838 case 108:
839 return jjMoveStringLiteralDfa15_0(active0, 0x100000000000L, active1, 0L);
840 case 114:
841 if ((active0 & 0x4000000000000000L) != 0L) {
842 return jjStartNfaWithStates_0(14, 62, 12);
843 }
844 return jjMoveStringLiteralDfa15_0(active0, 0x2000000000000000L, active1, 0L);
845 case 115:
846 return jjMoveStringLiteralDfa15_0(active0, 0x800000000000L, active1, 0L);
847 case 116:
848 return jjMoveStringLiteralDfa15_0(active0, 0x400000000L, active1, 0L);
849 default:
850 break;
851 }
852 return jjStartNfa_0(13, active0, active1);
853 }
854
855 private int jjMoveStringLiteralDfa15_0(final long old0, long active0, final long old1, long active1) {
856 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
857 return jjStartNfa_0(13, old0, old1);
858 }
859 try {
860 curChar = input_stream.readChar();
861 } catch (final java.io.IOException e) {
862 jjStopStringLiteralDfa_0(14, active0, 0L);
863 return 15;
864 }
865 switch (curChar) {
866 case 101:
867 if ((active0 & 0x2000000000000000L) != 0L) {
868 return jjStartNfaWithStates_0(15, 61, 12);
869 }
870 return jjMoveStringLiteralDfa16_0(active0, 0x800000000000L);
871 case 102:
872 return jjMoveStringLiteralDfa16_0(active0, 0x100000000000L);
873 case 110:
874 return jjMoveStringLiteralDfa16_0(active0, 0x600000000000L);
875 case 114:
876 return jjMoveStringLiteralDfa16_0(active0, 0x400000000L);
877 default:
878 break;
879 }
880 return jjStartNfa_0(14, active0, 0L);
881 }
882
883 private int jjMoveStringLiteralDfa16_0(final long old0, long active0) {
884 if ((active0 &= old0) == 0L) {
885 return jjStartNfa_0(14, old0, 0L);
886 }
887 try {
888 curChar = input_stream.readChar();
889 } catch (final java.io.IOException e) {
890 jjStopStringLiteralDfa_0(15, active0, 0L);
891 return 16;
892 }
893 switch (curChar) {
894 case 58:
895 return jjMoveStringLiteralDfa17_0(active0, 0x100000000000L);
896 case 103:
897 return jjMoveStringLiteralDfa17_0(active0, 0x600000000000L);
898 case 108:
899 return jjMoveStringLiteralDfa17_0(active0, 0x800000000000L);
900 case 117:
901 return jjMoveStringLiteralDfa17_0(active0, 0x400000000L);
902 default:
903 break;
904 }
905 return jjStartNfa_0(15, active0, 0L);
906 }
907
908 private int jjMoveStringLiteralDfa17_0(final long old0, long active0) {
909 if ((active0 &= old0) == 0L) {
910 return jjStartNfa_0(15, old0, 0L);
911 }
912 try {
913 curChar = input_stream.readChar();
914 } catch (final java.io.IOException e) {
915 jjStopStringLiteralDfa_0(16, active0, 0L);
916 return 17;
917 }
918 switch (curChar) {
919 case 58:
920 if ((active0 & 0x100000000000L) != 0L) {
921 return jjStopAtPos(17, 44);
922 }
923 return jjMoveStringLiteralDfa18_0(active0, 0x600000000000L);
924 case 99:
925 return jjMoveStringLiteralDfa18_0(active0, 0x400000000L);
926 case 102:
927 return jjMoveStringLiteralDfa18_0(active0, 0x800000000000L);
928 default:
929 break;
930 }
931 return jjStartNfa_0(16, active0, 0L);
932 }
933
934 private int jjMoveStringLiteralDfa18_0(final long old0, long active0) {
935 if ((active0 &= old0) == 0L) {
936 return jjStartNfa_0(16, old0, 0L);
937 }
938 try {
939 curChar = input_stream.readChar();
940 } catch (final java.io.IOException e) {
941 jjStopStringLiteralDfa_0(17, active0, 0L);
942 return 18;
943 }
944 switch (curChar) {
945 case 58:
946 if ((active0 & 0x200000000000L) != 0L) {
947 return jjStopAtPos(18, 45);
948 } else if ((active0 & 0x400000000000L) != 0L) {
949 return jjStopAtPos(18, 46);
950 }
951 return jjMoveStringLiteralDfa19_0(active0, 0x800000000000L);
952 case 116:
953 return jjMoveStringLiteralDfa19_0(active0, 0x400000000L);
954 default:
955 break;
956 }
957 return jjStartNfa_0(17, active0, 0L);
958 }
959
960 private int jjMoveStringLiteralDfa19_0(final long old0, long active0) {
961 if ((active0 &= old0) == 0L) {
962 return jjStartNfa_0(17, old0, 0L);
963 }
964 try {
965 curChar = input_stream.readChar();
966 } catch (final java.io.IOException e) {
967 jjStopStringLiteralDfa_0(18, active0, 0L);
968 return 19;
969 }
970 switch (curChar) {
971 case 58:
972 if ((active0 & 0x800000000000L) != 0L) {
973 return jjStopAtPos(19, 47);
974 }
975 break;
976 case 105:
977 return jjMoveStringLiteralDfa20_0(active0, 0x400000000L);
978 default:
979 break;
980 }
981 return jjStartNfa_0(18, active0, 0L);
982 }
983
984 private int jjMoveStringLiteralDfa2_0(final long old0, long active0, final long old1, long active1) {
985 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
986 return jjStartNfa_0(0, old0, old1);
987 }
988 try {
989 curChar = input_stream.readChar();
990 } catch (final java.io.IOException e) {
991 jjStopStringLiteralDfa_0(1, active0, active1);
992 return 2;
993 }
994 switch (curChar) {
995 case 97:
996 return jjMoveStringLiteralDfa3_0(active0, 0x400000000000000L, active1, 0x4L);
997 case 98:
998 return jjMoveStringLiteralDfa3_0(active0, 0xe000000000000000L, active1, 0L);
999 case 99:
1000 return jjMoveStringLiteralDfa3_0(active0, 0x20104000000000L, active1, 0L);
1001 case 100:
1002 if ((active0 & 0x10000000L) != 0L) {
1003 return jjStartNfaWithStates_0(2, 28, 12);
1004 } else if ((active0 & 0x20000000L) != 0L) {
1005 return jjStartNfaWithStates_0(2, 29, 12);
1006 }
1007 return jjMoveStringLiteralDfa3_0(active0, 0x800000080000000L, active1, 0L);
1008 case 101:
1009 return jjMoveStringLiteralDfa3_0(active0, 0x420000000000L, active1, 0L);
1010 case 105:
1011 return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L, active1, 0x1000L);
1012 case 108:
1013 return jjMoveStringLiteralDfa3_0(active0, 0x240800000000L, active1, 0xc0L);
1014 case 109:
1015 if ((active1 & 0x400L) != 0L) {
1016 return jjStartNfaWithStates_0(2, 74, 12);
1017 }
1018 return jjMoveStringLiteralDfa3_0(active0, 0xc0010200000000L, active1, 0x200L);
1019 case 110:
1020 return jjMoveStringLiteralDfa3_0(active0, 0x1200000000000000L, active1, 0x100L);
1021 case 111:
1022 return jjMoveStringLiteralDfa3_0(active0, 0x400000000L, active1, 0x808L);
1023 case 114:
1024 return jjMoveStringLiteralDfa3_0(active0, 0x100002000000000L, active1, 0x4003L);
1025 case 115:
1026 return jjMoveStringLiteralDfa3_0(active0, 0x3880000000000L, active1, 0L);
1027 case 116:
1028 if ((active1 & 0x10L) != 0L) {
1029 return jjStartNfaWithStates_0(2, 68, 12);
1030 }
1031 return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L, active1, 0L);
1032 case 117:
1033 return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L, active1, 0x2020L);
1034 case 118:
1035 if ((active0 & 0x40000000L) != 0L) {
1036 return jjStartNfaWithStates_0(2, 30, 12);
1037 }
1038 break;
1039 case 120:
1040 return jjMoveStringLiteralDfa3_0(active0, 0x100000000L, active1, 0L);
1041 case 121:
1042 if ((active0 & 0x10000000000000L) != 0L) {
1043 return jjStartNfaWithStates_0(2, 52, 12);
1044 }
1045 break;
1046 default:
1047 break;
1048 }
1049 return jjStartNfa_0(1, active0, active1);
1050 }
1051
1052 private int jjMoveStringLiteralDfa20_0(final long old0, long active0) {
1053 if ((active0 &= old0) == 0L) {
1054 return jjStartNfa_0(18, old0, 0L);
1055 }
1056 try {
1057 curChar = input_stream.readChar();
1058 } catch (final java.io.IOException e) {
1059 jjStopStringLiteralDfa_0(19, active0, 0L);
1060 return 20;
1061 }
1062 switch (curChar) {
1063 case 111:
1064 return jjMoveStringLiteralDfa21_0(active0, 0x400000000L);
1065 default:
1066 break;
1067 }
1068 return jjStartNfa_0(19, active0, 0L);
1069 }
1070
1071 private int jjMoveStringLiteralDfa21_0(final long old0, long active0) {
1072 if ((active0 &= old0) == 0L) {
1073 return jjStartNfa_0(19, old0, 0L);
1074 }
1075 try {
1076 curChar = input_stream.readChar();
1077 } catch (final java.io.IOException e) {
1078 jjStopStringLiteralDfa_0(20, active0, 0L);
1079 return 21;
1080 }
1081 switch (curChar) {
1082 case 110:
1083 if ((active0 & 0x400000000L) != 0L) {
1084 return jjStartNfaWithStates_0(21, 34, 12);
1085 }
1086 break;
1087 default:
1088 break;
1089 }
1090 return jjStartNfa_0(20, active0, 0L);
1091 }
1092
1093 private int jjMoveStringLiteralDfa3_0(final long old0, long active0, final long old1, long active1) {
1094 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
1095 return jjStartNfa_0(1, old0, old1);
1096 }
1097 try {
1098 curChar = input_stream.readChar();
1099 } catch (final java.io.IOException e) {
1100 jjStopStringLiteralDfa_0(2, active0, active1);
1101 return 3;
1102 }
1103 switch (curChar) {
1104 case 97:
1105 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000000L, active1, 0L);
1106 case 98:
1107 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x200L);
1108 case 99:
1109 return jjMoveStringLiteralDfa4_0(active0, 0x200ca0400000000L, active1, 0L);
1110 case 101:
1111 if ((active0 & 0x80000000L) != 0L) {
1112 return jjStartNfaWithStates_0(3, 31, 12);
1113 } else if ((active0 & 0x80000000000000L) != 0L) {
1114 jjmatchedKind = 55;
1115 jjmatchedPos = 3;
1116 } else if ((active1 & 0x20L) != 0L) {
1117 return jjStartNfaWithStates_0(3, 69, 12);
1118 }
1119 return jjMoveStringLiteralDfa4_0(active0, 0x40116000000000L, active1, 0L);
1120 case 102:
1121 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L, active1, 0L);
1122 case 103:
1123 if ((active1 & 0x100L) != 0L) {
1124 return jjStartNfaWithStates_0(3, 72, 12);
1125 }
1126 break;
1127 case 105:
1128 return jjMoveStringLiteralDfa4_0(active0, 0x102000000000000L, active1, 0x1L);
1129 case 108:
1130 if ((active1 & 0x80L) != 0L) {
1131 return jjStartNfaWithStates_0(3, 71, 12);
1132 }
1133 return jjMoveStringLiteralDfa4_0(active0, 0x241000000000L, active1, 0x1008L);
1134 case 109:
1135 return jjMoveStringLiteralDfa4_0(active0, 0x200000000L, active1, 0x4002L);
1136 case 110:
1137 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0x2004L);
1138 case 111:
1139 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x800L);
1140 case 114:
1141 return jjMoveStringLiteralDfa4_0(active0, 0x400008000000000L, active1, 0L);
1142 case 115:
1143 return jjMoveStringLiteralDfa4_0(active0, 0xe800000000000000L, active1, 0x40L);
1144 case 116:
1145 if ((active0 & 0x100000000L) != 0L) {
1146 return jjStartNfaWithStates_0(3, 32, 12);
1147 } else if ((active0 & 0x1000000000000L) != 0L) {
1148 return jjStartNfaWithStates_0(3, 48, 12);
1149 }
1150 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000000L, active1, 0L);
1151 default:
1152 break;
1153 }
1154 return jjStartNfa_0(2, active0, active1);
1155 }
1156
1157 private int jjMoveStringLiteralDfa4_0(final long old0, long active0, final long old1, long active1) {
1158 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
1159 return jjStartNfa_0(2, old0, old1);
1160 }
1161 try {
1162 curChar = input_stream.readChar();
1163 } catch (final java.io.IOException e) {
1164 jjStopStringLiteralDfa_0(3, active0, active1);
1165 return 4;
1166 }
1167 switch (curChar) {
1168 case 45:
1169 return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L);
1170 case 58:
1171 return jjMoveStringLiteralDfa5_0(active0, 0x800000000L, active1, 0L);
1172 case 97:
1173 return jjMoveStringLiteralDfa5_0(active0, 0x1200000000000000L, active1, 0x4002L);
1174 case 100:
1175 if ((active1 & 0x2000L) != 0L) {
1176 return jjStartNfaWithStates_0(4, 77, 12);
1177 }
1178 return jjMoveStringLiteralDfa5_0(active0, 0x1000000000L, active1, 0L);
1179 case 101:
1180 if ((active1 & 0x40L) != 0L) {
1181 return jjStartNfaWithStates_0(4, 70, 12);
1182 }
1183 return jjMoveStringLiteralDfa5_0(active0, 0xca0600000000L, active1, 0x208L);
1184 case 105:
1185 return jjMoveStringLiteralDfa5_0(active0, 0x8000000000L, active1, 0x1000L);
1186 case 108:
1187 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L);
1188 case 110:
1189 return jjMoveStringLiteralDfa5_0(active0, 0x100002000000000L, active1, 0x1L);
1190 case 111:
1191 return jjMoveStringLiteralDfa5_0(active0, 0x240000000000L, active1, 0L);
1192 case 114:
1193 if ((active1 & 0x800L) != 0L) {
1194 return jjStartNfaWithStates_0(4, 75, 12);
1195 }
1196 break;
1197 case 115:
1198 return jjMoveStringLiteralDfa5_0(active0, 0x40114000000000L, active1, 0x4L);
1199 case 116:
1200 if ((active0 & 0x4000000000000L) != 0L) {
1201 return jjStartNfaWithStates_0(4, 50, 12);
1202 }
1203 return jjMoveStringLiteralDfa5_0(active0, 0xe402000000000000L, active1, 0L);
1204 default:
1205 break;
1206 }
1207 return jjStartNfa_0(3, active0, active1);
1208 }
1209
1210 private int jjMoveStringLiteralDfa5_0(final long old0, long active0, final long old1, long active1) {
1211 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
1212 return jjStartNfa_0(3, old0, old1);
1213 }
1214 try {
1215 curChar = input_stream.readChar();
1216 } catch (final java.io.IOException e) {
1217 jjStopStringLiteralDfa_0(4, active0, active1);
1218 return 5;
1219 }
1220 switch (curChar) {
1221 case 45:
1222 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L);
1223 case 58:
1224 if ((active0 & 0x800000000L) != 0L) {
1225 return jjStopAtPos(5, 35);
1226 }
1227 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L, active1, 0L);
1228 case 97:
1229 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x8L);
1230 case 98:
1231 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
1232 case 100:
1233 return jjMoveStringLiteralDfa6_0(active0, 0x420000000000L, active1, 0L);
1234 case 103:
1235 if ((active0 & 0x100000000000000L) != 0L) {
1236 jjmatchedKind = 56;
1237 jjmatchedPos = 5;
1238 }
1239 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x1L);
1240 case 105:
1241 return jjMoveStringLiteralDfa6_0(active0, 0x1002000000000000L, active1, 0L);
1242 case 108:
1243 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x6L);
1244 case 110:
1245 return jjMoveStringLiteralDfa6_0(active0, 0x880200000000L, active1, 0x1000L);
1246 case 112:
1247 return jjMoveStringLiteralDfa6_0(active0, 0x40010000000000L, active1, 0L);
1248 case 114:
1249 if ((active1 & 0x200L) != 0L) {
1250 return jjStartNfaWithStates_0(5, 73, 12);
1251 }
1252 return jjMoveStringLiteralDfa6_0(active0, 0xe000000000000000L, active1, 0L);
1253 case 115:
1254 return jjMoveStringLiteralDfa6_0(active0, 0x400000400000000L, active1, 0L);
1255 case 116:
1256 if ((active0 & 0x200000000000000L) != 0L) {
1257 return jjStartNfaWithStates_0(5, 57, 12);
1258 }
1259 return jjMoveStringLiteralDfa6_0(active0, 0x106000000000L, active1, 0x4000L);
1260 case 119:
1261 return jjMoveStringLiteralDfa6_0(active0, 0x800240000000000L, active1, 0L);
1262 default:
1263 break;
1264 }
1265 return jjStartNfa_0(4, active0, active1);
1266 }
1267
1268 private int jjMoveStringLiteralDfa6_0(final long old0, long active0, final long old1, long active1) {
1269 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
1270 return jjStartNfa_0(4, old0, old1);
1271 }
1272 try {
1273 curChar = input_stream.readChar();
1274 } catch (final java.io.IOException e) {
1275 jjStopStringLiteralDfa_0(5, active0, active1);
1276 return 6;
1277 }
1278 switch (curChar) {
1279 case 45:
1280 return jjMoveStringLiteralDfa7_0(active0, 0x400000000000000L, active1, 0x4001L);
1281 case 58:
1282 if ((active0 & 0x1000000000L) != 0L) {
1283 return jjStopAtPos(6, 36);
1284 }
1285 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000L, active1, 0L);
1286 case 97:
1287 return jjMoveStringLiteralDfa7_0(active0, 0x40010000000000L, active1, 0x4L);
1288 case 100:
1289 return jjMoveStringLiteralDfa7_0(active0, 0x880000000000L, active1, 0L);
1290 case 103:
1291 if ((active1 & 0x1000L) != 0L) {
1292 return jjStartNfaWithStates_0(6, 76, 12);
1293 }
1294 break;
1295 case 105:
1296 return jjMoveStringLiteralDfa7_0(active0, 0xe800660000000000L, active1, 0x2L);
1297 case 110:
1298 if ((active1 & 0x8L) != 0L) {
1299 return jjStartNfaWithStates_0(6, 67, 12);
1300 }
1301 return jjMoveStringLiteralDfa7_0(active0, 0x1020000000000000L, active1, 0L);
1302 case 111:
1303 return jjMoveStringLiteralDfa7_0(active0, 0x2104000000000L, active1, 0L);
1304 case 115:
1305 return jjMoveStringLiteralDfa7_0(active0, 0x400000000L, active1, 0L);
1306 case 116:
1307 if ((active0 & 0x200000000L) != 0L) {
1308 return jjStartNfaWithStates_0(6, 33, 12);
1309 }
1310 break;
1311 case 117:
1312 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0L);
1313 default:
1314 break;
1315 }
1316 return jjStartNfa_0(5, active0, active1);
1317 }
1318
1319 private int jjMoveStringLiteralDfa7_0(final long old0, long active0, final long old1, long active1) {
1320 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
1321 return jjStartNfa_0(5, old0, old1);
1322 }
1323 try {
1324 curChar = input_stream.readChar();
1325 } catch (final java.io.IOException e) {
1326 jjStopStringLiteralDfa_0(6, active0, active1);
1327 return 7;
1328 }
1329 switch (curChar) {
1330 case 58:
1331 if ((active0 & 0x2000000000L) != 0L) {
1332 return jjStopAtPos(7, 37);
1333 }
1334 break;
1335 case 97:
1336 return jjMoveStringLiteralDfa8_0(active0, 0x20880000000000L, active1, 0L);
1337 case 99:
1338 return jjMoveStringLiteralDfa8_0(active0, 0x40010000000000L, active1, 0L);
1339 case 105:
1340 return jjMoveStringLiteralDfa8_0(active0, 0x400000000L, active1, 0L);
1341 case 108:
1342 return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x1L);
1343 case 110:
1344 if ((active0 & 0x2000000000000L) != 0L) {
1345 return jjStartNfaWithStates_0(7, 49, 12);
1346 }
1347 return jjMoveStringLiteralDfa8_0(active0, 0xe000660000000000L, active1, 0x4000L);
1348 case 114:
1349 return jjMoveStringLiteralDfa8_0(active0, 0x104000000000L, active1, 0L);
1350 case 115:
1351 if ((active0 & 0x1000000000000000L) != 0L) {
1352 return jjStartNfaWithStates_0(7, 60, 12);
1353 }
1354 break;
1355 case 116:
1356 return jjMoveStringLiteralDfa8_0(active0, 0x800008000000000L, active1, 0x4L);
1357 case 119:
1358 return jjMoveStringLiteralDfa8_0(active0, 0x400000000000000L, active1, 0L);
1359 case 122:
1360 return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x2L);
1361 default:
1362 break;
1363 }
1364 return jjStartNfa_0(6, active0, active1);
1365 }
1366
1367 private int jjMoveStringLiteralDfa8_0(final long old0, long active0, final long old1, long active1) {
1368 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
1369 return jjStartNfa_0(6, old0, old1);
1370 }
1371 try {
1372 curChar = input_stream.readChar();
1373 } catch (final java.io.IOException e) {
1374 jjStopStringLiteralDfa_0(7, active0, active1);
1375 return 8;
1376 }
1377 switch (curChar) {
1378 case 45:
1379 return jjMoveStringLiteralDfa9_0(active0, 0x100000000000L, active1, 0L);
1380 case 58:
1381 return jjMoveStringLiteralDfa9_0(active0, 0x4000000000L, active1, 0L);
1382 case 101:
1383 if ((active1 & 0x4L) != 0L) {
1384 return jjStartNfaWithStates_0(8, 66, 12);
1385 }
1386 return jjMoveStringLiteralDfa9_0(active0, 0x40018000000000L, active1, 0x3L);
1387 case 103:
1388 if ((active0 & 0x8000000000000000L) != 0L) {
1389 jjmatchedKind = 63;
1390 jjmatchedPos = 8;
1391 }
1392 return jjMoveStringLiteralDfa9_0(active0, 0x6000660000000000L, active1, 0L);
1393 case 104:
1394 if ((active0 & 0x800000000000000L) != 0L) {
1395 return jjStartNfaWithStates_0(8, 59, 12);
1396 }
1397 break;
1398 case 105:
1399 return jjMoveStringLiteralDfa9_0(active0, 0x400000000000000L, active1, 0L);
1400 case 109:
1401 return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L, active1, 0L);
1402 case 110:
1403 return jjMoveStringLiteralDfa9_0(active0, 0x880400000000L, active1, 0L);
1404 case 117:
1405 return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x4000L);
1406 default:
1407 break;
1408 }
1409 return jjStartNfa_0(7, active0, active1);
1410 }
1411
1412 private int jjMoveStringLiteralDfa9_0(final long old0, long active0, final long old1, long active1) {
1413 if (((active0 &= old0) | (active1 &= old1)) == 0L) {
1414 return jjStartNfa_0(7, old0, old1);
1415 }
1416 try {
1417 curChar = input_stream.readChar();
1418 } catch (final java.io.IOException e) {
1419 jjStopStringLiteralDfa_0(8, active0, active1);
1420 return 9;
1421 }
1422 switch (curChar) {
1423 case 45:
1424 return jjMoveStringLiteralDfa10_0(active0, 0x6040600000000000L, active1, 0x2L);
1425 case 58:
1426 if ((active0 & 0x4000000000L) != 0L) {
1427 return jjStopAtPos(9, 38);
1428 }
1429 return jjMoveStringLiteralDfa10_0(active0, 0x78000000000L, active1, 0L);
1430 case 101:
1431 if ((active0 & 0x20000000000000L) != 0L) {
1432 return jjStartNfaWithStates_0(9, 53, 12);
1433 }
1434 break;
1435 case 103:
1436 return jjMoveStringLiteralDfa10_0(active0, 0x400000000L, active1, 0L);
1437 case 109:
1438 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x4000L);
1439 case 110:
1440 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x1L);
1441 case 111:
1442 return jjMoveStringLiteralDfa10_0(active0, 0x100000000000L, active1, 0L);
1443 case 116:
1444 return jjMoveStringLiteralDfa10_0(active0, 0x400880000000000L, active1, 0L);
1445 default:
1446 break;
1447 }
1448 return jjStartNfa_0(8, active0, active1);
1449 }
1450
1451 private int jjStartNfa_0(final int pos, final long active0, final long active1) {
1452 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
1453 }
1454
1455 private int jjStartNfaWithStates_0(final int pos, final int kind, final int state) {
1456 jjmatchedKind = kind;
1457 jjmatchedPos = pos;
1458 try {
1459 curChar = input_stream.readChar();
1460 } catch (final java.io.IOException e) {
1461 return pos + 1;
1462 }
1463 return jjMoveNfa_0(state, pos + 1);
1464 }
1465
1466 private int jjStopAtPos(final int pos, final int kind) {
1467 jjmatchedKind = kind;
1468 jjmatchedPos = pos;
1469 return pos + 1;
1470 }
1471
1472 private int jjStopStringLiteralDfa_0(final int pos, final long active0, final long active1) {
1473 switch (pos) {
1474 case 0:
1475 if ((active1 & 0x180000L) != 0L) {
1476 return 10;
1477 }
1478 if ((active0 & 0xfffffffff8000000L) != 0L || (active1 & 0x7fffL) != 0L) {
1479 jjmatchedKind = 79;
1480 return 12;
1481 }
1482 return -1;
1483 case 1:
1484 if ((active0 & 0xfff7fffff0000000L) != 0L || (active1 & 0x7fffL) != 0L) {
1485 jjmatchedKind = 79;
1486 jjmatchedPos = 1;
1487 return 12;
1488 }
1489 if ((active0 & 0x8000008000000L) != 0L) {
1490 return 12;
1491 }
1492 return -1;
1493 case 2:
1494 if ((active0 & 0x10000070000000L) != 0L || (active1 & 0x410L) != 0L) {
1495 return 12;
1496 }
1497 if ((active0 & 0xffe7ffff80000000L) != 0L || (active1 & 0x7befL) != 0L) {
1498 jjmatchedKind = 79;
1499 jjmatchedPos = 2;
1500 return 12;
1501 }
1502 return -1;
1503 case 3:
1504 if ((active0 & 0xc1010180000000L) != 0L || (active1 & 0x1a0L) != 0L) {
1505 return 12;
1506 }
1507 if ((active0 & 0xff26fefe00000000L) != 0L || (active1 & 0x7a4fL) != 0L) {
1508 if (jjmatchedPos != 3) {
1509 jjmatchedKind = 79;
1510 jjmatchedPos = 3;
1511 }
1512 return 12;
1513 }
1514 return -1;
1515 case 4:
1516 if ((active0 & 0xff62fff600000000L) != 0L || (active1 & 0x520fL) != 0L) {
1517 jjmatchedKind = 79;
1518 jjmatchedPos = 4;
1519 return 12;
1520 }
1521 if ((active0 & 0x4000000000000L) != 0L || (active1 & 0x2840L) != 0L) {
1522 return 12;
1523 }
1524 if ((active0 & 0x800000000L) != 0L) {
1525 if (jjmatchedPos < 3) {
1526 jjmatchedKind = 79;
1527 jjmatchedPos = 3;
1528 }
1529 return -1;
1530 }
1531 return -1;
1532 case 5:
1533 if ((active0 & 0x300000000000000L) != 0L || (active1 & 0x201L) != 0L) {
1534 return 12;
1535 }
1536 if ((active0 & 0xfc62ffe600000000L) != 0L || (active1 & 0x500eL) != 0L) {
1537 if (jjmatchedPos != 5) {
1538 jjmatchedKind = 79;
1539 jjmatchedPos = 5;
1540 }
1541 return 12;
1542 }
1543 if ((active0 & 0x1000000000L) != 0L) {
1544 if (jjmatchedPos < 4) {
1545 jjmatchedKind = 79;
1546 jjmatchedPos = 4;
1547 }
1548 return -1;
1549 }
1550 if ((active0 & 0x800000000L) != 0L) {
1551 if (jjmatchedPos < 3) {
1552 jjmatchedKind = 79;
1553 jjmatchedPos = 3;
1554 }
1555 return -1;
1556 }
1557 return -1;
1558 case 6:
1559 if ((active0 & 0x200000000L) != 0L || (active1 & 0x1008L) != 0L) {
1560 return 12;
1561 }
1562 if ((active0 & 0xfc62ffc400000000L) != 0L || (active1 & 0x4007L) != 0L) {
1563 jjmatchedKind = 79;
1564 jjmatchedPos = 6;
1565 return 12;
1566 }
1567 if ((active0 & 0x2000000000L) != 0L) {
1568 if (jjmatchedPos < 5) {
1569 jjmatchedKind = 79;
1570 jjmatchedPos = 5;
1571 }
1572 return -1;
1573 }
1574 if ((active0 & 0x1000000000L) != 0L) {
1575 if (jjmatchedPos < 4) {
1576 jjmatchedKind = 79;
1577 jjmatchedPos = 4;
1578 }
1579 return -1;
1580 }
1581 return -1;
1582 case 7:
1583 if ((active0 & 0x1002000000000000L) != 0L) {
1584 return 12;
1585 }
1586 if ((active0 & 0x2000000000L) != 0L) {
1587 if (jjmatchedPos < 5) {
1588 jjmatchedKind = 79;
1589 jjmatchedPos = 5;
1590 }
1591 return -1;
1592 }
1593 if ((active0 & 0xec60ffc400000000L) != 0L || (active1 & 0x4007L) != 0L) {
1594 jjmatchedKind = 79;
1595 jjmatchedPos = 7;
1596 return 12;
1597 }
1598 return -1;
1599 case 8:
1600 if ((active0 & 0xe800000000000000L) != 0L || (active1 & 0x4L) != 0L) {
1601 return 12;
1602 }
1603 if ((active0 & 0x460ff8400000000L) != 0L || (active1 & 0x4003L) != 0L) {
1604 if (jjmatchedPos != 8) {
1605 jjmatchedKind = 79;
1606 jjmatchedPos = 8;
1607 }
1608 return 12;
1609 }
1610 if ((active0 & 0x4000000000L) != 0L) {
1611 if (jjmatchedPos < 7) {
1612 jjmatchedKind = 79;
1613 jjmatchedPos = 7;
1614 }
1615 return -1;
1616 }
1617 return -1;
1618 case 9:
1619 if ((active0 & 0x20000000000000L) != 0L) {
1620 return 12;
1621 }
1622 if ((active0 & 0x78000000000L) != 0L) {
1623 if (jjmatchedPos < 8) {
1624 jjmatchedKind = 79;
1625 jjmatchedPos = 8;
1626 }
1627 return -1;
1628 }
1629 if ((active0 & 0x4000000000L) != 0L) {
1630 if (jjmatchedPos < 7) {
1631 jjmatchedKind = 79;
1632 jjmatchedPos = 7;
1633 }
1634 return -1;
1635 }
1636 if ((active0 & 0x6440f80400000000L) != 0L || (active1 & 0x4003L) != 0L) {
1637 jjmatchedKind = 79;
1638 jjmatchedPos = 9;
1639 return 12;
1640 }
1641 return -1;
1642 case 10:
1643 if ((active0 & 0x400000000000000L) != 0L) {
1644 return 12;
1645 }
1646 if ((active0 & 0x6040f00400000000L) != 0L || (active1 & 0x4003L) != 0L) {
1647 jjmatchedKind = 79;
1648 jjmatchedPos = 10;
1649 return 12;
1650 }
1651 if ((active0 & 0x80000000000L) != 0L) {
1652 if (jjmatchedPos < 9) {
1653 jjmatchedKind = 79;
1654 jjmatchedPos = 9;
1655 }
1656 return -1;
1657 }
1658 if ((active0 & 0x78000000000L) != 0L) {
1659 if (jjmatchedPos < 8) {
1660 jjmatchedKind = 79;
1661 jjmatchedPos = 8;
1662 }
1663 return -1;
1664 }
1665 return -1;
1666 case 11:
1667 if ((active0 & 0x80000000000L) != 0L) {
1668 if (jjmatchedPos < 9) {
1669 jjmatchedKind = 79;
1670 jjmatchedPos = 9;
1671 }
1672 return -1;
1673 }
1674 if ((active0 & 0x6040f00400000000L) != 0L || (active1 & 0x4003L) != 0L) {
1675 jjmatchedKind = 79;
1676 jjmatchedPos = 11;
1677 return 12;
1678 }
1679 return -1;
1680 case 12:
1681 if ((active0 & 0x6000f00400000000L) != 0L || (active1 & 0x2L) != 0L) {
1682 jjmatchedKind = 79;
1683 jjmatchedPos = 12;
1684 return 12;
1685 }
1686 if ((active0 & 0x40000000000000L) != 0L || (active1 & 0x4001L) != 0L) {
1687 return 12;
1688 }
1689 return -1;
1690 case 13:
1691 if ((active0 & 0x6000f00400000000L) != 0L || (active1 & 0x2L) != 0L) {
1692 jjmatchedKind = 79;
1693 jjmatchedPos = 13;
1694 return 12;
1695 }
1696 return -1;
1697 case 14:
1698 if ((active0 & 0x4000000000000000L) != 0L || (active1 & 0x2L) != 0L) {
1699 return 12;
1700 }
1701 if ((active0 & 0x2000f00400000000L) != 0L) {
1702 jjmatchedKind = 79;
1703 jjmatchedPos = 14;
1704 return 12;
1705 }
1706 return -1;
1707 case 15:
1708 if ((active0 & 0x2000000000000000L) != 0L) {
1709 return 12;
1710 }
1711 if ((active0 & 0xf00400000000L) != 0L) {
1712 jjmatchedKind = 79;
1713 jjmatchedPos = 15;
1714 return 12;
1715 }
1716 return -1;
1717 case 16:
1718 if ((active0 & 0xe00400000000L) != 0L) {
1719 jjmatchedKind = 79;
1720 jjmatchedPos = 16;
1721 return 12;
1722 }
1723 if ((active0 & 0x100000000000L) != 0L) {
1724 if (jjmatchedPos < 15) {
1725 jjmatchedKind = 79;
1726 jjmatchedPos = 15;
1727 }
1728 return -1;
1729 }
1730 return -1;
1731 case 17:
1732 if ((active0 & 0x600000000000L) != 0L) {
1733 if (jjmatchedPos < 16) {
1734 jjmatchedKind = 79;
1735 jjmatchedPos = 16;
1736 }
1737 return -1;
1738 }
1739 if ((active0 & 0x100000000000L) != 0L) {
1740 if (jjmatchedPos < 15) {
1741 jjmatchedKind = 79;
1742 jjmatchedPos = 15;
1743 }
1744 return -1;
1745 }
1746 if ((active0 & 0x800400000000L) != 0L) {
1747 jjmatchedKind = 79;
1748 jjmatchedPos = 17;
1749 return 12;
1750 }
1751 return -1;
1752 case 18:
1753 if ((active0 & 0x800000000000L) != 0L) {
1754 if (jjmatchedPos < 17) {
1755 jjmatchedKind = 79;
1756 jjmatchedPos = 17;
1757 }
1758 return -1;
1759 }
1760 if ((active0 & 0x600000000000L) != 0L) {
1761 if (jjmatchedPos < 16) {
1762 jjmatchedKind = 79;
1763 jjmatchedPos = 16;
1764 }
1765 return -1;
1766 }
1767 if ((active0 & 0x400000000L) != 0L) {
1768 jjmatchedKind = 79;
1769 jjmatchedPos = 18;
1770 return 12;
1771 }
1772 return -1;
1773 case 19:
1774 if ((active0 & 0x400000000L) != 0L) {
1775 jjmatchedKind = 79;
1776 jjmatchedPos = 19;
1777 return 12;
1778 }
1779 if ((active0 & 0x800000000000L) != 0L) {
1780 if (jjmatchedPos < 17) {
1781 jjmatchedKind = 79;
1782 jjmatchedPos = 17;
1783 }
1784 return -1;
1785 }
1786 return -1;
1787 case 20:
1788 if ((active0 & 0x400000000L) != 0L) {
1789 jjmatchedKind = 79;
1790 jjmatchedPos = 20;
1791 return 12;
1792 }
1793 return -1;
1794 default:
1795 return -1;
1796 }
1797 }
1798
1799 public void ReInit(final SimpleCharStream stream) {
1800 jjmatchedPos = jjnewStateCnt = 0;
1801 curLexState = defaultLexState;
1802 input_stream = stream;
1803 ReInitRounds();
1804 }
1805
1806 public void ReInit(final SimpleCharStream stream, final int lexState) {
1807 ReInit(stream);
1808 SwitchTo(lexState);
1809 }
1810
1811 private void ReInitRounds() {
1812 int i;
1813 jjround = 0x80000001;
1814 for (i = 13; i-- > 0;) {
1815 jjrounds[i] = 0x80000000;
1816 }
1817 }
1818
1819 public void setDebugStream(final java.io.PrintStream ds) {
1820 debugStream = ds;
1821 }
1822
1823 public void SwitchTo(final int lexState) {
1824 if (lexState >= 1 || lexState < 0) {
1825 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1826 }
1827 curLexState = lexState;
1828 }
1829 }