//----------------------------------------------------
// code was generated by JCUP 0.14
// Thu Nov 07 15:57:40 CET 2002
//----------------------------------------------------

package jaco.java.grammar;

import jaco.java.struct.*;
import jaco.java.component.*;
import jaco.framework.*;
import Constant.*;
import Tree.*;

public final class Parser extends org.zenger.jcup.runtime.LRParser {

  /** constructor */
  public Parser() { super(); }

  /** production table */
  protected static final short _production_table[][] = {
        {0, 2},     {1, 1},     {71, 1},     {71, 1},     {71, 1}, 
        {71, 1},     {71, 1},     {71, 1},     {72, 1},     {72, 1}, 
        {73, 1},     {73, 1},     {74, 1},     {74, 1},     {75, 1}, 
        {75, 1},     {75, 1},     {75, 1},     {75, 1},     {76, 1}, 
        {76, 1},     {77, 1},     {77, 1},     {78, 1},     {79, 2}, 
        {79, 2},     {80, 1},     {80, 1},     {69, 1},     {69, 1}, 
        {69, 1},     {81, 3},     {81, 3},     {2, 3},     {20, 0}, 
        {20, 1},     {22, 1},     {22, 2},     {21, 0},     {21, 1}, 
        {23, 1},     {23, 2},     {82, 0},     {82, 1},     {83, 3}, 
        {84, 1},     {84, 1},     {85, 3},     {86, 5},     {87, 1}, 
        {87, 1},     {87, 1},     {87, 1},     {3, 0},     {3, 1}, 
        {4, 1},     {4, 2},     {5, 1},     {5, 1},     {5, 1}, 
        {5, 1},     {5, 1},     {5, 1},     {5, 1},     {5, 1}, 
        {5, 1},     {5, 1},     {5, 1},     {6, 6},     {7, 6}, 
        {88, 0},     {88, 1},     {89, 2},     {49, 0},     {49, 1}, 
        {50, 2},     {24, 1},     {24, 3},     {53, 3},     {53, 2}, 
        {52, 0},     {52, 1},     {25, 1},     {25, 2},     {26, 1}, 
        {26, 1},     {26, 1},     {26, 1},     {31, 1},     {31, 1}, 
        {31, 1},     {144, 1},     {144, 1},     {27, 4},     {28, 1}, 
        {28, 3},     {17, 1},     {17, 3},     {91, 1},     {91, 3}, 
        {90, 1},     {90, 1},     {10, 2},     {11, 4},     {11, 4}, 
        {12, 4},     {12, 3},     {12, 3},     {48, 0},     {48, 1}, 
        {38, 1},     {38, 3},     {38, 2},     {16, 2},     {16, 3}, 
        {55, 0},     {55, 1},     {56, 2},     {29, 1},     {29, 3}, 
        {54, 1},     {54, 1},     {92, 2},     {13, 4},     {14, 4}, 
        {14, 3},     {51, 3},     {51, 4},     {51, 2},     {94, 5}, 
        {94, 5},     {94, 7},     {8, 5},     {9, 5},     {57, 0}, 
        {57, 1},     {30, 2},     {30, 3},     {58, 3},     {58, 2}, 
        {59, 0},     {59, 1},     {32, 1},     {32, 2},     {33, 1}, 
        {33, 1},     {33, 1},     {33, 1},     {34, 1},     {15, 2}, 
        {95, 2},     {95, 3},     {95, 3},     {95, 4},     {95, 2}, 
        {35, 1},     {35, 3},     {96, 3},     {96, 2},     {42, 0}, 
        {42, 1},     {36, 1},     {36, 2},     {37, 1},     {37, 1}, 
        {37, 1},     {37, 1},     {39, 2},     {41, 2},     {41, 3}, 
        {98, 1},     {98, 1},     {98, 1},     {98, 1},     {98, 1}, 
        {98, 1},     {99, 1},     {99, 1},     {99, 1},     {99, 1}, 
        {99, 1},     {100, 1},     {100, 1},     {100, 1},     {100, 1}, 
        {100, 1},     {100, 1},     {100, 1},     {100, 1},     {100, 1}, 
        {100, 1},     {100, 1},     {100, 1},     {151, 3},     {151, 5}, 
        {97, 1},     {101, 3},     {102, 3},     {103, 2},     {104, 1}, 
        {104, 1},     {104, 1},     {104, 1},     {104, 1},     {104, 1}, 
        {104, 1},     {105, 5},     {106, 7},     {107, 7},     {108, 5}, 
        {66, 3},     {66, 4},     {66, 2},     {43, 1},     {43, 2}, 
        {67, 2},     {68, 0},     {68, 1},     {44, 1},     {44, 2}, 
        {109, 3},     {109, 2},     {110, 5},     {111, 5},     {112, 7}, 
        {113, 9},     {114, 9},     {61, 0},     {61, 1},     {60, 1}, 
        {60, 1},     {63, 0},     {63, 1},     {62, 1},     {45, 1}, 
        {45, 3},     {115, 2},     {115, 3},     {116, 2},     {116, 3}, 
        {117, 3},     {118, 3},     {119, 5},     {120, 3},     {120, 4}, 
        {65, 0},     {65, 1},     {46, 1},     {46, 2},     {121, 5}, 
        {122, 2},     {124, 1},     {124, 1},     {124, 3},     {124, 1}, 
        {124, 1},     {124, 1},     {124, 1},     {124, 3},     {123, 1}, 
        {123, 1},     {125, 5},     {125, 6},     {125, 7},     {125, 8}, 
        {125, 7},     {125, 8},     {64, 0},     {64, 1},     {47, 1}, 
        {47, 3},     {126, 4},     {126, 4},     {126, 4},     {126, 4}, 
        {40, 1},     {40, 2},     {127, 3},     {19, 0},     {19, 1}, 
        {18, 2},     {18, 3},     {128, 3},     {128, 3},     {128, 4}, 
        {128, 4},     {128, 3},     {129, 4},     {129, 6},     {129, 6}, 
        {130, 4},     {130, 4},     {130, 4},     {131, 1},     {131, 1}, 
        {131, 1},     {131, 1},     {132, 2},     {133, 2},     {134, 1}, 
        {134, 1},     {134, 2},     {134, 2},     {134, 1},     {135, 2}, 
        {136, 2},     {137, 1},     {137, 2},     {137, 2},     {137, 1}, 
        {138, 5},     {138, 4},     {138, 5},     {145, 1},     {145, 3}, 
        {145, 3},     {145, 3},     {145, 3},     {145, 3},     {146, 1}, 
        {146, 3},     {146, 3},     {146, 3},     {146, 3},     {146, 3}, 
        {146, 3},     {146, 3},     {146, 3},     {146, 3},     {146, 3}, 
        {146, 3},     {146, 3},     {146, 3},     {146, 3},     {146, 3}, 
        {139, 1},     {139, 5},     {142, 1},     {142, 1},     {140, 3}, 
        {140, 3},     {141, 1},     {141, 1},     {141, 1},     {70, 1}, 
        {70, 1},     {70, 1},     {70, 1},     {70, 1},     {70, 1}, 
        {70, 1},     {70, 1},     {70, 1},     {70, 1},     {70, 1}, 
        {143, 0},     {143, 1},     {93, 1},     {93, 1},     {147, 2}, 
        {148, 2},     {149, 2},     {150, 2}  };

  /** access to production table */
  public short[][] production_table() {return _production_table;}

  /** parse action table */
  protected static short[][] _action_table;

  /** access to parse action table */
  public short[][] action_table() {return _action_table;}

  /** reduce_goto table */
  protected static short[][] _reduce_table;

  /** access to reduce_goto table */
  public short[][] reduce_table() {return _reduce_table;}

  static {
    try {
      java.io.ObjectInputStream p = new java.io.ObjectInputStream(find_tables("jaco.java.grammar.Parser"));
      _action_table = (short[][])p.readObject();
      _reduce_table = (short[][])p.readObject();
    }
    catch (Exception e) {
      throw new RuntimeException("unable to load parser tables: " + e);
    }
  }
  /** instance of action encapsulation class */
  protected ParserActions action_obj;

  /** action encapsulation object initializer */
  protected void init_actions()
  {
      actObj = (action_obj = new ParserActions(this, stack));
  }

  /** start state */
  public final int start_state() { return 0; }
  /** start production */
  public final int start_production() { return 0; }

  /** EOF Symbol index */
  public final int EOF_sym() { return 0; }

  /** error Symbol index */
  public final int error_sym() { return 1; }


  /** user initialization */
  public final void user_init() throws java.lang.Exception
  {

    action_obj.lexer = lexer;
    action_obj.trees = lexer.trees;
    action_obj.make = trees.make;
    action_obj.report = report;

  }

  /** scan to get the next Symbol */
  public final org.zenger.jcup.runtime.Symbol scan()
    throws java.lang.Exception
  {

    Object  obj;
    switch (lexer.token)
    {
        case Symbols.IDENTIFIER:
            obj = lexer.name;
            break;
                
        case Symbols.CHARLITERAL:
            obj = mkConst.IntConst((int)lexer.intVal, TypeConst.CHAR);
            break;
            
        case Symbols.INTLITERAL:
            obj = mkConst.IntConst((int)lexer.intVal);
            break;
            
        case Symbols.LONGLITERAL:
            obj = mkConst.LongConst(lexer.intVal);
            break;
            
        case Symbols.FLOATLITERAL:
            obj = mkConst.FloatConst((float)lexer.floatVal);
            break;
            
        case Symbols.DOUBLELITERAL:
            obj = mkConst.DoubleConst(lexer.floatVal);
            break;
            
        case Symbols.STRINGLITERAL:
            obj = mkConst.StringConst(lexer.name);
            break;
        
        default:
            obj = null;
    }
    jaco.framework.parser.Symbol    sym =
        new jaco.framework.parser.Symbol(lexer.token,
                                    lexer.pos,
                                    Position.encode(lexer.cline, lexer.ccol),
                                    obj);
    lexer.nextToken();
    return sym;

  }


/* other components of the jaco compiler
 */
    Scanner             lexer;
    ErrorHandler        report;
    Trees               trees;
    Constant.Factory    mkConst;
    
    
    public Parser(Scanner lexer)
    {
        this.trees = lexer.trees;
        this.lexer = lexer;
        this.report = lexer.report;
        this.mkConst = lexer.constants.make;
    }
    
    public void report_error(String message, Object info)
    {
        if ((info instanceof jaco.framework.parser.Symbol) &&
            (((jaco.framework.parser.Symbol)info).sym > 0))
        {
            if (((jaco.framework.parser.Symbol)info).left != -1)
                report.error(((jaco.framework.parser.Symbol)info).left,
                        message + " (" +
                        ((jaco.framework.parser.Symbol)info).sym + ")");
            else
                report.error(Position.NOPOS, message);
        }
        else
            report.error(Position.NOPOS, message);
    }
    
    public void report_fatal_error(String message, Object info) throws Exception
    {
        done_parsing();
        report_error("fatal error: " + message, info);
        throw new Exception();
    }
    
    public void syntax_error(jaco.framework.parser.Symbol cur_token)
    {
        report_error("syntax error", cur_token);
    }
    
    protected int error_sync_size()
    {
        return 2;
    }

};

/** jcup generated class to encapsulate user supplied action code.*/
class ParserActions implements org.zenger.jcup.runtime.ActionInterface {
  protected org.zenger.jcup.runtime.LRParser   jcup$parser;
  protected org.zenger.jcup.runtime.ParseStack jcup$stack;
  private final Parser parser;


    Trees           trees;
    Tree.Factory    make;
    Scanner         lexer;
    ErrorHandler    report;
    
    Tree replaceArrayType(ArrayTypeTerm idx, Tree newType)
    {
        while ((idx.elemtype != null) &&
                (idx.elemtype instanceof ArrayTypeTerm))
            idx = (ArrayTypeTerm)idx.elemtype;
        Tree    oldType = idx.elemtype;
        idx.elemtype = newType;
        return oldType;
    }
    
    VarDecl[] varDeclArray(Tree[] trees)
    {
        if (trees == null)
            return null;
        else
        {
            VarDecl[]   decls = new VarDecl[trees.length];
            for (int i = 0; i < decls.length; i++)
                decls[i] = (VarDecl)trees[i];
            return decls;
        }
    }


  /** constructor */
  ParserActions(
    Parser parser,
    org.zenger.jcup.runtime.ParseStack stack)
  {
      this.parser = parser;
      jcup$parser = parser;
      jcup$stack = stack;
  }

  /** method with the actual generated action code. */
  public final org.zenger.jcup.runtime.Symbol doAction(
    int jcup$act_num,
    int jcup$top)
    throws java.lang.Exception
    {
      /* the parse stack */
      org.zenger.jcup.runtime.Symbol[] $stack = jcup$stack.stack;

      /* select the action based on the action number */
      switch (jcup$act_num)
        {
          /*. . . . . . . . . . . . . . . . . . . .*/
          case 362: // RecoverAtParen ::= error RPAREN 
            {
        Tree RESULT = null;
        RESULT = trees.errorTree;
              return jcup$stack.reuse(150/*RecoverAtParen*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 361: // RecoverAtComma ::= error COMMA 
            {
        Tree RESULT = null;
        RESULT = trees.errorTree;
              return jcup$stack.reuse(149/*RecoverAtComma*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 360: // RecoverAtBrace ::= error RBRACE 
            {
        Tree RESULT = null;
        RESULT = trees.errorTree;
              return jcup$stack.reuse(148/*RecoverAtBrace*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 359: // RecoverAtSemi ::= error SEMI 
            {
        Tree RESULT = null;
        RESULT = trees.errorTree;
              return jcup$stack.reuse(147/*RecoverAtSemi*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 358: // ClassOrArray ::= ArrayType 
            {
              return jcup$stack.reuse(93/*ClassOrArray*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 357: // ClassOrArray ::= Name 
            {
              return jcup$stack.reuse(93/*ClassOrArray*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 356: // Expressionopt ::= Expression 
            {
              return jcup$stack.reuse(143/*Expressionopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 355: // Expressionopt ::= 
            {
        Tree RESULT = null;
        RESULT = null;
              return new org.zenger.jcup.runtime.Symbol(143/*Expressionopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 354: // AssignmentOperator ::= BAREQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.BITOR);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 353: // AssignmentOperator ::= CARETEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.BITXOR);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 352: // AssignmentOperator ::= AMPEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.BITAND);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 351: // AssignmentOperator ::= GTGTGTEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.USR);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 350: // AssignmentOperator ::= GTGTEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.SR);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 349: // AssignmentOperator ::= LTLTEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.SL);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 348: // AssignmentOperator ::= SUBEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.MINUS);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 347: // AssignmentOperator ::= PLUSEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.PLUS);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 346: // AssignmentOperator ::= PERCENTEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.MOD);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 345: // AssignmentOperator ::= SLASHEQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.DIV);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 344: // AssignmentOperator ::= STAREQ 
            {
        Integer RESULT = null;
        RESULT = new Integer(OperatorConst.TIMES);
              return jcup$stack.reuse(70/*AssignmentOperator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 343: // LeftHandSide ::= ArrayAccess 
            {
              return jcup$stack.reuse(141/*LeftHandSide*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 342: // LeftHandSide ::= FieldAccess 
            {
              return jcup$stack.reuse(141/*LeftHandSide*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 341: // LeftHandSide ::= Name 
            {
              return jcup$stack.reuse(141/*LeftHandSide*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 340: // Assignment ::= LeftHandSide AssignmentOperator Expression 
            {
        Tree RESULT = null;
        Tree lhs = (Tree)$stack[jcup$top-2].value;
        Integer o = (Integer)$stack[jcup$top-1].value;
        Tree rhs = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Assignop(o.intValue(), lhs, rhs).at(oleft);
              return jcup$stack.reuse(140/*Assignment*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 339: // Assignment ::= LeftHandSide EQ Expression 
            {
        Tree RESULT = null;
        Tree lhs = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree rhs = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Assign(lhs, rhs).at(oleft);
              return jcup$stack.reuse(140/*Assignment*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 338: // Expression ::= Assignment 
            {
              return jcup$stack.reuse(142/*Expression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 337: // Expression ::= ConditionalExpression 
            {
              return jcup$stack.reuse(142/*Expression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 336: // ConditionalExpression ::= BinaryExpression QUES Expression COLON ConditionalExpression 
            {
        Tree RESULT = null;
        Tree c = (Tree)$stack[jcup$top-4].value;
        Object q = (Object)$stack[jcup$top-3].value;
        Tree e1 = (Tree)$stack[jcup$top-2].value;
        Tree e2 = (Tree)$stack[jcup$top].value;
        int qleft = $stack[jcup$top-3].left;
        
            RESULT = make.If(c, e1, e2).at(qleft);
              return jcup$stack.reuse(139/*ConditionalExpression*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 335: // ConditionalExpression ::= BinaryExpression 
            {
              return jcup$stack.reuse(139/*ConditionalExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 334: // BinaryExpressionInclEq ::= BinaryExpressionInclEq STAR BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.TIMES, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 333: // BinaryExpressionInclEq ::= BinaryExpressionInclEq SLASH BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.DIV, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 332: // BinaryExpressionInclEq ::= BinaryExpressionInclEq PERCENT BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.MOD, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 331: // BinaryExpressionInclEq ::= BinaryExpressionInclEq PLUS BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.PLUS, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 330: // BinaryExpressionInclEq ::= BinaryExpressionInclEq SUB BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.MINUS, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 329: // BinaryExpressionInclEq ::= BinaryExpressionInclEq LTLT BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.SL, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 328: // BinaryExpressionInclEq ::= BinaryExpressionInclEq GTGT BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.SR, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 327: // BinaryExpressionInclEq ::= BinaryExpressionInclEq GTGTGT BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.USR, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 326: // BinaryExpressionInclEq ::= BinaryExpressionInclEq LT BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.LT, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 325: // BinaryExpressionInclEq ::= BinaryExpressionInclEq GT BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.GT, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 324: // BinaryExpressionInclEq ::= BinaryExpressionInclEq LTEQ BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.LE, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 323: // BinaryExpressionInclEq ::= BinaryExpressionInclEq GTEQ BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.GE, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 322: // BinaryExpressionInclEq ::= BinaryExpressionInclEq INSTANCEOF ClassOrArray 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Typeop(OperatorConst.TYPETEST, x, y).
                                                            at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 321: // BinaryExpressionInclEq ::= BinaryExpressionInclEq EQEQ BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.EQ, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 320: // BinaryExpressionInclEq ::= BinaryExpressionInclEq BANGEQ BinaryExpressionInclEq 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.NE, x, y).at(oleft);
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 319: // BinaryExpressionInclEq ::= UnaryExpression 
            {
              return jcup$stack.reuse(146/*BinaryExpressionInclEq*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 318: // BinaryExpression ::= BinaryExpression AMP BinaryExpression 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.BITAND, x, y).at(oleft);
              return jcup$stack.reuse(145/*BinaryExpression*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 317: // BinaryExpression ::= BinaryExpression CARET BinaryExpression 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.BITXOR, x, y).at(oleft);
              return jcup$stack.reuse(145/*BinaryExpression*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 316: // BinaryExpression ::= BinaryExpression BAR BinaryExpression 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.BITOR, x, y).at(oleft);
              return jcup$stack.reuse(145/*BinaryExpression*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 315: // BinaryExpression ::= BinaryExpression AMPAMP BinaryExpression 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.AND, x, y).at(oleft);
              return jcup$stack.reuse(145/*BinaryExpression*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 314: // BinaryExpression ::= BinaryExpression BARBAR BinaryExpression 
            {
        Tree RESULT = null;
        Tree x = (Tree)$stack[jcup$top-2].value;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree y = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Binop(OperatorConst.OR, x, y).at(oleft);
              return jcup$stack.reuse(145/*BinaryExpression*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 313: // BinaryExpression ::= BinaryExpressionInclEq 
            {
              return jcup$stack.reuse(145/*BinaryExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 312: // CastExpression ::= LPAREN Name Dims RPAREN UnaryExpressionNotPlusMinus 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-4].value;
        Tree n = (Tree)$stack[jcup$top-3].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int lleft = $stack[jcup$top-4].left;
        
            if (d != null)
            {
                replaceArrayType(d, n);
                RESULT = make.Typeop(OperatorConst.TYPECAST, e, d).at(lleft);
            }
            else
                RESULT = make.Typeop(OperatorConst.TYPECAST, e, n).at(lleft);
              return jcup$stack.reuse(138/*CastExpression*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 311: // CastExpression ::= LPAREN Expression RPAREN UnaryExpressionNotPlusMinus 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-3].value;
        Tree t = (Tree)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int lleft = $stack[jcup$top-3].left;
        
            RESULT = make.Typeop(OperatorConst.TYPECAST, e, t).at(lleft);
              return jcup$stack.reuse(138/*CastExpression*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 310: // CastExpression ::= LPAREN PrimitiveType Dimsopt RPAREN UnaryExpression 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-4].value;
        Tree t = (Tree)$stack[jcup$top-3].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int lleft = $stack[jcup$top-4].left;
        
            if (d != null)
            {
                replaceArrayType(d, t);
                    RESULT = make.Typeop(OperatorConst.TYPECAST, e, d).at(lleft);
            }
            else
                RESULT = make.Typeop(OperatorConst.TYPECAST, e, t).at(lleft);
              return jcup$stack.reuse(138/*CastExpression*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 309: // UnaryExpressionNotPlusMinus ::= CastExpression 
            {
              return jcup$stack.reuse(137/*UnaryExpressionNotPlusMinus*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 308: // UnaryExpressionNotPlusMinus ::= BANG UnaryExpression 
            {
        Tree RESULT = null;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Unop(OperatorConst.NOT, e).at(oleft);
              return jcup$stack.reuse(137/*UnaryExpressionNotPlusMinus*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 307: // UnaryExpressionNotPlusMinus ::= TILDE UnaryExpression 
            {
        Tree RESULT = null;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Unop(OperatorConst.COMPL, e).at(oleft);
              return jcup$stack.reuse(137/*UnaryExpressionNotPlusMinus*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 306: // UnaryExpressionNotPlusMinus ::= PostfixExpression 
            {
              return jcup$stack.reuse(137/*UnaryExpressionNotPlusMinus*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 305: // PreDecrementExpression ::= SUBSUB UnaryExpression 
            {
        Tree RESULT = null;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Unop(OperatorConst.PREDEC, e).at(oleft);
              return jcup$stack.reuse(136/*PreDecrementExpression*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 304: // PreIncrementExpression ::= PLUSPLUS UnaryExpression 
            {
        Tree RESULT = null;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Unop(OperatorConst.PREINC, e).at(oleft);
              return jcup$stack.reuse(135/*PreIncrementExpression*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 303: // UnaryExpression ::= UnaryExpressionNotPlusMinus 
            {
              return jcup$stack.reuse(134/*UnaryExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 302: // UnaryExpression ::= SUB UnaryExpression 
            {
        Tree RESULT = null;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Unop(OperatorConst.NEG, e).at(oleft);
              return jcup$stack.reuse(134/*UnaryExpression*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 301: // UnaryExpression ::= PLUS UnaryExpression 
            {
        Tree RESULT = null;
        Object o = (Object)$stack[jcup$top-1].value;
        Tree e = (Tree)$stack[jcup$top].value;
        int oleft = $stack[jcup$top-1].left;
        
            RESULT = make.Unop(OperatorConst.POS, e).at(oleft);
              return jcup$stack.reuse(134/*UnaryExpression*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 300: // UnaryExpression ::= PreDecrementExpression 
            {
              return jcup$stack.reuse(134/*UnaryExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 299: // UnaryExpression ::= PreIncrementExpression 
            {
              return jcup$stack.reuse(134/*UnaryExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 298: // PostDecrementExpression ::= PostfixExpression SUBSUB 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-1].value;
        Object o = (Object)$stack[jcup$top].value;
        int oleft = $stack[jcup$top].left;
        
            RESULT = make.Unop(OperatorConst.POSTDEC, e).at(oleft);
              return jcup$stack.reuse(133/*PostDecrementExpression*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 297: // PostIncrementExpression ::= PostfixExpression PLUSPLUS 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-1].value;
        Object o = (Object)$stack[jcup$top].value;
        int oleft = $stack[jcup$top].left;
        
            RESULT = make.Unop(OperatorConst.POSTINC, e).at(oleft);
              return jcup$stack.reuse(132/*PostIncrementExpression*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 296: // PostfixExpression ::= PostDecrementExpression 
            {
              return jcup$stack.reuse(131/*PostfixExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 295: // PostfixExpression ::= PostIncrementExpression 
            {
              return jcup$stack.reuse(131/*PostfixExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 294: // PostfixExpression ::= Name 
            {
              return jcup$stack.reuse(131/*PostfixExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 293: // PostfixExpression ::= Primary 
            {
              return jcup$stack.reuse(131/*PostfixExpression*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 292: // ArrayAccess ::= error LBRACKET Expression RBRACKET 
            {
        Tree RESULT = null;
        RESULT = trees.errorTree;
              return jcup$stack.reuse(130/*ArrayAccess*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 291: // ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression RBRACKET 
            {
        Tree RESULT = null;
        Tree e1 = (Tree)$stack[jcup$top-3].value;
        Object l = (Object)$stack[jcup$top-2].value;
        Tree e2 = (Tree)$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Index(e1, e2).at(lleft);
              return jcup$stack.reuse(130/*ArrayAccess*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 290: // ArrayAccess ::= Name LBRACKET Expression RBRACKET 
            {
        Tree RESULT = null;
        Tree n = (Tree)$stack[jcup$top-3].value;
        Object l = (Object)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Index(n, e).at(lleft);
              return jcup$stack.reuse(130/*ArrayAccess*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 289: // MethodInvocation ::= SUPER DOT IDENTIFIER LPAREN ArgumentListopt RPAREN 
            {
        Tree RESULT = null;
        Object s = (Object)$stack[jcup$top-5].value;
        Object d = (Object)$stack[jcup$top-4].value;
        Name i = (Name)$stack[jcup$top-3].value;
        Object l = (Object)$stack[jcup$top-2].value;
        Tree[] a = (Tree[])$stack[jcup$top-1].value;
        int sleft = $stack[jcup$top-5].left;
        int dleft = $stack[jcup$top-4].left;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Apply(make.Select(trees.Super().at(sleft), i).
                                                at(dleft), a).at(lleft);
              return jcup$stack.reuse(129/*MethodInvocation*/, jcup$top - 5, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 288: // MethodInvocation ::= Primary DOT IDENTIFIER LPAREN ArgumentListopt RPAREN 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-5].value;
        Object k = (Object)$stack[jcup$top-4].value;
        Name i = (Name)$stack[jcup$top-3].value;
        Object l = (Object)$stack[jcup$top-2].value;
        Tree[] a = (Tree[])$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-4].left;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Apply(make.Select(e, i).at(kleft), a).
                                at(lleft);
              return jcup$stack.reuse(129/*MethodInvocation*/, jcup$top - 5, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 287: // MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN 
            {
        Tree RESULT = null;
        Tree n = (Tree)$stack[jcup$top-3].value;
        Object l = (Object)$stack[jcup$top-2].value;
        Tree[] a = (Tree[])$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Apply(n, a).at(lleft);
              return jcup$stack.reuse(129/*MethodInvocation*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 286: // FieldAccess ::= VOID DOT CLASS 
            {
        Tree RESULT = null;
        Object v = (Object)$stack[jcup$top-2].value;
        Object k = (Object)$stack[jcup$top].value;
        int vleft = $stack[jcup$top-2].left;
        int kleft = $stack[jcup$top].left;
        
            RESULT = trees.Class(make.BasicType(TypeConst.VOID).at(vleft)).
                            at(kleft);
              return jcup$stack.reuse(128/*FieldAccess*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 285: // FieldAccess ::= Name Dims DOT CLASS 
            {
        Tree RESULT = null;
        Tree n = (Tree)$stack[jcup$top-3].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top-2].value;
        Object k = (Object)$stack[jcup$top].value;
        int kleft = $stack[jcup$top].left;
        
            replaceArrayType(d, n);
            RESULT = trees.Class(d).at(kleft);
              return jcup$stack.reuse(128/*FieldAccess*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 284: // FieldAccess ::= PrimitiveType Dimsopt DOT CLASS 
            {
        Tree RESULT = null;
        Tree t = (Tree)$stack[jcup$top-3].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top-2].value;
        Object k = (Object)$stack[jcup$top].value;
        int kleft = $stack[jcup$top].left;
        
            if (d != null)
            {
                replaceArrayType(d, t);
                RESULT = trees.Class(d).at(kleft);
            }
            else
                RESULT = trees.Class(t).at(kleft);
              return jcup$stack.reuse(128/*FieldAccess*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 283: // FieldAccess ::= SUPER DOT IDENTIFIER 
            {
        Tree RESULT = null;
        Object s = (Object)$stack[jcup$top-2].value;
        Object k = (Object)$stack[jcup$top-1].value;
        Name i = (Name)$stack[jcup$top].value;
        int sleft = $stack[jcup$top-2].left;
        int kleft = $stack[jcup$top-1].left;
        
            RESULT = make.Select(trees.Super().at(sleft), i).at(kleft);
              return jcup$stack.reuse(128/*FieldAccess*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 282: // FieldAccess ::= Primary DOT IDENTIFIER 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-2].value;
        Object k = (Object)$stack[jcup$top-1].value;
        Name i = (Name)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-1].left;
        
            RESULT = make.Select(e, i).at(kleft);
              return jcup$stack.reuse(128/*FieldAccess*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 281: // Dims ::= Dims LBRACKET RBRACKET 
            {
        ArrayTypeTerm RESULT = null;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top-2].value;
        Object l = (Object)$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-1].left;
        
            RESULT = (ArrayTypeTerm)make.ArrayTypeTerm(d).at(lleft);
              return jcup$stack.reuse(18/*Dims*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 280: // Dims ::= LBRACKET RBRACKET 
            {
        ArrayTypeTerm RESULT = null;
        Object l = (Object)$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-1].left;
        
            RESULT = (ArrayTypeTerm)make.ArrayTypeTerm(null).at(lleft);
              return jcup$stack.reuse(18/*Dims*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 279: // Dimsopt ::= Dims 
            {
              return jcup$stack.reuse(19/*Dimsopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 278: // Dimsopt ::= 
            {
        ArrayTypeTerm RESULT = null;
        RESULT = null;
              return new org.zenger.jcup.runtime.Symbol(19/*Dimsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 277: // DimExpr ::= LBRACKET Expression RBRACKET 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-1].value;
         RESULT = e;
              return jcup$stack.reuse(127/*DimExpr*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 276: // DimExprs ::= DimExprs DimExpr 
            {
        TreeList RESULT = null;
        TreeList es = (TreeList)$stack[jcup$top-1].value;
        Tree e = (Tree)$stack[jcup$top].value;
         RESULT = es.append(e);
              return jcup$stack.reuse(40/*DimExprs*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 275: // DimExprs ::= DimExpr 
            {
        TreeList RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(e);
              return jcup$stack.reuse(40/*DimExprs*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 274: // ArrayCreationExpression ::= NEW ClassOrInterfaceType Dims ArrayInitializer 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-3].value;
        Tree t = (Tree)$stack[jcup$top-2].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top-1].value;
        Tree i = (Tree)$stack[jcup$top].value;
        
            if (d != null)
            {
                replaceArrayType(d, t);
                ((Aggregate)i).arrtype = d;
                RESULT = i;
            }
            else
                ((Aggregate)i).arrtype = t;
            RESULT = i;
              return jcup$stack.reuse(126/*ArrayCreationExpression*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 273: // ArrayCreationExpression ::= NEW PrimitiveType Dims ArrayInitializer 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-3].value;
        Tree t = (Tree)$stack[jcup$top-2].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top-1].value;
        Tree i = (Tree)$stack[jcup$top].value;
        
            if (d != null)
            {
                replaceArrayType(d, t);
                ((Aggregate)i).arrtype = d;
                RESULT = i;
            }
            else
                ((Aggregate)i).arrtype = t;
            RESULT = i;
              return jcup$stack.reuse(126/*ArrayCreationExpression*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 272: // ArrayCreationExpression ::= NEW ClassOrInterfaceType DimExprs Dimsopt 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-3].value;
        Tree t = (Tree)$stack[jcup$top-2].value;
        TreeList e = (TreeList)$stack[jcup$top-1].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-3].left;
        
            if (d != null)
            {
                replaceArrayType(d, t);
                RESULT = make.NewArray(d, e.toArray()).at(kleft);
            }
            else
                RESULT = make.NewArray(t, e.toArray()).at(kleft);
              return jcup$stack.reuse(126/*ArrayCreationExpression*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 271: // ArrayCreationExpression ::= NEW PrimitiveType DimExprs Dimsopt 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-3].value;
        Tree t = (Tree)$stack[jcup$top-2].value;
        TreeList e = (TreeList)$stack[jcup$top-1].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-3].left;
        
            if (d != null)
            {
                replaceArrayType(d, t);
                RESULT = make.NewArray(d, e.toArray()).at(kleft);
            }
            else
                RESULT = make.NewArray(t, e.toArray()).at(kleft);
              return jcup$stack.reuse(126/*ArrayCreationExpression*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 270: // ArgumentList ::= ArgumentList COMMA Expression 
            {
        TreeList RESULT = null;
        TreeList as = (TreeList)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top].value;
         RESULT = as.append(e);
              return jcup$stack.reuse(47/*ArgumentList*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 269: // ArgumentList ::= Expression 
            {
        TreeList RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(e);
              return jcup$stack.reuse(47/*ArgumentList*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 268: // ArgumentListopt ::= ArgumentList 
            {
        Tree[] RESULT = null;
        TreeList as = (TreeList)$stack[jcup$top].value;
         RESULT = as.toArray();
              return jcup$stack.reuse(64/*ArgumentListopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 267: // ArgumentListopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(64/*ArgumentListopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 266: // ClassInstanceCreationExpression ::= Name DOT NEW IDENTIFIER LPAREN ArgumentListopt RPAREN ClassBody 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-7].value;
        Object k = (Object)$stack[jcup$top-5].value;
        Name i = (Name)$stack[jcup$top-4].value;
        Tree[] a = (Tree[])$stack[jcup$top-2].value;
        Tree[] b = (Tree[])$stack[jcup$top].value;
        int kleft = $stack[jcup$top-5].left;
        int ileft = $stack[jcup$top-4].left;
        int bleft = $stack[jcup$top].left;
        
            RESULT = make.NewObj(e, make.Ident(i).at(ileft), a,
                        make.ClassDecl(null, 0, null, trees.noTrees,
                            b).at(bleft)).at(kleft);
              return jcup$stack.reuse(125/*ClassInstanceCreationExpression*/, jcup$top - 7, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 265: // ClassInstanceCreationExpression ::= Name DOT NEW IDENTIFIER LPAREN ArgumentListopt RPAREN 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-6].value;
        Object k = (Object)$stack[jcup$top-4].value;
        Name i = (Name)$stack[jcup$top-3].value;
        Tree[] a = (Tree[])$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-4].left;
        int ileft = $stack[jcup$top-3].left;
        
            RESULT = make.NewObj(e, make.Ident(i).at(ileft),
                            a, null).at(kleft);
              return jcup$stack.reuse(125/*ClassInstanceCreationExpression*/, jcup$top - 6, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 264: // ClassInstanceCreationExpression ::= Primary DOT NEW IDENTIFIER LPAREN ArgumentListopt RPAREN ClassBody 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-7].value;
        Object k = (Object)$stack[jcup$top-5].value;
        Name i = (Name)$stack[jcup$top-4].value;
        Tree[] a = (Tree[])$stack[jcup$top-2].value;
        Tree[] b = (Tree[])$stack[jcup$top].value;
        int kleft = $stack[jcup$top-5].left;
        int ileft = $stack[jcup$top-4].left;
        int bleft = $stack[jcup$top].left;
        
            RESULT = make.NewObj(e, make.Ident(i).at(ileft), a,
                        make.ClassDecl(null, 0, null, trees.noTrees,
                            b).at(bleft)).at(kleft);
              return jcup$stack.reuse(125/*ClassInstanceCreationExpression*/, jcup$top - 7, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 263: // ClassInstanceCreationExpression ::= Primary DOT NEW IDENTIFIER LPAREN ArgumentListopt RPAREN 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-6].value;
        Object k = (Object)$stack[jcup$top-4].value;
        Name i = (Name)$stack[jcup$top-3].value;
        Tree[] a = (Tree[])$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-4].left;
        int ileft = $stack[jcup$top-3].left;
        
            RESULT = make.NewObj(e, make.Ident(i).at(ileft),
                            a, null).at(kleft);
              return jcup$stack.reuse(125/*ClassInstanceCreationExpression*/, jcup$top - 6, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 262: // ClassInstanceCreationExpression ::= NEW ClassOrInterfaceType LPAREN ArgumentListopt RPAREN ClassBody 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-5].value;
        Tree t = (Tree)$stack[jcup$top-4].value;
        Tree[] a = (Tree[])$stack[jcup$top-2].value;
        Tree[] b = (Tree[])$stack[jcup$top].value;
        int kleft = $stack[jcup$top-5].left;
        int bleft = $stack[jcup$top].left;
        
            RESULT = make.NewObj(null, t, a,
                        make.ClassDecl(null, 0, null, trees.noTrees,
                            b).at(bleft)).at(kleft);
              return jcup$stack.reuse(125/*ClassInstanceCreationExpression*/, jcup$top - 5, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 261: // ClassInstanceCreationExpression ::= NEW ClassOrInterfaceType LPAREN ArgumentListopt RPAREN 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-4].value;
        Tree t = (Tree)$stack[jcup$top-3].value;
        Tree[] a = (Tree[])$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-4].left;
        
            RESULT = make.NewObj(null, t, a, null).at(kleft);
              return jcup$stack.reuse(125/*ClassInstanceCreationExpression*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 260: // Primary ::= ArrayCreationExpression 
            {
              return jcup$stack.reuse(123/*Primary*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 259: // Primary ::= PrimaryNoNewArray 
            {
              return jcup$stack.reuse(123/*Primary*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 258: // PrimaryNoNewArray ::= Name DOT THIS 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-2].value;
        Object k = (Object)$stack[jcup$top].value;
        int kleft = $stack[jcup$top].left;
        
            RESULT = make.Self(e, TreeConst.THIS).at(kleft);
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 257: // PrimaryNoNewArray ::= ArrayAccess 
            {
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 256: // PrimaryNoNewArray ::= MethodInvocation 
            {
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 255: // PrimaryNoNewArray ::= FieldAccess 
            {
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 254: // PrimaryNoNewArray ::= ClassInstanceCreationExpression 
            {
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 253: // PrimaryNoNewArray ::= LPAREN Expression RPAREN 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-1].value;
         RESULT = e;
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 252: // PrimaryNoNewArray ::= THIS 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top].value;
        int kleft = $stack[jcup$top].left;
         RESULT = trees.This().at(kleft);
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 251: // PrimaryNoNewArray ::= Literal 
            {
              return jcup$stack.reuse(124/*PrimaryNoNewArray*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 250: // Finally ::= FINALLY Block 
            {
        Tree RESULT = null;
        Tree b = (Tree)$stack[jcup$top].value;
         RESULT = b;
              return jcup$stack.reuse(122/*Finally*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 249: // CatchClause ::= CATCH LPAREN FormalParameter RPAREN Block 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-4].value;
        VarDecl f = (VarDecl)$stack[jcup$top-2].value;
        Tree b = (Tree)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-4].left;
        
            RESULT = make.Catch(f, b).at(kleft);
              return jcup$stack.reuse(121/*CatchClause*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 248: // Catches ::= Catches CatchClause 
            {
        TreeList RESULT = null;
        TreeList cs = (TreeList)$stack[jcup$top-1].value;
        Tree c = (Tree)$stack[jcup$top].value;
         RESULT = cs.append(c);
              return jcup$stack.reuse(46/*Catches*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 247: // Catches ::= CatchClause 
            {
        TreeList RESULT = null;
        Tree c = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(c);
              return jcup$stack.reuse(46/*Catches*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 246: // Catchesopt ::= Catches 
            {
        Catch[] RESULT = null;
        TreeList c = (TreeList)$stack[jcup$top].value;
        
            Tree[]      treess = c.toArray();
            Catch[]     catches = new Catch[treess.length];
            System.arraycopy(treess, 0, catches, 0, treess.length);
            RESULT = catches;
              return jcup$stack.reuse(65/*Catchesopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 245: // Catchesopt ::= 
            {
        Catch[] RESULT = null;
        RESULT = new Catch[0];
              return new org.zenger.jcup.runtime.Symbol(65/*Catchesopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 244: // TryStatement ::= TRY Block Catchesopt Finally 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-3].value;
        Tree b = (Tree)$stack[jcup$top-2].value;
        Catch[] c = (Catch[])$stack[jcup$top-1].value;
        Tree f = (Tree)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-3].left;
        
            RESULT = make.Try(b, c, f).at(kleft);
              return jcup$stack.reuse(120/*TryStatement*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 243: // TryStatement ::= TRY Block Catches 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-2].value;
        Tree b = (Tree)$stack[jcup$top-1].value;
        TreeList c = (TreeList)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-2].left;
        
            Tree[]      treess = c.toArray();
            Catch[]     catches = new Catch[treess.length];
            System.arraycopy(treess, 0, catches, 0, treess.length);
            RESULT = make.Try(b, catches, null).at(kleft);
              return jcup$stack.reuse(120/*TryStatement*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 242: // SynchronizedStatement ::= SYNCHRONIZED LPAREN Expression RPAREN Block 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-4].value;
        Tree e = (Tree)$stack[jcup$top-2].value;
        Tree b = (Tree)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-4].left;
        
            RESULT = make.Synchronized(e, b).at(kleft);
              return jcup$stack.reuse(119/*SynchronizedStatement*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 241: // ThrowStatement ::= THROW Expression SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-2].left;
        
            RESULT = make.Throw(e).at(kleft);
              return jcup$stack.reuse(118/*ThrowStatement*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 240: // ReturnStatement ::= RETURN Expressionopt SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-2].left;
        
            RESULT = make.Return(e).at(kleft);
              return jcup$stack.reuse(117/*ReturnStatement*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 239: // ContinueStatement ::= CONTINUE IDENTIFIER SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-2].value;
        Name i = (Name)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-2].left;
        
            RESULT = make.Continue(i).at(kleft);
              return jcup$stack.reuse(116/*ContinueStatement*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 238: // ContinueStatement ::= CONTINUE SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-1].left;
        
            RESULT = make.Continue(null).at(kleft);
              return jcup$stack.reuse(116/*ContinueStatement*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 237: // BreakStatement ::= BREAK IDENTIFIER SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-2].value;
        Name i = (Name)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-2].left;
        
            RESULT = make.Break(i).at(kleft);
              return jcup$stack.reuse(115/*BreakStatement*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 236: // BreakStatement ::= BREAK SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-1].left;
        
            RESULT = make.Break(null).at(kleft);
              return jcup$stack.reuse(115/*BreakStatement*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 235: // StatementExpressionList ::= StatementExpressionList COMMA StatementExpression 
            {
        TreeList RESULT = null;
        TreeList es = (TreeList)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top].value;
        
            RESULT = es.append(e);
              return jcup$stack.reuse(45/*StatementExpressionList*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 234: // StatementExpressionList ::= StatementExpression 
            {
        TreeList RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(e);
              return jcup$stack.reuse(45/*StatementExpressionList*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 233: // ForUpdate ::= StatementExpressionList 
            {
        Tree[] RESULT = null;
        TreeList es = (TreeList)$stack[jcup$top].value;
         RESULT = es.toArray();
              return jcup$stack.reuse(62/*ForUpdate*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 232: // ForUpdateopt ::= ForUpdate 
            {
              return jcup$stack.reuse(63/*ForUpdateopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 231: // ForUpdateopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(63/*ForUpdateopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 230: // ForInit ::= LocalVariableDeclaration 
            {
        Tree[] RESULT = null;
        TreeList vd = (TreeList)$stack[jcup$top].value;
         RESULT = vd.toArray();
              return jcup$stack.reuse(60/*ForInit*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 229: // ForInit ::= StatementExpressionList 
            {
        Tree[] RESULT = null;
        TreeList ss = (TreeList)$stack[jcup$top].value;
         RESULT = ss.toArray();
              return jcup$stack.reuse(60/*ForInit*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 228: // ForInitopt ::= ForInit 
            {
              return jcup$stack.reuse(61/*ForInitopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 227: // ForInitopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(61/*ForInitopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 226: // ForStatementNoShortIf ::= FOR LPAREN ForInitopt SEMI Expressionopt SEMI ForUpdateopt RPAREN StatementNoShortIf 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-8].value;
        Tree[] i = (Tree[])$stack[jcup$top-6].value;
        Tree e = (Tree)$stack[jcup$top-4].value;
        Tree[] u = (Tree[])$stack[jcup$top-2].value;
        Tree s = (Tree)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-8].left;
        
            RESULT = make.ForLoop(i, e, u, s).at(kleft);
              return jcup$stack.reuse(114/*ForStatementNoShortIf*/, jcup$top - 8, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 225: // ForStatement ::= FOR LPAREN ForInitopt SEMI Expressionopt SEMI ForUpdateopt RPAREN Statement 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-8].value;
        Tree[] i = (Tree[])$stack[jcup$top-6].value;
        Tree e = (Tree)$stack[jcup$top-4].value;
        Tree[] u = (Tree[])$stack[jcup$top-2].value;
        Tree s = (Tree)$stack[jcup$top].value;
        int kleft = $stack[jcup$top-8].left;
        
            RESULT = make.ForLoop(i, e, u, s).at(kleft);
              return jcup$stack.reuse(113/*ForStatement*/, jcup$top - 8, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 224: // DoStatement ::= DO Statement WHILE LPAREN Expression RPAREN SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-6].value;
        Tree s = (Tree)$stack[jcup$top-5].value;
        Tree e = (Tree)$stack[jcup$top-2].value;
        int kleft = $stack[jcup$top-6].left;
        
            RESULT = make.Loop(TreeConst.DO, e, s).at(kleft);
              return jcup$stack.reuse(112/*DoStatement*/, jcup$top - 6, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 223: // WhileStatementNoShortIf ::= WHILE LPAREN Expression RPAREN StatementNoShortIf 
            {
        Tree RESULT = null;
        Object w = (Object)$stack[jcup$top-4].value;
        Tree e = (Tree)$stack[jcup$top-2].value;
        Tree s = (Tree)$stack[jcup$top].value;
        int wleft = $stack[jcup$top-4].left;
        
            RESULT = make.Loop(TreeConst.WHILE, e, s).at(wleft);
              return jcup$stack.reuse(111/*WhileStatementNoShortIf*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 222: // WhileStatement ::= WHILE LPAREN Expression RPAREN Statement 
            {
        Tree RESULT = null;
        Object w = (Object)$stack[jcup$top-4].value;
        Tree e = (Tree)$stack[jcup$top-2].value;
        Tree s = (Tree)$stack[jcup$top].value;
        int wleft = $stack[jcup$top-4].left;
        
            RESULT = make.Loop(TreeConst.WHILE, e, s).at(wleft);
              return jcup$stack.reuse(110/*WhileStatement*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 221: // SwitchLabel ::= DEFAULT COLON 
            {
        Tree RESULT = null;
        RESULT = make.Exec(null);
              return jcup$stack.reuse(109/*SwitchLabel*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 220: // SwitchLabel ::= CASE BinaryExpression COLON 
            {
        Tree RESULT = null;
        Object c = (Object)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top-1].value;
         RESULT = make.Exec(e);
              return jcup$stack.reuse(109/*SwitchLabel*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 219: // SwitchLabels ::= SwitchLabels SwitchLabel 
            {
        TreeList RESULT = null;
        TreeList ls = (TreeList)$stack[jcup$top-1].value;
        Tree l = (Tree)$stack[jcup$top].value;
        
            RESULT = ls.append(l);
              return jcup$stack.reuse(44/*SwitchLabels*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 218: // SwitchLabels ::= SwitchLabel 
            {
        TreeList RESULT = null;
        Tree l = (Tree)$stack[jcup$top].value;
         RESULT = new TreeList(l);
              return jcup$stack.reuse(44/*SwitchLabels*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 217: // SwitchLabelsopt ::= SwitchLabels 
            {
        Case RESULT = null;
        TreeList ls = (TreeList)$stack[jcup$top].value;
        int lsleft = $stack[jcup$top].left;
        
            Tree[]  pats = ls.toArray();
            for (int i = 0; i < ls.length(); i++)
                if (pats[i] != null)
                    pats[i] = ((Exec)pats[i]).expr;
            RESULT = (Case)make.Case(pats, trees.noTrees).at(lsleft);
              return jcup$stack.reuse(68/*SwitchLabelsopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 216: // SwitchLabelsopt ::= 
            {
        Case RESULT = null;
        RESULT = null;
              return new org.zenger.jcup.runtime.Symbol(68/*SwitchLabelsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 215: // SwitchBlockStatementGroup ::= SwitchLabels BlockStatements 
            {
        Case RESULT = null;
        TreeList ls = (TreeList)$stack[jcup$top-1].value;
        TreeList ss = (TreeList)$stack[jcup$top].value;
        int lsleft = $stack[jcup$top-1].left;
        
            Tree[]  pats = ls.toArray();
            for (int i = 0; i < ls.length(); i++)
                if (pats[i] != null)
                    pats[i] = ((Exec)pats[i]).expr;
            RESULT = (Case)make.Case(pats, ss.toArray()).at(lsleft);
              return jcup$stack.reuse(67/*SwitchBlockStatementGroup*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 214: // SwitchBlockStatementGroups ::= SwitchBlockStatementGroups SwitchBlockStatementGroup 
            {
        TreeList RESULT = null;
        TreeList ss = (TreeList)$stack[jcup$top-1].value;
        Case ss2 = (Case)$stack[jcup$top].value;
        
            RESULT = ss.append(ss2);
              return jcup$stack.reuse(43/*SwitchBlockStatementGroups*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 213: // SwitchBlockStatementGroups ::= SwitchBlockStatementGroup 
            {
        TreeList RESULT = null;
        Case s = (Case)$stack[jcup$top].value;
         RESULT = trees.TreeList(s);
              return jcup$stack.reuse(43/*SwitchBlockStatementGroups*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 212: // SwitchBlock ::= LBRACE RecoverAtBrace 
            {
        Case[] RESULT = null;
        Tree err = (Tree)$stack[jcup$top].value;
         RESULT = new Case[0];
              return jcup$stack.reuse(66/*SwitchBlock*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 211: // SwitchBlock ::= LBRACE SwitchBlockStatementGroups SwitchLabelsopt RBRACE 
            {
        Case[] RESULT = null;
        TreeList ls = (TreeList)$stack[jcup$top-2].value;
        Case ls2 = (Case)$stack[jcup$top-1].value;
        
            Tree[]  treess = ls.append(ls2).toArray();
            Case[]  cases = new Case[treess.length];
            System.arraycopy(treess, 0, cases, 0, treess.length);
            RESULT = cases;
              return jcup$stack.reuse(66/*SwitchBlock*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 210: // SwitchBlock ::= LBRACE SwitchLabelsopt RBRACE 
            {
        Case[] RESULT = null;
        Case l = (Case)$stack[jcup$top-1].value;
        
            if (l == null)
                RESULT = new Case[0];
            else
                RESULT = new Case[]{l};
              return jcup$stack.reuse(66/*SwitchBlock*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 209: // SwitchStatement ::= SWITCH LPAREN Expression RPAREN SwitchBlock 
            {
        Tree RESULT = null;
        Object s = (Object)$stack[jcup$top-4].value;
        Tree e = (Tree)$stack[jcup$top-2].value;
        Case[] b = (Case[])$stack[jcup$top].value;
        int sleft = $stack[jcup$top-4].left;
        
            RESULT = make.Switch(e, b).at(sleft);
              return jcup$stack.reuse(108/*SwitchStatement*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 208: // IfThenElseStatementNoShortIf ::= IF LPAREN Expression RPAREN StatementNoShortIf ELSE StatementNoShortIf 
            {
        Tree RESULT = null;
        Object i = (Object)$stack[jcup$top-6].value;
        Tree e = (Tree)$stack[jcup$top-4].value;
        Tree s1 = (Tree)$stack[jcup$top-2].value;
        Tree s2 = (Tree)$stack[jcup$top].value;
        int ileft = $stack[jcup$top-6].left;
        
            RESULT = make.If(e, s1, s2).at(ileft);
              return jcup$stack.reuse(107/*IfThenElseStatementNoShortIf*/, jcup$top - 6, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 207: // IfThenElseStatement ::= IF LPAREN Expression RPAREN StatementNoShortIf ELSE Statement 
            {
        Tree RESULT = null;
        Object i = (Object)$stack[jcup$top-6].value;
        Tree e = (Tree)$stack[jcup$top-4].value;
        Tree s1 = (Tree)$stack[jcup$top-2].value;
        Tree s2 = (Tree)$stack[jcup$top].value;
        int ileft = $stack[jcup$top-6].left;
        
            RESULT = make.If(e, s1, s2).at(ileft);
              return jcup$stack.reuse(106/*IfThenElseStatement*/, jcup$top - 6, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 206: // IfThenStatement ::= IF LPAREN Expression RPAREN Statement 
            {
        Tree RESULT = null;
        Object i = (Object)$stack[jcup$top-4].value;
        Tree e = (Tree)$stack[jcup$top-2].value;
        Tree s = (Tree)$stack[jcup$top].value;
        int ileft = $stack[jcup$top-4].left;
        
            RESULT = make.If(e, s, null).at(ileft);
              return jcup$stack.reuse(105/*IfThenStatement*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 205: // StatementExpression ::= ClassInstanceCreationExpression 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
        int eleft = $stack[jcup$top].left;
        
            RESULT = make.Exec(e).at(eleft);
              return jcup$stack.reuse(104/*StatementExpression*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 204: // StatementExpression ::= MethodInvocation 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
        int eleft = $stack[jcup$top].left;
         RESULT = make.Exec(e).at(eleft);
              return jcup$stack.reuse(104/*StatementExpression*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 203: // StatementExpression ::= PostDecrementExpression 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
        int eleft = $stack[jcup$top].left;
         RESULT = make.Exec(e).at(eleft);
              return jcup$stack.reuse(104/*StatementExpression*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 202: // StatementExpression ::= PostIncrementExpression 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
        int eleft = $stack[jcup$top].left;
         RESULT = make.Exec(e).at(eleft);
              return jcup$stack.reuse(104/*StatementExpression*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 201: // StatementExpression ::= PreDecrementExpression 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
        int eleft = $stack[jcup$top].left;
         RESULT = make.Exec(e).at(eleft);
              return jcup$stack.reuse(104/*StatementExpression*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 200: // StatementExpression ::= PreIncrementExpression 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
        int eleft = $stack[jcup$top].left;
         RESULT = make.Exec(e).at(eleft);
              return jcup$stack.reuse(104/*StatementExpression*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 199: // StatementExpression ::= Assignment 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top].value;
        int eleft = $stack[jcup$top].left;
         RESULT = make.Exec(e).at(eleft);
              return jcup$stack.reuse(104/*StatementExpression*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 198: // ExpressionStatement ::= StatementExpression SEMI 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-1].value;
         RESULT = e;
              return jcup$stack.reuse(103/*ExpressionStatement*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 197: // LabeledStatementNoShortIf ::= IDENTIFIER COLON StatementNoShortIf 
            {
        Tree RESULT = null;
        Name n = (Name)$stack[jcup$top-2].value;
        Object c = (Object)$stack[jcup$top-1].value;
        Tree s = (Tree)$stack[jcup$top].value;
        int cleft = $stack[jcup$top-1].left;
        
            RESULT = make.Labelled(n, s).at(cleft);
              return jcup$stack.reuse(102/*LabeledStatementNoShortIf*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 196: // LabeledStatement ::= IDENTIFIER COLON Statement 
            {
        Tree RESULT = null;
        Name n = (Name)$stack[jcup$top-2].value;
        Object c = (Object)$stack[jcup$top-1].value;
        Tree s = (Tree)$stack[jcup$top].value;
        int cleft = $stack[jcup$top-1].left;
        
            RESULT = make.Labelled(n, s).at(cleft);
              return jcup$stack.reuse(101/*LabeledStatement*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 195: // EmptyStatement ::= SEMI 
            {
        Tree RESULT = null;
        RESULT = null;
              return jcup$stack.reuse(97/*EmptyStatement*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 194: // AssertStatement ::= ASSERT Expression COLON Expression SEMI 
            {
        Tree RESULT = null;
        Object a = (Object)$stack[jcup$top-4].value;
        Tree e = (Tree)$stack[jcup$top-3].value;
        Tree f = (Tree)$stack[jcup$top-1].value;
        int aleft = $stack[jcup$top-4].left;
        
            RESULT = make.Assert(e, f).at(aleft);
              return jcup$stack.reuse(151/*AssertStatement*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 193: // AssertStatement ::= ASSERT Expression SEMI 
            {
        Tree RESULT = null;
        Object a = (Object)$stack[jcup$top-2].value;
        Tree e = (Tree)$stack[jcup$top-1].value;
        int aleft = $stack[jcup$top-2].left;
        
            RESULT = make.Assert(e, null).at(aleft);
              return jcup$stack.reuse(151/*AssertStatement*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 192: // StatementWithoutTrailingSubstatement ::= AssertStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 191: // StatementWithoutTrailingSubstatement ::= EmptyStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 190: // StatementWithoutTrailingSubstatement ::= TryStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 189: // StatementWithoutTrailingSubstatement ::= ThrowStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 188: // StatementWithoutTrailingSubstatement ::= SynchronizedStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 187: // StatementWithoutTrailingSubstatement ::= ReturnStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 186: // StatementWithoutTrailingSubstatement ::= ContinueStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 185: // StatementWithoutTrailingSubstatement ::= BreakStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 184: // StatementWithoutTrailingSubstatement ::= DoStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 183: // StatementWithoutTrailingSubstatement ::= SwitchStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 182: // StatementWithoutTrailingSubstatement ::= ExpressionStatement 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 181: // StatementWithoutTrailingSubstatement ::= Block 
            {
              return jcup$stack.reuse(100/*StatementWithoutTrailingSubstatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 180: // StatementNoShortIf ::= ForStatementNoShortIf 
            {
              return jcup$stack.reuse(99/*StatementNoShortIf*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 179: // StatementNoShortIf ::= WhileStatementNoShortIf 
            {
              return jcup$stack.reuse(99/*StatementNoShortIf*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 178: // StatementNoShortIf ::= IfThenElseStatementNoShortIf 
            {
              return jcup$stack.reuse(99/*StatementNoShortIf*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 177: // StatementNoShortIf ::= LabeledStatementNoShortIf 
            {
              return jcup$stack.reuse(99/*StatementNoShortIf*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 176: // StatementNoShortIf ::= StatementWithoutTrailingSubstatement 
            {
              return jcup$stack.reuse(99/*StatementNoShortIf*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 175: // Statement ::= ForStatement 
            {
              return jcup$stack.reuse(98/*Statement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 174: // Statement ::= WhileStatement 
            {
              return jcup$stack.reuse(98/*Statement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 173: // Statement ::= IfThenElseStatement 
            {
              return jcup$stack.reuse(98/*Statement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 172: // Statement ::= IfThenStatement 
            {
              return jcup$stack.reuse(98/*Statement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 171: // Statement ::= LabeledStatement 
            {
              return jcup$stack.reuse(98/*Statement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 170: // Statement ::= StatementWithoutTrailingSubstatement 
            {
              return jcup$stack.reuse(98/*Statement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 169: // LocalVariableDeclaration ::= Modifiers Type VariableDeclarators 
            {
        TreeList RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-2].value;
        Tree t = (Tree)$stack[jcup$top-1].value;
        TreeList ds = (TreeList)$stack[jcup$top].value;
        
            int     mods = m.intValue();
            Tree[]  decls = ds.toArray();
            for (int i = 0; i < decls.length; i++)
            {
                VarDecl vd = (VarDecl)decls[i]; // fix declarations
                vd.mods = mods;
                if (vd.vartype instanceof ArrayTypeTerm)
                    vd.name = ((Ident)replaceArrayType(
                                    (ArrayTypeTerm)vd.vartype, t)).name;
                else
                {
                    vd.name = ((Ident)vd.vartype).name;
                    vd.vartype = t;
                }
            }
            RESULT = ds;
              return jcup$stack.reuse(41/*LocalVariableDeclaration*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 168: // LocalVariableDeclaration ::= Type VariableDeclarators 
            {
        TreeList RESULT = null;
        Tree t = (Tree)$stack[jcup$top-1].value;
        TreeList ds = (TreeList)$stack[jcup$top].value;
        
            Tree[]  decls = ds.toArray();
            for (int i = 0; i < decls.length; i++)
            {
                VarDecl vd = (VarDecl)decls[i]; // fix declarations
                if (vd.vartype instanceof ArrayTypeTerm)
                    vd.name = ((Ident)replaceArrayType(
                                    (ArrayTypeTerm)vd.vartype, t)).name;
                else
                {
                    vd.name = ((Ident)vd.vartype).name;
                    vd.vartype = t;
                }
            }
            RESULT = ds;
              return jcup$stack.reuse(41/*LocalVariableDeclaration*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 167: // LocalVariableDeclarationStatement ::= LocalVariableDeclaration SEMI 
            {
        TreeList RESULT = null;
        TreeList d = (TreeList)$stack[jcup$top-1].value;
         RESULT = d;
              return jcup$stack.reuse(39/*LocalVariableDeclarationStatement*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 166: // BlockStatement ::= RecoverAtSemi 
            {
        TreeList RESULT = null;
        Tree err = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(err);
              return jcup$stack.reuse(37/*BlockStatement*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 165: // BlockStatement ::= NestedClassDeclaration 
            {
        TreeList RESULT = null;
        ClassDecl s = (ClassDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(s);
              return jcup$stack.reuse(37/*BlockStatement*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 164: // BlockStatement ::= Statement 
            {
        TreeList RESULT = null;
        Tree s = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(s);
              return jcup$stack.reuse(37/*BlockStatement*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 163: // BlockStatement ::= LocalVariableDeclarationStatement 
            {
              return jcup$stack.reuse(37/*BlockStatement*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 162: // BlockStatements ::= BlockStatements BlockStatement 
            {
        TreeList RESULT = null;
        TreeList bs = (TreeList)$stack[jcup$top-1].value;
        TreeList b = (TreeList)$stack[jcup$top].value;
         RESULT = bs.append(b);
              return jcup$stack.reuse(36/*BlockStatements*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 161: // BlockStatements ::= BlockStatement 
            {
              return jcup$stack.reuse(36/*BlockStatements*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 160: // BlockStatementsopt ::= BlockStatements 
            {
              return jcup$stack.reuse(42/*BlockStatementsopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 159: // BlockStatementsopt ::= 
            {
        TreeList RESULT = null;
        RESULT = trees.TreeList();
              return new org.zenger.jcup.runtime.Symbol(42/*BlockStatementsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 158: // Block ::= LBRACE RecoverAtBrace 
            {
        Tree RESULT = null;
        Tree err = (Tree)$stack[jcup$top].value;
        int errleft = $stack[jcup$top].left;
        
            RESULT = make.Block(0, new Tree[]{err}).at(errleft);
              return jcup$stack.reuse(96/*Block*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 157: // Block ::= LBRACE BlockStatementsopt RBRACE 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-2].value;
        TreeList bs = (TreeList)$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Block(0, bs.toArray()).at(lleft);
              return jcup$stack.reuse(96/*Block*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 156: // VariableInitializers ::= VariableInitializers COMMA VariableInitializer 
            {
        TreeList RESULT = null;
        TreeList vs = (TreeList)$stack[jcup$top-2].value;
        Tree v = (Tree)$stack[jcup$top].value;
        
            RESULT = vs.append(v);
              return jcup$stack.reuse(35/*VariableInitializers*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 155: // VariableInitializers ::= VariableInitializer 
            {
        TreeList RESULT = null;
        Tree v = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(v);
              return jcup$stack.reuse(35/*VariableInitializers*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 154: // ArrayInitializer ::= LBRACE RecoverAtBrace 
            {
        Tree RESULT = null;
        Tree err = (Tree)$stack[jcup$top].value;
         RESULT = err;
              return jcup$stack.reuse(95/*ArrayInitializer*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 153: // ArrayInitializer ::= LBRACE VariableInitializers COMMA RBRACE 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-3].value;
        TreeList vs = (TreeList)$stack[jcup$top-2].value;
        int lleft = $stack[jcup$top-3].left;
        
            RESULT = make.Aggregate(vs.toArray(), null).at(lleft);
              return jcup$stack.reuse(95/*ArrayInitializer*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 152: // ArrayInitializer ::= LBRACE VariableInitializers RBRACE 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-2].value;
        TreeList vs = (TreeList)$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Aggregate(vs.toArray(), null).at(lleft);
              return jcup$stack.reuse(95/*ArrayInitializer*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 151: // ArrayInitializer ::= LBRACE COMMA RBRACE 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-2].value;
        int lleft = $stack[jcup$top-2].left;
        
            RESULT = make.Aggregate(trees.noTrees, null).at(lleft);
              return jcup$stack.reuse(95/*ArrayInitializer*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 150: // ArrayInitializer ::= LBRACE RBRACE 
            {
        Tree RESULT = null;
        Object l = (Object)$stack[jcup$top-1].value;
        int lleft = $stack[jcup$top-1].left;
        
            RESULT = make.Aggregate(trees.noTrees, null).at(lleft);
              return jcup$stack.reuse(95/*ArrayInitializer*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 149: // AbstractMethodDeclaration ::= MethodHeader SEMI 
            {
        MethodDecl RESULT = null;
        MethodDecl m = (MethodDecl)$stack[jcup$top-1].value;
         RESULT = m;
              return jcup$stack.reuse(15/*AbstractMethodDeclaration*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 148: // ConstantDeclaration ::= FieldDeclaration 
            {
              return jcup$stack.reuse(34/*ConstantDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 147: // InterfaceMemberDeclaration ::= NestedInterfaceDeclaration 
            {
        TreeList RESULT = null;
        ClassDecl d = (ClassDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(33/*InterfaceMemberDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 146: // InterfaceMemberDeclaration ::= NestedClassDeclaration 
            {
        TreeList RESULT = null;
        ClassDecl d = (ClassDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(33/*InterfaceMemberDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 145: // InterfaceMemberDeclaration ::= AbstractMethodDeclaration 
            {
        TreeList RESULT = null;
        MethodDecl d = (MethodDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(33/*InterfaceMemberDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 144: // InterfaceMemberDeclaration ::= ConstantDeclaration 
            {
              return jcup$stack.reuse(33/*InterfaceMemberDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 143: // InterfaceMemberDeclarations ::= InterfaceMemberDeclarations InterfaceMemberDeclaration 
            {
        TreeList RESULT = null;
        TreeList ds = (TreeList)$stack[jcup$top-1].value;
        TreeList d = (TreeList)$stack[jcup$top].value;
        
            RESULT = ds.append(d);
              return jcup$stack.reuse(32/*InterfaceMemberDeclarations*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 142: // InterfaceMemberDeclarations ::= InterfaceMemberDeclaration 
            {
              return jcup$stack.reuse(32/*InterfaceMemberDeclarations*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 141: // InterfaceMemberDeclarationsopt ::= InterfaceMemberDeclarations 
            {
        Tree[] RESULT = null;
        TreeList is = (TreeList)$stack[jcup$top].value;
         RESULT = is.toArray();
              return jcup$stack.reuse(59/*InterfaceMemberDeclarationsopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 140: // InterfaceMemberDeclarationsopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(59/*InterfaceMemberDeclarationsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 139: // InterfaceBody ::= LBRACE RecoverAtBrace 
            {
        Tree[] RESULT = null;
        Tree err = (Tree)$stack[jcup$top].value;
         RESULT = new Tree[]{err};
              return jcup$stack.reuse(58/*InterfaceBody*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 138: // InterfaceBody ::= LBRACE InterfaceMemberDeclarationsopt RBRACE 
            {
        Tree[] RESULT = null;
        Tree[] is = (Tree[])$stack[jcup$top-1].value;
         RESULT = is;
              return jcup$stack.reuse(58/*InterfaceBody*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 137: // ExtendsInterfaces ::= ExtendsInterfaces COMMA ClassOrInterfaceType 
            {
        TreeList RESULT = null;
        TreeList ts = (TreeList)$stack[jcup$top-2].value;
        Tree t = (Tree)$stack[jcup$top].value;
        
            RESULT = ts.append(t);
              return jcup$stack.reuse(30/*ExtendsInterfaces*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 136: // ExtendsInterfaces ::= EXTENDS ClassOrInterfaceType 
            {
        TreeList RESULT = null;
        Tree t = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(t);
              return jcup$stack.reuse(30/*ExtendsInterfaces*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 135: // ExtendsInterfacesopt ::= ExtendsInterfaces 
            {
        Tree[] RESULT = null;
        TreeList is = (TreeList)$stack[jcup$top].value;
         RESULT = is.toArray();
              return jcup$stack.reuse(57/*ExtendsInterfacesopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 134: // ExtendsInterfacesopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(57/*ExtendsInterfacesopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 133: // NestedInterfaceDeclaration ::= Modifiersopt INTERFACE IDENTIFIER ExtendsInterfacesopt InterfaceBody 
            {
        ClassDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-4].value;
        Name n = (Name)$stack[jcup$top-2].value;
        Tree[] e = (Tree[])$stack[jcup$top-1].value;
        Tree[] s = (Tree[])$stack[jcup$top].value;
        int mleft = $stack[jcup$top-4].left;
        
            RESULT = (ClassDecl)make.ClassDecl(n,
                        m.intValue() | ModifierConst.INTERFACE,
                        null, e, s).at(mleft);
              return jcup$stack.reuse(9/*NestedInterfaceDeclaration*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 132: // InterfaceDeclaration ::= Modifiersopt INTERFACE IDENTIFIER ExtendsInterfacesopt InterfaceBody 
            {
        ClassDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-4].value;
        Name n = (Name)$stack[jcup$top-2].value;
        Tree[] e = (Tree[])$stack[jcup$top-1].value;
        Tree[] ds = (Tree[])$stack[jcup$top].value;
        int mleft = $stack[jcup$top-4].left;
        int nleft = $stack[jcup$top-2].left;
        
            /* Tree[] ts = new Tree[ds.length + 1];
            System.arraycopy(ds, 0, ts, 1, ds.length);
            ts[0] = make.VarDecl(
                jaco.java.component.BytecodeGenerator.ASSERTIONS_ENABLED,
                ModifierConst.STATIC |
                ModifierConst.FINAL | ModifierConst.SYNTHETIC,
                make.BasicType(TypeConst.BOOLEAN).at(nleft),
                make.Ident(PredefConst.TRUE_N).at(nleft)).at(nleft); */
            RESULT = (ClassDecl)make.ClassDecl(n,
                        m.intValue() | ModifierConst.INTERFACE,
                        null, e, ds).at(mleft);
              return jcup$stack.reuse(8/*InterfaceDeclaration*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 131: // ExplicitConstructorInvocation ::= Primary DOT SUPER LPAREN ArgumentListopt RPAREN SEMI 
            {
        Tree RESULT = null;
        Tree p = (Tree)$stack[jcup$top-6].value;
        Object s = (Object)$stack[jcup$top-4].value;
        Tree[] a = (Tree[])$stack[jcup$top-2].value;
        int pleft = $stack[jcup$top-6].left;
        int sleft = $stack[jcup$top-4].left;
        int aleft = $stack[jcup$top-2].left;
        
            RESULT = make.Exec(
                        make.Apply(make.Self(p, TreeConst.SUPER).at(sleft), a).at(aleft)).
                     at(pleft);
              return jcup$stack.reuse(94/*ExplicitConstructorInvocation*/, jcup$top - 6, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 130: // ExplicitConstructorInvocation ::= SUPER LPAREN ArgumentListopt RPAREN SEMI 
            {
        Tree RESULT = null;
        Object s = (Object)$stack[jcup$top-4].value;
        Tree[] a = (Tree[])$stack[jcup$top-2].value;
        int sleft = $stack[jcup$top-4].left;
        int aleft = $stack[jcup$top-2].left;
        
            RESULT = make.Exec(
                        make.Apply(trees.Super().at(sleft), a).at(aleft)).
                     at(sleft);
              return jcup$stack.reuse(94/*ExplicitConstructorInvocation*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 129: // ExplicitConstructorInvocation ::= THIS LPAREN ArgumentListopt RPAREN SEMI 
            {
        Tree RESULT = null;
        Object s = (Object)$stack[jcup$top-4].value;
        Tree[] a = (Tree[])$stack[jcup$top-2].value;
        int sleft = $stack[jcup$top-4].left;
        int aleft = $stack[jcup$top-2].left;
        
            RESULT = make.Exec(
                        make.Apply(trees.This().at(sleft), a).at(aleft)).
                     at(sleft);
              return jcup$stack.reuse(94/*ExplicitConstructorInvocation*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 128: // ConstructorBody ::= LBRACE RecoverAtBrace 
            {
        Tree[] RESULT = null;
        Tree err = (Tree)$stack[jcup$top].value;
        
            RESULT = new Tree[]{err};
              return jcup$stack.reuse(51/*ConstructorBody*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 127: // ConstructorBody ::= LBRACE ExplicitConstructorInvocation BlockStatementsopt RBRACE 
            {
        Tree[] RESULT = null;
        Tree c = (Tree)$stack[jcup$top-2].value;
        TreeList s = (TreeList)$stack[jcup$top-1].value;
        
                RESULT = s.prepend(c).toArray();
              return jcup$stack.reuse(51/*ConstructorBody*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 126: // ConstructorBody ::= LBRACE BlockStatementsopt RBRACE 
            {
        Tree[] RESULT = null;
        Object a = (Object)$stack[jcup$top-2].value;
        TreeList s = (TreeList)$stack[jcup$top-1].value;
        
            RESULT = s.toArray();
              return jcup$stack.reuse(51/*ConstructorBody*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 125: // ConstructorDeclarator ::= SimpleName LPAREN RecoverAtParen 
            {
        MethodDecl RESULT = null;
        Name s = (Name)$stack[jcup$top-2].value;
        int sleft = $stack[jcup$top-2].left;
        
            RESULT = (MethodDecl)make.MethodDecl(s, 0, null, null, null, null).
                                            at(sleft);
              return jcup$stack.reuse(14/*ConstructorDeclarator*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 124: // ConstructorDeclarator ::= SimpleName LPAREN FormalParameterListopt RPAREN 
            {
        MethodDecl RESULT = null;
        Name s = (Name)$stack[jcup$top-3].value;
        VarDecl[] f = (VarDecl[])$stack[jcup$top-1].value;
        int sleft = $stack[jcup$top-3].left;
        
            RESULT = (MethodDecl)make.MethodDecl(s, 0, null, f, null, null).
                                            at(sleft);
              return jcup$stack.reuse(14/*ConstructorDeclarator*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 123: // ConstructorDeclaration ::= Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody 
            {
        MethodDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-3].value;
        MethodDecl c = (MethodDecl)$stack[jcup$top-2].value;
        Tree[] t = (Tree[])$stack[jcup$top-1].value;
        Tree[] s = (Tree[])$stack[jcup$top].value;
        
            // fix constructor declaration
            c.mods = m.intValue();
            c.thrown = t;
            c.stats = s;
            RESULT = c;
              return jcup$stack.reuse(13/*ConstructorDeclaration*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 122: // StaticInitializer ::= STATIC Block 
            {
        Tree RESULT = null;
        Tree s = (Tree)$stack[jcup$top].value;
        
            ((Block)s).mods |= ModifierConst.STATIC;
            RESULT = s;
              return jcup$stack.reuse(92/*StaticInitializer*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 121: // MethodBody ::= SEMI 
            {
        Tree[] RESULT = null;
        RESULT = null;
              return jcup$stack.reuse(54/*MethodBody*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 120: // MethodBody ::= Block 
            {
        Tree[] RESULT = null;
        Tree s = (Tree)$stack[jcup$top].value;
         RESULT = ((Block)s).stats;
              return jcup$stack.reuse(54/*MethodBody*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 119: // ClassTypeList ::= ClassTypeList COMMA ClassOrInterfaceType 
            {
        TreeList RESULT = null;
        TreeList ts = (TreeList)$stack[jcup$top-2].value;
        Tree t = (Tree)$stack[jcup$top].value;
        
            RESULT = ts.append(t);
              return jcup$stack.reuse(29/*ClassTypeList*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 118: // ClassTypeList ::= ClassOrInterfaceType 
            {
        TreeList RESULT = null;
        Tree t = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(t);
              return jcup$stack.reuse(29/*ClassTypeList*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 117: // Throws ::= THROWS ClassTypeList 
            {
        Tree[] RESULT = null;
        TreeList ts = (TreeList)$stack[jcup$top].value;
         RESULT = ts.toArray();
              return jcup$stack.reuse(56/*Throws*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 116: // Throwsopt ::= Throws 
            {
              return jcup$stack.reuse(55/*Throwsopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 115: // Throwsopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(55/*Throwsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 114: // FormalParameter ::= Modifiers Type VariableDeclaratorId 
            {
        VarDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-2].value;
        Tree t = (Tree)$stack[jcup$top-1].value;
        Tree v = (Tree)$stack[jcup$top].value;
        int mleft = $stack[jcup$top-2].left;
        
            if (v instanceof ArrayTypeTerm)
            {
                RESULT = (VarDecl)make.VarDecl(((Ident)
                                replaceArrayType((ArrayTypeTerm)v, t)).name,
                                        m.intValue(), v, null).at(mleft);
            }
            else
                RESULT = (VarDecl)make.VarDecl(((Ident)v).name,
                                m.intValue(), t, null).at(mleft);
              return jcup$stack.reuse(16/*FormalParameter*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 113: // FormalParameter ::= Type VariableDeclaratorId 
            {
        VarDecl RESULT = null;
        Tree t = (Tree)$stack[jcup$top-1].value;
        Tree v = (Tree)$stack[jcup$top].value;
        int tleft = $stack[jcup$top-1].left;
        
            if (v instanceof ArrayTypeTerm)
            {
                RESULT = (VarDecl)make.VarDecl(((Ident)
                    replaceArrayType((ArrayTypeTerm)v, t)).name, 0, v, null).
                        at(tleft);
            }
            else
                RESULT = (VarDecl)make.VarDecl(((Ident)v).name, 0, t,
                    null).at(tleft);
              return jcup$stack.reuse(16/*FormalParameter*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 112: // FormalParameterList ::= RecoverAtComma FormalParameter 
            {
        TreeList RESULT = null;
        VarDecl f = (VarDecl)$stack[jcup$top].value;
        
            RESULT = trees.TreeList(f);
              return jcup$stack.reuse(38/*FormalParameterList*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 111: // FormalParameterList ::= FormalParameterList COMMA FormalParameter 
            {
        TreeList RESULT = null;
        TreeList fs = (TreeList)$stack[jcup$top-2].value;
        VarDecl f = (VarDecl)$stack[jcup$top].value;
        
            RESULT = fs.append(f);
              return jcup$stack.reuse(38/*FormalParameterList*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 110: // FormalParameterList ::= FormalParameter 
            {
        TreeList RESULT = null;
        VarDecl f = (VarDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(f);
              return jcup$stack.reuse(38/*FormalParameterList*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 109: // FormalParameterListopt ::= FormalParameterList 
            {
        VarDecl[] RESULT = null;
        TreeList f = (TreeList)$stack[jcup$top].value;
         RESULT = varDeclArray(f.toArray());
              return jcup$stack.reuse(48/*FormalParameterListopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 108: // FormalParameterListopt ::= 
            {
        VarDecl[] RESULT = null;
        RESULT = new VarDecl[0];
              return new org.zenger.jcup.runtime.Symbol(48/*FormalParameterListopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 107: // MethodDeclarator ::= IDENTIFIER LPAREN RecoverAtParen 
            {
        MethodDecl RESULT = null;
        Name n = (Name)$stack[jcup$top-2].value;
        int nleft = $stack[jcup$top-2].left;
        
            RESULT = (MethodDecl)make.MethodDecl(n, 0, null, null, null, null).
                                            at(nleft);
              return jcup$stack.reuse(12/*MethodDeclarator*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 106: // MethodDeclarator ::= MethodDeclarator LBRACKET RBRACKET 
            {
        MethodDecl RESULT = null;
        MethodDecl d = (MethodDecl)$stack[jcup$top-2].value;
        Object a = (Object)$stack[jcup$top-1].value;
        int aleft = $stack[jcup$top-1].left;
        
            d.restype = make.ArrayTypeTerm(d.restype).at(aleft);
            RESULT = d;
              return jcup$stack.reuse(12/*MethodDeclarator*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 105: // MethodDeclarator ::= IDENTIFIER LPAREN FormalParameterListopt RPAREN 
            {
        MethodDecl RESULT = null;
        Name n = (Name)$stack[jcup$top-3].value;
        VarDecl[] p = (VarDecl[])$stack[jcup$top-1].value;
        int nleft = $stack[jcup$top-3].left;
        
            RESULT = (MethodDecl)make.MethodDecl(n, 0, null, p, null, null).
                                            at(nleft);
              return jcup$stack.reuse(12/*MethodDeclarator*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 104: // MethodHeader ::= Modifiersopt VOID MethodDeclarator Throwsopt 
            {
        MethodDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-3].value;
        Object v = (Object)$stack[jcup$top-2].value;
        MethodDecl d = (MethodDecl)$stack[jcup$top-1].value;
        Tree[] e = (Tree[])$stack[jcup$top].value;
        int vleft = $stack[jcup$top-2].left;
        
            d.mods = m.intValue();
            if (d.restype instanceof ArrayTypeTerm)
                replaceArrayType((ArrayTypeTerm)d.restype,
                                make.BasicType(TypeConst.VOID).at(vleft));
            else
                d.restype = make.BasicType(TypeConst.VOID).at(vleft);
            d.thrown = e;
            RESULT = d;
              return jcup$stack.reuse(11/*MethodHeader*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 103: // MethodHeader ::= Modifiersopt Type MethodDeclarator Throwsopt 
            {
        MethodDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-3].value;
        Tree t = (Tree)$stack[jcup$top-2].value;
        MethodDecl d = (MethodDecl)$stack[jcup$top-1].value;
        Tree[] e = (Tree[])$stack[jcup$top].value;
        
            // fix method declaration
            d.mods = m.intValue();
            if (d.restype instanceof ArrayTypeTerm)
                replaceArrayType((ArrayTypeTerm)d.restype, t);
            else
                d.restype = t;
            d.thrown = e;
            RESULT = d;
              return jcup$stack.reuse(11/*MethodHeader*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 102: // MethodDeclaration ::= MethodHeader MethodBody 
            {
        MethodDecl RESULT = null;
        MethodDecl h = (MethodDecl)$stack[jcup$top-1].value;
        Tree[] s = (Tree[])$stack[jcup$top].value;
         h.stats = s; RESULT = h;
              return jcup$stack.reuse(10/*MethodDeclaration*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 101: // VariableInitializer ::= ArrayInitializer 
            {
              return jcup$stack.reuse(90/*VariableInitializer*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 100: // VariableInitializer ::= Expression 
            {
              return jcup$stack.reuse(90/*VariableInitializer*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 99: // VariableDeclaratorId ::= VariableDeclaratorId LBRACKET RBRACKET 
            {
        Tree RESULT = null;
        Tree n = (Tree)$stack[jcup$top-2].value;
        int nleft = $stack[jcup$top-2].left;
        
            RESULT = make.ArrayTypeTerm(n).at(nleft);
              return jcup$stack.reuse(91/*VariableDeclaratorId*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 98: // VariableDeclaratorId ::= IDENTIFIER 
            {
        Tree RESULT = null;
        Name n = (Name)$stack[jcup$top].value;
        int nleft = $stack[jcup$top].left;
         RESULT = make.Ident(n).at(nleft);
              return jcup$stack.reuse(91/*VariableDeclaratorId*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 97: // VariableDeclarator ::= VariableDeclaratorId EQ VariableInitializer 
            {
        VarDecl RESULT = null;
        Tree n = (Tree)$stack[jcup$top-2].value;
        Tree i = (Tree)$stack[jcup$top].value;
        int nleft = $stack[jcup$top-2].left;
        
            RESULT = (VarDecl)make.VarDecl(null, 0, n, i).at(nleft);
              return jcup$stack.reuse(17/*VariableDeclarator*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 96: // VariableDeclarator ::= VariableDeclaratorId 
            {
        VarDecl RESULT = null;
        Tree n = (Tree)$stack[jcup$top].value;
        int nleft = $stack[jcup$top].left;
        
            RESULT = (VarDecl)make.VarDecl(null, 0, n, null).at(nleft);
              return jcup$stack.reuse(17/*VariableDeclarator*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 95: // VariableDeclarators ::= VariableDeclarators COMMA VariableDeclarator 
            {
        TreeList RESULT = null;
        TreeList vs = (TreeList)$stack[jcup$top-2].value;
        VarDecl v = (VarDecl)$stack[jcup$top].value;
        
            RESULT = vs.append(v);
              return jcup$stack.reuse(28/*VariableDeclarators*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 94: // VariableDeclarators ::= VariableDeclarator 
            {
        TreeList RESULT = null;
        VarDecl v = (VarDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(v);
              return jcup$stack.reuse(28/*VariableDeclarators*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 93: // FieldDeclaration ::= Modifiersopt Type VariableDeclarators SEMI 
            {
        TreeList RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-3].value;
        Tree t = (Tree)$stack[jcup$top-2].value;
        TreeList ds = (TreeList)$stack[jcup$top-1].value;
        
            int     mods = m.intValue();
            Tree[]  decls = ds.toArray();
            for (int i = 0; i < decls.length; i++)
            {
                VarDecl vd = (VarDecl)decls[i]; // fix declarations
                vd.mods = mods;
                if (vd.vartype instanceof ArrayTypeTerm)
                    vd.name = ((Ident)replaceArrayType(
                                    (ArrayTypeTerm)vd.vartype, t)).name;
                else
                {
                    vd.name = ((Ident)vd.vartype).name;
                    vd.vartype = t;
                }
            }
            RESULT = ds;
              return jcup$stack.reuse(27/*FieldDeclaration*/, jcup$top - 3, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 92: // InnerClassDeclaration ::= NestedInterfaceDeclaration 
            {
              return jcup$stack.reuse(144/*InnerClassDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 91: // InnerClassDeclaration ::= NestedClassDeclaration 
            {
              return jcup$stack.reuse(144/*InnerClassDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 90: // ClassMemberDeclaration ::= InnerClassDeclaration 
            {
        TreeList RESULT = null;
        Tree d = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(31/*ClassMemberDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 89: // ClassMemberDeclaration ::= MethodDeclaration 
            {
        TreeList RESULT = null;
        MethodDecl d = (MethodDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(31/*ClassMemberDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 88: // ClassMemberDeclaration ::= FieldDeclaration 
            {
              return jcup$stack.reuse(31/*ClassMemberDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 87: // ClassBodyDeclaration ::= Block 
            {
        TreeList RESULT = null;
        Tree d = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(26/*ClassBodyDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 86: // ClassBodyDeclaration ::= ConstructorDeclaration 
            {
        TreeList RESULT = null;
        MethodDecl d = (MethodDecl)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(26/*ClassBodyDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 85: // ClassBodyDeclaration ::= StaticInitializer 
            {
        TreeList RESULT = null;
        Tree d = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(26/*ClassBodyDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 84: // ClassBodyDeclaration ::= ClassMemberDeclaration 
            {
              return jcup$stack.reuse(26/*ClassBodyDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 83: // ClassBodyDeclarations ::= ClassBodyDeclarations ClassBodyDeclaration 
            {
        TreeList RESULT = null;
        TreeList ds = (TreeList)$stack[jcup$top-1].value;
        TreeList d = (TreeList)$stack[jcup$top].value;
        
            RESULT = ds.append(d);
              return jcup$stack.reuse(25/*ClassBodyDeclarations*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 82: // ClassBodyDeclarations ::= ClassBodyDeclaration 
            {
              return jcup$stack.reuse(25/*ClassBodyDeclarations*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 81: // ClassBodyDeclarationsopt ::= ClassBodyDeclarations 
            {
        Tree[] RESULT = null;
        TreeList ds = (TreeList)$stack[jcup$top].value;
         RESULT = ds.toArray();
              return jcup$stack.reuse(52/*ClassBodyDeclarationsopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 80: // ClassBodyDeclarationsopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(52/*ClassBodyDeclarationsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 79: // ClassBody ::= LBRACE RecoverAtBrace 
            {
        Tree[] RESULT = null;
        Tree err = (Tree)$stack[jcup$top].value;
         RESULT = new Tree[]{err};
              return jcup$stack.reuse(53/*ClassBody*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 78: // ClassBody ::= LBRACE ClassBodyDeclarationsopt RBRACE 
            {
        Tree[] RESULT = null;
        Tree[] ds = (Tree[])$stack[jcup$top-1].value;
         RESULT = ds;
              return jcup$stack.reuse(53/*ClassBody*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 77: // InterfaceTypeList ::= InterfaceTypeList COMMA ClassOrInterfaceType 
            {
        TreeList RESULT = null;
        TreeList is = (TreeList)$stack[jcup$top-2].value;
        Tree i = (Tree)$stack[jcup$top].value;
        
            RESULT = is.append(i);
              return jcup$stack.reuse(24/*InterfaceTypeList*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 76: // InterfaceTypeList ::= ClassOrInterfaceType 
            {
        TreeList RESULT = null;
        Tree i = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(i);
              return jcup$stack.reuse(24/*InterfaceTypeList*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 75: // Interfaces ::= IMPLEMENTS InterfaceTypeList 
            {
        Tree[] RESULT = null;
        TreeList i = (TreeList)$stack[jcup$top].value;
         RESULT = i.toArray();
              return jcup$stack.reuse(50/*Interfaces*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 74: // Interfacesopt ::= Interfaces 
            {
              return jcup$stack.reuse(49/*Interfacesopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 73: // Interfacesopt ::= 
            {
        Tree[] RESULT = null;
        RESULT = trees.noTrees;
              return new org.zenger.jcup.runtime.Symbol(49/*Interfacesopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 72: // Super ::= EXTENDS ClassOrInterfaceType 
            {
        Tree RESULT = null;
        Tree s = (Tree)$stack[jcup$top].value;
         RESULT = s;
              return jcup$stack.reuse(89/*Super*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 71: // Superopt ::= Super 
            {
              return jcup$stack.reuse(88/*Superopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 70: // Superopt ::= 
            {
        Tree RESULT = null;
        RESULT = null;
              return new org.zenger.jcup.runtime.Symbol(88/*Superopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 69: // NestedClassDeclaration ::= Modifiersopt CLASS IDENTIFIER Superopt Interfacesopt ClassBody 
            {
        ClassDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-5].value;
        Name n = (Name)$stack[jcup$top-3].value;
        Tree s = (Tree)$stack[jcup$top-2].value;
        Tree[] i = (Tree[])$stack[jcup$top-1].value;
        Tree[] ds = (Tree[])$stack[jcup$top].value;
        int mleft = $stack[jcup$top-5].left;
        
            RESULT = (ClassDecl)make.ClassDecl(n, m.intValue(), s, i, ds).
                        at(mleft);
              return jcup$stack.reuse(7/*NestedClassDeclaration*/, jcup$top - 5, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 68: // ClassDeclaration ::= Modifiersopt CLASS IDENTIFIER Superopt Interfacesopt ClassBody 
            {
        ClassDecl RESULT = null;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top-5].value;
        Name n = (Name)$stack[jcup$top-3].value;
        Tree s = (Tree)$stack[jcup$top-2].value;
        Tree[] i = (Tree[])$stack[jcup$top-1].value;
        Tree[] ds = (Tree[])$stack[jcup$top].value;
        int mleft = $stack[jcup$top-5].left;
        int nleft = $stack[jcup$top-3].left;
        
            /* Tree[] ts = new Tree[ds.length + 1];
            System.arraycopy(ds, 0, ts, 1, ds.length);
            ts[0] = make.VarDecl(
                jaco.java.component.BytecodeGenerator.ASSERTIONS_ENABLED,
                ModifierConst.PRIVATE | ModifierConst.STATIC |
                ModifierConst.FINAL | ModifierConst.SYNTHETIC,
                make.BasicType(TypeConst.BOOLEAN).at(nleft),
                make.Ident(PredefConst.TRUE_N).at(nleft)).at(nleft); */
            RESULT = (ClassDecl)make.ClassDecl(n, m.intValue(), s, i, ds).
                        at(mleft);
              return jcup$stack.reuse(6/*ClassDeclaration*/, jcup$top - 5, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 67: // Modifier ::= STRICTFP 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.STRICTFP);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 66: // Modifier ::= VOLATILE 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.VOLATILE);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 65: // Modifier ::= TRANSIENT 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.TRANSIENT);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 64: // Modifier ::= SYNCHRONIZED 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.SYNCHRONIZED);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 63: // Modifier ::= NATIVE 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.NATIVE);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 62: // Modifier ::= FINAL 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.FINAL);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 61: // Modifier ::= ABSTRACT 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.ABSTRACT);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 60: // Modifier ::= STATIC 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.STATIC);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 59: // Modifier ::= PRIVATE 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.PRIVATE);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 58: // Modifier ::= PROTECTED 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.PROTECTED);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 57: // Modifier ::= PUBLIC 
            {
        Modifiers.Wrapper RESULT = null;
        RESULT = trees.Modifiers(ModifierConst.PUBLIC);
              return jcup$stack.reuse(5/*Modifier*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 56: // Modifiers ::= Modifiers Modifier 
            {
        Modifiers.Wrapper RESULT = null;
        Modifiers.Wrapper mods = (Modifiers.Wrapper)$stack[jcup$top-1].value;
        Modifiers.Wrapper m = (Modifiers.Wrapper)$stack[jcup$top].value;
         RESULT = mods.add(m);
              return jcup$stack.reuse(4/*Modifiers*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 55: // Modifiers ::= Modifier 
            {
              return jcup$stack.reuse(4/*Modifiers*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 54: // Modifiersopt ::= Modifiers 
            {
        Modifiers.Wrapper RESULT = null;
        Modifiers.Wrapper mods = (Modifiers.Wrapper)$stack[jcup$top].value;
        
            lexer.metaContent = null;
            if (lexer.deprecatedFlag)
            {
                lexer.deprecatedFlag = false;
                RESULT = mods.add(ModifierConst.DEPRECATED);
            }
            else
                    RESULT = mods;
              return jcup$stack.reuse(3/*Modifiersopt*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 53: // Modifiersopt ::= 
            {
        Modifiers.Wrapper RESULT = null;
        lexer.metaContent = null;
            if (lexer.deprecatedFlag)
            {
                lexer.deprecatedFlag = false;
                RESULT = trees.Modifiers(ModifierConst.DEPRECATED);
            }
            else
                RESULT = trees.Modifiers(0);
              return new org.zenger.jcup.runtime.Symbol(3/*Modifiersopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 52: // TypeDeclaration ::= RecoverAtBrace 
            {
              return jcup$stack.reuse(87/*TypeDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 51: // TypeDeclaration ::= SEMI 
            {
        Tree RESULT = null;
        RESULT = null;
              return jcup$stack.reuse(87/*TypeDeclaration*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 50: // TypeDeclaration ::= InterfaceDeclaration 
            {
              return jcup$stack.reuse(87/*TypeDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 49: // TypeDeclaration ::= ClassDeclaration 
            {
              return jcup$stack.reuse(87/*TypeDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 48: // TypeImportOnDemandDeclaration ::= IMPORT Name DOT STAR SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-4].value;
        Tree n = (Tree)$stack[jcup$top-3].value;
        int kleft = $stack[jcup$top-4].left;
        
            RESULT = make.Import(TreeConst.IMPORTSTAR, n).at(kleft);
              return jcup$stack.reuse(86/*TypeImportOnDemandDeclaration*/, jcup$top - 4, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 47: // SingleTypeImportDeclaration ::= IMPORT Name SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-2].value;
        Tree n = (Tree)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-2].left;
        
            RESULT = make.Import(TreeConst.IMPORT, n).at(kleft);
              return jcup$stack.reuse(85/*SingleTypeImportDeclaration*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 46: // ImportDeclaration ::= TypeImportOnDemandDeclaration 
            {
              return jcup$stack.reuse(84/*ImportDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 45: // ImportDeclaration ::= SingleTypeImportDeclaration 
            {
              return jcup$stack.reuse(84/*ImportDeclaration*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 44: // PackageDeclaration ::= PACKAGE Name SEMI 
            {
        Tree RESULT = null;
        Object k = (Object)$stack[jcup$top-2].value;
        Tree n = (Tree)$stack[jcup$top-1].value;
        int kleft = $stack[jcup$top-2].left;
        
            RESULT = make.PackageDecl(n).at(kleft);
              return jcup$stack.reuse(83/*PackageDeclaration*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 43: // PackageDeclarationopt ::= PackageDeclaration 
            {
              return jcup$stack.reuse(82/*PackageDeclarationopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 42: // PackageDeclarationopt ::= 
            {
        Tree RESULT = null;
        RESULT = null;
              return new org.zenger.jcup.runtime.Symbol(82/*PackageDeclarationopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 41: // TypeDeclarations ::= TypeDeclaration TypeDeclarations 
            {
        TreeList RESULT = null;
        Tree d = (Tree)$stack[jcup$top-1].value;
        TreeList ds = (TreeList)$stack[jcup$top].value;
        
            RESULT = ds.prepend(d);
              return jcup$stack.reuse(23/*TypeDeclarations*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 40: // TypeDeclarations ::= TypeDeclaration 
            {
        TreeList RESULT = null;
        Tree d = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(d);
              return jcup$stack.reuse(23/*TypeDeclarations*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 39: // TypeDeclarationsopt ::= TypeDeclarations 
            {
              return jcup$stack.reuse(21/*TypeDeclarationsopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 38: // TypeDeclarationsopt ::= 
            {
        TreeList RESULT = null;
        RESULT = trees.TreeList();
              return new org.zenger.jcup.runtime.Symbol(21/*TypeDeclarationsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 37: // ImportDeclarations ::= ImportDeclaration ImportDeclarations 
            {
        TreeList RESULT = null;
        Tree i = (Tree)$stack[jcup$top-1].value;
        TreeList d = (TreeList)$stack[jcup$top].value;
        
            RESULT = d.prepend(i);
              return jcup$stack.reuse(22/*ImportDeclarations*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 36: // ImportDeclarations ::= ImportDeclaration 
            {
        TreeList RESULT = null;
        Tree i = (Tree)$stack[jcup$top].value;
         RESULT = trees.TreeList(i);
              return jcup$stack.reuse(22/*ImportDeclarations*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 35: // ImportDeclarationsopt ::= ImportDeclarations 
            {
              return jcup$stack.reuse(20/*ImportDeclarationsopt*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 34: // ImportDeclarationsopt ::= 
            {
        TreeList RESULT = null;
        RESULT = null;
              return new org.zenger.jcup.runtime.Symbol(20/*ImportDeclarationsopt*/, $stack[jcup$top].left, $stack[jcup$top].left, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 33: // TopLevel ::= PackageDeclarationopt ImportDeclarationsopt TypeDeclarationsopt 
            {
        CompilationUnit RESULT = null;
        Tree p = (Tree)$stack[jcup$top-2].value;
        TreeList i = (TreeList)$stack[jcup$top-1].value;
        TreeList t = (TreeList)$stack[jcup$top].value;
        int pleft = $stack[jcup$top-2].left;
        
            RESULT = (CompilationUnit)make.CompilationUnit(
                        trees.TreeList(p).append(i).append(t).toArray(),
                        report.getCurrentEnv()).
                     at(pleft);
              return jcup$stack.reuse(2/*TopLevel*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 32: // QualifiedName ::= Name DOT CLASS 
            {
        Tree RESULT = null;
        Tree n = (Tree)$stack[jcup$top-2].value;
        Object c = (Object)$stack[jcup$top].value;
        int nleft = $stack[jcup$top-2].left;
         RESULT = make.Select(n,
                                                lexer.tokenName[Symbols.CLASS]).
                                                at(nleft);
              return jcup$stack.reuse(81/*QualifiedName*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 31: // QualifiedName ::= Name DOT IDENTIFIER 
            {
        Tree RESULT = null;
        Tree n = (Tree)$stack[jcup$top-2].value;
        Name i = (Name)$stack[jcup$top].value;
        int nleft = $stack[jcup$top-2].left;
         RESULT = make.Select(n, i).at(nleft);
              return jcup$stack.reuse(81/*QualifiedName*/, jcup$top - 2, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 30: // SimpleName ::= CONST 
            {
        Name RESULT = null;
        Object c = (Object)$stack[jcup$top].value;
         RESULT = lexer.tokenName[Symbols.CONST];
              return jcup$stack.reuse(69/*SimpleName*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 29: // SimpleName ::= GOTO 
            {
        Name RESULT = null;
        Object g = (Object)$stack[jcup$top].value;
         RESULT = lexer.tokenName[Symbols.GOTO];
              return jcup$stack.reuse(69/*SimpleName*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 28: // SimpleName ::= IDENTIFIER 
            {
              return jcup$stack.reuse(69/*SimpleName*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 27: // Name ::= QualifiedName 
            {
              return jcup$stack.reuse(80/*Name*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 26: // Name ::= SimpleName 
            {
        Tree RESULT = null;
        Name t = (Name)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.Ident(t).at(tleft);
              return jcup$stack.reuse(80/*Name*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 25: // ArrayType ::= Name Dims 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-1].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top].value;
        
            replaceArrayType(d, e);
            RESULT = d;
              return jcup$stack.reuse(79/*ArrayType*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 24: // ArrayType ::= PrimitiveType Dims 
            {
        Tree RESULT = null;
        Tree e = (Tree)$stack[jcup$top-1].value;
        ArrayTypeTerm d = (ArrayTypeTerm)$stack[jcup$top].value;
        
            replaceArrayType(d, e);
            RESULT = d;
              return jcup$stack.reuse(79/*ArrayType*/, jcup$top - 1, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 23: // ClassOrInterfaceType ::= Name 
            {
              return jcup$stack.reuse(78/*ClassOrInterfaceType*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 22: // ReferenceType ::= ArrayType 
            {
              return jcup$stack.reuse(77/*ReferenceType*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 21: // ReferenceType ::= ClassOrInterfaceType 
            {
              return jcup$stack.reuse(77/*ReferenceType*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 20: // FloatingPointType ::= DOUBLE 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.DOUBLE).at(tleft);
              return jcup$stack.reuse(76/*FloatingPointType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 19: // FloatingPointType ::= FLOAT 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.FLOAT).at(tleft);
              return jcup$stack.reuse(76/*FloatingPointType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 18: // IntegralType ::= CHAR 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.CHAR).at(tleft);
              return jcup$stack.reuse(75/*IntegralType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 17: // IntegralType ::= LONG 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.LONG).at(tleft);
              return jcup$stack.reuse(75/*IntegralType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 16: // IntegralType ::= INT 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.INT).at(tleft);
              return jcup$stack.reuse(75/*IntegralType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 15: // IntegralType ::= SHORT 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.SHORT).at(tleft);
              return jcup$stack.reuse(75/*IntegralType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 14: // IntegralType ::= BYTE 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.BYTE).at(tleft);
              return jcup$stack.reuse(75/*IntegralType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 13: // NumericType ::= FloatingPointType 
            {
              return jcup$stack.reuse(74/*NumericType*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 12: // NumericType ::= IntegralType 
            {
              return jcup$stack.reuse(74/*NumericType*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 11: // PrimitiveType ::= BOOLEAN 
            {
        Tree RESULT = null;
        Object t = (Object)$stack[jcup$top].value;
        int tleft = $stack[jcup$top].left;
         RESULT = make.BasicType(TypeConst.
                                                BOOLEAN).at(tleft);
              return jcup$stack.reuse(73/*PrimitiveType*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 10: // PrimitiveType ::= NumericType 
            {
              return jcup$stack.reuse(73/*PrimitiveType*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 9: // Type ::= ReferenceType 
            {
              return jcup$stack.reuse(72/*Type*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 8: // Type ::= PrimitiveType 
            {
              return jcup$stack.reuse(72/*Type*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 7: // Literal ::= STRINGLITERAL 
            {
        Tree RESULT = null;
        Constant c = (Constant)$stack[jcup$top].value;
        int cleft = $stack[jcup$top].left;
         RESULT = make.Literal(c).at(cleft);
              return jcup$stack.reuse(71/*Literal*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 6: // Literal ::= CHARLITERAL 
            {
        Tree RESULT = null;
        Constant c = (Constant)$stack[jcup$top].value;
        int cleft = $stack[jcup$top].left;
         RESULT = make.Literal(c).at(cleft);
              return jcup$stack.reuse(71/*Literal*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 5: // Literal ::= DOUBLELITERAL 
            {
        Tree RESULT = null;
        Constant c = (Constant)$stack[jcup$top].value;
        int cleft = $stack[jcup$top].left;
         RESULT = make.Literal(c).at(cleft);
              return jcup$stack.reuse(71/*Literal*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 4: // Literal ::= FLOATLITERAL 
            {
        Tree RESULT = null;
        Constant c = (Constant)$stack[jcup$top].value;
        int cleft = $stack[jcup$top].left;
         RESULT = make.Literal(c).at(cleft);
              return jcup$stack.reuse(71/*Literal*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 3: // Literal ::= LONGLITERAL 
            {
        Tree RESULT = null;
        Constant c = (Constant)$stack[jcup$top].value;
        int cleft = $stack[jcup$top].left;
         RESULT = make.Literal(c).at(cleft);
              return jcup$stack.reuse(71/*Literal*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 2: // Literal ::= INTLITERAL 
            {
        Tree RESULT = null;
        Constant c = (Constant)$stack[jcup$top].value;
        int cleft = $stack[jcup$top].left;
         RESULT = make.Literal(c).at(cleft);
              return jcup$stack.reuse(71/*Literal*/, jcup$top, RESULT);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 1: // Goal ::= TopLevel 
            {
              return jcup$stack.reuse(1/*Goal*/);
            }

          /*. . . . . . . . . . . . . . . . . . . .*/
          case 0: // $START ::= Goal EOF 
            {
      org.zenger.jcup.runtime.Symbol jcup$result;
        Object RESULT = null;
        CompilationUnit start_val = (CompilationUnit)$stack[jcup$top-1].value;
        RESULT = start_val;
              jcup$result = new org.zenger.jcup.runtime.Symbol(0/*$START*/, jcup$top - 1, jcup$top, RESULT);
          /* ACCEPT */
          jcup$parser.done_parsing();
          return jcup$result;
            }

          /* . . . . . .*/
          default:
            throw new Exception(
               "Invalid action number found in internal parse table");

        }
    }
};

