pkg syscall (netbsd-arm64-cgo), const SYS_TIMER_CREATE = 235
pkg syscall (netbsd-arm64-cgo), const SYS_TIMER_CREATE ideal-int
pkg syscall (netbsd-arm64-cgo), const SYS_TIMER_DELETE = 236
pkg syscall (netbsd-arm64-cgo), const SYS_TIMER_DELETE ideal-int
pkg syscall (netbsd-arm64-cgo), const SYS_TIMER_GETOVERRUN = 239
pkg syscall (netbsd-arm64-cgo), const SYS_TIMER_GETOVERRUN ideal-int

reasonably cheap dynamic checks. These checks may be disabled
entirely using GODEBUG=cgocheck=0. Complete checking of pointer
handling, at some cost in run time, is available by setting
GOEXPERIMENT=cgocheck2 at build time.

It is possible to defeat this enforcement by using the unsafe package,
and of course there is nothing stopping the C code from doing anything

		if err == nil {
			t.Error("error expected")
		} else if err != io.ErrNoProgress {
			t.Error("unexpected error:", err)
		}
	case <-time.After(time.Second):
		t.Error("test timed out (endless loop in ReadByte?)")
	}
}

// A StringReader delivers its data one string segment at a time via Read.
type StringReader struct {
	data []string
	step int
}

func (r *StringReader) Read(p []byte) (n int, err error) {

right operand, which must be non-negative. If the shift count is negative at run time,
a <a href="#Run_time_panics">run-time panic</a> occurs.
The shift operators implement arithmetic shifts if the left operand is a signed
integer and logical shifts if it is an unsigned integer.
There is no upper limit on the shift count. Shifts behave
as if the left operand is shifted <code>n</code> times by 1 for a shift
count of <code>n</code>.

	AMOMAXUD	X5, (X6), X7			// af3353e6
	AMOMINW		X5, (X6), X7			// af235386
	AMOMIND		X5, (X6), X7			// af335386
	AMOMINUW	X5, (X6), X7			// af2353c6
	AMOMINUD	X5, (X6), X7			// af3353c6

	// 10.1: Base Counters and Timers
	RDCYCLE		X5				// f32200c0
	RDTIME		X5				// f32210c0
	RDINSTRET	X5				// f32220c0

	// 11.5: Single-Precision Load and Store Instructions
	FLW	(X5), F0				// 07a00200
	FLW	4(X5), F0				// 07a04200

### Timer changes

Go 1.23 makes two significant changes to the implementation of
[time.Timer] and [time.Ticker].

First, `Timer`s and `Ticker`s that are no longer referred to by the program
become eligible for garbage collection immediately, even if their
`Stop` methods have not been called.
Earlier versions of Go did not collect unstopped `Timer`s until after
they had fired and never collected unstopped `Ticker`s.

### 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,

	h := &FileHeader{
		Name:     "test.txt",
		Modified: time.Date(2017, 10, 31, 21, 11, 57, 0, timeZone(-7*time.Hour)),
	}
	w := NewWriter(&buf)
	if _, err := w.CreateHeader(h); err != nil {
		t.Fatalf("unexpected CreateHeader error: %v", err)
	}
	if err := w.Close(); err != nil {
		t.Fatalf("unexpected Close error: %v", err)
	}

	want, err := os.ReadFile("testdata/time-go.zip")
	if err != nil {

pkg syscall (linux-386), const SYS_TIME ideal-int
pkg syscall (linux-386), const SYS_TIMERFD_CREATE ideal-int
pkg syscall (linux-386), const SYS_TIMERFD_GETTIME ideal-int
pkg syscall (linux-386), const SYS_TIMERFD_SETTIME ideal-int
pkg syscall (linux-386), const SYS_TIMER_CREATE ideal-int
pkg syscall (linux-386), const SYS_TIMER_DELETE ideal-int
pkg syscall (linux-386), const SYS_TIMER_GETOVERRUN ideal-int

pkg syscall (freebsd-arm64), const SYS_KTIMER_CREATE = 235
pkg syscall (freebsd-arm64), const SYS_KTIMER_CREATE ideal-int
pkg syscall (freebsd-arm64), const SYS_KTIMER_DELETE = 236
pkg syscall (freebsd-arm64), const SYS_KTIMER_DELETE ideal-int
pkg syscall (freebsd-arm64), const SYS_KTIMER_GETOVERRUN = 239
pkg syscall (freebsd-arm64), const SYS_KTIMER_GETOVERRUN ideal-int