return unsafe.Sizeof(x)
}

// size returns the alignment of type T
func align[T any](x T) uintptr {
	return unsafe.Alignof(x)
}

type Tstruct[T any] struct {
	f1 T
	f2 int
}

// offset returns the offset of field f2 in the generic type Tstruct
func (r *Tstruct[T]) offset() uintptr {
	return unsafe.Offsetof(r.f2)
}

func main() {
	v1 := int(5)
	if got, want := size(v1), unsafe.Sizeof(v1); got != want {

func fString(a string) string { return a }

type TestStringAlias string

func fStringAlias(a TestStringAlias) TestStringAlias { return a }

type TestStruct struct {
	A int
	B string
}

func fStruct(a TestStruct) TestStruct { return a }

type TestStructAlias TestStruct

func fStructAlias(a TestStructAlias) TestStructAlias { return a }

func fUint16(a uint16) uint16 { return a }

type TestUint16Alias uint16

    override val analysisSession: KaFirSession,
) : KaDestructuringDeclarationSymbol(), KaFirSymbol<FirVariableSymbol<*>> {

    init {
        require(firSymbol.name == SpecialNames.DESTRUCT)
    }

    override val psi: KtDestructuringDeclaration
        get() = withValidityAssertion {
            when (val psi = firSymbol.fir.psi) {
                is KtDestructuringDeclaration -> psi

#include "tensorflow/c/eager/immediate_execution_operation.h"

// Wraps a pointer to an operation implementation.
//
// WARNING: Since the underlying object could be ref-counted a user of this
// interface cannot destruct the underlying operation object. Instead, call
// TFE_DeleteOp who calls Release() on the operation pointer and deletes
// the TFE_Op structure.
typedef struct TFE_Op TFE_Op;

namespace tensorflow {

	testCloneSeq[testStringArray](t, cSeq(0, 2*goarch.PtrSize, 4*goarch.PtrSize))
	testCloneSeq[testStringStruct](t, cSeq(0))
	testCloneSeq[testStringStructArrayStruct](t, cSeq(0, 2*goarch.PtrSize))
	testCloneSeq[testStruct](t, cSeq(8))
}

func cSeq(stringOffsets ...uintptr) cloneSeq {
	return cloneSeq{stringOffsets: stringOffsets}
}

func testCloneSeq[T any](t *testing.T, want cloneSeq) {
	typName := reflect.TypeFor[T]().Name()

#include "tensorflow/c/eager/immediate_execution_tensor_handle.h"

// Wraps a pointer to a tensor handle implementation.
//
// WARNING: Since the underlying object could be ref-counted a user of this
// interface cannot destruct the underlying handle object. Instead, call
// TFE_DeleteTensorHandle who calls Release() on the handle pointer and deletes
// the TFE_TensorHandle structure.
typedef struct TFE_TensorHandle TFE_TensorHandle;

	_ = x[TUINTPTR-11]
	_ = x[TCOMPLEX64-12]
	_ = x[TCOMPLEX128-13]
	_ = x[TFLOAT32-14]
	_ = x[TFLOAT64-15]
	_ = x[TBOOL-16]
	_ = x[TPTR-17]
	_ = x[TFUNC-18]
	_ = x[TSLICE-19]
	_ = x[TARRAY-20]
	_ = x[TSTRUCT-21]
	_ = x[TCHAN-22]
	_ = x[TMAP-23]
	_ = x[TINTER-24]
	_ = x[TFORW-25]
	_ = x[TANY-26]
	_ = x[TSTRING-27]
	_ = x[TUNSAFEPTR-28]
	_ = x[TIDEAL-29]
	_ = x[TNIL-30]
	_ = x[TBLANK-31]
	_ = x[TFUNCARGS-32]

#include "tensorflow/c/eager/immediate_execution_context.h"

// Wraps a pointer to a context implementation.
//
// WARNING: Since the underlying object could be ref-counted a user of this
// interface cannot destruct the underlying context object. Instead, call
// TFE_DeleteContext who calls Release() on the context pointer and deletes
// the TFE_Context structure.
typedef struct TFE_Context TFE_Context;

namespace tensorflow {

		t.Errorf("got %v, wanted {'Test': 12u, 'Check': 34u}", mpStrUint)
	}
	tstStr, err := mv.ConvertToNative(reflect.TypeOf(&tstStruct{}))
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(tstStr, &tstStruct{
		Test:  uint64(12),
		Check: uint64(34),
	}) {
		t.Errorf("got %v, wanted tstStruct{Test: 12u, Check: 34u}", tstStr)
	}
}

func TestMapValueEqual(t *testing.T) {
	mv := NewMapValue()

	tags   []string // field tags; nil if there are no tags
}

// NewStruct returns a new struct with the given fields and corresponding field tags.
// If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be
// only as long as required to hold the tag with the largest index i. Consequently,
// if no field has a tag, tags may be nil.
func NewStruct(fields []*Var, tags []string) *Struct {
	var fset objset