return nil, err
		}
		c.address = net.JoinHostPort(lb, fmt.Sprint(svc.Spec.Ports[0].Port))
		c.addressVM = net.JoinHostPort(lb, fmt.Sprint(svc.Spec.Ports[1].Port))
	} else {
		c.address = net.JoinHostPort(svc.Spec.ClusterIP, fmt.Sprint(svc.Spec.Ports[0].Port))
		c.addressVM = net.JoinHostPort(svc.Spec.ClusterIP, fmt.Sprint(svc.Spec.Ports[1].Port))
	}

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

// used to panic because 6g didn't generate
// the code to fill in the ... argument to fmt.Sprint.

package main

import "fmt"

type T struct {
	a, b, c, d, e []int;
}

var t T

func main() {
	if fmt.Sprint("xxx", t) != "yyy" { 
	}

	for _, tt := range tests {
		got := itoa.Itoa(tt)
		want := fmt.Sprint(tt)
		if want != got {
			t.Fatalf("Itoa(%d) = %s, want %s", tt, got, want)
		}
	}
}

func TestUitoa(t *testing.T) {
	tests := []uint{0, 1, 100, 999, math.MaxUint32, uint(maxUint64)}
	for _, tt := range tests {
		got := itoa.Uitoa(tt)
		want := fmt.Sprint(tt)
		if want != got {
			t.Fatalf("Uitoa(%d) = %s, want %s", tt, got, want)
		}

	{ET_LOOS + 5, "ET_LOOS+5"},
	{ProgFlag(0x50), "0x50"},
	{COMPRESS_ZLIB + 2, "COMPRESS_ZSTD+1"},
}

func TestNames(t *testing.T) {
	for i, tt := range nameTests {
		s := fmt.Sprint(tt.val)
		if s != tt.str {
			t.Errorf("#%d: Sprint(%d) = %q, want %q", i, tt.val, s, tt.str)
		}
	}

func copyStringInterfaceMap(m map[string]any) map[string]any {
	out := make(map[string]any, len(m))
	for k, v := range m {
		out[k] = v
	}
	return out
}

func maybeSprintf(format string, args []any) string {
	msg := format
	if len(args) > 0 {
		msg = fmt.Sprintf(format, args...)
	}
	return msg

// Test defer.

package main

import "fmt"

var result string

func addInt(i int) { result += fmt.Sprint(i) }

func test1helper() {
	for i := 0; i < 10; i++ {
		defer addInt(i)
	}
}

func test1() {
	result = ""
	test1helper()
	if result != "9876543210" {
		fmt.Printf("test1: bad defer result (should be 9876543210): %q\n", result)
		panic("defer")
	}
}

				Containers:  []string{"c4", "c5"},
				Labels: map[string]string{
					"l4": "lv4",
					"l5": "lv5",
				},
				Annotations: map[string]string{
					"a4": "av4",
					"a5": "av5",
				},
			},
		},
		Exclude: []*SelectionSpec{
			{
				Namespaces:  []string{"ns7", "ns8"},
				Deployments: []string{"d7", "d8"},
				Pods:        []string{"p7", "p8"},
				Containers:  []string{"c7", "c8"},

}

func (l *ConsoleLogger) LogAndPrintf(format string, a ...any) {
	s := fmt.Sprintf(format, a...)
	l.Print(s + "\n")
	l.scope.Infof(s)
}

func (l *ConsoleLogger) LogAndErrorf(format string, a ...any) {
	s := fmt.Sprintf(format, a...)
	l.PrintErr(s + "\n")
	l.scope.Infof(s)
}

func (l *ConsoleLogger) LogAndFatalf(format string, a ...any) {
	l.LogAndErrorf(format, a...)
	os.Exit(-1)
}

		}
		if d != kle {
			te.Errorf("d(%v) != kle(%v)", d, kle)
		}
		// data
		if s != fmt.Sprint(g) {
			te.Errorf("s(%v) != g(%v)", s, g)
		}
		if s != fmt.Sprint(l) {
			te.Errorf("s(%v) != l(%v)", s, l)
		}
		if s != fmt.Sprint(ge) {
			te.Errorf("s(%v) != ge(%v)", s, ge)
		}
		if s != fmt.Sprint(le) {
			te.Errorf("s(%v) != le(%v)", s, le)
		}
	}

	for _, d := range x {

		}
		// fmt.Sprint() over String() as nil.String() will panic
		if fmt.Sprint(out) != fmt.Sprint(tc.out) {
			t.Errorf("[%v]expected:\n\t%s\nbut got:\n\t%s", i, fmt.Sprint(tc.out), fmt.Sprint(out))
		}
	}
}

func BenchmarkLabelSelectorAsSelector(b *testing.B) {
	selector := &LabelSelector{
		MatchLabels: map[string]string{
			"foo": "foo",
			"bar": "bar",
		},