final public CompliancePart CompliancePart(Recovery next) throws ParseException {
    Token sort_t;
    Identifier identifier;
    DescriptionPart description;
    SyntaxPart syntax;
    WriteSyntaxPart write_syntax;
    AccessPart min_access;
    ComplianceObject compliance_object;
    CompliancePart compliance;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case GROUP_T:
      sort_t = jj_consume_token(GROUP_T);
      identifier = ValueIdentifier();
      description = DescriptionPart(next);
            compliance = new ComplianceGroup(identifier, description);
      break;
    case OBJECT_T:
            boolean has_syntax = false;
            boolean has_write_syntax = false;
            boolean has_min_access = false;
            next.push(DESCRIPTION_T);
            next.push(MIN_ACCESS_T);
            next.push(WRITE_SYNTAX_T);
            next.push(SYNTAX_T);
      sort_t = jj_consume_token(OBJECT_T);
      identifier = ValueIdentifier();
            compliance_object = new ComplianceObject(identifier);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SYNTAX_T:
        syntax = SyntaxPart(next);
                compliance_object.addNode(syntax);
                has_syntax = true;
        break;
      default:
        jj_la1[28] = jj_gen;
        ;
      }
            next.pop(); /* SYNTAX_T */

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WRITE_SYNTAX_T:
        write_syntax = WriteSyntaxPart(next);
                compliance_object.addNode(write_syntax);
                has_write_syntax = true;
        break;
      default:
        jj_la1[29] = jj_gen;
        ;
      }
            next.pop(); /* WRITE_SYNTAX_T */

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ACCESS_T:
      case MAX_ACCESS_T:
      case MIN_ACCESS_T:
        min_access = AccessPart(MIN_ACCESS_T, next);
                compliance_object.addNode(min_access);
                has_min_access = true;
        break;
      default:
        jj_la1[30] = jj_gen;
        ;
      }
            next.pop(); /* MIN_ACCESS_T */

            if (getToken(1).kind != DESCRIPTION_T) {
                String str = "";
                if (!has_min_access) {
                    str += "MIN-ACCESS-";
                    if (!has_write_syntax) {
                        str += ", WRITE-SYNTAX-";
                        if (!has_syntax) {
                            str += ", SYNTAX-";
                        }
                    }
                    str += " or ";
                }
                makeError(getToken(1), "expected " + str + "DESCRIPTION-clause");
                recovery(next);
            }
            next.pop(); /* DESCRIPTION_T */

      description = DescriptionPart(next);
            next.pop(); /* DESCRIPTION_T */
            compliance_object.addNode(description);
            compliance = compliance_object;
      break;
    default:
      jj_la1[31] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return compliance;}
    throw new Error("Missing return statement in function");
  }