| 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 */  | 
 | 
 | 
 | 
/*  | 
 | 
 * This source code is provided to illustrate the usage of a given feature  | 
 | 
 * or technique and has been deliberately simplified. Additional steps  | 
 | 
 * required for a production-quality application, such as security checks,  | 
 | 
 * input validation and proper error handling, might not be present in  | 
 | 
 * this sample code.  | 
 | 
 */  | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
package com.sun.tools.example.debug.expr;  | 
 | 
 | 
 | 
import com.sun.jdi.*;  | 
 | 
 | 
 | 
import java.util.Stack;  | 
 | 
import java.util.List;  | 
 | 
import java.util.ArrayList;  | 
 | 
 | 
 | 
public class ExpressionParser implements ExpressionParserConstants { | 
 | 
 | 
 | 
   Stack<LValue> stack = new Stack<LValue>();  | 
 | 
  VirtualMachine vm = null;  | 
 | 
  GetFrame frameGetter = null;  | 
 | 
  private static GetFrame lastFrameGetter;  | 
 | 
  private static LValue lastLValue;  | 
 | 
 | 
 | 
  LValue peek() { | 
 | 
      return stack.peek();  | 
 | 
  }  | 
 | 
 | 
 | 
  LValue pop() { | 
 | 
      return stack.pop();  | 
 | 
  }  | 
 | 
 | 
 | 
  void push(LValue lval) { | 
 | 
    stack.push(lval);  | 
 | 
  }  | 
 | 
 | 
 | 
  public static Value getMassagedValue() throws ParseException { | 
 | 
       return lastLValue.getMassagedValue(lastFrameGetter);  | 
 | 
  }  | 
 | 
 | 
 | 
  public interface GetFrame { | 
 | 
        StackFrame get() throws IncompatibleThreadStateException;  | 
 | 
  }  | 
 | 
 | 
 | 
  public static Value evaluate(String expr, VirtualMachine vm,  | 
 | 
         GetFrame frameGetter) throws ParseException, InvocationException,  | 
 | 
         InvalidTypeException, ClassNotLoadedException,  | 
 | 
                                            IncompatibleThreadStateException { | 
 | 
          | 
 | 
        java.io.InputStream in = new java.io.StringBufferInputStream(expr);  | 
 | 
        ExpressionParser parser = new ExpressionParser(in);  | 
 | 
        parser.vm = vm;  | 
 | 
        parser.frameGetter = frameGetter;  | 
 | 
        parser.Expression();  | 
 | 
        lastFrameGetter = frameGetter;  | 
 | 
        lastLValue = parser.pop();  | 
 | 
        return lastLValue.getValue();  | 
 | 
  }  | 
 | 
 | 
 | 
  public static void main(String args[]) { | 
 | 
    ExpressionParser parser;  | 
 | 
    System.out.print("Java Expression Parser:  "); | 
 | 
    if (args.length == 0) { | 
 | 
      System.out.println("Reading from standard input . . ."); | 
 | 
      parser = new ExpressionParser(System.in);  | 
 | 
    } else if (args.length == 1) { | 
 | 
      System.out.println("Reading from file " + args[0] + " . . ."); | 
 | 
      try { | 
 | 
        parser = new ExpressionParser(new java.io.FileInputStream(args[0]));  | 
 | 
      } catch (java.io.FileNotFoundException e) { | 
 | 
            System.out.println("Java Parser Version 1.0.2:  File " + args[0] | 
 | 
                  + " not found.");  | 
 | 
        return;  | 
 | 
      }  | 
 | 
    } else { | 
 | 
      System.out.println("Usage is one of:"); | 
 | 
      System.out.println("         java ExpressionParser < inputfile"); | 
 | 
      System.out.println("OR"); | 
 | 
      System.out.println("         java ExpressionParser inputfile"); | 
 | 
      return;  | 
 | 
    }  | 
 | 
    try { | 
 | 
        parser.Expression();  | 
 | 
        System.out.print("Java Expression Parser:  "); | 
 | 
        System.out.println("Java program parsed successfully."); | 
 | 
    } catch (ParseException e) { | 
 | 
        System.out.print("Java Expression Parser:  "); | 
 | 
        System.out.println("Encountered errors during parse."); | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
/*****************************************  | 
 | 
 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *  | 
 | 
 *****************************************/  | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 */  | 
 | 
  final public void Type() throws ParseException { | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case BOOLEAN:  | 
 | 
    case BYTE:  | 
 | 
    case CHAR:  | 
 | 
    case DOUBLE:  | 
 | 
    case FLOAT:  | 
 | 
    case INT:  | 
 | 
    case LONG:  | 
 | 
    case SHORT:  | 
 | 
      PrimitiveType();  | 
 | 
      break;  | 
 | 
    case IDENTIFIER:  | 
 | 
      Name();  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[0] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
      label_1: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case LBRACKET:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[1] = jj_gen;  | 
 | 
        break label_1;  | 
 | 
      }  | 
 | 
      jj_consume_token(LBRACKET);  | 
 | 
      jj_consume_token(RBRACKET);  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void PrimitiveType() throws ParseException { | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case BOOLEAN:  | 
 | 
      jj_consume_token(BOOLEAN);  | 
 | 
      break;  | 
 | 
    case CHAR:  | 
 | 
      jj_consume_token(CHAR);  | 
 | 
      break;  | 
 | 
    case BYTE:  | 
 | 
      jj_consume_token(BYTE);  | 
 | 
      break;  | 
 | 
    case SHORT:  | 
 | 
      jj_consume_token(SHORT);  | 
 | 
      break;  | 
 | 
    case INT:  | 
 | 
      jj_consume_token(INT);  | 
 | 
      break;  | 
 | 
    case LONG:  | 
 | 
      jj_consume_token(LONG);  | 
 | 
      break;  | 
 | 
    case FLOAT:  | 
 | 
      jj_consume_token(FLOAT);  | 
 | 
      break;  | 
 | 
    case DOUBLE:  | 
 | 
      jj_consume_token(DOUBLE);  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[2] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public String Name() throws ParseException { | 
 | 
 StringBuffer sb = new StringBuffer();  | 
 | 
    jj_consume_token(IDENTIFIER);  | 
 | 
                 sb.append(token);  | 
 | 
      label_2: while (true) { | 
 | 
      if (jj_2_1(2)) { | 
 | 
        ;  | 
 | 
      } else { | 
 | 
        break label_2;  | 
 | 
      }  | 
 | 
      jj_consume_token(DOT);  | 
 | 
      jj_consume_token(IDENTIFIER);  | 
 | 
         sb.append('.'); | 
 | 
         sb.append(token);  | 
 | 
      }  | 
 | 
      if (true) { | 
 | 
         return sb.toString();  | 
 | 
      }  | 
 | 
    throw new Error("Missing return statement in function"); | 
 | 
  }  | 
 | 
 | 
 | 
  final public void NameList() throws ParseException { | 
 | 
    Name();  | 
 | 
      label_3: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case COMMA:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[3] = jj_gen;  | 
 | 
        break label_3;  | 
 | 
      }  | 
 | 
      jj_consume_token(COMMA);  | 
 | 
      Name();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 */  | 
 | 
  final public void Expression() throws ParseException { | 
 | 
    if (jj_2_2(2147483647)) { | 
 | 
      Assignment();  | 
 | 
    } else { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case FALSE:  | 
 | 
      case NEW:  | 
 | 
      case NULL:  | 
 | 
      case SUPER:  | 
 | 
      case THIS:  | 
 | 
      case TRUE:  | 
 | 
      case INTEGER_LITERAL:  | 
 | 
      case FLOATING_POINT_LITERAL:  | 
 | 
      case CHARACTER_LITERAL:  | 
 | 
      case STRING_LITERAL:  | 
 | 
      case IDENTIFIER:  | 
 | 
      case LPAREN:  | 
 | 
      case BANG:  | 
 | 
      case TILDE:  | 
 | 
      case INCR:  | 
 | 
      case DECR:  | 
 | 
      case PLUS:  | 
 | 
      case MINUS:  | 
 | 
        ConditionalExpression();  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[4] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void Assignment() throws ParseException { | 
 | 
    PrimaryExpression();  | 
 | 
    AssignmentOperator();  | 
 | 
    Expression();  | 
 | 
      LValue exprVal = pop();  | 
 | 
      pop().setValue(exprVal);  | 
 | 
      push(exprVal);  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void AssignmentOperator() throws ParseException { | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case ASSIGN:  | 
 | 
      jj_consume_token(ASSIGN);  | 
 | 
      break;  | 
 | 
    case STARASSIGN:  | 
 | 
      jj_consume_token(STARASSIGN);  | 
 | 
      break;  | 
 | 
    case SLASHASSIGN:  | 
 | 
      jj_consume_token(SLASHASSIGN);  | 
 | 
      break;  | 
 | 
    case REMASSIGN:  | 
 | 
      jj_consume_token(REMASSIGN);  | 
 | 
      break;  | 
 | 
    case PLUSASSIGN:  | 
 | 
      jj_consume_token(PLUSASSIGN);  | 
 | 
      break;  | 
 | 
    case MINUSASSIGN:  | 
 | 
      jj_consume_token(MINUSASSIGN);  | 
 | 
      break;  | 
 | 
    case LSHIFTASSIGN:  | 
 | 
      jj_consume_token(LSHIFTASSIGN);  | 
 | 
      break;  | 
 | 
    case RSIGNEDSHIFTASSIGN:  | 
 | 
      jj_consume_token(RSIGNEDSHIFTASSIGN);  | 
 | 
      break;  | 
 | 
    case RUNSIGNEDSHIFTASSIGN:  | 
 | 
      jj_consume_token(RUNSIGNEDSHIFTASSIGN);  | 
 | 
      break;  | 
 | 
    case ANDASSIGN:  | 
 | 
      jj_consume_token(ANDASSIGN);  | 
 | 
      break;  | 
 | 
    case XORASSIGN:  | 
 | 
      jj_consume_token(XORASSIGN);  | 
 | 
      break;  | 
 | 
    case ORASSIGN:  | 
 | 
      jj_consume_token(ORASSIGN);  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[5] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void ConditionalExpression() throws ParseException { | 
 | 
    ConditionalOrExpression();  | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case HOOK:  | 
 | 
      jj_consume_token(HOOK);  | 
 | 
      Expression();  | 
 | 
      jj_consume_token(COLON);  | 
 | 
      ConditionalExpression();  | 
 | 
         LValue falseBranch = pop();  | 
 | 
         LValue trueBranch = pop();  | 
 | 
                  Value cond = pop().interiorGetValue();  | 
 | 
                  if (cond instanceof BooleanValue) { | 
 | 
            push(((BooleanValue) cond).booleanValue() ? trueBranch  | 
 | 
                  : falseBranch);  | 
 | 
                  } else { | 
 | 
            { | 
 | 
               if (true) { | 
 | 
                  throw new ParseException("Condition must be boolean"); | 
 | 
               }  | 
 | 
            }  | 
 | 
                  }  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[6] = jj_gen;  | 
 | 
      ;  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void ConditionalOrExpression() throws ParseException { | 
 | 
    ConditionalAndExpression();  | 
 | 
      label_4: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case SC_OR:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[7] = jj_gen;  | 
 | 
        break label_4;  | 
 | 
      }  | 
 | 
      jj_consume_token(SC_OR);  | 
 | 
      ConditionalAndExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void ConditionalAndExpression() throws ParseException { | 
 | 
    InclusiveOrExpression();  | 
 | 
      label_5: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case SC_AND:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[8] = jj_gen;  | 
 | 
        break label_5;  | 
 | 
      }  | 
 | 
      jj_consume_token(SC_AND);  | 
 | 
      InclusiveOrExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void InclusiveOrExpression() throws ParseException { | 
 | 
    ExclusiveOrExpression();  | 
 | 
      label_6: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case BIT_OR:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[9] = jj_gen;  | 
 | 
        break label_6;  | 
 | 
      }  | 
 | 
      jj_consume_token(BIT_OR);  | 
 | 
      ExclusiveOrExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void ExclusiveOrExpression() throws ParseException { | 
 | 
    AndExpression();  | 
 | 
      label_7: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case XOR:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[10] = jj_gen;  | 
 | 
        break label_7;  | 
 | 
      }  | 
 | 
      jj_consume_token(XOR);  | 
 | 
      AndExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void AndExpression() throws ParseException { | 
 | 
    EqualityExpression();  | 
 | 
      label_8: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case BIT_AND:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[11] = jj_gen;  | 
 | 
        break label_8;  | 
 | 
      }  | 
 | 
      jj_consume_token(BIT_AND);  | 
 | 
      EqualityExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void EqualityExpression() throws ParseException { | 
 | 
 Token tok;  | 
 | 
    InstanceOfExpression();  | 
 | 
      label_9: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case EQ:  | 
 | 
      case NE:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[12] = jj_gen;  | 
 | 
        break label_9;  | 
 | 
      }  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case EQ:  | 
 | 
        tok = jj_consume_token(EQ);  | 
 | 
        break;  | 
 | 
      case NE:  | 
 | 
        tok = jj_consume_token(NE);  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[13] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      InstanceOfExpression();  | 
 | 
                  LValue left = pop();  | 
 | 
                  push( LValue.booleanOperation(vm, tok, pop(), left) );  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void InstanceOfExpression() throws ParseException { | 
 | 
    RelationalExpression();  | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case INSTANCEOF:  | 
 | 
      jj_consume_token(INSTANCEOF);  | 
 | 
      Type();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[14] = jj_gen;  | 
 | 
      ;  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void RelationalExpression() throws ParseException { | 
 | 
 Token tok;  | 
 | 
    ShiftExpression();  | 
 | 
      label_10: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case GT:  | 
 | 
      case LT:  | 
 | 
      case LE:  | 
 | 
      case GE:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[15] = jj_gen;  | 
 | 
        break label_10;  | 
 | 
      }  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case LT:  | 
 | 
        tok = jj_consume_token(LT);  | 
 | 
        break;  | 
 | 
      case GT:  | 
 | 
        tok = jj_consume_token(GT);  | 
 | 
        break;  | 
 | 
      case LE:  | 
 | 
        tok = jj_consume_token(LE);  | 
 | 
        break;  | 
 | 
      case GE:  | 
 | 
        tok = jj_consume_token(GE);  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[16] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      ShiftExpression();  | 
 | 
                  LValue left = pop();  | 
 | 
                  push( LValue.booleanOperation(vm, tok, pop(), left) );  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void ShiftExpression() throws ParseException { | 
 | 
    AdditiveExpression();  | 
 | 
      label_11: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case LSHIFT:  | 
 | 
      case RSIGNEDSHIFT:  | 
 | 
      case RUNSIGNEDSHIFT:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[17] = jj_gen;  | 
 | 
        break label_11;  | 
 | 
      }  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case LSHIFT:  | 
 | 
        jj_consume_token(LSHIFT);  | 
 | 
        break;  | 
 | 
      case RSIGNEDSHIFT:  | 
 | 
        jj_consume_token(RSIGNEDSHIFT);  | 
 | 
        break;  | 
 | 
      case RUNSIGNEDSHIFT:  | 
 | 
        jj_consume_token(RUNSIGNEDSHIFT);  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[18] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      AdditiveExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void AdditiveExpression() throws ParseException { | 
 | 
 Token tok;  | 
 | 
    MultiplicativeExpression();  | 
 | 
      label_12: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case PLUS:  | 
 | 
      case MINUS:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[19] = jj_gen;  | 
 | 
        break label_12;  | 
 | 
      }  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case PLUS:  | 
 | 
        tok = jj_consume_token(PLUS);  | 
 | 
        break;  | 
 | 
      case MINUS:  | 
 | 
        tok = jj_consume_token(MINUS);  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[20] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      MultiplicativeExpression();  | 
 | 
                  LValue left = pop();  | 
 | 
                  push( LValue.operation(vm, tok, pop(), left, frameGetter) );  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void MultiplicativeExpression() throws ParseException { | 
 | 
 Token tok;  | 
 | 
    UnaryExpression();  | 
 | 
      label_13: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case STAR:  | 
 | 
      case SLASH:  | 
 | 
      case REM:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[21] = jj_gen;  | 
 | 
        break label_13;  | 
 | 
      }  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case STAR:  | 
 | 
        tok = jj_consume_token(STAR);  | 
 | 
        break;  | 
 | 
      case SLASH:  | 
 | 
        tok = jj_consume_token(SLASH);  | 
 | 
        break;  | 
 | 
      case REM:  | 
 | 
        tok = jj_consume_token(REM);  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[22] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      UnaryExpression();  | 
 | 
                  LValue left = pop();  | 
 | 
                  push( LValue.operation(vm, tok, pop(), left, frameGetter) );  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void UnaryExpression() throws ParseException { | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case PLUS:  | 
 | 
    case MINUS:  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case PLUS:  | 
 | 
        jj_consume_token(PLUS);  | 
 | 
        break;  | 
 | 
      case MINUS:  | 
 | 
        jj_consume_token(MINUS);  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[23] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      UnaryExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
      break;  | 
 | 
    case INCR:  | 
 | 
      PreIncrementExpression();  | 
 | 
      break;  | 
 | 
    case DECR:  | 
 | 
      PreDecrementExpression();  | 
 | 
      break;  | 
 | 
    case FALSE:  | 
 | 
    case NEW:  | 
 | 
    case NULL:  | 
 | 
    case SUPER:  | 
 | 
    case THIS:  | 
 | 
    case TRUE:  | 
 | 
    case INTEGER_LITERAL:  | 
 | 
    case FLOATING_POINT_LITERAL:  | 
 | 
    case CHARACTER_LITERAL:  | 
 | 
    case STRING_LITERAL:  | 
 | 
    case IDENTIFIER:  | 
 | 
    case LPAREN:  | 
 | 
    case BANG:  | 
 | 
    case TILDE:  | 
 | 
      UnaryExpressionNotPlusMinus();  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[24] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void PreIncrementExpression() throws ParseException { | 
 | 
    jj_consume_token(INCR);  | 
 | 
    PrimaryExpression();  | 
 | 
      { | 
 | 
         if (true) { | 
 | 
            throw new ParseException("operation not yet supported"); | 
 | 
         }  | 
 | 
      }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void PreDecrementExpression() throws ParseException { | 
 | 
    jj_consume_token(DECR);  | 
 | 
    PrimaryExpression();  | 
 | 
      { | 
 | 
         if (true) { | 
 | 
            throw new ParseException("operation not yet supported"); | 
 | 
         }  | 
 | 
      }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void UnaryExpressionNotPlusMinus() throws ParseException { | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case BANG:  | 
 | 
    case TILDE:  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case TILDE:  | 
 | 
        jj_consume_token(TILDE);  | 
 | 
        break;  | 
 | 
      case BANG:  | 
 | 
        jj_consume_token(BANG);  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[25] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      UnaryExpression();  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[26] = jj_gen;  | 
 | 
      if (jj_2_3(2147483647)) { | 
 | 
        CastExpression();  | 
 | 
      } else { | 
 | 
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
        case FALSE:  | 
 | 
        case NEW:  | 
 | 
        case NULL:  | 
 | 
        case SUPER:  | 
 | 
        case THIS:  | 
 | 
        case TRUE:  | 
 | 
        case INTEGER_LITERAL:  | 
 | 
        case FLOATING_POINT_LITERAL:  | 
 | 
        case CHARACTER_LITERAL:  | 
 | 
        case STRING_LITERAL:  | 
 | 
        case IDENTIFIER:  | 
 | 
        case LPAREN:  | 
 | 
          PostfixExpression();  | 
 | 
          break;  | 
 | 
        default:  | 
 | 
          jj_la1[27] = jj_gen;  | 
 | 
          jj_consume_token(-1);  | 
 | 
          throw new ParseException();  | 
 | 
        }  | 
 | 
      }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
   // This production is to determine lookahead only. The LOOKAHEAD  | 
 | 
   // specifications  | 
 | 
   // below are not used, but they are there just to indicate that we know  | 
 | 
   // about  | 
 | 
 | 
 | 
  final public void CastLookahead() throws ParseException { | 
 | 
    if (jj_2_4(2)) { | 
 | 
      jj_consume_token(LPAREN);  | 
 | 
      PrimitiveType();  | 
 | 
    } else if (jj_2_5(2147483647)) { | 
 | 
      jj_consume_token(LPAREN);  | 
 | 
      Name();  | 
 | 
      jj_consume_token(LBRACKET);  | 
 | 
      jj_consume_token(RBRACKET);  | 
 | 
    } else { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case LPAREN:  | 
 | 
        jj_consume_token(LPAREN);  | 
 | 
        Name();  | 
 | 
        jj_consume_token(RPAREN);  | 
 | 
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
        case TILDE:  | 
 | 
          jj_consume_token(TILDE);  | 
 | 
          break;  | 
 | 
        case BANG:  | 
 | 
          jj_consume_token(BANG);  | 
 | 
          break;  | 
 | 
        case LPAREN:  | 
 | 
          jj_consume_token(LPAREN);  | 
 | 
          break;  | 
 | 
        case IDENTIFIER:  | 
 | 
          jj_consume_token(IDENTIFIER);  | 
 | 
          break;  | 
 | 
        case THIS:  | 
 | 
          jj_consume_token(THIS);  | 
 | 
          break;  | 
 | 
        case SUPER:  | 
 | 
          jj_consume_token(SUPER);  | 
 | 
          break;  | 
 | 
        case NEW:  | 
 | 
          jj_consume_token(NEW);  | 
 | 
          break;  | 
 | 
        case FALSE:  | 
 | 
        case NULL:  | 
 | 
        case TRUE:  | 
 | 
        case INTEGER_LITERAL:  | 
 | 
        case FLOATING_POINT_LITERAL:  | 
 | 
        case CHARACTER_LITERAL:  | 
 | 
        case STRING_LITERAL:  | 
 | 
          Literal();  | 
 | 
          break;  | 
 | 
        default:  | 
 | 
          jj_la1[28] = jj_gen;  | 
 | 
          jj_consume_token(-1);  | 
 | 
          throw new ParseException();  | 
 | 
        }  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[29] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void PostfixExpression() throws ParseException { | 
 | 
    PrimaryExpression();  | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case INCR:  | 
 | 
    case DECR:  | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case INCR:  | 
 | 
        jj_consume_token(INCR);  | 
 | 
        break;  | 
 | 
      case DECR:  | 
 | 
        jj_consume_token(DECR);  | 
 | 
            { | 
 | 
               if (true) { | 
 | 
                  throw new ParseException("operation not yet supported"); | 
 | 
               }  | 
 | 
            }  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[30] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[31] = jj_gen;  | 
 | 
      ;  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void CastExpression() throws ParseException { | 
 | 
    if (jj_2_6(2)) { | 
 | 
      jj_consume_token(LPAREN);  | 
 | 
      PrimitiveType();  | 
 | 
         label_14: while (true) { | 
 | 
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
        case LBRACKET:  | 
 | 
          ;  | 
 | 
          break;  | 
 | 
        default:  | 
 | 
          jj_la1[32] = jj_gen;  | 
 | 
          break label_14;  | 
 | 
        }  | 
 | 
        jj_consume_token(LBRACKET);  | 
 | 
        jj_consume_token(RBRACKET);  | 
 | 
      }  | 
 | 
      jj_consume_token(RPAREN);  | 
 | 
      UnaryExpression();  | 
 | 
    } else { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case LPAREN:  | 
 | 
        jj_consume_token(LPAREN);  | 
 | 
        Name();  | 
 | 
            label_15: while (true) { | 
 | 
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
          case LBRACKET:  | 
 | 
            ;  | 
 | 
            break;  | 
 | 
          default:  | 
 | 
            jj_la1[33] = jj_gen;  | 
 | 
            break label_15;  | 
 | 
          }  | 
 | 
          jj_consume_token(LBRACKET);  | 
 | 
          jj_consume_token(RBRACKET);  | 
 | 
        }  | 
 | 
        jj_consume_token(RPAREN);  | 
 | 
        UnaryExpressionNotPlusMinus();  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[34] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void PrimaryExpression() throws ParseException { | 
 | 
    PrimaryPrefix();  | 
 | 
      label_16: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case LPAREN:  | 
 | 
      case LBRACKET:  | 
 | 
      case DOT:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[35] = jj_gen;  | 
 | 
        break label_16;  | 
 | 
      }  | 
 | 
      PrimarySuffix();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void PrimaryPrefix() throws ParseException { | 
 | 
 String name;  | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case FALSE:  | 
 | 
    case NULL:  | 
 | 
    case TRUE:  | 
 | 
    case INTEGER_LITERAL:  | 
 | 
    case FLOATING_POINT_LITERAL:  | 
 | 
    case CHARACTER_LITERAL:  | 
 | 
    case STRING_LITERAL:  | 
 | 
      Literal();  | 
 | 
      break;  | 
 | 
    case IDENTIFIER:  | 
 | 
      name = Name();  | 
 | 
                          push(LValue.makeName(vm, frameGetter, name));  | 
 | 
      break;  | 
 | 
    case THIS:  | 
 | 
      jj_consume_token(THIS);  | 
 | 
                          push(LValue.makeThisObject(vm, frameGetter, token));  | 
 | 
      break;  | 
 | 
    case SUPER:  | 
 | 
      jj_consume_token(SUPER);  | 
 | 
      jj_consume_token(DOT);  | 
 | 
      jj_consume_token(IDENTIFIER);  | 
 | 
         { | 
 | 
            if (true) { | 
 | 
               throw new ParseException("operation not yet supported"); | 
 | 
            }  | 
 | 
         }  | 
 | 
      break;  | 
 | 
    case LPAREN:  | 
 | 
      jj_consume_token(LPAREN);  | 
 | 
      Expression();  | 
 | 
      jj_consume_token(RPAREN);  | 
 | 
      break;  | 
 | 
    case NEW:  | 
 | 
      AllocationExpression();  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[36] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void PrimarySuffix() throws ParseException { | 
 | 
      List<Value> argList;  | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case LBRACKET:  | 
 | 
      jj_consume_token(LBRACKET);  | 
 | 
      Expression();  | 
 | 
      jj_consume_token(RBRACKET);  | 
 | 
                          LValue index = pop();  | 
 | 
                          push(pop().arrayElementLValue(index));  | 
 | 
      break;  | 
 | 
    case DOT:  | 
 | 
      jj_consume_token(DOT);  | 
 | 
      jj_consume_token(IDENTIFIER);  | 
 | 
                          push(pop().memberLValue(frameGetter, token.image));  | 
 | 
      break;  | 
 | 
    case LPAREN:  | 
 | 
      argList = Arguments();  | 
 | 
                          peek().invokeWith(argList);  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[37] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void Literal() throws ParseException { | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case INTEGER_LITERAL:  | 
 | 
      jj_consume_token(INTEGER_LITERAL);  | 
 | 
                          push(LValue.makeInteger(vm, token));  | 
 | 
      break;  | 
 | 
    case FLOATING_POINT_LITERAL:  | 
 | 
      jj_consume_token(FLOATING_POINT_LITERAL);  | 
 | 
                          push(LValue.makeFloat(vm, token));  | 
 | 
      break;  | 
 | 
    case CHARACTER_LITERAL:  | 
 | 
      jj_consume_token(CHARACTER_LITERAL);  | 
 | 
                          push(LValue.makeCharacter(vm, token));  | 
 | 
      break;  | 
 | 
    case STRING_LITERAL:  | 
 | 
      jj_consume_token(STRING_LITERAL);  | 
 | 
                          push(LValue.makeString(vm, token));  | 
 | 
      break;  | 
 | 
    case FALSE:  | 
 | 
    case TRUE:  | 
 | 
      BooleanLiteral();  | 
 | 
                          push(LValue.makeBoolean(vm, token));  | 
 | 
      break;  | 
 | 
    case NULL:  | 
 | 
      NullLiteral();  | 
 | 
                          push(LValue.makeNull(vm, token));  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[38] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void BooleanLiteral() throws ParseException { | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case TRUE:  | 
 | 
      jj_consume_token(TRUE);  | 
 | 
      break;  | 
 | 
    case FALSE:  | 
 | 
      jj_consume_token(FALSE);  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[39] = jj_gen;  | 
 | 
      jj_consume_token(-1);  | 
 | 
      throw new ParseException();  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void NullLiteral() throws ParseException { | 
 | 
    jj_consume_token(NULL);  | 
 | 
  }  | 
 | 
 | 
 | 
   final public List<Value> Arguments() throws ParseException { | 
 | 
      List<Value> argList = new ArrayList<Value>();  | 
 | 
    jj_consume_token(LPAREN);  | 
 | 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
    case FALSE:  | 
 | 
    case NEW:  | 
 | 
    case NULL:  | 
 | 
    case SUPER:  | 
 | 
    case THIS:  | 
 | 
    case TRUE:  | 
 | 
    case INTEGER_LITERAL:  | 
 | 
    case FLOATING_POINT_LITERAL:  | 
 | 
    case CHARACTER_LITERAL:  | 
 | 
    case STRING_LITERAL:  | 
 | 
    case IDENTIFIER:  | 
 | 
    case LPAREN:  | 
 | 
    case BANG:  | 
 | 
    case TILDE:  | 
 | 
    case INCR:  | 
 | 
    case DECR:  | 
 | 
    case PLUS:  | 
 | 
    case MINUS:  | 
 | 
      ArgumentList(argList);  | 
 | 
      break;  | 
 | 
    default:  | 
 | 
      jj_la1[40] = jj_gen;  | 
 | 
      ;  | 
 | 
    }  | 
 | 
    jj_consume_token(RPAREN);  | 
 | 
      { | 
 | 
         if (true) { | 
 | 
            return argList;  | 
 | 
         }  | 
 | 
      }  | 
 | 
    throw new Error("Missing return statement in function"); | 
 | 
  }  | 
 | 
 | 
 | 
   final public void ArgumentList(List<Value> argList) throws ParseException { | 
 | 
    Expression();  | 
 | 
                argList.add(pop().interiorGetValue());  | 
 | 
      label_17: while (true) { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case COMMA:  | 
 | 
        ;  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[41] = jj_gen;  | 
 | 
        break label_17;  | 
 | 
      }  | 
 | 
      jj_consume_token(COMMA);  | 
 | 
      Expression();  | 
 | 
                      argList.add(pop().interiorGetValue());  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void AllocationExpression() throws ParseException { | 
 | 
      List<Value> argList;  | 
 | 
      String className;  | 
 | 
    if (jj_2_7(2)) { | 
 | 
      jj_consume_token(NEW);  | 
 | 
      PrimitiveType();  | 
 | 
      ArrayDimensions();  | 
 | 
    } else { | 
 | 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
      case NEW:  | 
 | 
        jj_consume_token(NEW);  | 
 | 
        className = Name();  | 
 | 
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | 
 | 
        case LPAREN:  | 
 | 
          argList = Arguments();  | 
 | 
                          push(LValue.makeNewObject(vm, frameGetter, className, argList));  | 
 | 
          break;  | 
 | 
        case LBRACKET:  | 
 | 
          ArrayDimensions();  | 
 | 
               { | 
 | 
                  if (true) { | 
 | 
                     throw new ParseException("operation not yet supported"); | 
 | 
                  }  | 
 | 
               }  | 
 | 
          break;  | 
 | 
        default:  | 
 | 
          jj_la1[42] = jj_gen;  | 
 | 
          jj_consume_token(-1);  | 
 | 
          throw new ParseException();  | 
 | 
        }  | 
 | 
        break;  | 
 | 
      default:  | 
 | 
        jj_la1[43] = jj_gen;  | 
 | 
        jj_consume_token(-1);  | 
 | 
        throw new ParseException();  | 
 | 
      }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 | 
 */  | 
 | 
  final public void ArrayDimensions() throws ParseException { | 
 | 
      label_18: while (true) { | 
 | 
      jj_consume_token(LBRACKET);  | 
 | 
      Expression();  | 
 | 
      jj_consume_token(RBRACKET);  | 
 | 
      if (jj_2_8(2)) { | 
 | 
        ;  | 
 | 
      } else { | 
 | 
        break label_18;  | 
 | 
      }  | 
 | 
    }  | 
 | 
      label_19: while (true) { | 
 | 
      if (jj_2_9(2)) { | 
 | 
        ;  | 
 | 
      } else { | 
 | 
        break label_19;  | 
 | 
      }  | 
 | 
      jj_consume_token(LBRACKET);  | 
 | 
      jj_consume_token(RBRACKET);  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_1(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_1();  | 
 | 
    jj_save(0, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_2(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_2();  | 
 | 
    jj_save(1, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_3(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_3();  | 
 | 
    jj_save(2, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_4(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_4();  | 
 | 
    jj_save(3, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_5(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_5();  | 
 | 
    jj_save(4, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_6(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_6();  | 
 | 
    jj_save(5, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_7(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_7();  | 
 | 
    jj_save(6, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_8(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_8();  | 
 | 
    jj_save(7, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_2_9(int xla) { | 
 | 
      jj_la = xla;  | 
 | 
      jj_lastpos = jj_scanpos = token;  | 
 | 
    boolean retval = !jj_3_9();  | 
 | 
    jj_save(8, xla);  | 
 | 
    return retval;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_154() { | 
 | 
      if (jj_scan_token(INCR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_151() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_154()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_155()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_148() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3_6()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_150()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_6() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_23()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_152()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_115()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_25() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_50()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_51()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_50() { | 
 | 
      if (jj_3R_67()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_5() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_24()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_149() { | 
 | 
      if (jj_3R_20()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
      if (jj_3R_151()) { | 
 | 
         jj_scanpos = xsp;  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_41() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_24()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_59()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_60()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_61()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_62()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_63()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_64()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_65()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
                           if (jj_3R_66()) { | 
 | 
                              return true;  | 
 | 
                           }  | 
 | 
                           if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                              return false;  | 
 | 
                           }  | 
 | 
                        } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                           return false;  | 
 | 
                        }  | 
 | 
                     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                        return false;  | 
 | 
                     }  | 
 | 
                  } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                     return false;  | 
 | 
                  }  | 
 | 
               } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                  return false;  | 
 | 
               }  | 
 | 
            } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_40() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_24()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_123() { | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_1() { | 
 | 
      if (jj_scan_token(DOT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(IDENTIFIER)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_4() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_23()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_22() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3_4()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_40()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
            if (jj_3R_41()) { | 
 | 
               return true;  | 
 | 
            }  | 
 | 
            if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_3() { | 
 | 
      if (jj_3R_22()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_24() { | 
 | 
      if (jj_scan_token(IDENTIFIER)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3_1()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_147() { | 
 | 
      if (jj_scan_token(BANG)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_142() { | 
 | 
      if (jj_3R_149()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_122() { | 
 | 
      if (jj_3R_24()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_49() { | 
 | 
      if (jj_scan_token(DOUBLE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_141() { | 
 | 
      if (jj_3R_148()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_48() { | 
 | 
      if (jj_scan_token(FLOAT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_146() { | 
 | 
      if (jj_scan_token(TILDE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_47() { | 
 | 
      if (jj_scan_token(LONG)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_140() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_146()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_147()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_115()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_136() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_140()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_141()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
            if (jj_3R_142()) { | 
 | 
               return true;  | 
 | 
            }  | 
 | 
            if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_46() { | 
 | 
      if (jj_scan_token(INT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_145() { | 
 | 
      if (jj_scan_token(REM)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_45() { | 
 | 
      if (jj_scan_token(SHORT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_44() { | 
 | 
      if (jj_scan_token(BYTE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_135() { | 
 | 
      if (jj_scan_token(DECR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_20()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_43() { | 
 | 
      if (jj_scan_token(CHAR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_23() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_42()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_43()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_44()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_45()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_46()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_47()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_48()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
                           if (jj_3R_49()) { | 
 | 
                              return true;  | 
 | 
                           }  | 
 | 
                           if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                              return false;  | 
 | 
                           }  | 
 | 
                        } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                           return false;  | 
 | 
                        }  | 
 | 
                     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                        return false;  | 
 | 
                     }  | 
 | 
                  } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                     return false;  | 
 | 
                  }  | 
 | 
               } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                  return false;  | 
 | 
               }  | 
 | 
            } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_42() { | 
 | 
      if (jj_scan_token(BOOLEAN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_9() { | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_121() { | 
 | 
      if (jj_3R_23()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_144() { | 
 | 
      if (jj_scan_token(SLASH)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_134() { | 
 | 
      if (jj_scan_token(INCR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_20()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_114() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_121()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_122()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_123()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_120() { | 
 | 
      if (jj_scan_token(GE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_133() { | 
 | 
      if (jj_scan_token(MINUS)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_127() { | 
 | 
      if (jj_3R_136()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_126() { | 
 | 
      if (jj_3R_135()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_139() { | 
 | 
      if (jj_scan_token(MINUS)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_125() { | 
 | 
      if (jj_3R_134()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_132() { | 
 | 
      if (jj_scan_token(PLUS)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_143() { | 
 | 
      if (jj_scan_token(STAR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_124() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_132()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_133()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_115()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_115() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_124()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_125()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_126()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
               if (jj_3R_127()) { | 
 | 
                  return true;  | 
 | 
               }  | 
 | 
               if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                  return false;  | 
 | 
               }  | 
 | 
            } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_137() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_143()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_144()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
            if (jj_3R_145()) { | 
 | 
               return true;  | 
 | 
            }  | 
 | 
            if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_115()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_131() { | 
 | 
      if (jj_scan_token(RUNSIGNEDSHIFT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_119() { | 
 | 
      if (jj_scan_token(LE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_138() { | 
 | 
      if (jj_scan_token(PLUS)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_112() { | 
 | 
      if (jj_3R_115()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_137()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_88() { | 
 | 
      if (jj_3R_86()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_130() { | 
 | 
      if (jj_scan_token(RSIGNEDSHIFT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_128() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_138()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_139()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_112()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_87() { | 
 | 
      if (jj_3R_82()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_118() { | 
 | 
      if (jj_scan_token(GT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_129() { | 
 | 
      if (jj_scan_token(LSHIFT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_116() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_129()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_130()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
            if (jj_3R_131()) { | 
 | 
               return true;  | 
 | 
            }  | 
 | 
            if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_108()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_108() { | 
 | 
      if (jj_3R_112()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_128()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_8() { | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_25()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_86() { | 
 | 
    Token xsp;  | 
 | 
      if (jj_3_8()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3_8()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3_9()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_117() { | 
 | 
      if (jj_scan_token(LT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_106() { | 
 | 
      if (jj_3R_108()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_116()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_113() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_117()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_118()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_119()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
               if (jj_3R_120()) { | 
 | 
                  return true;  | 
 | 
               }  | 
 | 
               if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                  return false;  | 
 | 
               }  | 
 | 
            } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_106()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_111() { | 
 | 
      if (jj_scan_token(NE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_109() { | 
 | 
      if (jj_scan_token(INSTANCEOF)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_114()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_104() { | 
 | 
      if (jj_3R_106()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_113()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_81() { | 
 | 
      if (jj_scan_token(NEW)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_24()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_87()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_88()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_7() { | 
 | 
      if (jj_scan_token(NEW)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_23()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_86()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_70() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3_7()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_81()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_97() { | 
 | 
      if (jj_scan_token(COMMA)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_25()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_39() { | 
 | 
      if (jj_scan_token(ORASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_110() { | 
 | 
      if (jj_scan_token(EQ)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_102() { | 
 | 
      if (jj_3R_104()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
      if (jj_3R_109()) { | 
 | 
         jj_scanpos = xsp;  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_107() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_110()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_111()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_102()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_94() { | 
 | 
      if (jj_3R_25()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_97()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_89() { | 
 | 
      if (jj_3R_94()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_38() { | 
 | 
      if (jj_scan_token(XORASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_82() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
      if (jj_3R_89()) { | 
 | 
         jj_scanpos = xsp;  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_105() { | 
 | 
      if (jj_scan_token(BIT_AND)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_100()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_100() { | 
 | 
      if (jj_3R_102()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_107()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_37() { | 
 | 
      if (jj_scan_token(ANDASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_85() { | 
 | 
      if (jj_scan_token(NULL)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_103() { | 
 | 
      if (jj_scan_token(XOR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_98()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_98() { | 
 | 
      if (jj_3R_100()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_105()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_92() { | 
 | 
      if (jj_scan_token(FALSE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_36() { | 
 | 
      if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_91() { | 
 | 
      if (jj_scan_token(TRUE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_84() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_91()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
         if (jj_3R_92()) { | 
 | 
            return true;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_101() { | 
 | 
      if (jj_scan_token(BIT_OR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_95()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_95() { | 
 | 
      if (jj_3R_98()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_103()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_35() { | 
 | 
      if (jj_scan_token(RSIGNEDSHIFTASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_80() { | 
 | 
      if (jj_3R_85()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_66() { | 
 | 
      if (jj_3R_69()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_79() { | 
 | 
      if (jj_3R_84()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_78() { | 
 | 
      if (jj_scan_token(STRING_LITERAL)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_99() { | 
 | 
      if (jj_scan_token(SC_AND)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_90()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_90() { | 
 | 
      if (jj_3R_95()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_101()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_34() { | 
 | 
      if (jj_scan_token(LSHIFTASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_65() { | 
 | 
      if (jj_scan_token(NEW)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_77() { | 
 | 
      if (jj_scan_token(CHARACTER_LITERAL)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_76() { | 
 | 
      if (jj_scan_token(FLOATING_POINT_LITERAL)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_33() { | 
 | 
      if (jj_scan_token(MINUSASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_69() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_75()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_76()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_77()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_78()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_79()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
                     if (jj_3R_80()) { | 
 | 
                        return true;  | 
 | 
                     }  | 
 | 
                     if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                        return false;  | 
 | 
                     }  | 
 | 
                  } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                     return false;  | 
 | 
                  }  | 
 | 
               } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                  return false;  | 
 | 
               }  | 
 | 
            } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_75() { | 
 | 
      if (jj_scan_token(INTEGER_LITERAL)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_96() { | 
 | 
      if (jj_scan_token(SC_OR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_83()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_83() { | 
 | 
      if (jj_3R_90()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_99()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_64() { | 
 | 
      if (jj_scan_token(SUPER)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_32() { | 
 | 
      if (jj_scan_token(PLUSASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_73() { | 
 | 
      if (jj_3R_82()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_72() { | 
 | 
      if (jj_scan_token(DOT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(IDENTIFIER)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_74() { | 
 | 
      if (jj_3R_83()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_96()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_63() { | 
 | 
      if (jj_scan_token(THIS)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_31() { | 
 | 
      if (jj_scan_token(REMASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_58() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_71()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_72()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
            if (jj_3R_73()) { | 
 | 
               return true;  | 
 | 
            }  | 
 | 
            if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_71() { | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_25()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_93() { | 
 | 
      if (jj_scan_token(HOOK)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_25()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(COLON)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_68()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_57() { | 
 | 
      if (jj_3R_70()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_30() { | 
 | 
      if (jj_scan_token(SLASHASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_27() { | 
 | 
      if (jj_3R_58()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_56() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_25()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_152() { | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_55() { | 
 | 
      if (jj_scan_token(SUPER)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(DOT)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(IDENTIFIER)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_29() { | 
 | 
      if (jj_scan_token(STARASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_68() { | 
 | 
      if (jj_3R_74()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
      if (jj_3R_93()) { | 
 | 
         jj_scanpos = xsp;  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_54() { | 
 | 
      if (jj_scan_token(THIS)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_62() { | 
 | 
      if (jj_scan_token(IDENTIFIER)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_53() { | 
 | 
      if (jj_3R_24()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_153() { | 
 | 
      if (jj_scan_token(LBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RBRACKET)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_26() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_52()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_53()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_54()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_55()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_56()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
                     if (jj_3R_57()) { | 
 | 
                        return true;  | 
 | 
                     }  | 
 | 
                     if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                        return false;  | 
 | 
                     }  | 
 | 
                  } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                     return false;  | 
 | 
                  }  | 
 | 
               } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                  return false;  | 
 | 
               }  | 
 | 
            } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_52() { | 
 | 
      if (jj_3R_69()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_21() { | 
 | 
    Token xsp;  | 
 | 
    xsp = jj_scanpos;  | 
 | 
    if (jj_3R_28()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_29()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_30()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_31()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_32()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_33()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_34()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_35()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_36()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_37()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
    if (jj_3R_38()) { | 
 | 
    jj_scanpos = xsp;  | 
 | 
                                       if (jj_3R_39()) { | 
 | 
                                          return true;  | 
 | 
                                       }  | 
 | 
                                       if (jj_la == 0  | 
 | 
                                             && jj_scanpos == jj_lastpos) { | 
 | 
                                          return false;  | 
 | 
                                       }  | 
 | 
                                    } else if (jj_la == 0  | 
 | 
                                          && jj_scanpos == jj_lastpos) { | 
 | 
                                       return false;  | 
 | 
                                    }  | 
 | 
                                 } else if (jj_la == 0  | 
 | 
                                       && jj_scanpos == jj_lastpos) { | 
 | 
                                    return false;  | 
 | 
                                 }  | 
 | 
                              } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                                 return false;  | 
 | 
                              }  | 
 | 
                           } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                              return false;  | 
 | 
                           }  | 
 | 
                        } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                           return false;  | 
 | 
                        }  | 
 | 
                     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                        return false;  | 
 | 
                     }  | 
 | 
                  } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                     return false;  | 
 | 
                  }  | 
 | 
               } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
                  return false;  | 
 | 
               }  | 
 | 
            } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
               return false;  | 
 | 
            }  | 
 | 
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      } else if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_28() { | 
 | 
      if (jj_scan_token(ASSIGN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_61() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3_2() { | 
 | 
      if (jj_3R_20()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_21()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_20() { | 
 | 
      if (jj_3R_26()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_27()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_60() { | 
 | 
      if (jj_scan_token(BANG)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_155() { | 
 | 
      if (jj_scan_token(DECR)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_67() { | 
 | 
      if (jj_3R_20()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_21()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_25()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_150() { | 
 | 
      if (jj_scan_token(LPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_24()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    Token xsp;  | 
 | 
    while (true) { | 
 | 
      xsp = jj_scanpos;  | 
 | 
         if (jj_3R_153()) { | 
 | 
            jj_scanpos = xsp;  | 
 | 
            break;  | 
 | 
         }  | 
 | 
         if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
            return false;  | 
 | 
         }  | 
 | 
      }  | 
 | 
      if (jj_scan_token(RPAREN)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
      if (jj_3R_136()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_59() { | 
 | 
      if (jj_scan_token(TILDE)) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_3R_51() { | 
 | 
      if (jj_3R_68()) { | 
 | 
         return true;  | 
 | 
      }  | 
 | 
      if (jj_la == 0 && jj_scanpos == jj_lastpos) { | 
 | 
         return false;  | 
 | 
      }  | 
 | 
    return false;  | 
 | 
  }  | 
 | 
 | 
 | 
  public ExpressionParserTokenManager token_source;  | 
 | 
  ASCII_UCodeESC_CharStream jj_input_stream;  | 
 | 
  public Token token, jj_nt;  | 
 | 
  private int jj_ntk;  | 
 | 
  private Token jj_scanpos, jj_lastpos;  | 
 | 
  private int jj_la;  | 
 | 
  public boolean lookingAhead = false;  | 
 | 
  private int jj_gen;  | 
 | 
  final private int[] jj_la1 = new int[44];  | 
 | 
   final private int[] jj_la1_0 = { 0x8209400, 0x0, 0x8209400, 0x0, 0x1000000, | 
 | 
         0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  | 
 | 
         0x0, 0x0, 0x0, 0x0, 0x0, 0x1000000, 0x0, 0x0, 0x1000000, 0x1000000,  | 
 | 
         0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000000, 0x0, 0x1000000,  | 
 | 
         0x1000000, 0x1000000, 0x0, 0x0, 0x0, };  | 
 | 
   final private int[] jj_la1_1 = { 0x2014, 0x0, 0x2014, 0x0, 0x884480c0, 0x0, | 
 | 
         0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0,  | 
 | 
         0x0, 0x0, 0x0, 0x0, 0x884480c0, 0x0, 0x0, 0x884480c0, 0x884480c0, 0x0,  | 
 | 
         0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x884480c0, 0x0, 0x88400080, 0x400000,  | 
 | 
         0x884480c0, 0x0, 0x0, 0x40, };  | 
 | 
   final private int[] jj_la1_2 = { 0x8, 0x400, 0x0, 0x2000, 0xf00c004e, | 
 | 
         0x8000, 0x100000, 0x4000000, 0x8000000, 0x0, 0x0, 0x0, 0x2400000,  | 
 | 
         0x2400000, 0x0, 0x1830000, 0x1830000, 0x0, 0x0, 0xc0000000,  | 
 | 
         0xc0000000, 0x0, 0x0, 0xc0000000, 0xf00c004e, 0xc0000, 0xc0000, 0x4e,  | 
 | 
         0xc004e, 0x40, 0x30000000, 0x30000000, 0x400, 0x400, 0x40, 0x4440,  | 
 | 
         0x4e, 0x4440, 0x6, 0x0, 0xf00c004e, 0x2000, 0x440, 0x0, };  | 
 | 
   final private int[] jj_la1_3 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0xffe00, 0x0, 0x0, | 
 | 
         0x0, 0x8, 0x10, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1c0, 0x1c0, 0x0, 0x0,  | 
 | 
         0x23, 0x23, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  | 
 | 
         0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };  | 
 | 
  final private JJExpressionParserCalls[] jj_2_rtns = new JJExpressionParserCalls[9];  | 
 | 
  private boolean jj_rescan = false;  | 
 | 
  private int jj_gc = 0;  | 
 | 
 | 
 | 
  public ExpressionParser(java.io.InputStream stream) { | 
 | 
    jj_input_stream = new ASCII_UCodeESC_CharStream(stream, 1, 1);  | 
 | 
    token_source = new ExpressionParserTokenManager(jj_input_stream);  | 
 | 
    token = new Token();  | 
 | 
    jj_ntk = -1;  | 
 | 
    jj_gen = 0;  | 
 | 
      for (int i = 0; i < 44; i++) { | 
 | 
         jj_la1[i] = -1;  | 
 | 
      }  | 
 | 
      for (int i = 0; i < jj_2_rtns.length; i++) { | 
 | 
         jj_2_rtns[i] = new JJExpressionParserCalls();  | 
 | 
      }  | 
 | 
  }  | 
 | 
 | 
 | 
  public void ReInit(java.io.InputStream stream) { | 
 | 
    jj_input_stream.ReInit(stream, 1, 1);  | 
 | 
    token_source.ReInit(jj_input_stream);  | 
 | 
    token = new Token();  | 
 | 
    jj_ntk = -1;  | 
 | 
    jj_gen = 0;  | 
 | 
      for (int i = 0; i < 44; i++) { | 
 | 
         jj_la1[i] = -1;  | 
 | 
      }  | 
 | 
      for (int i = 0; i < jj_2_rtns.length; i++) { | 
 | 
         jj_2_rtns[i] = new JJExpressionParserCalls();  | 
 | 
      }  | 
 | 
  }  | 
 | 
 | 
 | 
  public ExpressionParser(ExpressionParserTokenManager tm) { | 
 | 
    token_source = tm;  | 
 | 
    token = new Token();  | 
 | 
    jj_ntk = -1;  | 
 | 
    jj_gen = 0;  | 
 | 
      for (int i = 0; i < 44; i++) { | 
 | 
         jj_la1[i] = -1;  | 
 | 
      }  | 
 | 
      for (int i = 0; i < jj_2_rtns.length; i++) { | 
 | 
         jj_2_rtns[i] = new JJExpressionParserCalls();  | 
 | 
      }  | 
 | 
  }  | 
 | 
 | 
 | 
  public void ReInit(ExpressionParserTokenManager tm) { | 
 | 
    token_source = tm;  | 
 | 
    token = new Token();  | 
 | 
    jj_ntk = -1;  | 
 | 
    jj_gen = 0;  | 
 | 
      for (int i = 0; i < 44; i++) { | 
 | 
         jj_la1[i] = -1;  | 
 | 
      }  | 
 | 
      for (int i = 0; i < jj_2_rtns.length; i++) { | 
 | 
         jj_2_rtns[i] = new JJExpressionParserCalls();  | 
 | 
      }  | 
 | 
  }  | 
 | 
 | 
 | 
  final private Token jj_consume_token(int kind) throws ParseException { | 
 | 
    Token oldToken;  | 
 | 
      if ((oldToken = token).next != null) { | 
 | 
         token = token.next;  | 
 | 
      } else { | 
 | 
         token = token.next = token_source.getNextToken();  | 
 | 
      }  | 
 | 
    jj_ntk = -1;  | 
 | 
    if (token.kind == kind) { | 
 | 
      jj_gen++;  | 
 | 
      if (++jj_gc > 100) { | 
 | 
        jj_gc = 0;  | 
 | 
            for (JJExpressionParserCalls jj_2_rtn : jj_2_rtns) { | 
 | 
               JJExpressionParserCalls c = jj_2_rtn;  | 
 | 
          while (c != null) { | 
 | 
                  if (c.gen < jj_gen) { | 
 | 
                     c.first = null;  | 
 | 
                  }  | 
 | 
            c = c.next;  | 
 | 
          }  | 
 | 
        }  | 
 | 
      }  | 
 | 
      return token;  | 
 | 
    }  | 
 | 
    token = oldToken;  | 
 | 
    jj_kind = kind;  | 
 | 
    throw generateParseException();  | 
 | 
  }  | 
 | 
 | 
 | 
  final private boolean jj_scan_token(int kind) { | 
 | 
    if (jj_scanpos == jj_lastpos) { | 
 | 
      jj_la--;  | 
 | 
      if (jj_scanpos.next == null) { | 
 | 
            jj_lastpos = jj_scanpos = jj_scanpos.next = token_source  | 
 | 
                  .getNextToken();  | 
 | 
      } else { | 
 | 
        jj_lastpos = jj_scanpos = jj_scanpos.next;  | 
 | 
      }  | 
 | 
    } else { | 
 | 
      jj_scanpos = jj_scanpos.next;  | 
 | 
    }  | 
 | 
    if (jj_rescan) { | 
 | 
         int i = 0;  | 
 | 
         Token tok = token;  | 
 | 
         while (tok != null && tok != jj_scanpos) { | 
 | 
            i++;  | 
 | 
            tok = tok.next;  | 
 | 
         }  | 
 | 
         if (tok != null) { | 
 | 
            jj_add_error_token(kind, i);  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return (jj_scanpos.kind != kind);  | 
 | 
  }  | 
 | 
 | 
 | 
  final public Token getNextToken() { | 
 | 
      if (token.next != null) { | 
 | 
         token = token.next;  | 
 | 
      } else { | 
 | 
         token = token.next = token_source.getNextToken();  | 
 | 
      }  | 
 | 
    jj_ntk = -1;  | 
 | 
    jj_gen++;  | 
 | 
    return token;  | 
 | 
  }  | 
 | 
 | 
 | 
  final public Token getToken(int index) { | 
 | 
    Token t = lookingAhead ? jj_scanpos : token;  | 
 | 
    for (int i = 0; i < index; i++) { | 
 | 
         if (t.next != null) { | 
 | 
            t = t.next;  | 
 | 
         } else { | 
 | 
            t = t.next = token_source.getNextToken();  | 
 | 
         }  | 
 | 
    }  | 
 | 
    return t;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private int jj_ntk() { | 
 | 
      if ((jj_nt = token.next) == null) { | 
 | 
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);  | 
 | 
      } else { | 
 | 
      return (jj_ntk = jj_nt.kind);  | 
 | 
  }  | 
 | 
   }  | 
 | 
 | 
 | 
   private java.util.Vector<int[]> jj_expentries = new java.util.Vector<int[]>();  | 
 | 
  private int[] jj_expentry;  | 
 | 
  private int jj_kind = -1;  | 
 | 
  private int[] jj_lasttokens = new int[100];  | 
 | 
  private int jj_endpos;  | 
 | 
 | 
 | 
  private void jj_add_error_token(int kind, int pos) { | 
 | 
      if (pos >= 100) { | 
 | 
         return;  | 
 | 
      }  | 
 | 
    if (pos == jj_endpos + 1) { | 
 | 
      jj_lasttokens[jj_endpos++] = kind;  | 
 | 
    } else if (jj_endpos != 0) { | 
 | 
      jj_expentry = new int[jj_endpos];  | 
 | 
      for (int i = 0; i < jj_endpos; i++) { | 
 | 
        jj_expentry[i] = jj_lasttokens[i];  | 
 | 
      }  | 
 | 
      boolean exists = false;  | 
 | 
         for (java.util.Enumeration<int[]> enum_ = jj_expentries.elements(); enum_  | 
 | 
               .hasMoreElements();) { | 
 | 
            int[] oldentry = (enum_.nextElement());  | 
 | 
        if (oldentry.length == jj_expentry.length) { | 
 | 
          exists = true;  | 
 | 
          for (int i = 0; i < jj_expentry.length; i++) { | 
 | 
            if (oldentry[i] != jj_expentry[i]) { | 
 | 
              exists = false;  | 
 | 
              break;  | 
 | 
            }  | 
 | 
          }  | 
 | 
               if (exists) { | 
 | 
                  break;  | 
 | 
               }  | 
 | 
            }  | 
 | 
         }  | 
 | 
         if (!exists) { | 
 | 
            jj_expentries.addElement(jj_expentry);  | 
 | 
         }  | 
 | 
         if (pos != 0) { | 
 | 
            jj_lasttokens[(jj_endpos = pos) - 1] = kind;  | 
 | 
         }  | 
 | 
    }  | 
 | 
  }  | 
 | 
 | 
 | 
  final public ParseException generateParseException() { | 
 | 
    jj_expentries.removeAllElements();  | 
 | 
    boolean[] la1tokens = new boolean[116];  | 
 | 
    for (int i = 0; i < 116; i++) { | 
 | 
      la1tokens[i] = false;  | 
 | 
    }  | 
 | 
    if (jj_kind >= 0) { | 
 | 
      la1tokens[jj_kind] = true;  | 
 | 
      jj_kind = -1;  | 
 | 
    }  | 
 | 
    for (int i = 0; i < 44; i++) { | 
 | 
      if (jj_la1[i] == jj_gen) { | 
 | 
        for (int j = 0; j < 32; j++) { | 
 | 
          if ((jj_la1_0[i] & (1<<j)) != 0) { | 
 | 
            la1tokens[j] = true;  | 
 | 
          }  | 
 | 
          if ((jj_la1_1[i] & (1<<j)) != 0) { | 
 | 
            la1tokens[32+j] = true;  | 
 | 
          }  | 
 | 
          if ((jj_la1_2[i] & (1<<j)) != 0) { | 
 | 
            la1tokens[64+j] = true;  | 
 | 
          }  | 
 | 
          if ((jj_la1_3[i] & (1<<j)) != 0) { | 
 | 
            la1tokens[96+j] = true;  | 
 | 
          }  | 
 | 
        }  | 
 | 
      }  | 
 | 
    }  | 
 | 
    for (int i = 0; i < 116; i++) { | 
 | 
      if (la1tokens[i]) { | 
 | 
        jj_expentry = new int[1];  | 
 | 
        jj_expentry[0] = i;  | 
 | 
        jj_expentries.addElement(jj_expentry);  | 
 | 
      }  | 
 | 
    }  | 
 | 
    jj_endpos = 0;  | 
 | 
    jj_rescan_token();  | 
 | 
    jj_add_error_token(0, 0);  | 
 | 
    int[][] exptokseq = new int[jj_expentries.size()][];  | 
 | 
    for (int i = 0; i < jj_expentries.size(); i++) { | 
 | 
         exptokseq[i] = jj_expentries.elementAt(i);  | 
 | 
    }  | 
 | 
    return new ParseException(token, exptokseq, tokenImage);  | 
 | 
  }  | 
 | 
 | 
 | 
  final public void enable_tracing() { | 
 | 
  }  | 
 | 
 | 
 | 
  final public void disable_tracing() { | 
 | 
  }  | 
 | 
 | 
 | 
  final private void jj_rescan_token() { | 
 | 
    jj_rescan = true;  | 
 | 
    for (int i = 0; i < 9; i++) { | 
 | 
      JJExpressionParserCalls p = jj_2_rtns[i];  | 
 | 
      do { | 
 | 
        if (p.gen > jj_gen) { | 
 | 
               jj_la = p.arg;  | 
 | 
               jj_lastpos = jj_scanpos = p.first;  | 
 | 
          switch (i) { | 
 | 
               case 0:  | 
 | 
                  jj_3_1();  | 
 | 
                  break;  | 
 | 
               case 1:  | 
 | 
                  jj_3_2();  | 
 | 
                  break;  | 
 | 
               case 2:  | 
 | 
                  jj_3_3();  | 
 | 
                  break;  | 
 | 
               case 3:  | 
 | 
                  jj_3_4();  | 
 | 
                  break;  | 
 | 
               case 4:  | 
 | 
                  jj_3_5();  | 
 | 
                  break;  | 
 | 
               case 5:  | 
 | 
                  jj_3_6();  | 
 | 
                  break;  | 
 | 
               case 6:  | 
 | 
                  jj_3_7();  | 
 | 
                  break;  | 
 | 
               case 7:  | 
 | 
                  jj_3_8();  | 
 | 
                  break;  | 
 | 
               case 8:  | 
 | 
                  jj_3_9();  | 
 | 
                  break;  | 
 | 
          }  | 
 | 
        }  | 
 | 
        p = p.next;  | 
 | 
      } while (p != null);  | 
 | 
    }  | 
 | 
    jj_rescan = false;  | 
 | 
  }  | 
 | 
 | 
 | 
  final private void jj_save(int index, int xla) { | 
 | 
    JJExpressionParserCalls p = jj_2_rtns[index];  | 
 | 
    while (p.gen > jj_gen) { | 
 | 
         if (p.next == null) { | 
 | 
            p = p.next = new JJExpressionParserCalls();  | 
 | 
            break;  | 
 | 
         }  | 
 | 
      p = p.next;  | 
 | 
    }  | 
 | 
      p.gen = jj_gen + xla - jj_la;  | 
 | 
      p.first = token;  | 
 | 
      p.arg = xla;  | 
 | 
  }  | 
 | 
 | 
 | 
}  | 
 | 
 | 
 | 
final class JJExpressionParserCalls { | 
 | 
  int gen;  | 
 | 
  Token first;  | 
 | 
  int arg;  | 
 | 
  JJExpressionParserCalls next;  | 
 | 
}  |