gt:       while (curChar <= 13 && (0x2400L & (1L << curChar)) != 0L)
context: /* Generated By:JavaCC: Do not edit this line. JBAParserTokenManager.java */
  package util.parser.ba;
  
  /** Token Manager. */
  public class JBAParserTokenManager implements JBAParserConstants
  {
  
    /** Debug output. */
    public  java.io.PrintStream debugStream = System.out;
    /** Set debug output. */
    public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  private final int jjStopStringLiteralDfa_0(int pos, long active0)
  {
     switch (pos)
     {
        case 0:
           if ((active0 & 0xaL) != 0L)
              return 5;
           return -1;
        default :
           return -1;
     }
  }
  private final int jjStartNfa_0(int pos, long active0)
  {
     return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  }
  private int jjStopAtPos(int pos, int kind)
  {
     jjmatchedKind = kind;
     jjmatchedPos = pos;
     return pos + 1;
  }
  private int jjMoveStringLiteralDfa0_0()
  {
     switch(curChar)
     {
        case 9:
           return jjStartNfaWithStates_0(0, 3, 5);
        case 32:
           return jjStartNfaWithStates_0(0, 1, 5);
        case 44:
           return jjStopAtPos(0, 7);
        case 45:
           return jjMoveStringLiteralDfa1_0(0x100L);
        default :
           return jjMoveNfa_0(0, 0);
     }
  }
  private int jjMoveStringLiteralDfa1_0(long active0)
  {
     try { curChar = input_stream.readChar(); }
     catch(java.io.IOException e) {
        jjStopStringLiteralDfa_0(0, active0);
        return 1;
     }
     switch(curChar)
     {
        case 62:
           if ((active0 & 0x100L) != 0L)
              return jjStopAtPos(1, 8);
           break;
        default :
           break;
     }
     return jjStartNfa_0(0, active0);
  }
  private int jjStartNfaWithStates_0(int pos, int kind, int state)
  {
     jjmatchedKind = kind;
     jjmatchedPos = pos;
     try { curChar = input_stream.readChar(); }
     catch(java.io.IOException e) { return pos + 1; }
     return jjMoveNfa_0(state, pos + 1);
  }
  static final long[] jjbitVec0 = {
     0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
  };
  private int jjMoveNfa_0(int startState, int curPos)
  {
     int startsAt = 0;
     jjnewStateCnt = 6;
     int i = 1;
     jjstateSet[0] = startState;
     int kind = 0x7fffffff;
     for (;;)
     {
        if (++jjround == 0x7fffffff)
           ReInitRounds();
        if (curChar < 64)
        {
           long l = 1L << curChar;
           do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                    if ((0xbfffcfffffffdbffL & l) != 0L)
                    {
                       if (kind > 9)
                          kind = 9;
                       jjCheckNAdd(5);
                    }
                    if (curChar == 47)
                       jjstateSet[jjnewStateCnt++] = 2;
                    else if (curChar == 37)
                    {
                       if (kind > 5)
                          kind = 5;
                       jjCheckNAdd(1);
                    }
                    break;
                 case 1:
                    if ((0xffffffffffffdbffL & l) == 0L)
                       break;
                    if (kind > 5)
                       kind = 5;
                    jjCheckNAdd(1);
                    break;
                 case 2:
                    if (curChar != 47)
                       break;
                    if (kind > 6)
                       kind = 6;
                    jjCheckNAdd(3);
                    break;
                 case 3:
                    if ((0xffffffffffffdbffL & l) == 0L)
                       break;
                    if (kind > 6)
                       kind = 6;
                    jjCheckNAdd(3);
                    break;
                 case 4:
                    if (curChar == 47)
                       jjstateSet[jjnewStateCnt++] = 2;
                    break;
                 case 5:
                    if ((0xbfffcfffffffdbffL & l) == 0L)
                       break;
                    if (kind > 9)
                       kind = 9;
                    jjCheckNAdd(5);
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        else if (curChar < 128)
        {
           long l = 1L << (curChar & 077);
           do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                 case 5:
                    if (kind > 9)
                       kind = 9;
                    jjCheckNAdd(5);
                    break;
                 case 1:
                    if (kind > 5)
                       kind = 5;
                    jjstateSet[jjnewStateCnt++] = 1;
                    break;
                 case 3:
                    if (kind > 6)
                       kind = 6;
                    jjstateSet[jjnewStateCnt++] = 3;
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        else
        {
           int i2 = (curChar & 0xff) >> 6;
           long l2 = 1L << (curChar & 077);
           do
           {
              switch(jjstateSet[--i])
              {
                 case 0:
                 case 5:
                    if ((jjbitVec0[i2] & l2) == 0L)
                       break;
                    if (kind > 9)
                       kind = 9;
                    jjCheckNAdd(5);
                    break;
                 case 1:
                    if ((jjbitVec0[i2] & l2) == 0L)
                       break;
                    if (kind > 5)
                       kind = 5;
                    jjstateSet[jjnewStateCnt++] = 1;
                    break;
                 case 3:
                    if ((jjbitVec0[i2] & l2) == 0L)
                       break;
                    if (kind > 6)
                       kind = 6;
                    jjstateSet[jjnewStateCnt++] = 3;
                    break;
                 default : break;
              }
           } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
           jjmatchedKind = kind;
           jjmatchedPos = curPos;
           kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
           return curPos;
        try { curChar = input_stream.readChar(); }
        catch(java.io.IOException e) { return curPos; }
     }
  }
  static final int[] jjnextStates = {
  };
  
  /** Token literal values. */
  public static final String[] jjstrLiteralImages = {
  "", null, null, null, null, null, null, "\54", "\55\76", null, };
  
  /** Lexer state names. */
  public static final String[] lexStateNames = {
     "DEFAULT",
  };
  static final long[] jjtoToken = {
     0x381L, 
  };
  static final long[] jjtoSkip = {
     0x7eL, 
  };
  protected SimpleCharStream input_stream;
  private final int[] jjrounds = new int[6];
  private final int[] jjstateSet = new int[12];
  protected char curChar;
  /** Constructor. */
  public JBAParserTokenManager(SimpleCharStream stream){
     if (SimpleCharStream.staticFlag)
        throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
     input_stream = stream;
  }
  
  /** Constructor. */
  public JBAParserTokenManager(SimpleCharStream stream, int lexState){
     this(stream);
     SwitchTo(lexState);
  }
  
  /** Reinitialise parser. */
  public void ReInit(SimpleCharStream stream)
  {
     jjmatchedPos = jjnewStateCnt = 0;
     curLexState = defaultLexState;
     input_stream = stream;
     ReInitRounds();
  }
  private void ReInitRounds()
  {
     int i;
     jjround = 0x80000001;
     for (i = 6; i-- > 0;)
        jjrounds[i] = 0x80000000;
  }
  
  /** Reinitialise parser. */
  public void ReInit(SimpleCharStream stream, int lexState)
  {
     ReInit(stream);
     SwitchTo(lexState);
  }
  
  /** Switch to specified lex state. */
  public void SwitchTo(int lexState)
  {
     if (lexState >= 1 || lexState < 0)
        throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
     else
        curLexState = lexState;
  }
  
  protected Token jjFillToken()
  {
     final Token t;
     final String curTokenImage;
     final int beginLine;
     final int endLine;
     final int beginColumn;
     final int endColumn;
     String im = jjstrLiteralImages[jjmatchedKind];
     curTokenImage = (im == null) ? input_stream.GetImage() : im;
     beginLine = input_stream.getBeginLine();
     beginColumn = input_stream.getBeginColumn();
     endLine = input_stream.getEndLine();
     endColumn = input_stream.getEndColumn();
     t = Token.newToken(jjmatchedKind, curTokenImage);
  
     t.beginLine = beginLine;
     t.endLine = endLine;
     t.beginColumn = beginColumn;
     t.endColumn = endColumn;
  
     return t;
  }
  
  int curLexState = 0;
  int defaultLexState = 0;
  int jjnewStateCnt;
  int jjround;
  int jjmatchedPos;
  int jjmatchedKind;
  
  /** Get the next Token. */
  public Token getNextToken() 
  {
    Token matchedToken;
    int curPos = 0;
  
    EOFLoop :
    for (;;)
    {
     try
     {
        curChar = input_stream.BeginToken();
     }
     catch(java.io.IOException e)
     {
        jjmatchedKind = 0;
        matchedToken = jjFillToken();
        return matchedToken;
     }
  
     try { input_stream.backup(0);
  