return fmt.Errorf("Int.GobDecode: encoding version %d not supported", b>>1)
	}
	z.neg = b&1 != 0
	z.abs = z.abs.setBytes(buf[1:])
	return nil
}

// MarshalText implements the [encoding.TextMarshaler] interface.
func (x *Int) MarshalText() (text []byte, err error) {
	if x == nil {
		return []byte("<nil>"), nil
	}
	return x.abs.itoa(x.neg, 10), nil
}

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.

// Abs method to a structure containing base types.

package main

import (
	"fmt"
	"math"
)

type Numeric interface {
	OrderedNumeric | Complex
}

// absDifference computes the absolute value of the difference of
// a and b, where the absolute value is determined by the abs function.
func absDifference[T Numeric](a, b T, abs func(a T) T) T {
	return abs(a - b)
}

	return !isNaN(f - f)
}

// isInf reports whether f is an infinity.
func isInf(f float64) bool {
	return !isNaN(f) && !isFinite(f)
}

// abs returns the absolute value of x.
//
// Special cases are:
//
//	abs(±Inf) = +Inf
//	abs(NaN) = NaN
func abs(x float64) float64 {
	const sign = 1 << 63
	return float64frombits(float64bits(x) &^ sign)
}

// copysign returns a value with the magnitude

	r.prevRune = -1
	var abs int64
	switch whence {
	case io.SeekStart:
		abs = offset
	case io.SeekCurrent:
		abs = r.i + offset
	case io.SeekEnd:
		abs = int64(len(r.s)) + offset
	default:
		return 0, errors.New("strings.Reader.Seek: invalid whence")
	}
	if abs < 0 {
		return 0, errors.New("strings.Reader.Seek: negative position")
	}
	r.i = abs
	return abs, nil
}

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

// numericAbs matches numeric types with an Abs method.
type numericAbs[T Numeric] interface {
	~struct{ Value T }
	Abs() T
}

// AbsDifference computes the absolute value of the difference of
// a and b, where the absolute value is determined by the Abs method.
func absDifference[T numericAbs[T /* ERROR "T does not satisfy Numeric" */]](a, b T) T {

  // CHECK: %[[Q1:.*]] = stablehlo.uniform_quantize %[[ARG0]]
  // CHECK: %[[Q2:.*]] = stablehlo.uniform_quantize %[[Q1]]
  // CHECK: %[[ABS:.*]] = stablehlo.abs %[[Q2]]
  // CHECK: %[[DQ:.*]] = stablehlo.uniform_dequantize %[[ABS]]
  // CHECK: %[[ADD:.*]] = stablehlo.add %[[ARG0]], %[[DQ]]
  // CHECK: return %[[ADD]]

	if timekeepSharedPage == nil || timekeepSharedPage.ver != _VDSO_TK_VER_CURR {
		return zeroBintime
	}
	abs := false
	switch clockID {
	case _CLOCK_MONOTONIC:
		/* ok */
	case _CLOCK_REALTIME:
		abs = true
	default:
		return zeroBintime
	}
	return binuptime(abs)
}

func fallback_nanotime() int64
func fallback_walltime() (sec int64, nsec int32)

//go:nosplit
func nanotime1() int64 {

	}
	got = Sum(vec1)
	if want != got {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	fwant := vec2[0] + vec2[1]
	fgot := Sum[float64](vec2)
	if Abs(fgot-fwant) > 1e-10 {
		panic(fmt.Sprintf("got %f, want %f", fgot, fwant))
	}
	fgot = Sum(vec2)
	if Abs(fgot-fwant) > 1e-10 {
		panic(fmt.Sprintf("got %f, want %f", fgot, fwant))
	}

	case "gc":
		prec = math.Inf(1) // exact precision using rational arithmetic
	case "gccgo":
		prec = 256
	default:
		// unknown compiler
		return
	}
	p := 1 - math.Log(math.Abs(ulp))/math.Log(2)
	if math.Abs(p-prec) > 1e-10 {
		fmt.Printf("BUG: got %g; want %g\n", p, prec)
	}

    19: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS sum.cpp
    20: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS multiply.cpp
    21: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
    22: 00000000004021e0     0 OBJECT  LOCAL  DEFAULT   19 __FRAME_END__
    23: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS
    24: 0000000000402014     0 NOTYPE  LOCAL  DEFAULT   18 __GNU_EH_FRAME_HDR