IN 15: R{ F7 } spilloffset: 72 typ: float64
        IN 16: R{ F8 F9 } spilloffset: 80 typ: complex128
        IN 17: R{ F10 F11 } spilloffset: 96 typ: complex128
        IN 18: R{ F12 F13 } spilloffset: 112 typ: complex128
        IN 19: R{ } offset: 0 typ: complex128
        IN 20: R{ } offset: 16 typ: complex64
        IN 21: R{ I8 } spilloffset: 128 typ: int8
        IN 22: R{ } offset: 24 typ: int16

	var z complex128
	z = (1 << s) << (1 << s)     // ERROR "non-integer|type complex128"
	z = (1 << s) << (1. << s)    // ERROR "non-integer|type complex128"
	z = (1 << s) << (1.1 << s)   // ERROR "invalid|truncated|complex128"
	z = (1. << s) << (1 << s)    // ERROR "non-integer|type complex128|must be integer"
	z = (1. << s) << (1. << s)   // ERROR "non-integer|type complex128|must be integer"

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

package p

type I struct {
	x int64
}

type F struct {
	x float64
}

type C struct {
	x *complex128
}

type D struct {
	x complex64
}

type A [1]*complex128

//go:noinline
func (i I) X() C {
	cx := complex(0, float64(i.x))
	return C{&cx}
}

//go:noinline
func (f F) X() C {
	cx := complex(f.x, 0)
	return C{&cx}

import "testing"

var global any

var allocsPerRunTests = []struct {
	name   string
	fn     func()
	allocs float64
}{
	{"alloc *byte", func() { global = new(*byte) }, 1},
	{"alloc complex128", func() { global = new(complex128) }, 1},
	{"alloc float64", func() { global = new(float64) }, 1},
	{"alloc int32", func() { global = new(int32) }, 1},
	{"alloc byte", func() { global = new(byte) }, 1},
}

	// structs
	dup("struct{}"),
	dup("struct{x int}"),
	{`struct {
		x, y int
		z float32 "foo"
	}`, `struct{x int; y int; z float32 "foo"}`},
	{`struct {
		string
		elems []complex128
	}`, `struct{string; elems []complex128}`},

	// pointers
	dup("*int"),
	dup("***struct{}"),
	dup("*struct{a int; b float32}"),

	// functions
	dup("func()"),
	dup("func(x int)"),

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

//    IEEE      -10,+10     30000       7.2e-16     1.2e-16
// Also tested by ctan * ccot = 1 and catan(ctan(z))  =  z.

// Tan returns the tangent of x.
func Tan(x complex128) complex128 {
	switch re, im := real(x), imag(x); {
	case math.IsInf(im, 0):
		switch {
		case math.IsInf(re, 0) || math.IsNaN(re):
			return complex(math.Copysign(0, re), math.Copysign(1, im))
		}

	var _ complex128 = complex /* ERRORx `cannot use .* in variable declaration` */ (f32, f32)
	var _ complex128 = complex(f64, f64)

	// untyped constants
	const _ int = complex(1, 0)
	const _ float32 = complex(1, 0)
	const _ complex64 = complex(1, 0)
	const _ complex128 = complex(1, 0)
	const _ = complex(0i, 0i)
	const _ = complex(0i, 0)

	sink = make([]byte, complex64(1+0i))  // ERROR "non-integer.*len|must be integer"
	sink = make([]byte, complex128(1+0i)) // ERROR "non-integer.*len|must be integer"

	sink = make([]byte, 0, 1+0i)
	sink = make([]byte, 0, complex64(1+0i))  // ERROR "non-integer.*cap|must be integer"
	sink = make([]byte, 0, complex128(1+0i)) // ERROR "non-integer.*cap|must be integer"

	f32, g32, h32                   float32 = 0, 0, 1
	f64, g64, h64, inf, negInf, nan float64 = 0, 0, 1, math.Inf(1), math.Inf(-1), math.NaN()

	c, d, e          complex128 = 0 + 0i, 0 + 0i, 1 + 1i
	c64, d64, e64    complex64  = 0 + 0i, 0 + 0i, 1 + 1i
	c128, d128, e128 complex128 = 0 + 0i, 0 + 0i, 1 + 1i
)

// Fool gccgo into thinking that these variables can change.
func NotCalled() {
	i++
	j++
	k++
	i8++
	j8++
	k8++