KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > xml > text > syntax > javacc > XMLSyntaxTokenManager


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19 package org.netbeans.modules.xml.text.syntax.javacc;
20 import java.io.*;
21 import org.netbeans.modules.xml.text.syntax.javacc.lib.*;
22
23 public class XMLSyntaxTokenManager implements XMLSyntaxConstants {
24
25     //!!! enter proper bridge
26
public final class Bridge extends XMLSyntaxTokenManager implements JJSyntaxInterface, JJConstants {
27         public Bridge() {
28             super(null);
29         }
30     }
31
32     //~~~~~~~~~~~~~~~~~~~~~ TEXT BASED SHARING START ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
33

34     private transient String JavaDoc myimage = ""; //contais image of last scanned [partial] token // NOI18N
35
private transient String JavaDoc lastImage = ""; // NOI18N
36
private transient int id;
37     
38     private int lastValidState; //contains last correct state
39
//state may become incorect if EOB is returned
40
//due to buffer end e.g.
41
//(a) <! moves to IN_DECL
42
//(b) <!-- moves to IN_COMMENT
43
//if (a) is followed by EOB that
44
//token manager enters illegal state
45

46     /** Return current state of lexan.
47      * There will be probably necessary simple ID mappe among
48      * Syntax's state IDs with reserved INIT(-1) and JavaCC DEFAULT(variable often the highest one).
49      */

50     public final int getState() {
51         return curLexState;
52     }
53
54     /** Return length of last recognized token. ?? SKIP*/
55     public final int getLength() {
56         return myimage.length();
57     }
58
59     /** Return last token. */
60     public final String JavaDoc getImage() {
61         return myimage.toString();
62     }
63
64     /** Set state info to folowing one. */
65     public final void setStateInfo(int[] state) {
66         int[] newstate = new int[state.length];
67         System.arraycopy(state, 0, newstate, 0, state.length);
68         states = newstate;
69         // dumpStack("L"); // NOI18N
70
lastValidState = popState(); //restore lastValidState
71
}
72
73     /** return copy of current state. */
74     public final int[] getStateInfo() {
75         pushState(lastValidState); // store lastValidState !modifies states stack
76
int[] state = new int[states.length];
77         System.arraycopy(states, 0, state, 0, states.length);
78         // dumpStack("S"); // NOI18N
79
popState(); // !restore the states stack
80
return state;
81     }
82
83
84     private void dumpStack(String JavaDoc label) {
85         StringBuffer JavaDoc s = new StringBuffer JavaDoc();
86         s.append(label + " "); // NOI18N
87
for (int i = 0; i<states.length; i++) {
88             s.append(states[i] + ", "); // NOI18N
89
}
90         System.err.println(s.toString());
91     }
92
93     /** Set input stream to folowing one
94      * and reset initial state.
95      */

96     public final void init(CharStream input) {
97         ReInit((UCode_CharStream)input);
98         lastValidState = getState();
99     }
100
101     /** Set input stream to folowing one
102      * and set current state.
103      */

104     public final void init(CharStream in, int state) {
105         ReInit((UCode_CharStream)in, state);
106         lastValidState = getState();
107     }
108
109     /** Syntax would want restore state on buffer boundaries. */
110     public final void setState(int state) {
111         lastValidState = state;
112         SwitchTo(state == -1 ? defaultLexState : state); //fix deleting at document start
113
}
114
115     //
116
// push analyzer state to states stack
117
//
118
private void pushState(int state) {
119         if (states == null) {
120             states = new int[] {state};
121         } else {
122             int[] newstates = new int[states.length + 1];
123             System.arraycopy(states, 0, newstates, 0, states.length);
124             newstates[newstates.length - 1] = state;
125             states = newstates;
126         }
127     }
128
129     //
130
// pop analyzer state from states stack
131
//
132
private int popState() {
133         int state = states[states.length - 1];
134         if (states.length == 1) {
135             states = null;
136         } else {
137             int[] newstates = new int[states.length - 1];
138             System.arraycopy(states, 0, newstates, 0, states.length - 1);
139             states = newstates;
140         }
141         return state;
142     }
143
144     /** Prepare next token from stream. */
145     public final void next() {
146         try {
147             Token tok = getNextToken();
148             myimage = tok.image;
149             id = tok.kind;
150             if (id == EOF) { //??? EOF is visible just at Parser LEVEL
151
setState(lastValidState);
152                 id = Bridge.JJ_EOF;
153             }
154             lastValidState = getState();
155
156         } catch (TokenMgrError ex) {
157             try {
158                 //is the exception caused by EOF?
159
char ch = input_stream.readChar();
160                 input_stream.backup(1);
161
162                 myimage = input_stream.GetImage();
163                 if (Boolean.getBoolean("netbeans.debug.exceptions")) // NOI18N
164
System.err.println(getClass().toString() + " ERROR:" + getState() + ":'" + ch + "'"); // NOI18N
165
id = Bridge.JJ_ERR;
166
167             } catch (IOException eof) {
168
169                 myimage = input_stream.GetImage();
170                 id = Bridge.JJ_EOF;
171             }
172         }
173     }
174
175     /** Return ID of the last recognized token. */
176     public int getID() {
177         return id;
178     }
179
180     /** Return name of the last token. */
181     public final String JavaDoc getName() {
182         return tokenImage[id];
183     }
184
185     /** For testing purposes only. */
186     public static void main(String JavaDoc args[]) throws Exception JavaDoc {
187
188         InputStream in;
189         int dump = 0;
190         int dump2 = 1000;
191
192         System.err.println("Got " + args.length + " arguments."); // NOI18N
193

194         if (args.length != 0) {
195             in = new FileInputStream(args[0]);
196             if (args.length == 2) { //dump just requested line
197
dump = Integer.parseInt(args[1]) - 1;
198                 dump2 = dump;
199                 System.err.println("Line to be dumped:" + dump); // NOI18N
200
}
201         } else {
202             System.err.println("One argument required."); // NOI18N
203
return;
204         }
205
206         CharStream input = new ASCIICharStream(in, 0, 0);
207         Bridge lex = null; //new XMLSyntaxTokenManager(input);
208

209         int i = 25; //token count
210
int id;
211         int toks = 0;
212         long time = System.currentTimeMillis();
213
214         while (i/*--*/>0) {
215
216             lex.next();
217             id = lex.getID();
218
219             toks++;
220             switch (id) {
221             case Bridge.JJ_EOF:
222                 System.err.println("EOF at " + lex.getState() + " " + lex.getImage()); // NOI18N
223
System.err.println("Line: " + input.getLine() ); // NOI18N
224
System.err.println("Tokens: " + toks ); // NOI18N
225
System.err.println("Time: " + (System.currentTimeMillis() - time) ); // NOI18N
226
return;
227
228             default:
229                 if (dump <= input.getLine() && input.getLine() <= dump2)
230                     System.err.println(" " + id + "@" + lex.getState() + ":" + lex.getImage() ); // NOI18N
231
}
232
233         }
234
235     }
236
237     /**
238      * The analyzer may store information about state in this
239      * stack (array). These will be used as Syntax state info.
240      */

241     private int[] states = null;
242     private final int jjStopStringLiteralDfa_9(int pos, long active0, long active1)
243     {
244         switch (pos)
245             {
246             case 0:
247                 if ((active0 & 0x6000000000000000L) != 0L)
248                     {
249                         jjmatchedKind = 64;
250                         return 1;
251                     }
252                 return -1;
253             case 1:
254                 if ((active0 & 0x6000000000000000L) != 0L)
255                     {
256                         jjmatchedKind = 64;
257                         jjmatchedPos = 1;
258                         return 1;
259                     }
260                 return -1;
261             case 2:
262                 if ((active0 & 0x6000000000000000L) != 0L)
263                     {
264                         jjmatchedKind = 64;
265                         jjmatchedPos = 2;
266                         return 1;
267                     }
268                 return -1;
269             case 3:
270                 if ((active0 & 0x6000000000000000L) != 0L)
271                     {
272                         jjmatchedKind = 64;
273                         jjmatchedPos = 3;
274                         return 1;
275                     }
276                 return -1;
277             case 4:
278                 if ((active0 & 0x6000000000000000L) != 0L)
279                     {
280                         jjmatchedKind = 64;
281                         jjmatchedPos = 4;
282                         return 1;
283                     }
284                 return -1;
285             case 5:
286                 if ((active0 & 0x4000000000000000L) != 0L)
287                     return 1;
288                 if ((active0 & 0x2000000000000000L) != 0L)
289                     {
290                         jjmatchedKind = 64;
291                         jjmatchedPos = 5;
292                         return 1;
293                     }
294                 return -1;
295             default :
296                 return -1;
297             }
298     }
299     private final int jjStartNfa_9(int pos, long active0, long active1)
300     {
301         return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0, active1), pos + 1);
302     }
303     private final int jjStopAtPos(int pos, int kind)
304     {
305         jjmatchedKind = kind;
306         jjmatchedPos = pos;
307         return pos + 1;
308     }
309     private final int jjStartNfaWithStates_9(int pos, int kind, int state)
310     {
311         jjmatchedKind = kind;
312         jjmatchedPos = pos;
313         try { curChar = input_stream.readChar(); }
314         catch(java.io.IOException JavaDoc e) { return pos + 1; }
315         return jjMoveNfa_9(state, pos + 1);
316     }
317     private final int jjMoveStringLiteralDfa0_9()
318     {
319         switch(curChar)
320             {
321             case 37:
322                 return jjStopAtPos(0, 86);
323             case 73:
324                 return jjMoveStringLiteralDfa1_9(0x6000000000000000L);
325             case 91:
326                 return jjStopAtPos(0, 65);
327             default :
328                 return jjMoveNfa_9(3, 0);
329             }
330     }
331     private final int jjMoveStringLiteralDfa1_9(long active0)
332     {
333         try { curChar = input_stream.readChar(); }
334         catch(java.io.IOException JavaDoc e) {
335             jjStopStringLiteralDfa_9(0, active0, 0L);
336             return 1;
337         }
338         switch(curChar)
339             {
340             case 71:
341                 return jjMoveStringLiteralDfa2_9(active0, 0x4000000000000000L);
342             case 78:
343                 return jjMoveStringLiteralDfa2_9(active0, 0x2000000000000000L);
344             default :
345                 break;
346             }
347         return jjStartNfa_9(0, active0, 0L);
348     }
349     private final int jjMoveStringLiteralDfa2_9(long old0, long active0)
350     {
351         if (((active0 &= old0)) == 0L)
352             return jjStartNfa_9(0, old0, 0L);
353         try { curChar = input_stream.readChar(); }
354         catch(java.io.IOException JavaDoc e) {
355             jjStopStringLiteralDfa_9(1, active0, 0L);
356             return 2;
357         }
358         switch(curChar)
359             {
360             case 67:
361                 return jjMoveStringLiteralDfa3_9(active0, 0x2000000000000000L);
362             case 78:
363                 return jjMoveStringLiteralDfa3_9(active0, 0x4000000000000000L);
364             default :
365                 break;
366             }
367         return jjStartNfa_9(1, active0, 0L);
368     }
369     private final int jjMoveStringLiteralDfa3_9(long old0, long active0)
370     {
371         if (((active0 &= old0)) == 0L)
372             return jjStartNfa_9(1, old0, 0L);
373         try { curChar = input_stream.readChar(); }
374         catch(java.io.IOException JavaDoc e) {
375             jjStopStringLiteralDfa_9(2, active0, 0L);
376             return 3;
377         }
378         switch(curChar)
379             {
380             case 76:
381                 return jjMoveStringLiteralDfa4_9(active0, 0x2000000000000000L);
382             case 79:
383                 return jjMoveStringLiteralDfa4_9(active0, 0x4000000000000000L);
384             default :
385                 break;
386             }
387         return jjStartNfa_9(2, active0, 0L);
388     }
389     private final int jjMoveStringLiteralDfa4_9(long old0, long active0)
390     {
391         if (((active0 &= old0)) == 0L)
392             return jjStartNfa_9(2, old0, 0L);
393         try { curChar = input_stream.readChar(); }
394         catch(java.io.IOException JavaDoc e) {
395             jjStopStringLiteralDfa_9(3, active0, 0L);
396             return 4;
397         }
398         switch(curChar)
399             {
400             case 82:
401                 return jjMoveStringLiteralDfa5_9(active0, 0x4000000000000000L);
402             case 85:
403                 return jjMoveStringLiteralDfa5_9(active0, 0x2000000000000000L);
404             default :
405                 break;
406             }
407         return jjStartNfa_9(3, active0, 0L);
408     }
409     private final int jjMoveStringLiteralDfa5_9(long old0, long active0)
410     {
411         if (((active0 &= old0)) == 0L)
412             return jjStartNfa_9(3, old0, 0L);
413         try { curChar = input_stream.readChar(); }
414         catch(java.io.IOException JavaDoc e) {
415             jjStopStringLiteralDfa_9(4, active0, 0L);
416             return 5;
417         }
418         switch(curChar)
419             {
420             case 68:
421                 return jjMoveStringLiteralDfa6_9(active0, 0x2000000000000000L);
422             case 69:
423                 if ((active0 & 0x4000000000000000L) != 0L)
424                     return jjStartNfaWithStates_9(5, 62, 1);
425                 break;
426             default :
427                 break;
428             }
429         return jjStartNfa_9(4, active0, 0L);
430     }
431     private final int jjMoveStringLiteralDfa6_9(long old0, long active0)
432     {
433         if (((active0 &= old0)) == 0L)
434             return jjStartNfa_9(4, old0, 0L);
435         try { curChar = input_stream.readChar(); }
436         catch(java.io.IOException JavaDoc e) {
437             jjStopStringLiteralDfa_9(5, active0, 0L);
438             return 6;
439         }
440         switch(curChar)
441             {
442             case 69:
443                 if ((active0 & 0x2000000000000000L) != 0L)
444                     return jjStartNfaWithStates_9(6, 61, 1);
445                 break;
446             default :
447                 break;
448             }
449         return jjStartNfa_9(5, active0, 0L);
450     }
451     private final void jjCheckNAdd(int state)
452     {
453         if (jjrounds[state] != jjround)
454             {
455                 jjstateSet[jjnewStateCnt++] = state;
456                 jjrounds[state] = jjround;
457             }
458     }
459     private final void jjAddStates(int start, int end)
460     {
461         do {
462             jjstateSet[jjnewStateCnt++] = jjnextStates[start];
463         } while (start++ != end);
464     }
465     private final void jjCheckNAddTwoStates(int state1, int state2)
466     {
467         jjCheckNAdd(state1);
468         jjCheckNAdd(state2);
469     }
470     private final void jjCheckNAddStates(int start, int end)
471     {
472         do {
473             jjCheckNAdd(jjnextStates[start]);
474         } while (start++ != end);
475     }
476     private final void jjCheckNAddStates(int start)
477     {
478         jjCheckNAdd(jjnextStates[start]);
479         jjCheckNAdd(jjnextStates[start + 1]);
480     }
481     static final long[] jjbitVec0 = {
482         0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
483     };
484     static final long[] jjbitVec2 = {
485         0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
486     };
487     private final int jjMoveNfa_9(int startState, int curPos)
488     {
489         int[] nextStates;
490         int startsAt = 0;
491         jjnewStateCnt = 3;
492         int i = 1;
493         jjstateSet[0] = startState;
494         int j, kind = 0x7fffffff;
495         for (;;)
496             {
497                 if (++jjround == 0x7fffffff)
498                     ReInitRounds();
499                 if (curChar < 64)
500                     {
501                         long l = 1L << curChar;
502                     MatchLoop: do
503                         {
504                             switch(jjstateSet[--i])
505                                 {
506                                 case 3:
507                                     if ((0x7ff7f10fffff9ffL & l) != 0L)
508                                         {
509                                             if (kind > 64)
510                                                 kind = 64;
511                                             jjCheckNAdd(1);
512                                         }
513                                     else if ((0x580080c600000000L & l) != 0L)
514                                         {
515                                             if (kind > 64)
516                                                 kind = 64;
517                                             jjCheckNAdd(2);
518                                         }
519                                     if ((0x100002600L & l) != 0L)
520                                         {
521                                             if (kind > 63)
522                                                 kind = 63;
523                                             jjCheckNAdd(0);
524                                         }
525                                     break;
526                                 case 0:
527                                     if ((0x100002600L & l) == 0L)
528                                         break;
529                                     if (kind > 63)
530                                         kind = 63;
531                                     jjCheckNAdd(0);
532                                     break;
533                                 case 1:
534                                     if ((0x7ff7f10fffff9ffL & l) == 0L)
535                                         break;
536                                     if (kind > 64)
537                                         kind = 64;
538                                     jjCheckNAdd(1);
539                                     break;
540                                 case 2:
541                                     if ((0x580080c600000000L & l) == 0L)
542                                         break;
543                                     kind = 64;
544                                     jjCheckNAdd(2);
545                                     break;
546                                 default : break;
547                                 }
548                         } while(i != startsAt);
549                     }
550                 else if (curChar < 128)
551                     {
552                         long l = 1L << (curChar & 077);
553                     MatchLoop: do
554                         {
555                             switch(jjstateSet[--i])
556                                 {
557                                 case 3:
558                                     if ((0xffffffffd7ffffffL & l) != 0L)
559                                         {
560                                             if (kind > 64)
561                                                 kind = 64;
562                                             jjCheckNAdd(1);
563                                         }
564                                     else if (curChar == 93)
565                                         {
566                                             if (kind > 64)
567                                                 kind = 64;
568                                             jjCheckNAdd(2);
569                                         }
570                                     break;
571                                 case 1:
572                                     if ((0xffffffffd7ffffffL & l) == 0L)
573                                         break;
574                                     kind = 64;
575                                     jjCheckNAdd(1);
576                                     break;
577                                 case 2:
578                                     if (curChar != 93)
579                                         break;
580                                     kind = 64;
581                                     jjCheckNAdd(2);
582                                     break;
583                                 default : break;
584                                 }
585                         } while(i != startsAt);
586                     }
587                 else
588                     {
589                         int hiByte = (int)(curChar >> 8);
590                         int i1 = hiByte >> 6;
591                         long l1 = 1L << (hiByte & 077);
592                         int i2 = (curChar & 0xff) >> 6;
593                         long l2 = 1L << (curChar & 077);
594                     MatchLoop: do
595                         {
596                             switch(jjstateSet[--i])
597                                 {
598                                 case 3:
599                                 case 1:
600                                     if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
601                                         break;
602                                     if (kind > 64)
603                                         kind = 64;
604                                     jjCheckNAdd(1);
605                                     break;
606                                 default : break;
607                                 }
608                         } while(i != startsAt);
609                     }
610                 if (kind != 0x7fffffff)
611                     {
612                         jjmatchedKind = kind;
613                         jjmatchedPos = curPos;
614                         kind = 0x7fffffff;
615                     }
616                 ++curPos;
617                 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
618                     return curPos;
619                 try { curChar = input_stream.readChar(); }
620                 catch(java.io.IOException JavaDoc e) { return curPos; }
621             }
622     }
623     private final int jjMoveStringLiteralDfa0_19()
624     {
625         return jjMoveNfa_19(2, 0);
626     }
627     private final int jjMoveNfa_19(int startState, int curPos)
628     {
629         int[] nextStates;
630         int startsAt = 0;
631         jjnewStateCnt = 3;
632         int i = 1;
633         jjstateSet[0] = startState;
634         int j, kind = 0x7fffffff;
635         for (;;)
636             {
637                 if (++jjround == 0x7fffffff)
638                     ReInitRounds();
639                 if (curChar < 64)
640                     {
641                         long l = 1L << curChar;
642                     MatchLoop: do
643                         {
644                             switch(jjstateSet[--i])
645                                 {
646                                 case 2:
647                                     if ((0x7ff7f10fffff9ffL & l) != 0L)
648                                         {
649                                             if (kind > 15)
650                                                 kind = 15;
651                                             jjCheckNAdd(0);
652                                         }
653                                     else if ((0x780000e700000000L & l) != 0L)
654                                         {
655                                             if (kind > 16)
656                                                 kind = 16;
657                                             jjCheckNAdd(1);
658                                         }
659                                     else if (curChar == 47)
660                                         {
661                                             if (kind > 16)
662                                                 kind = 16;
663                                             jjCheckNAdd(0);
664                                         }
665                                     break;
666                                 case 0:
667                                     if ((0x7ff7f10fffff9ffL & l) == 0L)
668                                         break;
669                                     kind = 15;
670                                     jjCheckNAdd(0);
671                                     break;
672                                 case 1:
673                                     if ((0x780000e700000000L & l) == 0L)
674                                         break;
675                                     kind = 16;
676                                     jjCheckNAdd(1);
677                                     break;
678                                 default : break;
679                                 }
680                         } while(i != startsAt);
681                     }
682                 else if (curChar < 128)
683                     {
684                         long l = 1L << (curChar & 077);
685                     MatchLoop: do
686                         {
687                             switch(jjstateSet[--i])
688                                 {
689                                 case 2:
690                                     if ((0xffffffffd7ffffffL & l) != 0L)
691                                         {
692                                             if (kind > 15)
693                                                 kind = 15;
694                                             jjCheckNAdd(0);
695                                         }
696                                     else if ((0x28000000L & l) != 0L)
697                                         {
698                                             if (kind > 16)
699                                                 kind = 16;
700                                             jjCheckNAdd(1);
701                                         }
702                                     break;
703                                 case 0:
704                                     if ((0xffffffffd7ffffffL & l) == 0L)
705                                         break;
706                                     kind = 15;
707                                     jjCheckNAdd(0);
708                                     break;
709                                 case 1:
710                                     if ((0x28000000L & l) == 0L)
711                                         break;
712                                     kind = 16;
713                                     jjCheckNAdd(1);
714                                     break;
715                                 default : break;
716                                 }
717                         } while(i != startsAt);
718                     }
719                 else
720                     {
721                         int hiByte = (int)(curChar >> 8);
722                         int i1 = hiByte >> 6;
723                         long l1 = 1L << (hiByte & 077);
724                         int i2 = (curChar & 0xff) >> 6;
725                         long l2 = 1L << (curChar & 077);
726                     MatchLoop: do
727                         {
728                             switch(jjstateSet[--i])
729                                 {
730                                 case 2:
731                                 case 0:
732                                     if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
733                                         break;
734                                     if (kind > 15)
735                                         kind = 15;
736                                     jjCheckNAdd(0);
737                                     break;
738                                 default : break;
739                                 }
740                         } while(i != startsAt);
741                     }
742                 if (kind != 0x7fffffff)
743                     {
744                         jjmatchedKind = kind;
745                         jjmatchedPos = curPos;
746                         kind = 0x7fffffff;
747                     }
748                 ++curPos;
749                 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
750                     return curPos;
751                 try { curChar = input_stream.readChar(); }
752                 catch(java.io.IOException JavaDoc e) { return curPos; }
753             }
754     }
755     private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
756     {
757         switch (pos)
758             {
759             default :
760                 return -1;
761             }
762     }
763     private final int jjStartNfa_2(int pos, long active0, long active1)
764     {
765         return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
766     }
767     private final int jjStartNfaWithStates_2(int pos, int kind, int state)
768     {
769         jjmatchedKind = kind;
770         jjmatchedPos = pos;
771         try { curChar = input_stream.readChar(); }
772         catch(java.io.IOException JavaDoc e) { return pos + 1; }
773         return jjMoveNfa_2(state, pos + 1);
774     }
775     private final int jjMoveStringLiteralDfa0_2()
776     {
777         switch(curChar)
778             {
779             case 39:
780                 return jjStopAtPos(0, 95);
781             default :
782                 return jjMoveNfa_2(0, 0);
783             }
784     }
785     private final int jjMoveNfa_2(int startState, int curPos)
786     {
787         int[] nextStates;
788         int startsAt = 0;
789         jjnewStateCnt = 1;
790         int i = 1;
791         jjstateSet[0] = startState;
792         int j, kind = 0x7fffffff;
793         for (;;)
794             {
795                 if (++jjround == 0x7fffffff)
796                     ReInitRounds();
797                 if (curChar < 64)
798                     {
799                         long l = 1L << curChar;
800                     MatchLoop: do
801                         {
802                             switch(jjstateSet[--i])
803                                 {
804                                 case 0:
805                                     if ((0xffffff7fffffffffL & l) == 0L)
806                                         break;
807                                     kind = 94;
808                                     jjstateSet[jjnewStateCnt++] = 0;
809                                     break;
810                                 default : break;
811                                 }
812                         } while(i != startsAt);
813                     }
814                 else if (curChar < 128)
815                     {
816                         long l = 1L << (curChar & 077);
817                     MatchLoop: do
818                         {
819                             switch(jjstateSet[--i])
820                                 {
821                                 case 0:
822                                     kind = 94;
823                                     jjstateSet[jjnewStateCnt++] = 0;
824                                     break;
825                                 default : break;
826                                 }
827                         } while(i != startsAt);
828                     }
829                 else
830                     {
831                         int hiByte = (int)(curChar >> 8);
832                         int i1 = hiByte >> 6;
833                         long l1 = 1L << (hiByte & 077);
834                         int i2 = (curChar & 0xff) >> 6;
835                         long l2 = 1L << (curChar & 077);
836                     MatchLoop: do
837                         {
838                             switch(jjstateSet[--i])
839                                 {
840                                 case 0:
841                                     if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
842                                         break;
843                                     if (kind > 94)
844                                         kind = 94;
845                                     jjstateSet[jjnewStateCnt++] = 0;
846                                     break;
847                                 default : break;
848                                 }
849                         } while(i != startsAt);
850                     }
851                 if (kind != 0x7fffffff)
852                     {
853                         jjmatchedKind = kind;
854                         jjmatchedPos = curPos;
855                         kind = 0x7fffffff;
856                     }
857                 ++curPos;
858                 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
859                     return curPos;
860                 try { curChar = input_stream.readChar(); }
861                 catch(java.io.IOException JavaDoc e) { return curPos; }
862             }
863     }
864     private final int jjStopStringLiteralDfa_12(int pos, long active0, long active1)
865     {
866         switch (pos)
867             {
868             default :
869                 return -1;
870             }
871     }
872     private final int jjStartNfa_12(int pos, long active0, long active1)
873     {
874         return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0, active1), pos + 1);
875     }
876     private final int jjStartNfaWithStates_12(int pos, int kind, int state)
877     {
878         jjmatchedKind = kind;
879         jjmatchedPos = pos;
880         try { curChar = input_stream.readChar(); }
881         catch(java.io.IOException JavaDoc e) { return pos + 1; }
882         return jjMoveNfa_12(state, pos + 1);
883     }
884     private final int jjMoveStringLiteralDfa0_12()
885     {
886         switch(curChar)
887             {
888             case 34:
889                 return jjStopAtPos(0, 99);
890             case 37:
891                 return jjStopAtPos(0, 86);
892             case 39:
893                 return jjStopAtPos(0, 93);
894             case 62:
895                 return jjStopAtPos(0, 51);
896             default :
897                 return jjMoveNfa_12(5, 0);
898             }
899     }
900     private final int jjMoveNfa_12(int startState, int curPos)
901     {
902         int[] nextStates;
903         int startsAt = 0;
904         jjnewStateCnt = 19;
905         int i = 1;
906         jjstateSet[0] = startState;
907         int j, kind = 0x7fffffff;
908         for (;;)
909             {
910                 if (++jjround == 0x7fffffff)
911                     ReInitRounds();
912                 if (curChar < 64)
913                     {
914                         long l = 1L << curChar;
915                     MatchLoop: do
916                         {
917                             switch(jjstateSet[--i])
918                                 {
919                                 case 5:
920                                     if ((0x3fffff52fffff9ffL & l) != 0L)
921                                         {
922                                             if (kind > 50)
923                                                 kind = 50;
924                                             jjCheckNAdd(18);
925                                         }
926                                     if ((0x100002600L & l) != 0L)
927                                         {
928                                             if (kind > 50)
929                                                 kind = 50;
930                                             jjCheckNAdd(17);
931                                         }
932                                     break;
933                                 case 17:
934                                     if ((0x100002600L & l) == 0L)
935                                         break;
936                                     if (kind > 50)
937                                         kind = 50;
938                                     jjCheckNAdd(17);
939                                     break;
940                                 case 18:
941                                     if ((0x3fffff52fffff9ffL & l) == 0L)
942                                         break;
943                                     if (kind > 50)
944                                         kind = 50;
945                                     jjCheckNAdd(18);
946                                     break;
947                                 default : break;
948                                 }
949                         } while(i != startsAt);
950                     }
951                 else if (curChar < 128)
952                     {
953                         long l = 1L << (curChar & 077);
954                     MatchLoop: do
955                         {
956                             switch(jjstateSet[--i])
957                                 {
958                                 case 5:
959                                     if (kind > 50)
960                                         kind = 50;
961                                     jjCheckNAdd(18);
962                                     if (curChar == 80)
963                                         jjstateSet[jjnewStateCnt++] = 15;
964                                     else if (curChar == 78)
965                                         jjstateSet[jjnewStateCnt++] = 9;
966                                     else if (curChar == 83)
967                                         jjstateSet[jjnewStateCnt++] = 4;
968                                     break;
969                                 case 0:
970                                     if (curChar == 77 && kind > 49)
971                                         kind = 49;
972                                     break;
973                                 case 1:
974                                     if (curChar == 69)
975                                         jjstateSet[jjnewStateCnt++] = 0;
976                                     break;
977                                 case 2:
978                                     if (curChar == 84)
979                                         jjstateSet[jjnewStateCnt++] = 1;
980                                     break;
981                                 case 3:
982                                     if (curChar == 83)
983                                         jjstateSet[jjnewStateCnt++] = 2;
984                                     break;
985                                 case 4:
986                                     if (curChar == 89)
987                                         jjstateSet[jjnewStateCnt++] = 3;
988                                     break;
989                                 case 6:
990                                     if (curChar == 65 && kind > 49)
991                                         kind = 49;
992                                     break;
993                                 case 7:
994                                     if (curChar == 84)
995                                         jjstateSet[jjnewStateCnt++] = 6;
996                                     break;
997                                 case 8:
998                                     if (curChar == 65)
999                                         jjstateSet[jjnewStateCnt++] = 7;
1000                                    break;
1001                                case 9:
1002                                    if (curChar == 68)
1003                                        jjstateSet[jjnewStateCnt++] = 8;
1004                                    break;
1005                                case 10:
1006                                    if (curChar == 78)
1007                                        jjstateSet[jjnewStateCnt++] = 9;
1008                                    break;
1009                                case 11:
1010                                    if (curChar == 67 && kind > 49)
1011                                        kind = 49;
1012                                    break;
1013                                case 12:
1014                                    if (curChar == 73)
1015                                        jjstateSet[jjnewStateCnt++] = 11;
1016                                    break;
1017                                case 13:
1018                                    if (curChar == 76)
1019                                        jjstateSet[jjnewStateCnt++] = 12;
1020                                    break;
1021                                case 14:
1022                                    if (curChar == 66)
1023                                        jjstateSet[jjnewStateCnt++] = 13;
1024                                    break;
1025                                case 15:
1026                                    if (curChar == 85)
1027                                        jjstateSet[jjnewStateCnt++] = 14;
1028                                    break;
1029                                case 16:
1030                                    if (curChar == 80)
1031                                        jjstateSet[jjnewStateCnt++] = 15;
1032                                    break;
1033                                case 18:
1034                                    if (kind > 50)
1035                                        kind = 50;
1036                                    jjCheckNAdd(18);
1037                                    break;
1038                                default : break;
1039                                }
1040                        } while(i != startsAt);
1041                    }
1042                else
1043                    {
1044                        int hiByte = (int)(curChar >> 8);
1045                        int i1 = hiByte >> 6;
1046                        long l1 = 1L << (hiByte & 077);
1047                        int i2 = (curChar & 0xff) >> 6;
1048                        long l2 = 1L << (curChar & 077);
1049                    MatchLoop: do
1050                        {
1051                            switch(jjstateSet[--i])
1052                                {
1053                                case 5:
1054                                case 18:
1055                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1056                                        break;
1057                                    if (kind > 50)
1058                                        kind = 50;
1059                                    jjCheckNAdd(18);
1060                                    break;
1061                                default : break;
1062                                }
1063                        } while(i != startsAt);
1064                    }
1065                if (kind != 0x7fffffff)
1066                    {
1067                        jjmatchedKind = kind;
1068                        jjmatchedPos = curPos;
1069                        kind = 0x7fffffff;
1070                    }
1071                ++curPos;
1072                if ((i = jjnewStateCnt) == (startsAt = 19 - (jjnewStateCnt = startsAt)))
1073                    return curPos;
1074                try { curChar = input_stream.readChar(); }
1075                catch(java.io.IOException JavaDoc e) { return curPos; }
1076            }
1077    }
1078    private final int jjMoveStringLiteralDfa0_3()
1079    {
1080        return jjMoveNfa_3(1, 0);
1081    }
1082    private final int jjMoveNfa_3(int startState, int curPos)
1083    {
1084        int[] nextStates;
1085        int startsAt = 0;
1086        jjnewStateCnt = 4;
1087        int i = 1;
1088        jjstateSet[0] = startState;
1089        int j, kind = 0x7fffffff;
1090        for (;;)
1091            {
1092                if (++jjround == 0x7fffffff)
1093                    ReInitRounds();
1094                if (curChar < 64)
1095                    {
1096                        long l = 1L << curChar;
1097                    MatchLoop: do
1098                        {
1099                            switch(jjstateSet[--i])
1100                                {
1101                                case 1:
1102                                    if ((0x7ff7f18fffff9ffL & l) != 0L)
1103                                        {
1104                                            if (kind > 90)
1105                                                kind = 90;
1106                                            jjCheckNAdd(0);
1107                                        }
1108                                    else if ((0xd00080e600000000L & l) != 0L)
1109                                        {
1110                                            if (kind > 91)
1111                                                kind = 91;
1112                                        }
1113                                    else if (curChar == 59)
1114                                        {
1115                                            if (kind > 92)
1116                                                kind = 92;
1117                                        }
1118                                    if ((0x100002600L & l) != 0L)
1119                                        {
1120                                            if (kind > 92)
1121                                                kind = 92;
1122                                            jjCheckNAdd(3);
1123                                        }
1124                                    break;
1125                                case 0:
1126                                    if ((0x7ff7f18fffff9ffL & l) == 0L)
1127                                        break;
1128                                    if (kind > 90)
1129                                        kind = 90;
1130                                    jjCheckNAdd(0);
1131                                    break;
1132                                case 2:
1133                                    if (curChar == 59)
1134                                        kind = 92;
1135                                    break;
1136                                case 3:
1137                                    if ((0x100002600L & l) == 0L)
1138                                        break;
1139                                    if (kind > 92)
1140                                        kind = 92;
1141                                    jjCheckNAdd(3);
1142                                    break;
1143                                default : break;
1144                                }
1145                        } while(i != startsAt);
1146                    }
1147                else if (curChar < 128)
1148                    {
1149                        long l = 1L << (curChar & 077);
1150                    MatchLoop: do
1151                        {
1152                            switch(jjstateSet[--i])
1153                                {
1154                                case 1:
1155                                case 0:
1156                                    if ((0xffffffffd7ffffffL & l) == 0L)
1157                                        break;
1158                                    kind = 90;
1159                                    jjCheckNAdd(0);
1160                                    break;
1161                                default : break;
1162                                }
1163                        } while(i != startsAt);
1164                    }
1165                else
1166                    {
1167                        int hiByte = (int)(curChar >> 8);
1168                        int i1 = hiByte >> 6;
1169                        long l1 = 1L << (hiByte & 077);
1170                        int i2 = (curChar & 0xff) >> 6;
1171                        long l2 = 1L << (curChar & 077);
1172                    MatchLoop: do
1173                        {
1174                            switch(jjstateSet[--i])
1175                                {
1176                                case 1:
1177                                case 0:
1178                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1179                                        break;
1180                                    if (kind > 90)
1181                                        kind = 90;
1182                                    jjCheckNAdd(0);
1183                                    break;
1184                                default : break;
1185                                }
1186                        } while(i != startsAt);
1187                    }
1188                if (kind != 0x7fffffff)
1189                    {
1190                        jjmatchedKind = kind;
1191                        jjmatchedPos = curPos;
1192                        kind = 0x7fffffff;
1193                    }
1194                ++curPos;
1195                if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1196                    return curPos;
1197                try { curChar = input_stream.readChar(); }
1198                catch(java.io.IOException JavaDoc e) { return curPos; }
1199            }
1200    }
1201    private final int jjStopStringLiteralDfa_8(int pos, long active0, long active1)
1202    {
1203        switch (pos)
1204            {
1205            case 0:
1206                if ((active1 & 0x7fc0L) != 0L)
1207                    {
1208                        jjmatchedKind = 79;
1209                        return 2;
1210                    }
1211                return -1;
1212            case 1:
1213                if ((active1 & 0x7c80L) != 0L)
1214                    {
1215                        if (jjmatchedPos != 1)
1216                            {
1217                                jjmatchedKind = 79;
1218                                jjmatchedPos = 1;
1219                            }
1220                        return 2;
1221                    }
1222                if ((active1 & 0x340L) != 0L)
1223                    return 2;
1224                return -1;
1225            case 2:
1226                if ((active1 & 0x7f80L) != 0L)
1227                    {
1228                        jjmatchedKind = 79;
1229                        jjmatchedPos = 2;
1230                        return 2;
1231                    }
1232                return -1;
1233            case 3:
1234                if ((active1 & 0x7f80L) != 0L)
1235                    {
1236                        jjmatchedKind = 79;
1237                        jjmatchedPos = 3;
1238                        return 2;
1239                    }
1240                return -1;
1241            case 4:
1242                if ((active1 & 0x380L) != 0L)
1243                    return 2;
1244                if ((active1 & 0x7c00L) != 0L)
1245                    {
1246                        if (jjmatchedPos != 4)
1247                            {
1248                                jjmatchedKind = 79;
1249                                jjmatchedPos = 4;
1250                            }
1251                        return 2;
1252                    }
1253                return -1;
1254            case 5:
1255                if ((active1 & 0x600L) != 0L)
1256                    return 2;
1257                if ((active1 & 0x7800L) != 0L)
1258                    {
1259                        jjmatchedKind = 79;
1260                        jjmatchedPos = 5;
1261                        return 2;
1262                    }
1263                return -1;
1264            case 6:
1265                if ((active1 & 0x3000L) != 0L)
1266                    return 2;
1267                if ((active1 & 0x4800L) != 0L)
1268                    {
1269                        if (jjmatchedPos != 6)
1270                            {
1271                                jjmatchedKind = 79;
1272                                jjmatchedPos = 6;
1273                            }
1274                        return 2;
1275                    }
1276                return -1;
1277            case 7:
1278                if ((active1 & 0x6800L) != 0L)
1279                    return 2;
1280                return -1;
1281            default :
1282                return -1;
1283            }
1284    }
1285    private final int jjStartNfa_8(int pos, long active0, long active1)
1286    {
1287        return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0, active1), pos + 1);
1288    }
1289    private final int jjStartNfaWithStates_8(int pos, int kind, int state)
1290    {
1291        jjmatchedKind = kind;
1292        jjmatchedPos = pos;
1293        try { curChar = input_stream.readChar(); }
1294        catch(java.io.IOException JavaDoc e) { return pos + 1; }
1295        return jjMoveNfa_8(state, pos + 1);
1296    }
1297    private final int jjMoveStringLiteralDfa0_8()
1298    {
1299        switch(curChar)
1300            {
1301            case 34:
1302                return jjStopAtPos(0, 99);
1303            case 35:
1304                return jjMoveStringLiteralDfa1_8(0x38L);
1305            case 39:
1306                return jjStopAtPos(0, 93);
1307            case 62:
1308                return jjStopAtPos(0, 80);
1309            case 67:
1310                return jjMoveStringLiteralDfa1_8(0x80L);
1311            case 69:
1312                return jjMoveStringLiteralDfa1_8(0xc00L);
1313            case 73:
1314                return jjMoveStringLiteralDfa1_8(0x340L);
1315            case 78:
1316                return jjMoveStringLiteralDfa1_8(0x7000L);
1317            default :
1318                return jjMoveNfa_8(4, 0);
1319            }
1320    }
1321    private final int jjMoveStringLiteralDfa1_8(long active1)
1322    {
1323        try { curChar = input_stream.readChar(); }
1324        catch(java.io.IOException JavaDoc e) {
1325            jjStopStringLiteralDfa_8(0, 0L, active1);
1326            return 1;
1327        }
1328        switch(curChar)
1329            {
1330            case 68:
1331                if ((active1 & 0x40L) != 0L)
1332                    {
1333                        jjmatchedKind = 70;
1334                        jjmatchedPos = 1;
1335                    }
1336                return jjMoveStringLiteralDfa2_8(active1, 0x380L);
1337            case 70:
1338                return jjMoveStringLiteralDfa2_8(active1, 0x20L);
1339            case 73:
1340                return jjMoveStringLiteralDfa2_8(active1, 0x10L);
1341            case 77:
1342                return jjMoveStringLiteralDfa2_8(active1, 0x3000L);
1343            case 78:
1344                return jjMoveStringLiteralDfa2_8(active1, 0xc00L);
1345            case 79:
1346                return jjMoveStringLiteralDfa2_8(active1, 0x4000L);
1347            case 82:
1348                return jjMoveStringLiteralDfa2_8(active1, 0x8L);
1349            default :
1350                break;
1351            }
1352        return jjStartNfa_8(0, 0L, active1);
1353    }
1354    private final int jjMoveStringLiteralDfa2_8(long old1, long active1)
1355    {
1356        if (((active1 &= old1)) == 0L)
1357            return jjStartNfa_8(0, 0L, old1);
1358        try { curChar = input_stream.readChar(); }
1359        catch(java.io.IOException JavaDoc e) {
1360            jjStopStringLiteralDfa_8(1, 0L, active1);
1361            return 2;
1362        }
1363        switch(curChar)
1364            {
1365            case 65:
1366                return jjMoveStringLiteralDfa3_8(active1, 0x80L);
1367            case 69:
1368                return jjMoveStringLiteralDfa3_8(active1, 0x8L);
1369            case 73:
1370                return jjMoveStringLiteralDfa3_8(active1, 0x20L);
1371            case 77:
1372                return jjMoveStringLiteralDfa3_8(active1, 0x10L);
1373            case 82:
1374                return jjMoveStringLiteralDfa3_8(active1, 0x300L);
1375            case 84:
1376                return jjMoveStringLiteralDfa3_8(active1, 0x7c00L);
1377            default :
1378                break;
1379            }
1380        return jjStartNfa_8(1, 0L, active1);
1381    }
1382    private final int jjMoveStringLiteralDfa3_8(long old1, long active1)
1383    {
1384        if (((active1 &= old1)) == 0L)
1385            return jjStartNfa_8(1, 0L, old1);
1386        try { curChar = input_stream.readChar(); }
1387        catch(java.io.IOException JavaDoc e) {
1388            jjStopStringLiteralDfa_8(2, 0L, active1);
1389            return 3;
1390        }
1391        switch(curChar)
1392            {
1393            case 65:
1394                return jjMoveStringLiteralDfa4_8(active1, 0x4000L);
1395            case 69:
1396                return jjMoveStringLiteralDfa4_8(active1, 0x300L);
1397            case 73:
1398                return jjMoveStringLiteralDfa4_8(active1, 0xc00L);
1399            case 79:
1400                return jjMoveStringLiteralDfa4_8(active1, 0x3000L);
1401            case 80:
1402                return jjMoveStringLiteralDfa4_8(active1, 0x10L);
1403            case 81:
1404                return jjMoveStringLiteralDfa4_8(active1, 0x8L);
1405            case 84:
1406                return jjMoveStringLiteralDfa4_8(active1, 0x80L);
1407            case 88:
1408                return jjMoveStringLiteralDfa4_8(active1, 0x20L);
1409            default :
1410                break;
1411            }
1412        return jjStartNfa_8(2, 0L, active1);
1413    }
1414    private final int jjMoveStringLiteralDfa4_8(long old1, long active1)
1415    {
1416        if (((active1 &= old1)) == 0L)
1417            return jjStartNfa_8(2, 0L, old1);
1418        try { curChar = input_stream.readChar(); }
1419        catch(java.io.IOException JavaDoc e) {
1420            jjStopStringLiteralDfa_8(3, 0L, active1);
1421            return 4;
1422        }
1423        switch(curChar)
1424            {
1425            case 65:
1426                if ((active1 & 0x80L) != 0L)
1427                    return jjStartNfaWithStates_8(4, 71, 2);
1428                break;
1429            case 69:
1430                return jjMoveStringLiteralDfa5_8(active1, 0x20L);
1431            case 70:
1432                if ((active1 & 0x100L) != 0L)
1433                    {
1434                        jjmatchedKind = 72;
1435                        jjmatchedPos = 4;
1436                    }
1437                return jjMoveStringLiteralDfa5_8(active1, 0x200L);
1438            case 75:
1439                return jjMoveStringLiteralDfa5_8(active1, 0x3000L);
1440            case 76:
1441                return jjMoveStringLiteralDfa5_8(active1, 0x10L);
1442            case 84:
1443                return jjMoveStringLiteralDfa5_8(active1, 0x4c00L);
1444            case 85:
1445                return jjMoveStringLiteralDfa5_8(active1, 0x8L);
1446            default :
1447                break;
1448            }
1449        return jjStartNfa_8(3, 0L, active1);
1450    }
1451    private final int jjMoveStringLiteralDfa5_8(long old1, long active1)
1452    {
1453        if (((active1 &= old1)) == 0L)
1454            return jjStartNfa_8(3, 0L, old1);
1455        try { curChar = input_stream.readChar(); }
1456        catch(java.io.IOException JavaDoc e) {
1457            jjStopStringLiteralDfa_8(4, 0L, active1);
1458            return 5;
1459        }
1460        switch(curChar)
1461            {
1462            case 68:
1463                if ((active1 & 0x20L) != 0L)
1464                    return jjStopAtPos(5, 69);
1465                break;
1466            case 69:
1467                return jjMoveStringLiteralDfa6_8(active1, 0x3000L);
1468            case 73:
1469                return jjMoveStringLiteralDfa6_8(active1, 0x4818L);
1470            case 83:
1471                if ((active1 & 0x200L) != 0L)
1472                    return jjStartNfaWithStates_8(5, 73, 2);
1473                break;
1474            case 89:
1475                if ((active1 & 0x400L) != 0L)
1476                    return jjStartNfaWithStates_8(5, 74, 2);
1477                break;
1478            default :
1479                break;
1480            }
1481        return jjStartNfa_8(4, 0L, active1);
1482    }
1483    private final int jjMoveStringLiteralDfa6_8(long old1, long active1)
1484    {
1485        if (((active1 &= old1)) == 0L)
1486            return jjStartNfa_8(4, 0L, old1);
1487        try { curChar = input_stream.readChar(); }
1488        catch(java.io.IOException JavaDoc e) {
1489            jjStopStringLiteralDfa_8(5, 0L, active1);
1490            return 6;
1491        }
1492        switch(curChar)
1493            {
1494            case 69:
1495                return jjMoveStringLiteralDfa7_8(active1, 0x810L);
1496            case 78:
1497                if ((active1 & 0x1000L) != 0L)
1498                    {
1499                        jjmatchedKind = 76;
1500                        jjmatchedPos = 6;
1501                    }
1502                return jjMoveStringLiteralDfa7_8(active1, 0x2000L);
1503            case 79:
1504                return jjMoveStringLiteralDfa7_8(active1, 0x4000L);
1505            case 82:
1506                return jjMoveStringLiteralDfa7_8(active1, 0x8L);
1507            default :
1508                break;
1509            }
1510        return jjStartNfa_8(5, 0L, active1);
1511    }
1512    private final int jjMoveStringLiteralDfa7_8(long old1, long active1)
1513    {
1514        if (((active1 &= old1)) == 0L)
1515            return jjStartNfa_8(5, 0L, old1);
1516        try { curChar = input_stream.readChar(); }
1517        catch(java.io.IOException JavaDoc e) {
1518            jjStopStringLiteralDfa_8(6, 0L, active1);
1519            return 7;
1520        }
1521        switch(curChar)
1522            {
1523            case 68:
1524                if ((active1 & 0x10L) != 0L)
1525                    return jjStopAtPos(7, 68);
1526                break;
1527            case 69:
1528                return jjMoveStringLiteralDfa8_8(active1, 0x8L);
1529            case 78:
1530                if ((active1 & 0x4000L) != 0L)
1531                    return jjStartNfaWithStates_8(7, 78, 2);
1532                break;
1533            case 83:
1534                if ((active1 & 0x800L) != 0L)
1535                    return jjStartNfaWithStates_8(7, 75, 2);
1536                else if ((active1 & 0x2000L) != 0L)
1537                    return jjStartNfaWithStates_8(7, 77, 2);
1538                break;
1539            default :
1540                break;
1541            }
1542        return jjStartNfa_8(6, 0L, active1);
1543    }
1544    private final int jjMoveStringLiteralDfa8_8(long old1, long active1)
1545    {
1546        if (((active1 &= old1)) == 0L)
1547            return jjStartNfa_8(6, 0L, old1);
1548        try { curChar = input_stream.readChar(); }
1549        catch(java.io.IOException JavaDoc e) {
1550            jjStopStringLiteralDfa_8(7, 0L, active1);
1551            return 8;
1552        }
1553        switch(curChar)
1554            {
1555            case 68:
1556                if ((active1 & 0x8L) != 0L)
1557                    return jjStopAtPos(8, 67);
1558                break;
1559            default :
1560                break;
1561            }
1562        return jjStartNfa_8(7, 0L, active1);
1563    }
1564    private final int jjMoveNfa_8(int startState, int curPos)
1565    {
1566        int[] nextStates;
1567        int startsAt = 0;
1568        jjnewStateCnt = 4;
1569        int i = 1;
1570        jjstateSet[0] = startState;
1571        int j, kind = 0x7fffffff;
1572        for (;;)
1573            {
1574                if (++jjround == 0x7fffffff)
1575                    ReInitRounds();
1576                if (curChar < 64)
1577                    {
1578                        long l = 1L << curChar;
1579                    MatchLoop: do
1580                        {
1581                            switch(jjstateSet[--i])
1582                                {
1583                                case 4:
1584                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
1585                                        {
1586                                            if (kind > 79)
1587                                                kind = 79;
1588                                            jjCheckNAdd(2);
1589                                        }
1590                                    else if ((0x800006000000000L & l) != 0L)
1591                                        {
1592                                            if (kind > 79)
1593                                                kind = 79;
1594                                            jjCheckNAdd(3);
1595                                        }
1596                                    else if (curChar == 60)
1597                                        {
1598                                            if (kind > 66)
1599                                                kind = 66;
1600                                            jjCheckNAdd(0);
1601                                        }
1602                                    if ((0x100002600L & l) != 0L)
1603                                        {
1604                                            if (kind > 79)
1605                                                kind = 79;
1606                                            jjCheckNAdd(1);
1607                                        }
1608                                    break;
1609                                case 0:
1610                                    if (curChar != 60)
1611                                        break;
1612                                    kind = 66;
1613                                    jjCheckNAdd(0);
1614                                    break;
1615                                case 1:
1616                                    if ((0x100002600L & l) == 0L)
1617                                        break;
1618                                    if (kind > 79)
1619                                        kind = 79;
1620                                    jjCheckNAdd(1);
1621                                    break;
1622                                case 2:
1623                                    if ((0x7ff7f10fffff9ffL & l) == 0L)
1624                                        break;
1625                                    if (kind > 79)
1626                                        kind = 79;
1627                                    jjCheckNAdd(2);
1628                                    break;
1629                                case 3:
1630                                    if ((0x800006000000000L & l) == 0L)
1631                                        break;
1632                                    kind = 79;
1633                                    jjCheckNAdd(3);
1634                                    break;
1635                                default : break;
1636                                }
1637                        } while(i != startsAt);
1638                    }
1639                else if (curChar < 128)
1640                    {
1641                        long l = 1L << (curChar & 077);
1642                    MatchLoop: do
1643                        {
1644                            switch(jjstateSet[--i])
1645                                {
1646                                case 4:
1647                                    if ((0xffffffffd7ffffffL & l) != 0L)
1648                                        {
1649                                            if (kind > 79)
1650                                                kind = 79;
1651                                            jjCheckNAdd(2);
1652                                        }
1653                                    else if ((0x28000000L & l) != 0L)
1654                                        {
1655                                            if (kind > 79)
1656                                                kind = 79;
1657                                            jjCheckNAdd(3);
1658                                        }
1659                                    break;
1660                                case 2:
1661                                    if ((0xffffffffd7ffffffL & l) == 0L)
1662                                        break;
1663                                    kind = 79;
1664                                    jjCheckNAdd(2);
1665                                    break;
1666                                case 3:
1667                                    if ((0x28000000L & l) == 0L)
1668                                        break;
1669                                    kind = 79;
1670                                    jjCheckNAdd(3);
1671                                    break;
1672                                default : break;
1673                                }
1674                        } while(i != startsAt);
1675                    }
1676                else
1677                    {
1678                        int hiByte = (int)(curChar >> 8);
1679                        int i1 = hiByte >> 6;
1680                        long l1 = 1L << (hiByte & 077);
1681                        int i2 = (curChar & 0xff) >> 6;
1682                        long l2 = 1L << (curChar & 077);
1683                    MatchLoop: do
1684                        {
1685                            switch(jjstateSet[--i])
1686                                {
1687                                case 4:
1688                                case 2:
1689                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1690                                        break;
1691                                    if (kind > 79)
1692                                        kind = 79;
1693                                    jjCheckNAdd(2);
1694                                    break;
1695                                default : break;
1696                                }
1697                        } while(i != startsAt);
1698                    }
1699                if (kind != 0x7fffffff)
1700                    {
1701                        jjmatchedKind = kind;
1702                        jjmatchedPos = curPos;
1703                        kind = 0x7fffffff;
1704                    }
1705                ++curPos;
1706                if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1707                    return curPos;
1708                try { curChar = input_stream.readChar(); }
1709                catch(java.io.IOException JavaDoc e) { return curPos; }
1710            }
1711    }
1712    private final int jjStopStringLiteralDfa_7(int pos, long active0, long active1)
1713    {
1714        switch (pos)
1715            {
1716            case 0:
1717                if ((active1 & 0x60000L) != 0L)
1718                    {
1719                        jjmatchedKind = 83;
1720                        return 1;
1721                    }
1722                return -1;
1723            case 1:
1724                if ((active1 & 0x60000L) != 0L)
1725                    {
1726                        jjmatchedKind = 83;
1727                        jjmatchedPos = 1;
1728                        return 1;
1729                    }
1730                return -1;
1731            case 2:
1732                if ((active1 & 0x60000L) != 0L)
1733                    {
1734                        jjmatchedKind = 83;
1735                        jjmatchedPos = 2;
1736                        return 1;
1737                    }
1738                return -1;
1739            case 3:
1740                if ((active1 & 0x60000L) != 0L)
1741                    {
1742                        jjmatchedKind = 83;
1743                        jjmatchedPos = 3;
1744                        return 1;
1745                    }
1746                return -1;
1747            case 4:
1748                if ((active1 & 0x60000L) != 0L)
1749                    {
1750                        jjmatchedKind = 83;
1751                        jjmatchedPos = 4;
1752                        return 1;
1753                    }
1754                return -1;
1755            default :
1756                return -1;
1757            }
1758    }
1759    private final int jjStartNfa_7(int pos, long active0, long active1)
1760    {
1761        return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1), pos + 1);
1762    }
1763    private final int jjStartNfaWithStates_7(int pos, int kind, int state)
1764    {
1765        jjmatchedKind = kind;
1766        jjmatchedPos = pos;
1767        try { curChar = input_stream.readChar(); }
1768        catch(java.io.IOException JavaDoc e) { return pos + 1; }
1769        return jjMoveNfa_7(state, pos + 1);
1770    }
1771    private final int jjMoveStringLiteralDfa0_7()
1772    {
1773        switch(curChar)
1774            {
1775            case 34:
1776                return jjStopAtPos(0, 99);
1777            case 37:
1778                return jjStopAtPos(0, 86);
1779            case 39:
1780                return jjStopAtPos(0, 93);
1781            case 80:
1782                return jjMoveStringLiteralDfa1_7(0x20000L);
1783            case 83:
1784                return jjMoveStringLiteralDfa1_7(0x40000L);
1785            default :
1786                return jjMoveNfa_7(3, 0);
1787            }
1788    }
1789    private final int jjMoveStringLiteralDfa1_7(long active1)
1790    {
1791        try { curChar = input_stream.readChar(); }
1792        catch(java.io.IOException JavaDoc e) {
1793            jjStopStringLiteralDfa_7(0, 0L, active1);
1794            return 1;
1795        }
1796        switch(curChar)
1797            {
1798            case 85:
1799                return jjMoveStringLiteralDfa2_7(active1, 0x20000L);
1800            case 89:
1801                return jjMoveStringLiteralDfa2_7(active1, 0x40000L);
1802            default :
1803                break;
1804            }
1805        return jjStartNfa_7(0, 0L, active1);
1806    }
1807    private final int jjMoveStringLiteralDfa2_7(long old1, long active1)
1808    {
1809        if (((active1 &= old1)) == 0L)
1810            return jjStartNfa_7(0, 0L, old1);
1811        try { curChar = input_stream.readChar(); }
1812        catch(java.io.IOException JavaDoc e) {
1813            jjStopStringLiteralDfa_7(1, 0L, active1);
1814            return 2;
1815        }
1816        switch(curChar)
1817            {
1818            case 66:
1819                return jjMoveStringLiteralDfa3_7(active1, 0x20000L);
1820            case 83:
1821                return jjMoveStringLiteralDfa3_7(active1, 0x40000L);
1822            default :
1823                break;
1824            }
1825        return jjStartNfa_7(1, 0L, active1);
1826    }
1827    private final int jjMoveStringLiteralDfa3_7(long old1, long active1)
1828    {
1829        if (((active1 &= old1)) == 0L)
1830            return jjStartNfa_7(1, 0L, old1);
1831        try { curChar = input_stream.readChar(); }
1832        catch(java.io.IOException JavaDoc e) {
1833            jjStopStringLiteralDfa_7(2, 0L, active1);
1834            return 3;
1835        }
1836        switch(curChar)
1837            {
1838            case 76:
1839                return jjMoveStringLiteralDfa4_7(active1, 0x20000L);
1840            case 84:
1841                return jjMoveStringLiteralDfa4_7(active1, 0x40000L);
1842            default :
1843                break;
1844            }
1845        return jjStartNfa_7(2, 0L, active1);
1846    }
1847    private final int jjMoveStringLiteralDfa4_7(long old1, long active1)
1848    {
1849        if (((active1 &= old1)) == 0L)
1850            return jjStartNfa_7(2, 0L, old1);
1851        try { curChar = input_stream.readChar(); }
1852        catch(java.io.IOException JavaDoc e) {
1853            jjStopStringLiteralDfa_7(3, 0L, active1);
1854            return 4;
1855        }
1856        switch(curChar)
1857            {
1858            case 69:
1859                return jjMoveStringLiteralDfa5_7(active1, 0x40000L);
1860            case 73:
1861                return jjMoveStringLiteralDfa5_7(active1, 0x20000L);
1862            default :
1863                break;
1864            }
1865        return jjStartNfa_7(3, 0L, active1);
1866    }
1867    private final int jjMoveStringLiteralDfa5_7(long old1, long active1)
1868    {
1869        if (((active1 &= old1)) == 0L)
1870            return jjStartNfa_7(3, 0L, old1);
1871        try { curChar = input_stream.readChar(); }
1872        catch(java.io.IOException JavaDoc e) {
1873            jjStopStringLiteralDfa_7(4, 0L, active1);
1874            return 5;
1875        }
1876        switch(curChar)
1877            {
1878            case 67:
1879                if ((active1 & 0x20000L) != 0L)
1880                    return jjStartNfaWithStates_7(5, 81, 1);
1881                break;
1882            case 77:
1883                if ((active1 & 0x40000L) != 0L)
1884                    return jjStartNfaWithStates_7(5, 82, 1);
1885                break;
1886            default :
1887                break;
1888            }
1889        return jjStartNfa_7(4, 0L, active1);
1890    }
1891    private final int jjMoveNfa_7(int startState, int curPos)
1892    {
1893        int[] nextStates;
1894        int startsAt = 0;
1895        jjnewStateCnt = 4;
1896        int i = 1;
1897        jjstateSet[0] = startState;
1898        int j, kind = 0x7fffffff;
1899        for (;;)
1900            {
1901                if (++jjround == 0x7fffffff)
1902                    ReInitRounds();
1903                if (curChar < 64)
1904                    {
1905                        long l = 1L << curChar;
1906                    MatchLoop: do
1907                        {
1908                            switch(jjstateSet[--i])
1909                                {
1910                                case 3:
1911                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
1912                                        {
1913                                            if (kind > 83)
1914                                                kind = 83;
1915                                            jjCheckNAdd(1);
1916                                        }
1917                                    else if ((0x3800804200000000L & l) != 0L)
1918                                        {
1919                                            if (kind > 84)
1920                                                kind = 84;
1921                                            jjCheckNAdd(2);
1922                                        }
1923                                    else if (curChar == 62)
1924                                        {
1925                                            if (kind > 85)
1926                                                kind = 85;
1927                                        }
1928                                    if ((0x100002600L & l) != 0L)
1929                                        {
1930                                            if (kind > 83)
1931                                                kind = 83;
1932                                            jjCheckNAdd(0);
1933                                        }
1934                                    break;
1935                                case 0:
1936                                    if ((0x100002600L & l) == 0L)
1937                                        break;
1938                                    if (kind > 83)
1939                                        kind = 83;
1940                                    jjCheckNAdd(0);
1941                                    break;
1942                                case 1:
1943                                    if ((0x7ff7f10fffff9ffL & l) == 0L)
1944                                        break;
1945                                    if (kind > 83)
1946                                        kind = 83;
1947                                    jjCheckNAdd(1);
1948                                    break;
1949                                case 2:
1950                                    if ((0x3800804200000000L & l) == 0L)
1951                                        break;
1952                                    kind = 84;
1953                                    jjCheckNAdd(2);
1954                                    break;
1955                                default : break;
1956                                }
1957                        } while(i != startsAt);
1958                    }
1959                else if (curChar < 128)
1960                    {
1961                        long l = 1L << (curChar & 077);
1962                    MatchLoop: do
1963                        {
1964                            switch(jjstateSet[--i])
1965                                {
1966                                case 3:
1967                                    if ((0xffffffffd7ffffffL & l) != 0L)
1968                                        {
1969                                            if (kind > 83)
1970                                                kind = 83;
1971                                            jjCheckNAdd(1);
1972                                        }
1973                                    else if (curChar == 91)
1974                                        {
1975                                            if (kind > 85)
1976                                                kind = 85;
1977                                        }
1978                                    else if (curChar == 93)
1979                                        {
1980                                            if (kind > 84)
1981                                                kind = 84;
1982                                            jjCheckNAdd(2);
1983                                        }
1984                                    break;
1985                                case 1:
1986                                    if ((0xffffffffd7ffffffL & l) == 0L)
1987                                        break;
1988                                    kind = 83;
1989                                    jjCheckNAdd(1);
1990                                    break;
1991                                case 2:
1992                                    if (curChar != 93)
1993                                        break;
1994                                    kind = 84;
1995                                    jjCheckNAdd(2);
1996                                    break;
1997                                default : break;
1998                                }
1999                        } while(i != startsAt);
2000                    }
2001                else
2002                    {
2003                        int hiByte = (int)(curChar >> 8);
2004                        int i1 = hiByte >> 6;
2005                        long l1 = 1L << (hiByte & 077);
2006                        int i2 = (curChar & 0xff) >> 6;
2007                        long l2 = 1L << (curChar & 077);
2008                    MatchLoop: do
2009                        {
2010                            switch(jjstateSet[--i])
2011                                {
2012                                case 3:
2013                                case 1:
2014                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2015                                        break;
2016                                    if (kind > 83)
2017                                        kind = 83;
2018                                    jjCheckNAdd(1);
2019                                    break;
2020                                default : break;
2021                                }
2022                        } while(i != startsAt);
2023                    }
2024                if (kind != 0x7fffffff)
2025                    {
2026                        jjmatchedKind = kind;
2027                        jjmatchedPos = curPos;
2028                        kind = 0x7fffffff;
2029                    }
2030                ++curPos;
2031                if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
2032                    return curPos;
2033                try { curChar = input_stream.readChar(); }
2034                catch(java.io.IOException JavaDoc e) { return curPos; }
2035            }
2036    }
2037    private final int jjStopStringLiteralDfa_18(int pos, long active0, long active1)
2038    {
2039        switch (pos)
2040            {
2041            default :
2042                return -1;
2043            }
2044    }
2045    private final int jjStartNfa_18(int pos, long active0, long active1)
2046    {
2047        return jjMoveNfa_18(jjStopStringLiteralDfa_18(pos, active0, active1), pos + 1);
2048    }
2049    private final int jjStartNfaWithStates_18(int pos, int kind, int state)
2050    {
2051        jjmatchedKind = kind;
2052        jjmatchedPos = pos;
2053        try { curChar = input_stream.readChar(); }
2054        catch(java.io.IOException JavaDoc e) { return pos + 1; }
2055        return jjMoveNfa_18(state, pos + 1);
2056    }
2057    private final int jjMoveStringLiteralDfa0_18()
2058    {
2059        switch(curChar)
2060            {
2061            case 34:
2062                return jjStopAtPos(0, 102);
2063            case 39:
2064                return jjStopAtPos(0, 96);
2065            case 61:
2066                return jjStopAtPos(0, 20);
2067            default :
2068                return jjMoveNfa_18(3, 0);
2069            }
2070    }
2071    private final int jjMoveNfa_18(int startState, int curPos)
2072    {
2073        int[] nextStates;
2074        int startsAt = 0;
2075        jjnewStateCnt = 5;
2076        int i = 1;
2077        jjstateSet[0] = startState;
2078        int j, kind = 0x7fffffff;
2079        for (;;)
2080            {
2081                if (++jjround == 0x7fffffff)
2082                    ReInitRounds();
2083                if (curChar < 64)
2084                    {
2085                        long l = 1L << curChar;
2086                    MatchLoop: do
2087                        {
2088                            switch(jjstateSet[--i])
2089                                {
2090                                case 3:
2091                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
2092                                        {
2093                                            if (kind > 17)
2094                                                kind = 17;
2095                                            jjCheckNAdd(0);
2096                                        }
2097                                    else if ((0x9800806200000000L & l) != 0L)
2098                                        {
2099                                            if (kind > 18)
2100                                                kind = 18;
2101                                            jjCheckNAdd(1);
2102                                        }
2103                                    else if (curChar == 62)
2104                                        {
2105                                            if (kind > 21)
2106                                                kind = 21;
2107                                        }
2108                                    if ((0x100002600L & l) != 0L)
2109                                        {
2110                                            if (kind > 19)
2111                                                kind = 19;
2112                                            jjCheckNAdd(2);
2113                                        }
2114                                    else if (curChar == 47)
2115                                        jjstateSet[jjnewStateCnt++] = 4;
2116                                    break;
2117                                case 0:
2118                                    if ((0x7ff7f10fffff9ffL & l) == 0L)
2119                                        break;
2120                                    if (kind > 17)
2121                                        kind = 17;
2122                                    jjCheckNAdd(0);
2123                                    break;
2124                                case 1:
2125                                    if ((0x9800806200000000L & l) == 0L)
2126                                        break;
2127                                    if (kind > 18)
2128                                        kind = 18;
2129                                    jjCheckNAdd(1);
2130                                    break;
2131                                case 2:
2132                                    if ((0x100002600L & l) == 0L)
2133                                        break;
2134                                    if (kind > 19)
2135                                        kind = 19;
2136                                    jjCheckNAdd(2);
2137                                    break;
2138                                case 4:
2139                                    if (curChar == 62)
2140                                        kind = 21;
2141                                    break;
2142                                default : break;
2143                                }
2144                        } while(i != startsAt);
2145                    }
2146                else if (curChar < 128)
2147                    {
2148                        long l = 1L << (curChar & 077);
2149                    MatchLoop: do
2150                        {
2151                            switch(jjstateSet[--i])
2152                                {
2153                                case 3:
2154                                    if ((0xffffffffd7ffffffL & l) != 0L)
2155                                        {
2156                                            if (kind > 17)
2157                                                kind = 17;
2158                                            jjCheckNAdd(0);
2159                                        }
2160                                    else if ((0x28000000L & l) != 0L)
2161                                        {
2162                                            if (kind > 18)
2163                                                kind = 18;
2164                                            jjCheckNAdd(1);
2165                                        }
2166                                    break;
2167                                case 0:
2168                                    if ((0xffffffffd7ffffffL & l) == 0L)
2169                                        break;
2170                                    kind = 17;
2171                                    jjCheckNAdd(0);
2172                                    break;
2173                                case 1:
2174                                    if ((0x28000000L & l) == 0L)
2175                                        break;
2176                                    kind = 18;
2177                                    jjCheckNAdd(1);
2178                                    break;
2179                                default : break;
2180                                }
2181                        } while(i != startsAt);
2182                    }
2183                else
2184                    {
2185                        int hiByte = (int)(curChar >> 8);
2186                        int i1 = hiByte >> 6;
2187                        long l1 = 1L << (hiByte & 077);
2188                        int i2 = (curChar & 0xff) >> 6;
2189                        long l2 = 1L << (curChar & 077);
2190                    MatchLoop: do
2191                        {
2192                            switch(jjstateSet[--i])
2193                                {
2194                                case 3:
2195                                case 0:
2196                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2197                                        break;
2198                                    if (kind > 17)
2199                                        kind = 17;
2200                                    jjCheckNAdd(0);
2201                                    break;
2202                                default : break;
2203                                }
2204                        } while(i != startsAt);
2205                    }
2206                if (kind != 0x7fffffff)
2207                    {
2208                        jjmatchedKind = kind;
2209                        jjmatchedPos = curPos;
2210                        kind = 0x7fffffff;
2211                    }
2212                ++curPos;
2213                if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
2214                    return curPos;
2215                try { curChar = input_stream.readChar(); }
2216                catch(java.io.IOException JavaDoc e) { return curPos; }
2217            }
2218    }
2219    private final int jjStopStringLiteralDfa_16(int pos, long active0)
2220    {
2221        switch (pos)
2222            {
2223            case 0:
2224                if ((active0 & 0x8000000L) != 0L)
2225                    {
2226                        jjmatchedKind = 28;
2227                        return -1;
2228                    }
2229                return -1;
2230            default :
2231                return -1;
2232            }
2233    }
2234    private final int jjStartNfa_16(int pos, long active0)
2235    {
2236        return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0), pos + 1);
2237    }
2238    private final int jjStartNfaWithStates_16(int pos, int kind, int state)
2239    {
2240        jjmatchedKind = kind;
2241        jjmatchedPos = pos;
2242        try { curChar = input_stream.readChar(); }
2243        catch(java.io.IOException JavaDoc e) { return pos + 1; }
2244        return jjMoveNfa_16(state, pos + 1);
2245    }
2246    private final int jjMoveStringLiteralDfa0_16()
2247    {
2248        switch(curChar)
2249            {
2250            case 63:
2251                return jjMoveStringLiteralDfa1_16(0x8000000L);
2252            default :
2253                return jjMoveNfa_16(2, 0);
2254            }
2255    }
2256    private final int jjMoveStringLiteralDfa1_16(long active0)
2257    {
2258        try { curChar = input_stream.readChar(); }
2259        catch(java.io.IOException JavaDoc e) {
2260            jjStopStringLiteralDfa_16(0, active0);
2261            return 1;
2262        }
2263        switch(curChar)
2264            {
2265            case 62:
2266                if ((active0 & 0x8000000L) != 0L)
2267                    return jjStopAtPos(1, 27);
2268                break;
2269            default :
2270                break;
2271            }
2272        return jjStartNfa_16(0, active0);
2273    }
2274    private final int jjMoveNfa_16(int startState, int curPos)
2275    {
2276        int[] nextStates;
2277        int startsAt = 0;
2278        jjnewStateCnt = 4;
2279        int i = 1;
2280        jjstateSet[0] = startState;
2281        int j, kind = 0x7fffffff;
2282        for (;;)
2283            {
2284                if (++jjround == 0x7fffffff)
2285                    ReInitRounds();
2286                if (curChar < 64)
2287                    {
2288                        long l = 1L << curChar;
2289                    MatchLoop: do
2290                        {
2291                            switch(jjstateSet[--i])
2292                                {
2293                                case 2:
2294                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
2295                                        {
2296                                            if (kind > 28)
2297                                                kind = 28;
2298                                            jjCheckNAdd(0);
2299                                        }
2300                                    else if ((0xe80080ee00000000L & l) != 0L)
2301                                        {
2302                                            if (kind > 28)
2303                                                kind = 28;
2304                                        }
2305                                    else if (curChar == 60)
2306                                        {
2307                                            if (kind > 29)
2308                                                kind = 29;
2309                                            jjCheckNAdd(3);
2310                                        }
2311                                    if ((0x100002600L & l) != 0L)
2312                                        {
2313                                            if (kind > 28)
2314                                                kind = 28;
2315                                            jjCheckNAdd(1);
2316                                        }
2317                                    break;
2318                                case 0:
2319                                    if ((0x7ff7f10fffff9ffL & l) == 0L)
2320                                        break;
2321                                    if (kind > 28)
2322                                        kind = 28;
2323                                    jjCheckNAdd(0);
2324                                    break;
2325                                case 1:
2326                                    if ((0x100002600L & l) == 0L)
2327                                        break;
2328                                    if (kind > 28)
2329                                        kind = 28;
2330                                    jjCheckNAdd(1);
2331                                    break;
2332                                case 3:
2333                                    if (curChar != 60)
2334                                        break;
2335                                    kind = 29;
2336                                    jjCheckNAdd(3);
2337                                    break;
2338                                default : break;
2339                                }
2340                        } while(i != startsAt);
2341                    }
2342                else if (curChar < 128)
2343                    {
2344                        long l = 1L << (curChar & 077);
2345                    MatchLoop: do
2346                        {
2347                            switch(jjstateSet[--i])
2348                                {
2349                                case 2:
2350                                    if ((0xffffffffd7ffffffL & l) != 0L)
2351                                        {
2352                                            if (kind > 28)
2353                                                kind = 28;
2354                                            jjCheckNAdd(0);
2355                                        }
2356                                    else if ((0x28000000L & l) != 0L)
2357                                        {
2358                                            if (kind > 28)
2359                                                kind = 28;
2360                                        }
2361                                    break;
2362                                case 0:
2363                                    if ((0xffffffffd7ffffffL & l) == 0L)
2364                                        break;
2365                                    kind = 28;
2366                                    jjCheckNAdd(0);
2367                                    break;
2368                                default : break;
2369                                }
2370                        } while(i != startsAt);
2371                    }
2372                else
2373                    {
2374                        int hiByte = (int)(curChar >> 8);
2375                        int i1 = hiByte >> 6;
2376                        long l1 = 1L << (hiByte & 077);
2377                        int i2 = (curChar & 0xff) >> 6;
2378                        long l2 = 1L << (curChar & 077);
2379                    MatchLoop: do
2380                        {
2381                            switch(jjstateSet[--i])
2382                                {
2383                                case 2:
2384                                case 0:
2385                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2386                                        break;
2387                                    if (kind > 28)
2388                                        kind = 28;
2389                                    jjCheckNAdd(0);
2390                                    break;
2391                                default : break;
2392                                }
2393                        } while(i != startsAt);
2394                    }
2395                if (kind != 0x7fffffff)
2396                    {
2397                        jjmatchedKind = kind;
2398                        jjmatchedPos = curPos;
2399                        kind = 0x7fffffff;
2400                    }
2401                ++curPos;
2402                if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
2403                    return curPos;
2404                try { curChar = input_stream.readChar(); }
2405                catch(java.io.IOException JavaDoc e) { return curPos; }
2406            }
2407    }
2408    private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
2409    {
2410        switch (pos)
2411            {
2412            default :
2413                return -1;
2414            }
2415    }
2416    private final int jjStartNfa_1(int pos, long active0, long active1)
2417    {
2418        return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
2419    }
2420    private final int jjStartNfaWithStates_1(int pos, int kind, int state)
2421    {
2422        jjmatchedKind = kind;
2423        jjmatchedPos = pos;
2424        try { curChar = input_stream.readChar(); }
2425        catch(java.io.IOException JavaDoc e) { return pos + 1; }
2426        return jjMoveNfa_1(state, pos + 1);
2427    }
2428    private final int jjMoveStringLiteralDfa0_1()
2429    {
2430        switch(curChar)
2431            {
2432            case 34:
2433                return jjStopAtPos(0, 101);
2434            default :
2435                return jjMoveNfa_1(0, 0);
2436            }
2437    }
2438    private final int jjMoveNfa_1(int startState, int curPos)
2439    {
2440        int[] nextStates;
2441        int startsAt = 0;
2442        jjnewStateCnt = 1;
2443        int i = 1;
2444        jjstateSet[0] = startState;
2445        int j, kind = 0x7fffffff;
2446        for (;;)
2447            {
2448                if (++jjround == 0x7fffffff)
2449                    ReInitRounds();
2450                if (curChar < 64)
2451                    {
2452                        long l = 1L << curChar;
2453                    MatchLoop: do
2454                        {
2455                            switch(jjstateSet[--i])
2456                                {
2457                                case 0:
2458                                    if ((0xfffffffbffffffffL & l) == 0L)
2459                                        break;
2460                                    kind = 100;
2461                                    jjstateSet[jjnewStateCnt++] = 0;
2462                                    break;
2463                                default : break;
2464                                }
2465                        } while(i != startsAt);
2466                    }
2467                else if (curChar < 128)
2468                    {
2469                        long l = 1L << (curChar & 077);
2470                    MatchLoop: do
2471                        {
2472                            switch(jjstateSet[--i])
2473                                {
2474                                case 0:
2475                                    kind = 100;
2476                                    jjstateSet[jjnewStateCnt++] = 0;
2477                                    break;
2478                                default : break;
2479                                }
2480                        } while(i != startsAt);
2481                    }
2482                else
2483                    {
2484                        int hiByte = (int)(curChar >> 8);
2485                        int i1 = hiByte >> 6;
2486                        long l1 = 1L << (hiByte & 077);
2487                        int i2 = (curChar & 0xff) >> 6;
2488                        long l2 = 1L << (curChar & 077);
2489                    MatchLoop: do
2490                        {
2491                            switch(jjstateSet[--i])
2492                                {
2493                                case 0:
2494                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2495                                        break;
2496                                    if (kind > 100)
2497                                        kind = 100;
2498                                    jjstateSet[jjnewStateCnt++] = 0;
2499                                    break;
2500                                default : break;
2501                                }
2502                        } while(i != startsAt);
2503                    }
2504                if (kind != 0x7fffffff)
2505                    {
2506                        jjmatchedKind = kind;
2507                        jjmatchedPos = curPos;
2508                        kind = 0x7fffffff;
2509                    }
2510                ++curPos;
2511                if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
2512                    return curPos;
2513                try { curChar = input_stream.readChar(); }
2514                catch(java.io.IOException JavaDoc e) { return curPos; }
2515            }
2516    }
2517    private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
2518    {
2519        switch (pos)
2520            {
2521            case 0:
2522                if ((active1 & 0x100000000000L) != 0L)
2523                    return 2;
2524                return -1;
2525            case 1:
2526                if ((active1 & 0x100000000000L) != 0L)
2527                    return 3;
2528                return -1;
2529            default :
2530                return -1;
2531            }
2532    }
2533    private final int jjStartNfa_0(int pos, long active0, long active1)
2534    {
2535        return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
2536    }
2537    private final int jjStartNfaWithStates_0(int pos, int kind, int state)
2538    {
2539        jjmatchedKind = kind;
2540        jjmatchedPos = pos;
2541        try { curChar = input_stream.readChar(); }
2542        catch(java.io.IOException JavaDoc e) { return pos + 1; }
2543        return jjMoveNfa_0(state, pos + 1);
2544    }
2545    private final int jjMoveStringLiteralDfa0_0()
2546    {
2547        switch(curChar)
2548            {
2549            case 45:
2550                return jjMoveStringLiteralDfa1_0(0x100000000000L);
2551            default :
2552                return jjMoveNfa_0(4, 0);
2553            }
2554    }
2555    private final int jjMoveStringLiteralDfa1_0(long active1)
2556    {
2557        try { curChar = input_stream.readChar(); }
2558        catch(java.io.IOException JavaDoc e) {
2559            jjStopStringLiteralDfa_0(0, 0L, active1);
2560            return 1;
2561        }
2562        switch(curChar)
2563            {
2564            case 45:
2565                return jjMoveStringLiteralDfa2_0(active1, 0x100000000000L);
2566            default :
2567                break;
2568            }
2569        return jjStartNfa_0(0, 0L, active1);
2570    }
2571    private final int jjMoveStringLiteralDfa2_0(long old1, long active1)
2572    {
2573        if (((active1 &= old1)) == 0L)
2574            return jjStartNfa_0(0, 0L, old1);
2575        try { curChar = input_stream.readChar(); }
2576        catch(java.io.IOException JavaDoc e) {
2577            jjStopStringLiteralDfa_0(1, 0L, active1);
2578            return 2;
2579        }
2580        switch(curChar)
2581            {
2582            case 62:
2583                if ((active1 & 0x100000000000L) != 0L)
2584                    return jjStopAtPos(2, 108);
2585                break;
2586            default :
2587                break;
2588            }
2589        return jjStartNfa_0(1, 0L, active1);
2590    }
2591    private final int jjMoveNfa_0(int startState, int curPos)
2592    {
2593        int[] nextStates;
2594        int startsAt = 0;
2595        jjnewStateCnt = 5;
2596        int i = 1;
2597        jjstateSet[0] = startState;
2598        int j, kind = 0x7fffffff;
2599        for (;;)
2600            {
2601                if (++jjround == 0x7fffffff)
2602                    ReInitRounds();
2603                if (curChar < 64)
2604                    {
2605                        long l = 1L << curChar;
2606                    MatchLoop: do
2607                        {
2608                            switch(jjstateSet[--i])
2609                                {
2610                                case 4:
2611                                    if ((0xffffdfffffffffffL & l) != 0L)
2612                                        {
2613                                            if (kind > 106)
2614                                                kind = 106;
2615                                            jjCheckNAddTwoStates(0, 1);
2616                                        }
2617                                    else if (curChar == 45)
2618                                        jjstateSet[jjnewStateCnt++] = 2;
2619                                    if (curChar == 45)
2620                                        jjCheckNAdd(0);
2621                                    break;
2622                                case 2:
2623                                    if ((0xffffdfffffffffffL & l) != 0L)
2624                                        {
2625                                            if (kind > 106)
2626                                                kind = 106;
2627                                            jjCheckNAddTwoStates(0, 1);
2628                                        }
2629                                    else if (curChar == 45)
2630                                        jjstateSet[jjnewStateCnt++] = 3;
2631                                    break;
2632                                case 0:
2633                                    if ((0xffffdfffffffffffL & l) == 0L)
2634                                        break;
2635                                    if (kind > 106)
2636                                        kind = 106;
2637                                    jjCheckNAddTwoStates(0, 1);
2638                                    break;
2639                                case 1:
2640                                    if (curChar == 45)
2641                                        jjCheckNAdd(0);
2642                                    break;
2643                                case 3:
2644                                    if ((0xbfffffffffffffffL & l) != 0L && kind > 107)
2645                                        kind = 107;
2646                                    break;
2647                                default : break;
2648                                }
2649                        } while(i != startsAt);
2650                    }
2651                else if (curChar < 128)
2652                    {
2653                        long l = 1L << (curChar & 077);
2654                    MatchLoop: do
2655                        {
2656                            switch(jjstateSet[--i])
2657                                {
2658                                case 4:
2659                                case 0:
2660                                    if (kind > 106)
2661                                        kind = 106;
2662                                    jjCheckNAddTwoStates(0, 1);
2663                                    break;
2664                                case 2:
2665                                    if (kind > 106)
2666                                        kind = 106;
2667                                    jjCheckNAddTwoStates(0, 1);
2668                                    break;
2669                                case 3:
2670                                    if (kind > 107)
2671                                        kind = 107;
2672                                    break;
2673                                default : break;
2674                                }
2675                        } while(i != startsAt);
2676                    }
2677                else
2678                    {
2679                        int hiByte = (int)(curChar >> 8);
2680                        int i1 = hiByte >> 6;
2681                        long l1 = 1L << (hiByte & 077);
2682                        int i2 = (curChar & 0xff) >> 6;
2683                        long l2 = 1L << (curChar & 077);
2684                    MatchLoop: do
2685                        {
2686                            switch(jjstateSet[--i])
2687                                {
2688                                case 4:
2689                                case 0:
2690                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2691                                        break;
2692                                    if (kind > 106)
2693                                        kind = 106;
2694                                    jjCheckNAddTwoStates(0, 1);
2695                                    break;
2696                                case 2:
2697                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2698                                        break;
2699                                    if (kind > 106)
2700                                        kind = 106;
2701                                    jjCheckNAddTwoStates(0, 1);
2702                                    break;
2703                                case 3:
2704                                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 107)
2705                                        kind = 107;
2706                                    break;
2707                                default : break;
2708                                }
2709                        } while(i != startsAt);
2710                    }
2711                if (kind != 0x7fffffff)
2712                    {
2713                        jjmatchedKind = kind;
2714                        jjmatchedPos = curPos;
2715                        kind = 0x7fffffff;
2716                    }
2717                ++curPos;
2718                if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
2719                    return curPos;
2720                try { curChar = input_stream.readChar(); }
2721                catch(java.io.IOException JavaDoc e) { return curPos; }
2722            }
2723    }
2724    private final int jjStopStringLiteralDfa_11(int pos, long active0, long active1)
2725    {
2726        switch (pos)
2727            {
2728            case 0:
2729                if ((active0 & 0x50000000000000L) != 0L)
2730                    {
2731                        jjmatchedKind = 55;
2732                        return 0;
2733                    }
2734                return -1;
2735            case 1:
2736                if ((active0 & 0x50000000000000L) != 0L)
2737                    {
2738                        jjmatchedKind = 55;
2739                        jjmatchedPos = 1;
2740                        return 0;
2741                    }
2742                return -1;
2743            case 2:
2744                if ((active0 & 0x40000000000000L) != 0L)
2745                    return 0;
2746                if ((active0 & 0x10000000000000L) != 0L)
2747                    {
2748                        jjmatchedKind = 55;
2749                        jjmatchedPos = 2;
2750                        return 0;
2751                    }
2752                return -1;
2753            case 3:
2754                if ((active0 & 0x10000000000000L) != 0L)
2755                    {
2756                        jjmatchedKind = 55;
2757                        jjmatchedPos = 3;
2758                        return 0;
2759                    }
2760                return -1;
2761            case 4:
2762                if ((active0 & 0x10000000000000L) != 0L)
2763                    return 0;
2764                return -1;
2765            default :
2766                return -1;
2767            }
2768    }
2769    private final int jjStartNfa_11(int pos, long active0, long active1)
2770    {
2771        return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0, active1), pos + 1);
2772    }
2773    private final int jjStartNfaWithStates_11(int pos, int kind, int state)
2774    {
2775        jjmatchedKind = kind;
2776        jjmatchedPos = pos;
2777        try { curChar = input_stream.readChar(); }
2778        catch(java.io.IOException JavaDoc e) { return pos + 1; }
2779        return jjMoveNfa_11(state, pos + 1);
2780    }
2781    private final int jjMoveStringLiteralDfa0_11()
2782    {
2783        switch(curChar)
2784            {
2785            case 35:
2786                return jjMoveStringLiteralDfa1_11(0x20000000000000L);
2787            case 37:
2788                return jjStopAtPos(0, 86);
2789            case 62:
2790                return jjStopAtPos(0, 56);
2791            case 65:
2792                return jjMoveStringLiteralDfa1_11(0x40000000000000L);
2793            case 69:
2794                return jjMoveStringLiteralDfa1_11(0x10000000000000L);
2795            default :
2796                return jjMoveNfa_11(2, 0);
2797            }
2798    }
2799    private final int jjMoveStringLiteralDfa1_11(long active0)
2800    {
2801        try { curChar = input_stream.readChar(); }
2802        catch(java.io.IOException JavaDoc e) {
2803            jjStopStringLiteralDfa_11(0, active0, 0L);
2804            return 1;
2805        }
2806        switch(curChar)
2807            {
2808            case 77:
2809                return jjMoveStringLiteralDfa2_11(active0, 0x10000000000000L);
2810            case 78:
2811                return jjMoveStringLiteralDfa2_11(active0, 0x40000000000000L);
2812            case 80:
2813                return jjMoveStringLiteralDfa2_11(active0, 0x20000000000000L);
2814            default :
2815                break;
2816            }
2817        return jjStartNfa_11(0, active0, 0L);
2818    }
2819    private final int jjMoveStringLiteralDfa2_11(long old0, long active0)
2820    {
2821        if (((active0 &= old0)) == 0L)
2822            return jjStartNfa_11(0, old0, 0L);
2823        try { curChar = input_stream.readChar(); }
2824        catch(java.io.IOException JavaDoc e) {
2825            jjStopStringLiteralDfa_11(1, active0, 0L);
2826            return 2;
2827        }
2828        switch(curChar)
2829            {
2830            case 67:
2831                return jjMoveStringLiteralDfa3_11(active0, 0x20000000000000L);
2832            case 80:
2833                return jjMoveStringLiteralDfa3_11(active0, 0x10000000000000L);
2834            case 89:
2835                if ((active0 & 0x40000000000000L) != 0L)
2836                    return jjStartNfaWithStates_11(2, 54, 0);
2837                break;
2838            default :
2839                break;
2840            }
2841        return jjStartNfa_11(1, active0, 0L);
2842    }
2843    private final int jjMoveStringLiteralDfa3_11(long old0, long active0)
2844    {
2845        if (((active0 &= old0)) == 0L)
2846            return jjStartNfa_11(1, old0, 0L);
2847        try { curChar = input_stream.readChar(); }
2848        catch(java.io.IOException JavaDoc e) {
2849            jjStopStringLiteralDfa_11(2, active0, 0L);
2850            return 3;
2851        }
2852        switch(curChar)
2853            {
2854            case 68:
2855                return jjMoveStringLiteralDfa4_11(active0, 0x20000000000000L);
2856            case 84:
2857                return jjMoveStringLiteralDfa4_11(active0, 0x10000000000000L);
2858            default :
2859                break;
2860            }
2861        return jjStartNfa_11(2, active0, 0L);
2862    }
2863    private final int jjMoveStringLiteralDfa4_11(long old0, long active0)
2864    {
2865        if (((active0 &= old0)) == 0L)
2866            return jjStartNfa_11(2, old0, 0L);
2867        try { curChar = input_stream.readChar(); }
2868        catch(java.io.IOException JavaDoc e) {
2869            jjStopStringLiteralDfa_11(3, active0, 0L);
2870            return 4;
2871        }
2872        switch(curChar)
2873            {
2874            case 65:
2875                return jjMoveStringLiteralDfa5_11(active0, 0x20000000000000L);
2876            case 89:
2877                if ((active0 & 0x10000000000000L) != 0L)
2878                    return jjStartNfaWithStates_11(4, 52, 0);
2879                break;
2880            default :
2881                break;
2882            }
2883        return jjStartNfa_11(3, active0, 0L);
2884    }
2885    private final int jjMoveStringLiteralDfa5_11(long old0, long active0)
2886    {
2887        if (((active0 &= old0)) == 0L)
2888            return jjStartNfa_11(3, old0, 0L);
2889        try { curChar = input_stream.readChar(); }
2890        catch(java.io.IOException JavaDoc e) {
2891            jjStopStringLiteralDfa_11(4, active0, 0L);
2892            return 5;
2893        }
2894        switch(curChar)
2895            {
2896            case 84:
2897                return jjMoveStringLiteralDfa6_11(active0, 0x20000000000000L);
2898            default :
2899                break;
2900            }
2901        return jjStartNfa_11(4, active0, 0L);
2902    }
2903    private final int jjMoveStringLiteralDfa6_11(long old0, long active0)
2904    {
2905        if (((active0 &= old0)) == 0L)
2906            return jjStartNfa_11(4, old0, 0L);
2907        try { curChar = input_stream.readChar(); }
2908        catch(java.io.IOException JavaDoc e) {
2909            jjStopStringLiteralDfa_11(5, active0, 0L);
2910            return 6;
2911        }
2912        switch(curChar)
2913            {
2914            case 65:
2915                if ((active0 & 0x20000000000000L) != 0L)
2916                    return jjStopAtPos(6, 53);
2917                break;
2918            default :
2919                break;
2920            }
2921        return jjStartNfa_11(5, active0, 0L);
2922    }
2923    private final int jjMoveNfa_11(int startState, int curPos)
2924    {
2925        int[] nextStates;
2926        int startsAt = 0;
2927        jjnewStateCnt = 3;
2928        int i = 1;
2929        jjstateSet[0] = startState;
2930        int j, kind = 0x7fffffff;
2931        for (;;)
2932            {
2933                if (++jjround == 0x7fffffff)
2934                    ReInitRounds();
2935                if (curChar < 64)
2936                    {
2937                        long l = 1L << curChar;
2938                    MatchLoop: do
2939                        {
2940                            switch(jjstateSet[--i])
2941                                {
2942                                case 2:
2943                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
2944                                        {
2945                                            if (kind > 55)
2946                                                kind = 55;
2947                                            jjCheckNAdd(0);
2948                                        }
2949                                    else if (curChar == 63)
2950                                        {
2951                                            if (kind > 55)
2952                                                kind = 55;
2953                                        }
2954                                    if ((0x100002600L & l) != 0L)
2955                                        {
2956                                            if (kind > 55)
2957                                                kind = 55;
2958                                            jjCheckNAdd(1);
2959                                        }
2960                                    break;
2961                                case 0:
2962                                    if ((0x7ff7f10fffff9ffL & l) == 0L)
2963                                        break;
2964                                    if (kind > 55)
2965                                        kind = 55;
2966                                    jjCheckNAdd(0);
2967                                    break;
2968                                case 1:
2969                                    if ((0x100002600L & l) == 0L)
2970                                        break;
2971                                    if (kind > 55)
2972                                        kind = 55;
2973                                    jjCheckNAdd(1);
2974                                    break;
2975                                default : break;
2976                                }
2977                        } while(i != startsAt);
2978                    }
2979                else if (curChar < 128)
2980                    {
2981                        long l = 1L << (curChar & 077);
2982                    MatchLoop: do
2983                        {
2984                            switch(jjstateSet[--i])
2985                                {
2986                                case 2:
2987                                case 0:
2988                                    if ((0xffffffffd7ffffffL & l) == 0L)
2989                                        break;
2990                                    kind = 55;
2991                                    jjCheckNAdd(0);
2992                                    break;
2993                                default : break;
2994                                }
2995                        } while(i != startsAt);
2996                    }
2997                else
2998                    {
2999                        int hiByte = (int)(curChar >> 8);
3000                        int i1 = hiByte >> 6;
3001                        long l1 = 1L << (hiByte & 077);
3002                        int i2 = (curChar & 0xff) >> 6;
3003                        long l2 = 1L << (curChar & 077);
3004                    MatchLoop: do
3005                        {
3006                            switch(jjstateSet[--i])
3007                                {
3008                                case 2:
3009                                case 0:
3010                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3011                                        break;
3012                                    if (kind > 55)
3013                                        kind = 55;
3014                                    jjCheckNAdd(0);
3015                                    break;
3016                                default : break;
3017                                }
3018                        } while(i != startsAt);
3019                    }
3020                if (kind != 0x7fffffff)
3021                    {
3022                        jjmatchedKind = kind;
3023                        jjmatchedPos = curPos;
3024                        kind = 0x7fffffff;
3025                    }
3026                ++curPos;
3027                if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
3028                    return curPos;
3029                try { curChar = input_stream.readChar(); }
3030                catch(java.io.IOException JavaDoc e) { return curPos; }
3031            }
3032    }
3033    private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
3034    {
3035        switch (pos)
3036            {
3037            default :
3038                return -1;
3039            }
3040    }
3041    private final int jjStartNfa_5(int pos, long active0, long active1)
3042    {
3043        return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
3044    }
3045    private final int jjStartNfaWithStates_5(int pos, int kind, int state)
3046    {
3047        jjmatchedKind = kind;
3048        jjmatchedPos = pos;
3049        try { curChar = input_stream.readChar(); }
3050        catch(java.io.IOException JavaDoc e) { return pos + 1; }
3051        return jjMoveNfa_5(state, pos + 1);
3052    }
3053    private final int jjMoveStringLiteralDfa0_5()
3054    {
3055        switch(curChar)
3056            {
3057            case 38:
3058                return jjStopAtPos(0, 89);
3059            case 39:
3060                return jjStopAtPos(0, 98);
3061            default :
3062                return jjMoveNfa_5(0, 0);
3063            }
3064    }
3065    private final int jjMoveNfa_5(int startState, int curPos)
3066    {
3067        int[] nextStates;
3068        int startsAt = 0;
3069        jjnewStateCnt = 1;
3070        int i = 1;
3071        jjstateSet[0] = startState;
3072        int j, kind = 0x7fffffff;
3073        for (;;)
3074            {
3075                if (++jjround == 0x7fffffff)
3076                    ReInitRounds();
3077                if (curChar < 64)
3078                    {
3079                        long l = 1L << curChar;
3080                    MatchLoop: do
3081                        {
3082                            switch(jjstateSet[--i])
3083                                {
3084                                case 0:
3085                                    if ((0xffffff3fffffffffL & l) == 0L)
3086                                        break;
3087                                    kind = 97;
3088                                    jjstateSet[jjnewStateCnt++] = 0;
3089                                    break;
3090                                default : break;
3091                                }
3092                        } while(i != startsAt);
3093                    }
3094                else if (curChar < 128)
3095                    {
3096                        long l = 1L << (curChar & 077);
3097                    MatchLoop: do
3098                        {
3099                            switch(jjstateSet[--i])
3100                                {
3101                                case 0:
3102                                    kind = 97;
3103                                    jjstateSet[jjnewStateCnt++] = 0;
3104                                    break;
3105                                default : break;
3106                                }
3107                        } while(i != startsAt);
3108                    }
3109                else
3110                    {
3111                        int hiByte = (int)(curChar >> 8);
3112                        int i1 = hiByte >> 6;
3113                        long l1 = 1L << (hiByte & 077);
3114                        int i2 = (curChar & 0xff) >> 6;
3115                        long l2 = 1L << (curChar & 077);
3116                    MatchLoop: do
3117                        {
3118                            switch(jjstateSet[--i])
3119                                {
3120                                case 0:
3121                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3122                                        break;
3123                                    if (kind > 97)
3124                                        kind = 97;
3125                                    jjstateSet[jjnewStateCnt++] = 0;
3126                                    break;
3127                                default : break;
3128                                }
3129                        } while(i != startsAt);
3130                    }
3131                if (kind != 0x7fffffff)
3132                    {
3133                        jjmatchedKind = kind;
3134                        jjmatchedPos = curPos;
3135                        kind = 0x7fffffff;
3136                    }
3137                ++curPos;
3138                if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
3139                    return curPos;
3140                try { curChar = input_stream.readChar(); }
3141                catch(java.io.IOException JavaDoc e) { return curPos; }
3142            }
3143    }
3144    private final int jjMoveStringLiteralDfa0_6()
3145    {
3146        return jjMoveNfa_6(1, 0);
3147    }
3148    private final int jjMoveNfa_6(int startState, int curPos)
3149    {
3150        int[] nextStates;
3151        int startsAt = 0;
3152        jjnewStateCnt = 3;
3153        int i = 1;
3154        jjstateSet[0] = startState;
3155        int j, kind = 0x7fffffff;
3156        for (;;)
3157            {
3158                if (++jjround == 0x7fffffff)
3159                    ReInitRounds();
3160                if (curChar < 64)
3161                    {
3162                        long l = 1L << curChar;
3163                    MatchLoop: do
3164                        {
3165                            switch(jjstateSet[--i])
3166                                {
3167                                case 1:
3168                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
3169                                        {
3170                                            if (kind > 87)
3171                                                kind = 87;
3172                                            jjCheckNAdd(0);
3173                                        }
3174                                    else if (curChar == 59)
3175                                        {
3176                                            if (kind > 88)
3177                                                kind = 88;
3178                                        }
3179                                    if ((0x100002600L & l) != 0L)
3180                                        {
3181                                            if (kind > 88)
3182                                                kind = 88;
3183                                            jjCheckNAdd(2);
3184                                        }
3185                                    break;
3186                                case 0:
3187                                    if ((0x7ff7f10fffff9ffL & l) == 0L)
3188                                        break;
3189                                    if (kind > 87)
3190                                        kind = 87;
3191                                    jjCheckNAdd(0);
3192                                    break;
3193                                case 2:
3194                                    if ((0x100002600L & l) == 0L)
3195                                        break;
3196                                    if (kind > 88)
3197                                        kind = 88;
3198                                    jjCheckNAdd(2);
3199                                    break;
3200                                default : break;
3201                                }
3202                        } while(i != startsAt);
3203                    }
3204                else if (curChar < 128)
3205                    {
3206                        long l = 1L << (curChar & 077);
3207                    MatchLoop: do
3208                        {
3209                            switch(jjstateSet[--i])
3210                                {
3211                                case 1:
3212                                case 0:
3213                                    if ((0xffffffffd7ffffffL & l) == 0L)
3214                                        break;
3215                                    kind = 87;
3216                                    jjCheckNAdd(0);
3217                                    break;
3218                                default : break;
3219                                }
3220                        } while(i != startsAt);
3221                    }
3222                else
3223                    {
3224                        int hiByte = (int)(curChar >> 8);
3225                        int i1 = hiByte >> 6;
3226                        long l1 = 1L << (hiByte & 077);
3227                        int i2 = (curChar & 0xff) >> 6;
3228                        long l2 = 1L << (curChar & 077);
3229                    MatchLoop: do
3230                        {
3231                            switch(jjstateSet[--i])
3232                                {
3233                                case 1:
3234                                case 0:
3235                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3236                                        break;
3237                                    if (kind > 87)
3238                                        kind = 87;
3239                                    jjCheckNAdd(0);
3240                                    break;
3241                                default : break;
3242                                }
3243                        } while(i != startsAt);
3244                    }
3245                if (kind != 0x7fffffff)
3246                    {
3247                        jjmatchedKind = kind;
3248                        jjmatchedPos = curPos;
3249                        kind = 0x7fffffff;
3250                    }
3251                ++curPos;
3252                if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
3253                    return curPos;
3254                try { curChar = input_stream.readChar(); }
3255                catch(java.io.IOException JavaDoc e) { return curPos; }
3256            }
3257    }
3258    private final int jjStopStringLiteralDfa_14(int pos, long active0)
3259    {
3260        switch (pos)
3261            {
3262            case 0:
3263                if ((active0 & 0x800000000L) != 0L)
3264                    return 2;
3265                return -1;
3266            case 1:
3267                if ((active0 & 0x800000000L) != 0L)
3268                    return 4;
3269                return -1;
3270            default :
3271                return -1;
3272            }
3273    }
3274    private final int jjStartNfa_14(int pos, long active0)
3275    {
3276        return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0), pos + 1);
3277    }
3278    private final int jjStartNfaWithStates_14(int pos, int kind, int state)
3279    {
3280        jjmatchedKind = kind;
3281        jjmatchedPos = pos;
3282        try { curChar = input_stream.readChar(); }
3283        catch(java.io.IOException JavaDoc e) { return pos + 1; }
3284        return jjMoveNfa_14(state, pos + 1);
3285    }
3286    private final int jjMoveStringLiteralDfa0_14()
3287    {
3288        switch(curChar)
3289            {
3290            case 93:
3291                return jjMoveStringLiteralDfa1_14(0x800000000L);
3292            default :
3293                return jjMoveNfa_14(6, 0);
3294            }
3295    }
3296    private final int jjMoveStringLiteralDfa1_14(long active0)
3297    {
3298        try { curChar = input_stream.readChar(); }
3299        catch(java.io.IOException JavaDoc e) {
3300            jjStopStringLiteralDfa_14(0, active0);
3301            return 1;
3302        }
3303        switch(curChar)
3304            {
3305            case 93:
3306                return jjMoveStringLiteralDfa2_14(active0, 0x800000000L);
3307            default :
3308                break;
3309            }
3310        return jjStartNfa_14(0, active0);
3311    }
3312    private final int jjMoveStringLiteralDfa2_14(long old0, long active0)
3313    {
3314        if (((active0 &= old0)) == 0L)
3315            return jjStartNfa_14(0, old0);
3316        try { curChar = input_stream.readChar(); }
3317        catch(java.io.IOException JavaDoc e) {
3318            jjStopStringLiteralDfa_14(1, active0);
3319            return 2;
3320        }
3321        switch(curChar)
3322            {
3323            case 62:
3324                if ((active0 & 0x800000000L) != 0L)
3325                    return jjStopAtPos(2, 35);
3326                break;
3327            default :
3328                break;
3329            }
3330        return jjStartNfa_14(1, active0);
3331    }
3332    private final int jjMoveNfa_14(int startState, int curPos)
3333    {
3334        int[] nextStates;
3335        int startsAt = 0;
3336        jjnewStateCnt = 16;
3337        int i = 1;
3338        jjstateSet[0] = startState;
3339        int j, kind = 0x7fffffff;
3340        for (;;)
3341            {
3342                if (++jjround == 0x7fffffff)
3343                    ReInitRounds();
3344                if (curChar < 64)
3345                    {
3346                        long l = 1L << curChar;
3347                    MatchLoop: do
3348                        {
3349                            switch(jjstateSet[--i])
3350                                {
3351                                case 2:
3352                                    if (kind > 36)
3353                                        kind = 36;
3354                                    jjCheckNAddStates(0, 2);
3355                                    break;
3356                                case 6:
3357                                    if ((0xefffffffffffffffL & l) != 0L)
3358                                        {
3359                                            if (kind > 36)
3360                                                kind = 36;
3361                                            jjCheckNAddStates(0, 2);
3362                                        }
3363                                    else if (curChar == 60)
3364                                        {
3365                                            if (kind > 36)
3366                                                kind = 36;
3367                                            jjCheckNAddTwoStates(7, 8);
3368                                        }
3369                                    break;
3370                                case 0:
3371                                    if ((0xefffffffffffffffL & l) == 0L)
3372                                        break;
3373                                    if (kind > 36)
3374                                        kind = 36;
3375                                    jjCheckNAddStates(0, 2);
3376                                    break;
3377                                case 4:
3378                                    if ((0xbfffffffffffffffL & l) == 0L)
3379                                        break;
3380                                    if (kind > 36)
3381                                        kind = 36;
3382                                    jjCheckNAddStates(0, 2);
3383                                    break;
3384                                case 7:
3385                                    if ((0x800200000000L & l) != 0L)
3386                                        jjCheckNAdd(8);
3387                                    break;
3388                                case 8:
3389                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
3390                                        jjCheckNAddStates(3, 7);
3391                                    break;
3392                                case 9:
3393                                    if ((0xefffffffffffffffL & l) != 0L)
3394                                        jjCheckNAddStates(8, 11);
3395                                    break;
3396                                case 11:
3397                                    jjCheckNAddStates(8, 11);
3398                                    break;
3399                                case 13:
3400                                    if ((0xbfffffffffffffffL & l) != 0L)
3401                                        jjCheckNAddStates(8, 11);
3402                                    break;
3403                                case 15:
3404                                    if (curChar == 62 && kind > 37)
3405                                        kind = 37;
3406                                    break;
3407                                default : break;
3408                                }
3409                        } while(i != startsAt);
3410                    }
3411                else if (curChar < 128)
3412                    {
3413                        long l = 1L << (curChar & 077);
3414                    MatchLoop: do
3415                        {
3416                            switch(jjstateSet[--i])
3417                                {
3418                                case 2:
3419                                    if ((0xffffffffdfffffffL & l) != 0L)
3420                                        {
3421                                            if (kind > 36)
3422                                                kind = 36;
3423                                            jjCheckNAddStates(0, 2);
3424                                        }
3425                                    else if (curChar == 93)
3426                                        jjstateSet[jjnewStateCnt++] = 4;
3427                                    break;
3428                                case 6:
3429                                    if ((0xffffffffdfffffffL & l) != 0L)
3430                                        {
3431                                            if (kind > 36)
3432                                                kind = 36;
3433                                            jjCheckNAddStates(0, 2);
3434                                        }
3435                                    else if (curChar == 93)
3436                                        jjstateSet[jjnewStateCnt++] = 3;
3437                                    if (curChar == 93)
3438                                        jjstateSet[jjnewStateCnt++] = 2;
3439                                    break;
3440                                case 0:
3441                                    if ((0xffffffffdfffffffL & l) == 0L)
3442                                        break;
3443                                    if (kind > 36)
3444                                        kind = 36;
3445                                    jjCheckNAddStates(0, 2);
3446                                    break;
3447                                case 1:
3448                                    if (curChar == 93)
3449                                        jjstateSet[jjnewStateCnt++] = 2;
3450                                    break;
3451                                case 3:
3452                                    if (curChar == 93)
3453                                        jjstateSet[jjnewStateCnt++] = 4;
3454                                    break;
3455                                case 4:
3456                                    if (kind > 36)
3457                                        kind = 36;
3458                                    jjCheckNAddStates(0, 2);
3459                                    break;
3460                                case 5:
3461                                    if (curChar == 93)
3462                                        jjstateSet[jjnewStateCnt++] = 3;
3463                                    break;
3464                                case 8:
3465                                    if ((0xffffffffd7ffffffL & l) != 0L)
3466                                        jjCheckNAddStates(3, 7);
3467                                    break;
3468                                case 9:
3469                                case 11:
3470                                    if ((0xffffffffdfffffffL & l) != 0L)
3471                                        jjCheckNAddStates(8, 11);
3472                                    break;
3473                                case 10:
3474                                    if (curChar == 93)
3475                                        jjstateSet[jjnewStateCnt++] = 11;
3476                                    break;
3477                                case 12:
3478                                    if (curChar == 93)
3479                                        jjstateSet[jjnewStateCnt++] = 13;
3480                                    break;
3481                                case 13:
3482                                    jjCheckNAddStates(8, 11);
3483                                    break;
3484                                case 14:
3485                                    if (curChar == 93)
3486                                        jjstateSet[jjnewStateCnt++] = 12;
3487                                    break;
3488                                default : break;
3489                                }
3490                        } while(i != startsAt);
3491                    }
3492                else
3493                    {
3494                        int hiByte = (int)(curChar >> 8);
3495                        int i1 = hiByte >> 6;
3496                        long l1 = 1L << (hiByte & 077);
3497                        int i2 = (curChar & 0xff) >> 6;
3498                        long l2 = 1L << (curChar & 077);
3499                    MatchLoop: do
3500                        {
3501                            switch(jjstateSet[--i])
3502                                {
3503                                case 2:
3504                                case 4:
3505                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3506                                        break;
3507                                    if (kind > 36)
3508                                        kind = 36;
3509                                    jjCheckNAddStates(0, 2);
3510                                    break;
3511                                case 6:
3512                                case 0:
3513                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3514                                        break;
3515                                    if (kind > 36)
3516                                        kind = 36;
3517                                    jjCheckNAddStates(0, 2);
3518                                    break;
3519                                case 8:
3520                                    if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3521                                        jjCheckNAddStates(3, 7);
3522                                    break;
3523                                case 9:
3524                                case 11:
3525                                case 13:
3526                                    if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3527                                        jjCheckNAddStates(8, 11);
3528                                    break;
3529                                default : break;
3530                                }
3531                        } while(i != startsAt);
3532                    }
3533                if (kind != 0x7fffffff)
3534                    {
3535                        jjmatchedKind = kind;
3536                        jjmatchedPos = curPos;
3537                        kind = 0x7fffffff;
3538                    }
3539                ++curPos;
3540                if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
3541                    return curPos;
3542                try { curChar = input_stream.readChar(); }
3543                catch(java.io.IOException JavaDoc e) { return curPos; }
3544            }
3545    }
3546    private final int jjStopStringLiteralDfa_15(int pos, long active0)
3547    {
3548        switch (pos)
3549            {
3550            default :
3551                return -1;
3552            }
3553    }
3554    private final int jjStartNfa_15(int pos, long active0)
3555    {
3556        return jjMoveNfa_15(jjStopStringLiteralDfa_15(pos, active0), pos + 1);
3557    }
3558    private final int jjStartNfaWithStates_15(int pos, int kind, int state)
3559    {
3560        jjmatchedKind = kind;
3561        jjmatchedPos = pos;
3562        try { curChar = input_stream.readChar(); }
3563        catch(java.io.IOException JavaDoc e) { return pos + 1; }
3564        return jjMoveNfa_15(state, pos + 1);
3565    }
3566    private final int jjMoveStringLiteralDfa0_15()
3567    {
3568        switch(curChar)
3569            {
3570            case 63:
3571                jjmatchedKind = 34;
3572                return jjMoveStringLiteralDfa1_15(0x200000000L);
3573            default :
3574                return jjMoveNfa_15(6, 0);
3575            }
3576    }
3577    private final int jjMoveStringLiteralDfa1_15(long active0)
3578    {
3579        try { curChar = input_stream.readChar(); }
3580        catch(java.io.IOException JavaDoc e) {
3581            jjStopStringLiteralDfa_15(0, active0);
3582            return 1;
3583        }
3584        switch(curChar)
3585            {
3586            case 62:
3587                if ((active0 & 0x200000000L) != 0L)
3588                    return jjStopAtPos(1, 33);
3589                break;
3590            default :
3591                break;
3592            }
3593        return jjStartNfa_15(0, active0);
3594    }
3595    private final int jjMoveNfa_15(int startState, int curPos)
3596    {
3597        int[] nextStates;
3598        int startsAt = 0;
3599        jjnewStateCnt = 27;
3600        int i = 1;
3601        jjstateSet[0] = startState;
3602        int j, kind = 0x7fffffff;
3603        for (;;)
3604            {
3605                if (++jjround == 0x7fffffff)
3606                    ReInitRounds();
3607                if (curChar < 64)
3608                    {
3609                        long l = 1L << curChar;
3610                    MatchLoop: do
3611                        {
3612                            switch(jjstateSet[--i])
3613                                {
3614                                case 6:
3615                                    if ((0x5ffffffefffff9ffL & l) != 0L)
3616                                        {
3617                                            if (kind > 31)
3618                                                kind = 31;
3619                                            jjCheckNAdd(25);
3620                                        }
3621                                    else if ((0x2000000100000600L & l) != 0L)
3622                                        {
3623                                            if (kind > 32)
3624                                                kind = 32;
3625                                            jjCheckNAdd(26);
3626                                        }
3627                                    break;
3628                                case 25:
3629                                    if ((0x5ffffffefffff9ffL & l) == 0L)
3630                                        break;
3631                                    kind = 31;
3632                                    jjCheckNAdd(25);
3633                                    break;
3634                                case 26:
3635                                    if ((0x2000000100000600L & l) == 0L)
3636                                        break;
3637                                    kind = 32;
3638                                    jjCheckNAdd(26);
3639                                    break;
3640                                default : break;
3641                                }
3642                        } while(i != startsAt);
3643                    }
3644                else if (curChar < 128)
3645                    {
3646                        long l = 1L << (curChar & 077);
3647                    MatchLoop: do
3648                        {
3649                            switch(jjstateSet[--i])
3650                                {
3651                                case 6:
3652                                    if (kind > 31)
3653                                        kind = 31;
3654                                    jjCheckNAdd(25);
3655                                    if (curChar == 115)
3656                                        jjstateSet[jjnewStateCnt++] = 23;
3657                                    else if (curChar == 101)
3658                                        jjstateSet[jjnewStateCnt++] = 13;
3659                                    else if (curChar == 118)
3660                                        jjstateSet[jjnewStateCnt++] = 5;
3661                                    break;
3662                                case 0:
3663                                    if (curChar == 110 && kind > 30)
3664                                        kind = 30;
3665                                    break;
3666                                case 1:
3667                                    if (curChar == 111)
3668                                        jjstateSet[jjnewStateCnt++] = 0;
3669                                    break;
3670                                case 2:
3671                                    if (curChar == 105)
3672                                        jjstateSet[jjnewStateCnt++] = 1;
3673                                    break;
3674                                case 3:
3675                                    if (curChar == 115)
3676                                        jjstateSet[jjnewStateCnt++] = 2;
3677                                    break;
3678                                case 4:
3679                                    if (curChar == 114)
3680                                        jjstateSet[jjnewStateCnt++] = 3;
3681                                    break;
3682                                case 5:
3683                                    if (curChar == 101)
3684                                        jjstateSet[jjnewStateCnt++] = 4;
3685                                    break;
3686                                case 7:
3687                                    if (curChar == 103 && kind > 30)
3688                                        kind = 30;
3689                                    break;
3690                                case 8:
3691                                    if (curChar == 110)
3692                                        jjstateSet[jjnewStateCnt++] = 7;
3693                                    break;
3694                                case 9:
3695                                    if (curChar == 105)
3696                                        jjstateSet[jjnewStateCnt++] = 8;
3697                                    break;
3698                                case 10:
3699                                    if (curChar == 100)
3700                                        jjstateSet[jjnewStateCnt++] = 9;
3701                                    break;
3702                                case 11:
3703                                    if (curChar == 111)
3704                                        jjstateSet[jjnewStateCnt++] = 10;
3705                                    break;
3706                                case 12:
3707                                    if (curChar == 99)
3708                                        jjstateSet[jjnewStateCnt++] = 11;
3709                                    break;
3710                                case 13:
3711                                    if (curChar == 110)
3712                                        jjstateSet[jjnewStateCnt++] = 12;
3713                                    break;
3714                                case 14:
3715                                    if (curChar == 101)
3716                                        jjstateSet[jjnewStateCnt++] = 13;
3717                                    break;
3718                                case 15:
3719                                    if (curChar == 101 && kind > 30)
3720                                        kind = 30;
3721                                    break;
3722                                case 16:
3723                                    if (curChar == 110)
3724                                        jjstateSet[jjnewStateCnt++] = 15;
3725                                    break;
3726                                case 17:
3727                                    if (curChar == 111)
3728                                        jjstateSet[jjnewStateCnt++] = 16;
3729                                    break;
3730                                case 18:
3731                                    if (curChar == 108)
3732                                        jjstateSet[jjnewStateCnt++] = 17;
3733                                    break;
3734                                case 19:
3735                                    if (curChar == 97)
3736                                        jjstateSet[jjnewStateCnt++] = 18;
3737                                    break;
3738                                case 20:
3739                                    if (curChar == 100)
3740                                        jjstateSet[jjnewStateCnt++] = 19;
3741                                    break;
3742                                case 21:
3743                                    if (curChar == 110)
3744                                        jjstateSet[jjnewStateCnt++] = 20;
3745                                    break;
3746                                case 22:
3747                                    if (curChar == 97)
3748                                        jjstateSet[jjnewStateCnt++] = 21;
3749                                    break;
3750                                case 23:
3751                                    if (curChar == 116)
3752                                        jjstateSet[jjnewStateCnt++] = 22;
3753                                    break;
3754                                case 24:
3755                                    if (curChar == 115)
3756                                        jjstateSet[jjnewStateCnt++] = 23;
3757                                    break;
3758                                case 25:
3759                                    if (kind > 31)
3760                                        kind = 31;
3761                                    jjCheckNAdd(25);
3762                                    break;
3763                                default : break;
3764                                }
3765                        } while(i != startsAt);
3766                    }
3767                else
3768                    {
3769                        int hiByte = (int)(curChar >> 8);
3770                        int i1 = hiByte >> 6;
3771                        long l1 = 1L << (hiByte & 077);
3772                        int i2 = (curChar & 0xff) >> 6;
3773                        long l2 = 1L << (curChar & 077);
3774                    MatchLoop: do
3775                        {
3776                            switch(jjstateSet[--i])
3777                                {
3778                                case 6:
3779                                case 25:
3780                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3781                                        break;
3782                                    if (kind > 31)
3783                                        kind = 31;
3784                                    jjCheckNAdd(25);
3785                                    break;
3786                                default : break;
3787                                }
3788                        } while(i != startsAt);
3789                    }
3790                if (kind != 0x7fffffff)
3791                    {
3792                        jjmatchedKind = kind;
3793                        jjmatchedPos = curPos;
3794                        kind = 0x7fffffff;
3795                    }
3796                ++curPos;
3797                if ((i = jjnewStateCnt) == (startsAt = 27 - (jjnewStateCnt = startsAt)))
3798                    return curPos;
3799                try { curChar = input_stream.readChar(); }
3800                catch(java.io.IOException JavaDoc e) { return curPos; }
3801            }
3802    }
3803    private final int jjStopStringLiteralDfa_10(int pos, long active0, long active1)
3804    {
3805        switch (pos)
3806            {
3807            default :
3808                return -1;
3809            }
3810    }
3811    private final int jjStartNfa_10(int pos, long active0, long active1)
3812    {
3813        return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1);
3814    }
3815    private final int jjStartNfaWithStates_10(int pos, int kind, int state)
3816    {
3817        jjmatchedKind = kind;
3818        jjmatchedPos = pos;
3819        try { curChar = input_stream.readChar(); }
3820        catch(java.io.IOException JavaDoc e) { return pos + 1; }
3821        return jjMoveNfa_10(state, pos + 1);
3822    }
3823    private final int jjMoveStringLiteralDfa0_10()
3824    {
3825        switch(curChar)
3826            {
3827            case 34:
3828                return jjStopAtPos(0, 99);
3829            case 39:
3830                return jjStopAtPos(0, 93);
3831            case 60:
3832                return jjStopAtPos(0, 59);
3833            case 62:
3834                return jjStopAtPos(0, 60);
3835            default :
3836                return jjMoveNfa_10(5, 0);
3837            }
3838    }
3839    private final int jjMoveNfa_10(int startState, int curPos)
3840    {
3841        int[] nextStates;
3842        int startsAt = 0;
3843        jjnewStateCnt = 14;
3844        int i = 1;
3845        jjstateSet[0] = startState;
3846        int j, kind = 0x7fffffff;
3847        for (;;)
3848            {
3849                if (++jjround == 0x7fffffff)
3850                    ReInitRounds();
3851                if (curChar < 64)
3852                    {
3853                        long l = 1L << curChar;
3854                    MatchLoop: do
3855                        {
3856                            switch(jjstateSet[--i])
3857                                {
3858                                case 5:
3859                                    if ((0xafffff7afffff9ffL & l) != 0L)
3860                                        {
3861                                            if (kind > 58)
3862                                                kind = 58;
3863                                            jjCheckNAdd(12);
3864                                        }
3865                                    if ((0x100002600L & l) != 0L)
3866                                        {
3867                                            if (kind > 58)
3868                                                kind = 58;
3869                                            jjCheckNAdd(13);
3870                                        }
3871                                    break;
3872                                case 12:
3873                                    if ((0xafffff7afffff9ffL & l) == 0L)
3874                                        break;
3875                                    if (kind > 58)
3876                                        kind = 58;
3877                                    jjCheckNAdd(12);
3878                                    break;
3879                                case 13:
3880                                    if ((0x100002600L & l) == 0L)
3881                                        break;
3882                                    if (kind > 58)
3883                                        kind = 58;
3884                                    jjCheckNAdd(13);
3885                                    break;
3886                                default : break;
3887                                }
3888                        } while(i != startsAt);
3889                    }
3890                else if (curChar < 128)
3891                    {
3892                        long l = 1L << (curChar & 077);
3893                    MatchLoop: do
3894                        {
3895                            switch(jjstateSet[--i])
3896                                {
3897                                case 5:
3898                                    if (kind > 58)
3899                                        kind = 58;
3900                                    jjCheckNAdd(12);
3901                                    if (curChar == 80)
3902                                        jjstateSet[jjnewStateCnt++] = 10;
3903                                    else if (curChar == 83)
3904                                        jjstateSet[jjnewStateCnt++] = 4;
3905                                    break;
3906                                case 0:
3907                                    if (curChar == 77 && kind > 57)
3908                                        kind = 57;
3909                                    break;
3910                                case 1:
3911                                    if (curChar == 69)
3912                                        jjstateSet[jjnewStateCnt++] = 0;
3913                                    break;
3914                                case 2:
3915                                    if (curChar == 84)
3916                                        jjstateSet[jjnewStateCnt++] = 1;
3917                                    break;
3918                                case 3:
3919                                    if (curChar == 83)
3920                                        jjstateSet[jjnewStateCnt++] = 2;
3921                                    break;
3922                                case 4:
3923                                    if (curChar == 89)
3924                                        jjstateSet[jjnewStateCnt++] = 3;
3925                                    break;
3926                                case 6:
3927                                    if (curChar == 67 && kind > 57)
3928                                        kind = 57;
3929                                    break;
3930                                case 7:
3931                                    if (curChar == 73)
3932                                        jjstateSet[jjnewStateCnt++] = 6;
3933                                    break;
3934                                case 8:
3935                                    if (curChar == 76)
3936                                        jjstateSet[jjnewStateCnt++] = 7;
3937                                    break;
3938                                case 9:
3939                                    if (curChar == 66)
3940                                        jjstateSet[jjnewStateCnt++] = 8;
3941                                    break;
3942                                case 10:
3943                                    if (curChar == 85)
3944                                        jjstateSet[jjnewStateCnt++] = 9;
3945                                    break;
3946                                case 11:
3947                                    if (curChar == 80)
3948                                        jjstateSet[jjnewStateCnt++] = 10;
3949                                    break;
3950                                case 12:
3951                                    if (kind > 58)
3952                                        kind = 58;
3953                                    jjCheckNAdd(12);
3954                                    break;
3955                                default : break;
3956                                }
3957                        } while(i != startsAt);
3958                    }
3959                else
3960                    {
3961                        int hiByte = (int)(curChar >> 8);
3962                        int i1 = hiByte >> 6;
3963                        long l1 = 1L << (hiByte & 077);
3964                        int i2 = (curChar & 0xff) >> 6;
3965                        long l2 = 1L << (curChar & 077);
3966                    MatchLoop: do
3967                        {
3968                            switch(jjstateSet[--i])
3969                                {
3970                                case 5:
3971                                case 12:
3972                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3973                                        break;
3974                                    if (kind > 58)
3975                                        kind = 58;
3976                                    jjCheckNAdd(12);
3977                                    break;
3978                                default : break;
3979                                }
3980                        } while(i != startsAt);
3981                    }
3982                if (kind != 0x7fffffff)
3983                    {
3984                        jjmatchedKind = kind;
3985                        jjmatchedPos = curPos;
3986                        kind = 0x7fffffff;
3987                    }
3988                ++curPos;
3989                if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt)))
3990                    return curPos;
3991                try { curChar = input_stream.readChar(); }
3992                catch(java.io.IOException JavaDoc e) { return curPos; }
3993            }
3994    }
3995    private final int jjStopStringLiteralDfa_13(int pos, long active0)
3996    {
3997        switch (pos)
3998            {
3999            case 0:
4000                if ((active0 & 0xf8000000000L) != 0L)
4001                    {
4002                        jjmatchedKind = 44;
4003                        return 0;
4004                    }
4005                return -1;
4006            case 1:
4007                if ((active0 & 0xf8000000000L) != 0L)
4008                    {
4009                        jjmatchedKind = 44;
4010                        jjmatchedPos = 1;
4011                        return 0;
4012                    }
4013                return -1;
4014            case 2:
4015                if ((active0 & 0xf8000000000L) != 0L)
4016                    {
4017                        jjmatchedKind = 44;
4018                        jjmatchedPos = 2;
4019                        return 0;
4020                    }
4021                return -1;
4022            case 3:
4023                if ((active0 & 0xf8000000000L) != 0L)
4024                    {
4025                        jjmatchedKind = 44;
4026                        jjmatchedPos = 3;
4027                        return 0;
4028                    }
4029                return -1;
4030            case 4:
4031                if ((active0 & 0xf8000000000L) != 0L)
4032                    {
4033                        jjmatchedKind = 44;
4034                        jjmatchedPos = 4;
4035                        return 0;
4036                    }
4037                return -1;
4038            case 5:
4039                if ((active0 & 0x8000000000L) != 0L)
4040                    return 0;
4041                if ((active0 & 0xf0000000000L) != 0L)
4042                    {
4043                        jjmatchedKind = 44;
4044                        jjmatchedPos = 5;
4045                        return 0;
4046                    }
4047                return -1;
4048            case 6:
4049                if ((active0 & 0x70000000000L) != 0L)
4050                    return 0;
4051                if ((active0 & 0x80000000000L) != 0L)
4052                    {
4053                        jjmatchedKind = 44;
4054                        jjmatchedPos = 6;
4055                        return 0;
4056                    }
4057                return -1;
4058            default :
4059                return -1;
4060            }
4061    }
4062    private final int jjStartNfa_13(int pos, long active0)
4063    {
4064        return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0), pos + 1);
4065    }
4066    private final int jjStartNfaWithStates_13(int pos, int kind, int state)
4067    {
4068        jjmatchedKind = kind;
4069        jjmatchedPos = pos;
4070        try { curChar = input_stream.readChar(); }
4071        catch(java.io.IOException JavaDoc e) { return pos + 1; }
4072        return jjMoveNfa_13(state, pos + 1);
4073    }
4074    private final int jjMoveStringLiteralDfa0_13()
4075    {
4076        switch(curChar)
4077            {
4078            case 62:
4079                return jjStopAtPos(0, 48);
4080            case 65:
4081                return jjMoveStringLiteralDfa1_13(0x10000000000L);
4082            case 68:
4083                return jjMoveStringLiteralDfa1_13(0x20000000000L);
4084            case 69:
4085                return jjMoveStringLiteralDfa1_13(0x48000000000L);
4086            case 78:
4087                return jjMoveStringLiteralDfa1_13(0x80000000000L);
4088            case 91:
4089                return jjStopAtPos(0, 47);
4090            default :
4091                return jjMoveNfa_13(3, 0);
4092            }
4093    }
4094    private final int jjMoveStringLiteralDfa1_13(long active0)
4095    {
4096        try { curChar = input_stream.readChar(); }
4097        catch(java.io.IOException JavaDoc e) {
4098            jjStopStringLiteralDfa_13(0, active0);
4099            return 1;
4100        }
4101        switch(curChar)
4102            {
4103            case 76:
4104                return jjMoveStringLiteralDfa2_13(active0, 0x40000000000L);
4105            case 78:
4106                return jjMoveStringLiteralDfa2_13(active0, 0x8000000000L);
4107            case 79:
4108                return jjMoveStringLiteralDfa2_13(active0, 0xa0000000000L);
4109            case 84:
4110                return jjMoveStringLiteralDfa2_13(active0, 0x10000000000L);
4111            default :
4112                break;
4113            }
4114        return jjStartNfa_13(0, active0);
4115    }
4116    private final int jjMoveStringLiteralDfa2_13(long old0, long active0)
4117    {
4118        if (((active0 &= old0)) == 0L)
4119            return jjStartNfa_13(0, old0);
4120        try { curChar = input_stream.readChar(); }
4121        catch(java.io.IOException JavaDoc e) {
4122            jjStopStringLiteralDfa_13(1, active0);
4123            return 2;
4124        }
4125        switch(curChar)
4126            {
4127            case 67:
4128                return jjMoveStringLiteralDfa3_13(active0, 0x20000000000L);
4129            case 69:
4130                return jjMoveStringLiteralDfa3_13(active0, 0x40000000000L);
4131            case 84:
4132                return jjMoveStringLiteralDfa3_13(active0, 0x98000000000L);
4133            default :
4134                break;
4135            }
4136        return jjStartNfa_13(1, active0);
4137    }
4138    private final int jjMoveStringLiteralDfa3_13(long old0, long active0)
4139    {
4140        if (((active0 &= old0)) == 0L)
4141            return jjStartNfa_13(1, old0);
4142        try { curChar = input_stream.readChar(); }
4143        catch(java.io.IOException JavaDoc e) {
4144            jjStopStringLiteralDfa_13(2, active0);
4145            return 3;
4146        }
4147        switch(curChar)
4148            {
4149            case 65:
4150                return jjMoveStringLiteralDfa4_13(active0, 0x80000000000L);
4151            case 73:
4152                return jjMoveStringLiteralDfa4_13(active0, 0x8000000000L);
4153            case 76:
4154                return jjMoveStringLiteralDfa4_13(active0, 0x10000000000L);
4155            case 77:
4156                return jjMoveStringLiteralDfa4_13(active0, 0x40000000000L);
4157            case 84:
4158                return jjMoveStringLiteralDfa4_13(active0, 0x20000000000L);
4159            default :
4160                break;
4161            }
4162        return jjStartNfa_13(2, active0);
4163    }
4164    private final int jjMoveStringLiteralDfa4_13(long old0, long active0)
4165    {
4166        if (((active0 &= old0)) == 0L)
4167            return jjStartNfa_13(2, old0);
4168        try { curChar = input_stream.readChar(); }
4169        catch(java.io.IOException JavaDoc e) {
4170            jjStopStringLiteralDfa_13(3, active0);
4171            return 4;
4172        }
4173        switch(curChar)
4174            {
4175            case 69:
4176                return jjMoveStringLiteralDfa5_13(active0, 0x40000000000L);
4177            case 73:
4178                return jjMoveStringLiteralDfa5_13(active0, 0x10000000000L);
4179            case 84:
4180                return jjMoveStringLiteralDfa5_13(active0, 0x88000000000L);
4181            case 89:
4182                return jjMoveStringLiteralDfa5_13(active0, 0x20000000000L);
4183            default :
4184                break;
4185            }
4186        return jjStartNfa_13(3, active0);
4187    }
4188    private final int jjMoveStringLiteralDfa5_13(long old0, long active0)
4189    {
4190        if (((active0 &= old0)) == 0L)
4191            return jjStartNfa_13(3, old0);
4192        try { curChar = input_stream.readChar(); }
4193        catch(java.io.IOException JavaDoc e) {
4194            jjStopStringLiteralDfa_13(4, active0);
4195            return 5;
4196        }
4197        switch(curChar)
4198            {
4199            case 73:
4200                return jjMoveStringLiteralDfa6_13(active0, 0x80000000000L);
4201            case 78:
4202                return jjMoveStringLiteralDfa6_13(active0, 0x40000000000L);
4203            case 80:
4204                return jjMoveStringLiteralDfa6_13(active0, 0x20000000000L);
4205            case 83:
4206                return jjMoveStringLiteralDfa6_13(active0, 0x10000000000L);
4207            case 89:
4208                if ((active0 & 0x8000000000L) != 0L)
4209                    return jjStartNfaWithStates_13(5, 39, 0);
4210                break;
4211            default :
4212                break;
4213            }
4214        return jjStartNfa_13(4, active0);
4215    }
4216    private final int jjMoveStringLiteralDfa6_13(long old0, long active0)
4217    {
4218        if (((active0 &= old0)) == 0L)
4219            return jjStartNfa_13(4, old0);
4220        try { curChar = input_stream.readChar(); }
4221        catch(java.io.IOException JavaDoc e) {
4222            jjStopStringLiteralDfa_13(5, active0);
4223            return 6;
4224        }
4225        switch(curChar)
4226            {
4227            case 69:
4228                if ((active0 & 0x20000000000L) != 0L)
4229                    return jjStartNfaWithStates_13(6, 41, 0);
4230                break;
4231            case 79:
4232                return jjMoveStringLiteralDfa7_13(active0, 0x80000000000L);
4233            case 84:
4234                if ((active0 & 0x10000000000L) != 0L)
4235                    return jjStartNfaWithStates_13(6, 40, 0);
4236                else if ((active0 & 0x40000000000L) != 0L)
4237                    return jjStartNfaWithStates_13(6, 42, 0);
4238                break;
4239            default :
4240                break;
4241            }
4242        return jjStartNfa_13(5, active0);
4243    }
4244    private final int jjMoveStringLiteralDfa7_13(long old0, long active0)
4245    {
4246        if (((active0 &= old0)) == 0L)
4247            return jjStartNfa_13(5, old0);
4248        try { curChar = input_stream.readChar(); }
4249        catch(java.io.IOException JavaDoc e) {
4250            jjStopStringLiteralDfa_13(6, active0);
4251            return 7;
4252        }
4253        switch(curChar)
4254            {
4255            case 78:
4256                if ((active0 & 0x80000000000L) != 0L)
4257                    return jjStartNfaWithStates_13(7, 43, 0);
4258                break;
4259            default :
4260                break;
4261            }
4262        return jjStartNfa_13(6, active0);
4263    }
4264    private final int jjMoveNfa_13(int startState, int curPos)
4265    {
4266        int[] nextStates;
4267        int startsAt = 0;
4268        jjnewStateCnt = 3;
4269        int i = 1;
4270        jjstateSet[0] = startState;
4271        int j, kind = 0x7fffffff;
4272        for (;;)
4273            {
4274                if (++jjround == 0x7fffffff)
4275                    ReInitRounds();
4276                if (curChar < 64)
4277                    {
4278                        long l = 1L << curChar;
4279                    MatchLoop: do
4280                        {
4281                            switch(jjstateSet[--i])
4282                                {
4283                                case 3:
4284                                    if ((0x7ff7f10fffff9ffL & l) != 0L)
4285                                        {
4286                                            if (kind > 44)
4287                                                kind = 44;
4288                                            jjCheckNAdd(0);
4289                                        }
4290                                    else if ((0x3800808600000000L & l) != 0L)
4291                                        {
4292                                            if (kind > 46)
4293                                                kind = 46;
4294                                            jjCheckNAdd(2);
4295                                        }
4296                                    if ((0x100002600L & l) != 0L)
4297                                        {
4298                                            if (kind > 45)
4299                                                kind = 45;
4300                                            jjCheckNAdd(1);
4301                                        }
4302                                    break;
4303                                case 0:
4304                                    if ((0x7ff7f10fffff9ffL & l) == 0L)
4305                                        break;
4306                                    if (kind > 44)
4307                                        kind = 44;
4308                                    jjCheckNAdd(0);
4309                                    break;
4310                                case 1:
4311                                    if ((0x100002600L & l) == 0L)
4312                                        break;
4313                                    if (kind > 45)
4314                                        kind = 45;
4315                                    jjCheckNAdd(1);
4316                                    break;
4317                                case 2:
4318                                    if ((0x3800808600000000L & l) == 0L)
4319                                        break;
4320                                    kind = 46;
4321                                    jjCheckNAdd(2);
4322                                    break;
4323                                default : break;
4324                                }
4325                        } while(i != startsAt);
4326                    }
4327                else if (curChar < 128)
4328                    {
4329                        long l = 1L << (curChar & 077);
4330                    MatchLoop: do
4331                        {
4332                            switch(jjstateSet[--i])
4333                                {
4334                                case 3:
4335                                    if ((0xffffffffd7ffffffL & l) != 0L)
4336                                        {
4337                                            if (kind > 44)
4338                                                kind = 44;
4339                                            jjCheckNAdd(0);
4340                                        }
4341                                    else if (curChar == 93)
4342                                        {
4343                                            if (kind > 46)
4344                                                kind = 46;
4345                                            jjCheckNAdd(2);
4346                                        }
4347                                    break;
4348                                case 0:
4349                                    if ((0xffffffffd7ffffffL & l) == 0L)
4350                                        break;
4351                                    kind = 44;
4352                                    jjCheckNAdd(0);
4353                                    break;
4354                                case 2:
4355                                    if (curChar != 93)
4356                                        break;
4357                                    kind = 46;
4358                                    jjCheckNAdd(2);
4359                                    break;
4360                                default : break;
4361                                }
4362                        } while(i != startsAt);
4363                    }
4364                else
4365                    {
4366                        int hiByte = (int)(curChar >> 8);
4367                        int i1 = hiByte >> 6;
4368                        long l1 = 1L << (hiByte & 077);
4369                        int i2 = (curChar & 0xff) >> 6;
4370                        long l2 = 1L << (curChar & 077);
4371                    MatchLoop: do
4372                        {
4373                            switch(jjstateSet[--i])
4374                                {
4375                                case 3:
4376                                case 0:
4377                                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4378                                        break;
4379                                    if (kind > 44)
4380                                        kind = 44;
4381                                    jjCheckNAdd(0);
4382                                    break;
4383                                default : break;
4384                                }
4385                        } while(i != startsAt);
4386                    }
4387                if (kind != 0x7fffffff)
4388                    {
4389                        jjmatchedKind = kind;
4390                        jjmatchedPos = curPos;
4391                        kind = 0x7fffffff;
4392                    }
4393                ++curPos;
4394                if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
4395                    return curPos;
4396                try { curChar = input_stream.readChar(); }
4397                catch(java.io.IOException JavaDoc e) { return curPos; }
4398            }
4399    }
4400    private final int jjStopStringLiteralDfa_20(int pos, long active0, long active1)
4401    {
4402        switch (pos)
4403            {
4404            default :
4405                return -1;
4406            }
4407    }
4408    private final int jjStartNfa_20(int pos, long active0, long active1)
4409    {
4410        return jjMoveNfa_20(jjStopStringLiteralDfa_20(pos, active0, active1), pos + 1);
4411    }
4412    private final int jjStartNfaWithStates_20(int pos, int kind, int state)
4413    {
4414        jjmatchedKind = kind;
4415        jjmatchedPos = pos;
4416        try { curChar = input_stream.readChar(); }
4417        catch(java.io.IOException JavaDoc e) { return pos + 1; }
4418        return jjMoveNfa_20(state, pos + 1);
4419    }
4420    private final int jjMoveStringLiteralDfa0_20()
4421    {
4422        switch(curChar)
4423            {
4424            case 38:
4425                return jjStopAtPos(0, 89);
4426            case 60:
4427                jjmatchedKind = 7;
4428                return jjMoveStringLiteralDfa1_20(0x4700L, 0x20000000000L);
4429            case 93:
4430                jjmatchedKind = 6;
4431                return jjMoveStringLiteralDfa1_20(0x1800L, 0x0L);
4432            default :
4433                return jjMoveNfa_20(1, 0);
4434            }
4435    }
4436    private final int jjMoveStringLiteralDfa1_20(long active0, long active1)
4437    {
4438        try { curChar = input_stream.readChar(); }
4439        catch(java.io.IOException JavaDoc e) {
4440            jjStopStringLiteralDfa_20(0, active0, active1);
4441            return 1;
4442        }
4443        switch(curChar)
4444            {
4445            case 33:
4446                if ((active0 & 0x100L) != 0L)
4447                    {
4448                        jjmatchedKind = 8;
4449                        jjmatchedPos = 1;
4450                    }
4451                return jjMoveStringLiteralDfa2_20(active0, 0x400L, active1, 0x20000000000L);
4452            case 60:
4453                if ((active0 & 0x4000L) != 0L)
4454                    return jjStopAtPos(1, 14);
4455                break;
4456            case 62:
4457                if ((active0 & 0x1000L) != 0L)
4458                    return jjStopAtPos(1, 12);
4459                break;
4460            case 63:
4461                if ((active0 & 0x200L) != 0L)
4462                    return jjStopAtPos(1, 9);
4463                break;
4464            case 93:
4465                return jjMoveStringLiteralDfa2_20(active0, 0x800L, active1, 0L);
4466            default :
4467                break;
4468            }
4469        return jjStartNfa_20(0, active0, active1);
4470    }
4471    private final int jjMoveStringLiteralDfa2_20(long old0, long active0, long old1, long active1)
4472    {
4473        if (((active0 &= old0) | (active1 &= old1)) == 0L)
4474            return jjStartNfa_20(