// Use of this source code is governed by a BSD-style
// 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)

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

func F[T any]() {

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type T[K any] struct {

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type Integer interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

type Builder[T Integer] struct{}

func (r Builder[T]) New() T {
	return T(42)

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "C"

import (
	"os"
	"runtime"
	"sync/atomic"
)

var started int32

// Start a goroutine that loops forever.
func init() {
	runtime.GOMAXPROCS(1)
	go func() {
		for {
			atomic.StoreInt32(&started, 1)
		}
	}()
}

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type Container[T any] struct {
	X T
}

func NewContainer[T any](x T) *Container[T] {
	return &Container[T]{x}
}

type MetaContainer struct {
	C *Container[Value]
}

type Value struct{}

func NewMetaContainer() *MetaContainer {

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

import (
	"fmt"
	"sync"
)

type WrapperWithLock[T any] interface {
	PrintWithLock()
}

func NewWrapperWithLock[T any](value T) WrapperWithLock[T] {
	return &wrapperWithLock[T]{
		Object: value,
	}
}

type wrapperWithLock[T any] struct {

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

import "unsafe"

func Append() {
	_ = append(appendArgs())
}

func Delete() {
	delete(deleteArgs())
}

func Print() {
	print(ints())
}

func Println() {
	println(ints())
}

func Complex() {
	_ = complex(float64s())
}

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type I interface{ M() }
type T int

func (T) M() {} // ERROR "can inline T.M"

func E() I { // ERROR "can inline E"
	return T(0) // ERROR "T\(0\) escapes to heap"
}

func F(i I) I { // ERROR "can inline F" "leaking param: i to result ~r0 level=0"
	i = nil
	return i

console.log('a');...