except.txt lists features that may disappear without breaking true
compatibility.

Starting with go1.19.txt, each API feature line must end in "#nnnnn"
giving the GitHub issue number of the proposal issue that accepted
the new API. This helps with our end-of-cycle audit of new APIs.
The same requirement applies to next/* (described below), which will
become a go1.XX.txt for XX >= 19.

    public final void setUid(final int uid) {
        this.uid = uid;
    }

    /**
     * Gets the signature sequence number
     * @return the signSeq
     */
    public int getSignSeq() {
        return this.signSeq;
    }

    /**
     * Sets the signature sequence number
     * @param signSeq
     *            the signSeq to set
     */
    public final void setSignSeq(final int signSeq) {

     *
     * @param s the short value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @return the number of bytes written (2)
     */
    public static int enc_uint16be(final short s, final byte[] dst, int di) {
        dst[di] = (byte) (s >> 8 & 0xFF);
        di++;
        dst[di] = (byte) (s & 0xFF);

queue_dir            (path)               staging dir for undelivered messages e.g. '/home/events'
queue_limit          (number)             maximum limit for undelivered messages, defaults to '100000'
max_open_connections (number)             maximum number of open connections to the database, defaults to '2'
comment              (sentence)           optionally add a comment to this setting
```

	processLocksWriteTotalMD          = NewGaugeMD(processLocksWriteTotal, "Number of current WRITE locks on this peer")
	processCPUTotalSecondsMD          = NewCounterMD(processCPUTotalSeconds, "Total user and system CPU time spent in seconds")
	processGoRoutineTotalMD           = NewGaugeMD(processGoRoutineTotal, "Total number of go routines running")

  public TestWriter(TestOutputStream out) {
    super(new OutputStreamWriter(checkNotNull(out), UTF_8));
    this.out = out;
  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

    @Deprecated
    public ArtifactMetadataRetrievalException(String message) {
        super(message, null, null);
    }

    /**
     * @param cause a cause
     * @deprecated use {@link #ArtifactMetadataRetrievalException(String, Throwable, Artifact)}
     */
    @Deprecated
    public ArtifactMetadataRetrievalException(Throwable cause) {
        super(null, cause, null);
    }

    /**
     * @param message a message

    max_digits: Annotated[
        int | None,
        Doc(
            """
            Maximum number of digits allowed for decimal values.
            """
        ),
    ] = _Unset,
    decimal_places: Annotated[
        int | None,
        Doc(
            """
            Maximum number of decimal places allowed for decimal values.
            """
        ),
    ] = _Unset,

   * hexadecimal number in lower case.
   *
   * <p>Note that if the output is considered to be a single hexadecimal number, whether this string
   * is big-endian or little-endian depends on the byte order of {@link #asBytes}. This may be
   * surprising for implementations of {@code HashCode} that represent the number in big-endian

        src[srcIndex + 8] = 0x00;
        src[srcIndex + 9] = 0x00;
        // RData length
        src[srcIndex + 10] = 0x00;
        src[srcIndex + 11] = 0x1F; // 31 bytes: 1 + 18 + 6 + 6
        // Number of names (1)
        src[srcIndex + 12] = 0x01;
        // Name entry (18 bytes)
        String name = "TEST            ";
        System.arraycopy(name.getBytes("US-ASCII"), 0, src, srcIndex + 13, 16);