defer append(x, 1) // ERROR "defer discards result of append|is not used"
	defer append(x, 1) // ERROR "defer discards result of append|is not used"
	defer unsafe.Alignof(t.X) // ERROR "defer discards result of unsafe.Alignof|is not used"
	defer unsafe.Offsetof(t.X) // ERROR "defer discards result of unsafe.Offsetof|is not used"
	defer unsafe.Sizeof(t) // ERROR "defer discards result of unsafe.Sizeof|is not used"
	

	complex(1, 2)			// ERROR "not used"
	imag(1i)			// ERROR "not used"
	len(a)				// ERROR "not used"
	make([]int, 10)			// ERROR "not used"
	new(int)			// ERROR "not used"
	real(1i)			// ERROR "not used"
	unsafe.Alignof(a)		// ERROR "not used"
	unsafe.Offsetof(s.f)		// ERROR "not used"
	unsafe.Sizeof(a)		// ERROR "not used"

	close(c)
	copy(a, a)
	delete(m, 0)
	panic(0)
	print("foo")
	println("bar")
	recover()

	{"Add", `_ = unsafe.Add(nil, 0)`, `func(unsafe.Pointer, int) unsafe.Pointer`},

	{"Alignof", `_ = unsafe.Alignof(0)`, `invalid type`},                 // constant
	{"Alignof", `var x struct{}; _ = unsafe.Alignof(x)`, `invalid type`}, // constant
	{"Alignof", `var x P; _ = unsafe.Alignof(x)`, `func(P) uintptr`},

	{"Offsetof", `var x struct{f bool}; _ = unsafe.Offsetof(x.f)`, `invalid type`},           // constant

	{"Add", `_ = unsafe.Add(nil, 0)`, `func(unsafe.Pointer, int) unsafe.Pointer`},

	{"Alignof", `_ = unsafe.Alignof(0)`, `invalid type`},                 // constant
	{"Alignof", `var x struct{}; _ = unsafe.Alignof(x)`, `invalid type`}, // constant
	{"Alignof", `var x P; _ = unsafe.Alignof(x)`, `func(P) uintptr`},

	{"Offsetof", `var x struct{f bool}; _ = unsafe.Offsetof(x.f)`, `invalid type`},           // constant

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

import "unsafe"

func _[T any](x T) {
	_ = unsafe.Alignof(x)
	_ = unsafe.Sizeof(x)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

import "unsafe"

func F[T any](v T) uintptr {
	return unsafe.Alignof(func() T {
		func(any) {}(struct{ _ T }{})
		return v
	}())
}

func f() {
	F(0)

// license that can be found in the LICENSE file.

// Issue 7525: self-referential array types.

package main

import "unsafe"

var x struct { // GC_ERROR "initialization cycle: x refers to itself"
	c [unsafe.Alignof(x.c)]int // GCCGO_ERROR "array bound|typechecking loop|invalid array"

	}

	if tab.baseList[0] != nil || tab.indexMap[nil] != 0 {
		t.Errorf("nil base not at index 0")
	}
}

func TestSize(t *testing.T) {
	var p XPos
	if unsafe.Alignof(p) != 4 {
		t.Errorf("alignment = %v; want 4", unsafe.Alignof(p))
	}
	if unsafe.Sizeof(p) != 8 {
		t.Errorf("size = %v; want 8", unsafe.Sizeof(p))
	}
}

func TestSetBase(t *testing.T) {
	var tab PosTable
	b1 := NewFileBase("b1", "b1")

type T2 struct {
	A int32
	U2
}

type U2 struct {
	B int32
	C int32
}

var t2 T2
var p2 *T2

func main() {
	// Test unsafe.Sizeof, unsafe.Alignof, and unsafe.Offsetof all return uintptr.
	isUintptr(unsafe.Sizeof(t))
	isUintptr(unsafe.Alignof(t))
	isUintptr(unsafe.Offsetof(t.X))

	// Test correctness of Offsetof with respect to embedded fields (issue 4909).
	if unsafe.Offsetof(t2.C) != 8 {

// license that can be found in the LICENSE file.

package a

import "unsafe"

func F[T any]() uintptr {
	var t T
	return unsafe.Sizeof(t)
}

func G[T any]() uintptr {
	var t T
	return unsafe.Alignof(t)
}

//func H[T any]() uintptr {
//	type S struct {
//		a T
//		b T
//	}
//	var s S
//	return unsafe.Offsetof(s.b)