import java.io.*;
         import java.util.*;
         import demeter.*;
         import java.lang.*;


import demeter.*;
public class Parser implements ParserConstants {

  static char unescapifyChar(String s) {
    char c = s.charAt(0);
    if (c == '\\') {
      switch (s.charAt(1)) {
      case 'n': c = '\n'; break;
      case 't': c = '\t'; break;
      case 'b': c = '\b'; break;
      case 'r': c = '\r'; break;
      case 'f': c = '\f'; break;
      case '\\': c = '\\'; break;
      case '\'': c = '\''; break;
      case '\"': c = '\"'; break;
      default:
         c = (char) Integer.parseInt(s.substring(2, s.length()), 8);
         break;
      }
    }
    return c;
  }

  static String unescapify(String s) {
    char str[] = new char[s.length()];
    int i = 0, o = 0;
    while (i < s.length()) {
      char c = s.charAt(i++);
      if (c == '\\') {
         int j = i + 1;
         while (j < s.length() &&
                Character.digit(s.charAt(j), 8) != -1) {
           j++;
         }
         c = unescapifyChar(s.substring(i-1, j));
         i = j;
      }
      str[o++] = c;
    }
    return String.valueOf(str, 0, o);
  }

  protected ParserTokenManager token_source;
  protected Token token = new Token();
  protected Token scanpos, lastpos;
  private int la;
  protected Parser me;

  private int[] scan_hist_kind = new int[10000];
  private Token[] scan_hist_index = new Token[10000];
  int scan_hist_ptr = 0;

  public Parser(java.io.InputStream stream) {
    me = this;
    ASCII_UCodeESC_CharStream input_stream = new ASCII_UCodeESC_CharStream(stream, 1, 1);
    token_source = new ParserTokenManager(input_stream);
  }

  public void ReInit(java.io.InputStream stream) {
    ASCII_UCodeESC_CharStream input_stream = new ASCII_UCodeESC_CharStream(stream, 1, 1);
    token_source.ReInit(input_stream);
    token = new Token();
    scan_hist_ptr = 0;
  }

  public Parser(ParserTokenManager tm) {
    me = this;
    token_source = tm;
  }

  public void ReInit(ParserTokenManager tm) {
    token_source = tm;
    token = new Token();
    scan_hist_ptr = 0;
  }

  final private Token consume_token(int kind) throws ParseError {
    if (token.next != null) token = token.next;
    else token = token_source.getNextToken();
    scan_hist_kind[scan_hist_ptr] = kind;
    scan_hist_index[scan_hist_ptr++] = token;
    if (token.kind == kind) {
      scan_hist_ptr = 0;
      return token;
    }
    token_error_setup(0);
    throw new ParseError();
  }

  final private boolean scan_token(int kind) throws ParseError {
    if (scanpos == lastpos) {
      la--;
      if (scanpos.next == null) {
        lastpos = scanpos = scanpos.next = token_source.getNextToken();
      } else {
        lastpos = scanpos = scanpos.next;
      }
    } else {
      scanpos = scanpos.next;
    }
    scan_hist_kind[scan_hist_ptr] = kind;
    scan_hist_index[scan_hist_ptr++] = scanpos;
    return (scanpos.kind != kind);
  }

  final public Token getNextToken() throws ParseError {
    if (token.next != null) token = token.next;
    else token = token_source.getNextToken();
    return token;
  }

  final public Token getToken(int index) throws ParseError {
    scanpos = token;
    for (int i = 0; i < index; i++) {
      if (scanpos.next != null) scanpos = scanpos.next;
      else scanpos = scanpos.next = token_source.getNextToken();
    }
    return scanpos;
  }

  static final String add_escapes(String str) {
    String retval = "";
    char ch;
    for (int i = 0; i < str.length(); i++) {
      ch = str.charAt(i);
      if (ch == '\b') {
        retval += "\\b";
      } else if (ch == '\t') {
        retval += "\\t";
      } else if (ch == '\n') {
        retval += "\\n";
      } else if (ch == '\f') {
        retval += "\\f";
      } else if (ch == '\r') {
        retval += "\\r";
      } else if (ch == '\"') {
        retval += "\\\"";
      } else if (ch == '\'') {
        retval += "\\\'";
      } else if (ch == '\\') {
        retval += "\\\\";
      } else {
        retval += ch;
      }
    }
    return retval;
  }

  protected int error_line;
  protected int error_column;
  protected String error_string;
  protected String[] expected_tokens;

  protected void token_error() {
    System.out.println("");
    System.out.println("Parse error at line " + error_line + ", column " + error_column + ".  Encountered:");
    System.out.println("    \"" + add_escapes(error_string) + "\"");
    System.out.println("");
    if (expected_tokens.length == 1) {
      System.out.println("Was expecting:");
    } else {
      System.out.println("Was expecting one of:");
    }
    for (int i = 0; i < expected_tokens.length; i++) {
      System.out.println("    " + expected_tokens[i]);
    }
    System.out.println("");
  }

  final protected void token_error_setup(int stream_ptr) {
    Token tok;
    int[] tokenbuf = new int[100];
    int tokenbufptr = 0;
    int maxsize = 0;
    String[] exp = new String[1000];
    int exp_count = 0;
    for (int i = 0; i < scan_hist_ptr; i++) {
      if (i == 0 || scan_hist_index[i-1].next == scan_hist_index[i]) {
        tokenbuf[tokenbufptr++] = scan_hist_kind[i];
        if (tokenbufptr > maxsize) maxsize = tokenbufptr;
      } else {
        exp[exp_count] = "";
        for (int j = 0; j < tokenbufptr; j++) {
          exp[exp_count] += tokenImage[tokenbuf[j]] + " ";
        }
        if (tokenbuf[tokenbufptr-1] != 0) exp[exp_count] += "...";
        exp_count++;
        for (int j = 0; j < exp_count-1; j++) {
          if (exp[j].equals(exp[exp_count-1])) {
            exp_count--; break;
          }
        }
        tok = token;
        if (stream_ptr == 1) tok = tok.next;
        tokenbufptr = 1;
        while (tok != scan_hist_index[i]) {
          tok = tok.next;
          tokenbufptr++;
        }
        tokenbuf[tokenbufptr-1] = scan_hist_kind[i];
      }
    }
    exp[exp_count] = "";
    for (int j = 0; j < tokenbufptr; j++) {
      exp[exp_count] += tokenImage[tokenbuf[j]] + " ";
    }
    if (tokenbuf[tokenbufptr-1] != 0) exp[exp_count] += "...";
    exp_count++;
    for (int j = 0; j < exp_count-1; j++) {
      if (exp[j].equals(exp[exp_count-1])) {
        exp_count--; break;
      }
    }
    expected_tokens = new String[exp_count];
    for (int i = 0; i < exp_count; i++) {
      expected_tokens[i] = exp[i];
    }
    error_line = token.beginLine;
    error_column = token.beginColumn;
    error_string = "";
    tok = token;
    if (stream_ptr == 1) tok = tok.next;
    for (int i = 0; i < maxsize; i++) {
      if (tok.kind == 0) {
        error_string += " " + tokenImage[0];
        break;
      }
      error_string += " " + tok.image;
      tok = tok.next;
    }
    error_string = error_string.substring(1);
    me.token_error();
  }

  final public Root _Root() throws ParseError {
  Root it;
  Ident _className;
  RootClass _rootclass;
    it=new Root();
    consume_token(1);
    _className = _Ident();
                             it.set_className(_className);
    _rootclass = _RootClass();
                            it.set_rootclass(_rootclass);
    consume_token(2);
         return it;
  }

  final public RootClass _RootClass() throws ParseError {
  RootClass it;
    if (_Jack2_1(1)) {
      it = _Non_Empty_RootClass();
    } else if (_Jack2_2(1)) {
      it = _Empty_RootClass();
    } else {
      token_error_setup(1);
      throw new ParseError();
    }
    return it;
  }

  final public void common_RootClass(RootClass it) throws ParseError {

  }

  final public Non_Empty_RootClass _Non_Empty_RootClass() throws ParseError {
  Non_Empty_RootClass it;
  Ident _className;
  SubClass1 _subclass1;
    it=new Non_Empty_RootClass();
    consume_token(3);
    _className = _Ident();
                             it.set_className(_className);
    _subclass1 = _SubClass1();
                            it.set_subclass1(_subclass1);
    consume_token(4);
         common_RootClass(it);
    return it;
  }

  final public Empty_RootClass _Empty_RootClass() throws ParseError {
  Empty_RootClass it;
    it=new Empty_RootClass();
    common_RootClass(it);
    return it;
  }

  final public SubClass1 _SubClass1() throws ParseError {
  SubClass1 it;
    if (_Jack2_3(1)) {
      it = _Non_Empty_SubClass1();
    } else if (_Jack2_4(1)) {
      it = _Empty_SubClass1();
    } else {
      token_error_setup(1);
      throw new ParseError();
    }
    return it;
  }

  final public void common_SubClass1(SubClass1 it) throws ParseError {

  }

  final public Non_Empty_SubClass1 _Non_Empty_SubClass1() throws ParseError {
  Non_Empty_SubClass1 it;
  Ident _className;
  SubClass2 _subclass2;
    it=new Non_Empty_SubClass1();
    consume_token(5);
    _className = _Ident();
                             it.set_className(_className);
    _subclass2 = _SubClass2();
                            it.set_subclass2(_subclass2);
    consume_token(6);
         common_SubClass1(it);
    return it;
  }

  final public Empty_SubClass1 _Empty_SubClass1() throws ParseError {
  Empty_SubClass1 it;
    it=new Empty_SubClass1();
    common_SubClass1(it);
    return it;
  }

  final public SubClass2 _SubClass2() throws ParseError {
  SubClass2 it;
    if (_Jack2_5(1)) {
      it = _Non_Empty_SubClass2();
    } else if (_Jack2_6(1)) {
      it = _Empty_SubClass2();
    } else {
      token_error_setup(1);
      throw new ParseError();
    }
    return it;
  }

  final public void common_SubClass2(SubClass2 it) throws ParseError {

  }

  final public Non_Empty_SubClass2 _Non_Empty_SubClass2() throws ParseError {
  Non_Empty_SubClass2 it;
  Ident _className;
    it=new Non_Empty_SubClass2();
    consume_token(7);
    _className = _Ident();
                             it.set_className(_className);
    consume_token(7);
         common_SubClass2(it);
    return it;
  }

  final public Empty_SubClass2 _Empty_SubClass2() throws ParseError {
  Empty_SubClass2 it;
    it=new Empty_SubClass2();
    common_SubClass2(it);
    return it;
  }

  final public Expected _Expected() throws ParseError {
  Expected it;
  Expected_Wrapper_List _expected_wrapper_list;
    it=new Expected();
    _expected_wrapper_list = _Expected_Wrapper_List();
                                                    it.set_expected_wrapper_list(_expected_wrapper_list);
    return it;
  }

  final public Expected_Wrapper _Expected_Wrapper() throws ParseError {
  Expected_Wrapper it;
  Ident _wrapper_name;
    it=new Expected_Wrapper();
    _wrapper_name = _Ident();
                           it.set_wrapper_name(_wrapper_name);
    return it;
  }

  final public Main _Main() throws ParseError {
  Main it;
    it=new Main();
    return it;
  }

  final public AppendVisitor _AppendVisitor() throws ParseError {
  AppendVisitor it;
  Names _names;
    it=new AppendVisitor();
    _names = _Names();
                    it.set_names(_names);
    return it;
  }

  final public ExpectedVisitor _ExpectedVisitor() throws ParseError {
  ExpectedVisitor it;
  Names _list;
    it=new ExpectedVisitor();
    _list = _Names();
                   it.set_list(_list);
    return it;
  }

  final public Names _Names() throws ParseError {
  Names it;
    it=new Names();
    return it;
  }

  final public Expected_Wrapper_List _Expected_Wrapper_List() throws ParseError {
  Expected_Wrapper_List it;
  Nonempty_Expected_Wrapper_List _first;
    it=new Expected_Wrapper_List();
    consume_token(5);
    _first = _Nonempty_Expected_Wrapper_List();
                                                  it.set_first(_first);
    consume_token(6);
         return it;
  }

  final public Nonempty_Expected_Wrapper_List _Nonempty_Expected_Wrapper_List() throws ParseError {
  Nonempty_Expected_Wrapper_List it;
  Expected_Wrapper _it;
  Nonempty_Expected_Wrapper_List _next;
    it=new Nonempty_Expected_Wrapper_List();
    _it = _Expected_Wrapper();
                            it.set_it(_it);
    if (_Jack2_7(1)) {
      consume_token(8);
      _next = _Nonempty_Expected_Wrapper_List();
                                                    it.set_next(_next);
    }
    return it;
  }

  final public boolean _boolean() throws ParseError {
                       Token t;
    if (_Jack2_8(1)) {
      t = consume_token(TRUE);
               return true;
    } else if (_Jack2_9(1)) {
      t = consume_token(FALSE);
                return false;
    } else {
      token_error_setup(1);
      throw new ParseError();
    }
  }

  final public char _char() throws ParseError {
                 Token t;
    t = consume_token(CHARACTER_LITERAL);
         String s = t.image;
         return unescapifyChar(s.substring(1, s.length()-1));
  }

  final public byte _byte() throws ParseError {
                 int i;
    i = _int();
             return (byte) i;
  }

  final public short _short() throws ParseError {
                   int i;
    i = _int();
             return (short) i;
  }

  final public int _int() throws ParseError {
               Number num;
    num = _Number();
                  return num.intValue();
  }

  final public long _long() throws ParseError {
                 Number num;
    num = _Number();
                  return num.longValue();
  }

  final public float _float() throws ParseError {
                   Number num;
    num = _Number();
                  return num.floatValue();
  }

  final public double _double() throws ParseError {
                     Number num;
    num = _Number();
                  return num.doubleValue();
  }

  final public Boolean _Boolean() throws ParseError {
                       Token t;
    if (_Jack2_10(1)) {
      t = consume_token(TRUE);
               return Boolean.TRUE;
    } else if (_Jack2_11(1)) {
      t = consume_token(FALSE);
                return Boolean.FALSE;
    } else {
      token_error_setup(1);
      throw new ParseError();
    }
  }

  final public Character _Character() throws ParseError {
                           char c;
    c = _char();
              return new Character(c);
  }

  final public Integer _Integer() throws ParseError {
                       int i;
    i = _int();
               return new Integer(i);
  }

  final public Long _Long() throws ParseError {
                 long l;
    l = _long();
              return new Long(l);
  }

  final public Float _Float() throws ParseError {
                   float f;
    f = _float();
               return new Float(f);
  }

  final public Double _Double() throws ParseError {
                     double d;
    d = _double();
                return new Double(d);
  }

  final public Number _Number() throws ParseError {
    Token t;
    String s;
    int radix;
    Number num;
    if (_Jack2_12(1)) {
      if (_Jack2_13(1)) {
        t = consume_token(DECIMAL_LITERAL);
         s = t.image;
         radix = 10;
      } else if (_Jack2_14(1)) {
        t = consume_token(HEX_LITERAL);
         s = t.image.substring(2, t.image.length());
         radix = 16;
      } else if (_Jack2_15(1)) {
        t = consume_token(OCTAL_LITERAL);
         s = t.image;
         radix = 8;
      } else {
        token_error_setup(1);
        throw new ParseError();
      }
         switch (s.charAt(s.length()-1)) {
         case 'l': case 'L':
             num = Long.valueOf(s.substring(0, s.length()-1), radix);
             break;
         default:
             num = Integer.valueOf(s, radix);
             break;
         }
    } else if (_Jack2_16(1)) {
      t = consume_token(FLOATING_POINT_LITERAL);
         s = t.image;
         switch (s.charAt(s.length()-1)) {
         case 'd': case 'D':
             num = Double.valueOf(s.substring(0, s.length()-1));
             break;
         case 'f': case 'F':
             num = Float.valueOf(s.substring(0, s.length()-1));
             break;
         default:
             num = Float.valueOf(s);
             break;
         }
    } else {
      token_error_setup(1);
      throw new ParseError();
    }
      return num;
  }

  final public String _String() throws ParseError {
                     Token t;
    t = consume_token(STRING_LITERAL);
         String s = t.image;
         return unescapify(s.substring(1, s.length()-1));
  }

  final public StringBuffer _StringBuffer() throws ParseError {
                                 String s;
    s = _String();
                return new StringBuffer(s);
  }

  final public Ident _Ident() throws ParseError {
                   Token t;
    t = consume_token(IDENTIFIER);
         return new Ident(t.image);
  }

  final public Text _Text() throws ParseError {
                 Token t;
    t = consume_token(TEXT_LITERAL);
         String s = t.image;
         return new Text(s.substring(2, s.length()-2));
  }

  final private boolean _Jack2_1(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_1();
  }

  final private boolean _Jack2_2(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_2();
  }

  final private boolean _Jack2_3(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_3();
  }

  final private boolean _Jack2_4(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_4();
  }

  final private boolean _Jack2_5(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_5();
  }

  final private boolean _Jack2_6(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_6();
  }

  final private boolean _Jack2_7(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_7();
  }

  final private boolean _Jack2_8(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_8();
  }

  final private boolean _Jack2_9(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_9();
  }

  final private boolean _Jack2_10(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_10();
  }

  final private boolean _Jack2_11(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_11();
  }

  final private boolean _Jack2_12(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_12();
  }

  final private boolean _Jack2_13(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_13();
  }

  final private boolean _Jack2_14(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_14();
  }

  final private boolean _Jack2_15(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_15();
  }

  final private boolean _Jack2_16(int xla) throws ParseError {
    la = xla; lastpos = scanpos = token;
    return !_Jack3_16();
  }

  final private boolean _Jack3_1() throws ParseError {
    if (_Jack3_Non_Empty_RootClass()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_2() throws ParseError {
    if (_Jack3_Empty_RootClass()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_3() throws ParseError {
    if (_Jack3_Non_Empty_SubClass1()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_4() throws ParseError {
    if (_Jack3_Empty_SubClass1()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_5() throws ParseError {
    if (_Jack3_Non_Empty_SubClass2()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_6() throws ParseError {
    if (_Jack3_Empty_SubClass2()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_7() throws ParseError {
    if (scan_token(8)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (_Jack3_Nonempty_Expected_Wrapper_List()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_8() throws ParseError {
    if (scan_token(TRUE)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_9() throws ParseError {
    if (scan_token(FALSE)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_10() throws ParseError {
    if (scan_token(TRUE)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_11() throws ParseError {
    if (scan_token(FALSE)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_12() throws ParseError {
    Token xsp;
    xsp = scanpos;
    if (_Jack3_13()) {
    scanpos = xsp;
    if (_Jack3_14()) {
    scanpos = xsp;
    if (_Jack3_15()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    } else if (la == 0 && scanpos == lastpos) return false;
    } else if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_13() throws ParseError {
    if (scan_token(DECIMAL_LITERAL)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_14() throws ParseError {
    if (scan_token(HEX_LITERAL)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_15() throws ParseError {
    if (scan_token(OCTAL_LITERAL)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_16() throws ParseError {
    if (scan_token(FLOATING_POINT_LITERAL)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_Non_Empty_RootClass() throws ParseError {
    if (scan_token(3)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (_Jack3_Ident()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (_Jack3_SubClass1()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (scan_token(4)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_Empty_RootClass() throws ParseError {
    return false;
  }

  final private boolean _Jack3_Non_Empty_SubClass1() throws ParseError {
    if (scan_token(5)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (_Jack3_Ident()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (_Jack3_SubClass2()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (scan_token(6)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_Empty_SubClass1() throws ParseError {
    return false;
  }

  final private boolean _Jack3_Non_Empty_SubClass2() throws ParseError {
    if (scan_token(7)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (_Jack3_Ident()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    if (scan_token(7)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_Empty_SubClass2() throws ParseError {
    return false;
  }

  final private boolean _Jack3_Nonempty_Expected_Wrapper_List() throws ParseError {
    if (_Jack3_Expected_Wrapper()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    Token xsp;
    xsp = scanpos;
    if (_Jack3_7()) scanpos = xsp;
    else if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_Ident() throws ParseError {
    if (scan_token(IDENTIFIER)) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_SubClass1() throws ParseError {
    Token xsp;
    xsp = scanpos;
    if (_Jack3_3()) {
    scanpos = xsp;
    if (_Jack3_4()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    } else if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_SubClass2() throws ParseError {
    Token xsp;
    xsp = scanpos;
    if (_Jack3_5()) {
    scanpos = xsp;
    if (_Jack3_6()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    } else if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

  final private boolean _Jack3_Expected_Wrapper() throws ParseError {
    if (_Jack3_Ident()) return true;
    if (la == 0 && scanpos == lastpos) return false;
    return false;
  }

}