_ = bool(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(.*untyped complex.*\) to type bool|invalid type conversion"

	_ = string(true) // ERROR "cannot convert true \(.*untyped bool.*\) to type string|invalid type conversion"
	_ = string(-1)
	_ = string(1.0)     // ERROR "cannot convert 1.* \(.*untyped float.*\) to type string|invalid type conversion"

// Complex literal comparison

package p

const x = 1i
const y = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
const z = x < 2i  // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"

func f() {
	_ = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"

		panic("s[0] != 1")
	}
	if s[1] != 2+3i {
		println(s[1])
		panic("s[1] != 2+3i")
	}
	if s[2] != 4+5i {
		println(s[2])
		panic("s[2] != 4+5i")
	}

	x := 1 + 2i
	y := a.Mul(x)
	if y != (1+2i)*(3+4i) {
		println(y)
		panic("y != (1+2i)*(3+4i)")
	}

	_ int = real(1)
	_ int = real('a')
	_ int = real(2.0)
	_ int = real(3i)

	_ float32 = real(1)
	_ float32 = real('a')
	_ float32 = real(2.1)
	_ float32 = real(3.2i)

	_ float64 = real(1)
	_ float64 = real('a')
	_ float64 = real(2.1)
	_ float64 = real(3.2i)

	_ int = imag(1)
	_ int = imag('a')
	_ int = imag(2.1 + 3i)
	_ int = imag(3i)

	_ float32 = imag(1)
	_ float32 = imag('a')
	_ float32 = imag(2.1 + 3.1i)

		n += 0.1i
		res += n / d
	}
	result = res
}

func BenchmarkComplex128DivDisNaN(b *testing.B) {
	d := 15 + 2i
	n := cmplx.NaN()
	res := 0i
	for i := 0; i < b.N; i++ {
		d += 0.1i
		res += n / d
	}
	result = res
}

func BenchmarkComplex128DivNisInf(b *testing.B) {
	d := 15 + 2i
	n := cmplx.Inf()
	res := 0i
	for i := 0; i < b.N; i++ {
		d += 0.1i
		res += n / d
	}
	result = res
}

	"testing"
)

func TestFormatComplex(t *testing.T) {
	tests := []struct {
		c       complex128
		fmt     byte
		prec    int
		bitSize int
		out     string
	}{
		// a variety of signs
		{1 + 2i, 'g', -1, 128, "(1+2i)"},
		{3 - 4i, 'g', -1, 128, "(3-4i)"},
		{-5 + 6i, 'g', -1, 128, "(-5+6i)"},
		{-7 - 8i, 'g', -1, 128, "(-7-8i)"},

		// test that fmt and prec are working

// Copyright 2013 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

func main() {
	_ = string(-4 + 2i + 2) // ERROR "-4 \+ 2i|invalid type conversion"

	{"%.3g", 0i, "(0+0i)"},
	{"%.3e", 1 + 2i, "(1.000e+00+2.000e+00i)"},
	{"%.3x", 1 + 2i, "(0x1.000p+00+0x1.000p+01i)"},
	{"%.3f", 1 + 2i, "(1.000+2.000i)"},
	{"%.3g", 1 + 2i, "(1+2i)"},
	{"%.3e", -1 - 2i, "(-1.000e+00-2.000e+00i)"},
	{"%.3x", -1 - 2i, "(-0x1.000p+00-0x1.000p+01i)"},
	{"%.3f", -1 - 2i, "(-1.000-2.000i)"},
	{"%.3g", -1 - 2i, "(-1-2i)"},
	{"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"},

//go:noinline
func complex128_ssa(a, b complex128, x bool) complex128 {
	var c complex128
	if x {
		c = a
	} else {
		c = b
	}
	return c
}

func testComplex64(t *testing.T) {
	var a complex64 = 1 + 2i
	var b complex64 = 3 + 4i

	if want, got := a, complex64_ssa(a, b, true); got != want {
		t.Errorf("complex64_ssa(%v, %v, true) = %v, want %v\n", a, b, got, want)
	}

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

package p

func f(b bool, c complex128) func(complex128) complex128 {
	return func(p complex128) complex128 {
		b = (p+1i == 0) && b
		return (p + 2i) * (p + 3i - c)
	}