CSSSyntaxTokenManager


1   /* Generated By:JavaCC: Do not edit this line. CSSSyntaxTokenManager.java */
2   /*
3    * The contents of this file are subject to the terms of the Common Development
4    * and Distribution License (the License). You may not use this file except in
5    * compliance with the License.
6    *
7    * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
8    * or http://www.netbeans.org/cddl.txt.
9    *
10   * When distributing Covered Code, include this CDDL Header Notice in each file
11   * and include the License file at http://www.netbeans.org/cddl.txt.
12   * If applicable, add the following below the CDDL Header, with the fields
13   * enclosed by brackets [] replaced by your own identifying information:
14   * "Portions Copyrighted [year] [name of copyright owner]"
15   *
16   * The Original Software is NetBeans. The Initial Developer of the Original
17   * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
18   * Microsystems, Inc. All Rights Reserved.
19   */
20  
21  package org.netbeans.modules.css.text.syntax.javacc;
22  import java.io.*;
23  import org.netbeans.modules.css.text.syntax.javacc.lib.*;
24  
25  public class CSSSyntaxTokenManager implements CSSSyntaxConstants
26  {
27      //!!! enter proper bridge
28      public final class Bridge extends CSSSyntaxTokenManager implements JJSyntaxInterface, JJConstants {
29          public Bridge() {
30              super(null);
31          }
32      }
33  
34  //~~~~~~~~~~~~~~~~~~~~~ TEXT BASED SHARING START ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
35  
36      private transient String   myimage = "";  //contais image of last scanned [partial] token // NOI18N
37      private transient String   lastImage = ""; // NOI18N
38      private transient int id;
39  
40      private int lastValidState; //contains last correct state
41                                  //state may become incorect if EOB is returned
42                                  //due to buffer end e.g.
43                                  //(a) <! moves to IN_DECL
44                                  //(b) <!-- moves to IN_COMMENT
45                                  //if (a) is followed by EOB that
46                                  //token manager enters illegal state
47  
48      /** Return current state of lexan.
49       * There will be probably necessary simple ID mappe among
50       * Syntax's state IDs with reserved INIT(-1) and JavaCC DEFAULT(variable often the highest one).
51       */
52      public final int getState() {
53          return curLexState;
54      }
55  
56      /** Return length of last recognized token. ?? SKIP*/
57      public final int getLength() {
58          return myimage.length();
59      }
60  
61      /** Return last token. */
62      public final String   getImage() {
63          return myimage.toString();
64      }
65  
66      /** Set state info to folowing one. */
67      public final void setStateInfo(int[] state) {
68          int[] newstate = new int[state.length];
69          System.arraycopy(state, 0, newstate, 0, state.length);
70          states = newstate;
71  //          dumpStack("L"); // NOI18N
72          lastValidState = popState(); //restore lastValidState
73      }
74  
75      /** return copy of current state. */
76      public final int[] getStateInfo() {
77          pushState(lastValidState); // store lastValidState  !modifies states stack
78          int[] state = new int[states.length];
79          System.arraycopy(states, 0, state, 0, states.length);
80  //          dumpStack("S"); // NOI18N
81          popState();                // !restore the states stack
82          return state;
83      }
84  
85  
86      private void dumpStack(String   label) {
87          StringBuffer   s = new StringBuffer  ();
88          s.append(label + " "); // NOI18N
89          for (int i = 0; i<states.length; i++) {
90              s.append(states[i] + ", "); // NOI18N
91          }
92          System.err.println(s.toString());
93      }
94  
95      /** Set input stream to folowing one
96       *  and reset initial state.
97       */
98      public final void init(CharStream input) {
99          ReInit((UCode_CharStream)input);
100         lastValidState = getState();
101     }
102 
103     /** Set input stream to folowing one
104      *  and set current state.
105      */
106     public final void init(CharStream in, int state) {
107         ReInit((UCode_CharStream)in, state);
108         lastValidState = getState();
109     }
110 
111     /** Syntax would want restore state on buffer boundaries. */
112     public final void setState(int state) {
113         lastValidState = state;
114         SwitchTo(state == -1 ? defaultLexState : state); //fix deleting at document start
115     }
116 
117     //
118     // push analyzer state to states stack
119     //
120     private void pushState(int state) {
121         if (states == null) {
122             states = new int[] {state};
123         } else {
124             int[] newstates = new int[states.length + 1];
125             System.arraycopy(states, 0, newstates, 0, states.length);
126             newstates[newstates.length - 1] = state;
127             states = newstates;
128         }
129     }
130 
131     //
132     // pop analyzer state from states stack
133     //
134     private int popState() {
135         int state = states[states.length - 1];
136         if (states.length == 1) {
137             states = null;
138         } else {
139             int[] newstates = new int[states.length - 1];
140             System.arraycopy(states, 0, newstates, 0, states.length - 1);
141             states = newstates;
142         }
143         return state;
144     }
145 
146     /** Prepare next token from stream. */
147     public final void next() {
148         try {
149             Token tok = getNextToken();
150             myimage = tok.image;
151             id = tok.kind;
152             if (id == EOF) { //??? EOF is visible just at Parser LEVEL
153                 setState(lastValidState);
154                 id = Bridge.JJ_EOF;
155             }
156             lastValidState = getState();
157 
158         } catch (TokenMgrError ex) {
159             try {
160                 //is the exception caused by EOF?
161                 char ch = input_stream.readChar();
162                 input_stream.backup(1);
163 
164                 myimage = input_stream.GetImage();
165                 if (Boolean.getBoolean("netbeans.debug.exceptions")) // NOI18N
166                     System.err.println(getClass().toString() + " ERROR:" + getState() + ":'" + ch + "'");
167                 id = Bridge.JJ_ERR;
168 
169             } catch (IOException eof) {
170 
171                 myimage = input_stream.GetImage();
172                 id = Bridge.JJ_EOF;
173             }
174         }
175     }
176 
177     /** Return ID of the last recognized token. */
178     public int getID() {
179         return id;
180     }
181 
182     /** Return name of the last token. */
183     public final String   getName() {
184         return tokenImage[id];
185     }
186 
187     /** For testing purposes only. */
188     public static void main(String   args[]) throws Exception   {
189 
190         InputStream in;
191         int dump = 0;
192         int dump2 = 1000;
193 
194         System.err.println("Got " + args.length + " arguments.");
195 
196         if (args.length != 0) {
197             in = new FileInputStream(args[0]);
198             if (args.length == 2) { //dump just requested line
199                 dump = Integer.parseInt(args[1]) - 1;
200                 dump2 = dump;
201                 System.err.println("Line to be dumped:" + dump);
202             }
203         } else  {
204             System.err.println("One argument required.");
205             return;
206         }
207 
208         CharStream input = new ASCIICharStream(in, 0, 0);
209         Bridge lex = null; //new XMLSyntaxTokenManager(input);
210 
211         int i = 25; //token count
212         int id;
213         int toks = 0;
214         long time = System.currentTimeMillis();
215 
216         while (i/*--*/>0) {
217 
218             lex.next();
219             id = lex.getID();
220 
221             toks++;
222             switch (id) {
223             case Bridge.JJ_EOF:
224                 System.err.println("EOF at " + lex.getState() + " " + lex.getImage());
225                 System.err.println("Line: " + input.getLine() );
226                 System.err.println("Tokens: " + toks );
227                 System.err.println("Time: " + (System.currentTimeMillis() - time) );
228                 return;
229 
230             default:
231                 if (dump <= input.getLine() && input.getLine() <= dump2)
232                     System.err.println(" " + id + "@" + lex.getState() + ":" + lex.getImage() );
233             }
234 
235         }
236 
237     }
238 
239     /**
240      * The analyzer may store information about state in this
241      * stack (array). These will be used as Syntax state info.
242      */
243     private int[] states = null;
244   public  java.io.PrintStream   debugStream = System.out;
245   public  void setDebugStream(java.io.PrintStream   ds) { debugStream = ds; }
246 private final int jjStopStringLiteralDfa_4(int pos, long active0)
247 {
248    switch (pos)
249    {
250       case 0:
251          if ((active0 & 0x30L) != 0L)
252          {
253             jjmatchedKind = 6;
254             return -1;
255          }
256          return -1;
257       case 1:
258          if ((active0 & 0x30L) != 0L)
259          {
260             if (jjmatchedPos == 0)
261             {
262                jjmatchedKind = 6;
263                jjmatchedPos = 0;
264             }
265             return -1;
266          }
267          return -1;
268       case 2:
269          if ((active0 & 0x10L) != 0L)
270          {
271             if (jjmatchedPos == 0)
272             {
273                jjmatchedKind = 6;
274                jjmatchedPos = 0;
275             }
276             return -1;
277          }
278          return -1;
279       default :
280          return -1;
281    }
282 }
283 private final int jjStartNfa_4(int pos, long active0)
284 {
285    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
286 }
287 private final int jjStopAtPos(int pos, int kind)
288 {
289    jjmatchedKind = kind;
290    jjmatchedPos = pos;
291    return pos + 1;
292 }
293 private final int jjStartNfaWithStates_4(int pos, int kind, int state)
294 {
295    jjmatchedKind = kind;
296    jjmatchedPos = pos;
297    try { curChar = input_stream.readChar(); }
298    catch(java.io.IOException   e) { return pos + 1; }
299    return jjMoveNfa_4(state, pos + 1);
300 }
301 private final int jjMoveStringLiteralDfa0_4()
302 {
303    switch(curChar)
304    {
305       case 10:
306          return jjStopAtPos(0, 1);
307       case 47:
308          return jjMoveStringLiteralDfa1_4(0x20L);
309       case 60:
310          return jjMoveStringLiteralDfa1_4(0x10L);
311       case 123:
312          return jjStopAtPos(0, 2);
313       case 125:
314          return jjStopAtPos(0, 3);
315       default :
316          return jjMoveNfa_4(1, 0);
317    }
318 }
319 private final int jjMoveStringLiteralDfa1_4(long active0)
320 {
321    try { curChar = input_stream.readChar(); }
322    catch(java.io.IOException   e) {
323       jjStopStringLiteralDfa_4(0, active0);
324       return 1;
325    }
326    switch(curChar)
327    {
328       case 33:
329          return jjMoveStringLiteralDfa2_4(active0, 0x10L);
330       case 42:
331          if ((active0 & 0x20L) != 0L)
332             return jjStopAtPos(1, 5);
333          break;
334       default :
335          break;
336    }
337    return jjStartNfa_4(0, active0);
338 }
339 private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
340 {
341    if (((active0 &= old0)) == 0L)
342       return jjStartNfa_4(0, old0); 
343    try { curChar = input_stream.readChar(); }
344    catch(java.io.IOException   e) {
345       jjStopStringLiteralDfa_4(1, active0);
346       return 2;
347    }
348    switch(curChar)
349    {
350       case 45:
351          return jjMoveStringLiteralDfa3_4(active0, 0x10L);
352       default :
353          break;
354    }
355    return jjStartNfa_4(1, active0);
356 }
357 private final int jjMoveStringLiteralDfa3_4(long old0, long active0)
358 {
359    if (((active0 &= old0)) == 0L)
360       return jjStartNfa_4(1, old0); 
361    try { curChar = input_stream.readChar(); }
362    catch(java.io.IOException   e) {
363       jjStopStringLiteralDfa_4(2, active0);
364       return 3;
365    }
366    switch(curChar)
367    {
368       case 45:
369          if ((active0 & 0x10L) != 0L)
370             return jjStopAtPos(3, 4);
371          break;
372       default :
373          break;
374    }
375    return jjStartNfa_4(2, active0);
376 }
377 private final void jjCheckNAdd(int state)
378 {
379    if (jjrounds[state] != jjround)
380    {
381       jjstateSet[jjnewStateCnt++] = state;
382       jjrounds[state] = jjround;
383    }
384 }
385 private final void jjAddStates(int start, int end)
386 {
387    do {
388       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
389    } while (start++ != end);
390 }
391 private final void jjCheckNAddTwoStates(int state1, int state2)
392 {
393    jjCheckNAdd(state1);
394    jjCheckNAdd(state2);
395 }
396 private final void jjCheckNAddStates(int start, int end)
397 {
398    do {
399       jjCheckNAdd(jjnextStates[start]);
400    } while (start++ != end);
401 }
402 private final void jjCheckNAddStates(int start)
403 {
404    jjCheckNAdd(jjnextStates[start]);
405    jjCheckNAdd(jjnextStates[start + 1]);
406 }
407 static final long[] jjbitVec0 = {
408    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
409 };
410 static final long[] jjbitVec2 = {
411    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
412 };
413 private final int jjMoveNfa_4(int startState, int curPos)
414 {
415    int[] nextStates;
416    int startsAt = 0;
417    jjnewStateCnt = 11;
418    int i = 1;
419    jjstateSet[0] = startState;
420    int j, kind = 0x7fffffff;
421    for (;;)
422    {
423       if (++jjround == 0x7fffffff)
424          ReInitRounds();
425       if (curChar < 64)
426       {
427          long l = 1L << curChar;
428          MatchLoop: do
429          {
430             switch(jjstateSet[--i])
431             {
432                case 1:
433                   if ((0xefff7ffffffffbffL & l) != 0L)
434                   {
435                      if (kind > 6)
436                         kind = 6;
437                      jjCheckNAdd(0);
438                   }
439                   else if ((0x1000800000000000L & l) != 0L)
440                   {
441                      if (kind > 6)
442                         kind = 6;
443                   }
444                   break;
445                case 0:
446                   if ((0xefff7ffffffffbffL & l) == 0L)
447                      break;
448                   if (kind > 6)
449                      kind = 6;
450                   jjCheckNAdd(0);
451                   break;
452                case 3:
453                   if ((0x100000200L & l) != 0L && kind > 7)
454                      kind = 7;
455                   break;
456                case 10:
457                   if ((0xfffffffefffff9ffL & l) == 0L)
458                      break;
459                   if (kind > 8)
460                      kind = 8;
461                   jjstateSet[jjnewStateCnt++] = 10;
462                   break;
463                default : break;
464             }
465          } while(i != startsAt);
466       }
467       else if (curChar < 128)
468       {
469          long l = 1L << (curChar & 077);
470          MatchLoop: do
471          {
472             switch(jjstateSet[--i])
473             {
474                case 1:
475                   if ((0xd7fffffffffffffeL & l) != 0L)
476                   {
477                      if (kind > 6)
478                         kind = 6;
479                      jjCheckNAdd(0);
480                   }
481                   else if (curChar == 64)
482                   {
483                      if (kind > 8)
484                         kind = 8;
485                      jjCheckNAdd(10);
486                   }
487                   if (curChar == 64)
488                      jjstateSet[jjnewStateCnt++] = 7;
489                   break;
490                case 0:
491                   if ((0xd7fffffffffffffeL & l) == 0L)
492                      break;
493                   if (kind > 6)
494                      kind = 6;
495                   jjCheckNAdd(0);
496                   break;
497                case 2:
498                   if (curChar == 97)
499                      jjstateSet[jjnewStateCnt++] = 3;
500                   break;
501                case 4:
502                   if (curChar == 105)
503                      jjstateSet[jjnewStateCnt++] = 2;
504                   break;
505                case 5:
506                   if (curChar == 100)
507                      jjstateSet[jjnewStateCnt++] = 4;
508                   break;
509                case 6:
510                   if (curChar == 101)
511                      jjstateSet[jjnewStateCnt++] = 5;
512                   break;
513                case 7:
514                   if (curChar == 109)
515                      jjstateSet[jjnewStateCnt++] = 6;
516                   break;
517                case 8:
518                   if (curChar == 64)
519                      jjstateSet[jjnewStateCnt++] = 7;
520                   break;
521                case 9:
522                   if (curChar != 64)
523                      break;
524                   if (kind > 8)
525                      kind = 8;
526                   jjCheckNAdd(10);
527                   break;
528                case 10:
529                   if (kind > 8)
530                      kind = 8;
531                   jjCheckNAdd(10);
532                   break;
533                default : break;
534             }
535          } while(i != startsAt);
536       }
537       else
538       {
539          int hiByte = (int)(curChar >> 8);
540          int i1 = hiByte >> 6;
541          long l1 = 1L << (hiByte & 077);
542          int i2 = (curChar & 0xff) >> 6;
543          long l2 = 1L << (curChar & 077);
544          MatchLoop: do
545          {
546             switch(jjstateSet[--i])
547             {
548                case 1:
549                case 0:
550                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
551                      break;
552                   if (kind > 6)
553                      kind = 6;
554                   jjCheckNAdd(0);
555                   break;
556                case 10:
557                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
558                      break;
559                   if (kind > 8)
560                      kind = 8;
561                   jjstateSet[jjnewStateCnt++] = 10;
562                   break;
563                default : break;
564             }
565          } while(i != startsAt);
566       }
567       if (kind != 0x7fffffff)
568       {
569          jjmatchedKind = kind;
570          jjmatchedPos = curPos;
571          kind = 0x7fffffff;
572       }
573       ++curPos;
574       if ((i = jjnewStateCnt) == (startsAt = 11 - (jjnewStateCnt = startsAt)))
575          return curPos;
576       try { curChar = input_stream.readChar(); }
577       catch(java.io.IOException   e) { return curPos; }
578    }
579 }
580 private final int jjStopStringLiteralDfa_3(int pos, long active0)
581 {
582    switch (pos)
583    {
584       default :
585          return -1;
586    }
587 }
588 private final int jjStartNfa_3(int pos, long active0)
589 {
590    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
591 }
592 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
593 {
594    jjmatchedKind = kind;
595    jjmatchedPos = pos;
596    try { curChar = input_stream.readChar(); }
597    catch(java.io.IOException   e) { return pos + 1; }
598    return jjMoveNfa_3(state, pos + 1);
599 }
600 private final int jjMoveStringLiteralDfa0_3()
601 {
602    switch(curChar)
603    {
604       case 10:
605          return jjStopAtPos(0, 1);
606       case 123:
607          return jjStopAtPos(0, 9);
608       default :
609          return jjMoveNfa_3(0, 0);
610    }
611 }
612 private final int jjMoveNfa_3(int startState, int curPos)
613 {
614    int[] nextStates;
615    int startsAt = 0;
616    jjnewStateCnt = 1;
617    int i = 1;
618    jjstateSet[0] = startState;
619    int j, kind = 0x7fffffff;
620    for (;;)
621    {
622       if (++jjround == 0x7fffffff)
623          ReInitRounds();
624       if (curChar < 64)
625       {
626          long l = 1L << curChar;
627          MatchLoop: do
628          {
629             switch(jjstateSet[--i])
630             {
631                case 0:
632                   if ((0xfffffffffffffbffL & l) == 0L)
633                      break;
634                   kind = 10;
635                   jjstateSet[jjnewStateCnt++] = 0;
636                   break;
637                default : break;
638             }
639          } while(i != startsAt);
640       }
641       else if (curChar < 128)
642       {
643          long l = 1L << (curChar & 077);
644          MatchLoop: do
645          {
646             switch(jjstateSet[--i])
647             {
648                case 0:
649                   if ((0xf7ffffffffffffffL & l) == 0L)
650                      break;
651                   kind = 10;
652                   jjstateSet[jjnewStateCnt++] = 0;
653                   break;
654                default : break;
655             }
656          } while(i != startsAt);
657       }
658       else
659       {
660          int hiByte = (int)(curChar >> 8);
661          int i1 = hiByte >> 6;
662          long l1 = 1L << (hiByte & 077);
663          int i2 = (curChar & 0xff) >> 6;
664          long l2 = 1L << (curChar & 077);
665          MatchLoop: do
666          {
667             switch(jjstateSet[--i])
668             {
669                case 0:
670                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
671                      break;
672                   if (kind > 10)
673                      kind = 10;
674                   jjstateSet[jjnewStateCnt++] = 0;
675                   break;
676                default : break;
677             }
678          } while(i != startsAt);
679       }
680       if (kind != 0x7fffffff)
681       {
682          jjmatchedKind = kind;
683          jjmatchedPos = curPos;
684          kind = 0x7fffffff;
685       }
686       ++curPos;
687       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
688          return curPos;
689       try { curChar = input_stream.readChar(); }
690       catch(java.io.IOException   e) { return curPos; }
691    }
692 }
693 private final int jjStopStringLiteralDfa_2(int pos, long active0)
694 {
695    switch (pos)
696    {
697       case 0:
698          if ((active0 & 0x6000L) != 0L)
699          {
700             jjmatchedKind = 12;
701             return -1;
702          }
703          return -1;
704       case 1:
705          if ((active0 & 0x6000L) != 0L)
706          {
707             if (jjmatchedPos == 0)
708             {
709                jjmatchedKind = 12;
710                jjmatchedPos = 0;
711             }
712             return -1;
713          }
714          return -1;
715       case 2:
716          if ((active0 & 0x2000L) != 0L)
717          {
718             if (jjmatchedPos == 0)
719             {
720                jjmatchedKind = 12;
721                jjmatchedPos = 0;
722             }
723             return -1;
724          }
725          return -1;
726       default :
727          return -1;
728    }
729 }
730 private final int jjStartNfa_2(int pos, long active0)
731 {
732    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
733 }
734 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
735 {
736    jjmatchedKind = kind;
737    jjmatchedPos = pos;
738    try { curChar = input_stream.readChar(); }
739    catch(java.io.IOException   e) { return pos + 1; }
740    return jjMoveNfa_2(state, pos + 1);
741 }
742 private final int jjMoveStringLiteralDfa0_2()
743 {
744    switch(curChar)
745    {
746       case 10:
747          return jjStopAtPos(0, 1);
748       case 47:
749          return jjMoveStringLiteralDfa1_2(0x4000L);
750       case 60:
751          return jjMoveStringLiteralDfa1_2(0x2000L);
752       default :
753          return jjMoveNfa_2(7, 0);
754    }
755 }
756 private final int jjMoveStringLiteralDfa1_2(long active0)
757 {
758    try { curChar = input_stream.readChar(); }
759    catch(java.io.IOException   e) {
760       jjStopStringLiteralDfa_2(0, active0);
761       return 1;
762    }
763    switch(curChar)
764    {
765       case 33:
766          return jjMoveStringLiteralDfa2_2(active0, 0x2000L);
767       case 42:
768          if ((active0 & 0x4000L) != 0L)
769             return jjStopAtPos(1, 14);
770          break;
771       default :
772          break;
773    }
774    return jjStartNfa_2(0, active0);
775 }
776 private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
777 {
778    if (((active0 &= old0)) == 0L)
779       return jjStartNfa_2(0, old0); 
780    try { curChar = input_stream.readChar(); }
781    catch(java.io.IOException   e) {
782       jjStopStringLiteralDfa_2(1, active0);
783       return 2;
784    }
785    switch(curChar)
786    {
787       case 45:
788          return jjMoveStringLiteralDfa3_2(active0, 0x2000L);
789       default :
790          break;
791    }
792    return jjStartNfa_2(1, active0);
793 }
794 private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
795 {
796    if (((active0 &= old0)) == 0L)
797       return jjStartNfa_2(1, old0); 
798    try { curChar = input_stream.readChar(); }
799    catch(java.io.IOException   e) {
800       jjStopStringLiteralDfa_2(2, active0);
801       return 3;
802    }
803    switch(curChar)
804    {
805       case 45:
806          if ((active0 & 0x2000L) != 0L)
807             return jjStopAtPos(3, 13);
808          break;
809       default :
810          break;
811    }
812    return jjStartNfa_2(2, active0);
813 }
814 private final int jjMoveNfa_2(int startState, int curPos)
815 {
816    int[] nextStates;
817    int startsAt = 0;
818    jjnewStateCnt = 897;
819    int i = 1;
820    jjstateSet[0] = startState;
821    int j, kind = 0x7fffffff;
822    for (;;)
823    {
824       if (++jjround == 0x7fffffff)
825          ReInitRounds();
826       if (curChar < 64)
827       {
828          long l = 1L << curChar;
829          MatchLoop: do
830          {
831             switch(jjstateSet[--i])
832             {
833                case 7:
834                   if ((0xefff7ffefffff9ffL & l) != 0L)
835                   {
836                      if (kind > 12)
837                         kind = 12;
838                      jjCheckNAdd(39);
839                   }
840                   else if ((0x1000800100000200L & l) != 0L)
841                   {
842                      if (kind > 12)
843                         kind = 12;
844                   }
845                   if (curChar == 32)
846                      jjstateSet[jjnewStateCnt++] = 42;
847                   break;
848                case 1:
849                   if (curChar == 58 && kind > 11)
850                      kind = 11;
851                   break;
852                case 24:
853                   if (curChar == 45)
854                      jjstateSet[jjnewStateCnt++] = 23;
855                   break;
856                case 37:
857                   if (curChar == 45)
858                      jjstateSet[jjnewStateCnt++] = 36;
859                   break;
860                case 39:
861                   if ((0xefff7ffefffff9ffL & l) == 0L)
862                      break;
863                   if (kind > 12)
864                      kind = 12;
865                   jjCheckNAdd(39);
866                   break;
867                case 40:
868                   if ((0x1000800100000200L & l) != 0L && kind > 12)
869                      kind = 12;
870                   break;
871                case 41:
872                   if (curChar == 32)
873                      jjstateSet[jjnewStateCnt++] = 42;
874                   break;
875                case 45:
876                   if (curChar == 45)
877                      jjAddStates(0, 4);
878                   break;
879                case 87:
880                   if (curChar == 45)
881                      jjAddStates(5, 11);
882                   break;
883                case 119:
884                   if (curChar == 45)
885                      jjstateSet[jjnewStateCnt++] = 118;
886                   break;
887                case 126:
888                   if (curChar == 45)
889                      jjstateSet[jjnewStateCnt++] = 125;
890                   break;
891                case 137:
892                   if (curChar == 45)
893                      jjstateSet[jjnewStateCnt++] = 136;
894                   break;
895                case 146:
896                   if (curChar == 45)
897                      jjstateSet[jjnewStateCnt++] = 145;
898                   break;
899                case 161:
900                   if (curChar == 45)
901                      jjstateSet[jjnewStateCnt++] = 160;
902                   break;
903                case 171:
904                   if (curChar == 45)
905                      jjstateSet[jjnewStateCnt++] = 170;
906                   break;
907                case 184:
908                   if (curChar == 45)
909                      jjstateSet[jjnewStateCnt++] = 183;
910                   break;
911                case 192:
912                   if (curChar == 45)
913                      jjstateSet[jjnewStateCnt++] = 191;
914                   break;
915                case 208:
916                   if (curChar == 45)
917                      jjstateSet[jjnewStateCnt++] = 207;
918                   break;
919                case 236:
920                   if (curChar == 45)
921                      jjstateSet[jjnewStateCnt++] = 235;
922                   break;
923                case 247:
924                   if (curChar == 45)
925                      jjstateSet[jjnewStateCnt++] = 246;
926                   break;
927                case 259:
928                   if (curChar == 45)
929                      jjstateSet[jjnewStateCnt++] = 258;
930                   break;
931                case 267:
932                   if (curChar == 45)
933                      jjstateSet[jjnewStateCnt++] = 266;
934                   break;
935                case 300:
936                   if (curChar == 45)
937                      jjstateSet[jjnewStateCnt++] = 299;
938                   break;
939                case 310:
940                   if (curChar == 45)
941                      jjAddStates(12, 15);
942                   break;
943                case 335:
944                   if (curChar == 45)
945                      jjstateSet[jjnewStateCnt++] = 334;
946                   break;
947                case 358:
948                   if (curChar == 45)
949                      jjstateSet[jjnewStateCnt++] = 357;
950                   break;
951                case 369:
952                   if (curChar == 45)
953                      jjstateSet[jjnewStateCnt++] = 368;
954                   break;
955                case 377:
956                   if (curChar == 45)
957                      jjstateSet[jjnewStateCnt++] = 376;
958                   break;
959                case 385:
960                   if (curChar == 45)
961                      jjstateSet[jjnewStateCnt++] = 384;
962                   break;
963                case 391:
964                   if (curChar == 45)
965                      jjstateSet[jjnewStateCnt++] = 390;
966                   break;
967                case 402:
968                   if (curChar == 45)
969                      jjstateSet[jjnewStateCnt++] = 401;
970                   break;
971                case 408:
972                   if (curChar == 45)
973                      jjstateSet[jjnewStateCnt++] = 407;
974                   break;
975                case 415:
976                   if (curChar == 45)
977                      jjstateSet[jjnewStateCnt++] = 414;
978                   break;
979                case 421:
980                   if (curChar == 45)
981                      jjstateSet[jjnewStateCnt++] = 420;
982                   break;
983                case 432:
984                   if (curChar == 45)
985                      jjstateSet[jjnewStateCnt++] = 431;
986                   break;
987                case 442:
988                   if (curChar == 45)
989                      jjstateSet[jjnewStateCnt++] = 441;
990                   break;
991                case 453:
992                   if (curChar == 45)
993                      jjstateSet[jjnewStateCnt++] = 452;
994                   break;
995                case 462:
996                   if (curChar == 45)
997                      jjstateSet[jjnewStateCnt++] = 461;
998                   break;
999                case 473:
1000                  if (curChar == 45)
1001                     jjstateSet[jjnewStateCnt++] = 472;
1002                  break;
1003               case 487:
1004                  if (curChar == 45)
1005                     jjstateSet[jjnewStateCnt++] = 486;
1006                  break;
1007               case 494:
1008                  if (curChar == 45)
1009                     jjstateSet[jjnewStateCnt++] = 493;
1010                  break;
1011               case 502:
1012                  if (curChar == 45)
1013                     jjstateSet[jjnewStateCnt++] = 501;
1014                  break;
1015               case 509:
1016                  if (curChar == 45)
1017                     jjstateSet[jjnewStateCnt++] = 508;
1018                  break;
1019               case 526:
1020                  if (curChar == 45)
1021                     jjstateSet[jjnewStateCnt++] = 525;
1022                  break;
1023               case 537:
1024                  if (curChar == 45)
1025                     jjstateSet[jjnewStateCnt++] = 536;
1026                  break;
1027               case 548:
1028                  if (curChar == 45)
1029                     jjstateSet[jjnewStateCnt++] = 547;
1030                  break;
1031               case 570:
1032                  if (curChar == 45)
1033                     jjstateSet[jjnewStateCnt++] = 569;
1034                  break;
1035               case 581:
1036                  if (curChar == 45)
1037                     jjstateSet[jjnewStateCnt++] = 580;
1038                  break;
1039               case 593:
1040                  if (curChar == 45)
1041                     jjstateSet[jjnewStateCnt++] = 592;
1042                  break;
1043               case 603:
1044                  if (curChar == 45)
1045                     jjstateSet[jjnewStateCnt++] = 602;
1046                  break;
1047               case 616:
1048                  if (curChar == 45)
1049                     jjstateSet[jjnewStateCnt++] = 615;
1050                  break;
1051               case 622:
1052                  if (curChar == 45)
1053                     jjstateSet[jjnewStateCnt++] = 621;
1054                  break;
1055               case 631:
1056                  if (curChar == 45)
1057                     jjstateSet[jjnewStateCnt++] = 630;
1058                  break;
1059               case 637:
1060                  if (curChar == 45)
1061                     jjstateSet[jjnewStateCnt++] = 636;
1062                  break;
1063               case 646:
1064                  if (curChar == 45)
1065                     jjstateSet[jjnewStateCnt++] = 645;
1066                  break;
1067               case 652:
1068                  if (curChar == 45)
1069                     jjstateSet[jjnewStateCnt++] = 651;
1070                  break;
1071               case 663:
1072                  if (curChar == 45)
1073                     jjstateSet[jjnewStateCnt++] = 662;
1074                  break;
1075               case 673:
1076                  if (curChar == 45)
1077                     jjstateSet[jjnewStateCnt++] = 672;
1078                  break;
1079               case 685:
1080                  if (curChar == 45)
1081                     jjstateSet[jjnewStateCnt++] = 684;
1082                  break;
1083               case 695:
1084                  if (curChar == 45)
1085                     jjstateSet[jjnewStateCnt++] = 694;
1086                  break;
1087               case 727:
1088                  if (curChar == 45)
1089                     jjstateSet[jjnewStateCnt++] = 726;
1090                  break;
1091               case 739:
1092                  if (curChar == 45)
1093                     jjstateSet[jjnewStateCnt++] = 738;
1094                  break;
1095               case 754:
1096                  if (curChar == 45)
1097                     jjstateSet[jjnewStateCnt++] = 753;
1098                  break;
1099               case 762:
1100                  if (curChar == 45)
1101                     jjstateSet[jjnewStateCnt++] = 761;
1102                  break;
1103               case 778:
1104                  if (curChar == 45)
1105                     jjstateSet[jjnewStateCnt++] = 777;
1106                  break;
1107               case 787:
1108                  if (curChar == 45)
1109                     jjstateSet[jjnewStateCnt++] = 786;
1110                  break;
1111               case 800:
1112                  if (curChar == 45)
1113                     jjstateSet[jjnewStateCnt++] = 799;
1114                  break;
1115               case 809:
1116                  if (curChar == 45)
1117                     jjstateSet[jjnewStateCnt++] = 808;
1118                  break;
1119               case 818:
1120                  if (curChar == 45)
1121                     jjstateSet[jjnewStateCnt++] = 817;
1122                  break;
1123               case 830:
1124                  if (curChar == 45)
1125                     jjstateSet[jjnewStateCnt++] = 829;
1126                  break;
1127               case 840:
1128                  if (curChar == 45)
1129                     jjstateSet[jjnewStateCnt++] = 839;
1130                  break;
1131               case 861:
1132                  if (curChar == 45)
1133                     jjstateSet[jjnewStateCnt++] = 860;
1134                  break;
1135               case 875:
1136                  if (curChar == 45)
1137                     jjstateSet[jjnewStateCnt++] = 874;
1138                  break;
1139               case 893:
1140                  if (curChar == 45)
1141                     jjstateSet[jjnewStateCnt++] = 892;
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 7:
1155                  if ((0xdfffffffffffffffL & l) != 0L)
1156                  {
1157                     if (kind > 12)
1158                        kind = 12;
1159                     jjCheckNAdd(39);
1160                  }
1161                  else if (curChar == 125)
1162                  {
1163                     if (kind > 15)
1164                        kind = 15;
1165                  }
1166                  if ((0x80000000800000L & l) != 0L)
1167                     jjAddStates(16, 19);
1168                  else if ((0x40000000400000L & l) != 0L)
1169                     jjAddStates(20, 23);
1170                  else if ((0x10000000100000L & l) != 0L)
1171                     jjAddStates(24, 30);
1172                  else if ((0x8000000080000L & l) != 0L)
1173                     jjAddStates(31, 37);
1174                  else if ((0x4000000040000L & l) != 0L)
1175                     jjAddStates(38, 39);
1176                  else if ((0x1000000010000L & l) != 0L)
1177                     jjAddStates(40, 55);
1178                  else if ((0x800000008000L & l) != 0L)
1179                     jjAddStates(56, 61);
1180                  else if ((0x200000002000L & l) != 0L)
1181                     jjAddStates(62, 72);
1182                  else if ((0x100000001000L & l) != 0L)
1183                     jjAddStates(73, 79);
1184                  else if ((0x4000000040L & l) != 0L)
1185                     jjAddStates(80, 81);
1186                  else if ((0x2000000020L & l) != 0L)
1187                     jjAddStates(82, 83);
1188                  else if ((0x1000000010L & l) != 0L)
1189                     jjAddStates(84, 85);
1190                  else if ((0x800000008L & l) != 0L)
1191                     jjAddStates(86, 96);
1192                  else if ((0x400000004L & l) != 0L)
1193                     jjAddStates(97, 99);
1194                  else if ((0x400000004000000L & l) != 0L)
1195                     jjstateSet[jjnewStateCnt++] = 37;
1196                  else if ((0x20000000200000L & l) != 0L)
1197                     jjstateSet[jjnewStateCnt++] = 30;
1198                  else if ((0x2000000020000L & l) != 0L)
1199                     jjstateSet[jjnewStateCnt++] = 18;
1200                  else if ((0x10000000100L & l) != 0L)
1201                     jjstateSet[jjnewStateCnt++] = 12;
1202                  else if ((0x200000002L & l) != 0L)
1203                     jjstateSet[jjnewStateCnt++] = 6;
1204                  break;
1205               case 0:
1206                  if ((0x10000000100L & l) == 0L)
1207                     break;
1208                  if (kind > 11)
1209                     kind = 11;
1210                  jjCheckNAdd(1);
1211                  break;
1212               case 2:
1213               case 88:
1214               case 490:
1215               case 505:
1216               case 544:
1217               case 884:
1218                  if ((0x10000000100000L & l) != 0L)
1219                     jjCheckNAdd(0);
1220                  break;
1221               case 3:
1222                  if ((0x20000000200000L & l) != 0L)
1223                     jjstateSet[jjnewStateCnt++] = 2;
1224                  break;
1225               case 4:
1226                  if ((0x200000002000L & l) != 0L)
1227                     jjstateSet[jjnewStateCnt++] = 3;
1228                  break;
1229               case 5:
1230                  if ((0x20000000200L & l) != 0L)
1231                     jjstateSet[jjnewStateCnt++] = 4;
1232                  break;
1233               case 6:
1234                  if ((0x400000004000000L & l) != 0L)
1235                     jjstateSet[jjnewStateCnt++] = 5;
1236                  break;
1237               case 8:
1238                  if ((0x10000000100000L & l) == 0L)
1239                     break;
1240                  if (kind > 11)
1241                     kind = 11;
1242                  jjCheckNAdd(1);
1243                  break;
1244               case 9:
1245               case 130:
1246               case 322:
1247               case 364:
1248               case 438:
1249               case 482:
1250               case 497:
1251               case 577:
1252               case 712:
1253                  if ((0x10000000100L & l) != 0L)
1254                     jjCheckNAdd(8);
1255                  break;
1256               case 10:
1257                  if ((0x8000000080L & l) != 0L)
1258                     jjstateSet[jjnewStateCnt++] = 9;
1259                  break;
1260               case 11:
1261                  if ((0x20000000200L & l) != 0L)
1262                     jjstateSet[jjnewStateCnt++] = 10;
1263                  break;
1264               case 12:
1265                  if ((0x2000000020L & l) != 0L)
1266                     jjstateSet[jjnewStateCnt++] = 11;
1267                  break;
1268               case 13:
1269                  if ((0x10000000100L & l) != 0L)
1270                     jjstateSet[jjnewStateCnt++] = 12;
1271                  break;
1272               case 14:
1273                  if ((0x8000000080000L & l) == 0L)
1274                     break;
1275                  if (kind > 11)
1276                     kind = 11;
1277                  jjCheckNAdd(1);
1278                  break;
1279               case 15:
1280                  if ((0x2000000020L & l) != 0L)
1281                     jjCheckNAdd(14);
1282                  break;
1283               case 16:
1284                  if ((0x10000000100000L & l) != 0L)
1285                     jjstateSet[jjnewStateCnt++] = 15;
1286                  break;
1287               case 17:
1288                  if ((0x800000008000L & l) != 0L)
1289                     jjstateSet[jjnewStateCnt++] = 16;
1290                  break;
1291               case 18:
1292                  if ((0x20000000200000L & l) != 0L)
1293                     jjstateSet[jjnewStateCnt++] = 17;
1294                  break;
1295               case 19:
1296                  if ((0x2000000020000L & l) != 0L)
1297                     jjstateSet[jjnewStateCnt++] = 18;
1298                  break;
1299               case 20:
1300                  if ((0x20000000200L & l) == 0L)
1301                     break;
1302                  if (kind > 11)
1303                     kind = 11;
1304                  jjCheckNAdd(1);
1305                  break;
1306               case 21:
1307                  if ((0x1000000010L & l) != 0L)
1308                     jjstateSet[jjnewStateCnt++] = 20;
1309                  break;
1310               case 22:
1311                  if ((0x20000000200L & l) != 0L)
1312                     jjstateSet[jjnewStateCnt++] = 21;
1313                  break;
1314               case 23:
1315                  if ((0x400000004L & l) != 0L)
1316                     jjstateSet[jjnewStateCnt++] = 22;
1317                  break;
1318               case 25:
1319                  if ((0x2000000020L & l) != 0L)
1320                     jjstateSet[jjnewStateCnt++] = 24;
1321                  break;
1322               case 26:
1323                  if ((0x1000000010L & l) != 0L)
1324                     jjstateSet[jjnewStateCnt++] = 25;
1325                  break;
1326               case 27:
1327                  if ((0x800000008000L & l) != 0L)
1328                     jjstateSet[jjnewStateCnt++] = 26;
1329                  break;
1330               case 28:
1331                  if ((0x800000008L & l) != 0L)
1332                     jjstateSet[jjnewStateCnt++] = 27;
1333                  break;
1334               case 29:
1335                  if ((0x20000000200L & l) != 0L)
1336                     jjstateSet[jjnewStateCnt++] = 28;
1337                  break;
1338               case 30:
1339                  if ((0x400000004000L & l) != 0L)
1340                     jjstateSet[jjnewStateCnt++] = 29;
1341                  break;
1342               case 31:
1343                  if ((0x20000000200000L & l) != 0L)
1344                     jjstateSet[jjnewStateCnt++] = 30;
1345                  break;
1346               case 32:
1347                  if ((0x100000001000000L & l) == 0L)
1348                     break;
1349                  if (kind > 11)
1350                     kind = 11;
1351                  jjCheckNAdd(1);
1352                  break;
1353               case 33:
1354                  if ((0x2000000020L & l) != 0L)
1355                     jjstateSet[jjnewStateCnt++] = 32;
1356                  break;
1357               case 34:
1358                  if ((0x1000000010L & l) != 0L)
1359                     jjstateSet[jjnewStateCnt++] = 33;
1360                  break;
1361               case 35:
1362                  if ((0x400000004000L & l) != 0L)
1363                     jjstateSet[jjnewStateCnt++] = 34;
1364                  break;
1365               case 36:
1366                  if ((0x20000000200L & l) != 0L)
1367                     jjstateSet[jjnewStateCnt++] = 35;
1368                  break;
1369               case 38:
1370                  if ((0x400000004000000L & l) != 0L)
1371                     jjstateSet[jjnewStateCnt++] = 37;
1372                  break;
1373               case 39:
1374                  if ((0xdfffffffffffffffL & l) == 0L)
1375                     break;
1376                  if (kind > 12)
1377                     kind = 12;
1378                  jjCheckNAdd(39);
1379                  break;
1380               case 42:
1381                  if (curChar == 125)
1382                     kind = 15;
1383                  break;
1384               case 43:
1385                  if ((0x400000004L & l) != 0L)
1386                     jjAddStates(97, 99);
1387                  break;
1388               case 44:
1389                  if ((0x1000000010L & l) == 0L)
1390                     break;
1391                  if (kind > 11)
1392                     kind = 11;
1393                  jjCheckNAddTwoStates(45, 1);
1394                  break;
1395               case 46:
1396               case 223:
1397               case 228:
1398               case 316:
1399               case 804:
1400                  if ((0x400000004000L & l) != 0L)
1401                     jjCheckNAdd(8);
1402                  break;
1403               case 47:
1404                  if ((0x2000000020L & l) != 0L)
1405                     jjstateSet[jjnewStateCnt++] = 46;
1406                  break;
1407               case 48:
1408                  if ((0x200000002000L & l) != 0L)
1409                     jjstateSet[jjnewStateCnt++] = 47;
1410                  break;
1411               case 49:
1412                  if ((0x10000000100L & l) != 0L)
1413                     jjstateSet[jjnewStateCnt++] = 48;
1414                  break;
1415               case 50:
1416                  if ((0x800000008L & l) != 0L)
1417                     jjstateSet[jjnewStateCnt++] = 49;
1418                  break;
1419               case 51:
1420                  if ((0x200000002L & l) != 0L)
1421                     jjstateSet[jjnewStateCnt++] = 50;
1422                  break;
1423               case 52:
1424                  if ((0x10000000100000L & l) != 0L)
1425                     jjstateSet[jjnewStateCnt++] = 51;
1426                  break;
1427               case 53:
1428                  if ((0x10000000100000L & l) != 0L)
1429                     jjstateSet[jjnewStateCnt++] = 52;
1430                  break;
1431               case 54:
1432                  if ((0x200000002L & l) != 0L)
1433                     jjstateSet[jjnewStateCnt++] = 53;
1434                  break;
1435               case 55:
1436                  if ((0x4000000040000L & l) == 0L)
1437                     break;
1438                  if (kind > 11)
1439                     kind = 11;
1440                  jjCheckNAdd(1);
1441                  break;
1442               case 56:
1443               case 99:
1444               case 115:
1445               case 133:
1446               case 157:
1447               case 180:
1448               case 220:
1449               case 270:
1450               case 522:
1451                  if ((0x800000008000L & l) != 0L)
1452                     jjCheckNAdd(55);
1453                  break;
1454               case 57:
1455                  if ((0x100000001000L & l) != 0L)
1456                     jjstateSet[jjnewStateCnt++] = 56;
1457                  break;
1458               case 58:
1459                  if ((0x800000008000L & l) != 0L)
1460                     jjstateSet[jjnewStateCnt++] = 57;
1461                  break;
1462               case 59:
1463                  if ((0x800000008L & l) != 0L)
1464                     jjstateSet[jjnewStateCnt++] = 58;
1465                  break;
1466               case 60:
1467                  if ((0x2000000020L & l) == 0L)
1468                     break;
1469                  if (kind > 11)
1470                     kind = 11;
1471                  jjCheckNAdd(1);
1472                  break;
1473               case 61:
1474               case 381:
1475               case 610:
1476               case 681:
1477                  if ((0x8000000080L & l) != 0L)
1478                     jjCheckNAdd(60);
1479                  break;
1480               case 62:
1481                  if ((0x200000002L & l) != 0L)
1482                     jjstateSet[jjnewStateCnt++] = 61;
1483                  break;
1484               case 63:
1485                  if ((0x200000002000L & l) != 0L)
1486                     jjstateSet[jjnewStateCnt++] = 62;
1487                  break;
1488               case 64:
1489                  if ((0x20000000200L & l) != 0L)
1490                     jjstateSet[jjnewStateCnt++] = 63;
1491                  break;
1492               case 65:
1493                  if ((0x400000004000L & l) == 0L)
1494                     break;
1495                  if (kind > 11)
1496                     kind = 11;
1497                  jjCheckNAdd(1);
1498                  break;
1499               case 66:
1500               case 275:
1501               case 289:
1502               case 395:
1503               case 699:
1504               case 744:
1505               case 791:
1506                  if ((0x800000008000L & l) != 0L)
1507                     jjCheckNAdd(65);
1508                  break;
1509               case 67:
1510                  if ((0x20000000200L & l) != 0L)
1511                     jjstateSet[jjnewStateCnt++] = 66;
1512                  break;
1513               case 68:
1514                  if ((0x10000000100000L & l) != 0L)
1515                     jjstateSet[jjnewStateCnt++] = 67;
1516                  break;
1517               case 69:
1518                  if ((0x20000000200L & l) != 0L)
1519                     jjstateSet[jjnewStateCnt++] = 68;
1520                  break;
1521               case 70:
1522                  if ((0x8000000080000L & l) != 0L)
1523                     jjstateSet[jjnewStateCnt++] = 69;
1524                  break;
1525               case 71:
1526                  if ((0x800000008000L & l) != 0L)
1527                     jjstateSet[jjnewStateCnt++] = 70;
1528                  break;
1529               case 72:
1530                  if ((0x1000000010000L & l) != 0L)
1531                     jjstateSet[jjnewStateCnt++] = 71;
1532                  break;
1533               case 73:
1534               case 306:
1535                  if ((0x200000002L & l) != 0L)
1536                     jjCheckNAdd(8);
1537                  break;
1538               case 74:
1539                  if ((0x2000000020L & l) != 0L)
1540                     jjstateSet[jjnewStateCnt++] = 73;
1541                  break;
1542               case 75:
1543                  if ((0x1000000010000L & l) != 0L)
1544                     jjstateSet[jjnewStateCnt++] = 74;
1545                  break;
1546               case 76:
1547                  if ((0x2000000020L & l) != 0L)
1548                     jjstateSet[jjnewStateCnt++] = 75;
1549                  break;
1550               case 77:
1551                  if ((0x4000000040000L & l) != 0L)
1552                     jjstateSet[jjnewStateCnt++] = 76;
1553                  break;
1554               case 78:
1555                  if ((0x400000004000L & l) != 0L)
1556                     jjstateSet[jjnewStateCnt++] = 44;
1557                  break;
1558               case 79:
1559                  if ((0x20000000200000L & l) != 0L)
1560                     jjstateSet[jjnewStateCnt++] = 78;
1561                  break;
1562               case 80:
1563                  if ((0x800000008000L & l) != 0L)
1564                     jjstateSet[jjnewStateCnt++] = 79;
1565                  break;
1566               case 81:
1567                  if ((0x4000000040000L & l) != 0L)
1568                     jjstateSet[jjnewStateCnt++] = 80;
1569                  break;
1570               case 82:
1571                  if ((0x8000000080L & l) != 0L)
1572                     jjstateSet[jjnewStateCnt++] = 81;
1573                  break;
1574               case 83:
1575                  if ((0x80000000800L & l) != 0L)
1576                     jjstateSet[jjnewStateCnt++] = 82;
1577                  break;
1578               case 84:
1579                  if ((0x800000008L & l) != 0L)
1580                     jjstateSet[jjnewStateCnt++] = 83;
1581                  break;
1582               case 85:
1583                  if ((0x200000002L & l) != 0L)
1584                     jjstateSet[jjnewStateCnt++] = 84;
1585                  break;
1586               case 86:
1587                  if ((0x4000000040000L & l) == 0L)
1588                     break;
1589                  if (kind > 11)
1590                     kind = 11;
1591                  jjCheckNAddTwoStates(87, 1);
1592                  break;
1593               case 89:
1594                  if ((0x1000000010L & l) != 0L)
1595                     jjstateSet[jjnewStateCnt++] = 88;
1596                  break;
1597               case 90:
1598                  if ((0x20000000200L & l) != 0L)
1599                     jjstateSet[jjnewStateCnt++] = 89;
1600                  break;
1601               case 91:
1602                  if ((0x80000000800000L & l) != 0L)
1603                     jjstateSet[jjnewStateCnt++] = 90;
1604                  break;
1605               case 92:
1606                  if ((0x800000008L & l) != 0L)
1607                     jjAddStates(100, 101);
1608                  break;
1609               case 93:
1610               case 656:
1611                  if ((0x8000000080000L & l) != 0L)
1612                     jjCheckNAdd(60);
1613                  break;
1614               case 94:
1615                  if ((0x1000000010000L & l) != 0L)
1616                     jjstateSet[jjnewStateCnt++] = 93;
1617                  break;
1618               case 95:
1619                  if ((0x200000002L & l) != 0L)
1620                     jjstateSet[jjnewStateCnt++] = 94;
1621                  break;
1622               case 96:
1623                  if ((0x100000001000L & l) != 0L)
1624                     jjstateSet[jjnewStateCnt++] = 95;
1625                  break;
1626               case 97:
1627                  if ((0x100000001000L & l) != 0L)
1628                     jjstateSet[jjnewStateCnt++] = 96;
1629                  break;
1630               case 98:
1631                  if ((0x800000008000L & l) != 0L)
1632                     jjstateSet[jjnewStateCnt++] = 97;
1633                  break;
1634               case 100:
1635                  if ((0x100000001000L & l) != 0L)
1636                     jjstateSet[jjnewStateCnt++] = 99;
1637                  break;
1638               case 101:
1639                  if ((0x800000008000L & l) != 0L)
1640                     jjstateSet[jjnewStateCnt++] = 100;
1641                  break;
1642               case 102:
1643                  if ((0x8000000080000L & l) != 0L)
1644                     jjAddStates(102, 103);
1645                  break;
1646               case 103:
1647                  if ((0x8000000080L & l) == 0L)
1648                     break;
1649                  if (kind > 11)
1650                     kind = 11;
1651                  jjCheckNAdd(1);
1652                  break;
1653               case 104:
1654               case 352:
1655               case 563:
1656               case 690:
1657               case 887:
1658                  if ((0x400000004000L & l) != 0L)
1659                     jjCheckNAdd(103);
1660                  break;
1661               case 105:
1662                  if ((0x20000000200L & l) != 0L)
1663                     jjstateSet[jjnewStateCnt++] = 104;
1664                  break;
1665               case 106:
1666                  if ((0x800000008L & l) != 0L)
1667                     jjstateSet[jjnewStateCnt++] = 105;
1668                  break;
1669               case 107:
1670                  if ((0x200000002L & l) != 0L)
1671                     jjstateSet[jjnewStateCnt++] = 106;
1672                  break;
1673               case 108:
1674                  if ((0x1000000010000L & l) != 0L)
1675                     jjstateSet[jjnewStateCnt++] = 107;
1676                  break;
1677               case 109:
1678               case 122:
1679               case 142:
1680               case 167:
1681               case 188:
1682               case 344:
1683               case 373:
1684               case 533:
1685                  if ((0x100000001000L & l) != 0L)
1686                     jjCheckNAdd(60);
1687                  break;
1688               case 110:
1689                  if ((0x200000002000000L & l) != 0L)
1690                     jjstateSet[jjnewStateCnt++] = 109;
1691                  break;
1692               case 111:
1693                  if ((0x10000000100000L & l) != 0L)
1694                     jjstateSet[jjnewStateCnt++] = 110;
1695                  break;
1696               case 112:
1697                  if ((0x10000000100000L & l) != 0L)
1698                     jjAddStates(104, 106);
1699                  break;
1700               case 113:
1701                  if ((0x1000000010000L & l) == 0L)
1702                     break;
1703                  if (kind > 11)
1704                     kind = 11;
1705                  jjCheckNAdd(1);
1706                  break;
1707               case 114:
1708               case 430:
1709               case 568:
1710               case 834:
1711                  if ((0x800000008000L & l) != 0L)
1712                     jjCheckNAdd(113);
1713                  break;
1714               case 116:
1715                  if ((0x100000001000L & l) != 0L)
1716                     jjstateSet[jjnewStateCnt++] = 115;
1717                  break;
1718               case 117:
1719                  if ((0x800000008000L & l) != 0L)
1720                     jjstateSet[jjnewStateCnt++] = 116;
1721                  break;
1722               case 118:
1723                  if ((0x800000008L & l) != 0L)
1724                     jjstateSet[jjnewStateCnt++] = 117;
1725                  break;
1726               case 120:
1727                  if ((0x1000000010000L & l) != 0L)
1728                     jjstateSet[jjnewStateCnt++] = 119;
1729                  break;
1730               case 121:
1731                  if ((0x800000008000L & l) != 0L)
1732                     jjstateSet[jjnewStateCnt++] = 120;
1733                  break;
1734               case 123:
1735                  if ((0x200000002000000L & l) != 0L)
1736                     jjstateSet[jjnewStateCnt++] = 122;
1737                  break;
1738               case 124:
1739                  if ((0x10000000100000L & l) != 0L)
1740                     jjstateSet[jjnewStateCnt++] = 123;
1741                  break;
1742               case 125:
1743                  if ((0x8000000080000L & l) != 0L)
1744                     jjstateSet[jjnewStateCnt++] = 124;
1745                  break;
1746               case 127:
1747                  if ((0x1000000010000L & l) != 0L)
1748                     jjstateSet[jjnewStateCnt++] = 126;
1749                  break;
1750               case 128:
1751                  if ((0x800000008000L & l) != 0L)
1752                     jjstateSet[jjnewStateCnt++] = 127;
1753                  break;
1754               case 129:
1755                  if ((0x4000000040000L & l) != 0L)
1756                     jjAddStates(107, 109);
1757                  break;
1758               case 131:
1759                  if ((0x8000000080L & l) != 0L)
1760                     jjstateSet[jjnewStateCnt++] = 130;
1761                  break;
1762               case 132:
1763                  if ((0x20000000200L & l) != 0L)
1764                     jjstateSet[jjnewStateCnt++] = 131;
1765                  break;
1766               case 134:
1767                  if ((0x100000001000L & l) != 0L)
1768                     jjstateSet[jjnewStateCnt++] = 133;
1769                  break;
1770               case 135:
1771                  if ((0x800000008000L & l) != 0L)
1772                     jjstateSet[jjnewStateCnt++] = 134;
1773                  break;
1774               case 136:
1775                  if ((0x800000008L & l) != 0L)
1776                     jjstateSet[jjnewStateCnt++] = 135;
1777                  break;
1778               case 138:
1779                  if ((0x10000000100000L & l) != 0L)
1780                     jjstateSet[jjnewStateCnt++] = 137;
1781                  break;
1782               case 139:
1783                  if ((0x10000000100L & l) != 0L)
1784                     jjstateSet[jjnewStateCnt++] = 138;
1785                  break;
1786               case 140:
1787                  if ((0x8000000080L & l) != 0L)
1788                     jjstateSet[jjnewStateCnt++] = 139;
1789                  break;
1790               case 141:
1791                  if ((0x20000000200L & l) != 0L)
1792                     jjstateSet[jjnewStateCnt++] = 140;
1793                  break;
1794               case 143:
1795                  if ((0x200000002000000L & l) != 0L)
1796                     jjstateSet[jjnewStateCnt++] = 142;
1797                  break;
1798               case 144:
1799                  if ((0x10000000100000L & l) != 0L)
1800                     jjstateSet[jjnewStateCnt++] = 143;
1801                  break;
1802               case 145:
1803                  if ((0x8000000080000L & l) != 0L)
1804                     jjstateSet[jjnewStateCnt++] = 144;
1805                  break;
1806               case 147:
1807                  if ((0x10000000100000L & l) != 0L)
1808                     jjstateSet[jjnewStateCnt++] = 146;
1809                  break;
1810               case 148:
1811                  if ((0x10000000100L & l) != 0L)
1812                     jjstateSet[jjnewStateCnt++] = 147;
1813                  break;
1814               case 149:
1815                  if ((0x8000000080L & l) != 0L)
1816                     jjstateSet[jjnewStateCnt++] = 148;
1817                  break;
1818               case 150:
1819                  if ((0x20000000200L & l) != 0L)
1820                     jjstateSet[jjnewStateCnt++] = 149;
1821                  break;
1822               case 151:
1823                  if ((0x400000004L & l) != 0L)
1824                     jjAddStates(110, 112);
1825                  break;
1826               case 152:
1827                  if ((0x200000002000L & l) == 0L)
1828                     break;
1829                  if (kind > 11)
1830                     kind = 11;
1831                  jjCheckNAdd(1);
1832                  break;
1833               case 153:
1834               case 200:
1835               case 448:
1836               case 588:
1837                  if ((0x800000008000L & l) != 0L)
1838                     jjCheckNAdd(152);
1839                  break;
1840               case 154:
1841                  if ((0x10000000100000L & l) != 0L)
1842                     jjstateSet[jjnewStateCnt++] = 153;
1843                  break;
1844               case 155:
1845                  if ((0x10000000100000L & l) != 0L)
1846                     jjstateSet[jjnewStateCnt++] = 154;
1847                  break;
1848               case 156:
1849                  if ((0x800000008000L & l) != 0L)
1850                     jjstateSet[jjnewStateCnt++] = 155;
1851                  break;
1852               case 158:
1853                  if ((0x100000001000L & l) != 0L)
1854                     jjstateSet[jjnewStateCnt++] = 157;
1855                  break;
1856               case 159:
1857                  if ((0x800000008000L & l) != 0L)
1858                     jjstateSet[jjnewStateCnt++] = 158;
1859                  break;
1860               case 160:
1861                  if ((0x800000008L & l) != 0L)
1862                     jjstateSet[jjnewStateCnt++] = 159;
1863                  break;
1864               case 162:
1865                  if ((0x200000002000L & l) != 0L)
1866                     jjstateSet[jjnewStateCnt++] = 161;
1867                  break;
1868               case 163:
1869                  if ((0x800000008000L & l) != 0L)
1870                     jjstateSet[jjnewStateCnt++] = 162;
1871                  break;
1872               case 164:
1873                  if ((0x10000000100000L & l) != 0L)
1874                     jjstateSet[jjnewStateCnt++] = 163;
1875                  break;
1876               case 165:
1877                  if ((0x10000000100000L & l) != 0L)
1878                     jjstateSet[jjnewStateCnt++] = 164;
1879                  break;
1880               case 166:
1881                  if ((0x800000008000L & l) != 0L)
1882                     jjstateSet[jjnewStateCnt++] = 165;
1883                  break;
1884               case 168:
1885                  if ((0x200000002000000L & l) != 0L)
1886                     jjstateSet[jjnewStateCnt++] = 167;
1887                  break;
1888               case 169:
1889                  if ((0x10000000100000L & l) != 0L)
1890                     jjstateSet[jjnewStateCnt++] = 168;
1891                  break;
1892               case 170:
1893                  if ((0x8000000080000L & l) != 0L)
1894                     jjstateSet[jjnewStateCnt++] = 169;
1895                  break;
1896               case 172:
1897                  if ((0x200000002000L & l) != 0L)
1898                     jjstateSet[jjnewStateCnt++] = 171;
1899                  break;
1900               case 173:
1901                  if ((0x800000008000L & l) != 0L)
1902                     jjstateSet[jjnewStateCnt++] = 172;
1903                  break;
1904               case 174:
1905                  if ((0x10000000100000L & l) != 0L)
1906                     jjstateSet[jjnewStateCnt++] = 173;
1907                  break;
1908               case 175:
1909                  if ((0x10000000100000L & l) != 0L)
1910                     jjstateSet[jjnewStateCnt++] = 174;
1911                  break;
1912               case 176:
1913                  if ((0x800000008000L & l) != 0L)
1914                     jjstateSet[jjnewStateCnt++] = 175;
1915                  break;
1916               case 177:
1917                  if ((0x100000001000L & l) != 0L)
1918                     jjAddStates(113, 115);
1919                  break;
1920               case 178:
1921               case 350:
1922               case 459:
1923               case 600:
1924                  if ((0x4000000040L & l) != 0L)
1925                     jjCheckNAdd(8);
1926                  break;
1927               case 179:
1928                  if ((0x2000000020L & l) != 0L)
1929                     jjstateSet[jjnewStateCnt++] = 178;
1930                  break;
1931               case 181:
1932                  if ((0x100000001000L & l) != 0L)
1933                     jjstateSet[jjnewStateCnt++] = 180;
1934                  break;
1935               case 182:
1936                  if ((0x800000008000L & l) != 0L)
1937                     jjstateSet[jjnewStateCnt++] = 181;
1938                  break;
1939               case 183:
1940                  if ((0x800000008L & l) != 0L)
1941                     jjstateSet[jjnewStateCnt++] = 182;
1942                  break;
1943               case 185:
1944                  if ((0x10000000100000L & l) != 0L)
1945                     jjstateSet[jjnewStateCnt++] = 184;
1946                  break;
1947               case 186:
1948                  if ((0x4000000040L & l) != 0L)
1949                     jjstateSet[jjnewStateCnt++] = 185;
1950                  break;
1951               case 187:
1952                  if ((0x2000000020L & l) != 0L)
1953                     jjstateSet[jjnewStateCnt++] = 186;
1954                  break;
1955               case 189:
1956                  if ((0x200000002000000L & l) != 0L)
1957                     jjstateSet[jjnewStateCnt++] = 188;
1958                  break;
1959               case 190:
1960                  if ((0x10000000100000L & l) != 0L)
1961                     jjstateSet[jjnewStateCnt++] = 189;
1962                  break;
1963               case 191:
1964                  if ((0x8000000080000L & l) != 0L)
1965                     jjstateSet[jjnewStateCnt++] = 190;
1966                  break;
1967               case 193:
1968                  if ((0x10000000100000L & l) != 0L)
1969                     jjstateSet[jjnewStateCnt++] = 192;
1970                  break;
1971               case 194:
1972                  if ((0x4000000040L & l) != 0L)
1973                     jjstateSet[jjnewStateCnt++] = 193;
1974                  break;
1975               case 195:
1976                  if ((0x2000000020L & l) != 0L)
1977                     jjstateSet[jjnewStateCnt++] = 194;
1978                  break;
1979               case 196:
1980                  if ((0x2000000020L & l) != 0L)
1981                     jjstateSet[jjnewStateCnt++] = 86;
1982                  break;
1983               case 197:
1984                  if ((0x1000000010L & l) != 0L)
1985                     jjstateSet[jjnewStateCnt++] = 196;
1986                  break;
1987               case 198:
1988                  if ((0x4000000040000L & l) != 0L)
1989                     jjstateSet[jjnewStateCnt++] = 197;
1990                  break;
1991               case 199:
1992                  if ((0x800000008000L & l) != 0L)
1993                     jjstateSet[jjnewStateCnt++] = 198;
1994                  break;
1995               case 201:
1996                  if ((0x10000000100000L & l) != 0L)
1997                     jjstateSet[jjnewStateCnt++] = 200;
1998                  break;
1999               case 202:
2000                  if ((0x10000000100000L & l) != 0L)
2001                     jjstateSet[jjnewStateCnt++] = 201;
2002                  break;
2003               case 203:
2004                  if ((0x800000008000L & l) != 0L)
2005                     jjstateSet[jjnewStateCnt++] = 202;
2006                  break;
2007               case 204:
2008                  if ((0x800000008L & l) != 0L)
2009                     jjAddStates(86, 96);
2010                  break;
2011               case 205:
2012               case 641:
2013                  if ((0x1000000010L & l) != 0L)
2014                     jjCheckNAdd(60);
2015                  break;
2016               case 206:
2017                  if ((0x20000000200L & l) != 0L)
2018                     jjstateSet[jjnewStateCnt++] = 205;
2019                  break;
2020               case 207:
2021                  if ((0x8000000080000L & l) != 0L)
2022                     jjstateSet[jjnewStateCnt++] = 206;
2023                  break;
2024               case 209:
2025                  if ((0x400000004000L & l) != 0L)
2026                     jjstateSet[jjnewStateCnt++] = 208;
2027                  break;
2028               case 210:
2029                  if ((0x800000008000L & l) != 0L)
2030                     jjstateSet[jjnewStateCnt++] = 209;
2031                  break;
2032               case 211:
2033                  if ((0x20000000200L & l) != 0L)
2034                     jjstateSet[jjnewStateCnt++] = 210;
2035                  break;
2036               case 212:
2037                  if ((0x10000000100000L & l) != 0L)
2038                     jjstateSet[jjnewStateCnt++] = 211;
2039                  break;
2040               case 213:
2041                  if ((0x1000000010000L & l) != 0L)
2042                     jjstateSet[jjnewStateCnt++] = 212;
2043                  break;
2044               case 214:
2045                  if ((0x200000002L & l) != 0L)
2046                     jjstateSet[jjnewStateCnt++] = 213;
2047                  break;
2048               case 215:
2049                  if ((0x200000002L & l) != 0L)
2050                     jjCheckNAdd(55);
2051                  break;
2052               case 216:
2053                  if ((0x2000000020L & l) != 0L)
2054                     jjstateSet[jjnewStateCnt++] = 215;
2055                  break;
2056               case 217:
2057                  if ((0x100000001000L & l) != 0L)
2058                     jjstateSet[jjnewStateCnt++] = 216;
2059                  break;
2060               case 218:
2061                  if ((0x20000000200L & l) != 0L)
2062                     jjCheckNAdd(113);
2063                  break;
2064               case 219:
2065                  if ((0x100000001000L & l) != 0L)
2066                     jjstateSet[jjnewStateCnt++] = 218;
2067                  break;
2068               case 221:
2069                  if ((0x100000001000L & l) != 0L)
2070                     jjstateSet[jjnewStateCnt++] = 220;
2071                  break;
2072               case 222:
2073                  if ((0x800000008000L & l) != 0L)
2074                     jjstateSet[jjnewStateCnt++] = 221;
2075                  break;
2076               case 224:
2077                  if ((0x2000000020L & l) != 0L)
2078                     jjstateSet[jjnewStateCnt++] = 223;
2079                  break;
2080               case 225:
2081                  if ((0x10000000100000L & l) != 0L)
2082                     jjstateSet[jjnewStateCnt++] = 224;
2083                  break;
2084               case 226:
2085                  if ((0x400000004000L & l) != 0L)
2086                     jjstateSet[jjnewStateCnt++] = 225;
2087                  break;
2088               case 227:
2089                  if ((0x800000008000L & l) != 0L)
2090                     jjstateSet[jjnewStateCnt++] = 226;
2091                  break;
2092               case 229:
2093                  if ((0x2000000020L & l) != 0L)
2094                     jjstateSet[jjnewStateCnt++] = 228;
2095                  break;
2096               case 230:
2097                  if ((0x200000002000L & l) != 0L)
2098                     jjstateSet[jjnewStateCnt++] = 229;
2099                  break;
2100               case 231:
2101                  if ((0x2000000020L & l) != 0L)
2102                     jjstateSet[jjnewStateCnt++] = 230;
2103                  break;
2104               case 232:
2105                  if ((0x4000000040000L & l) != 0L)
2106                     jjstateSet[jjnewStateCnt++] = 231;
2107                  break;
2108               case 233:
2109                  if ((0x800000008L & l) != 0L)
2110                     jjstateSet[jjnewStateCnt++] = 232;
2111                  break;
2112               case 234:
2113                  if ((0x400000004000L & l) != 0L)
2114                     jjstateSet[jjnewStateCnt++] = 233;
2115                  break;
2116               case 235:
2117                  if ((0x20000000200L & l) != 0L)
2118                     jjstateSet[jjnewStateCnt++] = 234;
2119                  break;
2120               case 237:
2121                  if ((0x4000000040000L & l) != 0L)
2122                     jjstateSet[jjnewStateCnt++] = 236;
2123                  break;
2124               case 238:
2125                  if ((0x2000000020L & l) != 0L)
2126                     jjstateSet[jjnewStateCnt++] = 237;
2127                  break;
2128               case 239:
2129                  if ((0x10000000100000L & l) != 0L)
2130                     jjstateSet[jjnewStateCnt++] = 238;
2131                  break;
2132               case 240:
2133                  if ((0x400000004000L & l) != 0L)
2134                     jjstateSet[jjnewStateCnt++] = 239;
2135                  break;
2136               case 241:
2137                  if ((0x20000000200000L & l) != 0L)
2138                     jjstateSet[jjnewStateCnt++] = 240;
2139                  break;
2140               case 242:
2141                  if ((0x800000008000L & l) != 0L)
2142                     jjstateSet[jjnewStateCnt++] = 241;
2143                  break;
2144               case 243:
2145               case 468:
2146                  if ((0x2000000020L & l) != 0L)
2147                     jjCheckNAdd(8);
2148                  break;
2149               case 244:
2150                  if ((0x8000000080000L & l) != 0L)
2151                     jjstateSet[jjnewStateCnt++] = 243;
2152                  break;
2153               case 245:
2154                  if ((0x2000000020L & l) != 0L)
2155                     jjstateSet[jjnewStateCnt++] = 244;
2156                  break;
2157               case 246:
2158                  if ((0x4000000040000L & l) != 0L)
2159                     jjstateSet[jjnewStateCnt++] = 245;
2160                  break;
2161               case 248:
2162                  if ((0x4000000040000L & l) != 0L)
2163                     jjstateSet[jjnewStateCnt++] = 247;
2164                  break;
2165               case 249:
2166                  if ((0x2000000020L & l) != 0L)
2167                     jjstateSet[jjnewStateCnt++] = 248;
2168                  break;
2169               case 250:
2170                  if ((0x10000000100000L & l) != 0L)
2171                     jjstateSet[jjnewStateCnt++] = 249;
2172                  break;
2173               case 251:
2174                  if ((0x400000004000L & l) != 0L)
2175                     jjstateSet[jjnewStateCnt++] = 250;
2176                  break;
2177               case 252:
2178                  if ((0x20000000200000L & l) != 0L)
2179                     jjstateSet[jjnewStateCnt++] = 251;
2180                  break;
2181               case 253:
2182                  if ((0x800000008000L & l) != 0L)
2183                     jjstateSet[jjnewStateCnt++] = 252;
2184                  break;
2185               case 254:
2186                  if ((0x20000000200000L & l) != 0L)
2187                     jjCheckNAdd(60);
2188                  break;
2189               case 255:
2190               case 612:
2191               case 659:
2192               case 722:
2193                  if ((0x2000000020L & l) != 0L)
2194                     jjCheckNAdd(55);
2195                  break;
2196               case 256:
2197                  if ((0x10000000100000L & l) != 0L)
2198                     jjstateSet[jjnewStateCnt++] = 255;
2199                  break;
2200               case 257:
2201                  if ((0x4000000040L & l) != 0L)
2202                     jjstateSet[jjnewStateCnt++] = 256;
2203                  break;
2204               case 258:
2205                  if ((0x200000002L & l) != 0L)
2206                     jjstateSet[jjnewStateCnt++] = 257;
2207                  break;
2208               case 260:
2209                  if ((0x2000000020L & l) != 0L)
2210                     jjstateSet[jjnewStateCnt++] = 259;
2211                  break;
2212               case 261:
2213                  if ((0x20000000200000L & l) != 0L)
2214                     jjstateSet[jjnewStateCnt++] = 260;
2215                  break;
2216               case 262:
2217               case 626:
2218               case 668:
2219                  if ((0x4000000040000L & l) != 0L)
2220                     jjCheckNAdd(60);
2221                  break;
2222               case 263:
2223                  if ((0x800000008000L & l) != 0L)
2224                     jjstateSet[jjnewStateCnt++] = 262;
2225                  break;
2226               case 264:
2227                  if ((0x4000000040L & l) != 0L)
2228                     jjstateSet[jjnewStateCnt++] = 263;
2229                  break;
2230               case 265:
2231                  if ((0x2000000020L & l) != 0L)
2232                     jjstateSet[jjnewStateCnt++] = 264;
2233                  break;
2234               case 266:
2235                  if ((0x400000004L & l) != 0L)
2236                     jjstateSet[jjnewStateCnt++] = 265;
2237                  break;
2238               case 268:
2239                  if ((0x2000000020L & l) != 0L)
2240                     jjstateSet[jjnewStateCnt++] = 267;
2241                  break;
2242               case 269:
2243                  if ((0x20000000200000L & l) != 0L)
2244                     jjstateSet[jjnewStateCnt++] = 268;
2245                  break;
2246               case 271:
2247                  if ((0x8000000080000L & l) != 0L)
2248                     jjstateSet[jjnewStateCnt++] = 270;
2249                  break;
2250               case 272:
2251                  if ((0x4000000040000L & l) != 0L)
2252                     jjstateSet[jjnewStateCnt++] = 271;
2253                  break;
2254               case 273:
2255                  if ((0x20000000200000L & l) != 0L)
2256                     jjstateSet[jjnewStateCnt++] = 272;
2257                  break;
2258               case 274:
2259                  if ((0x1000000010L & l) != 0L)
2260                     jjAddStates(84, 85);
2261                  break;
2262               case 276:
2263                  if ((0x20000000200L & l) != 0L)
2264                     jjstateSet[jjnewStateCnt++] = 275;
2265                  break;
2266               case 277:
2267                  if ((0x10000000100000L & l) != 0L)
2268                     jjstateSet[jjnewStateCnt++] = 276;
2269                  break;
2270               case 278:
2271                  if ((0x800000008L & l) != 0L)
2272                     jjstateSet[jjnewStateCnt++] = 277;
2273                  break;
2274               case 279:
2275                  if ((0x2000000020L & l) != 0L)
2276                     jjstateSet[jjnewStateCnt++] = 278;
2277                  break;
2278               case 280:
2279                  if ((0x4000000040000L & l) != 0L)
2280                     jjstateSet[jjnewStateCnt++] = 279;
2281                  break;
2282               case 281:
2283                  if ((0x20000000200L & l) != 0L)
2284                     jjstateSet[jjnewStateCnt++] = 280;
2285                  break;
2286               case 282:
2287                  if ((0x200000002000000L & l) == 0L)
2288                     break;
2289                  if (kind > 11)
2290                     kind = 11;
2291                  jjCheckNAdd(1);
2292                  break;
2293               case 283:
2294                  if ((0x200000002L & l) != 0L)
2295                     jjCheckNAdd(282);
2296                  break;
2297               case 284:
2298                  if ((0x100000001000L & l) != 0L)
2299                     jjstateSet[jjnewStateCnt++] = 283;
2300                  break;
2301               case 285:
2302                  if ((0x1000000010000L & l) != 0L)
2303                     jjstateSet[jjnewStateCnt++] = 284;
2304                  break;
2305               case 286:
2306                  if ((0x8000000080000L & l) != 0L)
2307                     jjstateSet[jjnewStateCnt++] = 285;
2308                  break;
2309               case 287:
2310                  if ((0x20000000200L & l) != 0L)
2311                     jjstateSet[jjnewStateCnt++] = 286;
2312                  break;
2313               case 288:
2314                  if ((0x2000000020L & l) != 0L)
2315                     jjAddStates(82, 83);
2316                  break;
2317               case 290:
2318                  if ((0x20000000200L & l) != 0L)
2319                     jjstateSet[jjnewStateCnt++] = 289;
2320                  break;
2321               case 291:
2322                  if ((0x10000000100000L & l) != 0L)
2323                     jjstateSet[jjnewStateCnt++] = 290;
2324                  break;
2325               case 292:
2326                  if ((0x200000002L & l) != 0L)
2327                     jjstateSet[jjnewStateCnt++] = 291;
2328                  break;
2329               case 293:
2330                  if ((0x40000000400000L & l) != 0L)
2331                     jjstateSet[jjnewStateCnt++] = 292;
2332                  break;
2333               case 294:
2334                  if ((0x2000000020L & l) != 0L)
2335                     jjstateSet[jjnewStateCnt++] = 293;
2336                  break;
2337               case 295:
2338                  if ((0x100000001000L & l) != 0L)
2339                     jjstateSet[jjnewStateCnt++] = 294;
2340                  break;
2341               case 296:
2342                  if ((0x100000001000L & l) != 0L)
2343                     jjCheckNAdd(14);
2344                  break;
2345               case 297:
2346                  if ((0x100000001000L & l) != 0L)
2347                     jjstateSet[jjnewStateCnt++] = 296;
2348                  break;
2349               case 298:
2350                  if ((0x2000000020L & l) != 0L)
2351                     jjstateSet[jjnewStateCnt++] = 297;
2352                  break;
2353               case 299:
2354                  if ((0x800000008L & l) != 0L)
2355                     jjstateSet[jjnewStateCnt++] = 298;
2356                  break;
2357               case 301:
2358                  if ((0x200000002000000L & l) != 0L)
2359                     jjstateSet[jjnewStateCnt++] = 300;
2360                  break;
2361               case 302:
2362                  if ((0x10000000100000L & l) != 0L)
2363                     jjstateSet[jjnewStateCnt++] = 301;
2364                  break;
2365               case 303:
2366                  if ((0x1000000010000L & l) != 0L)
2367                     jjstateSet[jjnewStateCnt++] = 302;
2368                  break;
2369               case 304:
2370                  if ((0x200000002000L & l) != 0L)
2371                     jjstateSet[jjnewStateCnt++] = 303;
2372                  break;
2373               case 305:
2374                  if ((0x4000000040L & l) != 0L)
2375                     jjAddStates(80, 81);
2376                  break;
2377               case 307:
2378                  if ((0x800000008000L & l) != 0L)
2379                     jjstateSet[jjnewStateCnt++] = 306;
2380                  break;
2381               case 308:
2382                  if ((0x100000001000L & l) != 0L)
2383                     jjstateSet[jjnewStateCnt++] = 307;
2384                  break;
2385               case 309:
2386                  if ((0x10000000100000L & l) == 0L)
2387                     break;
2388                  if (kind > 11)
2389                     kind = 11;
2390                  jjCheckNAddTwoStates(310, 1);
2391                  break;
2392               case 311:
2393               case 856:
2394                  if ((0x100000001000L & l) != 0L)
2395                     jjCheckNAdd(282);
2396                  break;
2397               case 312:
2398                  if ((0x20000000200L & l) != 0L)
2399                     jjstateSet[jjnewStateCnt++] = 311;
2400                  break;
2401               case 313:
2402                  if ((0x200000002000L & l) != 0L)
2403                     jjstateSet[jjnewStateCnt++] = 312;
2404                  break;
2405               case 314:
2406                  if ((0x200000002L & l) != 0L)
2407                     jjstateSet[jjnewStateCnt++] = 313;
2408                  break;
2409               case 315:
2410                  if ((0x4000000040L & l) != 0L)
2411                     jjstateSet[jjnewStateCnt++] = 314;
2412                  break;
2413               case 317:
2414                  if ((0x200000002L & l) != 0L)
2415                     jjstateSet[jjnewStateCnt++] = 316;
2416                  break;
2417               case 318:
2418                  if ((0x20000000200L & l) != 0L)
2419                     jjstateSet[jjnewStateCnt++] = 317;
2420                  break;
2421               case 319:
2422                  if ((0x4000000040000L & l) != 0L)
2423                     jjstateSet[jjnewStateCnt++] = 318;
2424                  break;
2425               case 320:
2426                  if ((0x200000002L & l) != 0L)
2427                     jjstateSet[jjnewStateCnt++] = 319;
2428                  break;
2429               case 321:
2430                  if ((0x40000000400000L & l) != 0L)
2431                     jjstateSet[jjnewStateCnt++] = 320;
2432                  break;
2433               case 323:
2434                  if ((0x8000000080L & l) != 0L)
2435                     jjstateSet[jjnewStateCnt++] = 322;
2436                  break;
2437               case 324:
2438                  if ((0x20000000200L & l) != 0L)
2439                     jjstateSet[jjnewStateCnt++] = 323;
2440                  break;
2441               case 325:
2442                  if ((0x2000000020L & l) != 0L)
2443                     jjstateSet[jjnewStateCnt++] = 324;
2444                  break;
2445               case 326:
2446                  if ((0x80000000800000L & l) != 0L)
2447                     jjstateSet[jjnewStateCnt++] = 325;
2448                  break;
2449               case 327:
2450                  if ((0x8000000080000L & l) != 0L)
2451                     jjAddStates(116, 119);
2452                  break;
2453               case 328:
2454               case 716:
2455                  if ((0x400000004000000L & l) != 0L)
2456                     jjCheckNAdd(60);
2457                  break;
2458               case 329:
2459                  if ((0x20000000200L & l) != 0L)
2460                     jjstateSet[jjnewStateCnt++] = 328;
2461                  break;
2462               case 330:
2463                  if ((0x8000000080000L & l) != 0L)
2464                     jjCheckNAdd(8);
2465                  break;
2466               case 331:
2467                  if ((0x20000000200000L & l) != 0L)
2468                     jjstateSet[jjnewStateCnt++] = 330;
2469                  break;
2470               case 332:
2471                  if ((0x40000000400L & l) != 0L)
2472                     jjstateSet[jjnewStateCnt++] = 331;
2473                  break;
2474               case 333:
2475                  if ((0x1000000010L & l) != 0L)
2476                     jjstateSet[jjnewStateCnt++] = 332;
2477                  break;
2478               case 334:
2479                  if ((0x200000002L & l) != 0L)
2480                     jjstateSet[jjnewStateCnt++] = 333;
2481                  break;
2482               case 336:
2483                  if ((0x2000000020L & l) != 0L)
2484                     jjstateSet[jjnewStateCnt++] = 335;
2485                  break;
2486               case 337:
2487                  if ((0x400000004000000L & l) != 0L)
2488                     jjstateSet[jjnewStateCnt++] = 336;
2489                  break;
2490               case 338:
2491                  if ((0x20000000200L & l) != 0L)
2492                     jjstateSet[jjnewStateCnt++] = 337;
2493                  break;
2494               case 339:
2495               case 678:
2496                  if ((0x800000008L & l) != 0L)
2497                     jjCheckNAdd(0);
2498                  break;
2499               case 340:
2500                  if ((0x10000000100000L & l) != 0L)
2501                     jjstateSet[jjnewStateCnt++] = 339;
2502                  break;
2503               case 341:
2504                  if ((0x2000000020L & l) != 0L)
2505                     jjstateSet[jjnewStateCnt++] = 340;
2506                  break;
2507               case 342:
2508                  if ((0x4000000040000L & l) != 0L)
2509                     jjstateSet[jjnewStateCnt++] = 341;
2510                  break;
2511               case 343:
2512                  if ((0x10000000100000L & l) != 0L)
2513                     jjstateSet[jjnewStateCnt++] = 342;
2514                  break;
2515               case 345:
2516                  if ((0x200000002000000L & l) != 0L)
2517                     jjstateSet[jjnewStateCnt++] = 344;
2518                  break;
2519               case 346:
2520                  if ((0x10000000100000L & l) != 0L)
2521                     jjstateSet[jjnewStateCnt++] = 345;
2522                  break;
2523               case 347:
2524                  if ((0x400000004000L & l) != 0L)
2525                     jjstateSet[jjnewStateCnt++] = 309;
2526                  break;
2527               case 348:
2528                  if ((0x800000008000L & l) != 0L)
2529                     jjstateSet[jjnewStateCnt++] = 347;
2530                  break;
2531               case 349:
2532                  if ((0x100000001000L & l) != 0L)
2533                     jjAddStates(73, 79);
2534                  break;
2535               case 351:
2536                  if ((0x2000000020L & l) != 0L)
2537                     jjstateSet[jjnewStateCnt++] = 350;
2538                  break;
2539               case 353:
2540                  if ((0x20000000200L & l) != 0L)
2541                     jjstateSet[jjnewStateCnt++] = 352;
2542                  break;
2543               case 354:
2544                  if ((0x800000008L & l) != 0L)
2545                     jjstateSet[jjnewStateCnt++] = 353;
2546                  break;
2547               case 355:
2548                  if ((0x200000002L & l) != 0L)
2549                     jjstateSet[jjnewStateCnt++] = 354;
2550                  break;
2551               case 356:
2552                  if ((0x1000000010000L & l) != 0L)
2553                     jjstateSet[jjnewStateCnt++] = 355;
2554                  break;
2555               case 357:
2556                  if ((0x8000000080000L & l) != 0L)
2557                     jjstateSet[jjnewStateCnt++] = 356;
2558                  break;
2559               case 359:
2560                  if ((0x4000000040000L & l) != 0L)
2561                     jjstateSet[jjnewStateCnt++] = 358;
2562                  break;
2563               case 360:
2564                  if ((0x2000000020L & l) != 0L)
2565                     jjstateSet[jjnewStateCnt++] = 359;
2566                  break;
2567               case 361:
2568                  if ((0x10000000100000L & l) != 0L)
2569                     jjstateSet[jjnewStateCnt++] = 360;
2570                  break;
2571               case 362:
2572                  if ((0x10000000100000L & l) != 0L)
2573                     jjstateSet[jjnewStateCnt++] = 361;
2574                  break;
2575               case 363:
2576                  if ((0x2000000020L & l) != 0L)
2577                     jjstateSet[jjnewStateCnt++] = 362;
2578                  break;
2579               case 365:
2580                  if ((0x8000000080L & l) != 0L)
2581                     jjstateSet[jjnewStateCnt++] = 364;
2582                  break;
2583               case 366:
2584                  if ((0x20000000200L & l) != 0L)
2585                     jjstateSet[jjnewStateCnt++] = 365;
2586                  break;
2587               case 367:
2588                  if ((0x2000000020L & l) != 0L)
2589                     jjstateSet[jjnewStateCnt++] = 366;
2590                  break;
2591               case 368:
2592                  if ((0x10000000100L & l) != 0L)
2593                     jjstateSet[jjnewStateCnt++] = 367;
2594                  break;
2595               case 370:
2596                  if ((0x2000000020L & l) != 0L)
2597                     jjstateSet[jjnewStateCnt++] = 369;
2598                  break;
2599               case 371:
2600                  if ((0x400000004000L & l) != 0L)
2601                     jjstateSet[jjnewStateCnt++] = 370;
2602                  break;
2603               case 372:
2604                  if ((0x20000000200L & l) != 0L)
2605                     jjstateSet[jjnewStateCnt++] = 371;
2606                  break;
2607               case 374:
2608                  if ((0x200000002000000L & l) != 0L)
2609                     jjstateSet[jjnewStateCnt++] = 373;
2610                  break;
2611               case 375:
2612                  if ((0x10000000100000L & l) != 0L)
2613                     jjstateSet[jjnewStateCnt++] = 374;
2614                  break;
2615               case 376:
2616                  if ((0x8000000080000L & l) != 0L)
2617                     jjstateSet[jjnewStateCnt++] = 375;
2618                  break;
2619               case 378:
2620                  if ((0x10000000100000L & l) != 0L)
2621                     jjstateSet[jjnewStateCnt++] = 377;
2622                  break;
2623               case 379:
2624                  if ((0x8000000080000L & l) != 0L)
2625                     jjstateSet[jjnewStateCnt++] = 378;
2626                  break;
2627               case 380:
2628                  if ((0x20000000200L & l) != 0L)
2629                     jjstateSet[jjnewStateCnt++] = 379;
2630                  break;
2631               case 382:
2632                  if ((0x200000002L & l) != 0L)
2633                     jjstateSet[jjnewStateCnt++] = 381;
2634                  break;
2635               case 383:
2636                  if ((0x200000002000L & l) != 0L)
2637                     jjstateSet[jjnewStateCnt++] = 382;
2638                  break;
2639               case 384:
2640                  if ((0x20000000200L & l) != 0L)
2641                     jjstateSet[jjnewStateCnt++] = 383;
2642                  break;
2643               case 386:
2644                  if ((0x2000000020L & l) != 0L)
2645                     jjstateSet[jjnewStateCnt++] = 385;
2646                  break;
2647               case 387:
2648                  if ((0x100000001000L & l) != 0L)
2649                     jjstateSet[jjnewStateCnt++] = 386;
2650                  break;
2651               case 388:
2652                  if ((0x200000002000000L & l) != 0L)
2653                     jjstateSet[jjnewStateCnt++] = 387;
2654                  break;
2655               case 389:
2656                  if ((0x10000000100000L & l) != 0L)
2657                     jjstateSet[jjnewStateCnt++] = 388;
2658                  break;
2659               case 390:
2660                  if ((0x8000000080000L & l) != 0L)
2661                     jjstateSet[jjnewStateCnt++] = 389;
2662                  break;
2663               case 392:
2664                  if ((0x10000000100000L & l) != 0L)
2665                     jjstateSet[jjnewStateCnt++] = 391;
2666                  break;
2667               case 393:
2668                  if ((0x8000000080000L & l) != 0L)
2669                     jjstateSet[jjnewStateCnt++] = 392;
2670                  break;
2671               case 394:
2672                  if ((0x20000000200L & l) != 0L)
2673                     jjstateSet[jjnewStateCnt++] = 393;
2674                  break;
2675               case 396:
2676                  if ((0x20000000200L & l) != 0L)
2677                     jjstateSet[jjnewStateCnt++] = 395;
2678                  break;
2679               case 397:
2680                  if ((0x10000000100000L & l) != 0L)
2681                     jjstateSet[jjnewStateCnt++] = 396;
2682                  break;
2683               case 398:
2684                  if ((0x20000000200L & l) != 0L)
2685                     jjstateSet[jjnewStateCnt++] = 397;
2686                  break;
2687               case 399:
2688                  if ((0x8000000080000L & l) != 0L)
2689                     jjstateSet[jjnewStateCnt++] = 398;
2690                  break;
2691               case 400:
2692                  if ((0x800000008000L & l) != 0L)
2693                     jjstateSet[jjnewStateCnt++] = 399;
2694                  break;
2695               case 401:
2696                  if ((0x1000000010000L & l) != 0L)
2697                     jjstateSet[jjnewStateCnt++] = 400;
2698                  break;
2699               case 403:
2700                  if ((0x2000000020L & l) != 0L)
2701                     jjstateSet[jjnewStateCnt++] = 402;
2702                  break;
2703               case 404:
2704                  if ((0x100000001000L & l) != 0L)
2705                     jjstateSet[jjnewStateCnt++] = 403;
2706                  break;
2707               case 405:
2708                  if ((0x200000002000000L & l) != 0L)
2709                     jjstateSet[jjnewStateCnt++] = 404;
2710                  break;
2711               case 406:
2712                  if ((0x10000000100000L & l) != 0L)
2713                     jjstateSet[jjnewStateCnt++] = 405;
2714                  break;
2715               case 407:
2716                  if ((0x8000000080000L & l) != 0L)
2717                     jjstateSet[jjnewStateCnt++] = 406;
2718                  break;
2719               case 409:
2720                  if ((0x10000000100000L & l) != 0L)
2721                     jjstateSet[jjnewStateCnt++] = 408;
2722                  break;
2723               case 410:
2724                  if ((0x8000000080000L & l) != 0L)
2725                     jjstateSet[jjnewStateCnt++] = 409;
2726                  break;
2727               case 411:
2728                  if ((0x20000000200L & l) != 0L)
2729                     jjstateSet[jjnewStateCnt++] = 410;
2730                  break;
2731               case 412:
2732                  if ((0x1000000010000L & l) != 0L)
2733                     jjCheckNAdd(60);
2734                  break;
2735               case 413:
2736                  if ((0x200000002000000L & l) != 0L)
2737                     jjstateSet[jjnewStateCnt++] = 412;
2738                  break;
2739               case 414:
2740                  if ((0x10000000100000L & l) != 0L)
2741                     jjstateSet[jjnewStateCnt++] = 413;
2742                  break;
2743               case 416:
2744                  if ((0x2000000020L & l) != 0L)
2745                     jjstateSet[jjnewStateCnt++] = 415;
2746                  break;
2747               case 417:
2748                  if ((0x100000001000L & l) != 0L)
2749                     jjstateSet[jjnewStateCnt++] = 416;
2750                  break;
2751               case 418:
2752                  if ((0x200000002000000L & l) != 0L)
2753                     jjstateSet[jjnewStateCnt++] = 417;
2754                  break;
2755               case 419:
2756                  if ((0x10000000100000L & l) != 0L)
2757                     jjstateSet[jjnewStateCnt++] = 418;
2758                  break;
2759               case 420:
2760                  if ((0x8000000080000L & l) != 0L)
2761                     jjstateSet[jjnewStateCnt++] = 419;
2762                  break;
2763               case 422:
2764                  if ((0x10000000100000L & l) != 0L)
2765                     jjstateSet[jjnewStateCnt++] = 421;
2766                  break;
2767               case 423:
2768                  if ((0x8000000080000L & l) != 0L)
2769                     jjstateSet[jjnewStateCnt++] = 422;
2770                  break;
2771               case 424:
2772                  if ((0x20000000200L & l) != 0L)
2773                     jjstateSet[jjnewStateCnt++] = 423;
2774                  break;
2775               case 425:
2776                  if ((0x200000002000L & l) != 0L)
2777                     jjAddStates(62, 72);
2778                  break;
2779               case 426:
2780                  if ((0x20000000200L & l) != 0L)
2781                     jjCheckNAdd(65);
2782                  break;
2783               case 427:
2784                  if ((0x8000000080L & l) != 0L)
2785                     jjstateSet[jjnewStateCnt++] = 426;
2786                  break;
2787               case 428:
2788                  if ((0x4000000040000L & l) != 0L)
2789                     jjstateSet[jjnewStateCnt++] = 427;
2790                  break;
2791               case 429:
2792                  if ((0x200000002L & l) != 0L)
2793                     jjstateSet[jjnewStateCnt++] = 428;
2794                  break;
2795               case 431:
2796                  if ((0x10000000100000L & l) != 0L)
2797                     jjstateSet[jjnewStateCnt++] = 430;
2798                  break;
2799               case 433:
2800                  if ((0x400000004000L & l) != 0L)
2801                     jjstateSet[jjnewStateCnt++] = 432;
2802                  break;
2803               case 434:
2804                  if ((0x20000000200L & l) != 0L)
2805                     jjstateSet[jjnewStateCnt++] = 433;
2806                  break;
2807               case 435:
2808                  if ((0x8000000080L & l) != 0L)
2809                     jjstateSet[jjnewStateCnt++] = 434;
2810                  break;
2811               case 436:
2812                  if ((0x4000000040000L & l) != 0L)
2813                     jjstateSet[jjnewStateCnt++] = 435;
2814                  break;
2815               case 437:
2816                  if ((0x200000002L & l) != 0L)
2817                     jjstateSet[jjnewStateCnt++] = 436;
2818                  break;
2819               case 439:
2820                  if ((0x8000000080L & l) != 0L)
2821                     jjstateSet[jjnewStateCnt++] = 438;
2822                  break;
2823               case 440:
2824                  if ((0x20000000200L & l) != 0L)
2825                     jjstateSet[jjnewStateCnt++] = 439;
2826                  break;
2827               case 441:
2828                  if ((0x4000000040000L & l) != 0L)
2829                     jjstateSet[jjnewStateCnt++] = 440;
2830                  break;
2831               case 443:
2832                  if ((0x400000004000L & l) != 0L)
2833                     jjstateSet[jjnewStateCnt++] = 442;
2834                  break;
2835               case 444:
2836                  if ((0x20000000200L & l) != 0L)
2837                     jjstateSet[jjnewStateCnt++] = 443;
2838                  break;
2839               case 445:
2840                  if ((0x8000000080L & l) != 0L)
2841                     jjstateSet[jjnewStateCnt++] = 444;
2842                  break;
2843               case 446:
2844                  if ((0x4000000040000L & l) != 0L)
2845                     jjstateSet[jjnewStateCnt++] = 445;
2846                  break;
2847               case 447:
2848                  if ((0x200000002L & l) != 0L)
2849                     jjstateSet[jjnewStateCnt++] = 446;
2850                  break;
2851               case 449:
2852                  if ((0x10000000100000L & l) != 0L)
2853                     jjstateSet[jjnewStateCnt++] = 448;
2854                  break;
2855               case 450:
2856                  if ((0x10000000100000L & l) != 0L)
2857                     jjstateSet[jjnewStateCnt++] = 449;
2858                  break;
2859               case 451:
2860                  if ((0x800000008000L & l) != 0L)
2861                     jjstateSet[jjnewStateCnt++] = 450;
2862                  break;
2863               case 452:
2864                  if ((0x400000004L & l) != 0L)
2865                     jjstateSet[jjnewStateCnt++] = 451;
2866                  break;
2867               case 454:
2868                  if ((0x400000004000L & l) != 0L)
2869                     jjstateSet[jjnewStateCnt++] = 453;
2870                  break;
2871               case 455:
2872                  if ((0x20000000200L & l) != 0L)
2873                     jjstateSet[jjnewStateCnt++] = 454;
2874                  break;
2875               case 456:
2876                  if ((0x8000000080L & l) != 0L)
2877                     jjstateSet[jjnewStateCnt++] = 455;
2878                  break;
2879               case 457:
2880                  if ((0x4000000040000L & l) != 0L)
2881                     jjstateSet[jjnewStateCnt++] = 456;
2882                  break;
2883               case 458:
2884                  if ((0x200000002L & l) != 0L)
2885                     jjstateSet[jjnewStateCnt++] = 457;
2886                  break;
2887               case 460:
2888                  if ((0x2000000020L & l) != 0L)
2889                     jjstateSet[jjnewStateCnt++] = 459;
2890                  break;
2891               case 461:
2892                  if ((0x100000001000L & l) != 0L)
2893                     jjstateSet[jjnewStateCnt++] = 460;
2894                  break;
2895               case 463:
2896                  if ((0x400000004000L & l) != 0L)
2897                     jjstateSet[jjnewStateCnt++] = 462;
2898                  break;
2899               case 464:
2900                  if ((0x20000000200L & l) != 0L)
2901                     jjstateSet[jjnewStateCnt++] = 463;
2902                  break;
2903               case 465:
2904                  if ((0x8000000080L & l) != 0L)
2905                     jjstateSet[jjnewStateCnt++] = 464;
2906                  break;
2907               case 466:
2908                  if ((0x4000000040000L & l) != 0L)
2909                     jjstateSet[jjnewStateCnt++] = 465;
2910                  break;
2911               case 467:
2912                  if ((0x200000002L & l) != 0L)
2913                     jjstateSet[jjnewStateCnt++] = 466;
2914                  break;
2915               case 469:
2916                  if ((0x8000000080000L & l) != 0L)
2917                     jjstateSet[jjnewStateCnt++] = 468;
2918                  break;
2919               case 470:
2920                  if ((0x4000000040L & l) != 0L)
2921                     jjstateSet[jjnewStateCnt++] = 469;
2922                  break;
2923               case 471:
2924                  if ((0x4000000040L & l) != 0L)
2925                     jjstateSet[jjnewStateCnt++] = 470;
2926                  break;
2927               case 472:
2928                  if ((0x800000008000L & l) != 0L)
2929                     jjstateSet[jjnewStateCnt++] = 471;
2930                  break;
2931               case 474:
2932                  if ((0x4000000040000L & l) != 0L)
2933                     jjstateSet[jjnewStateCnt++] = 473;
2934                  break;
2935               case 475:
2936                  if ((0x2000000020L & l) != 0L)
2937                     jjstateSet[jjnewStateCnt++] = 474;
2938                  break;
2939               case 476:
2940                  if ((0x80000000800L & l) != 0L)
2941                     jjstateSet[jjnewStateCnt++] = 475;
2942                  break;
2943               case 477:
2944                  if ((0x4000000040000L & l) != 0L)
2945                     jjstateSet[jjnewStateCnt++] = 476;
2946                  break;
2947               case 478:
2948                  if ((0x200000002L & l) != 0L)
2949                     jjstateSet[jjnewStateCnt++] = 477;
2950                  break;
2951               case 479:
2952                  if ((0x80000000800L & l) != 0L)
2953                     jjCheckNAdd(14);
2954                  break;
2955               case 480:
2956                  if ((0x4000000040000L & l) != 0L)
2957                     jjstateSet[jjnewStateCnt++] = 479;
2958                  break;
2959               case 481:
2960                  if ((0x200000002L & l) != 0L)
2961                     jjstateSet[jjnewStateCnt++] = 480;
2962                  break;
2963               case 483:
2964                  if ((0x8000000080L & l) != 0L)
2965                     jjstateSet[jjnewStateCnt++] = 482;
2966                  break;
2967               case 484:
2968                  if ((0x20000000200L & l) != 0L)
2969                     jjstateSet[jjnewStateCnt++] = 483;
2970                  break;
2971               case 485:
2972                  if ((0x2000000020L & l) != 0L)
2973                     jjstateSet[jjnewStateCnt++] = 484;
2974                  break;
2975               case 486:
2976                  if ((0x10000000100L & l) != 0L)
2977                     jjstateSet[jjnewStateCnt++] = 485;
2978                  break;
2979               case 488:
2980                  if ((0x100000001000000L & l) != 0L)
2981                     jjstateSet[jjnewStateCnt++] = 487;
2982                  break;
2983               case 489:
2984                  if ((0x200000002L & l) != 0L)
2985                     jjstateSet[jjnewStateCnt++] = 488;
2986                  break;
2987               case 491:
2988                  if ((0x1000000010L & l) != 0L)
2989                     jjstateSet[jjnewStateCnt++] = 490;
2990                  break;
2991               case 492:
2992                  if ((0x20000000200L & l) != 0L)
2993                     jjstateSet[jjnewStateCnt++] = 491;
2994                  break;
2995               case 493:
2996                  if ((0x80000000800000L & l) != 0L)
2997                     jjstateSet[jjnewStateCnt++] = 492;
2998                  break;
2999               case 495:
3000                  if ((0x100000001000000L & l) != 0L)
3001                     jjstateSet[jjnewStateCnt++] = 494;
3002                  break;
3003               case 496:
3004                  if ((0x200000002L & l) != 0L)
3005                     jjstateSet[jjnewStateCnt++] = 495;
3006                  break;
3007               case 498:
3008                  if ((0x8000000080L & l) != 0L)
3009                     jjstateSet[jjnewStateCnt++] = 497;
3010                  break;
3011               case 499:
3012                  if ((0x20000000200L & l) != 0L)
3013                     jjstateSet[jjnewStateCnt++] = 498;
3014                  break;
3015               case 500:
3016                  if ((0x2000000020L & l) != 0L)
3017                     jjstateSet[jjnewStateCnt++] = 499;
3018                  break;
3019               case 501:
3020                  if ((0x10000000100L & l) != 0L)
3021                     jjstateSet[jjnewStateCnt++] = 500;
3022                  break;
3023               case 503:
3024                  if ((0x400000004000L & l) != 0L)
3025                     jjstateSet[jjnewStateCnt++] = 502;
3026                  break;
3027               case 504:
3028                  if ((0x20000000200L & l) != 0L)
3029                     jjstateSet[jjnewStateCnt++] = 503;
3030                  break;
3031               case 506:
3032                  if ((0x1000000010L & l) != 0L)
3033                     jjstateSet[jjnewStateCnt++] = 505;
3034                  break;
3035               case 507:
3036                  if ((0x20000000200L & l) != 0L)
3037                     jjstateSet[jjnewStateCnt++] = 506;
3038                  break;
3039               case 508:
3040                  if ((0x80000000800000L & l) != 0L)
3041                     jjstateSet[jjnewStateCnt++] = 507;
3042                  break;
3043               case 510:
3044                  if ((0x400000004000L & l) != 0L)
3045                     jjstateSet[jjnewStateCnt++] = 509;
3046                  break;
3047               case 511:
3048                  if ((0x20000000200L & l) != 0L)
3049                     jjstateSet[jjnewStateCnt++] = 510;
3050                  break;
3051               case 512:
3052                  if ((0x800000008000L & l) != 0L)
3053                     jjAddStates(56, 61);
3054                  break;
3055               case 513:
3056                  if ((0x200000002L & l) != 0L)
3057                     jjCheckNAdd(65);
3058                  break;
3059               case 514:
3060                  if ((0x10000000100L & l) != 0L)
3061                     jjstateSet[jjnewStateCnt++] = 513;
3062                  break;
3063               case 515:
3064                  if ((0x1000000010000L & l) != 0L)
3065                     jjstateSet[jjnewStateCnt++] = 514;
3066                  break;
3067               case 516:
3068                  if ((0x4000000040000L & l) != 0L)
3069                     jjstateSet[jjnewStateCnt++] = 515;
3070                  break;
3071               case 517:
3072                  if ((0x400000004000L & l) != 0L)
3073                     jjCheckNAdd(60);
3074                  break;
3075               case 518:
3076                  if ((0x20000000200L & l) != 0L)
3077                     jjstateSet[jjnewStateCnt++] = 517;
3078                  break;
3079               case 519:
3080                  if ((0x100000001000L & l) != 0L)
3081                     jjstateSet[jjnewStateCnt++] = 518;
3082                  break;
3083               case 520:
3084                  if ((0x10000000100000L & l) != 0L)
3085                     jjstateSet[jjnewStateCnt++] = 519;
3086                  break;
3087               case 521:
3088                  if ((0x20000000200000L & l) != 0L)
3089                     jjstateSet[jjnewStateCnt++] = 520;
3090                  break;
3091               case 523:
3092                  if ((0x100000001000L & l) != 0L)
3093                     jjstateSet[jjnewStateCnt++] = 522;
3094                  break;
3095               case 524:
3096                  if ((0x800000008000L & l) != 0L)
3097                     jjstateSet[jjnewStateCnt++] = 523;
3098                  break;
3099               case 525:
3100                  if ((0x800000008L & l) != 0L)
3101                     jjstateSet[jjnewStateCnt++] = 524;
3102                  break;
3103               case 527:
3104                  if ((0x2000000020L & l) != 0L)
3105                     jjstateSet[jjnewStateCnt++] = 526;
3106                  break;
3107               case 528:
3108                  if ((0x400000004000L & l) != 0L)
3109                     jjstateSet[jjnewStateCnt++] = 527;
3110                  break;
3111               case 529:
3112                  if ((0x20000000200L & l) != 0L)
3113                     jjstateSet[jjnewStateCnt++] = 528;
3114                  break;
3115               case 530:
3116                  if ((0x100000001000L & l) != 0L)
3117                     jjstateSet[jjnewStateCnt++] = 529;
3118                  break;
3119               case 531:
3120                  if ((0x10000000100000L & l) != 0L)
3121                     jjstateSet[jjnewStateCnt++] = 530;
3122                  break;
3123               case 532:
3124                  if ((0x20000000200000L & l) != 0L)
3125                     jjstateSet[jjnewStateCnt++] = 531;
3126                  break;
3127               case 534:
3128                  if ((0x200000002000000L & l) != 0L)
3129                     jjstateSet[jjnewStateCnt++] = 533;
3130                  break;
3131               case 535:
3132                  if ((0x10000000100000L & l) != 0L)
3133                     jjstateSet[jjnewStateCnt++] = 534;
3134                  break;
3135               case 536:
3136                  if ((0x8000000080000L & l) != 0L)
3137                     jjstateSet[jjnewStateCnt++] = 535;
3138                  break;
3139               case 538:
3140                  if ((0x2000000020L & l) != 0L)
3141                     jjstateSet[jjnewStateCnt++] = 537;
3142                  break;
3143               case 539:
3144                  if ((0x400000004000L & l) != 0L)
3145                     jjstateSet[jjnewStateCnt++] = 538;
3146                  break;
3147               case 540:
3148                  if ((0x20000000200L & l) != 0L)
3149                     jjstateSet[jjnewStateCnt++] = 539;
3150                  break;
3151               case 541:
3152                  if ((0x100000001000L & l) != 0L)
3153                     jjstateSet[jjnewStateCnt++] = 540;
3154                  break;
3155               case 542:
3156                  if ((0x10000000100000L & l) != 0L)
3157                     jjstateSet[jjnewStateCnt++] = 541;
3158                  break;
3159               case 543:
3160                  if ((0x20000000200000L & l) != 0L)
3161                     jjstateSet[jjnewStateCnt++] = 542;
3162                  break;
3163               case 545:
3164                  if ((0x1000000010L & l) != 0L)
3165                     jjstateSet[jjnewStateCnt++] = 544;
3166                  break;
3167               case 546:
3168                  if ((0x20000000200L & l) != 0L)
3169                     jjstateSet[jjnewStateCnt++] = 545;
3170                  break;
3171               case 547:
3172                  if ((0x80000000800000L & l) != 0L)
3173                     jjstateSet[jjnewStateCnt++] = 546;
3174                  break;
3175               case 549:
3176                  if ((0x2000000020L & l) != 0L)
3177                     jjstateSet[jjnewStateCnt++] = 548;
3178                  break;
3179               case 550:
3180                  if ((0x400000004000L & l) != 0L)
3181                     jjstateSet[jjnewStateCnt++] = 549;
3182                  break;
3183               case 551:
3184                  if ((0x20000000200L & l) != 0L)
3185                     jjstateSet[jjnewStateCnt++] = 550;
3186                  break;
3187               case 552:
3188                  if ((0x100000001000L & l) != 0L)
3189                     jjstateSet[jjnewStateCnt++] = 551;
3190                  break;
3191               case 553:
3192                  if ((0x10000000100000L & l) != 0L)
3193                     jjstateSet[jjnewStateCnt++] = 552;
3194                  break;
3195               case 554:
3196                  if ((0x20000000200000L & l) != 0L)
3197                     jjstateSet[jjnewStateCnt++] = 553;
3198                  break;
3199               case 555:
3200                  if ((0x80000000800000L & l) == 0L)
3201                     break;
3202                  if (kind > 11)
3203                     kind = 11;
3204                  jjCheckNAdd(1);
3205                  break;
3206               case 556:
3207               case 813:
3208                  if ((0x800000008000L & l) != 0L)
3209                     jjCheckNAdd(555);
3210                  break;
3211               case 557:
3212                  if ((0x100000001000L & l) != 0L)
3213                     jjstateSet[jjnewStateCnt++] = 556;
3214                  break;
3215               case 558:
3216                  if ((0x4000000040L & l) != 0L)
3217                     jjstateSet[jjnewStateCnt++] = 557;
3218                  break;
3219               case 559:
3220                  if ((0x4000000040000L & l) != 0L)
3221                     jjstateSet[jjnewStateCnt++] = 558;
3222                  break;
3223               case 560:
3224                  if ((0x2000000020L & l) != 0L)
3225                     jjstateSet[jjnewStateCnt++] = 559;
3226                  break;
3227               case 561:
3228                  if ((0x40000000400000L & l) != 0L)
3229                     jjstateSet[jjnewStateCnt++] = 560;
3230                  break;
3231               case 562:
3232                  if ((0x1000000010000L & l) != 0L)
3233                     jjAddStates(40, 55);
3234                  break;
3235               case 564:
3236                  if ((0x20000000200L & l) != 0L)
3237                     jjstateSet[jjnewStateCnt++] = 563;
3238                  break;
3239               case 565:
3240                  if ((0x1000000010L & l) != 0L)
3241                     jjstateSet[jjnewStateCnt++] = 564;
3242                  break;
3243               case 566:
3244                  if ((0x1000000010L & l) != 0L)
3245                     jjstateSet[jjnewStateCnt++] = 565;
3246                  break;
3247               case 567:
3248                  if ((0x200000002L & l) != 0L)
3249                     jjstateSet[jjnewStateCnt++] = 566;
3250                  break;
3251               case 569:
3252                  if ((0x10000000100000L & l) != 0L)
3253                     jjstateSet[jjnewStateCnt++] = 568;
3254                  break;
3255               case 571:
3256                  if ((0x8000000080L & l) != 0L)
3257                     jjstateSet[jjnewStateCnt++] = 570;
3258                  break;
3259               case 572:
3260                  if ((0x400000004000L & l) != 0L)
3261                     jjstateSet[jjnewStateCnt++] = 571;
3262                  break;
3263               case 573:
3264                  if ((0x20000000200L & l) != 0L)
3265                     jjstateSet[jjnewStateCnt++] = 572;
3266                  break;
3267               case 574:
3268                  if ((0x1000000010L & l) != 0L)
3269                     jjstateSet[jjnewStateCnt++] = 573;
3270                  break;
3271               case 575:
3272                  if ((0x1000000010L & l) != 0L)
3273                     jjstateSet[jjnewStateCnt++] = 574;
3274                  break;
3275               case 576:
3276                  if ((0x200000002L & l) != 0L)
3277                     jjstateSet[jjnewStateCnt++] = 575;
3278                  break;
3279               case 578:
3280                  if ((0x8000000080L & l) != 0L)
3281                     jjstateSet[jjnewStateCnt++] = 577;
3282                  break;
3283               case 579:
3284                  if ((0x20000000200L & l) != 0L)
3285                     jjstateSet[jjnewStateCnt++] = 578;
3286                  break;
3287               case 580:
3288                  if ((0x4000000040000L & l) != 0L)
3289                     jjstateSet[jjnewStateCnt++] = 579;
3290                  break;
3291               case 582:
3292                  if ((0x8000000080L & l) != 0L)
3293                     jjstateSet[jjnewStateCnt++] = 581;
3294                  break;
3295               case 583:
3296                  if ((0x400000004000L & l) != 0L)
3297                     jjstateSet[jjnewStateCnt++] = 582;
3298                  break;
3299               case 584:
3300                  if ((0x20000000200L & l) != 0L)
3301                     jjstateSet[jjnewStateCnt++] = 583;
3302                  break;
3303               case 585:
3304                  if ((0x1000000010L & l) != 0L)
3305                     jjstateSet[jjnewStateCnt++] = 584;
3306                  break;
3307               case 586:
3308                  if ((0x1000000010L & l) != 0L)
3309                     jjstateSet[jjnewStateCnt++] = 585;
3310                  break;
3311               case 587:
3312                  if ((0x200000002L & l) != 0L)
3313                     jjstateSet[jjnewStateCnt++] = 586;
3314                  break;
3315               case 589:
3316                  if ((0x10000000100000L & l) != 0L)
3317                     jjstateSet[jjnewStateCnt++] = 588;
3318                  break;
3319               case 590:
3320                  if ((0x10000000100000L & l) != 0L)
3321                     jjstateSet[jjnewStateCnt++] = 589;
3322                  break;
3323               case 591:
3324                  if ((0x800000008000L & l) != 0L)
3325                     jjstateSet[jjnewStateCnt++] = 590;
3326                  break;
3327               case 592:
3328                  if ((0x400000004L & l) != 0L)
3329                     jjstateSet[jjnewStateCnt++] = 591;
3330                  break;
3331               case 594:
3332                  if ((0x8000000080L & l) != 0L)
3333                     jjstateSet[jjnewStateCnt++] = 593;
3334                  break;
3335               case 595:
3336                  if ((0x400000004000L & l) != 0L)
3337                     jjstateSet[jjnewStateCnt++] = 594;
3338                  break;
3339               case 596:
3340                  if ((0x20000000200L & l) != 0L)
3341                     jjstateSet[jjnewStateCnt++] = 595;
3342                  break;
3343               case 597:
3344                  if ((0x1000000010L & l) != 0L)
3345                     jjstateSet[jjnewStateCnt++] = 596;
3346                  break;
3347               case 598:
3348                  if ((0x1000000010L & l) != 0L)
3349                     jjstateSet[jjnewStateCnt++] = 597;
3350                  break;
3351               case 599:
3352                  if ((0x200000002L & l) != 0L)
3353                     jjstateSet[jjnewStateCnt++] = 598;
3354                  break;
3355               case 601:
3356                  if ((0x2000000020L & l) != 0L)
3357                     jjstateSet[jjnewStateCnt++] = 600;
3358                  break;
3359               case 602:
3360                  if ((0x100000001000L & l) != 0L)
3361                     jjstateSet[jjnewStateCnt++] = 601;
3362                  break;
3363               case 604:
3364                  if ((0x8000000080L & l) != 0L)
3365                     jjstateSet[jjnewStateCnt++] = 603;
3366                  break;
3367               case 605:
3368                  if ((0x400000004000L & l) != 0L)
3369                     jjstateSet[jjnewStateCnt++] = 604;
3370                  break;
3371               case 606:
3372                  if ((0x20000000200L & l) != 0L)
3373                     jjstateSet[jjnewStateCnt++] = 605;
3374                  break;
3375               case 607:
3376                  if ((0x1000000010L & l) != 0L)
3377                     jjstateSet[jjnewStateCnt++] = 606;
3378                  break;
3379               case 608:
3380                  if ((0x1000000010L & l) != 0L)
3381                     jjstateSet[jjnewStateCnt++] = 607;
3382                  break;
3383               case 609:
3384                  if ((0x200000002L & l) != 0L)
3385                     jjstateSet[jjnewStateCnt++] = 608;
3386                  break;
3387               case 611:
3388                  if ((0x200000002L & l) != 0L)
3389                     jjstateSet[jjnewStateCnt++] = 610;
3390                  break;
3391               case 613:
3392                  if ((0x10000000100000L & l) != 0L)
3393                     jjstateSet[jjnewStateCnt++] = 612;
3394                  break;
3395               case 614:
3396                  if ((0x4000000040L & l) != 0L)
3397                     jjstateSet[jjnewStateCnt++] = 613;
3398                  break;
3399               case 615:
3400                  if ((0x200000002L & l) != 0L)
3401                     jjstateSet[jjnewStateCnt++] = 614;
3402                  break;
3403               case 617:
3404                  if ((0x80000000800L & l) != 0L)
3405                     jjstateSet[jjnewStateCnt++] = 616;
3406                  break;
3407               case 618:
3408                  if ((0x200000002L & l) != 0L)
3409                     jjstateSet[jjnewStateCnt++] = 617;
3410                  break;
3411               case 619:
3412                  if ((0x2000000020L & l) != 0L)
3413                     jjstateSet[jjnewStateCnt++] = 618;
3414                  break;
3415               case 620:
3416                  if ((0x4000000040000L & l) != 0L)
3417                     jjstateSet[jjnewStateCnt++] = 619;
3418                  break;
3419               case 621:
3420                  if ((0x400000004L & l) != 0L)
3421                     jjstateSet[jjnewStateCnt++] = 620;
3422                  break;
3423               case 623:
3424                  if ((0x2000000020L & l) != 0L)
3425                     jjstateSet[jjnewStateCnt++] = 622;
3426                  break;
3427               case 624:
3428                  if ((0x8000000080L & l) != 0L)
3429                     jjstateSet[jjnewStateCnt++] = 623;
3430                  break;
3431               case 625:
3432                  if ((0x200000002L & l) != 0L)
3433                     jjstateSet[jjnewStateCnt++] = 624;
3434                  break;
3435               case 627:
3436                  if ((0x800000008000L & l) != 0L)
3437                     jjstateSet[jjnewStateCnt++] = 626;
3438                  break;
3439               case 628:
3440                  if ((0x4000000040L & l) != 0L)
3441                     jjstateSet[jjnewStateCnt++] = 627;
3442                  break;
3443               case 629:
3444                  if ((0x2000000020L & l) != 0L)
3445                     jjstateSet[jjnewStateCnt++] = 628;
3446                  break;
3447               case 630:
3448                  if ((0x400000004L & l) != 0L)
3449                     jjstateSet[jjnewStateCnt++] = 629;
3450                  break;
3451               case 632:
3452                  if ((0x80000000800L & l) != 0L)
3453                     jjstateSet[jjnewStateCnt++] = 631;
3454                  break;
3455               case 633:
3456                  if ((0x200000002L & l) != 0L)
3457                     jjstateSet[jjnewStateCnt++] = 632;
3458                  break;
3459               case 634:
3460                  if ((0x2000000020L & l) != 0L)
3461                     jjstateSet[jjnewStateCnt++] = 633;
3462                  break;
3463               case 635:
3464                  if ((0x4000000040000L & l) != 0L)
3465                     jjstateSet[jjnewStateCnt++] = 634;
3466                  break;
3467               case 636:
3468                  if ((0x400000004L & l) != 0L)
3469                     jjstateSet[jjnewStateCnt++] = 635;
3470                  break;
3471               case 638:
3472                  if ((0x2000000020L & l) != 0L)
3473                     jjstateSet[jjnewStateCnt++] = 637;
3474                  break;
3475               case 639:
3476                  if ((0x8000000080L & l) != 0L)
3477                     jjstateSet[jjnewStateCnt++] = 638;
3478                  break;
3479               case 640:
3480                  if ((0x200000002L & l) != 0L)
3481                     jjstateSet[jjnewStateCnt++] = 639;
3482                  break;
3483               case 642:
3484                  if ((0x20000000200L & l) != 0L)
3485                     jjstateSet[jjnewStateCnt++] = 641;
3486                  break;
3487               case 643:
3488                  if ((0x8000000080000L & l) != 0L)
3489                     jjstateSet[jjnewStateCnt++] = 642;
3490                  break;
3491               case 644:
3492                  if ((0x400000004000L & l) != 0L)
3493                     jjstateSet[jjnewStateCnt++] = 643;
3494                  break;
3495               case 645:
3496                  if ((0x20000000200L & l) != 0L)
3497                     jjstateSet[jjnewStateCnt++] = 644;
3498                  break;
3499               case 647:
3500                  if ((0x80000000800L & l) != 0L)
3501                     jjstateSet[jjnewStateCnt++] = 646;
3502                  break;
3503               case 648:
3504                  if ((0x200000002L & l) != 0L)
3505                     jjstateSet[jjnewStateCnt++] = 647;
3506                  break;
3507               case 649:
3508                  if ((0x2000000020L & l) != 0L)
3509                     jjstateSet[jjnewStateCnt++] = 648;
3510                  break;
3511               case 650:
3512                  if ((0x4000000040000L & l) != 0L)
3513                     jjstateSet[jjnewStateCnt++] = 649;
3514                  break;
3515               case 651:
3516                  if ((0x400000004L & l) != 0L)
3517                     jjstateSet[jjnewStateCnt++] = 650;
3518                  break;
3519               case 653:
3520                  if ((0x2000000020L & l) != 0L)
3521                     jjstateSet[jjnewStateCnt++] = 652;
3522                  break;
3523               case 654:
3524                  if ((0x8000000080L & l) != 0L)
3525                     jjstateSet[jjnewStateCnt++] = 653;
3526                  break;
3527               case 655:
3528                  if ((0x200000002L & l) != 0L)
3529                     jjstateSet[jjnewStateCnt++] = 654;
3530                  break;
3531               case 657:
3532                  if ((0x20000000200000L & l) != 0L)
3533                     jjstateSet[jjnewStateCnt++] = 656;
3534                  break;
3535               case 658:
3536                  if ((0x200000002L & l) != 0L)
3537                     jjstateSet[jjnewStateCnt++] = 657;
3538                  break;
3539               case 660:
3540                  if ((0x10000000100000L & l) != 0L)
3541                     jjstateSet[jjnewStateCnt++] = 659;
3542                  break;
3543               case 661:
3544                  if ((0x4000000040L & l) != 0L)
3545                     jjstateSet[jjnewStateCnt++] = 660;
3546                  break;
3547               case 662:
3548                  if ((0x200000002L & l) != 0L)
3549                     jjstateSet[jjnewStateCnt++] = 661;
3550                  break;
3551               case 664:
3552                  if ((0x2000000020L & l) != 0L)
3553                     jjstateSet[jjnewStateCnt++] = 663;
3554                  break;
3555               case 665:
3556                  if ((0x8000000080000L & l) != 0L)
3557                     jjstateSet[jjnewStateCnt++] = 664;
3558                  break;
3559               case 666:
3560                  if ((0x20000000200000L & l) != 0L)
3561                     jjstateSet[jjnewStateCnt++] = 665;
3562                  break;
3563               case 667:
3564                  if ((0x200000002L & l) != 0L)
3565                     jjstateSet[jjnewStateCnt++] = 666;
3566                  break;
3567               case 669:
3568                  if ((0x800000008000L & l) != 0L)
3569                     jjstateSet[jjnewStateCnt++] = 668;
3570                  break;
3571               case 670:
3572                  if ((0x4000000040L & l) != 0L)
3573                     jjstateSet[jjnewStateCnt++] = 669;
3574                  break;
3575               case 671:
3576                  if ((0x2000000020L & l) != 0L)
3577                     jjstateSet[jjnewStateCnt++] = 670;
3578                  break;
3579               case 672:
3580                  if ((0x400000004L & l) != 0L)
3581                     jjstateSet[jjnewStateCnt++] = 671;
3582                  break;
3583               case 674:
3584                  if ((0x2000000020L & l) != 0L)
3585                     jjstateSet[jjnewStateCnt++] = 673;
3586                  break;
3587               case 675:
3588                  if ((0x8000000080000L & l) != 0L)
3589                     jjstateSet[jjnewStateCnt++] = 674;
3590                  break;
3591               case 676:
3592                  if ((0x20000000200000L & l) != 0L)
3593                     jjstateSet[jjnewStateCnt++] = 675;
3594                  break;
3595               case 677:
3596                  if ((0x200000002L & l) != 0L)
3597                     jjstateSet[jjnewStateCnt++] = 676;
3598                  break;
3599               case 679:
3600                  if ((0x10000000100000L & l) != 0L)
3601                     jjstateSet[jjnewStateCnt++] = 678;
3602                  break;
3603               case 680:
3604                  if ((0x20000000200L & l) != 0L)
3605                     jjstateSet[jjnewStateCnt++] = 679;
3606                  break;
3607               case 682:
3608                  if ((0x400000004000L & l) != 0L)
3609                     jjstateSet[jjnewStateCnt++] = 681;
3610                  break;
3611               case 683:
3612                  if ((0x200000002L & l) != 0L)
3613                     jjstateSet[jjnewStateCnt++] = 682;
3614                  break;
3615               case 684:
3616                  if ((0x4000000040000L & l) != 0L)
3617                     jjstateSet[jjnewStateCnt++] = 683;
3618                  break;
3619               case 686:
3620                  if ((0x10000000100L & l) != 0L)
3621                     jjstateSet[jjnewStateCnt++] = 685;
3622                  break;
3623               case 687:
3624                  if ((0x800000008L & l) != 0L)
3625                     jjstateSet[jjnewStateCnt++] = 686;
3626                  break;
3627               case 688:
3628                  if ((0x10000000100000L & l) != 0L)
3629                     jjstateSet[jjnewStateCnt++] = 687;
3630                  break;
3631               case 689:
3632                  if ((0x20000000200L & l) != 0L)
3633                     jjstateSet[jjnewStateCnt++] = 688;
3634                  break;
3635               case 691:
3636                  if ((0x20000000200L & l) != 0L)
3637                     jjstateSet[jjnewStateCnt++] = 690;
3638                  break;
3639               case 692:
3640                  if ((0x4000000040000L & l) != 0L)
3641                     jjstateSet[jjnewStateCnt++] = 691;
3642                  break;
3643               case 693:
3644                  if ((0x20000000200000L & l) != 0L)
3645                     jjstateSet[jjnewStateCnt++] = 692;
3646                  break;
3647               case 694:
3648                  if ((0x1000000010L & l) != 0L)
3649                     jjstateSet[jjnewStateCnt++] = 693;
3650                  break;
3651               case 696:
3652                  if ((0x200000002000000L & l) != 0L)
3653                     jjstateSet[jjnewStateCnt++] = 695;
3654                  break;
3655               case 697:
3656                  if ((0x200000002L & l) != 0L)
3657                     jjstateSet[jjnewStateCnt++] = 696;
3658                  break;
3659               case 698:
3660                  if ((0x100000001000L & l) != 0L)
3661                     jjstateSet[jjnewStateCnt++] = 697;
3662                  break;
3663               case 700:
3664                  if ((0x20000000200L & l) != 0L)
3665                     jjstateSet[jjnewStateCnt++] = 699;
3666                  break;
3667               case 701:
3668                  if ((0x10000000100000L & l) != 0L)
3669                     jjstateSet[jjnewStateCnt++] = 700;
3670                  break;
3671               case 702:
3672                  if ((0x20000000200L & l) != 0L)
3673                     jjstateSet[jjnewStateCnt++] = 701;
3674                  break;
3675               case 703:
3676                  if ((0x8000000080000L & l) != 0L)
3677                     jjstateSet[jjnewStateCnt++] = 702;
3678                  break;
3679               case 704:
3680                  if ((0x800000008000L & l) != 0L)
3681                     jjstateSet[jjnewStateCnt++] = 703;
3682                  break;
3683               case 705:
3684                  if ((0x4000000040000L & l) != 0L)
3685                     jjAddStates(38, 39);
3686                  break;
3687               case 706:
3688               case 768:
3689                  if ((0x8000000080000L & l) != 0L)
3690                     jjCheckNAdd(14);
3691                  break;
3692               case 707:
3693                  if ((0x2000000020L & l) != 0L)
3694                     jjstateSet[jjnewStateCnt++] = 706;
3695                  break;
3696               case 708:
3697                  if ((0x400000004000L & l) != 0L)
3698                     jjstateSet[jjnewStateCnt++] = 707;
3699                  break;
3700               case 709:
3701                  if ((0x10000000100L & l) != 0L)
3702                     jjstateSet[jjnewStateCnt++] = 708;
3703                  break;
3704               case 710:
3705                  if ((0x800000008L & l) != 0L)
3706                     jjstateSet[jjnewStateCnt++] = 709;
3707                  break;
3708               case 711:
3709                  if ((0x20000000200L & l) != 0L)
3710                     jjstateSet[jjnewStateCnt++] = 710;
3711                  break;
3712               case 713:
3713                  if ((0x8000000080L & l) != 0L)
3714                     jjstateSet[jjnewStateCnt++] = 712;
3715                  break;
3716               case 714:
3717                  if ((0x20000000200L & l) != 0L)
3718                     jjstateSet[jjnewStateCnt++] = 713;
3719                  break;
3720               case 715:
3721                  if ((0x8000000080000L & l) != 0L)
3722                     jjAddStates(31, 37);
3723                  break;
3724               case 717:
3725                  if ((0x20000000200L & l) != 0L)
3726                     jjstateSet[jjnewStateCnt++] = 716;
3727                  break;
3728               case 718:
3729                  if ((0x80000000800L & l) == 0L)
3730                     break;
3731                  if (kind > 11)
3732                     kind = 11;
3733                  jjCheckNAdd(1);
3734                  break;
3735               case 719:
3736                  if ((0x200000002L & l) != 0L)
3737                     jjstateSet[jjnewStateCnt++] = 718;
3738                  break;
3739               case 720:
3740                  if ((0x2000000020L & l) != 0L)
3741                     jjstateSet[jjnewStateCnt++] = 719;
3742                  break;
3743               case 721:
3744                  if ((0x1000000010000L & l) != 0L)
3745                     jjstateSet[jjnewStateCnt++] = 720;
3746                  break;
3747               case 723:
3748                  if ((0x1000000010L & l) != 0L)
3749                     jjstateSet[jjnewStateCnt++] = 722;
3750                  break;
3751               case 724:
3752                  if ((0x200000002L & l) != 0L)
3753                     jjstateSet[jjnewStateCnt++] = 723;
3754                  break;
3755               case 725:
3756                  if ((0x2000000020L & l) != 0L)
3757                     jjstateSet[jjnewStateCnt++] = 724;
3758                  break;
3759               case 726:
3760                  if ((0x10000000100L & l) != 0L)
3761                     jjstateSet[jjnewStateCnt++] = 725;
3762                  break;
3763               case 728:
3764                  if ((0x80000000800L & l) != 0L)
3765                     jjstateSet[jjnewStateCnt++] = 727;
3766                  break;
3767               case 729:
3768                  if ((0x200000002L & l) != 0L)
3769                     jjstateSet[jjnewStateCnt++] = 728;
3770                  break;
3771               case 730:
3772                  if ((0x2000000020L & l) != 0L)
3773                     jjstateSet[jjnewStateCnt++] = 729;
3774                  break;
3775               case 731:
3776                  if ((0x1000000010000L & l) != 0L)
3777                     jjstateSet[jjnewStateCnt++] = 730;
3778                  break;
3779               case 732:
3780                  if ((0x100000001000L & l) == 0L)
3781                     break;
3782                  if (kind > 11)
3783                     kind = 11;
3784                  jjCheckNAdd(1);
3785                  break;
3786               case 733:
3787                  if ((0x200000002L & l) != 0L)
3788                     jjstateSet[jjnewStateCnt++] = 732;
3789                  break;
3790               case 734:
3791                  if ((0x4000000040000L & l) != 0L)
3792                     jjstateSet[jjnewStateCnt++] = 733;
3793                  break;
3794               case 735:
3795                  if ((0x2000000020L & l) != 0L)
3796                     jjstateSet[jjnewStateCnt++] = 734;
3797                  break;
3798               case 736:
3799                  if ((0x200000002000L & l) != 0L)
3800                     jjstateSet[jjnewStateCnt++] = 735;
3801                  break;
3802               case 737:
3803                  if ((0x20000000200000L & l) != 0L)
3804                     jjstateSet[jjnewStateCnt++] = 736;
3805                  break;
3806               case 738:
3807                  if ((0x400000004000L & l) != 0L)
3808                     jjstateSet[jjnewStateCnt++] = 737;
3809                  break;
3810               case 740:
3811                  if ((0x80000000800L & l) != 0L)
3812                     jjstateSet[jjnewStateCnt++] = 739;
3813                  break;
3814               case 741:
3815                  if ((0x200000002L & l) != 0L)
3816                     jjstateSet[jjnewStateCnt++] = 740;
3817                  break;
3818               case 742:
3819                  if ((0x2000000020L & l) != 0L)
3820                     jjstateSet[jjnewStateCnt++] = 741;
3821                  break;
3822               case 743:
3823                  if ((0x1000000010000L & l) != 0L)
3824                     jjstateSet[jjnewStateCnt++] = 742;
3825                  break;
3826               case 745:
3827                  if ((0x20000000200L & l) != 0L)
3828                     jjstateSet[jjnewStateCnt++] = 744;
3829                  break;
3830               case 746:
3831                  if ((0x10000000100000L & l) != 0L)
3832                     jjstateSet[jjnewStateCnt++] = 745;
3833                  break;
3834               case 747:
3835                  if ((0x200000002L & l) != 0L)
3836                     jjstateSet[jjnewStateCnt++] = 746;
3837                  break;
3838               case 748:
3839                  if ((0x20000000200000L & l) != 0L)
3840                     jjstateSet[jjnewStateCnt++] = 747;
3841                  break;
3842               case 749:
3843                  if ((0x10000000100000L & l) != 0L)
3844                     jjstateSet[jjnewStateCnt++] = 748;
3845                  break;
3846               case 750:
3847                  if ((0x800000008L & l) != 0L)
3848                     jjstateSet[jjnewStateCnt++] = 749;
3849                  break;
3850               case 751:
3851                  if ((0x400000004000L & l) != 0L)
3852                     jjstateSet[jjnewStateCnt++] = 750;
3853                  break;
3854               case 752:
3855                  if ((0x20000000200000L & l) != 0L)
3856                     jjstateSet[jjnewStateCnt++] = 751;
3857                  break;
3858               case 753:
3859                  if ((0x1000000010000L & l) != 0L)
3860                     jjstateSet[jjnewStateCnt++] = 752;
3861                  break;
3862               case 755:
3863                  if ((0x80000000800L & l) != 0L)
3864                     jjstateSet[jjnewStateCnt++] = 754;
3865                  break;
3866               case 756:
3867                  if ((0x200000002L & l) != 0L)
3868                     jjstateSet[jjnewStateCnt++] = 755;
3869                  break;
3870               case 757:
3871                  if ((0x2000000020L & l) != 0L)
3872                     jjstateSet[jjnewStateCnt++] = 756;
3873                  break;
3874               case 758:
3875                  if ((0x1000000010000L & l) != 0L)
3876                     jjstateSet[jjnewStateCnt++] = 757;
3877                  break;
3878               case 759:
3879                  if ((0x10000000100000L & l) != 0L)
3880                     jjCheckNAdd(60);
3881                  break;
3882               case 760:
3883                  if ((0x200000002L & l) != 0L)
3884                     jjstateSet[jjnewStateCnt++] = 759;
3885                  break;
3886               case 761:
3887                  if ((0x4000000040000L & l) != 0L)
3888                     jjstateSet[jjnewStateCnt++] = 760;
3889                  break;
3890               case 763:
3891                  if ((0x10000000100L & l) != 0L)
3892                     jjstateSet[jjnewStateCnt++] = 762;
3893                  break;
3894               case 764:
3895                  if ((0x800000008L & l) != 0L)
3896                     jjstateSet[jjnewStateCnt++] = 763;
3897                  break;
3898               case 765:
3899                  if ((0x2000000020L & l) != 0L)
3900                     jjstateSet[jjnewStateCnt++] = 764;
3901                  break;
3902               case 766:
3903                  if ((0x2000000020L & l) != 0L)
3904                     jjstateSet[jjnewStateCnt++] = 765;
3905                  break;
3906               case 767:
3907                  if ((0x1000000010000L & l) != 0L)
3908                     jjstateSet[jjnewStateCnt++] = 766;
3909                  break;
3910               case 769:
3911                  if ((0x2000000020L & l) != 0L)
3912                     jjstateSet[jjnewStateCnt++] = 768;
3913                  break;
3914               case 770:
3915                  if ((0x4000000040000L & l) != 0L)
3916                     jjstateSet[jjnewStateCnt++] = 769;
3917                  break;
3918               case 771:
3919                  if ((0x10000000100000L & l) != 0L)
3920                     jjstateSet[jjnewStateCnt++] = 770;
3921                  break;
3922               case 772:
3923                  if ((0x10000000100000L & l) != 0L)
3924                     jjAddStates(24, 30);
3925                  break;
3926               case 773:
3927                  if ((0x20000000200000L & l) != 0L)
3928                     jjCheckNAdd(8);
3929                  break;
3930               case 774:
3931                  if ((0x800000008000L & l) != 0L)
3932                     jjstateSet[jjnewStateCnt++] = 773;
3933                  break;
3934               case 775:
3935                  if ((0x200000002000000L & l) != 0L)
3936                     jjstateSet[jjnewStateCnt++] = 774;
3937                  break;
3938               case 776:
3939                  if ((0x200000002L & l) != 0L)
3940                     jjstateSet[jjnewStateCnt++] = 775;
3941                  break;
3942               case 777:
3943                  if ((0x100000001000L & l) != 0L)
3944                     jjstateSet[jjnewStateCnt++] = 776;
3945                  break;
3946               case 779:
3947                  if ((0x2000000020L & l) != 0L)
3948                     jjstateSet[jjnewStateCnt++] = 778;
3949                  break;
3950               case 780:
3951                  if ((0x100000001000L & l) != 0L)
3952                     jjstateSet[jjnewStateCnt++] = 779;
3953                  break;
3954               case 781:
3955                  if ((0x400000004L & l) != 0L)
3956                     jjstateSet[jjnewStateCnt++] = 780;
3957                  break;
3958               case 782:
3959                  if ((0x200000002L & l) != 0L)
3960                     jjstateSet[jjnewStateCnt++] = 781;
3961                  break;
3962               case 783:
3963               case 836:
3964                  if ((0x8000000080L & l) != 0L)
3965                     jjCheckNAdd(65);
3966                  break;
3967               case 784:
3968                  if ((0x20000000200L & l) != 0L)
3969                     jjstateSet[jjnewStateCnt++] = 783;
3970                  break;
3971               case 785:
3972                  if ((0x100000001000L & l) != 0L)
3973                     jjstateSet[jjnewStateCnt++] = 784;
3974                  break;
3975               case 786:
3976                  if ((0x200000002L & l) != 0L)
3977                     jjstateSet[jjnewStateCnt++] = 785;
3978                  break;
3979               case 788:
3980                  if ((0x10000000100000L & l) != 0L)
3981                     jjstateSet[jjnewStateCnt++] = 787;
3982                  break;
3983               case 789:
3984                  if ((0x100000001000000L & l) != 0L)
3985                     jjstateSet[jjnewStateCnt++] = 788;
3986                  break;
3987               case 790:
3988                  if ((0x2000000020L & l) != 0L)
3989                     jjstateSet[jjnewStateCnt++] = 789;
3990                  break;
3991               case 792:
3992                  if ((0x20000000200L & l) != 0L)
3993                     jjstateSet[jjnewStateCnt++] = 791;
3994                  break;
3995               case 793:
3996                  if ((0x10000000100000L & l) != 0L)
3997                     jjstateSet[jjnewStateCnt++] = 792;
3998                  break;
3999               case 794:
4000                  if ((0x200000002L & l) != 0L)
4001                     jjstateSet[jjnewStateCnt++] = 793;
4002                  break;
4003               case 795:
4004                  if ((0x4000000040000L & l) != 0L)
4005                     jjstateSet[jjnewStateCnt++] = 794;
4006                  break;
4007               case 796:
4008                  if ((0x800000008000L & l) != 0L)
4009                     jjstateSet[jjnewStateCnt++] = 795;
4010                  break;
4011               case 797:
4012                  if ((0x800000008L & l) != 0L)
4013                     jjstateSet[jjnewStateCnt++] = 796;
4014                  break;
4015               case 798:
4016                  if ((0x2000000020L & l) != 0L)
4017                     jjstateSet[jjnewStateCnt++] = 797;
4018                  break;
4019               case 799:
4020                  if ((0x1000000010L & l) != 0L)
4021                     jjstateSet[jjnewStateCnt++] = 798;
4022                  break;
4023               case 801:
4024                  if ((0x10000000100000L & l) != 0L)
4025                     jjstateSet[jjnewStateCnt++] = 800;
4026                  break;
4027               case 802:
4028                  if ((0x100000001000000L & l) != 0L)
4029                     jjstateSet[jjnewStateCnt++] = 801;
4030                  break;
4031               case 803:
4032                  if ((0x2000000020L & l) != 0L)
4033                     jjstateSet[jjnewStateCnt++] = 802;
4034                  break;
4035               case 805:
4036                  if ((0x2000000020L & l) != 0L)
4037                     jjstateSet[jjnewStateCnt++] = 804;
4038                  break;
4039               case 806:
4040                  if ((0x1000000010L & l) != 0L)
4041                     jjstateSet[jjnewStateCnt++] = 805;
4042                  break;
4043               case 807:
4044                  if ((0x400000004000L & l) != 0L)
4045                     jjstateSet[jjnewStateCnt++] = 806;
4046                  break;
4047               case 808:
4048                  if ((0x20000000200L & l) != 0L)
4049                     jjstateSet[jjnewStateCnt++] = 807;
4050                  break;
4051               case 810:
4052                  if ((0x10000000100000L & l) != 0L)
4053                     jjstateSet[jjnewStateCnt++] = 809;
4054                  break;
4055               case 811:
4056                  if ((0x100000001000000L & l) != 0L)
4057                     jjstateSet[jjnewStateCnt++] = 810;
4058                  break;
4059               case 812:
4060                  if ((0x2000000020L & l) != 0L)
4061                     jjstateSet[jjnewStateCnt++] = 811;
4062                  break;
4063               case 814:
4064                  if ((0x1000000010L & l) != 0L)
4065                     jjstateSet[jjnewStateCnt++] = 813;
4066                  break;
4067               case 815:
4068                  if ((0x200000002L & l) != 0L)
4069                     jjstateSet[jjnewStateCnt++] = 814;
4070                  break;
4071               case 816:
4072                  if ((0x10000000100L & l) != 0L)
4073                     jjstateSet[jjnewStateCnt++] = 815;
4074                  break;
4075               case 817:
4076                  if ((0x8000000080000L & l) != 0L)
4077                     jjstateSet[jjnewStateCnt++] = 816;
4078                  break;
4079               case 819:
4080                  if ((0x10000000100000L & l) != 0L)
4081                     jjstateSet[jjnewStateCnt++] = 818;
4082                  break;
4083               case 820:
4084                  if ((0x100000001000000L & l) != 0L)
4085                     jjstateSet[jjnewStateCnt++] = 819;
4086                  break;
4087               case 821:
4088                  if ((0x2000000020L & l) != 0L)
4089                     jjstateSet[jjnewStateCnt++] = 820;
4090                  break;
4091               case 822:
4092                  if ((0x4000000040000L & l) != 0L)
4093                     jjCheckNAdd(152);
4094                  break;
4095               case 823:
4096                  if ((0x800000008000L & l) != 0L)
4097                     jjstateSet[jjnewStateCnt++] = 822;
4098                  break;
4099               case 824:
4100                  if ((0x4000000040L & l) != 0L)
4101                     jjstateSet[jjnewStateCnt++] = 823;
4102                  break;
4103               case 825:
4104                  if ((0x8000000080000L & l) != 0L)
4105                     jjstateSet[jjnewStateCnt++] = 824;
4106                  break;
4107               case 826:
4108                  if ((0x400000004000L & l) != 0L)
4109                     jjstateSet[jjnewStateCnt++] = 825;
4110                  break;
4111               case 827:
4112                  if ((0x200000002L & l) != 0L)
4113                     jjstateSet[jjnewStateCnt++] = 826;
4114                  break;
4115               case 828:
4116                  if ((0x4000000040000L & l) != 0L)
4117                     jjstateSet[jjnewStateCnt++] = 827;
4118                  break;
4119               case 829:
4120                  if ((0x10000000100000L & l) != 0L)
4121                     jjstateSet[jjnewStateCnt++] = 828;
4122                  break;
4123               case 831:
4124                  if ((0x10000000100000L & l) != 0L)
4125                     jjstateSet[jjnewStateCnt++] = 830;
4126                  break;
4127               case 832:
4128                  if ((0x100000001000000L & l) != 0L)
4129                     jjstateSet[jjnewStateCnt++] = 831;
4130                  break;
4131               case 833:
4132                  if ((0x2000000020L & l) != 0L)
4133                     jjstateSet[jjnewStateCnt++] = 832;
4134                  break;
4135               case 835:
4136                  if ((0x40000000400000L & l) != 0L)
4137                     jjAddStates(20, 23);
4138                  break;
4139               case 837:
4140                  if ((0x20000000200L & l) != 0L)
4141                     jjstateSet[jjnewStateCnt++] = 836;
4142                  break;
4143               case 838:
4144                  if ((0x100000001000L & l) != 0L)
4145                     jjstateSet[jjnewStateCnt++] = 837;
4146                  break;
4147               case 839:
4148                  if ((0x200000002L & l) != 0L)
4149                     jjstateSet[jjnewStateCnt++] = 838;
4150                  break;
4151               case 841:
4152                  if ((0x100000001000L & l) != 0L)
4153                     jjstateSet[jjnewStateCnt++] = 840;
4154                  break;
4155               case 842:
4156                  if ((0x200000002L & l) != 0L)
4157                     jjstateSet[jjnewStateCnt++] = 841;
4158                  break;
4159               case 843:
4160                  if ((0x800000008L & l) != 0L)
4161                     jjstateSet[jjnewStateCnt++] = 842;
4162                  break;
4163               case 844:
4164                  if ((0x20000000200L & l) != 0L)
4165                     jjstateSet[jjnewStateCnt++] = 843;
4166                  break;
4167               case 845:
4168                  if ((0x10000000100000L & l) != 0L)
4169                     jjstateSet[jjnewStateCnt++] = 844;
4170                  break;
4171               case 846:
4172                  if ((0x4000000040000L & l) != 0L)
4173                     jjstateSet[jjnewStateCnt++] = 845;
4174                  break;
4175               case 847:
4176                  if ((0x2000000020L & l) != 0L)
4177                     jjstateSet[jjnewStateCnt++] = 846;
4178                  break;
4179               case 848:
4180                  if ((0x10000000100000L & l) != 0L)
4181                     jjCheckNAdd(282);
4182                  break;
4183               case 849:
4184                  if ((0x20000000200L & l) != 0L)
4185                     jjstateSet[jjnewStateCnt++] = 848;
4186                  break;
4187               case 850:
4188                  if ((0x100000001000L & l) != 0L)
4189                     jjstateSet[jjnewStateCnt++] = 849;
4190                  break;
4191               case 851:
4192                  if ((0x20000000200L & l) != 0L)
4193                     jjstateSet[jjnewStateCnt++] = 850;
4194                  break;
4195               case 852:
4196                  if ((0x400000004L & l) != 0L)
4197                     jjstateSet[jjnewStateCnt++] = 851;
4198                  break;
4199               case 853:
4200                  if ((0x20000000200L & l) != 0L)
4201                     jjstateSet[jjnewStateCnt++] = 852;
4202                  break;
4203               case 854:
4204                  if ((0x8000000080000L & l) != 0L)
4205                     jjstateSet[jjnewStateCnt++] = 853;
4206                  break;
4207               case 855:
4208                  if ((0x20000000200L & l) != 0L)
4209                     jjstateSet[jjnewStateCnt++] = 854;
4210                  break;
4211               case 857:
4212                  if ((0x20000000200L & l) != 0L)
4213                     jjstateSet[jjnewStateCnt++] = 856;
4214                  break;
4215               case 858:
4216                  if ((0x200000002000L & l) != 0L)
4217                     jjstateSet[jjnewStateCnt++] = 857;
4218                  break;
4219               case 859:
4220                  if ((0x200000002L & l) != 0L)
4221                     jjstateSet[jjnewStateCnt++] = 858;
4222                  break;
4223               case 860:
4224                  if ((0x4000000040L & l) != 0L)
4225                     jjstateSet[jjnewStateCnt++] = 859;
4226                  break;
4227               case 862:
4228                  if ((0x2000000020L & l) != 0L)
4229                     jjstateSet[jjnewStateCnt++] = 861;
4230                  break;
4231               case 863:
4232                  if ((0x800000008L & l) != 0L)
4233                     jjstateSet[jjnewStateCnt++] = 862;
4234                  break;
4235               case 864:
4236                  if ((0x20000000200L & l) != 0L)
4237                     jjstateSet[jjnewStateCnt++] = 863;
4238                  break;
4239               case 865:
4240                  if ((0x800000008000L & l) != 0L)
4241                     jjstateSet[jjnewStateCnt++] = 864;
4242                  break;
4243               case 866:
4244                  if ((0x200000002000L & l) != 0L)
4245                     jjCheckNAdd(60);
4246                  break;
4247               case 867:
4248                  if ((0x20000000200000L & l) != 0L)
4249                     jjstateSet[jjnewStateCnt++] = 866;
4250                  break;
4251               case 868:
4252                  if ((0x100000001000L & l) != 0L)
4253                     jjstateSet[jjnewStateCnt++] = 867;
4254                  break;
4255               case 869:
4256                  if ((0x800000008000L & l) != 0L)
4257                     jjstateSet[jjnewStateCnt++] = 868;
4258                  break;
4259               case 870:
4260                  if ((0x80000000800000L & l) != 0L)
4261                     jjAddStates(16, 19);
4262                  break;
4263               case 871:
4264                  if ((0x800000008L & l) != 0L)
4265                     jjCheckNAdd(60);
4266                  break;
4267               case 872:
4268                  if ((0x200000002L & l) != 0L)
4269                     jjstateSet[jjnewStateCnt++] = 871;
4270                  break;
4271               case 873:
4272                  if ((0x1000000010000L & l) != 0L)
4273                     jjstateSet[jjnewStateCnt++] = 872;
4274                  break;
4275               case 874:
4276                  if ((0x8000000080000L & l) != 0L)
4277                     jjstateSet[jjnewStateCnt++] = 873;
4278                  break;
4279               case 876:
4280                  if ((0x2000000020L & l) != 0L)
4281                     jjstateSet[jjnewStateCnt++] = 875;
4282                  break;
4283               case 877:
4284                  if ((0x10000000100000L & l) != 0L)
4285                     jjstateSet[jjnewStateCnt++] = 876;
4286                  break;
4287               case 878:
4288                  if ((0x20000000200L & l) != 0L)
4289                     jjstateSet[jjnewStateCnt++] = 877;
4290                  break;
4291               case 879:
4292                  if ((0x10000000100L & l) != 0L)
4293                     jjstateSet[jjnewStateCnt++] = 878;
4294                  break;
4295               case 880:
4296                  if ((0x80000000800000L & l) != 0L)
4297                     jjCheckNAdd(14);
4298                  break;
4299               case 881:
4300                  if ((0x800000008000L & l) != 0L)
4301                     jjstateSet[jjnewStateCnt++] = 880;
4302                  break;
4303               case 882:
4304                  if ((0x1000000010L & l) != 0L)
4305                     jjstateSet[jjnewStateCnt++] = 881;
4306                  break;
4307               case 883:
4308                  if ((0x20000000200L & l) != 0L)
4309                     jjstateSet[jjnewStateCnt++] = 882;
4310                  break;
4311               case 885:
4312                  if ((0x1000000010L & l) != 0L)
4313                     jjstateSet[jjnewStateCnt++] = 884;
4314                  break;
4315               case 886:
4316                  if ((0x20000000200L & l) != 0L)
4317                     jjstateSet[jjnewStateCnt++] = 885;
4318                  break;
4319               case 888:
4320                  if ((0x20000000200L & l) != 0L)
4321                     jjstateSet[jjnewStateCnt++] = 887;
4322                  break;
4323               case 889:
4324                  if ((0x800000008L & l) != 0L)
4325                     jjstateSet[jjnewStateCnt++] = 888;
4326                  break;
4327               case 890:
4328                  if ((0x200000002L & l) != 0L)
4329                     jjstateSet[jjnewStateCnt++] = 889;
4330                  break;
4331               case 891:
4332                  if ((0x1000000010000L & l) != 0L)
4333                     jjstateSet[jjnewStateCnt++] = 890;
4334                  break;
4335               case 892:
4336                  if ((0x8000000080000L & l) != 0L)
4337                     jjstateSet[jjnewStateCnt++] = 891;
4338                  break;
4339               case 894:
4340                  if ((0x1000000010L & l) != 0L)
4341                     jjstateSet[jjnewStateCnt++] = 893;
4342                  break;
4343               case 895:
4344                  if ((0x4000000040000L & l) != 0L)
4345                     jjstateSet[jjnewStateCnt++] = 894;
4346                  break;
4347               case 896:
4348                  if ((0x800000008000L & l) != 0L)
4349                     jjstateSet[jjnewStateCnt++] = 895;
4350                  break;
4351               default : break;
4352            }
4353         } while(i != startsAt);
4354      }
4355      else
4356      {
4357         int hiByte = (int)(curChar >> 8);
4358         int i1 = hiByte >> 6;
4359         long l1 = 1L << (hiByte & 077);
4360         int i2 = (curChar & 0xff) >> 6;
4361         long l2 = 1L << (curChar & 077);
4362         MatchLoop: do
4363         {
4364            switch(jjstateSet[--i])
4365            {
4366               case 7:
4367               case 39:
4368                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4369                     break;
4370                  if (kind > 12)
4371                     kind = 12;
4372                  jjCheckNAdd(39);
4373                  break;
4374               default : break;
4375            }
4376         } while(i != startsAt);
4377      }
4378      if (kind != 0x7fffffff)
4379      {
4380         jjmatchedKind = kind;
4381         jjmatchedPos = curPos;
4382         kind = 0x7fffffff;
4383      }
4384      ++curPos;
4385      if ((i = jjnewStateCnt) == (startsAt = 897 - (jjnewStateCnt = startsAt)))
4386         return curPos;
4387      try { curChar = input_stream.readChar(); }
4388      catch(java.io.IOException   e) { return curPos; }
4389   }
4390}
4391private final int jjStopStringLiteralDfa_0(int pos, long active0)
4392{
4393   switch (pos)
4394   {
4395      case 0:
4396         if ((active0 & 0x100000L) != 0L)
4397            return 2;
4398         return -1;
4399      default :
4400         return -1;
4401   }
4402}
4403private final int jjStartNfa_0(int pos, long active0)
4404{
4405   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
4406}
4407private final int jjStartNfaWithStates_0(int pos, int kind, int state)
4408{
4409   jjmatchedKind = kind;
4410   jjmatchedPos = pos;
4411   try { curChar = input_stream.readChar(); }
4412   catch(java.io.IOException   e) { return pos + 1; }
4413   return jjMoveNfa_0(state, pos + 1);
4414}
4415private final int jjMoveStringLiteralDfa0_0()
4416{
4417   switch(curChar)
4418   {
4419      case 10:
4420         return jjStopAtPos(0, 1);
4421      case 42:
4422         return jjMoveStringLiteralDfa1_0(0x100000L);
4423      default :
4424         return jjMoveNfa_0(3, 0);
4425   }
4426}
4427private final int jjMoveStringLiteralDfa1_0(long active0)
4428{
4429   try { curChar = input_stream.readChar(); }
4430   catch(java.io.IOException   e) {
4431      jjStopStringLiteralDfa_0(0, active0);
4432      return 1;
4433   }
4434   switch(curChar)
4435   {
4436      case 47:
4437         if ((active0 & 0x100000L) != 0L)
4438            return jjStopAtPos(1, 20);
4439         break;
4440      default :
4441         break;
4442   }
4443   return jjStartNfa_0(0, active0);
4444}
4445private final int jjMoveNfa_0(int startState, int curPos)
4446{
4447   int[] nextStates;
4448   int startsAt = 0;
4449   jjnewStateCnt = 3;
4450   int i = 1;
4451   jjstateSet[0] = startState;
4452   int j, kind = 0x7fffffff;
4453   for (;;)
4454   {
4455      if (++jjround == 0x7fffffff)
4456         ReInitRounds();
4457      if (curChar < 64)
4458      {
4459         long l = 1L << curChar;
4460         MatchLoop: do
4461         {
4462            switch(jjstateSet[--i])
4463            {
4464               case 3:
4465                  if ((0xfffffbfffffffbffL & l) != 0L)
4466                  {
4467                     if (kind > 19)
4468                        kind = 19;
4469                     jjCheckNAddTwoStates(0, 1);
4470                  }
4471                  else if (curChar == 42)
4472                     jjstateSet[jjnewStateCnt++] = 2;
4473                  break;
4474               case 0:
4475                  if ((0xfffffbfffffffbffL & l) == 0L)
4476                     break;
4477                  if (kind > 19)
4478                     kind = 19;
4479                  jjCheckNAddTwoStates(0, 1);
4480                  break;
4481               case 1:
4482                  if (curChar == 42)
4483                     jjstateSet[jjnewStateCnt++] = 2;
4484                  break;
4485               case 2:
4486                  if ((0xffff7ffffffffbffL & l) == 0L)
4487                     break;
4488                  if (kind > 19)
4489                     kind = 19;
4490                  jjCheckNAddTwoStates(0, 1);
4491                  break;
4492               default : break;
4493            }
4494         } while(i != startsAt);
4495      }
4496      else if (curChar < 128)
4497      {
4498         long l = 1L << (curChar & 077);
4499         MatchLoop: do
4500         {
4501            switch(jjstateSet[--i])
4502            {
4503               case 3:
4504               case 0:
4505               case 2:
4506                  if (kind > 19)
4507                     kind = 19;
4508                  jjCheckNAddTwoStates(0, 1);
4509                  break;
4510               default : break;
4511            }
4512         } while(i != startsAt);
4513      }
4514      else
4515      {
4516         int hiByte = (int)(curChar >> 8);
4517         int i1 = hiByte >> 6;
4518         long l1 = 1L << (hiByte & 077);
4519         int i2 = (curChar & 0xff) >> 6;
4520         long l2 = 1L << (curChar & 077);
4521         MatchLoop: do
4522         {
4523            switch(jjstateSet[--i])
4524            {
4525               case 3:
4526               case 0:
4527               case 2:
4528                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4529                     break;
4530                  if (kind > 19)
4531                     kind = 19;
4532                  jjCheckNAddTwoStates(0, 1);
4533                  break;
4534               default : break;
4535            }
4536         } while(i != startsAt);
4537      }
4538      if (kind != 0x7fffffff)
4539      {
4540         jjmatchedKind = kind;
4541         jjmatchedPos = curPos;
4542         kind = 0x7fffffff;
4543      }
4544      ++curPos;
4545      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
4546         return curPos;
4547      try { curChar = input_stream.readChar(); }
4548      catch(java.io.IOException   e) { return curPos; }
4549   }
4550}
4551private final int jjStopStringLiteralDfa_1(int pos, long active0)
4552{
4553   switch (pos)
4554   {
4555      case 0:
4556         if ((active0 & 0x40000L) != 0L)
4557            return 2;
4558         return -1;
4559      case 1:
4560         if ((active0 & 0x40000L) != 0L)
4561            return 3;
4562         return -1;
4563      default :
4564         return -1;
4565   }
4566}
4567private final int jjStartNfa_1(int pos, long active0)
4568{
4569   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
4570}
4571private final int jjStartNfaWithStates_1(int pos, int kind, int state)
4572{
4573   jjmatchedKind = kind;
4574   jjmatchedPos = pos;
4575   try { curChar = input_stream.readChar(); }
4576   catch(java.io.IOException   e) { return pos + 1; }
4577   return jjMoveNfa_1(state, pos + 1);
4578}
4579private final int jjMoveStringLiteralDfa0_1()
4580{
4581   switch(curChar)
4582   {
4583      case 10:
4584         return jjStopAtPos(0, 1);
4585      case 45:
4586         return jjMoveStringLiteralDfa1_1(0x40000L);
4587      default :
4588         return jjMoveNfa_1(4, 0);
4589   }
4590}
4591private final int jjMoveStringLiteralDfa1_1(long active0)
4592{
4593   try { curChar = input_stream.readChar(); }
4594   catch(java.io.IOException   e) {
4595      jjStopStringLiteralDfa_1(0, active0);
4596      return 1;
4597   }
4598   switch(curChar)
4599   {
4600      case 45:
4601         return jjMoveStringLiteralDfa2_1(active0, 0x40000L);
4602      default :
4603         break;
4604   }
4605   return jjStartNfa_1(0, active0);
4606}
4607private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
4608{
4609   if (((active0 &= old0)) == 0L)
4610      return jjStartNfa_1(0, old0); 
4611   try { curChar = input_stream.readChar(); }
4612   catch(java.io.IOException   e) {
4613      jjStopStringLiteralDfa_1(1, active0);
4614      return 2;
4615   }
4616   switch(curChar)
4617   {
4618      case 62:
4619         if ((active0 & 0x40000L) != 0L)
4620            return jjStopAtPos(2, 18);
4621         break;
4622      default :
4623         break;
4624   }
4625   return jjStartNfa_1(1, active0);
4626}
4627private final int jjMoveNfa_1(int startState, int curPos)
4628{
4629   int[] nextStates;
4630   int startsAt = 0;
4631   jjnewStateCnt = 5;
4632   int i = 1;
4633   jjstateSet[0] = startState;
4634   int j, kind = 0x7fffffff;
4635   for (;;)
4636   {
4637      if (++jjround == 0x7fffffff)
4638         ReInitRounds();
4639      if (curChar < 64)
4640      {
4641         long l = 1L << curChar;
4642         MatchLoop: do
4643         {
4644            switch(jjstateSet[--i])
4645            {
4646               case 4:
4647                  if ((0xffffdffffffffbffL & l) != 0L)
4648                  {
4649                     if (kind > 16)
4650                        kind = 16;
4651                     jjCheckNAddTwoStates(0, 1);
4652                  }
4653                  else if (curChar == 45)
4654                     jjstateSet[jjnewStateCnt++] = 2;
4655                  if (curChar == 45)
4656                     jjCheckNAdd(0);
4657                  break;
4658               case 2:
4659                  if ((0xffffdffffffffbffL & l) != 0L)
4660                  {
4661                     if (kind > 16)
4662                        kind = 16;
4663                     jjCheckNAddTwoStates(0, 1);
4664                  }
4665                  else if (curChar == 45)
4666                     jjstateSet[jjnewStateCnt++] = 3;
4667                  break;
4668               case 0:
4669                  if ((0xffffdffffffffbffL & l) == 0L)
4670                     break;
4671                  if (kind > 16)
4672                     kind = 16;
4673                  jjCheckNAddTwoStates(0, 1);
4674                  break;
4675               case 1:
4676                  if (curChar == 45)
4677                     jjCheckNAdd(0);
4678                  break;
4679               case 3:
4680                  if ((0xbffffffffffffbffL & l) != 0L && kind > 17)
4681                     kind = 17;
4682                  break;
4683               default : break;
4684            }
4685         } while(i != startsAt);
4686      }
4687      else if (curChar < 128)
4688      {
4689         long l = 1L << (curChar & 077);
4690         MatchLoop: do
4691         {
4692            switch(jjstateSet[--i])
4693            {
4694               case 4:
4695               case 0:
4696                  if (kind > 16)
4697                     kind = 16;
4698                  jjCheckNAddTwoStates(0, 1);
4699                  break;
4700               case 2:
4701                  if (kind > 16)
4702                     kind = 16;
4703                  jjCheckNAddTwoStates(0, 1);
4704                  break;
4705               case 3:
4706                  if (kind > 17)
4707                     kind = 17;
4708                  break;
4709               default : break;
4710            }
4711         } while(i != startsAt);
4712      }
4713      else
4714      {
4715         int hiByte = (int)(curChar >> 8);
4716         int i1 = hiByte >> 6;
4717         long l1 = 1L << (hiByte & 077);
4718         int i2 = (curChar & 0xff) >> 6;
4719         long l2 = 1L << (curChar & 077);
4720         MatchLoop: do
4721         {
4722            switch(jjstateSet[--i])
4723            {
4724               case 4:
4725               case 0:
4726                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4727                     break;
4728                  if (kind > 16)
4729                     kind = 16;
4730                  jjCheckNAddTwoStates(0, 1);
4731                  break;
4732               case 2:
4733                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4734                     break;
4735                  if (kind > 16)
4736                     kind = 16;
4737                  jjCheckNAddTwoStates(0, 1);
4738                  break;
4739               case 3:
4740                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 17)
4741                     kind = 17;
4742                  break;
4743               default : break;
4744            }
4745         } while(i != startsAt);
4746      }
4747      if (kind != 0x7fffffff)
4748      {
4749         jjmatchedKind = kind;
4750         jjmatchedPos = curPos;
4751         kind = 0x7fffffff;
4752      }
4753      ++curPos;
4754      if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
4755         return curPos;
4756      try { curChar = input_stream.readChar(); }
4757      catch(java.io.IOException   e) { return curPos; }
4758   }
4759}
4760static final int[] jjnextStates = {
4761   54, 59, 64, 72, 77, 91, 92, 102, 112, 129, 151, 177, 315, 321, 326, 327, 
4762   879, 883, 886, 896, 847, 855, 865, 869, 782, 790, 803, 812, 821, 833, 834, 717, 
4763   721, 731, 743, 758, 767, 771, 711, 714, 567, 576, 587, 599, 609, 611, 625, 640, 
4764   655, 658, 667, 677, 680, 689, 698, 704, 516, 521, 532, 543, 554, 561, 429, 437, 
4765   447, 458, 467, 478, 481, 489, 496, 504, 511, 351, 363, 372, 380, 394, 411, 424, 
4766   308, 348, 295, 304, 281, 287, 214, 217, 219, 222, 227, 242, 253, 254, 261, 269, 
4767   273, 85, 199, 203, 98, 101, 108, 111, 114, 121, 128, 132, 141, 150, 156, 166, 
4768   176, 179, 187, 195, 329, 338, 343, 346, 
4769};
4770private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
4771{
4772   switch(hiByte)
4773   {
4774      case 0:
4775         return ((jjbitVec2[i2] & l2) != 0L);
4776      default : 
4777         if ((jjbitVec0[i1] & l1) != 0L)
4778            return true;
4779         return false;
4780   }
4781}
4782public static final String  [] jjstrLiteralImages = {
4783"", "\12", "\173", "\175", "\74\41\55\55", "\57\52", null, null, null, "\173", 
4784null, null, null, "\74\41\55\55", "\57\52", null, null, null, "\55\55\76", null, 
4785"\52\57", };
4786public static final String  [] lexStateNames = {
4787   "IN_CCOMMENT", 
4788   "IN_COMMENT", 
4789   "IN_RULESET", 
4790   "IN_MEDIA_DECL", 
4791   "DEFAULT", 
4792};
4793public static final int[] jjnewLexState = {
4794   -1, -1, 2, -1, 1, 0, -1, 3, -1, 4, -1, -1, -1, 1, 0, 4, -1, -1, -1, -1, -1, 
4795};
4796protected SimpleCharStream input_stream;
4797private final int[] jjrounds = new int[897];
4798private final int[] jjstateSet = new int[1794];
4799StringBuffer   image;
4800int jjimageLen;
4801int lengthOfMatch;
4802protected char curChar;
4803public CSSSyntaxTokenManager(SimpleCharStream stream)
4804{
4805   if (SimpleCharStream.staticFlag)
4806      throw new Error  ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
4807   input_stream = stream;
4808}
4809public CSSSyntaxTokenManager(SimpleCharStream stream, int lexState)
4810{
4811   this(stream);
4812   SwitchTo(lexState);
4813}
4814public void ReInit(SimpleCharStream stream)
4815{
4816   jjmatchedPos = jjnewStateCnt = 0;
4817   curLexState = defaultLexState;
4818   input_stream = stream;
4819   ReInitRounds();
4820}
4821private final void ReInitRounds()
4822{
4823   int i;
4824   jjround = 0x80000001;
4825   for (i = 897; i-- > 0;)
4826      jjrounds[i] = 0x80000000;
4827}
4828public void ReInit(SimpleCharStream stream, int lexState)
4829{
4830   ReInit(stream);
4831   SwitchTo(lexState);
4832}
4833public void SwitchTo(int lexState)
4834{
4835   if (lexState >= 5 || lexState < 0)
4836      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
4837   else
4838      curLexState = lexState;
4839}
4840
4841protected Token jjFillToken()
4842{
4843   Token t = Token.newToken(jjmatchedKind);
4844   t.kind = jjmatchedKind;
4845   String   im = jjstrLiteralImages[jjmatchedKind];
4846   t.image = (im == null) ? input_stream.GetImage() : im;
4847   t.beginLine = input_stream.getBeginLine();
4848   t.beginColumn = input_stream.getBeginColumn();
4849   t.endLine = input_stream.getEndLine();
4850   t.endColumn = input_stream.getEndColumn();
4851   return t;
4852}
4853
4854int curLexState = 4;
4855int defaultLexState = 4;
4856int jjnewStateCnt;
4857int jjround;
4858int jjmatchedPos;
4859int jjmatchedKind;
4860
4861public Token getNextToken() 
4862{
4863  int kind;
4864  Token specialToken = null;
4865  Token matchedToken;
4866  int curPos = 0;
4867
4868  EOFLoop :
4869  for (;;)
4870  {   
4871   try   
4872   {     
4873      curChar = input_stream.BeginToken();
4874   }     
4875   catch(java.io.IOException   e)
4876   {        
4877      jjmatchedKind = 0;
4878      matchedToken = jjFillToken();
4879      return matchedToken;
4880   }
4881   image = null;
4882   jjimageLen = 0;
4883
4884   switch(curLexState)
4885   {
4886     case 0:
4887       jjmatchedKind = 0x7fffffff;
4888       jjmatchedPos = 0;
4889       curPos = jjMoveStringLiteralDfa0_0();
4890       break;
4891     case 1:
4892       jjmatchedKind = 0x7fffffff;
4893       jjmatchedPos = 0;
4894       curPos = jjMoveStringLiteralDfa0_1();
4895       break;
4896     case 2:
4897       jjmatchedKind = 0x7fffffff;
4898       jjmatchedPos = 0;
4899       curPos = jjMoveStringLiteralDfa0_2();
4900       break;
4901     case 3:
4902       jjmatchedKind = 0x7fffffff;
4903       jjmatchedPos = 0;
4904       curPos = jjMoveStringLiteralDfa0_3();
4905       break;
4906     case 4:
4907       jjmatchedKind = 0x7fffffff;
4908       jjmatchedPos = 0;
4909       curPos = jjMoveStringLiteralDfa0_4();
4910       break;
4911   }
4912     if (jjmatchedKind != 0x7fffffff)
4913     {
4914        if (jjmatchedPos + 1 < curPos)
4915           input_stream.backup(curPos - jjmatchedPos - 1);
4916           matchedToken = jjFillToken();
4917           TokenLexicalActions(matchedToken);
4918       if (jjnewLexState[jjmatchedKind] != -1)
4919         curLexState = jjnewLexState[jjmatchedKind];
4920           return matchedToken;
4921     }
4922     int error_line = input_stream.getEndLine();
4923     int error_column = input_stream.getEndColumn();
4924     String   error_after = null;
4925     boolean EOFSeen = false;
4926     try { input_stream.readChar(); input_stream.backup(1); }
4927     catch (java.io.IOException   e1) {
4928        EOFSeen = true;
4929        error_after = curPos <= 1 ? "" : input_stream.GetImage();
4930        if (curChar == '\n' || curChar == '\r') {
4931           error_line++;
4932           error_column = 0;
4933        }
4934        else
4935           error_column++;
4936     }
4937     if (!EOFSeen) {
4938        input_stream.backup(1);
4939        error_after = curPos <= 1 ? "" : input_stream.GetImage();
4940     }
4941     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
4942  }
4943}
4944
4945void TokenLexicalActions(Token matchedToken)
4946{
4947   switch(jjmatchedKind)
4948   {
4949      case 4 :
4950        if (image == null)
4951            image = new StringBuffer  (jjstrLiteralImages[4]);
4952         else
4953            image.append(jjstrLiteralImages[4]);
4954                            pushState(getState());
4955         break;
4956      case 5 :
4957        if (image == null)
4958            image = new StringBuffer  (jjstrLiteralImages[5]);
4959         else
4960            image.append(jjstrLiteralImages[5]);
4961                           pushState(getState());
4962         break;
4963      case 13 :
4964        if (image == null)
4965            image = new StringBuffer  (jjstrLiteralImages[13]);
4966         else
4967            image.append(jjstrLiteralImages[13]);
4968                                  pushState(getState());
4969         break;
4970      case 14 :
4971        if (image == null)
4972            image = new StringBuffer  (jjstrLiteralImages[14]);
4973         else
4974            image.append(jjstrLiteralImages[14]);
4975                                 pushState(getState());
4976         break;
4977      case 18 :
4978        if (image == null)
4979            image = new StringBuffer  (jjstrLiteralImages[18]);
4980         else
4981            image.append(jjstrLiteralImages[18]);
4982                          setState(popState());
4983         break;
4984      case 20 :
4985        if (image == null)
4986            image = new StringBuffer  (jjstrLiteralImages[20]);
4987         else
4988            image.append(jjstrLiteralImages[20]);
4989                          setState(popState());
4990         break;
4991      default : 
4992         break;
4993   }
4994}
4995}
4996
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags