func putpclcdelta(linkctxt *Link, dctxt dwCtxt, s *LSym, deltaPC uint64, deltaLC int64) {
	// Choose a special opcode that minimizes the number of bytes needed to
	// encode the remaining PC delta and LC delta.
	var opcode int64
	if deltaLC < LINE_BASE {
		if deltaPC >= PC_RANGE {
			opcode = OPCODE_BASE + (LINE_RANGE * PC_RANGE)
		} else {
			opcode = OPCODE_BASE + (LINE_RANGE * int64(deltaPC))
		}
	} else if deltaLC < LINE_BASE+LINE_RANGE {

	// Create a YCbCr image m, whose bounds are r translated by (delta.X, delta.Y).
	r1 := r.Add(delta)
	m := NewYCbCr(r1, subsampleRatio)

	// Test that the image buffer is reasonably small even if (delta.X, delta.Y) is far from the origin.
	if len(m.Y) > 100*100 {
		t.Errorf("r=%v, subsampleRatio=%v, delta=%v: image buffer is too large",
			r, subsampleRatio, delta)
		return
	}

    assertThat(transformation.transform(x1 + xDelta)).isWithin(ALLOWED_ERROR).of(y1 + yDelta);
    assertThat(transformation.inverse().transform(y1)).isWithin(ALLOWED_ERROR).of(x1);
    assertThat(transformation.inverse().transform(y1 + yDelta))
        .isWithin(ALLOWED_ERROR)
        .of(x1 + xDelta);
    assertThat(transformation.slope()).isWithin(ALLOWED_ERROR).of(yDelta / xDelta);

// Returns list of goroutines that become runnable.
// delay < 0: blocks indefinitely
// delay == 0: does not block, just polls
// delay > 0: block for up to that many nanoseconds
func netpoll(delay int64) (gList, int32) {
	if epfd == -1 {
		return gList{}, 0
	}
	var waitms int32
	if delay < 0 {
		waitms = -1
	} else if delay == 0 {
		waitms = 0
	} else if delay < 1e6 {
		waitms = 1
	} else if delay < 1e15 {

  // remat.insert. We store changes to the alloc/dealloc sizes due to the
  // insertion in a vector `delta`: A change `c_alloc` of `operations_[i].alloc`
  // as `delta[i] += c_alloc`, and a change `c_dealloc` of
  // `operations_[i].dealloc` as `delta[i+1] -= c_dealloc`.
  std::vector<MemSpec> deltas;

  if (remat.begin == remat.end) {
    return deltas;
  }

  // Helper lambda: converts an operation index in the original range to its

			sum += delta(r0, r1)
			sum += delta(g0, g1)
			sum += delta(b0, b1)
			n += 3
		}
	}
	return sum / n
}

// lzw.NewWriter wants an interface which is basically the same thing as gif's
// writer interface.  This ensures we're compatible.
var _ writer = blockWriter{}

var testCase = []struct {
	filename  string
	tolerance int64
}{
	{"../testdata/video-001.png", 1 << 12},
	{"../testdata/video-001.gif", 0},

	t.Parallel()
	const Count = 10
	Delta := 100 * Millisecond
	if testing.Short() {
		Delta = 10 * Millisecond
	}
	t0 := Now()
	for i := 0; i < Count; i++ {
		<-After(Delta)
	}
	t1 := Now()
	d := t1.Sub(t0)
	target := Delta * Count
	if d < target*9/10 {
		t.Fatalf("%d ticks of %s too fast: took %s, expected %s", Count, Delta, d, target)
	}
	if !testing.Short() && d > target*30/10 {

	hi := len(caseRange)
	for lo < hi {
		m := int(uint(lo+hi) >> 1)
		cr := caseRange[m]
		if rune(cr.Lo) <= r && r <= rune(cr.Hi) {
			delta := cr.Delta[_case]
			if delta > MaxRune {
				// In an Upper-Lower sequence, which always starts with
				// an UpperCase letter, the real deltas always look like:
				//	{0, 1, 0}    UpperCase (Lower is next)
				//	{-1, 0, -1}  LowerCase (Upper, Title are previous)

// delay < 0: blocks indefinitely
// delay == 0: does not block, just polls
// delay > 0: block for up to that many nanoseconds
func netpoll(delay int64) (gList, int32) {
	if kq == -1 {
		return gList{}, 0
	}
	var tp *timespec
	var ts timespec
	if delay < 0 {
		tp = nil
	} else if delay == 0 {
		tp = &ts
	} else {
		ts.setNsec(delay)
		if ts.tv_sec > 1e6 {

					continue
				}
				var v any
				if row.Counter != nil {
					cv := *row.Counter.Value
					key := toMetricKey(row, metric)
					if delta, f := m.deltas[key]; f {
						cv -= delta
					}
					v = cv
				} else if row.Gauge != nil {
					v = *row.Gauge.Value
				} else if row.Histogram != nil {
					v = row.Histogram
				}
				err := compare(v)