t: func() {
			c := complex64(complex(float32(1.01), float32(1.01)))
			for i := 0; i < mods; i++ {
				c = complex(real(c)*1.01, imag(c)*1.01)
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *complex64 { return new(complex64) }()
			*a = complex64(complex(float32(1.01), float32(1.01)))
			for i := 0; i < mods; i++ {
				*a *= complex(real(*a)*1.01, imag(*a)*1.01)
				runtime.Gosched()

// Copyright 2010 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 cmplx

// Conj returns the complex conjugate of x.

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

// Issue 1368.

package main

func main() {
	a := complex(2, 2)
	a /= 2
}

/*
bug315.go:13: internal compiler error: optoas: no entry DIV-complex

		},

		"complex, empty": {
			Rule:     rbacv1.PolicyRule{},
			Simple:   false,
			Resource: simpleResource{},
		},
		"complex, no group": {
			Rule:     rbacv1.PolicyRule{Verbs: []string{"get"}, APIGroups: []string{}, Resources: []string{"builds"}},
			Simple:   false,
			Resource: simpleResource{},
		},
		"complex, multi group": {

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

package a

const N = 2+3i

func Func() []complex128 {
	return []complex128{1, complex(2, 3), complex(4, 5)}
}

func Mul(z complex128) complex128 {
	return z * (3 + 4i)

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

// Valid program, gccgo reported an error.
// bug307.go:14:6: error: complex arguments must have identical types

package main

func main() {
	var f float64
	_ = complex(1/f, 0)

	var x []int
	defer append(x, 1) // ERROR "defer discards result of append|is not used"
	defer cap(x) // ERROR "defer discards result of cap|is not used"
	defer complex(1, 2) // ERROR "defer discards result of complex|is not used"
	defer complex(f, 1) // ERROR "defer discards result of complex|is not used"
	defer imag(1i) // ERROR "defer discards result of imag|is not used"
	defer imag(c) // ERROR "defer discards result of imag|is not used"

gcc -gdwarf-4 -m64 -c typedef.c -o typedef.macho4
*/
#include <complex.h>

typedef volatile int* t_ptr_volatile_int;
typedef const char *t_ptr_const_char;
typedef long t_long;
typedef unsigned short t_ushort;
typedef int t_func_int_of_float_double(float, double);
typedef int (*t_ptr_func_int_of_float_double)(float, double);
typedef int (*t_ptr_func_int_of_float_complex)(float complex);
typedef int (*t_ptr_func_int_of_double_complex)(double complex);

		case math.IsInf(re, 0) || math.IsNaN(re):
			return complex(math.Copysign(0, re), math.Copysign(1, im))
		}
		return complex(math.Copysign(0, math.Sin(2*re)), math.Copysign(1, im))
	case re == 0 && math.IsNaN(im):
		return x
	}
	d := math.Cos(2*real(x)) + math.Cosh(2*imag(x))
	if math.Abs(d) < 0.25 {
		d = tanSeries(x)
	}
	if d == 0 {
		return Inf()
	}
	return complex(math.Sin(2*real(x))/d, math.Sinh(2*imag(x))/d)
}

	{"complex", `_ = complex(1, 0)`, `invalid type`}, // constant
	{"complex", `var re float32; _ = complex(re, 1.0)`, `func(float32, float32) complex64`},
	{"complex", `var im float64; _ = complex(1, im)`, `func(float64, float64) complex128`},
	{"complex", `type F32 float32; var re, im F32; _ = complex(re, im)`, `func(p.F32, p.F32) complex64`},