### Go 1.23

Go 1.23 changed the channels created by package time to be unbuffered
(synchronous), which makes correct use of the [`Timer.Stop`](/pkg/time/#Timer.Stop)
and [`Timer.Reset`](/pkg/time/#Timer.Reset) method results much easier.
The [`asynctimerchan` setting](/pkg/time/#NewTimer) disables this change.
There are no runtime metrics for this change,

		}
	case *dwarf.TypedefType:
		// C has much more relaxed rules than Go for
		// implicit type conversions. When the parameter
		// is type T defined as *X, simulate a little of the
		// laxness of C by making the argument *X instead of T.
		if ptr, ok := base(dt.Type).(*dwarf.PtrType); ok {
			// Unless the typedef happens to point to void* since
			// Go has special rules around using unsafe.Pointer.

pkg syscall (freebsd-arm64), const SYS_RCTL_GET_RACCT = 525
pkg syscall (freebsd-arm64), const SYS_RCTL_GET_RACCT ideal-int
pkg syscall (freebsd-arm64), const SYS_RCTL_GET_RULES = 526
pkg syscall (freebsd-arm64), const SYS_RCTL_GET_RULES ideal-int
pkg syscall (freebsd-arm64), const SYS_RCTL_REMOVE_RULE = 529
pkg syscall (freebsd-arm64), const SYS_RCTL_REMOVE_RULE ideal-int
pkg syscall (freebsd-arm64), const SYS_READ = 3

pkg archive/zip, type FileHeader struct, UncompressedSize //deprecated
pkg compress/flate, type ReadError //deprecated
pkg compress/flate, type WriteError //deprecated
pkg crypto/rc4, method (*Cipher) Reset //deprecated
pkg crypto/tls, const VersionSSL30 //deprecated
pkg crypto/tls, method (*Config) BuildNameToCertificate //deprecated
pkg crypto/tls, type Config struct, NameToCertificate //deprecated

			c = ' ' // Treat the checksum field itself as all spaces.
		}
		unsigned += int64(c)
		signed += int64(int8(c))
	}
	return unsigned, signed
}

// reset clears the block with all zeros.
func (b *block) reset() {
	*b = block{}
}

type headerV7 [blockSize]byte

func (h *headerV7) name() []byte     { return h[000:][:100] }
func (h *headerV7) mode() []byte     { return h[100:][:8] }

	conf.Fprint(&buf, fset, f.AST)

	return buf.String()
}

var gofmtBuf strings.Builder

// gofmt returns the gofmt-formatted string for an AST node.
func gofmt(n interface{}) string {
	gofmtBuf.Reset()
	err := printer.Fprint(&gofmtBuf, fset, n)
	if err != nil {
		return "<" + err.Error() + ">"
	}
	return gofmtBuf.String()
}

// gofmtLineReplacer is used to put a gofmt-formatted string for an

types and instead use these constants.
This improves the readability of assembly code, and keeps it robust to
changes in data layout either in the Go type definitions or in the
layout rules used by the Go compiler.
</p>

<p>
Constants are of the form <code>const_<i>name</i></code>.
For example, given the Go declaration <code>const bufSize =

pkg syscall (freebsd-riscv64), const SYS_RCTL_GET_RACCT = 525 #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_GET_RACCT ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_GET_RULES = 526 #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_GET_RULES ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_REMOVE_RULE = 529 #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_REMOVE_RULE ideal-int #53466

			realSize := hdr.Size
			hdr.Size = 0 // Encoded size; does not account for encoded sparse map
			for _, s := range spd {
				hdr.Size += s.Length
			}
			copy(blk.V7().Size(), zeroBlock[:]) // Reset field
			f.formatNumeric(blk.V7().Size(), hdr.Size)
			f.formatNumeric(blk.GNU().RealSize(), realSize)
		}
	*/
	blk.setFormat(FormatGNU)
	if err := tw.writeRawHeader(blk, hdr.Size, hdr.Typeflag); err != nil {

now unbuffered, with capacity 0.
The main effect of this change is that Go now guarantees
that for any call to a `Reset` or `Stop` method, no stale values
prepared before that call will be sent or received after the call.
Earlier versions of Go used channels with a one-element buffer,
making it difficult to use `Reset` and `Stop` correctly.
A visible effect of this change is that `len` and `cap` of timer channels