// may lead to collisions. Introduce another way to get a unique id for this
// tensor.
int64_t ToId(const AbstractTensorHandle* t) {
  return static_cast<int64_t>(reinterpret_cast<uintptr_t>(t));
}

absl::Status ZerosLike(AbstractContext* ctx, AbstractTensorHandle* t,
                       AbstractTensorHandle** result) {
  AbstractOperationPtr op(ctx->CreateOperation());

pkg syscall (windows-386), type AddrinfoW struct, Addr uintptr
pkg syscall (windows-386), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
pkg syscall (windows-386), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
pkg syscall (windows-386), type CertContext struct, CertInfo uintptr
pkg syscall (windows-386), type CertRevocationInfo struct, CrlInfo uintptr

// uint is an unsigned integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, uint32.
type uint uint

// uintptr is an integer type that is large enough to hold the bit pattern of
// any pointer.
type uintptr uintptr

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.

func CallerFrame() runtime.Frame {
	// Preserve the original CallerFrame stack depth after introducing callerFrame().
	return callerFrame(4)
}

func callerFrame(skip int) runtime.Frame {
	pcs := [13]uintptr{}
	// skip is caller-path sensitive and should be selected by each public helper.
	len := runtime.Callers(skip, pcs[:])
	frames := runtime.CallersFrames(pcs[:len])
	for i := 0; i < len; i++ {

package unsafe

type ArbitraryType int  // shorthand for an arbitrary Go type; it is not a real type
type Pointer *ArbitraryType

func Alignof(variable ArbitraryType) uintptr
func Offsetof(selector ArbitraryType) uintptr
func Sizeof(variable ArbitraryType) uintptr

type IntegerType int  // shorthand for an integer type; it is not a real type
func Add(ptr Pointer, len IntegerType) Pointer

		2: {"-", 10, ""},
		3: {"gopher", 0, ""},
		4: {"-", -1, "negative"},
		5: {"--", -102, "negative"},
		6: {string(make([]byte, 255)), int((^uint(0))/255 + 1), "overflow"},
	})

	const is64Bit = 1<<(^uintptr(0)>>63)/2 != 0
	if !is64Bit {
		return
	}

	runTestCases("64-bit", []testCase{
		0: {"-", maxInt, "out of range"},
	})
}

type RunesTest struct {
	in    string
	out   []rune

partial word removed. func words(x []byte) []uintptr { n := uintptr(len(x)) / wordSize if n == 0 { // Avoid creating a *uintptr that refers to data smaller than a uintptr; // see issue 59334. return nil } return unsafe.Slice((*uintptr)(unsafe.Pointer(&x[0])), n) } func xorLoop[T byte | uintptr](dst, x, y []T) { x = x[:len(dst)] // remove bounds check in loop y = y[:len(dst)] // remove bounds check in loop for i := range dst { dst[i] = x[i] ^ y[i] } } golang.org/fips140@v1.26.0/fips140/v1.26.0/subtle/xor_loong64.go...