i, ok = m[0]
	test(i, 42)
	test(ok, true)

	_, ok = m[0]
	test(ok, true)

	// Type assertions.
	var u interface{}

	i, ok = u.(int)
	test(i, 0)
	test(ok, false)

	ip, ok = u.(*int)
	test(ip, (*int)(nil))
	test(ok, false)

	_, ok = u.(int)
	test(ok, false)

	u = 42
	i, ok = u.(int)
	test(i, 42)
	test(ok, true)

	_, ok = u.(int)
	test(ok, true)

	for i := 0; i < len(roundtests); i++ {
		test := &roundtests[i]
		d := NewDecimal(test.i)
		d.RoundDown(test.nd)
		s := d.String()
		if s != test.down {
			t.Errorf("Decimal %v RoundDown %d = %v, want %v",
				test.i, test.nd, s, test.down)
		}
		d = NewDecimal(test.i)
		d.Round(test.nd)
		s = d.String()
		if s != test.round {
			t.Errorf("Decimal %v Round %d = %v, want %v",
				test.i, test.nd, s, test.down)
		}

		{testSliceLenCap2_ssa, -1, 5, 5, 10},
		{testSliceLenCap2_ssa, -1, 10, 10, 10},
	}

	for i, test := range tests {
		if l, c := test.fn(a, test.i, test.j); l != test.l && c != test.c {
			t.Errorf("#%d len(a[%d:%d]), cap(a[%d:%d]) = %d %d, want %d %d", i, test.i, test.j, test.i, test.j, l, c, test.l, test.c)
		}
	}
}

//go:noinline
func testSliceGetElement_ssa(a [10]int, i, j, p int) int {
	return a[i:j][p]
}

	return s[i]
}

func testStringElem(t *testing.T) {
	tests := []struct {
		s string
		i int
		n byte
	}{
		{"foobar", 3, 98},
		{"foobar", 0, 102},
		{"foobar", 5, 114},
	}
	for _, test := range tests {
		if got := testStringElem_ssa(test.s, test.i); got != test.n {
			t.Errorf("testStringElem \"%s\"[%d] = %d, wanted %d", test.s, test.i, got, test.n)
		}
	}
}

//go:noinline

			fmt.Printf("$I($F(%f)) = %v, expected %v\n", f, v, i)
		}
	}`

const testFunc =
`func test$I(f float64, i int64) {
	if i != int64($I(i))$TEST {
		return
	}
$TESTSEGMENTS
}
`

var program =
`package main

import (
	"fmt"
	"math"
)

var tests = []struct {
	f float64
	i int64
}{
	{39.7, 39},
	{-39.7, -39},
	{258.6, 258},
	{-258.6, -258},

var errors int

func logf(f string, args ...interface{}) {
	errors++
	fmt.Printf(f, args...)
	if errors > 100 { // 100 is enough spewage
		panic("100 errors is plenty is enough")
	}
}

func test(i int, x uint64) {
	t := T.TrailingZeros64(x) // ERROR "intrinsic substitution for TrailingZeros64"
	if i != t {
		logf("TrailingZeros64(0x%x) expected %d but got %d\n", x, i, t)
	}
	x = -x

     */
    @Test
    public void testPerformance() throws Exception {
        final int num = 100;
        long start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            System.out.println("test" + i);
        }
        final long sysout = System.currentTimeMillis() - start;
        start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            logger.fatal("test" + i);
        }

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

package a

// Type I is the first basic test for the issue, which relates to a type that is recursive
// via a type constraint.  (In this test, I -> IConstraint -> MyStruct -> I.)
type JsonRaw []byte

type MyStruct struct {
	x *I[JsonRaw]
}

type IConstraint interface {
	JsonRaw | MyStruct
}

final class MainKt$test$1 {
    // source: 'main.kt'
    enclosing method MainKt.test()I
    public final static field INSTANCE: MainKt$test$1
    inner (anonymous) class MainKt$test$1
    static method <clinit>(): void
    method <init>(): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$test$1

    implementation -> testVariantExecutableImplementation [style=invis, weight=1000]
    testVariantExecutableImplementation -> implementation [headport=s, tailport=n]

    testVariantExecutableImplementation[label=<test<i>Variant</i>ExecutableImplementation>]
    implementation[style=dashed]
  }

  subgraph left {
    node[style=filled, fillcolor="#cfe2f3"]