final public Assignment Assignment(Recovery next) throws ParseException {
    Assignment assignment = null;
    Identifier identifier = null;
    Type type;
    MacroBody macro_body;
    Token begin_t;
    Token syntax_t;
    Token end_t;
    Token type_t;
    TypeTag typeTag;
    NodeList variables;
    EnterprisePart enterprise;
    DescriptionPart description;
    NumericValue number;
    NodeList vtList;
    ObjectInfo object_info;
    Token assign_t;
    AssignedValue assigned_value;
    if (jj_2_3(2)) {
      identifier = TypeIdentifier();
      AssignSymbol(new Recovery());
      type = TypeDefinition(next);
            assignment = new AssignmentType(identifier,
                        type);
    } else if (jj_2_4(2)) {
      identifier = ValueIdentifier();
            next.push(ASSIGN_T);
      try {
        object_info = ObjectDefinition(next);
      } catch (ParseException e) {
            object_info = new ObjectInfoObjectIdentifier();
            makeError(e.currentToken, "encountered in assignment '" + identifier + "'");
            recovery(next);
      } finally {
            /* Setup for continuation */
            next.pop(); /* ASSIGN_T */
            next.push(LEFT_BRACE_T);
      }
      AssignSymbol(next);
            next.pop(); /* LEFT_BRACE_T */

      assigned_value = AssignedValue();
          assignment = new AssignmentObject(identifier,
                            object_info,
                            assigned_value);
    } else if (jj_2_5(3)) {
      identifier = SmiTypes();
            next.push(INTEGER_T);
            next.push(BIT_STRING_T);
            next.push(OCTET_STRING_T);
            next.push(OBJECT_IDENTIFIER_T);
            next.push(LEFT_SQUARE_T);
      AssignSymbol(next);
            next.pop(); /* LEFT_SQUARE_T */

      typeTag = TypeTag(next);
            if (!next.contains(getToken(1).kind)) {
                recovery(next);
            }
            next.pop(4); /* OBJECT_IDENTIFIER_T, OCTET_STRING_T, BIT_STRING_T, INTEGER_T */

      type = Asn1Types();
            typeTag.setType((TypeSmi)type);
            assignment = new AssignmentType(identifier,
                                        typeTag);
    } else if (jj_2_6(3)) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COUNTER32_T:
      case COUNTER_T:
      case GAUGE32_T:
      case GAUGE_T:
      case TIMETICKS_T:
      case OPAQUE_T:
      case IP_ADDRESS_T:
      case NETWORK_ADDRESS_T:
      case NSAP_ADDRESS_T:
      case COUNTER64_T:
      case UNSIGNED32_T:
      case UINTEGER32_T:
      case INTEGER32_T:
        identifier = SmiTypes();
        break;
      case INDEX_SYNTAX_T:
      case APPLICATION_SYNTAX_T:
      case OBJECT_SYNTAX_T:
      case SIMPLE_SYNTAX_T:
        identifier = TypeIdentifierException();
        break;
      default:
        jj_la1[9] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
            next.push(CHOICE_T);
      AssignSymbol(next);
            next.pop(); /* CHOICE_T */

      type_t = jj_consume_token(CHOICE_T);
      vtList = BracedValueTypeList();
            assignment = new AssignmentType(identifier,
                                        new TypeChoice(vtList));
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OBJECT_TYPE_T:
      case OBJECT_IDENTITY_T:
      case OBJECT_GROUP_T:
      case TEXTUAL_CONVENTION_T:
      case NOTIFICATION_TYPE_T:
      case NOTIFICATION_GROUP_T:
      case MODULE_IDENTITY_T:
      case MODULE_COMPLIANCE_T:
      case AGENT_CAPABILITIES_T:
      case TRAP_TYPE_T:
        identifier = PredefinedMacro();
        /* Is actually a TypeIdentifier() */
                type_t = jj_consume_token(MACRO_T);
            next.push(BEGIN_T);
        AssignSymbol(next);
            next.pop(); /* BEGIN_T */

        begin_t = jj_consume_token(BEGIN_T);
        macro_body = MacroBody();
        end_t = jj_consume_token(END_T);
            assignment = new AssignmentMacro(identifier,
                                        macro_body);
        break;
      default:
        jj_la1[10] = jj_gen;
        if (jj_2_7(2)) {
          identifier = ValueIdentifier();
          type_t = jj_consume_token(TRAP_TYPE_T);
            next.push(ASSIGN_T);
            next.push(DESCRIPTION_T);
            next.push(VARIABLES_T);
          enterprise = EnterprisePart(next);
            next.pop(); /* VARIABLES_T */

          variables = VariablesPart(next);
            next.pop(); /* DESCRIPTION_T */

          description = DescriptionPart(next);
            next.pop(); /* ASSIGN_T */

            next.push(DEC_NUMBER_T);
            next.push(BIN_NUMBER_T);
            next.push(HEX_NUMBER_T);
            next.push(VALUE_IDENTIFIER_T);
            next.push(TYPE_IDENTIFIER_T);
          AssignSymbol(next);
            next.pop(3); /* DEC_NUMBER_T, BIN_NUMBER_T, HEX_NUMBER_T */

          number = NumericValue();
            next.pop(2); /* VALUE_IDENTIFIER_T, TYPE_IDENTIFIER_T */
            assignment = new AssignmentObject(identifier,
                        new ObjectInfoTrapType(enterprise,
                                        variables,
                                        description,
                                        number),
                        number);
        } else {
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    }
        {if (true) return assignment;}
    throw new Error("Missing return statement in function");
  }