func u8(i int) uint8 {
	i = 'a' + i%26
	return uint8(i)
}

func u16(ii int) uint16 {
	var i = uint16(ii)
	i = 'a' + i%26
	i |= i << 8
	return i
}

func u32(ii int) uint32 {
	var i = uint32(ii)
	i = 'a' + i%26
	i |= i << 8
	i |= i << 16
	return i
}

func u64(ii int) uint64 {
	var i = uint64(ii)
	i = 'a' + i%26
	i |= i << 8
	i |= i << 16
	i |= i << 32
	return i
}

	const pp = unsafe.Alignof(p)
	assert(pp == 8)
	const ll = unsafe.Alignof(l)
	assert(ll == 8)
	const ff = unsafe.Alignof(f)
	assert(ff == 8)
	const ii = unsafe.Alignof(i)
	assert(ii == 8)
	const cc = unsafe.Alignof(c)
	assert(cc == 8)
	const mm = unsafe.Alignof(m)
	assert(mm == 8)
	const _ = unsafe /* ERROR "not constant" */ .Alignof(t)
}

// unsafe.Offsetof

TEST_F(LinalgGradTest, Einsum_Trace) {
  TensorShape x_shape({3, 3});
  Output x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(x_shape));
  // Note: In Python this could just be "ii" becuase tf.einsum normalizes the
  // equation, but c++ doesn't do that.
  auto z = Einsum(scope_, {x}, "ii->");
  TensorShape z_shape({});
  RunTest({x}, {x_shape}, {z}, {z_shape});
}

TEST_F(LinalgGradTest, Einsum_TraceBroadcast) {

	} else if len(jk.Keys) != 2 {
		t.Fatalf("Expected 2 keys, got %d", len(jk.Keys))
	}

	keys := make([]crypto.PublicKey, len(jk.Keys))
	for ii, jks := range jk.Keys {
		var err error
		keys[ii], err = jks.DecodePublicKey()
		if err != nil {
			t.Fatalf("Failed to decode key %d: %v", ii, err)
		}
	}

	//nolint:gocritic
	if key0, ok := keys[0].(*ecdsa.PublicKey); !ok {
		t.Fatalf("Expected ECDSA key[0], got %T", keys[0])

	isDefault := func(item any) bool {
		var ii intstr.IntOrString
		switch item := item.(type) {
		case int:
			ii = intstr.FromInt32(int32(item))
		case int64:
			ii = intstr.FromInt32(int32(item))
		case string:
			ii = intstr.FromString(item)
		default:
			ii = intstr.FromInt32(0)
		}
		intVal, err := intstr.GetScaledValueFromIntOrPercent(&ii, 100, false)
		if err != nil || intVal == 0 {

//go:build ppc64 || ppc64le

#include "textflag.h"

TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
	// LWSYNC is the "export" barrier recommended by Power ISA
	// v2.07 book II, appendix B.2.2.2.
	// LWSYNC is a load/load, load/store, and store/store barrier.
	LWSYNC

}

type Conc struct {
	X int
}

func (c *Conc) Count() int {
	return c.X
}

func DoCall(c *Conc) {
	c2 := Callee(c)
	println(c2.Count())
}

func Callee(ii Ctr) Ctr {
	q := ii.Count()
	return &Conc{X: q}
}
-- main/main.go --
package main

import (
	"M/a"
	"M/b"
)

func MFunc() string {
	return "42"
}

func M2Func() int {

	v := 0 // ERROR "moved to heap: v$"
	b.ii = &v
	return b.ii
}

func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
	v := 0 // ERROR "moved to heap: v$"
	b.ii = &v
	return b.ii
}

func (b Bar) StillNoLeak() int { // ERROR "b does not escape$"
	v := 0
	b.ii = &v
	return b.i
}

func goLeak(b *Bar) { // ERROR "leaking param: b$"
	go b.NoLeak()

                        UniAddress[] addrs = new UniAddress[iaddrs.length];
                        for (int ii = 0; ii < iaddrs.length; ii++) {
                            addrs[ii] = new UniAddress(iaddrs[ii]);
                        }
                        return addrs; // Success
                    default:
                        throw new UnknownHostException( hostname );

}

func f1() (_ int, err error) {
	return 1, nil
}

func g1() (x int, _ error) {
	return 1, nil
}

func h1() (_ int, _ error) {
	return 1, nil
}

func ii() (int, error) {
	return 1, nil