bsh.ParserTokenManager

class ParserTokenManager implements ParserConstants
{
private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
{
   switch (pos)
   {
      case 0:
         if ((active0 & 0x3eL) != 0L)
            return 0;
         if ((active1 & 0x400040000000L) != 0L)
            return 56;
         if ((active1 & 0x20L) != 0L)
            return 11;
         if ((active0 & 0x3fffffffff800L) != 0L)
         {
            jjmatchedKind = 58;
            return 35;
         }
         return -1;
      case 1:
         if ((active0 & 0x3ffffbf9ff800L) != 0L)
         {
            if (jjmatchedPos != 1)
            {
               jjmatchedKind = 58;
               jjmatchedPos = 1;
            }
            return 35;
         }
         if ((active0 & 0x40600000L) != 0L)
            return 35;
         return -1;
      case 2:
         if ((active0 & 0x37fe9afdff800L) != 0L)
         {
            if (jjmatchedPos != 2)
            {
               jjmatchedKind = 58;
               jjmatchedPos = 2;
            }
            return 35;
         }
         if ((active0 & 0x801610000000L) != 0L)
            return 35;
         return -1;
      case 3:
         if ((active0 & 0x140282082c000L) != 0L)
            return 35;
         if ((active0 & 0x23fc58f5d3800L) != 0L)
         {
            if (jjmatchedPos != 3)
            {
               jjmatchedKind = 58;
               jjmatchedPos = 3;
            }
            return 35;
         }
         return -1;
      case 4:
         if ((active0 & 0x1bc580580800L) != 0L)
         {
            if (jjmatchedPos != 4)
            {
               jjmatchedKind = 58;
               jjmatchedPos = 4;
            }
            return 35;
         }
         if ((active0 & 0x224000f053000L) != 0L)
            return 35;
         return -1;
      case 5:
         if ((active0 & 0xc504180800L) != 0L)
         {
            jjmatchedKind = 58;
            jjmatchedPos = 5;
            return 35;
         }
         if ((active0 & 0x1b0080400000L) != 0L)
            return 35;
         return -1;
      case 6:
         if ((active0 & 0x4004100800L) != 0L)
            return 35;
         if ((active0 & 0x8500080000L) != 0L)
         {
            jjmatchedKind = 58;
            jjmatchedPos = 6;
            return 35;
         }
         return -1;
      case 7:
         if ((active0 & 0x8500000000L) != 0L)
         {
            jjmatchedKind = 58;
            jjmatchedPos = 7;
            return 35;
         }
         if ((active0 & 0x80000L) != 0L)
            return 35;
         return -1;
      case 8:
         if ((active0 & 0x100000000L) != 0L)
         {
            jjmatchedKind = 58;
            jjmatchedPos = 8;
            return 35;
         }
         if ((active0 & 0x8400000000L) != 0L)
            return 35;
         return -1;
      case 9:
         if ((active0 & 0x100000000L) != 0L)
            return 35;
         return -1;
      default :
         return -1;
   }
}
private final int jjStartNfa_0(int pos, long active0, long active1)
{
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
}
private final int jjStopAtPos(int pos, int kind)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   return pos + 1;
}
private final 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);
}
private final int jjMoveStringLiteralDfa0_0()
{
   switch(curChar)
   {
      case 9:
         return jjStartNfaWithStates_0(0, 2, 0);
      case 10:
         return jjStartNfaWithStates_0(0, 5, 0);
      case 12:
         return jjStartNfaWithStates_0(0, 4, 0);
      case 13:
         return jjStartNfaWithStates_0(0, 3, 0);
      case 32:
         return jjStartNfaWithStates_0(0, 1, 0);
      case 33:
         jjmatchedKind = 75;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000L);
      case 37:
         jjmatchedKind = 100;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
      case 38:
         jjmatchedKind = 95;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000800000L);
      case 40:
         return jjStopAtPos(0, 61);
      case 41:
         return jjStopAtPos(0, 62);
      case 42:
         jjmatchedKind = 93;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000L);
      case 43:
         jjmatchedKind = 91;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x80002000000L);
      case 44:
         return jjStopAtPos(0, 68);
      case 45:
         jjmatchedKind = 92;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x100004000000L);
      case 46:
         return jjStartNfaWithStates_0(0, 69, 11);
      case 47:
         jjmatchedKind = 94;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L);
      case 58:
         return jjStopAtPos(0, 78);
      case 59:
         return jjStopAtPos(0, 67);
      case 60:
         jjmatchedKind = 73;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x20002000010000L);
      case 61:
         jjmatchedKind = 70;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000L);
      case 62:
         jjmatchedKind = 71;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x280028000040000L);
      case 63:
         return jjStopAtPos(0, 77);
      case 64:
         return jjMoveStringLiteralDfa1_0(0x0L, 0x5450545014a0500L);
      case 91:
         return jjStopAtPos(0, 65);
      case 93:
         return jjStopAtPos(0, 66);
      case 94:
         jjmatchedKind = 99;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
      case 98:
         return jjMoveStringLiteralDfa1_0(0x5800L, 0x0L);
      case 99:
         return jjMoveStringLiteralDfa1_0(0xfa000L, 0x0L);
      case 100:
         return jjMoveStringLiteralDfa1_0(0x700000L, 0x0L);
      case 101:
         return jjMoveStringLiteralDfa1_0(0x800000L, 0x0L);
      case 102:
         return jjMoveStringLiteralDfa1_0(0x1f000000L, 0x0L);
      case 103:
         return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
      case 105:
         return jjMoveStringLiteralDfa1_0(0x7c0000000L, 0x0L);
      case 108:
         return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L);
      case 110:
         return jjMoveStringLiteralDfa1_0(0x3000000000L, 0x0L);
      case 112:
         return jjMoveStringLiteralDfa1_0(0x1c000000000L, 0x0L);
      case 114:
         return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L);
      case 115:
         return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L);
      case 116:
         return jjMoveStringLiteralDfa1_0(0xe00000000000L, 0x0L);
      case 118:
         return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
      case 119:
         return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L);
      case 123:
         return jjStopAtPos(0, 63);
      case 124:
         jjmatchedKind = 97;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000200000L);
      case 125:
         return jjStopAtPos(0, 64);
      case 126:
         return jjStopAtPos(0, 76);
      default :
         return jjMoveNfa_0(6, 0);
   }
}
private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
{
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0, active1);
      return 1;
   }
   switch(curChar)
   {
      case 38:
         if ((active1 & 0x800000L) != 0L)
            return jjStopAtPos(1, 87);
         break;
      case 43:
         if ((active1 & 0x2000000L) != 0L)
            return jjStopAtPos(1, 89);
         break;
      case 45:
         if ((active1 & 0x4000000L) != 0L)
            return jjStopAtPos(1, 90);
         break;
      case 60:
         if ((active1 & 0x2000000000L) != 0L)
         {
            jjmatchedKind = 101;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000000000000L);
      case 61:
         if ((active1 & 0x8000L) != 0L)
            return jjStopAtPos(1, 79);
         else if ((active1 & 0x10000L) != 0L)
            return jjStopAtPos(1, 80);
         else if ((active1 & 0x40000L) != 0L)
            return jjStopAtPos(1, 82);
         else if ((active1 & 0x100000L) != 0L)
            return jjStopAtPos(1, 84);
         else if ((active1 & 0x80000000000L) != 0L)
            return jjStopAtPos(1, 107);
         else if ((active1 & 0x100000000000L) != 0L)
            return jjStopAtPos(1, 108);
         else if ((active1 & 0x200000000000L) != 0L)
            return jjStopAtPos(1, 109);
         else if ((active1 & 0x400000000000L) != 0L)
            return jjStopAtPos(1, 110);
         else if ((active1 & 0x800000000000L) != 0L)
            return jjStopAtPos(1, 111);
         else if ((active1 & 0x2000000000000L) != 0L)
            return jjStopAtPos(1, 113);
         else if ((active1 & 0x8000000000000L) != 0L)
            return jjStopAtPos(1, 115);
         else if ((active1 & 0x10000000000000L) != 0L)
            return jjStopAtPos(1, 116);
         break;
      case 62:
         if ((active1 & 0x8000000000L) != 0L)
         {
            jjmatchedKind = 103;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x280020000000000L);
      case 97:
         return jjMoveStringLiteralDfa2_0(active0, 0x1018000L, active1, 0x1000001000000L);
      case 98:
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x500000000L);
      case 101:
         return jjMoveStringLiteralDfa2_0(active0, 0x21000100000L, active1, 0L);
      case 102:
         if ((active0 & 0x40000000L) != 0L)
            return jjStartNfaWithStates_0(1, 30, 35);
         break;
      case 103:
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80100L);
      case 104:
         return jjMoveStringLiteralDfa2_0(active0, 0x2240000020000L, active1, 0L);
      case 105:
         return jjMoveStringLiteralDfa2_0(active0, 0x6000000L, active1, 0L);
      case 108:
         return jjMoveStringLiteralDfa2_0(active0, 0x8802000L, active1, 0x40004000020400L);
      case 109:
         return jjMoveStringLiteralDfa2_0(active0, 0x80000000L, active1, 0L);
      case 110:
         return jjMoveStringLiteralDfa2_0(active0, 0x700000000L, active1, 0L);
      case 111:
         if ((active0 & 0x200000L) != 0L)
         {
            jjmatchedKind = 21;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0x10008304c0800L, active1, 0x4000000400000L);
      case 114:
         return jjMoveStringLiteralDfa2_0(active0, 0xc0c000001000L, active1, 0x500050000000000L);
      case 116:
         return jjMoveStringLiteralDfa2_0(active0, 0x80000000000L, active1, 0L);
      case 117:
         return jjMoveStringLiteralDfa2_0(active0, 0x12000000000L, active1, 0L);
      case 119:
         return jjMoveStringLiteralDfa2_0(active0, 0x100000000000L, active1, 0L);
      case 121:
         return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L);
      case 124:
         if ((active1 & 0x200000L) != 0L)
            return jjStopAtPos(1, 85);
         break;
      default :
         break;
   }
   return jjStartNfa_0(0, active0, active1);
}
private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(0, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(1, active0, active1);
      return 2;
   }
   switch(curChar)
   {
      case 61:
         if ((active1 & 0x20000000000000L) != 0L)
            return jjStopAtPos(2, 117);
         else if ((active1 & 0x80000000000000L) != 0L)
            return jjStopAtPos(2, 119);
         break;
      case 62:
         if ((active1 & 0x20000000000L) != 0L)
         {
            jjmatchedKind = 105;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000000000000L);
      case 97:
         return jjMoveStringLiteralDfa3_0(active0, 0x80000022000L, active1, 0L);
      case 98:
         return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L, active1, 0L);
      case 101:
         return jjMoveStringLiteralDfa3_0(active0, 0x1000L, active1, 0x40004000000000L);
      case 102:
         return jjMoveStringLiteralDfa3_0(active0, 0x100000L, active1, 0L);
      case 105:
         return jjMoveStringLiteralDfa3_0(active0, 0x3104000000000L, active1, 0x500050500000000L);
      case 108:
         return jjMoveStringLiteralDfa3_0(active0, 0x2001000000L, active1, 0L);
      case 110:
         return jjMoveStringLiteralDfa3_0(active0, 0x8060c0000L, active1, 0x1000001000000L);
      case 111:
         return jjMoveStringLiteralDfa3_0(active0, 0x48008000800L, active1, 0L);
      case 112:
         return jjMoveStringLiteralDfa3_0(active0, 0x80000000L, active1, 0L);
      case 114:
         if ((active0 & 0x10000000L) != 0L)
            return jjStartNfaWithStates_0(2, 28, 35);
         else if ((active1 & 0x400000L) != 0L)
         {
            jjmatchedKind = 86;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0x4000000000000L);
      case 115:
         return jjMoveStringLiteralDfa3_0(active0, 0x100808000L, active1, 0L);
      case 116:
         if ((active0 & 0x200000000L) != 0L)
         {
            jjmatchedKind = 33;
            jjmatchedPos = 2;
         }
         else if ((active1 & 0x100L) != 0L)
         {
            jjmatchedKind = 72;
            jjmatchedPos = 2;
         }
         else if ((active1 & 0x400L) != 0L)
         {
            jjmatchedKind = 74;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0x20420014000L, active1, 0xa0000L);
      case 117:
         return jjMoveStringLiteralDfa3_0(active0, 0x400000400000L, active1, 0L);
      case 119:
         if ((active0 & 0x1000000000L) != 0L)
            return jjStartNfaWithStates_0(2, 36, 35);
         break;
      case 121:
         if ((active0 & 0x800000000000L) != 0L)
            return jjStartNfaWithStates_0(2, 47, 35);
         break;
      default :
         break;
   }
   return jjStartNfa_0(1, active0, active1);
}
private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(1, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0, active1);
      return 3;
   }
   switch(curChar)
   {
      case 61:
         if ((active1 & 0x200000000000000L) != 0L)
            return jjStopAtPos(3, 121);
         break;
      case 95:
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x4000000000000L);
      case 97:
         return jjMoveStringLiteralDfa4_0(active0, 0xe101000L, active1, 0L);
      case 98:
         return jjMoveStringLiteralDfa4_0(active0, 0x400000L, active1, 0L);
      case 99:
         return jjMoveStringLiteralDfa4_0(active0, 0x10000L, active1, 0L);
      case 100:
         if ((active0 & 0x1000000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 48, 35);
         else if ((active1 & 0x1000000L) != 0L)
         {
            jjmatchedKind = 88;
            jjmatchedPos = 3;
         }
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x1000000000000L);
      case 101:
         if ((active0 & 0x4000L) != 0L)
            return jjStartNfaWithStates_0(3, 14, 35);
         else if ((active0 & 0x8000L) != 0L)
            return jjStartNfaWithStates_0(3, 15, 35);
         else if ((active0 & 0x800000L) != 0L)
            return jjStartNfaWithStates_0(3, 23, 35);
         else if ((active0 & 0x400000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 46, 35);
         return jjMoveStringLiteralDfa4_0(active0, 0x400000000L, active1, 0xa0000L);
      case 102:
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x40004000000000L);
      case 103:
         if ((active0 & 0x800000000L) != 0L)
            return jjStartNfaWithStates_0(3, 35, 35);
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x500050000000000L);
      case 108:
         if ((active0 & 0x2000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 37, 35);
         return jjMoveStringLiteralDfa4_0(active0, 0x2010000000800L, active1, 0L);
      case 111:
         if ((active0 & 0x20000000L) != 0L)
            return jjStartNfaWithStates_0(3, 29, 35);
         return jjMoveStringLiteralDfa4_0(active0, 0x200080000000L, active1, 0L);
      case 114:
         if ((active0 & 0x20000L) != 0L)
            return jjStartNfaWithStates_0(3, 17, 35);
         return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L, active1, 0L);
      case 115:
         return jjMoveStringLiteralDfa4_0(active0, 0x1042000L, active1, 0L);
      case 116:
         return jjMoveStringLiteralDfa4_0(active0, 0x188100080000L, active1, 0x500000000L);
      case 117:
         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L);
      case 118:
         return jjMoveStringLiteralDfa4_0(active0, 0x4000000000L, active1, 0L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0, active1);
}
private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(2, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(3, active0, active1);
      return 4;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1000000000000L);
      case 97:
         return jjMoveStringLiteralDfa5_0(active0, 0x4100000000L, active1, 0x4000000000000L);
      case 99:
         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000L, active1, 0L);
      case 101:
         if ((active0 & 0x1000000L) != 0L)
            return jjStartNfaWithStates_0(4, 24, 35);
         else if ((active0 & 0x2000000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 49, 35);
         return jjMoveStringLiteralDfa5_0(active0, 0x8000000800L, active1, 0L);
      case 104:
         if ((active0 & 0x10000L) != 0L)
            return jjStartNfaWithStates_0(4, 16, 35);
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x500050000000000L);
      case 105:
         return jjMoveStringLiteralDfa5_0(active0, 0x90000080000L, active1, 0L);
      case 107:
         if ((active0 & 0x1000L) != 0L)
            return jjStartNfaWithStates_0(4, 12, 35);
         break;
      case 108:
         if ((active0 & 0x2000000L) != 0L)
         {
            jjmatchedKind = 25;
            jjmatchedPos = 4;
         }
         return jjMoveStringLiteralDfa5_0(active0, 0x4400000L, active1, 0L);
      case 113:
         if ((active1 & 0x20000L) != 0L)
            return jjStopAtPos(4, 81);
         else if ((active1 & 0x80000L) != 0L)
            return jjStopAtPos(4, 83);
         break;
      case 114:
         return jjMoveStringLiteralDfa5_0(active0, 0x20480000000L, active1, 0L);
      case 115:
         if ((active0 & 0x2000L) != 0L)
            return jjStartNfaWithStates_0(4, 13, 35);
         break;
      case 116:
         if ((active0 & 0x40000L) != 0L)
            return jjStartNfaWithStates_0(4, 18, 35);
         else if ((active0 & 0x8000000L) != 0L)
            return jjStartNfaWithStates_0(4, 27, 35);
         else if ((active0 & 0x40000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 42, 35);
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x40004000000000L);
      case 117:
         return jjMoveStringLiteralDfa5_0(active0, 0x100000L, active1, 0L);
      case 119:
         if ((active0 & 0x200000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 45, 35);
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x500000000L);
      default :
         break;
   }
   return jjStartNfa_0(3, active0, active1);
}
private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(3, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(4, active0, active1);
      return 5;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x40004000000000L);
      case 97:
         return jjMoveStringLiteralDfa6_0(active0, 0x800L, active1, 0x1000000000000L);
      case 99:
         if ((active0 & 0x10000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 40, 35);
         else if ((active0 & 0x80000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 43, 35);
         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
      case 101:
         if ((active0 & 0x400000L) != 0L)
            return jjStartNfaWithStates_0(5, 22, 35);
         break;
      case 102:
         return jjMoveStringLiteralDfa6_0(active0, 0x400000000L, active1, 0L);
      case 104:
         if ((active0 & 0x100000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 44, 35);
         break;
      case 105:
         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x500000000L);
      case 108:
         return jjMoveStringLiteralDfa6_0(active0, 0x4100000L, active1, 0L);
      case 110:
         if ((active0 & 0x20000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 41, 35);
         return jjMoveStringLiteralDfa6_0(active0, 0x100080000L, active1, 0L);
      case 115:
         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x4000000000000L);
      case 116:
         if ((active0 & 0x80000000L) != 0L)
            return jjStartNfaWithStates_0(5, 31, 35);
         return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L, active1, 0x500050000000000L);
      default :
         break;
   }
   return jjStartNfa_0(4, active0, active1);
}
private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(4, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(5, active0, active1);
      return 6;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x500050000000000L);
      case 97:
         return jjMoveStringLiteralDfa7_0(active0, 0x400000000L, active1, 0L);
      case 99:
         return jjMoveStringLiteralDfa7_0(active0, 0x100000000L, active1, 0L);
      case 101:
         if ((active0 & 0x4000000000L) != 0L)
            return jjStartNfaWithStates_0(6, 38, 35);
         break;
      case 110:
         if ((active0 & 0x800L) != 0L)
            return jjStartNfaWithStates_0(6, 11, 35);
         break;
      case 115:
         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x45004500000000L);
      case 116:
         if ((active0 & 0x100000L) != 0L)
            return jjStartNfaWithStates_0(6, 20, 35);
         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0L);
      case 117:
         return jjMoveStringLiteralDfa7_0(active0, 0x80000L, active1, 0L);
      case 121:
         if ((active0 & 0x4000000L) != 0L)
            return jjStartNfaWithStates_0(6, 26, 35);
         break;
      default :
         break;
   }
   return jjStartNfa_0(5, active0, active1);
}
private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(5, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(6, active0, active1);
      return 7;
   }
   switch(curChar)
   {
      case 99:
         return jjMoveStringLiteralDfa8_0(active0, 0x400000000L, active1, 0L);
      case 101:
         if ((active0 & 0x80000L) != 0L)
            return jjStartNfaWithStates_0(7, 19, 35);
         return jjMoveStringLiteralDfa8_0(active0, 0x8100000000L, active1, 0x500000000L);
      case 104:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x40004000000000L);
      case 105:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x4000000000000L);
      case 115:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x101010000000000L);
      case 117:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x400040000000000L);
      default :
         break;
   }
   return jjStartNfa_0(6, active0, active1);
}
private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(6, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(7, active0, active1);
      return 8;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x500000000L);
      case 100:
         if ((active0 & 0x8000000000L) != 0L)
            return jjStartNfaWithStates_0(8, 39, 35);
         break;
      case 101:
         if ((active0 & 0x400000000L) != 0L)
            return jjStartNfaWithStates_0(8, 34, 35);
         break;
      case 103:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x4000000000000L);
      case 104:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x100010000000000L);
      case 105:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x41004000000000L);
      case 110:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x400040000000000L);
      case 111:
         return jjMoveStringLiteralDfa9_0(active0, 0x100000000L, active1, 0L);
      default :
         break;
   }
   return jjStartNfa_0(7, active0, active1);
}
private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(7, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(8, active0, active1);
      return 9;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x100000000L);
      case 102:
         if ((active0 & 0x100000000L) != 0L)
            return jjStartNfaWithStates_0(9, 32, 35);
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x40004000000000L);
      case 103:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x1000000000000L);
      case 105:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x100010000000000L);
      case 110:
         if ((active1 & 0x4000000000000L) != 0L)
            return jjStopAtPos(9, 114);
         break;
      case 111:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x400000000L);
      case 115:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x400040000000000L);
      default :
         break;
   }
   return jjStartNfa_0(8, active0, active1);
}
private final int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(8, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(9, 0L, active1);
      return 10;
   }
   switch(curChar)
   {
      case 102:
         return jjMoveStringLiteralDfa11_0(active1, 0x100010000000000L);
      case 105:
         return jjMoveStringLiteralDfa11_0(active1, 0x400040000000000L);
      case 110:
         if ((active1 & 0x1000000000000L) != 0L)
            return jjStopAtPos(10, 112);
         return jjMoveStringLiteralDfa11_0(active1, 0x100000000L);
      case 114:
         if ((active1 & 0x400000000L) != 0L)
            return jjStopAtPos(10, 98);
         break;
      case 116:
         if ((active1 & 0x4000000000L) != 0L)
         {
            jjmatchedKind = 102;
            jjmatchedPos = 10;
         }
         return jjMoveStringLiteralDfa11_0(active1, 0x40000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(9, 0L, active1);
}
private final int jjMoveStringLiteralDfa11_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(9, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(10, 0L, active1);
      return 11;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa12_0(active1, 0x40000000000000L);
      case 100:
         if ((active1 & 0x100000000L) != 0L)
            return jjStopAtPos(11, 96);
         break;
      case 103:
         return jjMoveStringLiteralDfa12_0(active1, 0x400040000000000L);
      case 116:
         if ((active1 & 0x10000000000L) != 0L)
         {
            jjmatchedKind = 104;
            jjmatchedPos = 11;
         }
         return jjMoveStringLiteralDfa12_0(active1, 0x100000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(10, 0L, active1);
}
private final int jjMoveStringLiteralDfa12_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(10, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(11, 0L, active1);
      return 12;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa13_0(active1, 0x100000000000000L);
      case 97:
         return jjMoveStringLiteralDfa13_0(active1, 0x40000000000000L);
      case 110:
         return jjMoveStringLiteralDfa13_0(active1, 0x400040000000000L);
      default :
         break;
   }
   return jjStartNfa_0(11, 0L, active1);
}
private final int jjMoveStringLiteralDfa13_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(11, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(12, 0L, active1);
      return 13;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa14_0(active1, 0x100000000000000L);
      case 101:
         return jjMoveStringLiteralDfa14_0(active1, 0x400040000000000L);
      case 115:
         return jjMoveStringLiteralDfa14_0(active1, 0x40000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(12, 0L, active1);
}
private final int jjMoveStringLiteralDfa14_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(12, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(13, 0L, active1);
      return 14;
   }
   switch(curChar)
   {
      case 100:
         return jjMoveStringLiteralDfa15_0(active1, 0x400040000000000L);
      case 115:
         return jjMoveStringLiteralDfa15_0(active1, 0x140000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(13, 0L, active1);
}
private final int jjMoveStringLiteralDfa15_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(13, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(14, 0L, active1);
      return 15;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa16_0(active1, 0x400040000000000L);
      case 105:
         return jjMoveStringLiteralDfa16_0(active1, 0x40000000000000L);
      case 115:
         return jjMoveStringLiteralDfa16_0(active1, 0x100000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(14, 0L, active1);
}
private final int jjMoveStringLiteralDfa16_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(14, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(15, 0L, active1);
      return 16;
   }
   switch(curChar)
   {
      case 103:
         return jjMoveStringLiteralDfa17_0(active1, 0x40000000000000L);
      case 105:
         return jjMoveStringLiteralDfa17_0(active1, 0x100000000000000L);
      case 115:
         return jjMoveStringLiteralDfa17_0(active1, 0x400040000000000L);
      default :
         break;
   }
   return jjStartNfa_0(15, 0L, active1);
}
private final int jjMoveStringLiteralDfa17_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(15, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(16, 0L, active1);
      return 17;
   }
   switch(curChar)
   {
      case 103:
         return jjMoveStringLiteralDfa18_0(active1, 0x100000000000000L);
      case 104:
         return jjMoveStringLiteralDfa18_0(active1, 0x400040000000000L);
      case 110:
         if ((active1 & 0x40000000000000L) != 0L)
            return jjStopAtPos(17, 118);
         break;
      default :
         break;
   }
   return jjStartNfa_0(16, 0L, active1);
}
private final int jjMoveStringLiteralDfa18_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(16, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(17, 0L, active1);
      return 18;
   }
   switch(curChar)
   {
      case 105:
         return jjMoveStringLiteralDfa19_0(active1, 0x400040000000000L);
      case 110:
         if ((active1 & 0x100000000000000L) != 0L)
            return jjStopAtPos(18, 120);
         break;
      default :
         break;
   }
   return jjStartNfa_0(17, 0L, active1);
}
private final int jjMoveStringLiteralDfa19_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(17, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(18, 0L, active1);
      return 19;
   }
   switch(curChar)
   {
      case 102:
         return jjMoveStringLiteralDfa20_0(active1, 0x400040000000000L);
      default :
         break;
   }
   return jjStartNfa_0(18, 0L, active1);
}
private final int jjMoveStringLiteralDfa20_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(18, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(19, 0L, active1);
      return 20;
   }
   switch(curChar)
   {
      case 116:
         if ((active1 & 0x40000000000L) != 0L)
         {
            jjmatchedKind = 106;
            jjmatchedPos = 20;
         }
         return jjMoveStringLiteralDfa21_0(active1, 0x400000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(19, 0L, active1);
}
private final int jjMoveStringLiteralDfa21_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(19, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(20, 0L, active1);
      return 21;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa22_0(active1, 0x400000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(20, 0L, active1);
}
private final int jjMoveStringLiteralDfa22_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(20, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(21, 0L, active1);
      return 22;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa23_0(active1, 0x400000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(21, 0L, active1);
}
private final int jjMoveStringLiteralDfa23_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(21, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(22, 0L, active1);
      return 23;
   }
   switch(curChar)
   {
      case 115:
         return jjMoveStringLiteralDfa24_0(active1, 0x400000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(22, 0L, active1);
}
private final int jjMoveStringLiteralDfa24_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(22, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(23, 0L, active1);
      return 24;
   }
   switch(curChar)
   {
      case 115:
         return jjMoveStringLiteralDfa25_0(active1, 0x400000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(23, 0L, active1);
}
private final int jjMoveStringLiteralDfa25_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(23, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(24, 0L, active1);
      return 25;
   }
   switch(curChar)
   {
      case 105:
         return jjMoveStringLiteralDfa26_0(active1, 0x400000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(24, 0L, active1);
}
private final int jjMoveStringLiteralDfa26_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(24, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(25, 0L, active1);
      return 26;
   }
   switch(curChar)
   {
      case 103:
         return jjMoveStringLiteralDfa27_0(active1, 0x400000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(25, 0L, active1);
}
private final int jjMoveStringLiteralDfa27_0(long old1, long active1)
{
   if (((active1 &= old1)) == 0L)
      return jjStartNfa_0(25, 0L, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(26, 0L, active1);
      return 27;
   }
   switch(curChar)
   {
      case 110:
         if ((active1 & 0x400000000000000L) != 0L)
            return jjStopAtPos(27, 122);
         break;
      default :
         break;
   }
   return jjStartNfa_0(26, 0L, active1);
}
private final void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private final void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private final void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}
private final void jjCheckNAddStates(int start, int end)
{
   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
}
private final void jjCheckNAddStates(int start)
{
   jjCheckNAdd(jjnextStates[start]);
   jjCheckNAdd(jjnextStates[start + 1]);
}
static final long[] jjbitVec0 = {
   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec1 = {
   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec3 = {
   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
};
static final long[] jjbitVec4 = {
   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
};
static final long[] jjbitVec5 = {
   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec6 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
};
static final long[] jjbitVec7 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
};
static final long[] jjbitVec8 = {
   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
};
private final int jjMoveNfa_0(int startState, int curPos)
{
   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 74;
   int i = 1;
   jjstateSet[0] = startState;
   int j, kind = 0x7fffffff;
   for (;;)
   {
      if (++jjround == 0x7fffffff)
         ReInitRounds();
      if (curChar < 64)
      {
         long l = 1L << curChar;
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 6:
                  if ((0x1ffffffffL & l) != 0L)
                  {
                     if (kind > 6)
                        kind = 6;
                     jjCheckNAdd(0);
                  }
                  else if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddStates(0, 6);
                  else if (curChar == 47)
                     jjAddStates(7, 9);
                  else if (curChar == 36)
                  {
                     if (kind > 58)
                        kind = 58;
                     jjCheckNAdd(35);
                  }
                  else if (curChar == 34)
                     jjCheckNAddStates(10, 12);
                  else if (curChar == 39)
                     jjAddStates(13, 14);
                  else if (curChar == 46)
                     jjCheckNAdd(11);
                  else if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 1;
                  if ((0x3fe000000000000L & l) != 0L)
                  {
                     if (kind > 50)
                        kind = 50;
                     jjCheckNAddTwoStates(8, 9);
                  }
                  else if (curChar == 48)
                  {
                     if (kind > 50)
                        kind = 50;
                     jjCheckNAddStates(15, 17);
                  }
                  break;
               case 56:
                  if (curChar == 42)
                     jjCheckNAddTwoStates(69, 70);
                  else if (curChar == 47)
                  {
                     if (kind > 7)
                        kind = 7;
                     jjCheckNAddStates(18, 20);
                  }
                  if (curChar == 42)
                     jjstateSet[jjnewStateCnt++] = 61;
                  break;
               case 0:
                  if ((0x1ffffffffL & l) == 0L)
                     break;
                  if (kind > 6)
                     kind = 6;
                  jjCheckNAdd(0);
                  break;
               case 1:
                  if (curChar == 33)
                     jjCheckNAddStates(21, 23);
                  break;
               case 2:
                  if ((0xffffffffffffdbffL & l) != 0L)
                     jjCheckNAddStates(21, 23);
                  break;
               case 3:
                  if ((0x2400L & l) != 0L && kind > 8)
                     kind = 8;
                  break;
               case 4:
                  if (curChar == 10 && kind > 8)
                     kind = 8;
                  break;
               case 5:
                  if (curChar == 13)
                     jjstateSet[jjnewStateCnt++] = 4;
                  break;
               case 7:
                  if ((0x3fe000000000000L & l) == 0L)
                     break;
                  if (kind > 50)
                     kind = 50;
                  jjCheckNAddTwoStates(8, 9);
                  break;
               case 8:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 50)
                     kind = 50;
                  jjCheckNAddTwoStates(8, 9);
                  break;
               case 10:
                  if (curChar == 46)
                     jjCheckNAdd(11);
                  break;
               case 11:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 54)
                     kind = 54;
                  jjCheckNAddStates(24, 26);
                  break;
               case 13:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(14);
                  break;
               case 14:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 54)
                     kind = 54;
                  jjCheckNAddTwoStates(14, 15);
                  break;
               case 16:
                  if (curChar == 39)
                     jjAddStates(13, 14);
                  break;
               case 17:
                  if ((0xffffff7fffffdbffL & l) != 0L)
                     jjCheckNAdd(18);
                  break;
               case 18:
                  if (curChar == 39 && kind > 56)
                     kind = 56;
                  break;
               case 20:
                  if ((0x8400000000L & l) != 0L)
                     jjCheckNAdd(18);
                  break;
               case 21:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(22, 18);
                  break;
               case 22:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAdd(18);
                  break;
               case 23:
                  if ((0xf000000000000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 24;
                  break;
               case 24:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAdd(22);
                  break;
               case 25:
                  if (curChar == 34)
                     jjCheckNAddStates(10, 12);
                  break;
               case 26:
                  if ((0xfffffffbffffdbffL & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 28:
                  if ((0x8400000000L & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 29:
                  if (curChar == 34 && kind > 57)
                     kind = 57;
                  break;
               case 30:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAddStates(27, 30);
                  break;
               case 31:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 32:
                  if ((0xf000000000000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 33;
                  break;
               case 33:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAdd(31);
                  break;
               case 34:
                  if (curChar != 36)
                     break;
                  if (kind > 58)
                     kind = 58;
                  jjCheckNAdd(35);
                  break;
               case 35:
                  if ((0x3ff001000000000L & l) == 0L)
                     break;
                  if (kind > 58)
                     kind = 58;
                  jjCheckNAdd(35);
                  break;
               case 36:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddStates(0, 6);
                  break;
               case 37:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(37, 38);
                  break;
               case 38:
                  if (curChar != 46)
                     break;
                  if (kind > 54)
                     kind = 54;
                  jjCheckNAddStates(31, 33);
                  break;
               case 39:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 54)
                     kind = 54;
                  jjCheckNAddStates(31, 33);
                  break;
               case 41:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(42);
                  break;
               case 42:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 54)
                     kind = 54;
                  jjCheckNAddTwoStates(42, 15);
                  break;
               case 43:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(43, 44);
                  break;
               case 45:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(46);
                  break;
               case 46:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 54)
                     kind = 54;
                  jjCheckNAddTwoStates(46, 15);
                  break;
               case 47:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddStates(34, 36);
                  break;
               case 49:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(50);
                  break;
               case 50:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(50, 15);
                  break;
               case 51:
                  if (curChar != 48)
                     break;
                  if (kind > 50)
                     kind = 50;
                  jjCheckNAddStates(15, 17);
                  break;
               case 53:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 50)
                     kind = 50;
                  jjCheckNAddTwoStates(53, 9);
                  break;
               case 54:
                  if ((0xff000000000000L & l) == 0L)
                     break;
                  if (kind > 50)
                     kind = 50;
                  jjCheckNAddTwoStates(54, 9);
                  break;
               case 55:
                  if (curChar == 47)
                     jjAddStates(7, 9);
                  break;
               case 57:
                  if ((0xffffffffffffdbffL & l) == 0L)
                     break;
                  if (kind > 7)
                     kind = 7;
                  jjCheckNAddStates(18, 20);
                  break;
               case 58:
                  if ((0x2400L & l) != 0L && kind > 7)
                     kind = 7;
                  break;
               case 59:
                  if (curChar == 10 && kind > 7)
                     kind = 7;
                  break;
               case 60:
                  if (curChar == 13)
                     jjstateSet[jjnewStateCnt++] = 59;
                  break;
               case 61:
                  if (curChar == 42)
                     jjCheckNAddTwoStates(62, 63);
                  break;
               case 62:
                  if ((0xfffffbffffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(62, 63);
                  break;
               case 63:
                  if (curChar == 42)
                     jjCheckNAddStates(37, 39);
                  break;
               case 64:
                  if ((0xffff7bffffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(65, 63);
                  break;
               case 65:
                  if ((0xfffffbffffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(65, 63);
                  break;
               case 66:
                  if (curChar == 47 && kind > 9)
                     kind = 9;
                  break;
               case 67:
                  if (curChar == 42)
                     jjstateSet[jjnewStateCnt++] = 61;
                  break;
               case 68:
                  if (curChar == 42)
                     jjCheckNAddTwoStates(69, 70);
                  break;
               case 69:
                  if ((0xfffffbffffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(69, 70);
                  break;
               case 70:
                  if (curChar == 42)
                     jjCheckNAddStates(40, 42);
                  break;
               case 71:
                  if ((0xffff7bffffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(72, 70);
                  break;
               case 72:
                  if ((0xfffffbffffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(72, 70);
                  break;
               case 73:
                  if (curChar == 47 && kind > 10)
                     kind = 10;
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 6:
               case 35:
                  if ((0x7fffffe87fffffeL & l) == 0L)
                     break;
                  if (kind > 58)
                     kind = 58;
                  jjCheckNAdd(35);
                  break;
               case 2:
                  jjAddStates(21, 23);
                  break;
               case 9:
                  if ((0x100000001000L & l) != 0L && kind > 50)
                     kind = 50;
                  break;
               case 12:
                  if ((0x2000000020L & l) != 0L)
                     jjAddStates(43, 44);
                  break;
               case 15:
                  if ((0x5000000050L & l) != 0L && kind > 54)
                     kind = 54;
                  break;
               case 17:
                  if ((0xffffffffefffffffL & l) != 0L)
                     jjCheckNAdd(18);
                  break;
               case 19:
                  if (curChar == 92)
                     jjAddStates(45, 47);
                  break;
               case 20:
                  if ((0x14404410000000L & l) != 0L)
                     jjCheckNAdd(18);
                  break;
               case 26:
                  if ((0xffffffffefffffffL & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 27:
                  if (curChar == 92)
                     jjAddStates(48, 50);
                  break;
               case 28:
                  if ((0x14404410000000L & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 40:
                  if ((0x2000000020L & l) != 0L)
                     jjAddStates(51, 52);
                  break;
               case 44:
                  if ((0x2000000020L & l) != 0L)
                     jjAddStates(53, 54);
                  break;
               case 48:
                  if ((0x2000000020L & l) != 0L)
                     jjAddStates(55, 56);
                  break;
               case 52:
                  if ((0x100000001000000L & l) != 0L)
                     jjCheckNAdd(53);
                  break;
               case 53:
                  if ((0x7e0000007eL & l) == 0L)
                     break;
                  if (kind > 50)
                     kind = 50;
                  jjCheckNAddTwoStates(53, 9);
                  break;
               case 57:
                  if (kind > 7)
                     kind = 7;
                  jjAddStates(18, 20);
                  break;
               case 62:
                  jjCheckNAddTwoStates(62, 63);
                  break;
               case 64:
               case 65:
                  jjCheckNAddTwoStates(65, 63);
                  break;
               case 69:
                  jjCheckNAddTwoStates(69, 70);
                  break;
               case 71:
               case 72:
                  jjCheckNAddTwoStates(72, 70);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 6:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                  {
                     if (kind > 6)
                        kind = 6;
                     jjCheckNAdd(0);
                  }
                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
                  {
                     if (kind > 58)
                        kind = 58;
                     jjCheckNAdd(35);
                  }
                  break;
               case 0:
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 6)
                     kind = 6;
                  jjCheckNAdd(0);
                  break;
               case 2:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjAddStates(21, 23);
                  break;
               case 17:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjstateSet[jjnewStateCnt++] = 18;
                  break;
               case 26:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjAddStates(10, 12);
                  break;
               case 34:
               case 35:
                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 58)
                     kind = 58;
                  jjCheckNAdd(35);
                  break;
               case 57:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 7)
                     kind = 7;
                  jjAddStates(18, 20);
                  break;
               case 62:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(62, 63);
                  break;
               case 64:
               case 65:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(65, 63);
                  break;
               case 69:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(69, 70);
                  break;
               case 71:
               case 72:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(72, 70);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 74 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
static final int[] jjnextStates = {
   37, 38, 43, 44, 47, 48, 15, 56, 67, 68, 26, 27, 29, 17, 19, 52,
   54, 9, 57, 58, 60, 2, 3, 5, 11, 12, 15, 26, 27, 31, 29, 39,
   40, 15, 47, 48, 15, 63, 64, 66, 70, 71, 73, 13, 14, 20, 21, 23,
   28, 30, 32, 41, 42, 45, 46, 49, 50,
};
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
{
   switch(hiByte)
   {
      case 0:
         return ((jjbitVec0[i2] & l2) != 0L);
      default :
         return false;
   }
}
private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
{
   switch(hiByte)
   {
      case 0:
         return ((jjbitVec0[i2] & l2) != 0L);
      default :
         if ((jjbitVec1[i1] & l1) != 0L)
            return true;
         return false;
   }
}
private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
{
   switch(hiByte)
   {
      case 0:
         return ((jjbitVec4[i2] & l2) != 0L);
      case 48:
         return ((jjbitVec5[i2] & l2) != 0L);
      case 49:
         return ((jjbitVec6[i2] & l2) != 0L);
      case 51:
         return ((jjbitVec7[i2] & l2) != 0L);
      case 61:
         return ((jjbitVec8[i2] & l2) != 0L);
      default :
         if ((jjbitVec3[i1] & l1) != 0L)
            return true;
         return false;
   }
}
public static final String[] jjstrLiteralImages = {
"", null, null, null, null, null, null, null, null, null, null,
"\142\157\157\154\145\141\156", "\142\162\145\141\153", "\143\154\141\163\163", "\142\171\164\145",
"\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\157\156\163\164",
"\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145",
"\145\154\163\145", "\146\141\154\163\145", "\146\151\156\141\154",
"\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\145\167", "\156\165\154\154",
"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
"\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143",
"\163\167\151\164\143\150", "\164\150\162\157\167", "\164\162\165\145", "\164\162\171",
"\166\157\151\144", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null,
null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
"\75", "\76", "\100\147\164", "\74", "\100\154\164", "\41", "\176", "\77", "\72",
"\75\75", "\74\75", "\100\154\164\145\161", "\76\75", "\100\147\164\145\161", "\41\75",
"\174\174", "\100\157\162", "\46\46", "\100\141\156\144", "\53\53", "\55\55", "\53",
"\55", "\52", "\57", "\46", "\100\142\151\164\167\151\163\145\137\141\156\144",
"\174", "\100\142\151\164\167\151\163\145\137\157\162", "\136", "\45", "\74\74",
"\100\154\145\146\164\137\163\150\151\146\164", "\76\76", "\100\162\151\147\150\164\137\163\150\151\146\164", "\76\76\76",
"\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75",
"\100\141\156\144\137\141\163\163\151\147\156", "\174\75", "\100\157\162\137\141\163\163\151\147\156", "\136\75", "\45\75",
"\74\74\75", "\100\154\145\146\164\137\163\150\151\146\164\137\141\163\163\151\147\156",
"\76\76\75",
"\100\162\151\147\150\164\137\163\150\151\146\164\137\141\163\163\151\147\156", "\76\76\76\75",
"\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164\137\141\163\163\151\147\156", };
public static final String[] lexStateNames = {
   "DEFAULT",
};
static final long[] jjtoToken = {
   0xe747fffffffff801L, 0x7ffffffffffffffL,
};
static final long[] jjtoSkip = {
   0x7feL, 0x0L,
};
static final long[] jjtoSpecial = {
   0x780L, 0x0L,
};
private ASCII_UCodeESC_CharStream input_stream;
private final int[] jjrounds = new int[74];
private final int[] jjstateSet = new int[148];
protected char curChar;
public ParserTokenManager(ASCII_UCodeESC_CharStream stream)
{
   if (ASCII_UCodeESC_CharStream.staticFlag)
      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
   input_stream = stream;
}
public ParserTokenManager(ASCII_UCodeESC_CharStream stream, int lexState)
{
   this(stream);
   SwitchTo(lexState);
}
public void ReInit(ASCII_UCodeESC_CharStream stream)
{
   jjmatchedPos = jjnewStateCnt = 0;
   curLexState = defaultLexState;
   input_stream = stream;
   ReInitRounds();
}
private final void ReInitRounds()
{
   int i;
   jjround = 0x80000001;
   for (i = 74; i-- > 0;)
      jjrounds[i] = 0x80000000;
}
public void ReInit(ASCII_UCodeESC_CharStream stream, int lexState)
{
   ReInit(stream);
   SwitchTo(lexState);
}
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;
}

private final Token jjFillToken()
{
   Token t = Token.newToken(jjmatchedKind);
   t.kind = jjmatchedKind;
   String im = jjstrLiteralImages[jjmatchedKind];
   t.image = (im == null) ? input_stream.GetImage() : im;
   t.beginLine = input_stream.getBeginLine();
   t.beginColumn = input_stream.getBeginColumn();
   t.endLine = input_stream.getEndLine();
   t.endColumn = input_stream.getEndColumn();
   return t;
}

int curLexState = 0;
int defaultLexState = 0;
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;

public final Token getNextToken()
{
  int kind;
  Token specialToken = null;
  Token matchedToken;
  int curPos = 0;

  EOFLoop :
  for (;;)
  {
   try
   {
      curChar = input_stream.BeginToken();
   }
   catch(java.io.IOException e)
   {
      jjmatchedKind = 0;
      matchedToken = jjFillToken();
      matchedToken.specialToken = specialToken;
      return matchedToken;
   }

   jjmatchedKind = 0x7fffffff;
   jjmatchedPos = 0;
   curPos = jjMoveStringLiteralDfa0_0();
   if (jjmatchedKind != 0x7fffffff)
   {
      if (jjmatchedPos + 1 < curPos)
         input_stream.backup(curPos - jjmatchedPos - 1);
      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
      {
         matchedToken = jjFillToken();
         matchedToken.specialToken = specialToken;
         return matchedToken;
      }
      else
      {
         if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
         {
            matchedToken = jjFillToken();
            if (specialToken == null)
               specialToken = matchedToken;
            else
            {
               matchedToken.specialToken = specialToken;
               specialToken = (specialToken.next = matchedToken);
            }
         }
         continue EOFLoop;
      }
   }
   int error_line = input_stream.getEndLine();
   int error_column = input_stream.getEndColumn();
   String error_after = null;
   boolean EOFSeen = false;
   try { input_stream.readChar(); input_stream.backup(1); }
   catch (java.io.IOException e1) {
      EOFSeen = true;
      error_after = curPos <= 1 ? "" : input_stream.GetImage();
      if (curChar == '\n' || curChar == '\r') {
         error_line++;
         error_column = 0;
      }
      else
         error_column++;
   }
   if (!EOFSeen) {
      input_stream.backup(1);
      error_after = curPos <= 1 ? "" : input_stream.GetImage();
   }
   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);

FUNC_DECL RETURN PARAM PARAM PARAM CALL BINARY_OP CALL LITERAL_ANCHOR

FUNC_DECL RETURN TRY PARAM PARAM PARAM CALL CATCH ASSIGN ASSIGN BINARY_OP RETURN ASSIGN LITERAL_ANCHOR BINARY_OP CALL LITERAL_ANCHOR

FUNC_DECL IF PARAM BINARY_OP ASSIGN ASSIGN

FUNC_DECL LOOP PARAM PARAM BINARY_OP ASSIGN

FUNC_DECL LOOP PARAM PARAM BINARY_OP CALL

FUNC_DECL PARAM CALL ASSIGN ASSIGN ASSIGN ASSIGN LITERAL_ANCHOR

FUNC_DECL RETURN VAR_DECL VAR_DECL ASSIGN ASSIGN ASSIGN ASSIGN ASSIGN ASSIGN CALL CALL CALL CALL COND_EXPR CALL CALL BINARY_OP LITERAL_ANCHOR


public class LoadSaveOptionPane extends AbstractOptionPane
{
	//{{{ LoadSaveOptionPane constructor
	public LoadSaveOptionPane()
	{
		super("loadsave");
	} //}}}

	//{{{ _init() method
	public void _init()
	{
		/* Autosave interval */
		autosave = new JTextField(jEdit.getProperty("autosave"));
		addComponent(jEdit.getProperty("options.loadsave.autosave"),autosave);

		/* Backup count */
		backups = new JTextField(jEdit.getProperty("backups"));
		addComponent(jEdit.getProperty("options.loadsave.backups"),backups);

		/* Backup directory */
		backupDirectory = new JTextField(jEdit.getProperty(
			"backup.directory"));
		addComponent(jEdit.getProperty("options.loadsave.backupDirectory"),
			backupDirectory);

		/* Backup filename prefix */
		backupPrefix = new JTextField(jEdit.getProperty("backup.prefix"));
		addComponent(jEdit.getProperty("options.loadsave.backupPrefix"),
			backupPrefix);

		/* Backup suffix */
		backupSuffix = new JTextField(jEdit.getProperty(
			"backup.suffix"));
		addComponent(jEdit.getProperty("options.loadsave.backupSuffix"),
			backupSuffix);

		/* Line separator */
		String[] lineSeps = { jEdit.getProperty("lineSep.unix"),
			jEdit.getProperty("lineSep.windows"),
			jEdit.getProperty("lineSep.mac") };
		lineSeparator = new JComboBox(lineSeps);
		String lineSep = jEdit.getProperty("buffer.lineSeparator",
			System.getProperty("line.separator"));
		if("\n".equals(lineSep))
			lineSeparator.setSelectedIndex(0);
		else if("\r\n".equals(lineSep))
			lineSeparator.setSelectedIndex(1);
		else if("\r".equals(lineSep))
			lineSeparator.setSelectedIndex(2);
		addComponent(jEdit.getProperty("options.loadsave.lineSeparator"),
			lineSeparator);

		/* Default file encoding */
		DefaultComboBoxModel encodings = new DefaultComboBoxModel();
		StringTokenizer st = new StringTokenizer(jEdit.getProperty("encodings"));
		while(st.hasMoreTokens())
		{
			encodings.addElement(st.nextToken());
		}

		encoding = new JComboBox(encodings);
		encoding.setEditable(true);
		encoding.setSelectedItem(jEdit.getProperty("buffer.encoding",
			System.getProperty("file.encoding")));
		addComponent(jEdit.getProperty("options.loadsave.encoding"),encoding);

		/* Session management */
		restore = new JCheckBox(jEdit.getProperty(
			"options.loadsave.restore"));
		restore.setSelected(jEdit.getBooleanProperty("restore"));
		restore.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent evt)
			{
				restoreCLI.setEnabled(restore.isSelected());
			}
		});

		addComponent(restore);
		restoreCLI = new JCheckBox(jEdit.getProperty(
			"options.loadsave.restore.cli"));
		restoreCLI.setSelected(jEdit.getBooleanProperty("restore.cli"));
		restoreCLI.setEnabled(restore.isSelected());
		addComponent(restoreCLI);

		/* Clients open files in new view */
		newView = new JCheckBox(jEdit.getProperty(
			"options.loadsave.newView"));
		newView.setSelected(jEdit.getBooleanProperty("client.newView"));
		addComponent(newView);

		/* Persistent markers */
		persistentMarkers = new JCheckBox(jEdit.getProperty(
			"options.loadsave.persistentMarkers"));
		persistentMarkers.setSelected(jEdit.getBooleanProperty(
			"persistentMarkers"));
		addComponent(persistentMarkers);

		/* Two-stage save */
		twoStageSave = new JCheckBox(jEdit.getProperty(
			"options.loadsave.twoStageSave"));
		twoStageSave.setSelected(jEdit.getBooleanProperty(
			"twoStageSave"));
		addComponent(twoStageSave);

		/* Backup on every save */
		backupEverySave = new JCheckBox(jEdit.getProperty(
			"options.loadsave.backupEverySave"));
		backupEverySave.setSelected(jEdit.getBooleanProperty("backupEverySave"));
		addComponent(backupEverySave);

		/* Backup on every save */
		stripTrailingEOL = new JCheckBox(jEdit.getProperty(
			"options.loadsave.stripTrailingEOL"));
		stripTrailingEOL.setSelected(jEdit.getBooleanProperty("stripTrailingEOL"));
		addComponent(stripTrailingEOL);

	} //}}}

	//{{{ _save() method
	public void _save()
	{
		jEdit.setProperty("autosave",autosave.getText());
		jEdit.setProperty("backups",backups.getText());
		jEdit.setProperty("backup.directory",backupDirectory.getText());
		jEdit.setProperty("backup.prefix",backupPrefix.getText());
		jEdit.setProperty("backup.suffix",backupSuffix.getText());
		String lineSep = null;
		switch(lineSeparator.getSelectedIndex())
		{
		case 0:
			lineSep = "\n";
			break;
		case 1:
			lineSep = "\r\n";
			break;
		case 2:
			lineSep = "\r";
			break;
		}
		jEdit.setProperty("buffer.lineSeparator",lineSep);
		jEdit.setProperty("buffer.encoding",(String)
			encoding.getSelectedItem());
		jEdit.setBooleanProperty("restore",restore.isSelected());
		jEdit.setBooleanProperty("restore.cli",restoreCLI.isSelected());
		jEdit.setBooleanProperty("client.newView",newView.isSelected());
		jEdit.setBooleanProperty("persistentMarkers",
			persistentMarkers.isSelected());
		jEdit.setBooleanProperty("twoStageSave",twoStageSave.isSelected());
		jEdit.setBooleanProperty("backupEverySave", backupEverySave.isSelected());
		jEdit.setBooleanProperty("stripTrailingEOL", stripTrailingEOL.isSelected());
	} //}}}

	//{{{ Private members
	private JTextField autosave;
	private JTextField backups;
	private JTextField backupDirectory;
	private JTextField backupPrefix;
	private JTextField backupSuffix;
	private JComboBox lineSeparator;
	private JComboBox encoding;
	private JCheckBox restore;
	private JCheckBox restoreCLI;
	private JCheckBox newView;
	private JCheckBox persistentMarkers;
	private JCheckBox twoStageSave;
	private JCheckBox backupEverySave;
	private JCheckBox stripTrailingEOL;

FUNC_DECL LOOP VAR_DECL VAR_DECL IF VAR_DECL VAR_DECL CALL CALL ASSIGN CALL CALL ASSIGN CALL CALL ASSIGN CALL CALL ASSIGN CALL CALL ASSIGN CALL CALL CALL ASSIGN CALL CALL CALL ASSIGN CALL CALL CALL ASSIGN CALL CALL IF LITERAL_ANCHOR ASSIGN CALL ASSIGN CALL ASSIGN CALL ASSIGN CALL ASSIGN CALL ASSIGN CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL LITERAL_ANCHOR CALL CALL CALL CALL IF LITERAL_ANCHOR CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL FUNC_DECL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL CALL LITERAL_ANCHOR LITERAL_ANCHOR CALL CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL CALL CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR PARAM LITERAL_ANCHOR LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL CALL LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR LITERAL_ANCHOR CALL LITERAL_ANCHOR CALL


public class XmppComponent extends DefaultComponent<XmppExchange> {
    /**
     * Static builder method
     */
    public static XmppComponent xmppComponent() {
        return new XmppComponent();
    }

    public XmppComponent() {
    }

    public XmppComponent(CamelContext context) {
        super(context);
    }

    @Override
    protected Endpoint<XmppExchange> createEndpoint(String uri, String remaining, Map parameters) throws Exception {
        XmppEndpoint endpoint = new XmppEndpoint(uri, this);

        URI u = new URI(uri);
        endpoint.setHost(u.getHost());
        endpoint.setPort(u.getPort());
        if (u.getUserInfo() != null) {
            endpoint.setUser(u.getUserInfo());
        }
        String remainingPath = u.getPath();
        if (remainingPath != null) {
            if (remainingPath.startsWith("/")) {
                remainingPath = remainingPath.substring(1);
            }

            if (remainingPath.length() > 0) {
                endpoint.setParticipant(remainingPath);
            }
        }
        return endpoint;


org.gjt.sp.jedit.bsh.LHS

class LHS implements ParserConstants, java.io.Serializable
{
	NameSpace nameSpace;
	/** The assignment should be to a local variable */
	boolean localVar;

	/**
		Identifiers for the various types of LHS.
	*/
	static final int
		VARIABLE = 0,
		FIELD = 1,
		PROPERTY = 2,
		INDEX = 3,
		METHOD_EVAL = 4;

	int type;

	String varName;
	String propName;
	Field field;
	Object object;
	int index;

/**
		Variable LHS constructor.
*/
	LHS( NameSpace nameSpace, String varName )
	{
throw new Error("namespace lhs");
/*
		type = VARIABLE;
		this.varName = varName;
		this.nameSpace = nameSpace;
*/
	}

	/**
		@param localVar if true the variable is set directly in the This
		reference's local scope.  If false recursion to look for the variable
		definition in parent's scope is allowed. (e.g. the default case for
		undefined vars going to global).
	*/
	LHS( NameSpace nameSpace, String varName, boolean localVar )
	{
		type = VARIABLE;
		this.localVar = localVar;
		this.varName = varName;
		this.nameSpace = nameSpace;
	}

	/**
		Static field LHS Constructor.
		This simply calls Object field constructor with null object.
	*/
	LHS( Field field )
	{
		type = FIELD;
		this.object = null;
		this.field = field;
	}

	/**
		Object field LHS Constructor.
	*/
	LHS( Object object, Field field )
	{
		if ( object == null)
			throw new NullPointerException("constructed empty LHS");

		type = FIELD;
		this.object = object;
		this.field = field;
	}

	/**
		Object property LHS Constructor.
	*/
	LHS( Object object, String propName )
	{
		if(object == null)
			throw new NullPointerException("constructed empty LHS");

		type = PROPERTY;
		this.object = object;
		this.propName = propName;
	}

	/**
		Array index LHS Constructor.
	*/
	LHS( Object array, int index )
	{
		if(array == null)
			throw new NullPointerException("constructed empty LHS");

		type = INDEX;
		this.object = array;
		this.index = index;
	}

	public Object getValue() throws UtilEvalError
	{
		if ( type == VARIABLE )
			return nameSpace.getVariable( varName );

		if (type == FIELD)
			try {
				Object o = field.get( object );
				return Primitive.wrap( o, field.getType() );
			} catch(IllegalAccessException e2) {
				throw new UtilEvalError("Can't read field: " + field);
			}

		if ( type == PROPERTY )
			try {
				return Reflect.getObjectProperty(object, propName);
			}
			catch(ReflectError e) {
				Interpreter.debug(e.getMessage());
				throw new UtilEvalError("No such property: " + propName);
			}

		if ( type == INDEX )
			try {
				return Reflect.getIndex(object, index);
			}
			catch(Exception e) {
				throw new UtilEvalError("Array access: " + e);
			}

		throw new InterpreterError("LHS type");
	}

	/**
		Assign a value to the LHS.
	*/
	public Object assign( Object val, boolean strictJava )
		throws UtilEvalError
	{
		if ( type == VARIABLE )
		{
			// Set the variable in namespace according to localVar flag
			if ( localVar )
				nameSpace.setLocalVariable( varName, val, strictJava );
			else
				nameSpace.setVariable( varName, val, strictJava );
		} else
		if ( type == FIELD )
		{
			try {
				Object fieldVal = val instanceof Primitive ?
					((Primitive)val).getValue() : val;

				// This should probably be in Reflect.java
				ReflectManager.RMSetAccessible( field );
				field.set( object, fieldVal );
				return val;
			}
			catch( NullPointerException e) {
    			throw new UtilEvalError(
					"LHS ("+field.getName()+") not a static field.");
			}
   			catch( IllegalAccessException e2) {
				throw new UtilEvalError(
					"LHS ("+field.getName()+") can't access field: "+e2);
			}
			catch( IllegalArgumentException e3)
			{
				String type = val instanceof Primitive ?
					((Primitive)val).getType().getName()
					: val.getClass().getName();
				throw new UtilEvalError(
					"Argument type mismatch. " + (val == null ? "null" : type )
					+ " not assignable to field "+field.getName());
			}
		}
		else
		if ( type == PROPERTY )
		{
			/*
			if ( object instanceof Hashtable )
				((Hashtable)object).put(propName, val);
			*/
			CollectionManager cm = CollectionManager.getCollectionManager();
			if ( cm.isMap( object ) )
				cm.putInMap( object/*map*/, propName, val );
			else
				try {
					Reflect.setObjectProperty(object, propName, val);
				}
				catch(ReflectError e) {
					Interpreter.debug("Assignment: " + e.getMessage());
					throw new UtilEvalError("No such property: " + propName);
				}
		} else
		if ( type == INDEX )
			try {
				Reflect.setIndex(object, index, val);
			} catch ( UtilTargetError e1 ) { // pass along target error
				throw e1;
			} catch ( Exception e ) {
				throw new UtilEvalError("Assignment: " + e.getMessage());
			}
		else
			throw new InterpreterError("unknown lhs");

		return val;
	}

	public String toString() {
		return "LHS: "
			+((field!=null)? "field = "+field.toString():"")
			+(varName!=null ? " varName = "+varName: "")
			+(nameSpace!=null ? " nameSpace = "+nameSpace.toString(): "");

FUNC_DECL PARAM PARAM PARAM ASSIGN ASSIGN ASSIGN ASSIGN

FUNC_DECL PARAM ASSIGN ASSIGN ASSIGN LITERAL_ANCHOR


public class CurrentBufferSet implements SearchFileSet
{
	//{{{ getFirstFile() method
	public String getFirstFile(View view)
	{
		return view.getBuffer().getPath();
	} //}}}

	//{{{ getNextFile() method
	public String getNextFile(View view, String file)
	{
		if(file == null)
			return view.getBuffer().getPath();
		else
			return null;
	} //}}}

	//{{{ getFiles() method
	public String[] getFiles(View view)
	{
		return new String[] { view.getBuffer().getPath() };
	} //}}}

	//{{{ getFileCount() method
	public int getFileCount()
	{
		return 1;
	} //}}}

	//{{{ getCode() method
	public String getCode()
	{
		return "new CurrentBufferSet()";

	public int getFileCount()
	{
		return 1;


public class PropertyIDMap extends HashMap
{

    /* The following definitions are for the Summary Information. */
    public static final int PID_TITLE = 2;
    public static final int PID_SUBJECT = 3;
    public static final int PID_AUTHOR = 4;
    public static final int PID_KEYWORDS = 5;
    public static final int PID_COMMENTS = 6;
    public static final int PID_TEMPLATE = 7;
    public static final int PID_LASTAUTHOR = 8;
    public static final int PID_REVNUMBER = 9;
    public static final int PID_EDITTIME = 10;
    public static final int PID_LASTPRINTED = 11;
    public static final int PID_CREATE_DTM = 12;
    public static final int PID_LASTSAVE_DTM = 13;
    public static final int PID_PAGECOUNT = 14;
    public static final int PID_WORDCOUNT = 15;
    public static final int PID_CHARCOUNT = 16;
    public static final int PID_THUMBNAIL = 17;
    public static final int PID_APPNAME = 18;
    public static final int PID_SECURITY = 19;

    /* The following definitions are for the Document Summary Information. */
    public static final int PID_CATEGORY = 2;
    public static final int PID_PRESFORMAT = 3;
    public static final int PID_BYTECOUNT = 4;
    public static final int PID_LINECOUNT = 5;
    public static final int PID_PARCOUNT = 6;
    public static final int PID_SLIDECOUNT = 7;
    public static final int PID_NOTECOUNT = 8;
    public static final int PID_HIDDENCOUNT = 9;
    public static final int PID_MMCLIPCOUNT = 10;
    public static final int PID_SCALE = 11;
    public static final int PID_HEADINGPAIR = 12;
    public static final int PID_DOCPARTS = 13;
    public static final int PID_MANAGER = 14;
    public static final int PID_COMPANY = 15;
    public static final int PID_LINKSDIRTY = 16;

    private static PropertyIDMap summaryInformationProperties;
    private static PropertyIDMap documentSummaryInformationProperties;

    public PropertyIDMap(int initialCapacity, float loadFactor)
    {
	super(initialCapacity, loadFactor);
    }

    /**
     *
Puts a ID string for an ID into the {@link
     * PropertyIDMap}.

     *
     * @param id The ID.
     *
     * @param idString The ID string.
     */
    public Object put(int id, String idString)
    {
	return put(new Integer(id), idString);
    }

    /**
     *
Gets the ID string for an ID from the {@link
     * PropertyIDMap}.

     *
     * @param id The ID.
     */
    public Object get(int id)
    {
	return get(new Integer(id));
    }

    /**
     *
Returns the Summary Information properties singleton.

     */
    public static PropertyIDMap getSummaryInformationProperties()
    {
	if (summaryInformationProperties == null)
	{
	    PropertyIDMap m = new PropertyIDMap(17, (float) 1.0);
	    m.put(PID_TITLE, "PID_TITLE");
	    m.put(PID_SUBJECT, "PID_SUBJECT");
	    m.put(PID_AUTHOR, "PID_AUTHOR");
	    m.put(PID_KEYWORDS, "PID_KEYWORDS");
	    m.put(PID_COMMENTS, "PID_COMMENTS");
	    m.put(PID_TEMPLATE, "PID_TEMPLATE");
	    m.put(PID_LASTAUTHOR, "PID_LASTAUTHOR");
	    m.put(PID_REVNUMBER, "PID_REVNUMBER");
	    m.put(PID_EDITTIME, "PID_EDITTIME");
	    m.put(PID_LASTPRINTED, "PID_LASTPRINTED");
	    m.put(PID_CREATE_DTM, "PID_CREATE_DTM");
	    m.put(PID_LASTSAVE_DTM, "PID_LASTSAVE_DTM");
	    m.put(PID_PAGECOUNT, "PID_PAGECOUNT");
	    m.put(PID_WORDCOUNT, "PID_WORDCOUNT");
	    m.put(PID_CHARCOUNT, "PID_CHARCOUNT");
	    m.put(PID_THUMBNAIL, "PID_THUMBNAIL");
	    m.put(PID_APPNAME, "PID_APPNAME");
	    m.put(PID_SECURITY, "PID_SECURITY");
	    summaryInformationProperties = m;
	}
	return summaryInformationProperties;
    }

    /**
     *
Returns the Summary Information properties singleton.

     */
    public static PropertyIDMap getDocumentSummaryInformationProperties()
    {
	if (documentSummaryInformationProperties == null)
	{
	    PropertyIDMap m = new PropertyIDMap(17, (float) 1.0);
	    m.put(PID_CATEGORY, "PID_CATEGORY");
	    m.put(PID_PRESFORMAT, "PID_PRESFORMAT");
	    m.put(PID_BYTECOUNT, "PID_BYTECOUNT");
	    m.put(PID_LINECOUNT, "PID_LINECOUNT");
	    m.put(PID_PARCOUNT, "PID_PARCOUNT");
	    m.put(PID_SLIDECOUNT, "PID_SLIDECOUNT");
	    m.put(PID_NOTECOUNT, "PID_NOTECOUNT");
	    m.put(PID_HIDDENCOUNT, "PID_HIDDENCOUNT");
	    m.put(PID_MMCLIPCOUNT, "PID_MMCLIPCOUNT");
	    m.put(PID_SCALE, "PID_SCALE");
	    m.put(PID_HEADINGPAIR, "PID_HEADINGPAIR");
	    m.put(PID_DOCPARTS, "PID_DOCPARTS");
	    m.put(PID_MANAGER, "PID_MANAGER");
	    m.put(PID_COMPANY, "PID_COMPANY");
	    m.put(PID_LINKSDIRTY, "PID_LINKSDIRTY");
	    documentSummaryInformationProperties = m;
	}
	return documentSummaryInformationProperties;

    }

    public static void main(String args[])
    {
	PropertyIDMap s1 = getSummaryInformationProperties();
	PropertyIDMap s2 = getDocumentSummaryInformationProperties();
	System.out.println("s1: " + s1);
	System.out.println("s2: " + s2);


public class PlotGrowthRecord
    extends Record
{
    public final static short      sid                             = 0x1064;
    private  int        field_1_horizontalScale;
    private  int        field_2_verticalScale;

    public PlotGrowthRecord()
    {

    }

    /**
     * Constructs a PlotGrowth record and sets its fields appropriately.
     *
     * @param id    id must be 0x1064 or an exception
     *              will be throw upon validation
     * @param size  size the size of the data area of the record
     * @param data  data of the record (should not contain sid/len)
     */

    public PlotGrowthRecord(short id, short size, byte [] data)
    {
        super(id, size, data);

    }

    /**
     * Constructs a PlotGrowth record and sets its fields appropriately.
     *
     * @param id    id must be 0x1064 or an exception
     *              will be throw upon validation
     * @param size  size the size of the data area of the record
     * @param data  data of the record (should not contain sid/len)
     * @param offset of the record's data
     */

    public PlotGrowthRecord(short id, short size, byte [] data, int offset)
    {
        super(id, size, data, offset);

    }

    /**
     * Checks the sid matches the expected side for this record
     *
     * @param id   the expected sid.
     */
    protected void validateSid(short id)
    {
        if (id != sid)
        {
            throw new RecordFormatException("Not a PlotGrowth record");
        }
    }

    protected void fillFields(byte [] data, short size, int offset)
    {

        int pos = 0;
        field_1_horizontalScale        = LittleEndian.getInt(data, pos + 0x0 + offset);
        field_2_verticalScale          = LittleEndian.getInt(data, pos + 0x4 + offset);

    }

    public String toString()
    {
        StringBuffer buffer = new StringBuffer();

        buffer.append("[PLOTGROWTH]\n");
        buffer.append("    .horizontalScale      = ")
            .append("0x").append(HexDump.toHex(  getHorizontalScale ()))
            .append(" (").append( getHorizontalScale() ).append(" )");
        buffer.append(System.getProperty("line.separator"));
        buffer.append("    .verticalScale        = ")
            .append("0x").append(HexDump.toHex(  getVerticalScale ()))
            .append(" (").append( getVerticalScale() ).append(" )");
        buffer.append(System.getProperty("line.separator"));

        buffer.append("[/PLOTGROWTH]\n");
        return buffer.toString();
    }

    public int serialize(int offset, byte[] data)
    {
        int pos = 0;

        LittleEndian.putShort(data, 0 + offset, sid);
        LittleEndian.putShort(data, 2 + offset, (short)(getRecordSize() - 4));

        LittleEndian.putInt(data, 4 + offset + pos, field_1_horizontalScale);
        LittleEndian.putInt(data, 8 + offset + pos, field_2_verticalScale);

        return getRecordSize();
    }

    /**
     * Size of record (exluding 4 byte header)
     */
    public int getRecordSize()
    {
        return 4  + 4 + 4;
    }

    public short getSid()
    {
        return this.sid;
    }

    public Object clone() {
        PlotGrowthRecord rec = new PlotGrowthRecord();

        rec.field_1_horizontalScale = field_1_horizontalScale;
        rec.field_2_verticalScale = field_2_verticalScale;
        return rec;
    }

    /**
     * Get the horizontalScale field for the PlotGrowth record.
     */
    public int getHorizontalScale()
    {
        return field_1_horizontalScale;
    }

    /**
     * Set the horizontalScale field for the PlotGrowth record.
     */
    public void setHorizontalScale(int field_1_horizontalScale)
    {
        this.field_1_horizontalScale = field_1_horizontalScale;
    }

    /**
     * Get the verticalScale field for the PlotGrowth record.
     */
    public int getVerticalScale()
    {
        return field_2_verticalScale;
    }

    /**
     * Set the verticalScale field for the PlotGrowth record.
     */
    public void setVerticalScale(int field_2_verticalScale)
    {
        this.field_2_verticalScale = field_2_verticalScale;

FUNC_DECL RETURN VAR_DECL ASSIGN ASSIGN CALL