chki16(int16(u8), cu8&0xffff)
	chki16(int16(u16), cu16&0xffff-1<<16)
	chki16(int16(u32), cu32&0xffff)
	chki16(int16(u64), cu64&0xffff-1<<16)
	//	chki16(int16(f32), 0)
	//	chki16(int16(f64), 0)

	chki32(int32(i8), ci8&0xffffffff-1<<32)
	chki32(int32(i16), ci16&0xffffffff-1<<32)
	chki32(int32(i32), ci32&0xffffffff-1<<32)
	chki32(int32(i64), ci64&0xffffffff)
	chki32(int32(u8), cu8&0xffffffff)

	RET

// Test reporting of multiple over-the-limit chains
TEXT ·startChain(SB),NOSPLIT,$16-0
	CALL ·chain0(SB)
	CALL ·chain1(SB)
	CALL ·chain2(SB)
	RET
TEXT ·chain0(SB),NOSPLIT,$32-0
	CALL ·chainEnd(SB)
	RET
TEXT ·chain1(SB),NOSPLIT,$48-0 // Doesn't go over
	RET
TEXT ·chain2(SB),NOSPLIT,$64-0
	CALL ·chainEnd(SB)
	RET
TEXT ·chainEnd(SB),NOSPLIT,$1000-0 // Should be reported twice
	RET

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

package main

func main() { asmMain() }

func asmMain()

func startSelf()

func startChain()
func chain0()
func chain1()
func chain2()
func chainEnd()

func startRec()

	db := concurrent.Debouncer[config.GroupVersionKind]{}
	chKind := make(chan config.GroupVersionKind, 10)

	for _, k := range c.analyzer.Schemas().All() {
		c.analyzer.RegisterEventHandler(k.GroupVersionKind(), func(oldcfg config.Config, newcfg config.Config, ev model.Event) {
			gvk := oldcfg.GroupVersionKind
			if (gvk == config.GroupVersionKind{}) {
				gvk = newcfg.GroupVersionKind
			}
			chKind <- gvk
		})
	}

const (
	cj = 100011
	ci int = 100012
	ci8 int8 = 115
	ci16 int16 = 10016
	ci32 int32 = 100013
	ci64 int64 = 100014
	ci64big int64 = 1<<31
	ci64bigger int64 = 1<<32
	chuge = 1<<100
	cfgood = 2.0
	cfbad = 2.1

	cnj = -2
	cni int = -3
	cni8 int8 = -6
	cni16 int16 = -7
	cni32 int32 = -4
	cni64 int64 = -5
	cni64big int64 = -1<<31
	cni64bigger int64 = -1<<32
	cnhuge = -1<<100

pkg debug/elf, method (R_MIPS) GoString() string
pkg debug/elf, method (R_MIPS) String() string
pkg debug/elf, type Chdr32 struct
pkg debug/elf, type Chdr32 struct, Addralign uint32
pkg debug/elf, type Chdr32 struct, Size uint32
pkg debug/elf, type Chdr32 struct, Type uint32
pkg debug/elf, type Chdr64 struct
pkg debug/elf, type Chdr64 struct, Addralign uint64
pkg debug/elf, type Chdr64 struct, Size uint64

// CHECK-NEXT: %[[EX1:.*]] = tfr.call @tf__expand_dims(%[[CAST1]], %[[AXIS]]) : (!tfr.tensor, i32) -> !tfr.tensor
// CHECK-NEXT: %[[CONCAT1:.*]] = tfr.call @tf__risc_concat(%[[EX0]], %[[EX1]], %c0_i32) : (!tfr.tensor, !tfr.tensor, i32) -> !tfr.tensor
// CHECK-NEXT: %[[EX2:.*]] = tfr.call @tf__expand_dims(%[[CAST2]], %[[AXIS]]) : (!tfr.tensor, i32) -> !tfr.tensor

			`main.startChain<0>
    grows 32 bytes, calls main.chain0<0>
        grows 48 bytes, calls main.chainEnd<0>
            grows 1008 bytes
            %d bytes over limit
    grows 32 bytes, calls main.chain2<0>
        grows 80 bytes, calls main.chainEnd<0>
            grows 1008 bytes
            %d bytes over limit
`, 32+48+1008-limit, 32+80+1008-limit),
		"main.startRec": `main.startRec<0>

// runtime·_mul64x32(lo64 *uint64, a uint64, b uint32) (hi32 uint32)
// sets *lo64 = low 64 bits of 96-bit product a*b; returns high 32 bits.
TEXT runtime·_mul64by32(SB), NOSPLIT, $0
	MOVL	lo64+0(FP), CX
	MOVL	a_lo+4(FP), AX
	MULL	b+12(FP)
	MOVL	AX, 0(CX)
	MOVL	DX, BX
	MOVL	a_hi+8(FP), AX
	MULL	b+12(FP)
	ADDL	AX, BX
	ADCL	$0, DX
	MOVL	BX, 4(CX)
	MOVL	DX, AX
	MOVL	AX, hi32+16(FP)
	RET

		return slowdodiv(n, d)
	}

	if d > n {
		return 0, n
	}

	if uint32(d>>32) != 0 {
		t := uint32(n>>32) / uint32(d>>32)
		var lo64 uint64
		hi32 := _mul64by32(&lo64, d, t)
		if hi32 != 0 || lo64 > n {
			return slowdodiv(n, d)
		}
		return uint64(t), n - lo64
	}

	// d is 32 bit
	var qhi uint32
	if uint32(n>>32) >= uint32(d) {
		if uint32(d) == 0 {