diff --git a/src/pkg/cmath/asin.go b/src/pkg/cmath/asin.go
index eb87ba5e5bd..d6a3ca48026 100644
--- a/src/pkg/cmath/asin.go
+++ b/src/pkg/cmath/asin.go
@@ -51,16 +51,16 @@ import "math"
 func Asin(x complex128) complex128 {
 	if imag(x) == 0 {
 		if math.Fabs(real(x)) > 1 {
-			return cmplx(math.Pi/2, 0) // DOMAIN error
+			return complex(math.Pi/2, 0) // DOMAIN error
 		}
-		return cmplx(math.Asin(real(x)), 0)
+		return complex(math.Asin(real(x)), 0)
 	}
-	ct := cmplx(-imag(x), real(x)) // i * x
+	ct := complex(-imag(x), real(x)) // i * x
 	xx := x * x
-	x1 := cmplx(1-real(xx), -imag(xx)) // 1 - x*x
-	x2 := Sqrt(x1)                     // x2 = sqrt(1 - x*x)
+	x1 := complex(1-real(xx), -imag(xx)) // 1 - x*x
+	x2 := Sqrt(x1)                       // x2 = sqrt(1 - x*x)
 	w := Log(ct + x2)
-	return cmplx(imag(w), -real(w)) // -i * w
+	return complex(imag(w), -real(w)) // -i * w
 }
 
 // Asinh returns the inverse hyperbolic sine of x.
@@ -68,13 +68,13 @@ func Asinh(x complex128) complex128 {
 	// TODO check range
 	if imag(x) == 0 {
 		if math.Fabs(real(x)) > 1 {
-			return cmplx(math.Pi/2, 0) // DOMAIN error
+			return complex(math.Pi/2, 0) // DOMAIN error
 		}
-		return cmplx(math.Asinh(real(x)), 0)
+		return complex(math.Asinh(real(x)), 0)
 	}
 	xx := x * x
-	x1 := cmplx(1+real(xx), imag(xx)) // 1 + x*x
-	return Log(x + Sqrt(x1))          // log(x + sqrt(1 + x*x))
+	x1 := complex(1+real(xx), imag(xx)) // 1 + x*x
+	return Log(x + Sqrt(x1))            // log(x + sqrt(1 + x*x))
 }
 
 // Complex circular arc cosine
@@ -93,16 +93,16 @@ func Asinh(x complex128) complex128 {
 // Acos returns the inverse cosine of x.
 func Acos(x complex128) complex128 {
 	w := Asin(x)
-	return cmplx(math.Pi/2-real(w), -imag(w))
+	return complex(math.Pi/2-real(w), -imag(w))
 }
 
 // Acosh returns the inverse hyperbolic cosine of x.
 func Acosh(x complex128) complex128 {
 	w := Acos(x)
 	if imag(w) <= 0 {
-		return cmplx(-imag(w), real(w)) // i * w
+		return complex(-imag(w), real(w)) // i * w
 	}
-	return cmplx(imag(w), -real(w)) // -i * w
+	return complex(imag(w), -real(w)) // -i * w
 }
 
 // Complex circular arc tangent
@@ -159,12 +159,12 @@ func Atan(x complex128) complex128 {
 	}
 	t = imag(x) + 1
 	c := (x2 + t*t) / b
-	return cmplx(w, 0.25*math.Log(c))
+	return complex(w, 0.25*math.Log(c))
 }
 
 // Atanh returns the inverse hyperbolic tangent of x.
 func Atanh(x complex128) complex128 {
-	z := cmplx(-imag(x), real(x)) // z = i * x
+	z := complex(-imag(x), real(x)) // z = i * x
 	z = Atan(z)
-	return cmplx(imag(z), -real(z)) // z = -i * z
+	return complex(imag(z), -real(z)) // z = -i * z
 }
diff --git a/src/pkg/cmath/cmath_test.go b/src/pkg/cmath/cmath_test.go
index bf1a9605df7..6a595b0a609 100644
--- a/src/pkg/cmath/cmath_test.go
+++ b/src/pkg/cmath/cmath_test.go
@@ -355,15 +355,15 @@ var expSC = []complex128{
 	NaN(),
 }
 var vcIsNaNSC = []complex128{
-	cmplx(math.Inf(-1), math.Inf(-1)),
-	cmplx(math.Inf(-1), math.NaN()),
-	cmplx(math.NaN(), math.Inf(-1)),
-	cmplx(0, math.NaN()),
-	cmplx(math.NaN(), 0),
-	cmplx(math.Inf(1), math.Inf(1)),
-	cmplx(math.Inf(1), math.NaN()),
-	cmplx(math.NaN(), math.Inf(1)),
-	cmplx(math.NaN(), math.NaN()),
+	complex(math.Inf(-1), math.Inf(-1)),
+	complex(math.Inf(-1), math.NaN()),
+	complex(math.NaN(), math.Inf(-1)),
+	complex(0, math.NaN()),
+	complex(math.NaN(), 0),
+	complex(math.Inf(1), math.Inf(1)),
+	complex(math.Inf(1), math.NaN()),
+	complex(math.NaN(), math.Inf(1)),
+	complex(math.NaN(), math.NaN()),
 }
 var isNaNSC = []bool{
 	false,
@@ -656,7 +656,7 @@ func TestPolar(t *testing.T) {
 	}
 }
 func TestPow(t *testing.T) {
-	var a = cmplx(float64(3), float64(3))
+	var a = complex(3.0, 3.0)
 	for i := 0; i < len(vc); i++ {
 		if f := Pow(a, vc[i]); !cSoclose(pow[i], f, 4e-15) {
 			t.Errorf("Pow(%g, %g) = %g, want %g", a, vc[i], f, pow[i])
@@ -743,82 +743,82 @@ func TestTanh(t *testing.T) {
 
 func BenchmarkAbs(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Abs(cmplx(2.5, 3.5))
+		Abs(complex(2.5, 3.5))
 	}
 }
 func BenchmarkAcos(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Acos(cmplx(2.5, 3.5))
+		Acos(complex(2.5, 3.5))
 	}
 }
 func BenchmarkAcosh(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Acosh(cmplx(2.5, 3.5))
+		Acosh(complex(2.5, 3.5))
 	}
 }
 func BenchmarkAsin(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Asin(cmplx(2.5, 3.5))
+		Asin(complex(2.5, 3.5))
 	}
 }
 func BenchmarkAsinh(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Asinh(cmplx(2.5, 3.5))
+		Asinh(complex(2.5, 3.5))
 	}
 }
 func BenchmarkAtan(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Atan(cmplx(2.5, 3.5))
+		Atan(complex(2.5, 3.5))
 	}
 }
 func BenchmarkAtanh(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Atanh(cmplx(2.5, 3.5))
+		Atanh(complex(2.5, 3.5))
 	}
 }
 func BenchmarkConj(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Conj(cmplx(2.5, 3.5))
+		Conj(complex(2.5, 3.5))
 	}
 }
 func BenchmarkCos(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Cos(cmplx(2.5, 3.5))
+		Cos(complex(2.5, 3.5))
 	}
 }
 func BenchmarkCosh(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Cosh(cmplx(2.5, 3.5))
+		Cosh(complex(2.5, 3.5))
 	}
 }
 func BenchmarkExp(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Exp(cmplx(2.5, 3.5))
+		Exp(complex(2.5, 3.5))
 	}
 }
 func BenchmarkLog(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Log(cmplx(2.5, 3.5))
+		Log(complex(2.5, 3.5))
 	}
 }
 func BenchmarkLog10(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Log10(cmplx(2.5, 3.5))
+		Log10(complex(2.5, 3.5))
 	}
 }
 func BenchmarkPhase(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Phase(cmplx(2.5, 3.5))
+		Phase(complex(2.5, 3.5))
 	}
 }
 func BenchmarkPolar(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Polar(cmplx(2.5, 3.5))
+		Polar(complex(2.5, 3.5))
 	}
 }
 func BenchmarkPow(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Pow(cmplx(2.5, 3.5), cmplx(2.5, 3.5))
+		Pow(complex(2.5, 3.5), complex(2.5, 3.5))
 	}
 }
 func BenchmarkRect(b *testing.B) {
@@ -828,26 +828,26 @@ func BenchmarkRect(b *testing.B) {
 }
 func BenchmarkSin(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Sin(cmplx(2.5, 3.5))
+		Sin(complex(2.5, 3.5))
 	}
 }
 func BenchmarkSinh(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Sinh(cmplx(2.5, 3.5))
+		Sinh(complex(2.5, 3.5))
 	}
 }
 func BenchmarkSqrt(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Sqrt(cmplx(2.5, 3.5))
+		Sqrt(complex(2.5, 3.5))
 	}
 }
 func BenchmarkTan(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Tan(cmplx(2.5, 3.5))
+		Tan(complex(2.5, 3.5))
 	}
 }
 func BenchmarkTanh(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Tanh(cmplx(2.5, 3.5))
+		Tanh(complex(2.5, 3.5))
 	}
 }
diff --git a/src/pkg/cmath/conj.go b/src/pkg/cmath/conj.go
index 7a19e863111..776b57da7b7 100644
--- a/src/pkg/cmath/conj.go
+++ b/src/pkg/cmath/conj.go
@@ -5,4 +5,4 @@
 package cmath
 
 // Conj returns the complex conjugate of x.
-func Conj(x complex128) complex128 { return cmplx(real(x), -imag(x)) }
+func Conj(x complex128) complex128 { return complex(real(x), -imag(x)) }
diff --git a/src/pkg/cmath/exp.go b/src/pkg/cmath/exp.go
index 1a639c5969e..64c1ef40939 100644
--- a/src/pkg/cmath/exp.go
+++ b/src/pkg/cmath/exp.go
@@ -51,5 +51,5 @@ import "math"
 func Exp(x complex128) complex128 {
 	r := math.Exp(real(x))
 	s, c := math.Sincos(imag(x))
-	return cmplx(r*c, r*s)
+	return complex(r*c, r*s)
 }
diff --git a/src/pkg/cmath/isinf.go b/src/pkg/cmath/isinf.go
index f17a752ecb0..f23d2dea787 100644
--- a/src/pkg/cmath/isinf.go
+++ b/src/pkg/cmath/isinf.go
@@ -14,8 +14,8 @@ func IsInf(x complex128) bool {
 	return false
 }
 
-// Inf returns a complex infinity, cmplx(+Inf, +Inf).
+// Inf returns a complex infinity, complex(+Inf, +Inf).
 func Inf() complex128 {
 	inf := math.Inf(1)
-	return cmplx(inf, inf)
+	return complex(inf, inf)
 }
diff --git a/src/pkg/cmath/isnan.go b/src/pkg/cmath/isnan.go
index 8e971dbd3c4..2063bb83566 100644
--- a/src/pkg/cmath/isnan.go
+++ b/src/pkg/cmath/isnan.go
@@ -21,5 +21,5 @@ func IsNaN(x complex128) bool {
 // NaN returns a complex ``not-a-number'' value.
 func NaN() complex128 {
 	nan := math.NaN()
-	return cmplx(nan, nan)
+	return complex(nan, nan)
 }
diff --git a/src/pkg/cmath/log.go b/src/pkg/cmath/log.go
index b42062b2ab9..8e6964fee89 100644
--- a/src/pkg/cmath/log.go
+++ b/src/pkg/cmath/log.go
@@ -55,7 +55,7 @@ import "math"
 
 // Log returns the natural logarithm of x.
 func Log(x complex128) complex128 {
-	return cmplx(math.Log(Abs(x)), Phase(x))
+	return complex(math.Log(Abs(x)), Phase(x))
 }
 
 // Log10 returns the decimal logarithm of x.
diff --git a/src/pkg/cmath/pow.go b/src/pkg/cmath/pow.go
index de2c4db56ea..68e1207c674 100644
--- a/src/pkg/cmath/pow.go
+++ b/src/pkg/cmath/pow.go
@@ -46,7 +46,7 @@ import "math"
 func Pow(x, y complex128) complex128 {
 	modulus := Abs(x)
 	if modulus == 0 {
-		return cmplx(0, 0)
+		return complex(0, 0)
 	}
 	r := math.Pow(modulus, real(y))
 	arg := Phase(x)
@@ -56,5 +56,5 @@ func Pow(x, y complex128) complex128 {
 		theta += imag(y) * math.Log(modulus)
 	}
 	s, c := math.Sincos(theta)
-	return cmplx(r*c, r*s)
+	return complex(r*c, r*s)
 }
diff --git a/src/pkg/cmath/rect.go b/src/pkg/cmath/rect.go
index 1a88d867925..b955f0bf7d5 100644
--- a/src/pkg/cmath/rect.go
+++ b/src/pkg/cmath/rect.go
@@ -9,5 +9,5 @@ import "math"
 // Rect returns the complex number x with polar coordinates r, θ.
 func Rect(r, θ float64) complex128 {
 	s, c := math.Sincos(θ)
-	return cmplx(r*c, r*s)
+	return complex(r*c, r*s)
 }
diff --git a/src/pkg/cmath/sin.go b/src/pkg/cmath/sin.go
index 1b79da493d9..8900ecddea3 100644
--- a/src/pkg/cmath/sin.go
+++ b/src/pkg/cmath/sin.go
@@ -53,7 +53,7 @@ import "math"
 func Sin(x complex128) complex128 {
 	s, c := math.Sincos(real(x))
 	sh, ch := sinhcosh(imag(x))
-	return cmplx(s*ch, c*sh)
+	return complex(s*ch, c*sh)
 }
 
 // Complex hyperbolic sine
@@ -73,7 +73,7 @@ func Sin(x complex128) complex128 {
 func Sinh(x complex128) complex128 {
 	s, c := math.Sincos(imag(x))
 	sh, ch := sinhcosh(real(x))
-	return cmplx(c*sh, s*ch)
+	return complex(c*sh, s*ch)
 }
 
 // Complex circular cosine
@@ -98,7 +98,7 @@ func Sinh(x complex128) complex128 {
 func Cos(x complex128) complex128 {
 	s, c := math.Sincos(real(x))
 	sh, ch := sinhcosh(imag(x))
-	return cmplx(c*ch, -s*sh)
+	return complex(c*ch, -s*sh)
 }
 
 // Complex hyperbolic cosine
@@ -117,7 +117,7 @@ func Cos(x complex128) complex128 {
 func Cosh(x complex128) complex128 {
 	s, c := math.Sincos(imag(x))
 	sh, ch := sinhcosh(real(x))
-	return cmplx(c*ch, s*sh)
+	return complex(c*ch, s*sh)
 }
 
 // calculate sinh and cosh
diff --git a/src/pkg/cmath/sqrt.go b/src/pkg/cmath/sqrt.go
index 58bc4b691d0..e77a9b9df21 100644
--- a/src/pkg/cmath/sqrt.go
+++ b/src/pkg/cmath/sqrt.go
@@ -57,20 +57,20 @@ import "math"
 func Sqrt(x complex128) complex128 {
 	if imag(x) == 0 {
 		if real(x) == 0 {
-			return cmplx(0, 0)
+			return complex(0, 0)
 		}
 		if real(x) < 0 {
-			return cmplx(0, math.Sqrt(-real(x)))
+			return complex(0, math.Sqrt(-real(x)))
 		}
-		return cmplx(math.Sqrt(real(x)), 0)
+		return complex(math.Sqrt(real(x)), 0)
 	}
 	if real(x) == 0 {
 		if imag(x) < 0 {
 			r := math.Sqrt(-0.5 * imag(x))
-			return cmplx(r, -r)
+			return complex(r, -r)
 		}
 		r := math.Sqrt(0.5 * imag(x))
-		return cmplx(r, r)
+		return complex(r, r)
 	}
 	a := real(x)
 	b := imag(x)
@@ -97,7 +97,7 @@ func Sqrt(x complex128) complex128 {
 		r *= scale
 	}
 	if b < 0 {
-		return cmplx(t, -r)
+		return complex(t, -r)
 	}
-	return cmplx(t, r)
+	return complex(t, r)
 }
diff --git a/src/pkg/cmath/tan.go b/src/pkg/cmath/tan.go
index d1945cd7900..94b517521ec 100644
--- a/src/pkg/cmath/tan.go
+++ b/src/pkg/cmath/tan.go
@@ -64,7 +64,7 @@ func Tan(x complex128) complex128 {
 	if d == 0 {
 		return Inf()
 	}
-	return cmplx(math.Sin(2*real(x))/d, math.Sinh(2*imag(x))/d)
+	return complex(math.Sin(2*real(x))/d, math.Sinh(2*imag(x))/d)
 }
 
 // Complex hyperbolic tangent
@@ -85,7 +85,7 @@ func Tanh(x complex128) complex128 {
 	if d == 0 {
 		return Inf()
 	}
-	return cmplx(math.Sinh(2*real(x))/d, math.Sin(2*imag(x))/d)
+	return complex(math.Sinh(2*real(x))/d, math.Sin(2*imag(x))/d)
 }
 
 // Program to subtract nearest integer multiple of PI
@@ -114,11 +114,11 @@ func tanSeries(z complex128) float64 {
 	x = reducePi(x)
 	x = x * x
 	y = y * y
-	x2 := float64(1)
-	y2 := float64(1)
-	f := float64(1)
-	rn := float64(0)
-	d := float64(0)
+	x2 := 1.0
+	y2 := 1.0
+	f := 1.0
+	rn := 0.0
+	d := 0.0
 	for {
 		rn += 1
 		f *= rn
@@ -180,5 +180,5 @@ func Cot(x complex128) complex128 {
 	if d == 0 {
 		return Inf()
 	}
-	return cmplx(math.Sin(2*real(x))/d, -math.Sinh(2*imag(x))/d)
+	return complex(math.Sin(2*real(x))/d, -math.Sinh(2*imag(x))/d)
 }
diff --git a/src/pkg/container/vector/numbers_test.go b/src/pkg/container/vector/numbers_test.go
index 93335ca60f2..d540ace0502 100644
--- a/src/pkg/container/vector/numbers_test.go
+++ b/src/pkg/container/vector/numbers_test.go
@@ -46,7 +46,7 @@ func TestVectorNums(t *testing.T) {
 	v.Resize(0, 0)
 	runtime.GC()
 	n := m.Alloc - m0.Alloc
-	t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float(n)/memTestN)
+	t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float64(n)/memTestN)
 }
 
 
@@ -64,7 +64,7 @@ func TestIntVectorNums(t *testing.T) {
 	v.Resize(0, 0)
 	runtime.GC()
 	n := m.Alloc - m0.Alloc
-	t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float(n)/memTestN)
+	t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float64(n)/memTestN)
 }
 
 
@@ -82,7 +82,7 @@ func TestStringVectorNums(t *testing.T) {
 	v.Resize(0, 0)
 	runtime.GC()
 	n := m.Alloc - m0.Alloc
-	t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float(n)/memTestN)
+	t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float64(n)/memTestN)
 }
 
 
diff --git a/src/pkg/encoding/binary/binary.go b/src/pkg/encoding/binary/binary.go
index 6bbe7eb8959..77ff3a9f3ef 100644
--- a/src/pkg/encoding/binary/binary.go
+++ b/src/pkg/encoding/binary/binary.go
@@ -199,7 +199,7 @@ func sizeof(v reflect.Type) int {
 
 	case *reflect.UintType, *reflect.IntType, *reflect.FloatType, *reflect.ComplexType:
 		switch t := t.Kind(); t {
-		case reflect.Int, reflect.Uint, reflect.Uintptr, reflect.Float, reflect.Complex:
+		case reflect.Int, reflect.Uint, reflect.Uintptr:
 			return -1
 		}
 		return int(v.Size())
@@ -331,12 +331,12 @@ func (d *decoder) value(v reflect.Value) {
 	case *reflect.ComplexValue:
 		switch v.Type().Kind() {
 		case reflect.Complex64:
-			v.Set(cmplx(
+			v.Set(complex(
 				float64(math.Float32frombits(d.uint32())),
 				float64(math.Float32frombits(d.uint32())),
 			))
 		case reflect.Complex128:
-			v.Set(cmplx(
+			v.Set(complex(
 				math.Float64frombits(d.uint64()),
 				math.Float64frombits(d.uint64()),
 			))
diff --git a/src/pkg/encoding/binary/binary_test.go b/src/pkg/encoding/binary/binary_test.go
index c378413f102..e09ec489fd4 100644
--- a/src/pkg/encoding/binary/binary_test.go
+++ b/src/pkg/encoding/binary/binary_test.go
@@ -31,8 +31,6 @@ type Struct struct {
 type T struct {
 	Int     int
 	Uint    uint
-	Float   float
-	Complex complex
 	Uintptr uintptr
 	Array   [4]int
 }
@@ -49,11 +47,11 @@ var s = Struct{
 
 	math.Float32frombits(0x1f202122),
 	math.Float64frombits(0x232425262728292a),
-	cmplx(
+	complex(
 		math.Float32frombits(0x2b2c2d2e),
 		math.Float32frombits(0x2f303132),
 	),
-	cmplx(
+	complex(
 		math.Float64frombits(0x333435363738393a),
 		math.Float64frombits(0x3b3c3d3e3f404142),
 	),
diff --git a/src/pkg/exp/datafmt/datafmt_test.go b/src/pkg/exp/datafmt/datafmt_test.go
index f6a09f820c8..d7c70b21dec 100644
--- a/src/pkg/exp/datafmt/datafmt_test.go
+++ b/src/pkg/exp/datafmt/datafmt_test.go
@@ -80,10 +80,10 @@ func TestCustomFormatters(t *testing.T) {
 	f = parse(t, ``, fmap1)
 	verify(t, f, `even odd even odd `, 0, 1, 2, 3)
 
-	f = parse(t, `/ =@:blank; float="#"`, fmap1)
+	f = parse(t, `/ =@:blank; float64="#"`, fmap1)
 	verify(t, f, `# # #`, 0.0, 1.0, 2.0)
 
-	f = parse(t, `float=@:nil`, fmap1)
+	f = parse(t, `float64=@:nil`, fmap1)
 	verify(t, f, ``, 0.0, 1.0, 2.0)
 
 	f = parse(t, `testing "testing"; ptr=*`, fmap2)
@@ -139,7 +139,7 @@ func TestBasicTypes(t *testing.T) {
 
 	const f = 3.141592
 	const fs = `3.141592`
-	check(t, `float  ="%g"`, fs, f)
+	check(t, `float64="%g"`, fs, f)
 	check(t, `float32="%g"`, fs, float32(f))
 	check(t, `float64="%g"`, fs, float64(f))
 }
diff --git a/src/pkg/exp/eval/Makefile b/src/pkg/exp/eval/Makefile
index 2b716b14c47..872316cadc0 100644
--- a/src/pkg/exp/eval/Makefile
+++ b/src/pkg/exp/eval/Makefile
@@ -30,7 +30,7 @@ eval: main.$O
 gen.$O: gen.go
 	$(GC) $<
 
-generate: gen.$O $(pkgdir)/$(TARG).a
+generate: gen.$O
 	$(LD) -o $@ $<;\
 	./generate > expr1.go;\
 	gofmt -w expr1.go
diff --git a/src/pkg/exp/eval/bridge.go b/src/pkg/exp/eval/bridge.go
index 3fa498d6882..12835c4c028 100644
--- a/src/pkg/exp/eval/bridge.go
+++ b/src/pkg/exp/eval/bridge.go
@@ -43,8 +43,6 @@ func TypeFromNative(t reflect.Type) Type {
 			et = Float32Type
 		case reflect.Float64:
 			et = Float64Type
-		case reflect.Float:
-			et = FloatType
 		}
 	case *reflect.IntType:
 		switch t.Kind() {
diff --git a/src/pkg/exp/eval/eval_test.go b/src/pkg/exp/eval/eval_test.go
index 6bfe9089db8..ff28cf1a908 100644
--- a/src/pkg/exp/eval/eval_test.go
+++ b/src/pkg/exp/eval/eval_test.go
@@ -173,8 +173,8 @@ func toValue(val interface{}) Value {
 		return &r
 	case *big.Int:
 		return &idealIntV{val}
-	case float:
-		r := floatV(val)
+	case float64:
+		r := float64V(val)
 		return &r
 	case *big.Rat:
 		return &idealFloatV{val}
@@ -244,7 +244,7 @@ func newTestWorld() *World {
 	def("i", IntType, 1)
 	def("i2", IntType, 2)
 	def("u", UintType, uint(1))
-	def("f", FloatType, 1.0)
+	def("f", Float64Type, 1.0)
 	def("s", StringType, "abc")
 	def("t", NewStructType([]StructField{{"a", IntType, false}}), vstruct{1})
 	def("ai", NewArrayType(2, IntType), varray{1, 2})
diff --git a/src/pkg/exp/eval/expr.go b/src/pkg/exp/eval/expr.go
index 70f63cf2d9b..e65f47617bd 100644
--- a/src/pkg/exp/eval/expr.go
+++ b/src/pkg/exp/eval/expr.go
@@ -1981,7 +1981,7 @@ func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) {
 		case tempType.isInteger():
 			tempType = IntType
 		case tempType.isFloat():
-			tempType = FloatType
+			tempType = Float64Type
 		default:
 			log.Panicf("unexpected ideal type %v", tempType)
 		}
diff --git a/src/pkg/exp/eval/expr1.go b/src/pkg/exp/eval/expr1.go
index ae0cfc72374..5d0e5000032 100755
--- a/src/pkg/exp/eval/expr1.go
+++ b/src/pkg/exp/eval/expr1.go
@@ -9,8 +9,8 @@ import (
 )
 
 /*
-* "As" functions.  These retrieve evaluator functions from an
-* expr, panicking if the requested evaluator has the wrong type.
+ * "As" functions.  These retrieve evaluator functions from an
+ * expr, panicking if the requested evaluator has the wrong type.
  */
 func (a *expr) asBool() func(*Thread) bool {
 	return a.eval.(func(*Thread) bool)
@@ -90,7 +90,7 @@ func (a *expr) asInterface() func(*Thread) interface{} {
 }
 
 /*
-* Operator generators.
+ * Operator generators.
  */
 
 func (a *expr) genConstant(v Value) {
@@ -392,13 +392,6 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 				ret = l + r
 				return float64(float64(ret))
 			}
-		case 0:
-			a.eval = func(t *Thread) float64 {
-				l, r := lf(t), rf(t)
-				var ret float64
-				ret = l + r
-				return float64(float(ret))
-			}
 		default:
 			log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos)
 		}
@@ -528,13 +521,6 @@ func (a *expr) genBinOpSub(l, r *expr) {
 				ret = l - r
 				return float64(float64(ret))
 			}
-		case 0:
-			a.eval = func(t *Thread) float64 {
-				l, r := lf(t), rf(t)
-				var ret float64
-				ret = l - r
-				return float64(float(ret))
-			}
 		default:
 			log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos)
 		}
@@ -657,13 +643,6 @@ func (a *expr) genBinOpMul(l, r *expr) {
 				ret = l * r
 				return float64(float64(ret))
 			}
-		case 0:
-			a.eval = func(t *Thread) float64 {
-				l, r := lf(t), rf(t)
-				var ret float64
-				ret = l * r
-				return float64(float(ret))
-			}
 		default:
 			log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos)
 		}
@@ -822,16 +801,6 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 				ret = l / r
 				return float64(float64(ret))
 			}
-		case 0:
-			a.eval = func(t *Thread) float64 {
-				l, r := lf(t), rf(t)
-				var ret float64
-				if r == 0 {
-					t.Abort(DivByZeroError{})
-				}
-				ret = l / r
-				return float64(float(ret))
-			}
 		default:
 			log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos)
 		}
diff --git a/src/pkg/exp/eval/gen.go b/src/pkg/exp/eval/gen.go
index 81863dd6fe6..a2b11984658 100644
--- a/src/pkg/exp/eval/gen.go
+++ b/src/pkg/exp/eval/gen.go
@@ -47,7 +47,7 @@ var (
 	}
 	idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*big.Int", As: "asIdealInt", IsIdeal: true}
 	floatType    = &Type{Repr: "*floatType", Value: "FloatValue", Native: "float64", As: "asFloat",
-		Sizes: []Size{{32, "float32"}, {64, "float64"}, {0, "float"}},
+		Sizes: []Size{{32, "float32"}, {64, "float64"}},
 	}
 	idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*big.Rat", As: "asIdealFloat", IsIdeal: true}
 	stringType     = &Type{Repr: "*stringType", Value: "StringValue", Native: "string", As: "asString"}
diff --git a/src/pkg/exp/eval/stmt.go b/src/pkg/exp/eval/stmt.go
index b9ffa94fa24..77ff066d09c 100644
--- a/src/pkg/exp/eval/stmt.go
+++ b/src/pkg/exp/eval/stmt.go
@@ -602,7 +602,7 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token,
 				case ac.rmt.Elems[i].isInteger():
 					lt = IntType
 				case ac.rmt.Elems[i].isFloat():
-					lt = FloatType
+					lt = Float64Type
 				default:
 					log.Panicf("unexpected ideal type %v", rs[i].t)
 				}
diff --git a/src/pkg/exp/eval/type.go b/src/pkg/exp/eval/type.go
index db77ab198de..3f272ce4b6c 100644
--- a/src/pkg/exp/eval/type.go
+++ b/src/pkg/exp/eval/type.go
@@ -372,7 +372,6 @@ type floatType struct {
 var (
 	Float32Type = universe.DefineType("float32", universePos, &floatType{commonType{}, 32, "float32"})
 	Float64Type = universe.DefineType("float64", universePos, &floatType{commonType{}, 64, "float64"})
-	FloatType   = universe.DefineType("float", universePos, &floatType{commonType{}, 0, "float"})
 )
 
 func (t *floatType) compat(o Type, conv bool) bool {
@@ -394,9 +393,6 @@ func (t *floatType) Zero() Value {
 	case 64:
 		res := float64V(0)
 		return &res
-	case 0:
-		res := floatV(0)
-		return &res
 	}
 	panic("unexpected float bit count")
 }
@@ -408,9 +404,6 @@ var minFloat64Val *big.Rat
 
 func (t *floatType) minVal() *big.Rat {
 	bits := t.Bits
-	if bits == 0 {
-		bits = uint(8 * unsafe.Sizeof(float(0)))
-	}
 	switch bits {
 	case 32:
 		return minFloat32Val
@@ -423,9 +416,6 @@ func (t *floatType) minVal() *big.Rat {
 
 func (t *floatType) maxVal() *big.Rat {
 	bits := t.Bits
-	if bits == 0 {
-		bits = uint(8 * unsafe.Sizeof(float(0)))
-	}
 	switch bits {
 	case 32:
 		return maxFloat32Val
diff --git a/src/pkg/exp/eval/value.go b/src/pkg/exp/eval/value.go
index cace2fd37b7..daa69189792 100644
--- a/src/pkg/exp/eval/value.go
+++ b/src/pkg/exp/eval/value.go
@@ -307,16 +307,6 @@ func (v *float64V) Get(*Thread) float64 { return float64(*v) }
 
 func (v *float64V) Set(t *Thread, x float64) { *v = float64V(x) }
 
-type floatV float
-
-func (v *floatV) String() string { return fmt.Sprint(*v) }
-
-func (v *floatV) Assign(t *Thread, o Value) { *v = floatV(o.(FloatValue).Get(t)) }
-
-func (v *floatV) Get(*Thread) float64 { return float64(*v) }
-
-func (v *floatV) Set(t *Thread, x float64) { *v = floatV(x) }
-
 /*
  * Ideal float
  */
diff --git a/src/pkg/exp/ogle/rtype.go b/src/pkg/exp/ogle/rtype.go
index fd77f1bc248..b3c35575af4 100644
--- a/src/pkg/exp/ogle/rtype.go
+++ b/src/pkg/exp/ogle/rtype.go
@@ -209,9 +209,6 @@ func parseRemoteType(a aborter, rs remoteStruct) *remoteType {
 	case p.runtime.PFloat64Type:
 		t = eval.Float64Type
 		mk = mkFloat64
-	case p.runtime.PFloatType:
-		t = eval.FloatType
-		mk = mkFloat
 	case p.runtime.PStringType:
 		t = eval.StringType
 		mk = mkString
diff --git a/src/pkg/expvar/expvar_test.go b/src/pkg/expvar/expvar_test.go
index 2659434438b..a8b1a96a93c 100644
--- a/src/pkg/expvar/expvar_test.go
+++ b/src/pkg/expvar/expvar_test.go
@@ -128,7 +128,7 @@ func TestIntFunc(t *testing.T) {
 }
 
 func TestFloatFunc(t *testing.T) {
-	x := float64(8.5)
+	x := 8.5
 	ix := FloatFunc(func() float64 { return x })
 	if s := ix.String(); s != "8.5" {
 		t.Errorf("ix.String() = %v, want 3.14", s)
diff --git a/src/pkg/flag/flag.go b/src/pkg/flag/flag.go
index 04fe2fa05b6..143a1061150 100644
--- a/src/pkg/flag/flag.go
+++ b/src/pkg/flag/flag.go
@@ -166,22 +166,6 @@ func (s *stringValue) Set(val string) bool {
 
 func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) }
 
-// -- Float Value
-type floatValue float
-
-func newFloatValue(val float, p *float) *floatValue {
-	*p = val
-	return (*floatValue)(p)
-}
-
-func (f *floatValue) Set(s string) bool {
-	v, err := strconv.Atof(s)
-	*f = floatValue(v)
-	return err == nil
-}
-
-func (f *floatValue) String() string { return fmt.Sprintf("%v", *f) }
-
 // -- Float64 Value
 type float64Value float64
 
@@ -385,20 +369,6 @@ func String(name, value string, usage string) *string {
 	return p
 }
 
-// FloatVar defines a float flag with specified name, default value, and usage string.
-// The argument p points to a float variable in which to store the value of the flag.
-func FloatVar(p *float, name string, value float, usage string) {
-	Var(newFloatValue(value, p), name, usage)
-}
-
-// Float defines a float flag with specified name, default value, and usage string.
-// The return value is the address of a float variable that stores the value of the flag.
-func Float(name string, value float, usage string) *float {
-	p := new(float)
-	FloatVar(p, name, value, usage)
-	return p
-}
-
 // Float64Var defines a float64 flag with specified name, default value, and usage string.
 // The argument p points to a float64 variable in which to store the value of the flag.
 func Float64Var(p *float64, name string, value float64, usage string) {
diff --git a/src/pkg/flag/flag_test.go b/src/pkg/flag/flag_test.go
index 4ebb7380582..b91a8b56795 100644
--- a/src/pkg/flag/flag_test.go
+++ b/src/pkg/flag/flag_test.go
@@ -18,8 +18,7 @@ var (
 	test_uint    = Uint("test_uint", 0, "uint value")
 	test_uint64  = Uint64("test_uint64", 0, "uint64 value")
 	test_string  = String("test_string", "0", "string value")
-	test_float   = Float("test_float", 0, "float value")
-	test_float64 = Float("test_float64", 0, "float64 value")
+	test_float64 = Float64("test_float64", 0, "float64 value")
 )
 
 func boolString(s string) string {
@@ -48,7 +47,7 @@ func TestEverything(t *testing.T) {
 		}
 	}
 	VisitAll(visitor)
-	if len(m) != 8 {
+	if len(m) != 7 {
 		t.Error("VisitAll misses some flags")
 		for k, v := range m {
 			t.Log(k, *v)
@@ -69,11 +68,10 @@ func TestEverything(t *testing.T) {
 	Set("test_uint", "1")
 	Set("test_uint64", "1")
 	Set("test_string", "1")
-	Set("test_float", "1")
 	Set("test_float64", "1")
 	desired = "1"
 	Visit(visitor)
-	if len(m) != 8 {
+	if len(m) != 7 {
 		t.Error("Visit fails after set")
 		for k, v := range m {
 			t.Log(k, *v)
@@ -101,8 +99,7 @@ func TestParse(t *testing.T) {
 	uintFlag := Uint("uint", 0, "uint value")
 	uint64Flag := Uint64("uint64", 0, "uint64 value")
 	stringFlag := String("string", "0", "string value")
-	floatFlag := Float("float", 0, "float value")
-	float64Flag := Float("float64", 0, "float64 value")
+	float64Flag := Float64("float64", 0, "float64 value")
 	extra := "one-extra-argument"
 	args := []string{
 		"a.out",
@@ -113,7 +110,6 @@ func TestParse(t *testing.T) {
 		"-uint", "24",
 		"--uint64", "25",
 		"-string", "hello",
-		"--float", "3141.5",
 		"-float64", "2718e28",
 		extra,
 	}
@@ -141,9 +137,6 @@ func TestParse(t *testing.T) {
 	if *stringFlag != "hello" {
 		t.Error("string flag should be `hello`, is ", *stringFlag)
 	}
-	if *floatFlag != 3141.5 {
-		t.Error("float flag should be 3141.5, is ", *floatFlag)
-	}
 	if *float64Flag != 2718e28 {
 		t.Error("float64 flag should be 2718e28, is ", *float64Flag)
 	}
diff --git a/src/pkg/fmt/fmt_test.go b/src/pkg/fmt/fmt_test.go
index 0aafe6d9942..3f085b72245 100644
--- a/src/pkg/fmt/fmt_test.go
+++ b/src/pkg/fmt/fmt_test.go
@@ -28,10 +28,8 @@ type (
 	renamedUintptr    uintptr
 	renamedString     string
 	renamedBytes      []byte
-	renamedFloat      float
 	renamedFloat32    float32
 	renamedFloat64    float64
-	renamedComplex    complex
 	renamedComplex64  complex64
 	renamedComplex128 complex128
 )
@@ -224,31 +222,31 @@ var fmttests = []struct {
 	{"%b", 7, "111"},
 	{"%b", b64, "1111111111111111111111111111111111111111111111111111111111111111"},
 	{"%b", -6, "-110"},
-	{"%e", float64(1), "1.000000e+00"},
-	{"%e", float64(1234.5678e3), "1.234568e+06"},
-	{"%e", float64(1234.5678e-8), "1.234568e-05"},
-	{"%e", float64(-7), "-7.000000e+00"},
-	{"%e", float64(-1e-9), "-1.000000e-09"},
-	{"%f", float64(1234.5678e3), "1234567.800000"},
-	{"%f", float64(1234.5678e-8), "0.000012"},
-	{"%f", float64(-7), "-7.000000"},
-	{"%f", float64(-1e-9), "-0.000000"},
-	{"%g", float64(1234.5678e3), "1.2345678e+06"},
+	{"%e", 1.0, "1.000000e+00"},
+	{"%e", 1234.5678e3, "1.234568e+06"},
+	{"%e", 1234.5678e-8, "1.234568e-05"},
+	{"%e", -7.0, "-7.000000e+00"},
+	{"%e", -1e-9, "-1.000000e-09"},
+	{"%f", 1234.5678e3, "1234567.800000"},
+	{"%f", 1234.5678e-8, "0.000012"},
+	{"%f", -7.0, "-7.000000"},
+	{"%f", -1e-9, "-0.000000"},
+	{"%g", 1234.5678e3, "1.2345678e+06"},
 	{"%g", float32(1234.5678e3), "1.2345678e+06"},
-	{"%g", float64(1234.5678e-8), "1.2345678e-05"},
-	{"%g", float64(-7), "-7"},
-	{"%g", float64(-1e-9), "-1e-09"},
+	{"%g", 1234.5678e-8, "1.2345678e-05"},
+	{"%g", -7.0, "-7"},
+	{"%g", -1e-9, "-1e-09"},
 	{"%g", float32(-1e-9), "-1e-09"},
-	{"%E", float64(1), "1.000000E+00"},
-	{"%E", float64(1234.5678e3), "1.234568E+06"},
-	{"%E", float64(1234.5678e-8), "1.234568E-05"},
-	{"%E", float64(-7), "-7.000000E+00"},
-	{"%E", float64(-1e-9), "-1.000000E-09"},
-	{"%G", float64(1234.5678e3), "1.2345678E+06"},
+	{"%E", 1.0, "1.000000E+00"},
+	{"%E", 1234.5678e3, "1.234568E+06"},
+	{"%E", 1234.5678e-8, "1.234568E-05"},
+	{"%E", -7.0, "-7.000000E+00"},
+	{"%E", -1e-9, "-1.000000E-09"},
+	{"%G", 1234.5678e3, "1.2345678E+06"},
 	{"%G", float32(1234.5678e3), "1.2345678E+06"},
-	{"%G", float64(1234.5678e-8), "1.2345678E-05"},
-	{"%G", float64(-7), "-7"},
-	{"%G", float64(-1e-9), "-1E-09"},
+	{"%G", 1234.5678e-8, "1.2345678E-05"},
+	{"%G", -7.0, "-7"},
+	{"%G", -1e-9, "-1E-09"},
 	{"%G", float32(-1e-9), "-1E-09"},
 	{"%c", 'x', "x"},
 	{"%c", 0xe4, "ä"},
@@ -273,15 +271,15 @@ var fmttests = []struct {
 	{"%20e", 1.2345e3, "        1.234500e+03"},
 	{"%20e", 1.2345e-3, "        1.234500e-03"},
 	{"%20.8e", 1.2345e3, "      1.23450000e+03"},
-	{"%20f", float64(1.23456789e3), "         1234.567890"},
-	{"%20f", float64(1.23456789e-3), "            0.001235"},
-	{"%20f", float64(12345678901.23456789), "  12345678901.234568"},
-	{"%-20f", float64(1.23456789e3), "1234.567890         "},
-	{"%20.8f", float64(1.23456789e3), "       1234.56789000"},
-	{"%20.8f", float64(1.23456789e-3), "          0.00123457"},
-	{"%g", float64(1.23456789e3), "1234.56789"},
-	{"%g", float64(1.23456789e-3), "0.00123456789"},
-	{"%g", float64(1.23456789e20), "1.23456789e+20"},
+	{"%20f", 1.23456789e3, "         1234.567890"},
+	{"%20f", 1.23456789e-3, "            0.001235"},
+	{"%20f", 12345678901.23456789, "  12345678901.234568"},
+	{"%-20f", 1.23456789e3, "1234.567890         "},
+	{"%20.8f", 1.23456789e3, "       1234.56789000"},
+	{"%20.8f", 1.23456789e-3, "          0.00123457"},
+	{"%g", 1.23456789e3, "1234.56789"},
+	{"%g", 1.23456789e-3, "0.00123456789"},
+	{"%g", 1.23456789e20, "1.23456789e+20"},
 	{"%20e", math.Inf(1), "                +Inf"},
 	{"%-20f", math.Inf(-1), "-Inf                "},
 	{"%20g", math.NaN(), "                 NaN"},
@@ -346,10 +344,8 @@ var fmttests = []struct {
 	{"%x", renamedString("thing"), "7468696e67"},
 	{"%d", renamedBytes([]byte{1, 2, 15}), `[1 2 15]`},
 	{"%q", renamedBytes([]byte("hello")), `"hello"`},
-	{"%v", renamedFloat(11), "11"},
 	{"%v", renamedFloat32(22), "22"},
 	{"%v", renamedFloat64(33), "33"},
-	{"%v", renamedComplex(7 + .2i), "(7+0.2i)"},
 	{"%v", renamedComplex64(3 + 4i), "(3+4i)"},
 	{"%v", renamedComplex128(4 - 3i), "(4-3i)"},
 
@@ -363,7 +359,7 @@ var fmttests = []struct {
 	{"%#v", S{F(7), G(8)}, "fmt_test.S{f:<v=F(7)>, g:GoString(8)}"},
 
 	// %T
-	{"%T", (4 - 3i), "complex"},
+	{"%T", (4 - 3i), "complex128"},
 	{"%T", renamedComplex128(4 - 3i), "fmt_test.renamedComplex128"},
 	{"%T", intVal, "int"},
 	{"%6T", &intVal, "  *int"},
diff --git a/src/pkg/fmt/format.go b/src/pkg/fmt/format.go
index 0121dda31dc..86057bf693c 100644
--- a/src/pkg/fmt/format.go
+++ b/src/pkg/fmt/format.go
@@ -396,36 +396,3 @@ func (f *fmt) fmt_c128(v complex128, verb int) {
 	}
 	f.buf.Write(irparenBytes)
 }
-
-// float
-func (x *fmt) f(a float) {
-	if strconv.FloatSize == 32 {
-		x.fmt_f32(float32(a))
-	} else {
-		x.fmt_f64(float64(a))
-	}
-}
-
-func (x *fmt) e(a float) {
-	if strconv.FloatSize == 32 {
-		x.fmt_e32(float32(a))
-	} else {
-		x.fmt_e64(float64(a))
-	}
-}
-
-func (x *fmt) g(a float) {
-	if strconv.FloatSize == 32 {
-		x.fmt_g32(float32(a))
-	} else {
-		x.fmt_g64(float64(a))
-	}
-}
-
-func (x *fmt) fb(a float) {
-	if strconv.FloatSize == 32 {
-		x.fmt_fb32(float32(a))
-	} else {
-		x.fmt_fb64(float64(a))
-	}
-}
diff --git a/src/pkg/fmt/print.go b/src/pkg/fmt/print.go
index 412260441fb..96029a8789f 100644
--- a/src/pkg/fmt/print.go
+++ b/src/pkg/fmt/print.go
@@ -573,26 +573,12 @@ func (p *pp) printField(field interface{}, verb int, plus, goSyntax bool, depth
 	case bool:
 		p.fmtBool(f, verb, field)
 		return false
-	case float:
-		if floatBits == 32 {
-			p.fmtFloat32(float32(f), verb, field)
-		} else {
-			p.fmtFloat64(float64(f), verb, field)
-		}
-		return false
 	case float32:
 		p.fmtFloat32(f, verb, field)
 		return false
 	case float64:
 		p.fmtFloat64(f, verb, field)
 		return false
-	case complex:
-		if complexBits == 64 {
-			p.fmtComplex64(complex64(f), verb, field)
-		} else {
-			p.fmtComplex128(complex128(f), verb, field)
-		}
-		return false
 	case complex64:
 		p.fmtComplex64(complex64(f), verb, field)
 		return false
diff --git a/src/pkg/fmt/scan.go b/src/pkg/fmt/scan.go
index dcc42bc92da..ebbb17155e4 100644
--- a/src/pkg/fmt/scan.go
+++ b/src/pkg/fmt/scan.go
@@ -640,7 +640,7 @@ func (s *ss) scanComplex(verb int, n int) complex128 {
 	sreal, simag := s.complexTokens()
 	real := s.convertFloat(sreal, n/2)
 	imag := s.convertFloat(simag, n/2)
-	return cmplx(real, imag)
+	return complex(real, imag)
 }
 
 // convertString returns the string represented by the next input characters.
@@ -772,8 +772,6 @@ func (s *ss) scanOne(verb int, field interface{}) {
 	switch v := field.(type) {
 	case *bool:
 		*v = s.scanBool(verb)
-	case *complex:
-		*v = complex(s.scanComplex(verb, int(complexBits)))
 	case *complex64:
 		*v = complex64(s.scanComplex(verb, 64))
 	case *complex128:
@@ -802,11 +800,6 @@ func (s *ss) scanOne(verb int, field interface{}) {
 		*v = uintptr(s.scanUint(verb, uintptrBits))
 	// Floats are tricky because you want to scan in the precision of the result, not
 	// scan in high precision and convert, in order to preserve the correct error condition.
-	case *float:
-		if s.okVerb(verb, floatVerbs, "float") {
-			s.skipSpace(false)
-			*v = float(s.convertFloat(s.floatToken(), int(floatBits)))
-		}
 	case *float32:
 		if s.okVerb(verb, floatVerbs, "float32") {
 			s.skipSpace(false)
diff --git a/src/pkg/fmt/scan_test.go b/src/pkg/fmt/scan_test.go
index fe5ee1d6175..78b9fbb4ab0 100644
--- a/src/pkg/fmt/scan_test.go
+++ b/src/pkg/fmt/scan_test.go
@@ -50,13 +50,11 @@ var (
 	uint16Val            uint16
 	uint32Val            uint32
 	uint64Val            uint64
-	floatVal             float
 	float32Val           float32
 	float64Val           float64
 	stringVal            string
 	stringVal1           string
 	bytesVal             []byte
-	complexVal           complex
 	complex64Val         complex64
 	complex128Val        complex128
 	renamedBoolVal       renamedBool
@@ -73,10 +71,8 @@ var (
 	renamedUintptrVal    renamedUintptr
 	renamedStringVal     renamedString
 	renamedBytesVal      renamedBytes
-	renamedFloatVal      renamedFloat
 	renamedFloat32Val    renamedFloat32
 	renamedFloat64Val    renamedFloat64
-	renamedComplexVal    renamedComplex
 	renamedComplex64Val  renamedComplex64
 	renamedComplex128Val renamedComplex128
 )
@@ -161,12 +157,12 @@ var scanTests = []ScanTest{
 	{"30\n", &uint64Val, uint64(30)},
 	{"255\n", &uint8Val, uint8(255)},
 	{"32767\n", &int16Val, int16(32767)},
-	{"2.3\n", &floatVal, 2.3},
+	{"2.3\n", &float64Val, 2.3},
 	{"2.3e1\n", &float32Val, float32(2.3e1)},
-	{"2.3e2\n", &float64Val, float64(2.3e2)},
+	{"2.3e2\n", &float64Val, 2.3e2},
 	{"2.35\n", &stringVal, "2.35"},
 	{"2345678\n", &bytesVal, []byte("2345678")},
-	{"(3.4e1-2i)\n", &complexVal, 3.4e1 - 2i},
+	{"(3.4e1-2i)\n", &complex128Val, 3.4e1 - 2i},
 	{"-3.45e1-3i\n", &complex64Val, complex64(-3.45e1 - 3i)},
 	{"-.45e1-1e2i\n", &complex128Val, complex128(-.45e1 - 100i)},
 	{"hello\n", &stringVal, "hello"},
@@ -256,10 +252,8 @@ var scanfTests = []ScanfTest{
 	{"%d", "113\n", &renamedUintptrVal, renamedUintptr(113)},
 	{"%s", "114\n", &renamedStringVal, renamedString("114")},
 	{"%q", "\"1155\"\n", &renamedBytesVal, renamedBytes([]byte("1155"))},
-	{"%g", "115.1\n", &renamedFloatVal, renamedFloat(115.1)},
 	{"%g", "116e1\n", &renamedFloat32Val, renamedFloat32(116e1)},
 	{"%g", "-11.7e+1", &renamedFloat64Val, renamedFloat64(-11.7e+1)},
-	{"%g", "11+5.1i\n", &renamedComplexVal, renamedComplex(11 + 5.1i)},
 	{"%g", "11+6e1i\n", &renamedComplex64Val, renamedComplex64(11 + 6e1i)},
 	{"%g", "-11.+7e+1i", &renamedComplex128Val, renamedComplex128(-11. + 7e+1i)},
 
@@ -288,15 +282,15 @@ var overflowTests = []ScanTest{
 	{"65536", &uint16Val, 0},
 	{"1e100", &float32Val, 0},
 	{"1e500", &float64Val, 0},
-	{"(1e100+0i)", &complexVal, 0},
+	{"(1e100+0i)", &complex64Val, 0},
 	{"(1+1e100i)", &complex64Val, 0},
 	{"(1-1e500i)", &complex128Val, 0},
 }
 
 var i, j, k int
-var f float
+var f float64
 var s, t string
-var c complex
+var c complex128
 var x, y Xs
 
 var multiTests = []ScanfMultiTest{
@@ -307,7 +301,7 @@ var multiTests = []ScanfMultiTest{
 	{"%2d.%3d", "66.777", args(&i, &j), args(66, 777), ""},
 	{"%d, %d", "23, 18", args(&i, &j), args(23, 18), ""},
 	{"%3d22%3d", "33322333", args(&i, &j), args(333, 333), ""},
-	{"%6vX=%3fY", "3+2iX=2.5Y", args(&c, &f), args((3 + 2i), float(2.5)), ""},
+	{"%6vX=%3fY", "3+2iX=2.5Y", args(&c, &f), args((3 + 2i), 2.5), ""},
 	{"%d%s", "123abc", args(&i, &s), args(123, "abc"), ""},
 	{"%c%c%c", "2\u50c2X", args(&i, &j, &k), args('2', '\u50c2', 'X'), ""},
 
@@ -409,7 +403,7 @@ func TestScanOverflow(t *testing.T) {
 }
 
 func verifyNaN(str string, t *testing.T) {
-	var f float
+	var f float64
 	var f32 float32
 	var f64 float64
 	text := str + " " + str + " " + str
@@ -432,7 +426,7 @@ func TestNaN(t *testing.T) {
 }
 
 func verifyInf(str string, t *testing.T) {
-	var f float
+	var f float64
 	var f32 float32
 	var f64 float64
 	text := str + " " + str + " " + str
diff --git a/src/pkg/fmt/stringer_test.go b/src/pkg/fmt/stringer_test.go
index 815147e1ae6..0ca3f522d62 100644
--- a/src/pkg/fmt/stringer_test.go
+++ b/src/pkg/fmt/stringer_test.go
@@ -20,7 +20,7 @@ type TU16 uint16
 type TU32 uint32
 type TU64 uint64
 type TUI uintptr
-type TF float
+type TF float64
 type TF32 float32
 type TF64 float64
 type TB bool
@@ -37,7 +37,7 @@ func (v TU16) String() string { return Sprintf("U16: %d", uint16(v)) }
 func (v TU32) String() string { return Sprintf("U32: %d", uint32(v)) }
 func (v TU64) String() string { return Sprintf("U64: %d", uint64(v)) }
 func (v TUI) String() string  { return Sprintf("UI: %d", uintptr(v)) }
-func (v TF) String() string   { return Sprintf("F: %f", float(v)) }
+func (v TF) String() string   { return Sprintf("F: %f", float64(v)) }
 func (v TF32) String() string { return Sprintf("F32: %f", float32(v)) }
 func (v TF64) String() string { return Sprintf("F64: %f", float64(v)) }
 func (v TB) String() string   { return Sprintf("B: %t", bool(v)) }
diff --git a/src/pkg/go/doc/doc.go b/src/pkg/go/doc/doc.go
index fb1c4e03d86..e46857cb8a1 100644
--- a/src/pkg/go/doc/doc.go
+++ b/src/pkg/go/doc/doc.go
@@ -154,7 +154,7 @@ func (doc *docReader) addValue(decl *ast.GenDecl) {
 	// determine values list
 	const threshold = 0.75
 	values := &doc.values
-	if domName != "" && domFreq >= int(float(len(decl.Specs))*threshold) {
+	if domName != "" && domFreq >= int(float64(len(decl.Specs))*threshold) {
 		// typed entries are sufficiently frequent
 		typ := doc.lookupTypeDoc(domName)
 		if typ != nil {
diff --git a/src/pkg/go/printer/nodes.go b/src/pkg/go/printer/nodes.go
index 8aadc75a54c..8207996dcdc 100644
--- a/src/pkg/go/printer/nodes.go
+++ b/src/pkg/go/printer/nodes.go
@@ -228,7 +228,7 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp
 				useFF = false
 			} else {
 				const r = 4 // threshold
-				ratio := float(size) / float(prevSize)
+				ratio := float64(size) / float64(prevSize)
 				useFF = ratio <= 1/r || r <= ratio
 			}
 		}
diff --git a/src/pkg/gob/codec_test.go b/src/pkg/gob/codec_test.go
index d150dbe9a9a..af941c629cd 100644
--- a/src/pkg/gob/codec_test.go
+++ b/src/pkg/gob/codec_test.go
@@ -254,18 +254,6 @@ func TestScalarEncInstructions(t *testing.T) {
 		}
 	}
 
-	// float
-	{
-		b.Reset()
-		data := struct{ a float }{17}
-		instr := &encInstr{encFloat, 6, 0, 0}
-		state := newencoderState(b)
-		instr.op(instr, state, unsafe.Pointer(&data))
-		if !bytes.Equal(floatResult, b.Bytes()) {
-			t.Errorf("float enc instructions: expected % x got % x", floatResult, b.Bytes())
-		}
-	}
-
 	// float32
 	{
 		b.Reset()
@@ -492,19 +480,6 @@ func TestScalarDecInstructions(t *testing.T) {
 		}
 	}
 
-	// float
-	{
-		var data struct {
-			a float
-		}
-		instr := &decInstr{decOpMap[reflect.Float], 6, 0, 0, ovfl}
-		state := newDecodeStateFromData(floatResult)
-		execDec("float", instr, state, t, unsafe.Pointer(&data))
-		if data.a != 17 {
-			t.Errorf("float a = %v not 17", data.a)
-		}
-	}
-
 	// float32
 	{
 		var data struct {
@@ -531,19 +506,6 @@ func TestScalarDecInstructions(t *testing.T) {
 		}
 	}
 
-	// complex
-	{
-		var data struct {
-			a complex
-		}
-		instr := &decInstr{decOpMap[reflect.Complex], 6, 0, 0, ovfl}
-		state := newDecodeStateFromData(complexResult)
-		execDec("complex", instr, state, t, unsafe.Pointer(&data))
-		if data.a != 17+19i {
-			t.Errorf("complex a = %v not 17+19i", data.a)
-		}
-	}
-
 	// complex64
 	{
 		var data struct {
@@ -605,8 +567,8 @@ func TestEndToEnd(t *testing.T) {
 	s2 := "string2"
 	type T1 struct {
 		A, B, C int
-		M       map[string]*float
-		N       *[3]float
+		M       map[string]*float64
+		N       *[3]float64
 		Strs    *[2]string
 		Int64s  *[]int64
 		RI      complex64
@@ -620,8 +582,8 @@ func TestEndToEnd(t *testing.T) {
 		A:      17,
 		B:      18,
 		C:      -5,
-		M:      map[string]*float{"pi": &pi, "e": &e},
-		N:      &[3]float{1.5, 2.5, 3.5},
+		M:      map[string]*float64{"pi": &pi, "e": &e},
+		N:      &[3]float64{1.5, 2.5, 3.5},
 		Strs:   &[2]string{s1, s2},
 		Int64s: &[]int64{77, 89, 123412342134},
 		RI:     17 - 23i,
@@ -799,7 +761,7 @@ func TestOverflow(t *testing.T) {
 	// complex64
 	b.Reset()
 	it = inputT{
-		Maxc: cmplx(math.MaxFloat32*2, math.MaxFloat32*2),
+		Maxc: complex(math.MaxFloat32*2, math.MaxFloat32*2),
 	}
 	type outc64 struct {
 		Maxc complex64
@@ -940,10 +902,10 @@ func TestAutoIndirection(t *testing.T) {
 type RT0 struct {
 	A int
 	B string
-	C float
+	C float64
 }
 type RT1 struct {
-	C      float
+	C      float64
 	B      string
 	A      int
 	NotSet string
@@ -973,13 +935,13 @@ type IT0 struct {
 	A        int64
 	B        string
 	Ignore_d []int
-	Ignore_e [3]float
+	Ignore_e [3]float64
 	Ignore_f bool
 	Ignore_g string
 	Ignore_h []byte
 	Ignore_i *RT1
 	Ignore_m map[string]int
-	C        float
+	C        float64
 }
 
 func TestIgnoredFields(t *testing.T) {
@@ -1013,7 +975,7 @@ func TestIgnoredFields(t *testing.T) {
 
 type Bad0 struct {
 	ch chan int
-	c  float
+	c  float64
 }
 
 var nilEncoder *Encoder
@@ -1109,7 +1071,7 @@ func (i Int) Square() int {
 	return int(i * i)
 }
 
-type Float float
+type Float float64
 
 func (f Float) Square() int {
 	return int(f * f)
@@ -1137,14 +1099,14 @@ func (p Point) Square() int {
 type InterfaceItem struct {
 	I             int
 	Sq1, Sq2, Sq3 Squarer
-	F             float
+	F             float64
 	Sq            []Squarer
 }
 
 // The same struct without interfaces
 type NoInterfaceItem struct {
 	I int
-	F float
+	F float64
 }
 
 func TestInterface(t *testing.T) {
@@ -1207,8 +1169,8 @@ func TestInterface(t *testing.T) {
 type BasicInterfaceItem struct {
 	Int, Int8, Int16, Int32, Int64      interface{}
 	Uint, Uint8, Uint16, Uint32, Uint64 interface{}
-	Float, Float32, Float64             interface{}
-	Complex, Complex64, Complex128      interface{}
+	Float32, Float64                    interface{}
+	Complex64, Complex128               interface{}
 	Bool                                interface{}
 	String                              interface{}
 	Bytes                               interface{}
@@ -1219,8 +1181,8 @@ func TestInterfaceBasic(t *testing.T) {
 	item1 := &BasicInterfaceItem{
 		int(1), int8(1), int16(1), int32(1), int64(1),
 		uint(1), uint8(1), uint16(1), uint32(1), uint64(1),
-		float(1), float32(1), float64(1),
-		complex(0i), complex64(0i), complex128(0i),
+		float32(1), 1.0,
+		complex64(0i), complex128(0i),
 		true,
 		"hello",
 		[]byte("sailor"),
@@ -1318,7 +1280,7 @@ func TestIgnoreInterface(t *testing.T) {
 type U struct {
 	A int
 	B string
-	c float
+	c float64
 	D uint
 }
 
@@ -1354,7 +1316,7 @@ type DT struct {
 	//	X OnTheFly
 	A     int
 	B     string
-	C     float
+	C     float64
 	I     interface{}
 	J     interface{}
 	I_nil interface{}
diff --git a/src/pkg/gob/decode.go b/src/pkg/gob/decode.go
index f88ca72daab..2db75215c19 100644
--- a/src/pkg/gob/decode.go
+++ b/src/pkg/gob/decode.go
@@ -333,7 +333,7 @@ func decComplex64(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		p = *(*unsafe.Pointer)(p)
 	}
 	storeFloat32(i, state, p)
-	storeFloat32(i, state, unsafe.Pointer(uintptr(p)+uintptr(unsafe.Sizeof(float(0)))))
+	storeFloat32(i, state, unsafe.Pointer(uintptr(p)+uintptr(unsafe.Sizeof(float32(0)))))
 }
 
 func decComplex128(i *decInstr, state *decodeState, p unsafe.Pointer) {
@@ -345,7 +345,7 @@ func decComplex128(i *decInstr, state *decodeState, p unsafe.Pointer) {
 	}
 	real := floatFromBits(uint64(state.decodeUint()))
 	imag := floatFromBits(uint64(state.decodeUint()))
-	*(*complex128)(p) = cmplx(real, imag)
+	*(*complex128)(p) = complex(real, imag)
 }
 
 // uint8 arrays are encoded as an unsigned count followed by the raw bytes.
@@ -993,20 +993,6 @@ func (dec *Decoder) decode(wireId typeId, val reflect.Value) os.Error {
 }
 
 func init() {
-	var fop, cop decOp
-	switch reflect.Typeof(float(0)).Bits() {
-	case 32:
-		fop = decFloat32
-		cop = decComplex64
-	case 64:
-		fop = decFloat64
-		cop = decComplex128
-	default:
-		panic("gob: unknown size of float")
-	}
-	decOpMap[reflect.Float] = fop
-	decOpMap[reflect.Complex] = cop
-
 	var iop, uop decOp
 	switch reflect.Typeof(int(0)).Bits() {
 	case 32:
diff --git a/src/pkg/gob/encode.go b/src/pkg/gob/encode.go
index 3431eafa7e9..d286a7e00b8 100644
--- a/src/pkg/gob/encode.go
+++ b/src/pkg/gob/encode.go
@@ -223,15 +223,6 @@ func floatBits(f float64) uint64 {
 	return v
 }
 
-func encFloat(i *encInstr, state *encoderState, p unsafe.Pointer) {
-	f := *(*float)(p)
-	if f != 0 || state.sendZero {
-		v := floatBits(float64(f))
-		state.update(i)
-		state.encodeUint(v)
-	}
-}
-
 func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) {
 	f := *(*float32)(p)
 	if f != 0 || state.sendZero {
@@ -251,17 +242,6 @@ func encFloat64(i *encInstr, state *encoderState, p unsafe.Pointer) {
 }
 
 // Complex numbers are just a pair of floating-point numbers, real part first.
-func encComplex(i *encInstr, state *encoderState, p unsafe.Pointer) {
-	c := *(*complex)(p)
-	if c != 0+0i || state.sendZero {
-		rpart := floatBits(float64(real(c)))
-		ipart := floatBits(float64(imag(c)))
-		state.update(i)
-		state.encodeUint(rpart)
-		state.encodeUint(ipart)
-	}
-}
-
 func encComplex64(i *encInstr, state *encoderState, p unsafe.Pointer) {
 	c := *(*complex64)(p)
 	if c != 0+0i || state.sendZero {
@@ -446,10 +426,8 @@ var encOpMap = []encOp{
 	reflect.Uint32:     encUint32,
 	reflect.Uint64:     encUint64,
 	reflect.Uintptr:    encUintptr,
-	reflect.Float:      encFloat,
 	reflect.Float32:    encFloat32,
 	reflect.Float64:    encFloat64,
-	reflect.Complex:    encComplex,
 	reflect.Complex64:  encComplex64,
 	reflect.Complex128: encComplex128,
 	reflect.String:     encString,
diff --git a/src/pkg/gob/encoder_test.go b/src/pkg/gob/encoder_test.go
index db0b7db6670..c2309352a09 100644
--- a/src/pkg/gob/encoder_test.go
+++ b/src/pkg/gob/encoder_test.go
@@ -33,7 +33,7 @@ type ET3 struct {
 // Like ET1 but with a different type for a field
 type ET4 struct {
 	A    int
-	Et2  float
+	Et2  float64
 	Next int
 }
 
@@ -189,13 +189,13 @@ func TestPtrTypeToType(t *testing.T) {
 
 func TestTypeToPtrPtrPtrPtrType(t *testing.T) {
 	type Type2 struct {
-		A ****float
+		A ****float64
 	}
 	t2 := Type2{}
-	t2.A = new(***float)
-	*t2.A = new(**float)
-	**t2.A = new(*float)
-	***t2.A = new(float)
+	t2.A = new(***float64)
+	*t2.A = new(**float64)
+	**t2.A = new(*float64)
+	***t2.A = new(float64)
 	****t2.A = 27.4
 	t2pppp := new(***Type2)
 	if err := encAndDec(t2, t2pppp); err != nil {
@@ -254,13 +254,13 @@ func TestDefaultsInArray(t *testing.T) {
 		B []bool
 		I []int
 		S []string
-		F []float
+		F []float64
 	}
 	t7 := Type7{
 		[]bool{false, false, true},
 		[]int{0, 0, 1},
 		[]string{"hi", "", "there"},
-		[]float{0, 0, 1},
+		[]float64{0, 0, 1},
 	}
 	var t7p Type7
 	if err := encAndDec(t7, &t7p); err != nil {
diff --git a/src/pkg/gob/type.go b/src/pkg/gob/type.go
index c00af87bf20..22502a6e6b9 100644
--- a/src/pkg/gob/type.go
+++ b/src/pkg/gob/type.go
@@ -93,7 +93,7 @@ var (
 	tBool      = bootstrapType("bool", false, 1)
 	tInt       = bootstrapType("int", int(0), 2)
 	tUint      = bootstrapType("uint", uint(0), 3)
-	tFloat     = bootstrapType("float", float64(0), 4)
+	tFloat     = bootstrapType("float", 0.0, 4)
 	tBytes     = bootstrapType("bytes", make([]byte, 0), 5)
 	tString    = bootstrapType("string", "", 6)
 	tComplex   = bootstrapType("complex", 0+0i, 7)
@@ -529,10 +529,8 @@ func registerBasics() {
 	Register(uint16(0))
 	Register(uint32(0))
 	Register(uint64(0))
-	Register(float(0))
 	Register(float32(0))
-	Register(float64(0))
-	Register(complex(0i))
+	Register(0.0)
 	Register(complex64(0i))
 	Register(complex128(0i))
 	Register(false)
diff --git a/src/pkg/gob/type_test.go b/src/pkg/gob/type_test.go
index 106e4f10b51..5aecde103a5 100644
--- a/src/pkg/gob/type_test.go
+++ b/src/pkg/gob/type_test.go
@@ -135,8 +135,8 @@ type Foo struct {
 	b int32 // will become int
 	c string
 	d []byte
-	e *float      // will become float
-	f ****float64 // will become float
+	e *float64    // will become float64
+	f ****float64 // will become float64
 	g *Bar
 	h *Bar // should not interpolate the definition of Bar again
 	i *Foo // will not explode
diff --git a/src/pkg/json/decode.go b/src/pkg/json/decode.go
index c704cacbd28..ff91dd83c33 100644
--- a/src/pkg/json/decode.go
+++ b/src/pkg/json/decode.go
@@ -749,7 +749,7 @@ func (d *decodeState) literalInterface() interface{} {
 		}
 		n, err := strconv.Atof64(string(item))
 		if err != nil {
-			d.saveError(&UnmarshalTypeError{"number " + string(item), reflect.Typeof(float64(0))})
+			d.saveError(&UnmarshalTypeError{"number " + string(item), reflect.Typeof(0.0)})
 		}
 		return n
 	}
diff --git a/src/pkg/json/decode_test.go b/src/pkg/json/decode_test.go
index 68cdea051ea..9cb27af412a 100644
--- a/src/pkg/json/decode_test.go
+++ b/src/pkg/json/decode_test.go
@@ -52,7 +52,7 @@ var unmarshalTests = []unmarshalTest{
 	// basic types
 	{`true`, new(bool), true, nil},
 	{`1`, new(int), 1, nil},
-	{`1.2`, new(float), 1.2, nil},
+	{`1.2`, new(float64), 1.2, nil},
 	{`-5`, new(int16), int16(-5), nil},
 	{`"a\u1234"`, new(string), "a\u1234", nil},
 	{`"http:\/\/"`, new(string), "http://", nil},
@@ -220,7 +220,6 @@ type All struct {
 	Uint32  uint32
 	Uint64  uint64
 	Uintptr uintptr
-	Float   float
 	Float32 float32
 	Float64 float64
 
@@ -238,7 +237,6 @@ type All struct {
 	PUint32  *uint32
 	PUint64  *uint64
 	PUintptr *uintptr
-	PFloat   *float
 	PFloat32 *float32
 	PFloat64 *float64
 
@@ -291,7 +289,6 @@ var allValue = All{
 	Uint32:  10,
 	Uint64:  11,
 	Uintptr: 12,
-	Float:   13.1,
 	Float32: 14.1,
 	Float64: 15.1,
 	Foo:     "foo",
@@ -312,7 +309,7 @@ var allValue = All{
 	ByteSlice:   []byte{27, 28, 29},
 	Small:       Small{Tag: "tag30"},
 	PSmall:      &Small{Tag: "tag31"},
-	Interface:   float64(5.2),
+	Interface:   5.2,
 }
 
 var pallValue = All{
@@ -328,7 +325,6 @@ var pallValue = All{
 	PUint32:    &allValue.Uint32,
 	PUint64:    &allValue.Uint64,
 	PUintptr:   &allValue.Uintptr,
-	PFloat:     &allValue.Float,
 	PFloat32:   &allValue.Float32,
 	PFloat64:   &allValue.Float64,
 	PString:    &allValue.String,
@@ -353,7 +349,6 @@ var allValueIndent = `{
 	"Uint32": 10,
 	"Uint64": 11,
 	"Uintptr": 12,
-	"Float": 13.1,
 	"Float32": 14.1,
 	"Float64": 15.1,
 	"bar": "foo",
@@ -369,7 +364,6 @@ var allValueIndent = `{
 	"PUint32": null,
 	"PUint64": null,
 	"PUintptr": null,
-	"PFloat": null,
 	"PFloat32": null,
 	"PFloat64": null,
 	"String": "16",
@@ -449,7 +443,6 @@ var pallValueIndent = `{
 	"Uint32": 0,
 	"Uint64": 0,
 	"Uintptr": 0,
-	"Float": 0,
 	"Float32": 0,
 	"Float64": 0,
 	"bar": "",
@@ -465,7 +458,6 @@ var pallValueIndent = `{
 	"PUint32": 10,
 	"PUint64": 11,
 	"PUintptr": 12,
-	"PFloat": 13.1,
 	"PFloat32": 14.1,
 	"PFloat64": 15.1,
 	"String": "",
diff --git a/src/pkg/json/stream_test.go b/src/pkg/json/stream_test.go
index c83cfe3a937..6ddaed9fe8f 100644
--- a/src/pkg/json/stream_test.go
+++ b/src/pkg/json/stream_test.go
@@ -13,14 +13,14 @@ import (
 // Test values for the stream test.
 // One of each JSON kind.
 var streamTest = []interface{}{
-	float64(0.1),
+	0.1,
 	"hello",
 	nil,
 	true,
 	false,
 	[]interface{}{"a", "b", "c"},
 	map[string]interface{}{"K": "Kelvin", "ß": "long s"},
-	float64(3.14), // another value to make sure something can follow map
+	3.14, // another value to make sure something can follow map
 }
 
 var streamEncoded = `0.1
diff --git a/src/pkg/math/all_test.go b/src/pkg/math/all_test.go
index 0efef2bbf0a..d2a7d411ec0 100644
--- a/src/pkg/math/all_test.go
+++ b/src/pkg/math/all_test.go
@@ -2076,7 +2076,7 @@ func TestLog1p(t *testing.T) {
 			t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i])
 		}
 	}
-	a := float64(9)
+	a := 9.0
 	if f := Log1p(a); f != Ln10 {
 		t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10)
 	}
diff --git a/src/pkg/math/gamma.go b/src/pkg/math/gamma.go
index 4c5b17d05c7..73ca0e53add 100644
--- a/src/pkg/math/gamma.go
+++ b/src/pkg/math/gamma.go
@@ -151,7 +151,7 @@ func Gamma(x float64) float64 {
 	}
 
 	// Reduce argument
-	z := float64(1)
+	z := 1.0
 	for x >= 3 {
 		x = x - 1
 		z = z * x
diff --git a/src/pkg/math/jn.go b/src/pkg/math/jn.go
index 7d317431076..9024af3c223 100644
--- a/src/pkg/math/jn.go
+++ b/src/pkg/math/jn.go
@@ -132,7 +132,7 @@ func Jn(n int, x float64) float64 {
 			} else {
 				temp := x * 0.5
 				b = temp
-				a := float64(1)
+				a := 1.0
 				for i := 2; i <= n; i++ {
 					a *= float64(i) // a = n!
 					b *= temp       // b = (x/2)**n
@@ -181,7 +181,7 @@ func Jn(n int, x float64) float64 {
 				q0, q1 = q1, z*q1-q0
 			}
 			m := n + n
-			t := float64(0)
+			t := 0.0
 			for i := 2 * (n + k); i >= m; i -= 2 {
 				t = 1 / (float64(i)/x - t)
 			}
diff --git a/src/pkg/math/lgamma.go b/src/pkg/math/lgamma.go
index dc31be929db..dc30f468f4b 100644
--- a/src/pkg/math/lgamma.go
+++ b/src/pkg/math/lgamma.go
@@ -272,7 +272,7 @@ func Lgamma(x float64) (lgamma float64, sign int) {
 		p := y * (S0 + y*(S1+y*(S2+y*(S3+y*(S4+y*(S5+y*S6))))))
 		q := 1 + y*(R1+y*(R2+y*(R3+y*(R4+y*(R5+y*R6)))))
 		lgamma = 0.5*y + p/q
-		z := float64(1) // Lgamma(1+s) = Log(s) + Lgamma(s)
+		z := 1.0 // Lgamma(1+s) = Log(s) + Lgamma(s)
 		switch i {
 		case 7:
 			z *= (y + 6)
diff --git a/src/pkg/math/pow.go b/src/pkg/math/pow.go
index f0ad84af6b9..06b107401b9 100644
--- a/src/pkg/math/pow.go
+++ b/src/pkg/math/pow.go
@@ -98,7 +98,7 @@ func Pow(x, y float64) float64 {
 	}
 
 	// ans = a1 * 2**ae (= 1 for now).
-	a1 := float64(1)
+	a1 := 1.0
 	ae := 0
 
 	// ans *= x**yf
diff --git a/src/pkg/rand/rand.go b/src/pkg/rand/rand.go
index 8c1219a7a1c..459aed1db4f 100644
--- a/src/pkg/rand/rand.go
+++ b/src/pkg/rand/rand.go
@@ -88,9 +88,6 @@ func (r *Rand) Float64() float64 { return float64(r.Int63()) / (1 << 63) }
 // Float32 returns, as a float32, a pseudo-random number in [0.0,1.0).
 func (r *Rand) Float32() float32 { return float32(r.Float64()) }
 
-// Float returns, as a float, a pseudo-random number in [0.0,1.0).
-func (r *Rand) Float() float { return float(r.Float64()) }
-
 // Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
 func (r *Rand) Perm(n int) []int {
 	m := make([]int, n)
@@ -140,9 +137,6 @@ func Float64() float64 { return globalRand.Float64() }
 // Float32 returns, as a float32, a pseudo-random number in [0.0,1.0).
 func Float32() float32 { return globalRand.Float32() }
 
-// Float returns, as a float, a pseudo-random number in [0.0,1.0).
-func Float() float { return globalRand.Float() }
-
 // Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
 func Perm(n int) []int { return globalRand.Perm(n) }
 
diff --git a/src/pkg/rand/rand_test.go b/src/pkg/rand/rand_test.go
index b9bf43208a3..2476ebaf61d 100644
--- a/src/pkg/rand/rand_test.go
+++ b/src/pkg/rand/rand_test.go
@@ -131,8 +131,8 @@ func TestStandardNormalValues(t *testing.T) {
 }
 
 func TestNonStandardNormalValues(t *testing.T) {
-	for sd := float64(0.5); sd < 1000; sd *= 2 {
-		for m := float64(0.5); m < 1000; m *= 2 {
+	for sd := 0.5; sd < 1000; sd *= 2 {
+		for m := 0.5; m < 1000; m *= 2 {
 			for _, seed := range testSeeds {
 				testNormalDistribution(t, numTestSamples, m, sd, seed)
 			}
@@ -182,7 +182,7 @@ func TestStandardExponentialValues(t *testing.T) {
 }
 
 func TestNonStandardExponentialValues(t *testing.T) {
-	for rate := float64(0.05); rate < 10; rate *= 2 {
+	for rate := 0.05; rate < 10; rate *= 2 {
 		for _, seed := range testSeeds {
 			testExponentialDistribution(t, numTestSamples, rate, seed)
 		}
diff --git a/src/pkg/rand/zipf.go b/src/pkg/rand/zipf.go
index c4e7b7d93e9..38e8ec5162a 100644
--- a/src/pkg/rand/zipf.go
+++ b/src/pkg/rand/zipf.go
@@ -55,7 +55,7 @@ func NewZipf(r *Rand, s float64, v float64, imax uint64) *Zipf {
 // Uint64 returns a value drawn from the Zipf distributed described
 // by the Zipf object.
 func (z *Zipf) Uint64() uint64 {
-	k := float64(0.0)
+	k := 0.0
 
 	for {
 		r := z.r.Float64() // r on [0,1]
diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go
index 7d34e5ca30f..3675be6f1c1 100644
--- a/src/pkg/reflect/all_test.go
+++ b/src/pkg/reflect/all_test.go
@@ -48,7 +48,6 @@ var typeTests = []pair{
 	{struct{ x uint16 }{}, "uint16"},
 	{struct{ x uint32 }{}, "uint32"},
 	{struct{ x uint64 }{}, "uint64"},
-	{struct{ x float }{}, "float"},
 	{struct{ x float32 }{}, "float32"},
 	{struct{ x float64 }{}, "float64"},
 	{struct{ x int8 }{}, "int8"},
@@ -244,8 +243,6 @@ func TestSet(t *testing.T) {
 			}
 		case *FloatValue:
 			switch v.Type().Kind() {
-			case Float:
-				v.Set(128.5)
 			case Float32:
 				v.Set(256.25)
 			case Float64:
@@ -253,8 +250,6 @@ func TestSet(t *testing.T) {
 			}
 		case *ComplexValue:
 			switch v.Type().Kind() {
-			case Complex:
-				v.Set(53200.0 + 100i)
 			case Complex64:
 				v.Set(532.125 + 10i)
 			case Complex128:
@@ -304,17 +299,13 @@ func TestSetValue(t *testing.T) {
 			}
 		case *FloatValue:
 			switch v.Type().Kind() {
-			case Float:
-				v.SetValue(NewValue(float(128.5)))
 			case Float32:
 				v.SetValue(NewValue(float32(256.25)))
 			case Float64:
-				v.SetValue(NewValue(float64(512.125)))
+				v.SetValue(NewValue(512.125))
 			}
 		case *ComplexValue:
 			switch v.Type().Kind() {
-			case Complex:
-				v.SetValue(NewValue(complex(53200.0 + 100i)))
 			case Complex64:
 				v.SetValue(NewValue(complex64(532.125 + 10i)))
 			case Complex128:
@@ -470,7 +461,7 @@ func TestInterfaceGet(t *testing.T) {
 	assert(t, v2.Type().String(), "interface { }")
 	i2 := v2.(*InterfaceValue).Interface()
 	v3 := NewValue(i2)
-	assert(t, v3.Type().String(), "float")
+	assert(t, v3.Type().String(), "float64")
 }
 
 func TestInterfaceValue(t *testing.T) {
@@ -482,11 +473,11 @@ func TestInterfaceValue(t *testing.T) {
 	v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0)
 	assert(t, v2.Type().String(), "interface { }")
 	v3 := v2.(*InterfaceValue).Elem()
-	assert(t, v3.Type().String(), "float")
+	assert(t, v3.Type().String(), "float64")
 
 	i3 := v2.Interface()
-	if _, ok := i3.(float); !ok {
-		t.Error("v2.Interface() did not return float, got ", Typeof(i3))
+	if _, ok := i3.(float64); !ok {
+		t.Error("v2.Interface() did not return float64, got ", Typeof(i3))
 	}
 }
 
@@ -697,11 +688,11 @@ type _Complex struct {
 	a int
 	b [3]*_Complex
 	c *string
-	d map[float]float
+	d map[float64]float64
 }
 
 func TestDeepEqualComplexStruct(t *testing.T) {
-	m := make(map[float]float)
+	m := make(map[float64]float64)
 	stra, strb := "hello", "hello"
 	a, b := new(_Complex), new(_Complex)
 	*a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
@@ -712,7 +703,7 @@ func TestDeepEqualComplexStruct(t *testing.T) {
 }
 
 func TestDeepEqualComplexStructInequality(t *testing.T) {
-	m := make(map[float]float)
+	m := make(map[float64]float64)
 	stra, strb := "hello", "helloo" // Difference is here
 	a, b := new(_Complex), new(_Complex)
 	*a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
@@ -1317,12 +1308,12 @@ func TestImportPath(t *testing.T) {
 
 func TestDotDotDot(t *testing.T) {
 	// Test example from FuncType.DotDotDot documentation.
-	var f func(x int, y ...float)
+	var f func(x int, y ...float64)
 	typ := Typeof(f).(*FuncType)
 	if typ.NumIn() == 2 && typ.In(0) == Typeof(int(0)) {
 		sl, ok := typ.In(1).(*SliceType)
 		if ok {
-			if sl.Elem() == Typeof(float(0)) {
+			if sl.Elem() == Typeof(0.0) {
 				// ok
 				return
 			}
@@ -1330,7 +1321,7 @@ func TestDotDotDot(t *testing.T) {
 	}
 
 	// Failed
-	t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float")
+	t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float64")
 	s := fmt.Sprintf("have NumIn() = %d", typ.NumIn())
 	for i := 0; i < typ.NumIn(); i++ {
 		s += fmt.Sprintf(", In(%d) = %s", i, typ.In(i))
diff --git a/src/pkg/reflect/type.go b/src/pkg/reflect/type.go
index 9a7467b32d6..8dcbb241361 100644
--- a/src/pkg/reflect/type.go
+++ b/src/pkg/reflect/type.go
@@ -264,10 +264,8 @@ const (
 	Uint32
 	Uint64
 	Uintptr
-	Float
 	Float32
 	Float64
-	Complex
 	Complex64
 	Complex128
 	Array
@@ -306,9 +304,10 @@ var kindNames = []string{
 	Uint32:        "uint32",
 	Uint64:        "uint64",
 	Uintptr:       "uintptr",
-	Float:         "float",
 	Float32:       "float32",
 	Float64:       "float64",
+	Complex64:     "complex64",
+	Complex128:    "complex128",
 	Array:         "array",
 	Chan:          "chan",
 	Func:          "func",
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
index e0bcb1a39d4..4d7d8723731 100644
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -142,8 +142,6 @@ type FloatValue struct {
 // Get returns the underlying int value.
 func (v *FloatValue) Get() float64 {
 	switch v.typ.Kind() {
-	case Float:
-		return float64(*(*float)(v.addr))
 	case Float32:
 		return float64(*(*float32)(v.addr))
 	case Float64:
@@ -160,8 +158,6 @@ func (v *FloatValue) Set(x float64) {
 	switch v.typ.Kind() {
 	default:
 		panic("reflect: invalid float kind")
-	case Float:
-		*(*float)(v.addr) = float(x)
 	case Float32:
 		*(*float32)(v.addr) = float32(x)
 	case Float64:
@@ -191,8 +187,6 @@ type ComplexValue struct {
 // Get returns the underlying complex value.
 func (v *ComplexValue) Get() complex128 {
 	switch v.typ.Kind() {
-	case Complex:
-		return complex128(*(*complex)(v.addr))
 	case Complex64:
 		return complex128(*(*complex64)(v.addr))
 	case Complex128:
@@ -209,8 +203,6 @@ func (v *ComplexValue) Set(x complex128) {
 	switch v.typ.Kind() {
 	default:
 		panic("reflect: invalid complex kind")
-	case Complex:
-		*(*complex)(v.addr) = complex(x)
 	case Complex64:
 		*(*complex64)(v.addr) = complex64(x)
 	case Complex128:
diff --git a/src/pkg/runtime/type.go b/src/pkg/runtime/type.go
index d92fe5f2a32..a350d4a0b15 100644
--- a/src/pkg/runtime/type.go
+++ b/src/pkg/runtime/type.go
@@ -51,10 +51,8 @@ const (
 	kindUint32
 	kindUint64
 	kindUintptr
-	kindFloat
 	kindFloat32
 	kindFloat64
-	kindComplex
 	kindComplex64
 	kindComplex128
 	kindArray
diff --git a/src/pkg/runtime/type.h b/src/pkg/runtime/type.h
index 4b5bd7ac2ec..3fb368ebd9f 100644
--- a/src/pkg/runtime/type.h
+++ b/src/pkg/runtime/type.h
@@ -41,10 +41,8 @@ enum {
 	KindUint32,
 	KindUint64,
 	KindUintptr,
-	KindFloat,
 	KindFloat32,
 	KindFloat64,
-	KindComplex,
 	KindComplex64,
 	KindComplex128,
 	KindArray,
diff --git a/src/pkg/sort/search.go b/src/pkg/sort/search.go
index b3ddd2dfa81..6828e19b63b 100644
--- a/src/pkg/sort/search.go
+++ b/src/pkg/sort/search.go
@@ -74,7 +74,7 @@ func Search(n int, f func(int) bool) int {
 
 // Convenience wrappers for common cases.
 
-// SearchInts searches x in a sorted slice of ints and returns the index
+// SearchInts searches for x in a sorted slice of ints and returns the index
 // as specified by Search. The array must be sorted in ascending order.
 //
 func SearchInts(a []int, x int) int {
@@ -82,15 +82,15 @@ func SearchInts(a []int, x int) int {
 }
 
 
-// SearchFloats searches x in a sorted slice of floats and returns the index
+// SearchFloat64s searches for x in a sorted slice of float64s and returns the index
 // as specified by Search. The array must be sorted in ascending order.
 // 
-func SearchFloats(a []float, x float) int {
+func SearchFloat64s(a []float64, x float64) int {
 	return Search(len(a), func(i int) bool { return a[i] >= x })
 }
 
 
-// SearchStrings searches x in a sorted slice of strings and returns the index
+// SearchStrings searches for x in a sorted slice of strings and returns the index
 // as specified by Search. The array must be sorted in ascending order.
 // 
 func SearchStrings(a []string, x string) int {
@@ -102,8 +102,8 @@ func SearchStrings(a []string, x string) int {
 func (p IntArray) Search(x int) int { return SearchInts(p, x) }
 
 
-// Search returns the result of applying SearchFloats to the receiver and x.
-func (p FloatArray) Search(x float) int { return SearchFloats(p, x) }
+// Search returns the result of applying SearchFloat64s to the receiver and x.
+func (p Float64Array) Search(x float64) int { return SearchFloat64s(p, x) }
 
 
 // Search returns the result of applying SearchStrings to the receiver and x.
diff --git a/src/pkg/sort/search_test.go b/src/pkg/sort/search_test.go
index e16e2c93fb7..939f66af380 100644
--- a/src/pkg/sort/search_test.go
+++ b/src/pkg/sort/search_test.go
@@ -96,7 +96,7 @@ func TestSearchEfficiency(t *testing.T) {
 
 // Smoke tests for convenience wrappers - not comprehensive.
 
-var fdata = []float{0: -3.14, 1: 0, 2: 1, 3: 2, 4: 1000.7}
+var fdata = []float64{0: -3.14, 1: 0, 2: 1, 3: 2, 4: 1000.7}
 var sdata = []string{0: "f", 1: "foo", 2: "foobar", 3: "x"}
 
 var wrappertests = []struct {
@@ -105,10 +105,10 @@ var wrappertests = []struct {
 	i      int
 }{
 	{"SearchInts", SearchInts(data, 11), 8},
-	{"SearchFloats", SearchFloats(fdata, 2.1), 4},
+	{"SearchFloat64s", SearchFloat64s(fdata, 2.1), 4},
 	{"SearchStrings", SearchStrings(sdata, ""), 0},
 	{"IntArray.Search", IntArray(data).Search(0), 2},
-	{"FloatArray.Search", FloatArray(fdata).Search(2.0), 3},
+	{"Float64Array.Search", Float64Array(fdata).Search(2.0), 3},
 	{"StringArray.Search", StringArray(sdata).Search("x"), 3},
 }
 
diff --git a/src/pkg/sort/sort.go b/src/pkg/sort/sort.go
index 02e647fca9a..c7945d21b61 100644
--- a/src/pkg/sort/sort.go
+++ b/src/pkg/sort/sort.go
@@ -166,15 +166,15 @@ func (p IntArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 func (p IntArray) Sort() { Sort(p) }
 
 
-// FloatArray attaches the methods of Interface to []float, sorting in increasing order.
-type FloatArray []float
+// Float64Array attaches the methods of Interface to []float64, sorting in increasing order.
+type Float64Array []float64
 
-func (p FloatArray) Len() int           { return len(p) }
-func (p FloatArray) Less(i, j int) bool { return p[i] < p[j] }
-func (p FloatArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+func (p Float64Array) Len() int           { return len(p) }
+func (p Float64Array) Less(i, j int) bool { return p[i] < p[j] }
+func (p Float64Array) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
 // Sort is a convenience method.
-func (p FloatArray) Sort() { Sort(p) }
+func (p Float64Array) Sort() { Sort(p) }
 
 
 // StringArray attaches the methods of Interface to []string, sorting in increasing order.
@@ -192,15 +192,15 @@ func (p StringArray) Sort() { Sort(p) }
 
 // SortInts sorts an array of ints in increasing order.
 func SortInts(a []int) { Sort(IntArray(a)) }
-// SortFloats sorts an array of floats in increasing order.
-func SortFloats(a []float) { Sort(FloatArray(a)) }
+// SortFloat64s sorts an array of float64s in increasing order.
+func SortFloat64s(a []float64) { Sort(Float64Array(a)) }
 // SortStrings sorts an array of strings in increasing order.
 func SortStrings(a []string) { Sort(StringArray(a)) }
 
 
 // IntsAreSorted tests whether an array of ints is sorted in increasing order.
 func IntsAreSorted(a []int) bool { return IsSorted(IntArray(a)) }
-// FloatsAreSorted tests whether an array of floats is sorted in increasing order.
-func FloatsAreSorted(a []float) bool { return IsSorted(FloatArray(a)) }
+// Float64sAreSorted tests whether an array of float64s is sorted in increasing order.
+func Float64sAreSorted(a []float64) bool { return IsSorted(Float64Array(a)) }
 // StringsAreSorted tests whether an array of strings is sorted in increasing order.
 func StringsAreSorted(a []string) bool { return IsSorted(StringArray(a)) }
diff --git a/src/pkg/sort/sort_test.go b/src/pkg/sort/sort_test.go
index 2085a67c82a..1bea8f03262 100644
--- a/src/pkg/sort/sort_test.go
+++ b/src/pkg/sort/sort_test.go
@@ -13,7 +13,7 @@ import (
 
 
 var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
-var floats = [...]float{74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8}
+var float64s = [...]float64{74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8}
 var strings = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
 
 func TestSortIntArray(t *testing.T) {
@@ -26,12 +26,12 @@ func TestSortIntArray(t *testing.T) {
 	}
 }
 
-func TestSortFloatArray(t *testing.T) {
-	data := floats
-	a := FloatArray(data[0:])
+func TestSortFloat64Array(t *testing.T) {
+	data := float64s
+	a := Float64Array(data[0:])
 	Sort(a)
 	if !IsSorted(a) {
-		t.Errorf("sorted %v", floats)
+		t.Errorf("sorted %v", float64s)
 		t.Errorf("   got %v", data)
 	}
 }
@@ -55,11 +55,11 @@ func TestSortInts(t *testing.T) {
 	}
 }
 
-func TestSortFloats(t *testing.T) {
-	data := floats
-	SortFloats(data[0:])
-	if !FloatsAreSorted(data[0:]) {
-		t.Errorf("sorted %v", floats)
+func TestSortFloat64s(t *testing.T) {
+	data := float64s
+	SortFloat64s(data[0:])
+	if !Float64sAreSorted(data[0:]) {
+		t.Errorf("sorted %v", float64s)
 		t.Errorf("   got %v", data)
 	}
 }
diff --git a/src/pkg/strconv/atof.go b/src/pkg/strconv/atof.go
index bcb138f7ad2..72f162c5134 100644
--- a/src/pkg/strconv/atof.go
+++ b/src/pkg/strconv/atof.go
@@ -243,7 +243,7 @@ out:
 // Compute exact floating-point integer from d's digits.
 // Caller is responsible for avoiding overflow.
 func decimalAtof64Int(neg bool, d *decimal) float64 {
-	f := float64(0)
+	f := 0.0
 	for i := 0; i < d.nd; i++ {
 		f = f*10 + float64(d.d[i]-'0')
 	}
@@ -400,17 +400,6 @@ func Atof64(s string) (f float64, err os.Error) {
 	return f, err
 }
 
-// Atof is like Atof32 or Atof64, depending on the size of float.
-func Atof(s string) (f float, err os.Error) {
-	if FloatSize == 32 {
-		f1, err1 := Atof32(s)
-		return float(f1), err1
-	}
-	f1, err1 := Atof64(s)
-	return float(f1), err1
-}
-
-
 // AtofN converts the string s to a 64-bit floating-point number,
 // but it rounds the result assuming that it will be stored in a value
 // of n bits (32 or 64).
diff --git a/src/pkg/strconv/atof_test.go b/src/pkg/strconv/atof_test.go
index 68c50bfbead..6cc60e549da 100644
--- a/src/pkg/strconv/atof_test.go
+++ b/src/pkg/strconv/atof_test.go
@@ -150,15 +150,6 @@ func testAtof(t *testing.T, opt bool) {
 					test.in, out32, err, test.out, test.err, out)
 			}
 		}
-
-		if FloatSize == 64 || float64(float32(out)) == out {
-			outf, err := Atof(test.in)
-			outs := Ftoa(outf, 'g', -1)
-			if outs != test.out || !reflect.DeepEqual(err, test.err) {
-				t.Errorf("Ftoa(%v) = %v, %v want %v, %v  # %v",
-					test.in, outf, err, test.out, test.err, out)
-			}
-		}
 	}
 	SetOptimize(oldopt)
 }
@@ -167,26 +158,26 @@ func TestAtof(t *testing.T) { testAtof(t, true) }
 
 func TestAtofSlow(t *testing.T) { testAtof(t, false) }
 
-func BenchmarkAtofDecimal(b *testing.B) {
+func BenchmarkAtof64Decimal(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Atof("33909")
+		Atof64("33909")
 	}
 }
 
-func BenchmarkAtofFloat(b *testing.B) {
+func BenchmarkAtof64Float(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Atof("339.7784")
+		Atof64("339.7784")
 	}
 }
 
-func BenchmarkAtofFloatExp(b *testing.B) {
+func BenchmarkAtof64FloatExp(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Atof("-5.09e75")
+		Atof64("-5.09e75")
 	}
 }
 
-func BenchmarkAtofBig(b *testing.B) {
+func BenchmarkAtof64Big(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		Atof("123456789123456789123456789")
+		Atof64("123456789123456789123456789")
 	}
 }
diff --git a/src/pkg/strconv/ftoa.go b/src/pkg/strconv/ftoa.go
index a6091fc6c38..4ec3cdbb974 100644
--- a/src/pkg/strconv/ftoa.go
+++ b/src/pkg/strconv/ftoa.go
@@ -22,20 +22,6 @@ type floatInfo struct {
 var float32info = floatInfo{23, 8, -127}
 var float64info = floatInfo{52, 11, -1023}
 
-func floatsize() int {
-	// Figure out whether float is float32 or float64.
-	// 1e-35 is representable in both, but 1e-70
-	// is too small for a float32.
-	var f float = 1e-35
-	if f*f == 0 {
-		return 32
-	}
-	return 64
-}
-
-// Floatsize gives the size of the float type, either 32 or 64.
-var FloatSize = floatsize()
-
 // Ftoa32 converts the 32-bit floating-point number f to a string,
 // according to the format fmt and precision prec.
 //
@@ -77,14 +63,6 @@ func FtoaN(f float64, fmt byte, prec int, n int) string {
 	return Ftoa64(f, fmt, prec)
 }
 
-// Ftoa behaves as Ftoa32 or Ftoa64, depending on the size of the float type.
-func Ftoa(f float, fmt byte, prec int) string {
-	if FloatSize == 32 {
-		return Ftoa32(float32(f), fmt, prec)
-	}
-	return Ftoa64(float64(f), fmt, prec)
-}
-
 func genericFtoa(bits uint64, fmt byte, prec int, flt *floatInfo) string {
 	neg := bits>>flt.expbits>>flt.mantbits != 0
 	exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)
diff --git a/src/pkg/strconv/ftoa_test.go b/src/pkg/strconv/ftoa_test.go
index 6044afdae6d..3a862a2beeb 100644
--- a/src/pkg/strconv/ftoa_test.go
+++ b/src/pkg/strconv/ftoa_test.go
@@ -121,10 +121,6 @@ var ftoatests = []ftoaTest{
 }
 
 func TestFtoa(t *testing.T) {
-	if FloatSize != 32 {
-		println("floatsize: ", FloatSize)
-		panic("floatsize")
-	}
 	for i := 0; i < len(ftoatests); i++ {
 		test := &ftoatests[i]
 		s := Ftoa64(test.f, test.fmt, test.prec)
diff --git a/src/pkg/testing/quick/quick.go b/src/pkg/testing/quick/quick.go
index 0b1659725bd..a5568b04830 100644
--- a/src/pkg/testing/quick/quick.go
+++ b/src/pkg/testing/quick/quick.go
@@ -60,18 +60,16 @@ func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool) {
 	switch concrete := t.(type) {
 	case *reflect.BoolType:
 		return reflect.NewValue(rand.Int()&1 == 0), true
-	case *reflect.FloatType, *reflect.IntType, *reflect.UintType:
+	case *reflect.FloatType, *reflect.IntType, *reflect.UintType, *reflect.ComplexType:
 		switch t.Kind() {
 		case reflect.Float32:
 			return reflect.NewValue(randFloat32(rand)), true
 		case reflect.Float64:
 			return reflect.NewValue(randFloat64(rand)), true
-		case reflect.Float:
-			if t.Size() == 4 {
-				return reflect.NewValue(float(randFloat32(rand))), true
-			} else {
-				return reflect.NewValue(float(randFloat64(rand))), true
-			}
+		case reflect.Complex64:
+			return reflect.NewValue(complex(randFloat32(rand), randFloat32(rand))), true
+		case reflect.Complex128:
+			return reflect.NewValue(complex(randFloat64(rand), randFloat64(rand))), true
 		case reflect.Int16:
 			return reflect.NewValue(int16(randInt64(rand))), true
 		case reflect.Int32:
@@ -157,7 +155,7 @@ type Config struct {
 	MaxCount int
 	// MaxCountScale is a non-negative scale factor applied to the default
 	// maximum. If zero, the default is unchanged.
-	MaxCountScale float
+	MaxCountScale float64
 	// If non-nil, rand is a source of random numbers. Otherwise a default
 	// pseudo-random source will be used.
 	Rand *rand.Rand
@@ -183,7 +181,7 @@ func (c *Config) getMaxCount() (maxCount int) {
 	maxCount = c.MaxCount
 	if maxCount == 0 {
 		if c.MaxCountScale != 0 {
-			maxCount = int(c.MaxCountScale * float(*defaultMaxCount))
+			maxCount = int(c.MaxCountScale * float64(*defaultMaxCount))
 		} else {
 			maxCount = *defaultMaxCount
 		}
diff --git a/src/pkg/testing/quick/quick_test.go b/src/pkg/testing/quick/quick_test.go
index c7bff962b91..b126e4a1669 100644
--- a/src/pkg/testing/quick/quick_test.go
+++ b/src/pkg/testing/quick/quick_test.go
@@ -17,7 +17,9 @@ func fFloat32(a float32) float32 { return a }
 
 func fFloat64(a float64) float64 { return a }
 
-func fFloat(a float) float { return a }
+func fComplex64(a complex64) complex64 { return a }
+
+func fComplex128(a complex128) complex128 { return a }
 
 func fInt16(a int16) int16 { return a }
 
@@ -71,7 +73,8 @@ func TestCheckEqual(t *testing.T) {
 	reportError("fBool", CheckEqual(fBool, fBool, nil), t)
 	reportError("fFloat32", CheckEqual(fFloat32, fFloat32, nil), t)
 	reportError("fFloat64", CheckEqual(fFloat64, fFloat64, nil), t)
-	reportError("fFloat", CheckEqual(fFloat, fFloat, nil), t)
+	reportError("fComplex64", CheckEqual(fComplex64, fComplex64, nil), t)
+	reportError("fComplex128", CheckEqual(fComplex128, fComplex128, nil), t)
 	reportError("fInt16", CheckEqual(fInt16, fInt16, nil), t)
 	reportError("fInt32", CheckEqual(fInt32, fInt32, nil), t)
 	reportError("fInt64", CheckEqual(fInt64, fInt64, nil), t)
diff --git a/src/pkg/xml/xml_test.go b/src/pkg/xml/xml_test.go
index 9ab199a30e7..317ecabd90d 100644
--- a/src/pkg/xml/xml_test.go
+++ b/src/pkg/xml/xml_test.go
@@ -227,7 +227,6 @@ type allScalars struct {
 	Uint32  uint32
 	Uint64  uint64
 	Uintptr uintptr
-	Float   float
 	Float32 float32
 	Float64 float64
 	String  string
@@ -249,7 +248,6 @@ var all = allScalars{
 	Uint32:  9,
 	Uint64:  10,
 	Uintptr: 11,
-	Float:   12.0,
 	Float32: 13.0,
 	Float64: 14.0,
 	String:  "15",
diff --git a/test/append.go b/test/append.go
index 17c665227a8..96421c36b89 100644
--- a/test/append.go
+++ b/test/append.go
@@ -193,7 +193,7 @@ func verifyInterface() {
 		case 2:
 			e[i] = fmt.Sprintf("%d", i)
 		case 3:
-			e[i] = float(i)
+			e[i] = float64(i)
 		}
 	}
 
diff --git a/test/blank.go b/test/blank.go
index 6e69f8aaaeb..681a5e77cb4 100644
--- a/test/blank.go
+++ b/test/blank.go
@@ -28,7 +28,7 @@ const (
 	c4
 )
 
-var ints = []string {
+var ints = []string{
 	"1",
 	"2",
 	"3",
@@ -36,15 +36,15 @@ var ints = []string {
 
 func f() (int, int) {
 	call += "f"
-	return 1,2
+	return 1, 2
 }
 
-func g() (float, float) {
+func g() (float64, float64) {
 	call += "g"
-	return 3,4
+	return 3, 4
 }
 
-func h(_ int, _ float) {
+func h(_ int, _ float64) {
 }
 
 func i() int {
@@ -55,43 +55,64 @@ func i() int {
 var _ = i()
 
 func main() {
-	if call != "i" {panic("init did not run")}
+	if call != "i" {
+		panic("init did not run")
+	}
 	call = ""
 	_, _ = f()
 	a, _ := f()
-	if a != 1 {panic(a)}
+	if a != 1 {
+		panic(a)
+	}
 	b, _ := g()
-	if b != 3 {panic(b)}
+	if b != 3 {
+		panic(b)
+	}
 	_, a = f()
-	if a != 2 {panic(a)}
+	if a != 2 {
+		panic(a)
+	}
 	_, b = g()
-	if b != 4 {panic(b)}
+	if b != 4 {
+		panic(b)
+	}
 	_ = i()
-	if call != "ffgfgi" {panic(call)}
-	if c4 != 4 {panic(c4)}
+	if call != "ffgfgi" {
+		panic(call)
+	}
+	if c4 != 4 {
+		panic(c4)
+	}
 
 	out := ""
 	for _, s := range ints {
 		out += s
 	}
-	if out != "123" {panic(out)}
+	if out != "123" {
+		panic(out)
+	}
 
 	sum := 0
 	for s := range ints {
 		sum += s
 	}
-	if sum != 3 {panic(sum)}
+	if sum != 3 {
+		panic(sum)
+	}
 
-	h(a,b)
+	h(a, b)
 }
 
 // useless but legal
 var _ int = 1
 var _ = 2
 var _, _ = 3, 4
+
 const _ = 3
 const _, _ = 4, 5
+
 type _ int
+
 func _() {
 	panic("oops")
 }
diff --git a/test/cmplx.go b/test/cmplx.go
index fad96c60589..d5a77d684a7 100644
--- a/test/cmplx.go
+++ b/test/cmplx.go
@@ -7,26 +7,19 @@
 package main
 
 var (
-	f float
 	f32 float32
 	f64 float64
 
-	c complex
-	c64 complex64
+	c64  complex64
 	c128 complex128
 )
-	
+
 func main() {
 	// ok
-	c = cmplx(f, f)
-	c64 = cmplx(f32, f32)
-	c128 = cmplx(f64, f64)
+	c64 = complex(f32, f32)
+	c128 = complex(f64, f64)
 
-	_ = complex(0) // ok
-	_ = cmplx(f, f32)	// ERROR "cmplx"
-	_ = cmplx(f, f64)	// ERROR "cmplx"
-	_ = cmplx(f32, f)	// ERROR "cmplx"
-	_ = cmplx(f32, f64)	// ERROR "cmplx"
-	_ = cmplx(f64, f)	// ERROR "cmplx"
-	_ = cmplx(f64, f32)	// ERROR "cmplx"
+	_ = complex128(0)     // ok
+	_ = complex(f32, f64) // ERROR "complex"
+	_ = complex(f64, f32) // ERROR "complex"
 }
diff --git a/test/cmplxdivide.c b/test/cmplxdivide.c
index b3c6055ed23..b340f04d887 100644
--- a/test/cmplxdivide.c
+++ b/test/cmplxdivide.c
@@ -72,7 +72,7 @@ main(void)
 		if(iscnan(n) && d == 0)
 			q = (NAN+NAN*I) / zero;
 
-		printf("\tTest{cmplx(%s, %s), cmplx(%s, %s), cmplx(%s, %s)},\n",
+		printf("\tTest{complex(%s, %s), complex(%s, %s), complex(%s, %s)},\n",
 			fmt(creal(n)), fmt(cimag(n)),
 			fmt(creal(d)), fmt(cimag(d)),
 			fmt(creal(q)), fmt(cimag(q)));
diff --git a/test/cmplxdivide1.go b/test/cmplxdivide1.go
index 96ea704a3e2..6a1dee9fe78 100644
--- a/test/cmplxdivide1.go
+++ b/test/cmplxdivide1.go
@@ -1,2407 +1,2406 @@
 // # generated by cmplxdivide.c
 
 package main
-
 var tests = []Test{
-	Test{cmplx(0, 0), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(0, 1), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(0, -1), cmplx(negzero, 0)},
-	Test{cmplx(0, 0), cmplx(0, 2), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(0, inf), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 0), cmplx(1, 0), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(1, 1), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(1, -1), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(1, 2), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(1, inf), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 0), cmplx(-1, 0), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(-1, 1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(-1, -1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(-1, 2), cmplx(0, negzero)},
-	Test{cmplx(0, 0), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(0, 0), cmplx(-1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(2, 0), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(2, 1), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(2, -1), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(2, 2), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(2, inf), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 0), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 0), cmplx(nan, inf), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(nan, -inf), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(0, 0), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(0, 0), cmplx(-inf, nan), cmplx(0, negzero)},
-	Test{cmplx(0, 0), cmplx(-inf, inf), cmplx(0, negzero)},
-	Test{cmplx(0, 0), cmplx(-inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 1), cmplx(0, 0), cmplx(nan, inf)},
-	Test{cmplx(0, 1), cmplx(0, 1), cmplx(1, 0)},
-	Test{cmplx(0, 1), cmplx(0, -1), cmplx(-1, 0)},
-	Test{cmplx(0, 1), cmplx(0, 2), cmplx(0.5, 0)},
-	Test{cmplx(0, 1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(0, inf), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 1), cmplx(1, 0), cmplx(0, 1)},
-	Test{cmplx(0, 1), cmplx(1, 1), cmplx(0.5, 0.5)},
-	Test{cmplx(0, 1), cmplx(1, -1), cmplx(-0.5, 0.5)},
-	Test{cmplx(0, 1), cmplx(1, 2), cmplx(0.4, 0.2)},
-	Test{cmplx(0, 1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(1, inf), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 1), cmplx(-1, 0), cmplx(negzero, -1)},
-	Test{cmplx(0, 1), cmplx(-1, 1), cmplx(0.5, -0.5)},
-	Test{cmplx(0, 1), cmplx(-1, -1), cmplx(-0.5, -0.5)},
-	Test{cmplx(0, 1), cmplx(-1, 2), cmplx(0.4, -0.2)},
-	Test{cmplx(0, 1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(0, 1), cmplx(-1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, 1), cmplx(2, 0), cmplx(0, 0.5)},
-	Test{cmplx(0, 1), cmplx(2, 1), cmplx(0.2, 0.4)},
-	Test{cmplx(0, 1), cmplx(2, -1), cmplx(-0.2, 0.4)},
-	Test{cmplx(0, 1), cmplx(2, 2), cmplx(0.25, 0.25)},
-	Test{cmplx(0, 1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(2, inf), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 1), cmplx(nan, inf), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(nan, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 1), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(0, 1), cmplx(inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 1), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(0, 1), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 1), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 1), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(0, 1), cmplx(-inf, nan), cmplx(0, negzero)},
-	Test{cmplx(0, 1), cmplx(-inf, inf), cmplx(0, negzero)},
-	Test{cmplx(0, 1), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, -1), cmplx(0, 0), cmplx(nan, -inf)},
-	Test{cmplx(0, -1), cmplx(0, 1), cmplx(-1, negzero)},
-	Test{cmplx(0, -1), cmplx(0, -1), cmplx(1, negzero)},
-	Test{cmplx(0, -1), cmplx(0, 2), cmplx(-0.5, negzero)},
-	Test{cmplx(0, -1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(0, inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, -1), cmplx(0, -inf), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(1, 0), cmplx(0, -1)},
-	Test{cmplx(0, -1), cmplx(1, 1), cmplx(-0.5, -0.5)},
-	Test{cmplx(0, -1), cmplx(1, -1), cmplx(0.5, -0.5)},
-	Test{cmplx(0, -1), cmplx(1, 2), cmplx(-0.4, -0.2)},
-	Test{cmplx(0, -1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(1, inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, -1), cmplx(1, -inf), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(-1, 0), cmplx(negzero, 1)},
-	Test{cmplx(0, -1), cmplx(-1, 1), cmplx(-0.5, 0.5)},
-	Test{cmplx(0, -1), cmplx(-1, -1), cmplx(0.5, 0.5)},
-	Test{cmplx(0, -1), cmplx(-1, 2), cmplx(-0.4, 0.2)},
-	Test{cmplx(0, -1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(-1, inf), cmplx(negzero, 0)},
-	Test{cmplx(0, -1), cmplx(-1, -inf), cmplx(0, 0)},
-	Test{cmplx(0, -1), cmplx(2, 0), cmplx(0, -0.5)},
-	Test{cmplx(0, -1), cmplx(2, 1), cmplx(-0.2, -0.4)},
-	Test{cmplx(0, -1), cmplx(2, -1), cmplx(0.2, -0.4)},
-	Test{cmplx(0, -1), cmplx(2, 2), cmplx(-0.25, -0.25)},
-	Test{cmplx(0, -1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(2, inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, -1), cmplx(2, -inf), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -1), cmplx(nan, inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, -1), cmplx(nan, -inf), cmplx(0, 0)},
-	Test{cmplx(0, -1), cmplx(inf, 0), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(inf, 1), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(inf, -1), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(inf, 2), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(inf, nan), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(inf, inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, -1), cmplx(inf, -inf), cmplx(0, negzero)},
-	Test{cmplx(0, -1), cmplx(-inf, 0), cmplx(negzero, 0)},
-	Test{cmplx(0, -1), cmplx(-inf, 1), cmplx(negzero, 0)},
-	Test{cmplx(0, -1), cmplx(-inf, -1), cmplx(negzero, 0)},
-	Test{cmplx(0, -1), cmplx(-inf, 2), cmplx(negzero, 0)},
-	Test{cmplx(0, -1), cmplx(-inf, nan), cmplx(negzero, 0)},
-	Test{cmplx(0, -1), cmplx(-inf, inf), cmplx(negzero, 0)},
-	Test{cmplx(0, -1), cmplx(-inf, -inf), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(0, 0), cmplx(nan, inf)},
-	Test{cmplx(0, 2), cmplx(0, 1), cmplx(2, 0)},
-	Test{cmplx(0, 2), cmplx(0, -1), cmplx(-2, 0)},
-	Test{cmplx(0, 2), cmplx(0, 2), cmplx(1, 0)},
-	Test{cmplx(0, 2), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(0, inf), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 2), cmplx(1, 0), cmplx(0, 2)},
-	Test{cmplx(0, 2), cmplx(1, 1), cmplx(1, 1)},
-	Test{cmplx(0, 2), cmplx(1, -1), cmplx(-1, 1)},
-	Test{cmplx(0, 2), cmplx(1, 2), cmplx(0.8, 0.4)},
-	Test{cmplx(0, 2), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(1, inf), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 2), cmplx(-1, 0), cmplx(negzero, -2)},
-	Test{cmplx(0, 2), cmplx(-1, 1), cmplx(1, -1)},
-	Test{cmplx(0, 2), cmplx(-1, -1), cmplx(-1, -1)},
-	Test{cmplx(0, 2), cmplx(-1, 2), cmplx(0.8, -0.4)},
-	Test{cmplx(0, 2), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(0, 2), cmplx(-1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, 2), cmplx(2, 0), cmplx(0, 1)},
-	Test{cmplx(0, 2), cmplx(2, 1), cmplx(0.4, 0.8)},
-	Test{cmplx(0, 2), cmplx(2, -1), cmplx(-0.4, 0.8)},
-	Test{cmplx(0, 2), cmplx(2, 2), cmplx(0.5, 0.5)},
-	Test{cmplx(0, 2), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(2, inf), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 2), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(0, 2), cmplx(nan, inf), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(nan, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 2), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(0, 2), cmplx(inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(0, 2), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(0, 2), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 2), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(0, 2), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(0, 2), cmplx(-inf, nan), cmplx(0, negzero)},
-	Test{cmplx(0, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-	Test{cmplx(0, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(0, nan), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(0, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(0, 0), cmplx(nan, inf)},
-	Test{cmplx(0, inf), cmplx(0, 1), cmplx(inf, nan)},
-	Test{cmplx(0, inf), cmplx(0, -1), cmplx(-inf, nan)},
-	Test{cmplx(0, inf), cmplx(0, 2), cmplx(inf, nan)},
-	Test{cmplx(0, inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(1, 0), cmplx(nan, inf)},
-	Test{cmplx(0, inf), cmplx(1, 1), cmplx(inf, inf)},
-	Test{cmplx(0, inf), cmplx(1, -1), cmplx(-inf, inf)},
-	Test{cmplx(0, inf), cmplx(1, 2), cmplx(inf, inf)},
-	Test{cmplx(0, inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-	Test{cmplx(0, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-	Test{cmplx(0, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(0, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-	Test{cmplx(0, inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(2, 0), cmplx(nan, inf)},
-	Test{cmplx(0, inf), cmplx(2, 1), cmplx(inf, inf)},
-	Test{cmplx(0, inf), cmplx(2, -1), cmplx(-inf, inf)},
-	Test{cmplx(0, inf), cmplx(2, 2), cmplx(inf, inf)},
-	Test{cmplx(0, inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(0, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(0, 0), cmplx(nan, -inf)},
-	Test{cmplx(0, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-	Test{cmplx(0, -inf), cmplx(0, -1), cmplx(inf, nan)},
-	Test{cmplx(0, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-	Test{cmplx(0, -inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-	Test{cmplx(0, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(0, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-	Test{cmplx(0, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(0, -inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-	Test{cmplx(0, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-	Test{cmplx(0, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-	Test{cmplx(0, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-	Test{cmplx(0, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-	Test{cmplx(0, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-	Test{cmplx(0, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-	Test{cmplx(0, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-	Test{cmplx(0, -inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(0, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(0, 0), cmplx(inf, nan)},
-	Test{cmplx(1, 0), cmplx(0, 1), cmplx(0, -1)},
-	Test{cmplx(1, 0), cmplx(0, -1), cmplx(negzero, 1)},
-	Test{cmplx(1, 0), cmplx(0, 2), cmplx(0, -0.5)},
-	Test{cmplx(1, 0), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(0, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 0), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 0), cmplx(1, 0), cmplx(1, 0)},
-	Test{cmplx(1, 0), cmplx(1, 1), cmplx(0.5, -0.5)},
-	Test{cmplx(1, 0), cmplx(1, -1), cmplx(0.5, 0.5)},
-	Test{cmplx(1, 0), cmplx(1, 2), cmplx(0.2, -0.4)},
-	Test{cmplx(1, 0), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(1, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 0), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 0), cmplx(-1, 0), cmplx(-1, negzero)},
-	Test{cmplx(1, 0), cmplx(-1, 1), cmplx(-0.5, -0.5)},
-	Test{cmplx(1, 0), cmplx(-1, -1), cmplx(-0.5, 0.5)},
-	Test{cmplx(1, 0), cmplx(-1, 2), cmplx(-0.2, -0.4)},
-	Test{cmplx(1, 0), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 0), cmplx(-1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 0), cmplx(2, 0), cmplx(0.5, 0)},
-	Test{cmplx(1, 0), cmplx(2, 1), cmplx(0.4, -0.2)},
-	Test{cmplx(1, 0), cmplx(2, -1), cmplx(0.4, 0.2)},
-	Test{cmplx(1, 0), cmplx(2, 2), cmplx(0.25, -0.25)},
-	Test{cmplx(1, 0), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(2, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 0), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 0), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 0), cmplx(nan, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 0), cmplx(nan, -inf), cmplx(0, 0)},
-	Test{cmplx(1, 0), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(1, 0), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(1, 0), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(1, 0), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(1, 0), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(1, 0), cmplx(inf, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 0), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(1, 0), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(1, 0), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(1, 0), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(1, 0), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(1, 0), cmplx(-inf, nan), cmplx(negzero, negzero)},
-	Test{cmplx(1, 0), cmplx(-inf, inf), cmplx(negzero, negzero)},
-	Test{cmplx(1, 0), cmplx(-inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 1), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(1, 1), cmplx(0, 1), cmplx(1, -1)},
-	Test{cmplx(1, 1), cmplx(0, -1), cmplx(-1, 1)},
-	Test{cmplx(1, 1), cmplx(0, 2), cmplx(0.5, -0.5)},
-	Test{cmplx(1, 1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(0, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 1), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 1), cmplx(1, 0), cmplx(1, 1)},
-	Test{cmplx(1, 1), cmplx(1, 1), cmplx(1, 0)},
-	Test{cmplx(1, 1), cmplx(1, -1), cmplx(0, 1)},
-	Test{cmplx(1, 1), cmplx(1, 2), cmplx(0.6, -0.2)},
-	Test{cmplx(1, 1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(1, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 1), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 1), cmplx(-1, 0), cmplx(-1, -1)},
-	Test{cmplx(1, 1), cmplx(-1, 1), cmplx(negzero, -1)},
-	Test{cmplx(1, 1), cmplx(-1, -1), cmplx(-1, negzero)},
-	Test{cmplx(1, 1), cmplx(-1, 2), cmplx(0.2, -0.6)},
-	Test{cmplx(1, 1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 1), cmplx(-1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 1), cmplx(2, 0), cmplx(0.5, 0.5)},
-	Test{cmplx(1, 1), cmplx(2, 1), cmplx(0.6, 0.2)},
-	Test{cmplx(1, 1), cmplx(2, -1), cmplx(0.2, 0.6)},
-	Test{cmplx(1, 1), cmplx(2, 2), cmplx(0.5, 0)},
-	Test{cmplx(1, 1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(2, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 1), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 1), cmplx(nan, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 1), cmplx(nan, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 1), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(1, 1), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(1, 1), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(1, 1), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(1, 1), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(1, 1), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(1, 1), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(1, 1), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(1, 1), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(1, 1), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(1, 1), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(1, 1), cmplx(-inf, nan), cmplx(negzero, negzero)},
-	Test{cmplx(1, 1), cmplx(-inf, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 1), cmplx(-inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, -1), cmplx(0, 0), cmplx(inf, -inf)},
-	Test{cmplx(1, -1), cmplx(0, 1), cmplx(-1, -1)},
-	Test{cmplx(1, -1), cmplx(0, -1), cmplx(1, 1)},
-	Test{cmplx(1, -1), cmplx(0, 2), cmplx(-0.5, -0.5)},
-	Test{cmplx(1, -1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(0, inf), cmplx(negzero, negzero)},
-	Test{cmplx(1, -1), cmplx(0, -inf), cmplx(0, 0)},
-	Test{cmplx(1, -1), cmplx(1, 0), cmplx(1, -1)},
-	Test{cmplx(1, -1), cmplx(1, 1), cmplx(0, -1)},
-	Test{cmplx(1, -1), cmplx(1, -1), cmplx(1, 0)},
-	Test{cmplx(1, -1), cmplx(1, 2), cmplx(-0.2, -0.6)},
-	Test{cmplx(1, -1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(1, inf), cmplx(negzero, negzero)},
-	Test{cmplx(1, -1), cmplx(1, -inf), cmplx(0, 0)},
-	Test{cmplx(1, -1), cmplx(-1, 0), cmplx(-1, 1)},
-	Test{cmplx(1, -1), cmplx(-1, 1), cmplx(-1, negzero)},
-	Test{cmplx(1, -1), cmplx(-1, -1), cmplx(negzero, 1)},
-	Test{cmplx(1, -1), cmplx(-1, 2), cmplx(-0.6, -0.2)},
-	Test{cmplx(1, -1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(-1, inf), cmplx(negzero, negzero)},
-	Test{cmplx(1, -1), cmplx(-1, -inf), cmplx(0, 0)},
-	Test{cmplx(1, -1), cmplx(2, 0), cmplx(0.5, -0.5)},
-	Test{cmplx(1, -1), cmplx(2, 1), cmplx(0.2, -0.6)},
-	Test{cmplx(1, -1), cmplx(2, -1), cmplx(0.6, -0.2)},
-	Test{cmplx(1, -1), cmplx(2, 2), cmplx(0, -0.5)},
-	Test{cmplx(1, -1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(2, inf), cmplx(negzero, negzero)},
-	Test{cmplx(1, -1), cmplx(2, -inf), cmplx(0, 0)},
-	Test{cmplx(1, -1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -1), cmplx(nan, inf), cmplx(negzero, negzero)},
-	Test{cmplx(1, -1), cmplx(nan, -inf), cmplx(0, 0)},
-	Test{cmplx(1, -1), cmplx(inf, 0), cmplx(0, negzero)},
-	Test{cmplx(1, -1), cmplx(inf, 1), cmplx(0, negzero)},
-	Test{cmplx(1, -1), cmplx(inf, -1), cmplx(0, negzero)},
-	Test{cmplx(1, -1), cmplx(inf, 2), cmplx(0, negzero)},
-	Test{cmplx(1, -1), cmplx(inf, nan), cmplx(0, negzero)},
-	Test{cmplx(1, -1), cmplx(inf, inf), cmplx(0, negzero)},
-	Test{cmplx(1, -1), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(1, -1), cmplx(-inf, 0), cmplx(negzero, 0)},
-	Test{cmplx(1, -1), cmplx(-inf, 1), cmplx(negzero, 0)},
-	Test{cmplx(1, -1), cmplx(-inf, -1), cmplx(negzero, 0)},
-	Test{cmplx(1, -1), cmplx(-inf, 2), cmplx(negzero, 0)},
-	Test{cmplx(1, -1), cmplx(-inf, nan), cmplx(negzero, 0)},
-	Test{cmplx(1, -1), cmplx(-inf, inf), cmplx(negzero, 0)},
-	Test{cmplx(1, -1), cmplx(-inf, -inf), cmplx(0, 0)},
-	Test{cmplx(1, 2), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(1, 2), cmplx(0, 1), cmplx(2, -1)},
-	Test{cmplx(1, 2), cmplx(0, -1), cmplx(-2, 1)},
-	Test{cmplx(1, 2), cmplx(0, 2), cmplx(1, -0.5)},
-	Test{cmplx(1, 2), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(0, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 2), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 2), cmplx(1, 0), cmplx(1, 2)},
-	Test{cmplx(1, 2), cmplx(1, 1), cmplx(1.5, 0.5)},
-	Test{cmplx(1, 2), cmplx(1, -1), cmplx(-0.5, 1.5)},
-	Test{cmplx(1, 2), cmplx(1, 2), cmplx(1, 0)},
-	Test{cmplx(1, 2), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(1, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 2), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 2), cmplx(-1, 0), cmplx(-1, -2)},
-	Test{cmplx(1, 2), cmplx(-1, 1), cmplx(0.5, -1.5)},
-	Test{cmplx(1, 2), cmplx(-1, -1), cmplx(-1.5, -0.5)},
-	Test{cmplx(1, 2), cmplx(-1, 2), cmplx(0.6, -0.8)},
-	Test{cmplx(1, 2), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 2), cmplx(-1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 2), cmplx(2, 0), cmplx(0.5, 1)},
-	Test{cmplx(1, 2), cmplx(2, 1), cmplx(0.8, 0.6)},
-	Test{cmplx(1, 2), cmplx(2, -1), cmplx(0, 1)},
-	Test{cmplx(1, 2), cmplx(2, 2), cmplx(0.75, 0.25)},
-	Test{cmplx(1, 2), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(2, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 2), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 2), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(1, 2), cmplx(nan, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 2), cmplx(nan, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 2), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(1, 2), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(1, 2), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(1, 2), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(1, 2), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(1, 2), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(1, 2), cmplx(inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(1, 2), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(1, 2), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(1, 2), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(1, 2), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(1, 2), cmplx(-inf, nan), cmplx(negzero, negzero)},
-	Test{cmplx(1, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-	Test{cmplx(1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(1, nan), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(1, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(1, inf), cmplx(0, 1), cmplx(inf, nan)},
-	Test{cmplx(1, inf), cmplx(0, -1), cmplx(-inf, nan)},
-	Test{cmplx(1, inf), cmplx(0, 2), cmplx(inf, nan)},
-	Test{cmplx(1, inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(1, 0), cmplx(nan, inf)},
-	Test{cmplx(1, inf), cmplx(1, 1), cmplx(inf, inf)},
-	Test{cmplx(1, inf), cmplx(1, -1), cmplx(-inf, inf)},
-	Test{cmplx(1, inf), cmplx(1, 2), cmplx(inf, inf)},
-	Test{cmplx(1, inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-	Test{cmplx(1, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-	Test{cmplx(1, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(1, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-	Test{cmplx(1, inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(2, 0), cmplx(nan, inf)},
-	Test{cmplx(1, inf), cmplx(2, 1), cmplx(inf, inf)},
-	Test{cmplx(1, inf), cmplx(2, -1), cmplx(-inf, inf)},
-	Test{cmplx(1, inf), cmplx(2, 2), cmplx(inf, inf)},
-	Test{cmplx(1, inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(1, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(0, 0), cmplx(inf, -inf)},
-	Test{cmplx(1, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-	Test{cmplx(1, -inf), cmplx(0, -1), cmplx(inf, nan)},
-	Test{cmplx(1, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-	Test{cmplx(1, -inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-	Test{cmplx(1, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(1, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-	Test{cmplx(1, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(1, -inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-	Test{cmplx(1, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-	Test{cmplx(1, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-	Test{cmplx(1, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-	Test{cmplx(1, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-	Test{cmplx(1, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-	Test{cmplx(1, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-	Test{cmplx(1, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-	Test{cmplx(1, -inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(0, 0), cmplx(-inf, nan)},
-	Test{cmplx(-1, 0), cmplx(0, 1), cmplx(0, 1)},
-	Test{cmplx(-1, 0), cmplx(0, -1), cmplx(negzero, -1)},
-	Test{cmplx(-1, 0), cmplx(0, 2), cmplx(0, 0.5)},
-	Test{cmplx(-1, 0), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(0, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 0), cmplx(0, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 0), cmplx(1, 0), cmplx(-1, 0)},
-	Test{cmplx(-1, 0), cmplx(1, 1), cmplx(-0.5, 0.5)},
-	Test{cmplx(-1, 0), cmplx(1, -1), cmplx(-0.5, -0.5)},
-	Test{cmplx(-1, 0), cmplx(1, 2), cmplx(-0.2, 0.4)},
-	Test{cmplx(-1, 0), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(1, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 0), cmplx(1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 0), cmplx(-1, 0), cmplx(1, negzero)},
-	Test{cmplx(-1, 0), cmplx(-1, 1), cmplx(0.5, 0.5)},
-	Test{cmplx(-1, 0), cmplx(-1, -1), cmplx(0.5, -0.5)},
-	Test{cmplx(-1, 0), cmplx(-1, 2), cmplx(0.2, 0.4)},
-	Test{cmplx(-1, 0), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(-1, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 0), cmplx(-1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 0), cmplx(2, 0), cmplx(-0.5, 0)},
-	Test{cmplx(-1, 0), cmplx(2, 1), cmplx(-0.4, 0.2)},
-	Test{cmplx(-1, 0), cmplx(2, -1), cmplx(-0.4, -0.2)},
-	Test{cmplx(-1, 0), cmplx(2, 2), cmplx(-0.25, 0.25)},
-	Test{cmplx(-1, 0), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(2, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 0), cmplx(2, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 0), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 0), cmplx(nan, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 0), cmplx(nan, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 0), cmplx(inf, 0), cmplx(negzero, 0)},
-	Test{cmplx(-1, 0), cmplx(inf, 1), cmplx(negzero, 0)},
-	Test{cmplx(-1, 0), cmplx(inf, -1), cmplx(negzero, 0)},
-	Test{cmplx(-1, 0), cmplx(inf, 2), cmplx(negzero, 0)},
-	Test{cmplx(-1, 0), cmplx(inf, nan), cmplx(negzero, 0)},
-	Test{cmplx(-1, 0), cmplx(inf, inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, 0), cmplx(inf, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 0), cmplx(-inf, 0), cmplx(0, negzero)},
-	Test{cmplx(-1, 0), cmplx(-inf, 1), cmplx(0, negzero)},
-	Test{cmplx(-1, 0), cmplx(-inf, -1), cmplx(0, negzero)},
-	Test{cmplx(-1, 0), cmplx(-inf, 2), cmplx(0, negzero)},
-	Test{cmplx(-1, 0), cmplx(-inf, nan), cmplx(0, 0)},
-	Test{cmplx(-1, 0), cmplx(-inf, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 0), cmplx(-inf, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, 1), cmplx(0, 0), cmplx(-inf, inf)},
-	Test{cmplx(-1, 1), cmplx(0, 1), cmplx(1, 1)},
-	Test{cmplx(-1, 1), cmplx(0, -1), cmplx(-1, -1)},
-	Test{cmplx(-1, 1), cmplx(0, 2), cmplx(0.5, 0.5)},
-	Test{cmplx(-1, 1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(0, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 1), cmplx(0, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 1), cmplx(1, 0), cmplx(-1, 1)},
-	Test{cmplx(-1, 1), cmplx(1, 1), cmplx(0, 1)},
-	Test{cmplx(-1, 1), cmplx(1, -1), cmplx(-1, 0)},
-	Test{cmplx(-1, 1), cmplx(1, 2), cmplx(0.2, 0.6)},
-	Test{cmplx(-1, 1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(1, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 1), cmplx(1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 1), cmplx(-1, 0), cmplx(1, -1)},
-	Test{cmplx(-1, 1), cmplx(-1, 1), cmplx(1, negzero)},
-	Test{cmplx(-1, 1), cmplx(-1, -1), cmplx(negzero, -1)},
-	Test{cmplx(-1, 1), cmplx(-1, 2), cmplx(0.6, 0.2)},
-	Test{cmplx(-1, 1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(-1, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 1), cmplx(-1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 1), cmplx(2, 0), cmplx(-0.5, 0.5)},
-	Test{cmplx(-1, 1), cmplx(2, 1), cmplx(-0.2, 0.6)},
-	Test{cmplx(-1, 1), cmplx(2, -1), cmplx(-0.6, 0.2)},
-	Test{cmplx(-1, 1), cmplx(2, 2), cmplx(0, 0.5)},
-	Test{cmplx(-1, 1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(2, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 1), cmplx(2, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 1), cmplx(nan, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 1), cmplx(nan, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 1), cmplx(inf, 0), cmplx(negzero, 0)},
-	Test{cmplx(-1, 1), cmplx(inf, 1), cmplx(negzero, 0)},
-	Test{cmplx(-1, 1), cmplx(inf, -1), cmplx(negzero, 0)},
-	Test{cmplx(-1, 1), cmplx(inf, 2), cmplx(negzero, 0)},
-	Test{cmplx(-1, 1), cmplx(inf, nan), cmplx(negzero, 0)},
-	Test{cmplx(-1, 1), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 1), cmplx(inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, 1), cmplx(-inf, 0), cmplx(0, negzero)},
-	Test{cmplx(-1, 1), cmplx(-inf, 1), cmplx(0, negzero)},
-	Test{cmplx(-1, 1), cmplx(-inf, -1), cmplx(0, negzero)},
-	Test{cmplx(-1, 1), cmplx(-inf, 2), cmplx(0, negzero)},
-	Test{cmplx(-1, 1), cmplx(-inf, nan), cmplx(0, negzero)},
-	Test{cmplx(-1, 1), cmplx(-inf, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 1), cmplx(-inf, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, -1), cmplx(0, 0), cmplx(-inf, -inf)},
-	Test{cmplx(-1, -1), cmplx(0, 1), cmplx(-1, 1)},
-	Test{cmplx(-1, -1), cmplx(0, -1), cmplx(1, -1)},
-	Test{cmplx(-1, -1), cmplx(0, 2), cmplx(-0.5, 0.5)},
-	Test{cmplx(-1, -1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(0, inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, -1), cmplx(0, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, -1), cmplx(1, 0), cmplx(-1, -1)},
-	Test{cmplx(-1, -1), cmplx(1, 1), cmplx(-1, 0)},
-	Test{cmplx(-1, -1), cmplx(1, -1), cmplx(0, -1)},
-	Test{cmplx(-1, -1), cmplx(1, 2), cmplx(-0.6, 0.2)},
-	Test{cmplx(-1, -1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(1, inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, -1), cmplx(1, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, -1), cmplx(-1, 0), cmplx(1, 1)},
-	Test{cmplx(-1, -1), cmplx(-1, 1), cmplx(negzero, 1)},
-	Test{cmplx(-1, -1), cmplx(-1, -1), cmplx(1, negzero)},
-	Test{cmplx(-1, -1), cmplx(-1, 2), cmplx(-0.2, 0.6)},
-	Test{cmplx(-1, -1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(-1, inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, -1), cmplx(-1, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, -1), cmplx(2, 0), cmplx(-0.5, -0.5)},
-	Test{cmplx(-1, -1), cmplx(2, 1), cmplx(-0.6, -0.2)},
-	Test{cmplx(-1, -1), cmplx(2, -1), cmplx(-0.2, -0.6)},
-	Test{cmplx(-1, -1), cmplx(2, 2), cmplx(-0.5, 0)},
-	Test{cmplx(-1, -1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(2, inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, -1), cmplx(2, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, -1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -1), cmplx(nan, inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, -1), cmplx(nan, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, -1), cmplx(inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(-1, -1), cmplx(inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(-1, -1), cmplx(inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(-1, -1), cmplx(inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(-1, -1), cmplx(inf, nan), cmplx(negzero, negzero)},
-	Test{cmplx(-1, -1), cmplx(inf, inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, -1), cmplx(inf, -inf), cmplx(0, negzero)},
-	Test{cmplx(-1, -1), cmplx(-inf, 0), cmplx(0, 0)},
-	Test{cmplx(-1, -1), cmplx(-inf, 1), cmplx(0, 0)},
-	Test{cmplx(-1, -1), cmplx(-inf, -1), cmplx(0, 0)},
-	Test{cmplx(-1, -1), cmplx(-inf, 2), cmplx(0, 0)},
-	Test{cmplx(-1, -1), cmplx(-inf, nan), cmplx(0, 0)},
-	Test{cmplx(-1, -1), cmplx(-inf, inf), cmplx(0, 0)},
-	Test{cmplx(-1, -1), cmplx(-inf, -inf), cmplx(0, 0)},
-	Test{cmplx(-1, 2), cmplx(0, 0), cmplx(-inf, inf)},
-	Test{cmplx(-1, 2), cmplx(0, 1), cmplx(2, 1)},
-	Test{cmplx(-1, 2), cmplx(0, -1), cmplx(-2, -1)},
-	Test{cmplx(-1, 2), cmplx(0, 2), cmplx(1, 0.5)},
-	Test{cmplx(-1, 2), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(0, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 2), cmplx(0, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 2), cmplx(1, 0), cmplx(-1, 2)},
-	Test{cmplx(-1, 2), cmplx(1, 1), cmplx(0.5, 1.5)},
-	Test{cmplx(-1, 2), cmplx(1, -1), cmplx(-1.5, 0.5)},
-	Test{cmplx(-1, 2), cmplx(1, 2), cmplx(0.6, 0.8)},
-	Test{cmplx(-1, 2), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(1, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 2), cmplx(1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 2), cmplx(-1, 0), cmplx(1, -2)},
-	Test{cmplx(-1, 2), cmplx(-1, 1), cmplx(1.5, -0.5)},
-	Test{cmplx(-1, 2), cmplx(-1, -1), cmplx(-0.5, -1.5)},
-	Test{cmplx(-1, 2), cmplx(-1, 2), cmplx(1, 0)},
-	Test{cmplx(-1, 2), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(-1, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 2), cmplx(-1, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 2), cmplx(2, 0), cmplx(-0.5, 1)},
-	Test{cmplx(-1, 2), cmplx(2, 1), cmplx(0, 1)},
-	Test{cmplx(-1, 2), cmplx(2, -1), cmplx(-0.8, 0.6)},
-	Test{cmplx(-1, 2), cmplx(2, 2), cmplx(0.25, 0.75)},
-	Test{cmplx(-1, 2), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(2, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 2), cmplx(2, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 2), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, 2), cmplx(nan, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 2), cmplx(nan, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, 2), cmplx(inf, 0), cmplx(negzero, 0)},
-	Test{cmplx(-1, 2), cmplx(inf, 1), cmplx(negzero, 0)},
-	Test{cmplx(-1, 2), cmplx(inf, -1), cmplx(negzero, 0)},
-	Test{cmplx(-1, 2), cmplx(inf, 2), cmplx(negzero, 0)},
-	Test{cmplx(-1, 2), cmplx(inf, nan), cmplx(negzero, 0)},
-	Test{cmplx(-1, 2), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(-1, 2), cmplx(inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(-1, 2), cmplx(-inf, 0), cmplx(0, negzero)},
-	Test{cmplx(-1, 2), cmplx(-inf, 1), cmplx(0, negzero)},
-	Test{cmplx(-1, 2), cmplx(-inf, -1), cmplx(0, negzero)},
-	Test{cmplx(-1, 2), cmplx(-inf, 2), cmplx(0, negzero)},
-	Test{cmplx(-1, 2), cmplx(-inf, nan), cmplx(0, negzero)},
-	Test{cmplx(-1, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-	Test{cmplx(-1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-	Test{cmplx(-1, nan), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(0, 0), cmplx(-inf, inf)},
-	Test{cmplx(-1, inf), cmplx(0, 1), cmplx(inf, nan)},
-	Test{cmplx(-1, inf), cmplx(0, -1), cmplx(-inf, nan)},
-	Test{cmplx(-1, inf), cmplx(0, 2), cmplx(inf, nan)},
-	Test{cmplx(-1, inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(1, 0), cmplx(nan, inf)},
-	Test{cmplx(-1, inf), cmplx(1, 1), cmplx(inf, inf)},
-	Test{cmplx(-1, inf), cmplx(1, -1), cmplx(-inf, inf)},
-	Test{cmplx(-1, inf), cmplx(1, 2), cmplx(inf, inf)},
-	Test{cmplx(-1, inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-	Test{cmplx(-1, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-	Test{cmplx(-1, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-1, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-	Test{cmplx(-1, inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(2, 0), cmplx(nan, inf)},
-	Test{cmplx(-1, inf), cmplx(2, 1), cmplx(inf, inf)},
-	Test{cmplx(-1, inf), cmplx(2, -1), cmplx(-inf, inf)},
-	Test{cmplx(-1, inf), cmplx(2, 2), cmplx(inf, inf)},
-	Test{cmplx(-1, inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(0, 0), cmplx(-inf, -inf)},
-	Test{cmplx(-1, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-	Test{cmplx(-1, -inf), cmplx(0, -1), cmplx(inf, nan)},
-	Test{cmplx(-1, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-	Test{cmplx(-1, -inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-	Test{cmplx(-1, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(-1, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-	Test{cmplx(-1, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(-1, -inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-	Test{cmplx(-1, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-	Test{cmplx(-1, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-	Test{cmplx(-1, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-	Test{cmplx(-1, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-	Test{cmplx(-1, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-	Test{cmplx(-1, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-	Test{cmplx(-1, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-	Test{cmplx(-1, -inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(0, 0), cmplx(inf, nan)},
-	Test{cmplx(2, 0), cmplx(0, 1), cmplx(0, -2)},
-	Test{cmplx(2, 0), cmplx(0, -1), cmplx(negzero, 2)},
-	Test{cmplx(2, 0), cmplx(0, 2), cmplx(0, -1)},
-	Test{cmplx(2, 0), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(0, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 0), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 0), cmplx(1, 0), cmplx(2, 0)},
-	Test{cmplx(2, 0), cmplx(1, 1), cmplx(1, -1)},
-	Test{cmplx(2, 0), cmplx(1, -1), cmplx(1, 1)},
-	Test{cmplx(2, 0), cmplx(1, 2), cmplx(0.4, -0.8)},
-	Test{cmplx(2, 0), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(1, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 0), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 0), cmplx(-1, 0), cmplx(-2, negzero)},
-	Test{cmplx(2, 0), cmplx(-1, 1), cmplx(-1, -1)},
-	Test{cmplx(2, 0), cmplx(-1, -1), cmplx(-1, 1)},
-	Test{cmplx(2, 0), cmplx(-1, 2), cmplx(-0.4, -0.8)},
-	Test{cmplx(2, 0), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 0), cmplx(-1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 0), cmplx(2, 0), cmplx(1, 0)},
-	Test{cmplx(2, 0), cmplx(2, 1), cmplx(0.8, -0.4)},
-	Test{cmplx(2, 0), cmplx(2, -1), cmplx(0.8, 0.4)},
-	Test{cmplx(2, 0), cmplx(2, 2), cmplx(0.5, -0.5)},
-	Test{cmplx(2, 0), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(2, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 0), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 0), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 0), cmplx(nan, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 0), cmplx(nan, -inf), cmplx(0, 0)},
-	Test{cmplx(2, 0), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(2, 0), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(2, 0), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(2, 0), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(2, 0), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(2, 0), cmplx(inf, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 0), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(2, 0), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(2, 0), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(2, 0), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(2, 0), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(2, 0), cmplx(-inf, nan), cmplx(negzero, negzero)},
-	Test{cmplx(2, 0), cmplx(-inf, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, 0), cmplx(-inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 1), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(2, 1), cmplx(0, 1), cmplx(1, -2)},
-	Test{cmplx(2, 1), cmplx(0, -1), cmplx(-1, 2)},
-	Test{cmplx(2, 1), cmplx(0, 2), cmplx(0.5, -1)},
-	Test{cmplx(2, 1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(0, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 1), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 1), cmplx(1, 0), cmplx(2, 1)},
-	Test{cmplx(2, 1), cmplx(1, 1), cmplx(1.5, -0.5)},
-	Test{cmplx(2, 1), cmplx(1, -1), cmplx(0.5, 1.5)},
-	Test{cmplx(2, 1), cmplx(1, 2), cmplx(0.8, -0.6)},
-	Test{cmplx(2, 1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(1, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 1), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 1), cmplx(-1, 0), cmplx(-2, -1)},
-	Test{cmplx(2, 1), cmplx(-1, 1), cmplx(-0.5, -1.5)},
-	Test{cmplx(2, 1), cmplx(-1, -1), cmplx(-1.5, 0.5)},
-	Test{cmplx(2, 1), cmplx(-1, 2), cmplx(0, -1)},
-	Test{cmplx(2, 1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 1), cmplx(-1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 1), cmplx(2, 0), cmplx(1, 0.5)},
-	Test{cmplx(2, 1), cmplx(2, 1), cmplx(1, 0)},
-	Test{cmplx(2, 1), cmplx(2, -1), cmplx(0.6, 0.8)},
-	Test{cmplx(2, 1), cmplx(2, 2), cmplx(0.75, -0.25)},
-	Test{cmplx(2, 1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(2, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 1), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 1), cmplx(nan, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 1), cmplx(nan, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 1), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(2, 1), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(2, 1), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(2, 1), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(2, 1), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(2, 1), cmplx(inf, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 1), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(2, 1), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(2, 1), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(2, 1), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(2, 1), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(2, 1), cmplx(-inf, nan), cmplx(negzero, negzero)},
-	Test{cmplx(2, 1), cmplx(-inf, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, 1), cmplx(-inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, -1), cmplx(0, 0), cmplx(inf, -inf)},
-	Test{cmplx(2, -1), cmplx(0, 1), cmplx(-1, -2)},
-	Test{cmplx(2, -1), cmplx(0, -1), cmplx(1, 2)},
-	Test{cmplx(2, -1), cmplx(0, 2), cmplx(-0.5, -1)},
-	Test{cmplx(2, -1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(0, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, -1), cmplx(0, -inf), cmplx(0, 0)},
-	Test{cmplx(2, -1), cmplx(1, 0), cmplx(2, -1)},
-	Test{cmplx(2, -1), cmplx(1, 1), cmplx(0.5, -1.5)},
-	Test{cmplx(2, -1), cmplx(1, -1), cmplx(1.5, 0.5)},
-	Test{cmplx(2, -1), cmplx(1, 2), cmplx(0, -1)},
-	Test{cmplx(2, -1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(1, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, -1), cmplx(1, -inf), cmplx(0, 0)},
-	Test{cmplx(2, -1), cmplx(-1, 0), cmplx(-2, 1)},
-	Test{cmplx(2, -1), cmplx(-1, 1), cmplx(-1.5, -0.5)},
-	Test{cmplx(2, -1), cmplx(-1, -1), cmplx(-0.5, 1.5)},
-	Test{cmplx(2, -1), cmplx(-1, 2), cmplx(-0.8, -0.6)},
-	Test{cmplx(2, -1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(-1, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, -1), cmplx(-1, -inf), cmplx(0, 0)},
-	Test{cmplx(2, -1), cmplx(2, 0), cmplx(1, -0.5)},
-	Test{cmplx(2, -1), cmplx(2, 1), cmplx(0.6, -0.8)},
-	Test{cmplx(2, -1), cmplx(2, -1), cmplx(1, 0)},
-	Test{cmplx(2, -1), cmplx(2, 2), cmplx(0.25, -0.75)},
-	Test{cmplx(2, -1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(2, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, -1), cmplx(2, -inf), cmplx(0, 0)},
-	Test{cmplx(2, -1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -1), cmplx(nan, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, -1), cmplx(nan, -inf), cmplx(0, 0)},
-	Test{cmplx(2, -1), cmplx(inf, 0), cmplx(0, negzero)},
-	Test{cmplx(2, -1), cmplx(inf, 1), cmplx(0, negzero)},
-	Test{cmplx(2, -1), cmplx(inf, -1), cmplx(0, negzero)},
-	Test{cmplx(2, -1), cmplx(inf, 2), cmplx(0, negzero)},
-	Test{cmplx(2, -1), cmplx(inf, nan), cmplx(0, negzero)},
-	Test{cmplx(2, -1), cmplx(inf, inf), cmplx(0, negzero)},
-	Test{cmplx(2, -1), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(2, -1), cmplx(-inf, 0), cmplx(negzero, 0)},
-	Test{cmplx(2, -1), cmplx(-inf, 1), cmplx(negzero, 0)},
-	Test{cmplx(2, -1), cmplx(-inf, -1), cmplx(negzero, 0)},
-	Test{cmplx(2, -1), cmplx(-inf, 2), cmplx(negzero, 0)},
-	Test{cmplx(2, -1), cmplx(-inf, nan), cmplx(negzero, 0)},
-	Test{cmplx(2, -1), cmplx(-inf, inf), cmplx(negzero, negzero)},
-	Test{cmplx(2, -1), cmplx(-inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 2), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(2, 2), cmplx(0, 1), cmplx(2, -2)},
-	Test{cmplx(2, 2), cmplx(0, -1), cmplx(-2, 2)},
-	Test{cmplx(2, 2), cmplx(0, 2), cmplx(1, -1)},
-	Test{cmplx(2, 2), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(0, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 2), cmplx(0, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 2), cmplx(1, 0), cmplx(2, 2)},
-	Test{cmplx(2, 2), cmplx(1, 1), cmplx(2, 0)},
-	Test{cmplx(2, 2), cmplx(1, -1), cmplx(0, 2)},
-	Test{cmplx(2, 2), cmplx(1, 2), cmplx(1.2, -0.4)},
-	Test{cmplx(2, 2), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(1, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 2), cmplx(1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 2), cmplx(-1, 0), cmplx(-2, -2)},
-	Test{cmplx(2, 2), cmplx(-1, 1), cmplx(negzero, -2)},
-	Test{cmplx(2, 2), cmplx(-1, -1), cmplx(-2, negzero)},
-	Test{cmplx(2, 2), cmplx(-1, 2), cmplx(0.4, -1.2)},
-	Test{cmplx(2, 2), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(-1, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 2), cmplx(-1, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 2), cmplx(2, 0), cmplx(1, 1)},
-	Test{cmplx(2, 2), cmplx(2, 1), cmplx(1.2, 0.4)},
-	Test{cmplx(2, 2), cmplx(2, -1), cmplx(0.4, 1.2)},
-	Test{cmplx(2, 2), cmplx(2, 2), cmplx(1, 0)},
-	Test{cmplx(2, 2), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(2, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 2), cmplx(2, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 2), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(2, 2), cmplx(nan, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 2), cmplx(nan, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, 2), cmplx(inf, 0), cmplx(0, 0)},
-	Test{cmplx(2, 2), cmplx(inf, 1), cmplx(0, 0)},
-	Test{cmplx(2, 2), cmplx(inf, -1), cmplx(0, 0)},
-	Test{cmplx(2, 2), cmplx(inf, 2), cmplx(0, 0)},
-	Test{cmplx(2, 2), cmplx(inf, nan), cmplx(0, 0)},
-	Test{cmplx(2, 2), cmplx(inf, inf), cmplx(0, 0)},
-	Test{cmplx(2, 2), cmplx(inf, -inf), cmplx(0, 0)},
-	Test{cmplx(2, 2), cmplx(-inf, 0), cmplx(negzero, negzero)},
-	Test{cmplx(2, 2), cmplx(-inf, 1), cmplx(negzero, negzero)},
-	Test{cmplx(2, 2), cmplx(-inf, -1), cmplx(negzero, negzero)},
-	Test{cmplx(2, 2), cmplx(-inf, 2), cmplx(negzero, negzero)},
-	Test{cmplx(2, 2), cmplx(-inf, nan), cmplx(negzero, negzero)},
-	Test{cmplx(2, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-	Test{cmplx(2, 2), cmplx(-inf, -inf), cmplx(negzero, 0)},
-	Test{cmplx(2, nan), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(2, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(2, inf), cmplx(0, 1), cmplx(inf, nan)},
-	Test{cmplx(2, inf), cmplx(0, -1), cmplx(-inf, nan)},
-	Test{cmplx(2, inf), cmplx(0, 2), cmplx(inf, nan)},
-	Test{cmplx(2, inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(1, 0), cmplx(nan, inf)},
-	Test{cmplx(2, inf), cmplx(1, 1), cmplx(inf, inf)},
-	Test{cmplx(2, inf), cmplx(1, -1), cmplx(-inf, inf)},
-	Test{cmplx(2, inf), cmplx(1, 2), cmplx(inf, inf)},
-	Test{cmplx(2, inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-	Test{cmplx(2, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-	Test{cmplx(2, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(2, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-	Test{cmplx(2, inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(2, 0), cmplx(nan, inf)},
-	Test{cmplx(2, inf), cmplx(2, 1), cmplx(inf, inf)},
-	Test{cmplx(2, inf), cmplx(2, -1), cmplx(-inf, inf)},
-	Test{cmplx(2, inf), cmplx(2, 2), cmplx(inf, inf)},
-	Test{cmplx(2, inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(2, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(0, 0), cmplx(inf, -inf)},
-	Test{cmplx(2, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-	Test{cmplx(2, -inf), cmplx(0, -1), cmplx(inf, nan)},
-	Test{cmplx(2, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-	Test{cmplx(2, -inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-	Test{cmplx(2, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(2, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-	Test{cmplx(2, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(2, -inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-	Test{cmplx(2, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-	Test{cmplx(2, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-	Test{cmplx(2, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-	Test{cmplx(2, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-	Test{cmplx(2, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-	Test{cmplx(2, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-	Test{cmplx(2, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-	Test{cmplx(2, -inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(2, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 0), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 1), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -1), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, 2), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(0, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(0, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(0, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(0, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-1, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-1, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-1, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-1, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(2, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(2, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(2, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(2, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(0, 0), cmplx(nan, inf)},
-	Test{cmplx(nan, inf), cmplx(0, 1), cmplx(inf, nan)},
-	Test{cmplx(nan, inf), cmplx(0, -1), cmplx(-inf, nan)},
-	Test{cmplx(nan, inf), cmplx(0, 2), cmplx(inf, nan)},
-	Test{cmplx(nan, inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(1, 0), cmplx(nan, inf)},
-	Test{cmplx(nan, inf), cmplx(1, 1), cmplx(inf, inf)},
-	Test{cmplx(nan, inf), cmplx(1, -1), cmplx(-inf, inf)},
-	Test{cmplx(nan, inf), cmplx(1, 2), cmplx(inf, inf)},
-	Test{cmplx(nan, inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-	Test{cmplx(nan, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-	Test{cmplx(nan, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(nan, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-	Test{cmplx(nan, inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(2, 0), cmplx(nan, inf)},
-	Test{cmplx(nan, inf), cmplx(2, 1), cmplx(inf, inf)},
-	Test{cmplx(nan, inf), cmplx(2, -1), cmplx(-inf, inf)},
-	Test{cmplx(nan, inf), cmplx(2, 2), cmplx(inf, inf)},
-	Test{cmplx(nan, inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(0, 0), cmplx(nan, -inf)},
-	Test{cmplx(nan, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-	Test{cmplx(nan, -inf), cmplx(0, -1), cmplx(inf, nan)},
-	Test{cmplx(nan, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-	Test{cmplx(nan, -inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-	Test{cmplx(nan, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(nan, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-	Test{cmplx(nan, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(nan, -inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-	Test{cmplx(nan, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-	Test{cmplx(nan, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-	Test{cmplx(nan, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-	Test{cmplx(nan, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-	Test{cmplx(nan, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-	Test{cmplx(nan, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-	Test{cmplx(nan, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-	Test{cmplx(nan, -inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(nan, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(0, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, 0), cmplx(0, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, 0), cmplx(0, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, 0), cmplx(0, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, 0), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(1, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, 0), cmplx(1, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, 0), cmplx(1, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, 0), cmplx(1, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, 0), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-1, 0), cmplx(-inf, nan)},
-	Test{cmplx(inf, 0), cmplx(-1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(inf, 0), cmplx(-1, -1), cmplx(-inf, inf)},
-	Test{cmplx(inf, 0), cmplx(-1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(inf, 0), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(2, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, 0), cmplx(2, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, 0), cmplx(2, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, 0), cmplx(2, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, 0), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(inf, 1), cmplx(0, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, 1), cmplx(0, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, 1), cmplx(0, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, 1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(1, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, 1), cmplx(1, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, 1), cmplx(1, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, 1), cmplx(1, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, 1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-1, 0), cmplx(-inf, nan)},
-	Test{cmplx(inf, 1), cmplx(-1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(inf, 1), cmplx(-1, -1), cmplx(-inf, inf)},
-	Test{cmplx(inf, 1), cmplx(-1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(inf, 1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(2, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, 1), cmplx(2, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, 1), cmplx(2, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, 1), cmplx(2, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, 1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(0, 0), cmplx(inf, -inf)},
-	Test{cmplx(inf, -1), cmplx(0, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, -1), cmplx(0, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, -1), cmplx(0, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, -1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(1, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, -1), cmplx(1, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, -1), cmplx(1, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, -1), cmplx(1, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, -1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-1, 0), cmplx(-inf, nan)},
-	Test{cmplx(inf, -1), cmplx(-1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(inf, -1), cmplx(-1, -1), cmplx(-inf, inf)},
-	Test{cmplx(inf, -1), cmplx(-1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(inf, -1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(2, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, -1), cmplx(2, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, -1), cmplx(2, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, -1), cmplx(2, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, -1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(inf, 2), cmplx(0, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, 2), cmplx(0, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, 2), cmplx(0, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, 2), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(1, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, 2), cmplx(1, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, 2), cmplx(1, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, 2), cmplx(1, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, 2), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-1, 0), cmplx(-inf, nan)},
-	Test{cmplx(inf, 2), cmplx(-1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(inf, 2), cmplx(-1, -1), cmplx(-inf, inf)},
-	Test{cmplx(inf, 2), cmplx(-1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(inf, 2), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(2, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, 2), cmplx(2, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, 2), cmplx(2, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, 2), cmplx(2, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, 2), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(0, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, nan), cmplx(0, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, nan), cmplx(0, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, nan), cmplx(0, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, nan), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(1, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, nan), cmplx(1, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, nan), cmplx(1, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, nan), cmplx(1, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, nan), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-1, 0), cmplx(-inf, nan)},
-	Test{cmplx(inf, nan), cmplx(-1, 1), cmplx(-inf, -inf)},
-	Test{cmplx(inf, nan), cmplx(-1, -1), cmplx(-inf, inf)},
-	Test{cmplx(inf, nan), cmplx(-1, 2), cmplx(-inf, -inf)},
-	Test{cmplx(inf, nan), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(2, 0), cmplx(inf, nan)},
-	Test{cmplx(inf, nan), cmplx(2, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, nan), cmplx(2, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, nan), cmplx(2, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, nan), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(0, 0), cmplx(inf, inf)},
-	Test{cmplx(inf, inf), cmplx(0, 1), cmplx(inf, -inf)},
-	Test{cmplx(inf, inf), cmplx(0, -1), cmplx(-inf, inf)},
-	Test{cmplx(inf, inf), cmplx(0, 2), cmplx(inf, -inf)},
-	Test{cmplx(inf, inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(1, 0), cmplx(inf, inf)},
-	Test{cmplx(inf, inf), cmplx(1, 1), cmplx(inf, nan)},
-	Test{cmplx(inf, inf), cmplx(1, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, inf), cmplx(1, 2), cmplx(inf, nan)},
-	Test{cmplx(inf, inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-1, 0), cmplx(-inf, -inf)},
-	Test{cmplx(inf, inf), cmplx(-1, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, inf), cmplx(-1, -1), cmplx(-inf, nan)},
-	Test{cmplx(inf, inf), cmplx(-1, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(2, 0), cmplx(inf, inf)},
-	Test{cmplx(inf, inf), cmplx(2, 1), cmplx(inf, nan)},
-	Test{cmplx(inf, inf), cmplx(2, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, inf), cmplx(2, 2), cmplx(inf, nan)},
-	Test{cmplx(inf, inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(0, 0), cmplx(inf, -inf)},
-	Test{cmplx(inf, -inf), cmplx(0, 1), cmplx(-inf, -inf)},
-	Test{cmplx(inf, -inf), cmplx(0, -1), cmplx(inf, inf)},
-	Test{cmplx(inf, -inf), cmplx(0, 2), cmplx(-inf, -inf)},
-	Test{cmplx(inf, -inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(1, 0), cmplx(inf, -inf)},
-	Test{cmplx(inf, -inf), cmplx(1, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, -inf), cmplx(1, -1), cmplx(inf, nan)},
-	Test{cmplx(inf, -inf), cmplx(1, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, -inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-1, 0), cmplx(-inf, inf)},
-	Test{cmplx(inf, -inf), cmplx(-1, 1), cmplx(-inf, nan)},
-	Test{cmplx(inf, -inf), cmplx(-1, -1), cmplx(nan, inf)},
-	Test{cmplx(inf, -inf), cmplx(-1, 2), cmplx(-inf, nan)},
-	Test{cmplx(inf, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(2, 0), cmplx(inf, -inf)},
-	Test{cmplx(inf, -inf), cmplx(2, 1), cmplx(nan, -inf)},
-	Test{cmplx(inf, -inf), cmplx(2, -1), cmplx(inf, nan)},
-	Test{cmplx(inf, -inf), cmplx(2, 2), cmplx(nan, -inf)},
-	Test{cmplx(inf, -inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(0, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, 0), cmplx(0, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, 0), cmplx(0, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, 0), cmplx(0, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, 0), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(1, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, 0), cmplx(1, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 0), cmplx(1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, 0), cmplx(1, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 0), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-1, 0), cmplx(inf, nan)},
-	Test{cmplx(-inf, 0), cmplx(-1, 1), cmplx(inf, inf)},
-	Test{cmplx(-inf, 0), cmplx(-1, -1), cmplx(inf, -inf)},
-	Test{cmplx(-inf, 0), cmplx(-1, 2), cmplx(inf, inf)},
-	Test{cmplx(-inf, 0), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(2, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, 0), cmplx(2, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 0), cmplx(2, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, 0), cmplx(2, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 0), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(0, 0), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 1), cmplx(0, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, 1), cmplx(0, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, 1), cmplx(0, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, 1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(1, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, 1), cmplx(1, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 1), cmplx(1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, 1), cmplx(1, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-1, 0), cmplx(inf, nan)},
-	Test{cmplx(-inf, 1), cmplx(-1, 1), cmplx(inf, inf)},
-	Test{cmplx(-inf, 1), cmplx(-1, -1), cmplx(inf, -inf)},
-	Test{cmplx(-inf, 1), cmplx(-1, 2), cmplx(inf, inf)},
-	Test{cmplx(-inf, 1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(2, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, 1), cmplx(2, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 1), cmplx(2, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, 1), cmplx(2, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(0, 0), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, -1), cmplx(0, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, -1), cmplx(0, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, -1), cmplx(0, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, -1), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(1, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, -1), cmplx(1, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, -1), cmplx(1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, -1), cmplx(1, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, -1), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-1, 0), cmplx(inf, nan)},
-	Test{cmplx(-inf, -1), cmplx(-1, 1), cmplx(inf, inf)},
-	Test{cmplx(-inf, -1), cmplx(-1, -1), cmplx(inf, -inf)},
-	Test{cmplx(-inf, -1), cmplx(-1, 2), cmplx(inf, inf)},
-	Test{cmplx(-inf, -1), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(2, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, -1), cmplx(2, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, -1), cmplx(2, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, -1), cmplx(2, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, -1), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(0, 0), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 2), cmplx(0, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, 2), cmplx(0, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, 2), cmplx(0, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, 2), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(1, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, 2), cmplx(1, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 2), cmplx(1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, 2), cmplx(1, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 2), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-1, 0), cmplx(inf, nan)},
-	Test{cmplx(-inf, 2), cmplx(-1, 1), cmplx(inf, inf)},
-	Test{cmplx(-inf, 2), cmplx(-1, -1), cmplx(inf, -inf)},
-	Test{cmplx(-inf, 2), cmplx(-1, 2), cmplx(inf, inf)},
-	Test{cmplx(-inf, 2), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(2, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, 2), cmplx(2, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 2), cmplx(2, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, 2), cmplx(2, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, 2), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(0, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, nan), cmplx(0, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, nan), cmplx(0, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, nan), cmplx(0, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, nan), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(1, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, nan), cmplx(1, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, nan), cmplx(1, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, nan), cmplx(1, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, nan), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-1, 0), cmplx(inf, nan)},
-	Test{cmplx(-inf, nan), cmplx(-1, 1), cmplx(inf, inf)},
-	Test{cmplx(-inf, nan), cmplx(-1, -1), cmplx(inf, -inf)},
-	Test{cmplx(-inf, nan), cmplx(-1, 2), cmplx(inf, inf)},
-	Test{cmplx(-inf, nan), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(2, 0), cmplx(-inf, nan)},
-	Test{cmplx(-inf, nan), cmplx(2, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, nan), cmplx(2, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, nan), cmplx(2, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, nan), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(0, 0), cmplx(-inf, inf)},
-	Test{cmplx(-inf, inf), cmplx(0, 1), cmplx(inf, inf)},
-	Test{cmplx(-inf, inf), cmplx(0, -1), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, inf), cmplx(0, 2), cmplx(inf, inf)},
-	Test{cmplx(-inf, inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(1, 0), cmplx(-inf, inf)},
-	Test{cmplx(-inf, inf), cmplx(1, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, inf), cmplx(1, -1), cmplx(-inf, nan)},
-	Test{cmplx(-inf, inf), cmplx(1, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-1, 0), cmplx(inf, -inf)},
-	Test{cmplx(-inf, inf), cmplx(-1, 1), cmplx(inf, nan)},
-	Test{cmplx(-inf, inf), cmplx(-1, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, inf), cmplx(-1, 2), cmplx(inf, nan)},
-	Test{cmplx(-inf, inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(2, 0), cmplx(-inf, inf)},
-	Test{cmplx(-inf, inf), cmplx(2, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, inf), cmplx(2, -1), cmplx(-inf, nan)},
-	Test{cmplx(-inf, inf), cmplx(2, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(0, 0), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, -inf), cmplx(0, 1), cmplx(-inf, inf)},
-	Test{cmplx(-inf, -inf), cmplx(0, -1), cmplx(inf, -inf)},
-	Test{cmplx(-inf, -inf), cmplx(0, 2), cmplx(-inf, inf)},
-	Test{cmplx(-inf, -inf), cmplx(0, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(0, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(1, 0), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, -inf), cmplx(1, 1), cmplx(-inf, nan)},
-	Test{cmplx(-inf, -inf), cmplx(1, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, -inf), cmplx(1, 2), cmplx(-inf, nan)},
-	Test{cmplx(-inf, -inf), cmplx(1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-1, 0), cmplx(inf, inf)},
-	Test{cmplx(-inf, -inf), cmplx(-1, 1), cmplx(nan, inf)},
-	Test{cmplx(-inf, -inf), cmplx(-1, -1), cmplx(inf, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-1, 2), cmplx(nan, inf)},
-	Test{cmplx(-inf, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(2, 0), cmplx(-inf, -inf)},
-	Test{cmplx(-inf, -inf), cmplx(2, 1), cmplx(-inf, nan)},
-	Test{cmplx(-inf, -inf), cmplx(2, -1), cmplx(nan, -inf)},
-	Test{cmplx(-inf, -inf), cmplx(2, 2), cmplx(-inf, nan)},
-	Test{cmplx(-inf, -inf), cmplx(2, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(2, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-	Test{cmplx(-inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
+	Test{complex(0, 0), complex(0, 0), complex(-nan, -nan)},
+	Test{complex(0, 0), complex(0, 1), complex(0, 0)},
+	Test{complex(0, 0), complex(0, -1), complex(negzero, 0)},
+	Test{complex(0, 0), complex(0, 2), complex(0, 0)},
+	Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 0), complex(1, 0), complex(0, 0)},
+	Test{complex(0, 0), complex(1, 1), complex(0, 0)},
+	Test{complex(0, 0), complex(1, -1), complex(0, 0)},
+	Test{complex(0, 0), complex(1, 2), complex(0, 0)},
+	Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 0), complex(-1, 0), complex(negzero, negzero)},
+	Test{complex(0, 0), complex(-1, 1), complex(negzero, negzero)},
+	Test{complex(0, 0), complex(-1, -1), complex(negzero, negzero)},
+	Test{complex(0, 0), complex(-1, 2), complex(0, negzero)},
+	Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 0), complex(2, 0), complex(0, 0)},
+	Test{complex(0, 0), complex(2, 1), complex(0, 0)},
+	Test{complex(0, 0), complex(2, -1), complex(0, 0)},
+	Test{complex(0, 0), complex(2, 2), complex(0, 0)},
+	Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 0), complex(nan, 0), complex(nan, nan)},
+	Test{complex(0, 0), complex(nan, 1), complex(nan, nan)},
+	Test{complex(0, 0), complex(nan, -1), complex(nan, nan)},
+	Test{complex(0, 0), complex(nan, 2), complex(nan, nan)},
+	Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 0), complex(inf, 0), complex(0, 0)},
+	Test{complex(0, 0), complex(inf, 1), complex(0, 0)},
+	Test{complex(0, 0), complex(inf, -1), complex(0, 0)},
+	Test{complex(0, 0), complex(inf, 2), complex(0, 0)},
+	Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 0), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(0, 0), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(0, 0), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(0, 0), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 1), complex(0, 0), complex(-nan, inf)},
+	Test{complex(0, 1), complex(0, 1), complex(1, 0)},
+	Test{complex(0, 1), complex(0, -1), complex(-1, 0)},
+	Test{complex(0, 1), complex(0, 2), complex(0.5, 0)},
+	Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 1), complex(1, 0), complex(0, 1)},
+	Test{complex(0, 1), complex(1, 1), complex(0.5, 0.5)},
+	Test{complex(0, 1), complex(1, -1), complex(-0.5, 0.5)},
+	Test{complex(0, 1), complex(1, 2), complex(0.4, 0.2)},
+	Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 1), complex(-1, 0), complex(negzero, -1)},
+	Test{complex(0, 1), complex(-1, 1), complex(0.5, -0.5)},
+	Test{complex(0, 1), complex(-1, -1), complex(-0.5, -0.5)},
+	Test{complex(0, 1), complex(-1, 2), complex(0.4, -0.2)},
+	Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 1), complex(2, 0), complex(0, 0.5)},
+	Test{complex(0, 1), complex(2, 1), complex(0.2, 0.4)},
+	Test{complex(0, 1), complex(2, -1), complex(-0.2, 0.4)},
+	Test{complex(0, 1), complex(2, 2), complex(0.25, 0.25)},
+	Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(0, 1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(0, 1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(0, 1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 1), complex(inf, 0), complex(0, 0)},
+	Test{complex(0, 1), complex(inf, 1), complex(0, 0)},
+	Test{complex(0, 1), complex(inf, -1), complex(0, 0)},
+	Test{complex(0, 1), complex(inf, 2), complex(0, 0)},
+	Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 1), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(0, 1), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(0, 1), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(0, 1), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(0, -1), complex(0, 1), complex(-1, negzero)},
+	Test{complex(0, -1), complex(0, -1), complex(1, negzero)},
+	Test{complex(0, -1), complex(0, 2), complex(-0.5, negzero)},
+	Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(0, -1), complex(1, 0), complex(0, -1)},
+	Test{complex(0, -1), complex(1, 1), complex(-0.5, -0.5)},
+	Test{complex(0, -1), complex(1, -1), complex(0.5, -0.5)},
+	Test{complex(0, -1), complex(1, 2), complex(-0.4, -0.2)},
+	Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(0, -1), complex(-1, 0), complex(negzero, 1)},
+	Test{complex(0, -1), complex(-1, 1), complex(-0.5, 0.5)},
+	Test{complex(0, -1), complex(-1, -1), complex(0.5, 0.5)},
+	Test{complex(0, -1), complex(-1, 2), complex(-0.4, 0.2)},
+	Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(0, -1), complex(2, 0), complex(0, -0.5)},
+	Test{complex(0, -1), complex(2, 1), complex(-0.2, -0.4)},
+	Test{complex(0, -1), complex(2, -1), complex(0.2, -0.4)},
+	Test{complex(0, -1), complex(2, 2), complex(-0.25, -0.25)},
+	Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(0, -1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(0, -1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(0, -1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(0, -1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(0, -1), complex(inf, 0), complex(0, negzero)},
+	Test{complex(0, -1), complex(inf, 1), complex(0, negzero)},
+	Test{complex(0, -1), complex(inf, -1), complex(0, negzero)},
+	Test{complex(0, -1), complex(inf, 2), complex(0, negzero)},
+	Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(0, -1), complex(-inf, 0), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-inf, 1), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-inf, -1), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-inf, 2), complex(negzero, 0)},
+	Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(0, 2), complex(0, 0), complex(-nan, inf)},
+	Test{complex(0, 2), complex(0, 1), complex(2, 0)},
+	Test{complex(0, 2), complex(0, -1), complex(-2, 0)},
+	Test{complex(0, 2), complex(0, 2), complex(1, 0)},
+	Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 2), complex(1, 0), complex(0, 2)},
+	Test{complex(0, 2), complex(1, 1), complex(1, 1)},
+	Test{complex(0, 2), complex(1, -1), complex(-1, 1)},
+	Test{complex(0, 2), complex(1, 2), complex(0.8, 0.4)},
+	Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 2), complex(-1, 0), complex(negzero, -2)},
+	Test{complex(0, 2), complex(-1, 1), complex(1, -1)},
+	Test{complex(0, 2), complex(-1, -1), complex(-1, -1)},
+	Test{complex(0, 2), complex(-1, 2), complex(0.8, -0.4)},
+	Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 2), complex(2, 0), complex(0, 1)},
+	Test{complex(0, 2), complex(2, 1), complex(0.4, 0.8)},
+	Test{complex(0, 2), complex(2, -1), complex(-0.4, 0.8)},
+	Test{complex(0, 2), complex(2, 2), complex(0.5, 0.5)},
+	Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 2), complex(nan, 0), complex(nan, nan)},
+	Test{complex(0, 2), complex(nan, 1), complex(nan, nan)},
+	Test{complex(0, 2), complex(nan, -1), complex(nan, nan)},
+	Test{complex(0, 2), complex(nan, 2), complex(nan, nan)},
+	Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 2), complex(inf, 0), complex(0, 0)},
+	Test{complex(0, 2), complex(inf, 1), complex(0, 0)},
+	Test{complex(0, 2), complex(inf, -1), complex(0, 0)},
+	Test{complex(0, 2), complex(inf, 2), complex(0, 0)},
+	Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(0, 2), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(0, 2), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(0, 2), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(0, 2), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+	Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+	Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(1, 0), complex(0, 0), complex(inf, -nan)},
+	Test{complex(1, 0), complex(0, 1), complex(0, -1)},
+	Test{complex(1, 0), complex(0, -1), complex(negzero, 1)},
+	Test{complex(1, 0), complex(0, 2), complex(0, -0.5)},
+	Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 0), complex(1, 0), complex(1, 0)},
+	Test{complex(1, 0), complex(1, 1), complex(0.5, -0.5)},
+	Test{complex(1, 0), complex(1, -1), complex(0.5, 0.5)},
+	Test{complex(1, 0), complex(1, 2), complex(0.2, -0.4)},
+	Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 0), complex(-1, 0), complex(-1, negzero)},
+	Test{complex(1, 0), complex(-1, 1), complex(-0.5, -0.5)},
+	Test{complex(1, 0), complex(-1, -1), complex(-0.5, 0.5)},
+	Test{complex(1, 0), complex(-1, 2), complex(-0.2, -0.4)},
+	Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 0), complex(2, 0), complex(0.5, 0)},
+	Test{complex(1, 0), complex(2, 1), complex(0.4, -0.2)},
+	Test{complex(1, 0), complex(2, -1), complex(0.4, 0.2)},
+	Test{complex(1, 0), complex(2, 2), complex(0.25, -0.25)},
+	Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 0), complex(nan, 0), complex(nan, nan)},
+	Test{complex(1, 0), complex(nan, 1), complex(nan, nan)},
+	Test{complex(1, 0), complex(nan, -1), complex(nan, nan)},
+	Test{complex(1, 0), complex(nan, 2), complex(nan, nan)},
+	Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 0), complex(inf, 0), complex(0, 0)},
+	Test{complex(1, 0), complex(inf, 1), complex(0, 0)},
+	Test{complex(1, 0), complex(inf, -1), complex(0, 0)},
+	Test{complex(1, 0), complex(inf, 2), complex(0, 0)},
+	Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 0), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(1, 0), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(1, 0), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(1, 0), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 1), complex(0, 0), complex(inf, inf)},
+	Test{complex(1, 1), complex(0, 1), complex(1, -1)},
+	Test{complex(1, 1), complex(0, -1), complex(-1, 1)},
+	Test{complex(1, 1), complex(0, 2), complex(0.5, -0.5)},
+	Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 1), complex(1, 0), complex(1, 1)},
+	Test{complex(1, 1), complex(1, 1), complex(1, 0)},
+	Test{complex(1, 1), complex(1, -1), complex(0, 1)},
+	Test{complex(1, 1), complex(1, 2), complex(0.6, -0.2)},
+	Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 1), complex(-1, 0), complex(-1, -1)},
+	Test{complex(1, 1), complex(-1, 1), complex(negzero, -1)},
+	Test{complex(1, 1), complex(-1, -1), complex(-1, negzero)},
+	Test{complex(1, 1), complex(-1, 2), complex(0.2, -0.6)},
+	Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 1), complex(2, 0), complex(0.5, 0.5)},
+	Test{complex(1, 1), complex(2, 1), complex(0.6, 0.2)},
+	Test{complex(1, 1), complex(2, -1), complex(0.2, 0.6)},
+	Test{complex(1, 1), complex(2, 2), complex(0.5, 0)},
+	Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(1, 1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(1, 1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(1, 1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 1), complex(inf, 0), complex(0, 0)},
+	Test{complex(1, 1), complex(inf, 1), complex(0, 0)},
+	Test{complex(1, 1), complex(inf, -1), complex(0, 0)},
+	Test{complex(1, 1), complex(inf, 2), complex(0, 0)},
+	Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 1), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(1, 1), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(1, 1), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(1, 1), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, -1), complex(0, 0), complex(inf, -inf)},
+	Test{complex(1, -1), complex(0, 1), complex(-1, -1)},
+	Test{complex(1, -1), complex(0, -1), complex(1, 1)},
+	Test{complex(1, -1), complex(0, 2), complex(-0.5, -0.5)},
+	Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(1, -1), complex(1, 0), complex(1, -1)},
+	Test{complex(1, -1), complex(1, 1), complex(0, -1)},
+	Test{complex(1, -1), complex(1, -1), complex(1, 0)},
+	Test{complex(1, -1), complex(1, 2), complex(-0.2, -0.6)},
+	Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(1, -1), complex(-1, 0), complex(-1, 1)},
+	Test{complex(1, -1), complex(-1, 1), complex(-1, negzero)},
+	Test{complex(1, -1), complex(-1, -1), complex(negzero, 1)},
+	Test{complex(1, -1), complex(-1, 2), complex(-0.6, -0.2)},
+	Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(1, -1), complex(2, 0), complex(0.5, -0.5)},
+	Test{complex(1, -1), complex(2, 1), complex(0.2, -0.6)},
+	Test{complex(1, -1), complex(2, -1), complex(0.6, -0.2)},
+	Test{complex(1, -1), complex(2, 2), complex(0, -0.5)},
+	Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(1, -1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(1, -1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(1, -1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(1, -1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(1, -1), complex(inf, 0), complex(0, negzero)},
+	Test{complex(1, -1), complex(inf, 1), complex(0, negzero)},
+	Test{complex(1, -1), complex(inf, -1), complex(0, negzero)},
+	Test{complex(1, -1), complex(inf, 2), complex(0, negzero)},
+	Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(1, -1), complex(-inf, 0), complex(negzero, 0)},
+	Test{complex(1, -1), complex(-inf, 1), complex(negzero, 0)},
+	Test{complex(1, -1), complex(-inf, -1), complex(negzero, 0)},
+	Test{complex(1, -1), complex(-inf, 2), complex(negzero, 0)},
+	Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(1, 2), complex(0, 0), complex(inf, inf)},
+	Test{complex(1, 2), complex(0, 1), complex(2, -1)},
+	Test{complex(1, 2), complex(0, -1), complex(-2, 1)},
+	Test{complex(1, 2), complex(0, 2), complex(1, -0.5)},
+	Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 2), complex(1, 0), complex(1, 2)},
+	Test{complex(1, 2), complex(1, 1), complex(1.5, 0.5)},
+	Test{complex(1, 2), complex(1, -1), complex(-0.5, 1.5)},
+	Test{complex(1, 2), complex(1, 2), complex(1, 0)},
+	Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 2), complex(-1, 0), complex(-1, -2)},
+	Test{complex(1, 2), complex(-1, 1), complex(0.5, -1.5)},
+	Test{complex(1, 2), complex(-1, -1), complex(-1.5, -0.5)},
+	Test{complex(1, 2), complex(-1, 2), complex(0.6, -0.8)},
+	Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 2), complex(2, 0), complex(0.5, 1)},
+	Test{complex(1, 2), complex(2, 1), complex(0.8, 0.6)},
+	Test{complex(1, 2), complex(2, -1), complex(0, 1)},
+	Test{complex(1, 2), complex(2, 2), complex(0.75, 0.25)},
+	Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 2), complex(nan, 0), complex(nan, nan)},
+	Test{complex(1, 2), complex(nan, 1), complex(nan, nan)},
+	Test{complex(1, 2), complex(nan, -1), complex(nan, nan)},
+	Test{complex(1, 2), complex(nan, 2), complex(nan, nan)},
+	Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 2), complex(inf, 0), complex(0, 0)},
+	Test{complex(1, 2), complex(inf, 1), complex(0, 0)},
+	Test{complex(1, 2), complex(inf, -1), complex(0, 0)},
+	Test{complex(1, 2), complex(inf, 2), complex(0, 0)},
+	Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(1, 2), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(1, 2), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(1, 2), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(1, 2), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+	Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+	Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-1, 0), complex(0, 0), complex(-inf, -nan)},
+	Test{complex(-1, 0), complex(0, 1), complex(0, 1)},
+	Test{complex(-1, 0), complex(0, -1), complex(negzero, -1)},
+	Test{complex(-1, 0), complex(0, 2), complex(0, 0.5)},
+	Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 0), complex(1, 0), complex(-1, 0)},
+	Test{complex(-1, 0), complex(1, 1), complex(-0.5, 0.5)},
+	Test{complex(-1, 0), complex(1, -1), complex(-0.5, -0.5)},
+	Test{complex(-1, 0), complex(1, 2), complex(-0.2, 0.4)},
+	Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 0), complex(-1, 0), complex(1, negzero)},
+	Test{complex(-1, 0), complex(-1, 1), complex(0.5, 0.5)},
+	Test{complex(-1, 0), complex(-1, -1), complex(0.5, -0.5)},
+	Test{complex(-1, 0), complex(-1, 2), complex(0.2, 0.4)},
+	Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 0), complex(2, 0), complex(-0.5, 0)},
+	Test{complex(-1, 0), complex(2, 1), complex(-0.4, 0.2)},
+	Test{complex(-1, 0), complex(2, -1), complex(-0.4, -0.2)},
+	Test{complex(-1, 0), complex(2, 2), complex(-0.25, 0.25)},
+	Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 0), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-1, 0), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-1, 0), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-1, 0), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 0), complex(inf, 0), complex(negzero, 0)},
+	Test{complex(-1, 0), complex(inf, 1), complex(negzero, 0)},
+	Test{complex(-1, 0), complex(inf, -1), complex(negzero, 0)},
+	Test{complex(-1, 0), complex(inf, 2), complex(negzero, 0)},
+	Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 0), complex(-inf, 0), complex(0, negzero)},
+	Test{complex(-1, 0), complex(-inf, 1), complex(0, negzero)},
+	Test{complex(-1, 0), complex(-inf, -1), complex(0, negzero)},
+	Test{complex(-1, 0), complex(-inf, 2), complex(0, negzero)},
+	Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 1), complex(0, 0), complex(-inf, inf)},
+	Test{complex(-1, 1), complex(0, 1), complex(1, 1)},
+	Test{complex(-1, 1), complex(0, -1), complex(-1, -1)},
+	Test{complex(-1, 1), complex(0, 2), complex(0.5, 0.5)},
+	Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 1), complex(1, 0), complex(-1, 1)},
+	Test{complex(-1, 1), complex(1, 1), complex(0, 1)},
+	Test{complex(-1, 1), complex(1, -1), complex(-1, 0)},
+	Test{complex(-1, 1), complex(1, 2), complex(0.2, 0.6)},
+	Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 1), complex(-1, 0), complex(1, -1)},
+	Test{complex(-1, 1), complex(-1, 1), complex(1, negzero)},
+	Test{complex(-1, 1), complex(-1, -1), complex(negzero, -1)},
+	Test{complex(-1, 1), complex(-1, 2), complex(0.6, 0.2)},
+	Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 1), complex(2, 0), complex(-0.5, 0.5)},
+	Test{complex(-1, 1), complex(2, 1), complex(-0.2, 0.6)},
+	Test{complex(-1, 1), complex(2, -1), complex(-0.6, 0.2)},
+	Test{complex(-1, 1), complex(2, 2), complex(0, 0.5)},
+	Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-1, 1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-1, 1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-1, 1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 1), complex(inf, 0), complex(negzero, 0)},
+	Test{complex(-1, 1), complex(inf, 1), complex(negzero, 0)},
+	Test{complex(-1, 1), complex(inf, -1), complex(negzero, 0)},
+	Test{complex(-1, 1), complex(inf, 2), complex(negzero, 0)},
+	Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 1), complex(-inf, 0), complex(0, negzero)},
+	Test{complex(-1, 1), complex(-inf, 1), complex(0, negzero)},
+	Test{complex(-1, 1), complex(-inf, -1), complex(0, negzero)},
+	Test{complex(-1, 1), complex(-inf, 2), complex(0, negzero)},
+	Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, -1), complex(0, 0), complex(-inf, -inf)},
+	Test{complex(-1, -1), complex(0, 1), complex(-1, 1)},
+	Test{complex(-1, -1), complex(0, -1), complex(1, -1)},
+	Test{complex(-1, -1), complex(0, 2), complex(-0.5, 0.5)},
+	Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, -1), complex(1, 0), complex(-1, -1)},
+	Test{complex(-1, -1), complex(1, 1), complex(-1, 0)},
+	Test{complex(-1, -1), complex(1, -1), complex(0, -1)},
+	Test{complex(-1, -1), complex(1, 2), complex(-0.6, 0.2)},
+	Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, -1), complex(-1, 0), complex(1, 1)},
+	Test{complex(-1, -1), complex(-1, 1), complex(negzero, 1)},
+	Test{complex(-1, -1), complex(-1, -1), complex(1, negzero)},
+	Test{complex(-1, -1), complex(-1, 2), complex(-0.2, 0.6)},
+	Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, -1), complex(2, 0), complex(-0.5, -0.5)},
+	Test{complex(-1, -1), complex(2, 1), complex(-0.6, -0.2)},
+	Test{complex(-1, -1), complex(2, -1), complex(-0.2, -0.6)},
+	Test{complex(-1, -1), complex(2, 2), complex(-0.5, 0)},
+	Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, -1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-1, -1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-1, -1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-1, -1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, -1), complex(inf, 0), complex(negzero, negzero)},
+	Test{complex(-1, -1), complex(inf, 1), complex(negzero, negzero)},
+	Test{complex(-1, -1), complex(inf, -1), complex(negzero, negzero)},
+	Test{complex(-1, -1), complex(inf, 2), complex(negzero, negzero)},
+	Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, -1), complex(-inf, 0), complex(0, 0)},
+	Test{complex(-1, -1), complex(-inf, 1), complex(0, 0)},
+	Test{complex(-1, -1), complex(-inf, -1), complex(0, 0)},
+	Test{complex(-1, -1), complex(-inf, 2), complex(0, 0)},
+	Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+	Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+	Test{complex(-1, 2), complex(0, 0), complex(-inf, inf)},
+	Test{complex(-1, 2), complex(0, 1), complex(2, 1)},
+	Test{complex(-1, 2), complex(0, -1), complex(-2, -1)},
+	Test{complex(-1, 2), complex(0, 2), complex(1, 0.5)},
+	Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 2), complex(1, 0), complex(-1, 2)},
+	Test{complex(-1, 2), complex(1, 1), complex(0.5, 1.5)},
+	Test{complex(-1, 2), complex(1, -1), complex(-1.5, 0.5)},
+	Test{complex(-1, 2), complex(1, 2), complex(0.6, 0.8)},
+	Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 2), complex(-1, 0), complex(1, -2)},
+	Test{complex(-1, 2), complex(-1, 1), complex(1.5, -0.5)},
+	Test{complex(-1, 2), complex(-1, -1), complex(-0.5, -1.5)},
+	Test{complex(-1, 2), complex(-1, 2), complex(1, 0)},
+	Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 2), complex(2, 0), complex(-0.5, 1)},
+	Test{complex(-1, 2), complex(2, 1), complex(0, 1)},
+	Test{complex(-1, 2), complex(2, -1), complex(-0.8, 0.6)},
+	Test{complex(-1, 2), complex(2, 2), complex(0.25, 0.75)},
+	Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 2), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-1, 2), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-1, 2), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-1, 2), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 2), complex(inf, 0), complex(negzero, 0)},
+	Test{complex(-1, 2), complex(inf, 1), complex(negzero, 0)},
+	Test{complex(-1, 2), complex(inf, -1), complex(negzero, 0)},
+	Test{complex(-1, 2), complex(inf, 2), complex(negzero, 0)},
+	Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(-1, 2), complex(-inf, 0), complex(0, negzero)},
+	Test{complex(-1, 2), complex(-inf, 1), complex(0, negzero)},
+	Test{complex(-1, 2), complex(-inf, -1), complex(0, negzero)},
+	Test{complex(-1, 2), complex(-inf, 2), complex(0, negzero)},
+	Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+	Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+	Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+	Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+	Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(2, 0), complex(0, 0), complex(inf, -nan)},
+	Test{complex(2, 0), complex(0, 1), complex(0, -2)},
+	Test{complex(2, 0), complex(0, -1), complex(negzero, 2)},
+	Test{complex(2, 0), complex(0, 2), complex(0, -1)},
+	Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 0), complex(1, 0), complex(2, 0)},
+	Test{complex(2, 0), complex(1, 1), complex(1, -1)},
+	Test{complex(2, 0), complex(1, -1), complex(1, 1)},
+	Test{complex(2, 0), complex(1, 2), complex(0.4, -0.8)},
+	Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 0), complex(-1, 0), complex(-2, negzero)},
+	Test{complex(2, 0), complex(-1, 1), complex(-1, -1)},
+	Test{complex(2, 0), complex(-1, -1), complex(-1, 1)},
+	Test{complex(2, 0), complex(-1, 2), complex(-0.4, -0.8)},
+	Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 0), complex(2, 0), complex(1, 0)},
+	Test{complex(2, 0), complex(2, 1), complex(0.8, -0.4)},
+	Test{complex(2, 0), complex(2, -1), complex(0.8, 0.4)},
+	Test{complex(2, 0), complex(2, 2), complex(0.5, -0.5)},
+	Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 0), complex(nan, 0), complex(nan, nan)},
+	Test{complex(2, 0), complex(nan, 1), complex(nan, nan)},
+	Test{complex(2, 0), complex(nan, -1), complex(nan, nan)},
+	Test{complex(2, 0), complex(nan, 2), complex(nan, nan)},
+	Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 0), complex(inf, 0), complex(0, 0)},
+	Test{complex(2, 0), complex(inf, 1), complex(0, 0)},
+	Test{complex(2, 0), complex(inf, -1), complex(0, 0)},
+	Test{complex(2, 0), complex(inf, 2), complex(0, 0)},
+	Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 0), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(2, 0), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(2, 0), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(2, 0), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 1), complex(0, 0), complex(inf, inf)},
+	Test{complex(2, 1), complex(0, 1), complex(1, -2)},
+	Test{complex(2, 1), complex(0, -1), complex(-1, 2)},
+	Test{complex(2, 1), complex(0, 2), complex(0.5, -1)},
+	Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 1), complex(1, 0), complex(2, 1)},
+	Test{complex(2, 1), complex(1, 1), complex(1.5, -0.5)},
+	Test{complex(2, 1), complex(1, -1), complex(0.5, 1.5)},
+	Test{complex(2, 1), complex(1, 2), complex(0.8, -0.6)},
+	Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 1), complex(-1, 0), complex(-2, -1)},
+	Test{complex(2, 1), complex(-1, 1), complex(-0.5, -1.5)},
+	Test{complex(2, 1), complex(-1, -1), complex(-1.5, 0.5)},
+	Test{complex(2, 1), complex(-1, 2), complex(0, -1)},
+	Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 1), complex(2, 0), complex(1, 0.5)},
+	Test{complex(2, 1), complex(2, 1), complex(1, 0)},
+	Test{complex(2, 1), complex(2, -1), complex(0.6, 0.8)},
+	Test{complex(2, 1), complex(2, 2), complex(0.75, -0.25)},
+	Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(2, 1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(2, 1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(2, 1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 1), complex(inf, 0), complex(0, 0)},
+	Test{complex(2, 1), complex(inf, 1), complex(0, 0)},
+	Test{complex(2, 1), complex(inf, -1), complex(0, 0)},
+	Test{complex(2, 1), complex(inf, 2), complex(0, 0)},
+	Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 1), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(2, 1), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(2, 1), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(2, 1), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, -1), complex(0, 0), complex(inf, -inf)},
+	Test{complex(2, -1), complex(0, 1), complex(-1, -2)},
+	Test{complex(2, -1), complex(0, -1), complex(1, 2)},
+	Test{complex(2, -1), complex(0, 2), complex(-0.5, -1)},
+	Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(2, -1), complex(1, 0), complex(2, -1)},
+	Test{complex(2, -1), complex(1, 1), complex(0.5, -1.5)},
+	Test{complex(2, -1), complex(1, -1), complex(1.5, 0.5)},
+	Test{complex(2, -1), complex(1, 2), complex(0, -1)},
+	Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(2, -1), complex(-1, 0), complex(-2, 1)},
+	Test{complex(2, -1), complex(-1, 1), complex(-1.5, -0.5)},
+	Test{complex(2, -1), complex(-1, -1), complex(-0.5, 1.5)},
+	Test{complex(2, -1), complex(-1, 2), complex(-0.8, -0.6)},
+	Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(2, -1), complex(2, 0), complex(1, -0.5)},
+	Test{complex(2, -1), complex(2, 1), complex(0.6, -0.8)},
+	Test{complex(2, -1), complex(2, -1), complex(1, 0)},
+	Test{complex(2, -1), complex(2, 2), complex(0.25, -0.75)},
+	Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(2, -1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(2, -1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(2, -1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(2, -1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(2, -1), complex(inf, 0), complex(0, negzero)},
+	Test{complex(2, -1), complex(inf, 1), complex(0, negzero)},
+	Test{complex(2, -1), complex(inf, -1), complex(0, negzero)},
+	Test{complex(2, -1), complex(inf, 2), complex(0, negzero)},
+	Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(2, -1), complex(-inf, 0), complex(negzero, 0)},
+	Test{complex(2, -1), complex(-inf, 1), complex(negzero, 0)},
+	Test{complex(2, -1), complex(-inf, -1), complex(negzero, 0)},
+	Test{complex(2, -1), complex(-inf, 2), complex(negzero, 0)},
+	Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+	Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+	Test{complex(2, 2), complex(0, 0), complex(inf, inf)},
+	Test{complex(2, 2), complex(0, 1), complex(2, -2)},
+	Test{complex(2, 2), complex(0, -1), complex(-2, 2)},
+	Test{complex(2, 2), complex(0, 2), complex(1, -1)},
+	Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 2), complex(1, 0), complex(2, 2)},
+	Test{complex(2, 2), complex(1, 1), complex(2, 0)},
+	Test{complex(2, 2), complex(1, -1), complex(0, 2)},
+	Test{complex(2, 2), complex(1, 2), complex(1.2, -0.4)},
+	Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 2), complex(-1, 0), complex(-2, -2)},
+	Test{complex(2, 2), complex(-1, 1), complex(negzero, -2)},
+	Test{complex(2, 2), complex(-1, -1), complex(-2, negzero)},
+	Test{complex(2, 2), complex(-1, 2), complex(0.4, -1.2)},
+	Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 2), complex(2, 0), complex(1, 1)},
+	Test{complex(2, 2), complex(2, 1), complex(1.2, 0.4)},
+	Test{complex(2, 2), complex(2, -1), complex(0.4, 1.2)},
+	Test{complex(2, 2), complex(2, 2), complex(1, 0)},
+	Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 2), complex(nan, 0), complex(nan, nan)},
+	Test{complex(2, 2), complex(nan, 1), complex(nan, nan)},
+	Test{complex(2, 2), complex(nan, -1), complex(nan, nan)},
+	Test{complex(2, 2), complex(nan, 2), complex(nan, nan)},
+	Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 2), complex(inf, 0), complex(0, 0)},
+	Test{complex(2, 2), complex(inf, 1), complex(0, 0)},
+	Test{complex(2, 2), complex(inf, -1), complex(0, 0)},
+	Test{complex(2, 2), complex(inf, 2), complex(0, 0)},
+	Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(2, 2), complex(-inf, 0), complex(negzero, negzero)},
+	Test{complex(2, 2), complex(-inf, 1), complex(negzero, negzero)},
+	Test{complex(2, 2), complex(-inf, -1), complex(negzero, negzero)},
+	Test{complex(2, 2), complex(-inf, 2), complex(negzero, negzero)},
+	Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+	Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+	Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+	Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+	Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, 0), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, 0), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, 0), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, 0), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, 1), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, 1), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, 1), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, 1), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, -1), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, -1), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, -1), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, -1), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, 2), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, 2), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, 2), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, 2), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+	Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+	Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(0, 0), complex(inf, -nan)},
+	Test{complex(inf, 0), complex(0, 1), complex(-nan, -inf)},
+	Test{complex(inf, 0), complex(0, -1), complex(-nan, inf)},
+	Test{complex(inf, 0), complex(0, 2), complex(-nan, -inf)},
+	Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(1, 0), complex(inf, -nan)},
+	Test{complex(inf, 0), complex(1, 1), complex(inf, -inf)},
+	Test{complex(inf, 0), complex(1, -1), complex(inf, inf)},
+	Test{complex(inf, 0), complex(1, 2), complex(inf, -inf)},
+	Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-1, 0), complex(-inf, -nan)},
+	Test{complex(inf, 0), complex(-1, 1), complex(-inf, -inf)},
+	Test{complex(inf, 0), complex(-1, -1), complex(-inf, inf)},
+	Test{complex(inf, 0), complex(-1, 2), complex(-inf, -inf)},
+	Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(2, 0), complex(inf, -nan)},
+	Test{complex(inf, 0), complex(2, 1), complex(inf, -inf)},
+	Test{complex(inf, 0), complex(2, -1), complex(inf, inf)},
+	Test{complex(inf, 0), complex(2, 2), complex(inf, -inf)},
+	Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(nan, 0), complex(nan, nan)},
+	Test{complex(inf, 0), complex(nan, 1), complex(nan, nan)},
+	Test{complex(inf, 0), complex(nan, -1), complex(nan, nan)},
+	Test{complex(inf, 0), complex(nan, 2), complex(nan, nan)},
+	Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(0, 0), complex(inf, inf)},
+	Test{complex(inf, 1), complex(0, 1), complex(-nan, -inf)},
+	Test{complex(inf, 1), complex(0, -1), complex(-nan, inf)},
+	Test{complex(inf, 1), complex(0, 2), complex(-nan, -inf)},
+	Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(1, 0), complex(inf, -nan)},
+	Test{complex(inf, 1), complex(1, 1), complex(inf, -inf)},
+	Test{complex(inf, 1), complex(1, -1), complex(inf, inf)},
+	Test{complex(inf, 1), complex(1, 2), complex(inf, -inf)},
+	Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-1, 0), complex(-inf, -nan)},
+	Test{complex(inf, 1), complex(-1, 1), complex(-inf, -inf)},
+	Test{complex(inf, 1), complex(-1, -1), complex(-inf, inf)},
+	Test{complex(inf, 1), complex(-1, 2), complex(-inf, -inf)},
+	Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(2, 0), complex(inf, -nan)},
+	Test{complex(inf, 1), complex(2, 1), complex(inf, -inf)},
+	Test{complex(inf, 1), complex(2, -1), complex(inf, inf)},
+	Test{complex(inf, 1), complex(2, 2), complex(inf, -inf)},
+	Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(inf, 1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(inf, 1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(inf, 1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(0, 0), complex(inf, -inf)},
+	Test{complex(inf, -1), complex(0, 1), complex(-nan, -inf)},
+	Test{complex(inf, -1), complex(0, -1), complex(-nan, inf)},
+	Test{complex(inf, -1), complex(0, 2), complex(-nan, -inf)},
+	Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(1, 0), complex(inf, -nan)},
+	Test{complex(inf, -1), complex(1, 1), complex(inf, -inf)},
+	Test{complex(inf, -1), complex(1, -1), complex(inf, inf)},
+	Test{complex(inf, -1), complex(1, 2), complex(inf, -inf)},
+	Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-1, 0), complex(-inf, -nan)},
+	Test{complex(inf, -1), complex(-1, 1), complex(-inf, -inf)},
+	Test{complex(inf, -1), complex(-1, -1), complex(-inf, inf)},
+	Test{complex(inf, -1), complex(-1, 2), complex(-inf, -inf)},
+	Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(2, 0), complex(inf, -nan)},
+	Test{complex(inf, -1), complex(2, 1), complex(inf, -inf)},
+	Test{complex(inf, -1), complex(2, -1), complex(inf, inf)},
+	Test{complex(inf, -1), complex(2, 2), complex(inf, -inf)},
+	Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(inf, -1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(inf, -1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(inf, -1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(0, 0), complex(inf, inf)},
+	Test{complex(inf, 2), complex(0, 1), complex(-nan, -inf)},
+	Test{complex(inf, 2), complex(0, -1), complex(-nan, inf)},
+	Test{complex(inf, 2), complex(0, 2), complex(-nan, -inf)},
+	Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(1, 0), complex(inf, -nan)},
+	Test{complex(inf, 2), complex(1, 1), complex(inf, -inf)},
+	Test{complex(inf, 2), complex(1, -1), complex(inf, inf)},
+	Test{complex(inf, 2), complex(1, 2), complex(inf, -inf)},
+	Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-1, 0), complex(-inf, -nan)},
+	Test{complex(inf, 2), complex(-1, 1), complex(-inf, -inf)},
+	Test{complex(inf, 2), complex(-1, -1), complex(-inf, inf)},
+	Test{complex(inf, 2), complex(-1, 2), complex(-inf, -inf)},
+	Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(2, 0), complex(inf, -nan)},
+	Test{complex(inf, 2), complex(2, 1), complex(inf, -inf)},
+	Test{complex(inf, 2), complex(2, -1), complex(inf, inf)},
+	Test{complex(inf, 2), complex(2, 2), complex(inf, -inf)},
+	Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(nan, 0), complex(nan, nan)},
+	Test{complex(inf, 2), complex(nan, 1), complex(nan, nan)},
+	Test{complex(inf, 2), complex(nan, -1), complex(nan, nan)},
+	Test{complex(inf, 2), complex(nan, 2), complex(nan, nan)},
+	Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+	Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+	Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(0, 0), complex(-inf, -nan)},
+	Test{complex(-inf, 0), complex(0, 1), complex(-nan, inf)},
+	Test{complex(-inf, 0), complex(0, -1), complex(-nan, -inf)},
+	Test{complex(-inf, 0), complex(0, 2), complex(-nan, inf)},
+	Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(1, 0), complex(-inf, -nan)},
+	Test{complex(-inf, 0), complex(1, 1), complex(-inf, inf)},
+	Test{complex(-inf, 0), complex(1, -1), complex(-inf, -inf)},
+	Test{complex(-inf, 0), complex(1, 2), complex(-inf, inf)},
+	Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-1, 0), complex(inf, -nan)},
+	Test{complex(-inf, 0), complex(-1, 1), complex(inf, inf)},
+	Test{complex(-inf, 0), complex(-1, -1), complex(inf, -inf)},
+	Test{complex(-inf, 0), complex(-1, 2), complex(inf, inf)},
+	Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(2, 0), complex(-inf, -nan)},
+	Test{complex(-inf, 0), complex(2, 1), complex(-inf, inf)},
+	Test{complex(-inf, 0), complex(2, -1), complex(-inf, -inf)},
+	Test{complex(-inf, 0), complex(2, 2), complex(-inf, inf)},
+	Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(0, 0), complex(-inf, inf)},
+	Test{complex(-inf, 1), complex(0, 1), complex(-nan, inf)},
+	Test{complex(-inf, 1), complex(0, -1), complex(-nan, -inf)},
+	Test{complex(-inf, 1), complex(0, 2), complex(-nan, inf)},
+	Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(1, 0), complex(-inf, -nan)},
+	Test{complex(-inf, 1), complex(1, 1), complex(-inf, inf)},
+	Test{complex(-inf, 1), complex(1, -1), complex(-inf, -inf)},
+	Test{complex(-inf, 1), complex(1, 2), complex(-inf, inf)},
+	Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-1, 0), complex(inf, -nan)},
+	Test{complex(-inf, 1), complex(-1, 1), complex(inf, inf)},
+	Test{complex(-inf, 1), complex(-1, -1), complex(inf, -inf)},
+	Test{complex(-inf, 1), complex(-1, 2), complex(inf, inf)},
+	Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(2, 0), complex(-inf, -nan)},
+	Test{complex(-inf, 1), complex(2, 1), complex(-inf, inf)},
+	Test{complex(-inf, 1), complex(2, -1), complex(-inf, -inf)},
+	Test{complex(-inf, 1), complex(2, 2), complex(-inf, inf)},
+	Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(0, 0), complex(-inf, -inf)},
+	Test{complex(-inf, -1), complex(0, 1), complex(-nan, inf)},
+	Test{complex(-inf, -1), complex(0, -1), complex(-nan, -inf)},
+	Test{complex(-inf, -1), complex(0, 2), complex(-nan, inf)},
+	Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(1, 0), complex(-inf, -nan)},
+	Test{complex(-inf, -1), complex(1, 1), complex(-inf, inf)},
+	Test{complex(-inf, -1), complex(1, -1), complex(-inf, -inf)},
+	Test{complex(-inf, -1), complex(1, 2), complex(-inf, inf)},
+	Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-1, 0), complex(inf, -nan)},
+	Test{complex(-inf, -1), complex(-1, 1), complex(inf, inf)},
+	Test{complex(-inf, -1), complex(-1, -1), complex(inf, -inf)},
+	Test{complex(-inf, -1), complex(-1, 2), complex(inf, inf)},
+	Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(2, 0), complex(-inf, -nan)},
+	Test{complex(-inf, -1), complex(2, 1), complex(-inf, inf)},
+	Test{complex(-inf, -1), complex(2, -1), complex(-inf, -inf)},
+	Test{complex(-inf, -1), complex(2, 2), complex(-inf, inf)},
+	Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(0, 0), complex(-inf, inf)},
+	Test{complex(-inf, 2), complex(0, 1), complex(-nan, inf)},
+	Test{complex(-inf, 2), complex(0, -1), complex(-nan, -inf)},
+	Test{complex(-inf, 2), complex(0, 2), complex(-nan, inf)},
+	Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(1, 0), complex(-inf, -nan)},
+	Test{complex(-inf, 2), complex(1, 1), complex(-inf, inf)},
+	Test{complex(-inf, 2), complex(1, -1), complex(-inf, -inf)},
+	Test{complex(-inf, 2), complex(1, 2), complex(-inf, inf)},
+	Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-1, 0), complex(inf, -nan)},
+	Test{complex(-inf, 2), complex(-1, 1), complex(inf, inf)},
+	Test{complex(-inf, 2), complex(-1, -1), complex(inf, -inf)},
+	Test{complex(-inf, 2), complex(-1, 2), complex(inf, inf)},
+	Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(2, 0), complex(-inf, -nan)},
+	Test{complex(-inf, 2), complex(2, 1), complex(-inf, inf)},
+	Test{complex(-inf, 2), complex(2, -1), complex(-inf, -inf)},
+	Test{complex(-inf, 2), complex(2, 2), complex(-inf, inf)},
+	Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+	Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+	Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+	Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+	Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+	Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+	Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+	Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+	Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+	Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+	Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+	Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+	Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+	Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
 }
diff --git a/test/complit.go b/test/complit.go
index f3b7c9abe71..f5f7aca9d90 100644
--- a/test/complit.go
+++ b/test/complit.go
@@ -6,9 +6,16 @@
 
 package main
 
-type T struct { i int; f float; s string; next *T }
+type T struct {
+	i    int
+	f    float64
+	s    string
+	next *T
+}
 
-type R struct { num int }
+type R struct {
+	num int
+}
 
 func itor(a int) *R {
 	r := new(R)
@@ -18,11 +25,16 @@ func itor(a int) *R {
 
 func eq(a []*R) {
 	for i := 0; i < len(a); i++ {
-		if a[i].num != i { panic("bad") }
+		if a[i].num != i {
+			panic("bad")
+		}
 	}
 }
 
-type P struct { a, b int }
+type P struct {
+	a, b int
+}
+
 func NewP(a, b int) *P {
 	return &P{a, b}
 }
@@ -34,37 +46,57 @@ func main() {
 	var tp *T
 	tp = &T{0, 7.2, "hi", &t}
 
-	a1 := []int{1,2,3}
-	if len(a1) != 3 { panic("a1") }
-	a2 := [10]int{1,2,3}
-	if len(a2) != 10 || cap(a2) != 10 { panic("a2") }
+	a1 := []int{1, 2, 3}
+	if len(a1) != 3 {
+		panic("a1")
+	}
+	a2 := [10]int{1, 2, 3}
+	if len(a2) != 10 || cap(a2) != 10 {
+		panic("a2")
+	}
 
-	a3 := [10]int{1,2,3,}
-	if len(a3) != 10 || a2[3] != 0 { panic("a3") }
+	a3 := [10]int{1, 2, 3}
+	if len(a3) != 10 || a2[3] != 0 {
+		panic("a3")
+	}
 
 	var oai []int
-	oai = []int{1,2,3}
-	if len(oai) != 3 { panic("oai") }
+	oai = []int{1, 2, 3}
+	if len(oai) != 3 {
+		panic("oai")
+	}
 
 	at := [...]*T{&t, tp, &t}
-	if len(at) != 3 { panic("at") }
+	if len(at) != 3 {
+		panic("at")
+	}
 
 	c := make(chan int)
 	ac := []chan int{c, c, c}
-	if len(ac) != 3 { panic("ac") }
+	if len(ac) != 3 {
+		panic("ac")
+	}
 
 	aat := [][len(at)]*T{at, at}
-	if len(aat) != 2 || len(aat[1]) != 3 { panic("aat") }
+	if len(aat) != 2 || len(aat[1]) != 3 {
+		panic("aat")
+	}
 
 	s := string([]byte{'h', 'e', 'l', 'l', 'o'})
-	if s != "hello" { panic("s") }
+	if s != "hello" {
+		panic("s")
+	}
 
-	m := map[string]float{"one":1.0, "two":2.0, "pi":22./7.}
-	if len(m) != 3 { panic("m") }
+	m := map[string]float64{"one": 1.0, "two": 2.0, "pi": 22. / 7.}
+	if len(m) != 3 {
+		panic("m")
+	}
 
 	eq([]*R{itor(0), itor(1), itor(2), itor(3), itor(4), itor(5)})
 
 	p1 := NewP(1, 2)
 	p2 := NewP(1, 2)
-	if p1 == p2 { panic("NewP") }
+	if p1 == p2 {
+		panic("NewP")
+	}
 }
diff --git a/test/const1.go b/test/const1.go
index cf07055cfa3..67f36e4fdc9 100644
--- a/test/const1.go
+++ b/test/const1.go
@@ -6,76 +6,77 @@
 
 package main
 
-type I interface {}
+type I interface{}
+
 const (
 	// assume all types behave similarly to int8/uint8
-	Int8 int8 = 101
-	Minus1 int8 = -1
-	Uint8 uint8 = 102
-	Const = 103
+	Int8   int8  = 101
+	Minus1 int8  = -1
+	Uint8  uint8 = 102
+	Const  = 103
 
-	Float32 float32 = 104.5
-	Float float = 105.5
+	Float32    float32 = 104.5
+	Float64    float64 = 105.5
 	ConstFloat = 106.5
-	Big float64 = 1e300
+	Big        float64 = 1e300
 
 	String = "abc"
-	Bool = true
+	Bool   = true
 )
 
 var (
-	a1 = Int8 * 100	// ERROR "overflow"
-	a2 = Int8 * -1	// OK
-	a3 = Int8 * 1000	// ERROR "overflow"
-	a4 = Int8 * int8(1000)	// ERROR "overflow"
-	a5 = int8(Int8 * 1000)	// ERROR "overflow"
-	a6 = int8(Int8 * int8(1000))	// ERROR "overflow"
-	a7 = Int8 - 2*Int8 - 2*Int8	// ERROR "overflow"
-	a8 = Int8 * Const / 100	// ERROR "overflow"
-	a9 = Int8 * (Const / 100)	// OK
+	a1 = Int8 * 100              // ERROR "overflow"
+	a2 = Int8 * -1               // OK
+	a3 = Int8 * 1000             // ERROR "overflow"
+	a4 = Int8 * int8(1000)       // ERROR "overflow"
+	a5 = int8(Int8 * 1000)       // ERROR "overflow"
+	a6 = int8(Int8 * int8(1000)) // ERROR "overflow"
+	a7 = Int8 - 2*Int8 - 2*Int8  // ERROR "overflow"
+	a8 = Int8 * Const / 100      // ERROR "overflow"
+	a9 = Int8 * (Const / 100)    // OK
 
-	b1 = Uint8 * Uint8	// ERROR "overflow"
-	b2 = Uint8 * -1	// ERROR "overflow"
-	b3 = Uint8 - Uint8	// OK
-	b4 = Uint8 - Uint8 - Uint8	// ERROR "overflow"
-	b5 = uint8(^0)	// ERROR "overflow"
-	b6 = ^uint8(0)	// OK
-	b7 = uint8(Minus1)	// ERROR "overflow"
-	b8 = uint8(int8(-1))	// ERROR "overflow"
-	b8a = uint8(-1)	// ERROR "overflow"
-	b9 byte = (1<<10) >> 8	// OK
-	b10 byte = (1<<10)	// ERROR "overflow"
-	b11 byte = (byte(1)<<10) >> 8	// ERROR "overflow"
-	b12 byte = 1000	// ERROR "overflow"
-	b13 byte = byte(1000)	// ERROR "overflow"
-	b14 byte = byte(100) * byte(100)	// ERROR "overflow"
-	b15 byte = byte(100) * 100	// ERROR "overflow"
-	b16 byte = byte(0) * 1000	// ERROR "overflow"
-	b16a byte = 0 * 1000	// OK
-	b17 byte = byte(0) * byte(1000)	// ERROR "overflow"
-	b18 byte = Uint8/0	// ERROR "division by zero"
+	b1   = Uint8 * Uint8                                 // ERROR "overflow"
+	b2   = Uint8 * -1                                    // ERROR "overflow"
+	b3   = Uint8 - Uint8                                 // OK
+	b4   = Uint8 - Uint8 - Uint8                         // ERROR "overflow"
+	b5   = uint8(^0)                                     // ERROR "overflow"
+	b6   = ^uint8(0)                                     // OK
+	b7   = uint8(Minus1)                                 // ERROR "overflow"
+	b8   = uint8(int8(-1))                               // ERROR "overflow"
+	b8a  = uint8(-1)                                     // ERROR "overflow"
+	b9   byte                    = (1 << 10) >> 8        // OK
+	b10  byte                    = (1 << 10)             // ERROR "overflow"
+	b11  byte                    = (byte(1) << 10) >> 8  // ERROR "overflow"
+	b12  byte                    = 1000                  // ERROR "overflow"
+	b13  byte                    = byte(1000)            // ERROR "overflow"
+	b14  byte                    = byte(100) * byte(100) // ERROR "overflow"
+	b15  byte                    = byte(100) * 100       // ERROR "overflow"
+	b16  byte                    = byte(0) * 1000        // ERROR "overflow"
+	b16a byte                    = 0 * 1000              // OK
+	b17  byte                    = byte(0) * byte(1000)  // ERROR "overflow"
+	b18  byte                    = Uint8 / 0             // ERROR "division by zero"
 
-	c1 float64 = Big
-	c2 float64 = Big*Big	// ERROR "overflow"
-	c3 float64 = float64(Big)*Big	// ERROR "overflow"
-	c4 = Big*Big	// ERROR "overflow"
-	c5 = Big/0	// ERROR "division by zero"
+	c1 float64     = Big
+	c2 float64     = Big * Big          // ERROR "overflow"
+	c3 float64     = float64(Big) * Big // ERROR "overflow"
+	c4 = Big * Big                      // ERROR "overflow"
+	c5 = Big / 0                        // ERROR "division by zero"
 )
 
 func f(int)
 
 func main() {
-	f(Int8)	// ERROR "convert|wrong type|cannot"
-	f(Minus1)	// ERROR "convert|wrong type|cannot"
-	f(Uint8)	// ERROR "convert|wrong type|cannot"
-	f(Const)	// OK
-	f(Float32)	// ERROR "convert|wrong type|cannot"
-	f(Float)	// ERROR "convert|wrong type|cannot"
-	f(ConstFloat)	// ERROR "truncate"
-	f(ConstFloat - 0.5)	// OK
-	f(Big)	// ERROR "convert|wrong type|cannot"
-	f(String)	// ERROR "convert|wrong type|cannot|incompatible"
-	f(Bool)	// ERROR "convert|wrong type|cannot|incompatible"
+	f(Int8)             // ERROR "convert|wrong type|cannot"
+	f(Minus1)           // ERROR "convert|wrong type|cannot"
+	f(Uint8)            // ERROR "convert|wrong type|cannot"
+	f(Const)            // OK
+	f(Float32)          // ERROR "convert|wrong type|cannot"
+	f(Float64)          // ERROR "convert|wrong type|cannot"
+	f(ConstFloat)       // ERROR "truncate"
+	f(ConstFloat - 0.5) // OK
+	f(Big)              // ERROR "convert|wrong type|cannot"
+	f(String)           // ERROR "convert|wrong type|cannot|incompatible"
+	f(Bool)             // ERROR "convert|wrong type|cannot|incompatible"
 }
 
-const ptr = nil  // ERROR "const.*nil"
+const ptr = nil // ERROR "const.*nil"
diff --git a/test/convlit.go b/test/convlit.go
index 94889d4a963..90ac5490c84 100644
--- a/test/convlit.go
+++ b/test/convlit.go
@@ -11,54 +11,56 @@ package main
 // the language spec says for now.
 var x1 = string(1)
 var x2 string = string(1)
-var x3 = int(1.5)	// ERROR "convert|truncate"
-var x4 int = int(1.5)	// ERROR "convert|truncate"
+var x3 = int(1.5)     // ERROR "convert|truncate"
+var x4 int = int(1.5) // ERROR "convert|truncate"
 var x5 = "a" + string(1)
-var x6 = int(1e100)	// ERROR "overflow"
-var x7 = float(1e1000)	// ERROR "overflow"
+var x6 = int(1e100)      // ERROR "overflow"
+var x7 = float32(1e1000) // ERROR "overflow"
 
 // implicit conversions merit scrutiny
 var s string
-var bad1 string = 1	// ERROR "conver|incompatible|invalid|cannot"
-var bad2 = s + 1		// ERROR "conver|incompatible|invalid"
-var bad3 = s + 'a'	// ERROR "conver|incompatible|invalid"
-var bad4 = "a" + 1	// ERROR "literals|incompatible|convert|invalid"
-var bad5 = "a" + 'a'	// ERROR "literals|incompatible|convert|invalid"
+var bad1 string = 1  // ERROR "conver|incompatible|invalid|cannot"
+var bad2 = s + 1     // ERROR "conver|incompatible|invalid"
+var bad3 = s + 'a'   // ERROR "conver|incompatible|invalid"
+var bad4 = "a" + 1   // ERROR "literals|incompatible|convert|invalid"
+var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid"
 
-var bad6 int = 1.5	// ERROR "convert|truncate"
-var bad7 int = 1e100	// ERROR "overflow"
-var bad8 float32 = 1e200	// ERROR "overflow"
+var bad6 int = 1.5       // ERROR "convert|truncate"
+var bad7 int = 1e100     // ERROR "overflow"
+var bad8 float32 = 1e200 // ERROR "overflow"
 
 // but these implicit conversions are okay
 var good1 string = "a"
 var good2 int = 1.0
 var good3 int = 1e9
-var good4 float = 1e20
+var good4 float64 = 1e20
 
 // explicit conversion of string is okay
 var _ = []int("abc")
 var _ = []byte("abc")
 
 // implicit is not
-var _ []int = "abc"	// ERROR "cannot use|incompatible|invalid"
-var _ []byte = "abc"	// ERROR "cannot use|incompatible|invalid"
+var _ []int = "abc"  // ERROR "cannot use|incompatible|invalid"
+var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid"
 
 // named string is okay
 type Tstring string
+
 var ss Tstring = "abc"
 var _ = []int(ss)
 var _ = []byte(ss)
 
 // implicit is still not
-var _ []int = ss	// ERROR "cannot use|incompatible|invalid"
-var _ []byte = ss	// ERROR "cannot use|incompatible|invalid"
+var _ []int = ss  // ERROR "cannot use|incompatible|invalid"
+var _ []byte = ss // ERROR "cannot use|incompatible|invalid"
 
 // named slice is not
 type Tint []int
 type Tbyte []byte
-var _ = Tint("abc")	// ERROR "convert|incompatible|invalid"
-var _ = Tbyte("abc")	// ERROR "convert|incompatible|invalid"
+
+var _ = Tint("abc")  // ERROR "convert|incompatible|invalid"
+var _ = Tbyte("abc") // ERROR "convert|incompatible|invalid"
 
 // implicit is still not
-var _ Tint = "abc"	// ERROR "cannot use|incompatible|invalid"
-var _ Tbyte = "abc"	// ERROR "cannot use|incompatible|invalid"
+var _ Tint = "abc"  // ERROR "cannot use|incompatible|invalid"
+var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid"
diff --git a/test/decl.go b/test/decl.go
index c31082bcfdc..95b6346c3ed 100644
--- a/test/decl.go
+++ b/test/decl.go
@@ -8,26 +8,26 @@
 
 package main
 
-func f1() int { return 1 }
-func f2() (float, int) { return 1, 2 }
-func f3() (float, int, string) { return 1, 2, "3" }
+func f1() int                    { return 1 }
+func f2() (float32, int)         { return 1, 2 }
+func f3() (float32, int, string) { return 1, 2, "3" }
 
 func x() (s string) {
 	a, b, s := f3()
 	_, _ = a, b
-	return	// tests that result var is in scope for redeclaration
+	return // tests that result var is in scope for redeclaration
 }
 
 func main() {
 	i, f, s := f3()
-	j, f := f2()	// redeclare f
+	j, f := f2() // redeclare f
 	k := f1()
 	m, g, s := f3()
 	m, h, s := f3()
 	{
 		// new block should be ok.
 		i, f, s := f3()
-		j, f := f2()	// redeclare f
+		j, f := f2() // redeclare f
 		k := f1()
 		m, g, s := f3()
 		m, h, s := f3()
diff --git a/test/declbad.go b/test/declbad.go
index 269ebdefb53..5e5e1450110 100644
--- a/test/declbad.go
+++ b/test/declbad.go
@@ -8,51 +8,51 @@
 
 package main
 
-func f1() int { return 1 }
-func f2() (float, int) { return 1, 2 }
-func f3() (float, int, string) { return 1, 2, "3" }
+func f1() int                    { return 1 }
+func f2() (float32, int)         { return 1, 2 }
+func f3() (float32, int, string) { return 1, 2, "3" }
 
 func main() {
 	{
 		// simple redeclaration
 		i := f1()
-		i := f1()	// ERROR "redeclared|no new"
+		i := f1() // ERROR "redeclared|no new"
 		_ = i
 	}
 	{
 		// change of type for f
 		i, f, s := f3()
-		f, g, t := f3()	// ERROR "redeclared|cannot assign|incompatible"
+		f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible"
 		_, _, _, _, _ = i, f, s, g, t
 	}
 	{
 		// change of type for i
 		i, f, s := f3()
-		j, i, t := f3()	// ERROR "redeclared|cannot assign|incompatible"
+		j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible"
 		_, _, _, _, _ = i, f, s, j, t
 	}
 	{
 		// no new variables
 		i, f, s := f3()
-		i, f := f2()	// ERROR "redeclared|no new"
+		i, f := f2() // ERROR "redeclared|no new"
 		_, _, _ = i, f, s
 	}
 	{
 		// single redeclaration
 		i, f, s := f3()
-		i := f1()		// ERROR "redeclared|no new|incompatible"
+		i := f1() // ERROR "redeclared|no new|incompatible"
 		_, _, _ = i, f, s
 	}
-		// double redeclaration
+	// double redeclaration
 	{
 		i, f, s := f3()
-		i, f := f2()	// ERROR "redeclared|no new"
+		i, f := f2() // ERROR "redeclared|no new"
 		_, _, _ = i, f, s
 	}
 	{
 		// triple redeclaration
 		i, f, s := f3()
-		i, f, s := f3()	// ERROR "redeclared|no new"
+		i, f, s := f3() // ERROR "redeclared|no new"
 		_, _, _ = i, f, s
 	}
 }
diff --git a/test/fixedbugs/bug006.go b/test/fixedbugs/bug006.go
index e7694f95b56..43b5dfb1294 100644
--- a/test/fixedbugs/bug006.go
+++ b/test/fixedbugs/bug006.go
@@ -9,11 +9,16 @@ package main
 import "os"
 
 const (
-	x float = iota;
-	g float = 4.5 * iota;
-);
+	x float64 = iota
+	g float64 = 4.5 * iota
+)
 
 func main() {
-	if g == 0.0 { print("zero\n");}
-	if g != 4.5 { print(" fail\n"); os.Exit(1); }
+	if g == 0.0 {
+		print("zero\n")
+	}
+	if g != 4.5 {
+		print(" fail\n")
+		os.Exit(1)
+	}
 }
diff --git a/test/fixedbugs/bug007.go b/test/fixedbugs/bug007.go
index bd970de5f92..d65f6da4503 100644
--- a/test/fixedbugs/bug007.go
+++ b/test/fixedbugs/bug007.go
@@ -7,7 +7,9 @@
 package main
 
 type (
-	Point struct { x, y float };
+	Point struct {
+		x, y float64
+	}
 	Polar Point
 )
 
diff --git a/test/fixedbugs/bug010.go b/test/fixedbugs/bug010.go
index e71c4d7f0bc..7d96988d43b 100644
--- a/test/fixedbugs/bug010.go
+++ b/test/fixedbugs/bug010.go
@@ -7,14 +7,14 @@
 package main
 
 
-func f(i int, f float) {
-	i = 8;
-	f = 8.0;
-	return;
+func f(i int, f float64) {
+	i = 8
+	f = 8.0
+	return
 }
 
 func main() {
-	f(3, float(5))
+	f(3, float64(5))
 }
 
 /*
diff --git a/test/fixedbugs/bug011.go b/test/fixedbugs/bug011.go
index 551adb77dfc..ce627472c47 100644
--- a/test/fixedbugs/bug011.go
+++ b/test/fixedbugs/bug011.go
@@ -8,19 +8,19 @@ package main
 
 
 type T struct {
-	x, y int;
+	x, y int
 }
 
-func (t *T) m(a int, b float) int {
-	return (t.x+a) * (t.y+int(b));
+func (t *T) m(a int, b float64) int {
+	return (t.x + a) * (t.y + int(b))
 }
 
 func main() {
-	var t *T = new(T);
-	t.x = 1;
-	t.y = 2;
-	r10 := t.m(1, 3.0);
-	_ = r10;
+	var t *T = new(T)
+	t.x = 1
+	t.y = 2
+	r10 := t.m(1, 3.0)
+	_ = r10
 }
 /*
 bug11.go:16: fatal error: walktype: switch 1 unknown op CALLMETH l(16) <int32>INT32
diff --git a/test/fixedbugs/bug035.go b/test/fixedbugs/bug035.go
index 461c0607ac9..bd2a633f298 100644
--- a/test/fixedbugs/bug035.go
+++ b/test/fixedbugs/bug035.go
@@ -6,8 +6,8 @@
 
 package main
 
-func f9(a int) (i int, f float) {
-	i := 9;  // ERROR "redecl|no new"
-	f := float(9);  // ERROR "redecl|no new"
-	return i, f;
+func f9(a int) (i int, f float64) {
+	i := 9          // ERROR "redecl|no new"
+	f := float64(9) // ERROR "redecl|no new"
+	return i, f
 }
diff --git a/test/fixedbugs/bug047.go b/test/fixedbugs/bug047.go
index f3749e73972..5a776abce8d 100644
--- a/test/fixedbugs/bug047.go
+++ b/test/fixedbugs/bug047.go
@@ -9,15 +9,15 @@ package main
 func main() {
 
 	type T struct {
-		s string;
-		f float;
-	};
-	var s string = "hello";
-	var f float = 0.2;
-	t := T{s, f};
+		s string
+		f float64
+	}
+	var s string = "hello"
+	var f float64 = 0.2
+	t := T{s, f}
 
-	type M map[int] int;
-	m0 := M{7:8};
+	type M map[int]int
+	m0 := M{7: 8}
 
-	_, _ = t, m0;
+	_, _ = t, m0
 }
diff --git a/test/fixedbugs/bug080.go b/test/fixedbugs/bug080.go
index a5003d29b1f..bae16cdb2e9 100644
--- a/test/fixedbugs/bug080.go
+++ b/test/fixedbugs/bug080.go
@@ -4,18 +4,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package main	
- 	
-func f1() (x int, y float) {
-	return;
+package main
+
+func f1() (x int, y float64) {
+	return
 }
 
-func f2   (x int, y float) {
-	return;
+func f2(x int, y float64) {
+	return
 }
 
 func main() {
-	f2(f1());  // this should be a legal call
+	f2(f1()) // this should be a legal call
 }
 
 /*
diff --git a/test/fixedbugs/bug109.go b/test/fixedbugs/bug109.go
index c679771f2ec..7666577230f 100644
--- a/test/fixedbugs/bug109.go
+++ b/test/fixedbugs/bug109.go
@@ -5,10 +5,11 @@
 // license that can be found in the LICENSE file.
 
 package main
-func f(a float) float {
-	e := 1.0;
-	e = e * a;
-	return e;
+
+func f(a float64) float64 {
+	e := 1.0
+	e = e * a
+	return e
 }
 
 /*
diff --git a/test/fixedbugs/bug167.go b/test/fixedbugs/bug167.go
index 729299b6657..33eb3cb1a95 100644
--- a/test/fixedbugs/bug167.go
+++ b/test/fixedbugs/bug167.go
@@ -7,20 +7,24 @@
 package main
 
 func f1() {
-	type T struct { x int }
+	type T struct {
+		x int
+	}
 }
 
 func f2() {
-	type T struct { x float }
+	type T struct {
+		x float64
+	}
 }
 
 func main() {
-	f1();
-	f2();
+	f1()
+	f2()
 }
 
 /*
 1606416576: conflicting definitions for main.T·bug167
 bug167.6:	type main.T·bug167 struct { x int }
-bug167.6:	type main.T·bug167 struct { x float }
+bug167.6:	type main.T·bug167 struct { x float64 }
 */
diff --git a/test/fixedbugs/bug193.go b/test/fixedbugs/bug193.go
index f6b03e13d2e..5ef02b1c1d7 100644
--- a/test/fixedbugs/bug193.go
+++ b/test/fixedbugs/bug193.go
@@ -7,10 +7,10 @@
 package main
 
 func main() {
-	s := uint(10);
-	ss := 1<<s;
-	y1 := float(ss);
-	y2 := float(1<<s);  // ERROR "shift"
-	y3 := string(1<<s);  // ERROR "shift"
-	_, _, _, _, _ = s, ss, y1, y2, y3;
+	s := uint(10)
+	ss := 1 << s
+	y1 := float64(ss)
+	y2 := float64(1 << s) // ERROR "shift"
+	y3 := string(1 << s)  // ERROR "shift"
+	_, _, _, _, _ = s, ss, y1, y2, y3
 }
diff --git a/test/fixedbugs/bug220.go b/test/fixedbugs/bug220.go
index 3f8aaa4ece5..ff027ddc229 100644
--- a/test/fixedbugs/bug220.go
+++ b/test/fixedbugs/bug220.go
@@ -7,8 +7,8 @@
 package main
 
 func main() {
-	m := make(map[int]map[uint]float);
-	
-	m[0] = make(map[uint]float), false;	// 6g used to reject this
-	m[1] = nil;
+	m := make(map[int]map[uint]float64)
+
+	m[0] = make(map[uint]float64), false // 6g used to reject this
+	m[1] = nil
 }
diff --git a/test/fixedbugs/bug230.go b/test/fixedbugs/bug230.go
index 81b256e314a..c7ad1a3660c 100644
--- a/test/fixedbugs/bug230.go
+++ b/test/fixedbugs/bug230.go
@@ -8,14 +8,17 @@ package main
 
 type S string
 type I int
-type F float
+type F float64
 
 func (S) m() {}
 func (I) m() {}
 func (F) m() {}
 
 func main() {
-	c := make(chan interface { m() }, 10)
+	c := make(chan interface {
+		m()
+	},
+		10)
 	c <- I(0)
 	c <- F(1)
 	c <- S("hi")
diff --git a/test/fixedbugs/bug238.go b/test/fixedbugs/bug238.go
index 8b7c7ac3833..7e8660d37e4 100644
--- a/test/fixedbugs/bug238.go
+++ b/test/fixedbugs/bug238.go
@@ -17,6 +17,6 @@ const f struct{} = 6    // ERROR "convert|wrong|invalid"
 const g interface{} = 7 // ERROR "constant|wrong|invalid"
 const h bool = false
 const i int = 2
-const j float = 5
+const j float64 = 5
 
 func main() { println(a, b, c, d, e, f, g) }
diff --git a/test/fixedbugs/bug248.dir/bug2.go b/test/fixedbugs/bug248.dir/bug2.go
index 68c0ce0bc49..4ea187a4b12 100644
--- a/test/fixedbugs/bug248.dir/bug2.go
+++ b/test/fixedbugs/bug248.dir/bug2.go
@@ -23,7 +23,7 @@ type t0 int
 
 func (t0) M(p0.T) {}
 
-type t1 float
+type t1 float64
 
 func (t1) M(p1.T) {}
 
diff --git a/test/fixedbugs/bug248.dir/bug3.go b/test/fixedbugs/bug248.dir/bug3.go
index c96bf16768a..e5a24495577 100644
--- a/test/fixedbugs/bug248.dir/bug3.go
+++ b/test/fixedbugs/bug248.dir/bug3.go
@@ -26,7 +26,7 @@ type t0 int
 func (t0) M(p0.T) {}
 
 // t1 satisfies I1 and p1.I
-type t1 float
+type t1 float64
 
 func (t1) M(p1.T) {}
 
diff --git a/test/fixedbugs/bug299.go b/test/fixedbugs/bug299.go
index 4d731443227..1c7adb5f5b8 100644
--- a/test/fixedbugs/bug299.go
+++ b/test/fixedbugs/bug299.go
@@ -11,9 +11,9 @@ type T struct {
 	x int
 	y (int)
 	int
-	*float
+	*float64
 	// not legal according to spec
-	(complex)  // ERROR "non-declaration|expected|parenthesize"
+	(complex128)  // ERROR "non-declaration|expected|parenthesize"
 	(*string)  // ERROR "non-declaration|expected|parenthesize"
 	*(bool)    // ERROR "non-declaration|expected|parenthesize"
 }
diff --git a/test/fixedbugs/bug307.go b/test/fixedbugs/bug307.go
index a1a30dfb71c..1b42c09ab1e 100644
--- a/test/fixedbugs/bug307.go
+++ b/test/fixedbugs/bug307.go
@@ -5,11 +5,11 @@
 // license that can be found in the LICENSE file.
 
 // Valid program, gccgo reported an error.
-// bug307.go:14:6: error: cmplx arguments must have identical types
+// bug307.go:14:6: error: complex arguments must have identical types
 
 package main
 
 func main() {
 	var f float64
-	_ = cmplx(1 / f, 0)
+	_ = complex(1/f, 0)
 }
diff --git a/test/fixedbugs/bug315.go b/test/fixedbugs/bug315.go
index 198bae77ab6..c59ef29e6c0 100644
--- a/test/fixedbugs/bug315.go
+++ b/test/fixedbugs/bug315.go
@@ -9,7 +9,7 @@
 package main
 
 func main() {
-	a := cmplx(2, 2)
+	a := complex(2, 2)
 	a /= 2
 }
 
diff --git a/test/fixedbugs/bug316.go b/test/fixedbugs/bug316.go
index bd4d99eb6a3..2146408a1e2 100644
--- a/test/fixedbugs/bug316.go
+++ b/test/fixedbugs/bug316.go
@@ -9,7 +9,7 @@
 package main
 
 const (
-	c = cmplx(1, 2)
+	c = complex(1, 2)
 	r = real(c) // was: const initializer must be constant
 	i = imag(c) // was: const initializer must be constant
 )
diff --git a/test/func.go b/test/func.go
index 0c1a07979df..e8ed928bcd3 100644
--- a/test/func.go
+++ b/test/func.go
@@ -21,10 +21,10 @@ func f2(a int) {
 }
 
 func f3(a, b int) int {
-	return a+b
+	return a + b
 }
 
-func f4(a, b int, c float) int {
+func f4(a, b int, c float32) int {
 	return (a+b)/2 + int(c)
 }
 
@@ -36,12 +36,12 @@ func f6(a int) (r int) {
 	return 6
 }
 
-func f7(a int) (x int, y float) {
+func f7(a int) (x int, y float32) {
 	return 7, 7.0
 }
 
 
-func f8(a int) (x int, y float) {
+func f8(a int) (x int, y float32) {
 	return 8, 8.0
 }
 
@@ -49,12 +49,12 @@ type T struct {
 	x, y int
 }
 
-func (t *T) m10(a int, b float) int {
-	return (t.x+a) * (t.y+int(b))
+func (t *T) m10(a int, b float32) int {
+	return (t.x + a) * (t.y + int(b))
 }
 
 
-func f9(a int) (i int, f float) {
+func f9(a int) (i int, f float32) {
 	i = 9
 	f = 9.0
 	return
diff --git a/test/func1.go b/test/func1.go
index 56f4dfcba40..056ff9877d3 100644
--- a/test/func1.go
+++ b/test/func1.go
@@ -8,11 +8,11 @@
 
 package main
 
-func f1(a int) (int, float) {  // BUG (not caught by compiler): multiple return values must have names
+func f1(a int) (int, float32) { // BUG (not caught by compiler): multiple return values must have names
 	return 7, 7.0
 }
 
 
-func f2(a int) (a int, b float) {  // ERROR "redeclared|definition"
+func f2(a int) (a int, b float32) { // ERROR "redeclared|definition"
 	return 8, 8.0
 }
diff --git a/test/golden.out b/test/golden.out
index 04c71327b17..83e8327a517 100644
--- a/test/golden.out
+++ b/test/golden.out
@@ -60,7 +60,6 @@ Hello World!
 =========== ken/cplx3.go
 (+1.292308e+000-1.384615e-001i)
 (+1.292308e+000-1.384615e-001i)
-64
 
 =========== ken/cplx4.go
 c = (-5.000000-6.000000i)
diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index b952f8fc8ad..b6a582fffba 100644
--- a/test/interface/explicit.go
+++ b/test/interface/explicit.go
@@ -51,21 +51,25 @@ func main() {
 	t = T(e) // ERROR "need explicit|need type assertion|incompatible"
 }
 
-type M interface { M() }
+type M interface {
+	M()
+}
+
 var m M
 
-var _ = m.(int)	// ERROR "impossible type assertion"
+var _ = m.(int) // ERROR "impossible type assertion"
 
 type Int int
-func (Int) M(float) {}
 
-var _ = m.(Int)	// ERROR "impossible type assertion"
+func (Int) M(float64) {}
+
+var _ = m.(Int) // ERROR "impossible type assertion"
 
 var ii int
 var jj Int
 
-var m1 M = ii	// ERROR "incompatible|missing"
-var m2 M = jj	// ERROR "incompatible|wrong type for M method"
+var m1 M = ii // ERROR "incompatible|missing"
+var m2 M = jj // ERROR "incompatible|wrong type for M method"
 
-var m3 = M(ii)	// ERROR "invalid|missing"
-var m4 = M(jj)	// ERROR "invalid|wrong type for M method"
+var m3 = M(ii) // ERROR "invalid|missing"
+var m4 = M(jj) // ERROR "invalid|wrong type for M method"
diff --git a/test/iota.go b/test/iota.go
index 20b77c6cc05..c40ca1f3824 100644
--- a/test/iota.go
+++ b/test/iota.go
@@ -17,8 +17,8 @@ const (
 	x int = iota
 	y = iota
 	z = 1 << iota
-	f float = 2 * iota
-	g float = 4.5 * float(iota)
+	f float32 = 2 * iota
+	g float32 = 4.5 * float32(iota)
 )
 
 const (
@@ -57,7 +57,7 @@ const (
 )
 
 const (
-	p = float(iota)
+	p = float32(iota)
 	q
 	r
 )
@@ -68,9 +68,9 @@ const (
 )
 
 const (
-	abit, amask = 1 << iota, 1 << iota - 1
-	bbit, bmask = 1 << iota, 1 << iota - 1
-	cbit, cmask = 1 << iota, 1 << iota - 1
+	abit, amask = 1 << iota, 1<<iota - 1
+	bbit, bmask = 1 << iota, 1<<iota - 1
+	cbit, cmask = 1 << iota, 1<<iota - 1
 )
 
 func main() {
diff --git a/test/ken/cplx0.go b/test/ken/cplx0.go
index 6e9bfd023d0..ba1fa196fd6 100644
--- a/test/ken/cplx0.go
+++ b/test/ken/cplx0.go
@@ -13,7 +13,7 @@ const (
 	C1 = R + I // ADD(5,6)
 )
 
-func doprint(c complex) { println(c) }
+func doprint(c complex128) { println(c) }
 
 func main() {
 
diff --git a/test/ken/cplx1.go b/test/ken/cplx1.go
index 26b1139928f..8ec7d40f5e5 100644
--- a/test/ken/cplx1.go
+++ b/test/ken/cplx1.go
@@ -48,7 +48,7 @@ func main() {
 	booltest(6+9i, false)
 }
 
-func booltest(a complex, r bool) {
+func booltest(a complex64, r bool) {
 	var b bool
 
 	b = a == C1
diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go
index 5a66dc9a954..b36e93ecd66 100644
--- a/test/ken/cplx2.go
+++ b/test/ken/cplx2.go
@@ -28,13 +28,13 @@ const (
 
 func main() {
 
-	r := 5 + 0i
+	var r complex64 = 5 + 0i
 	if r != R {
 		println("opcode 1", r, R)
 		panic("fail")
 	}
 
-	i := 6i
+	var i complex64 = 6i
 	if i != I {
 		println("opcode 2", i, I)
 		panic("fail")
diff --git a/test/ken/cplx3.go b/test/ken/cplx3.go
index 997894b4184..83acc15ff7c 100644
--- a/test/ken/cplx3.go
+++ b/test/ken/cplx3.go
@@ -16,24 +16,18 @@ const (
 	C1 = R + I // ADD(5,6)
 )
 
-var complexBits = reflect.Typeof(complex(0i)).Size() * 8
-
 func main() {
 	c0 := C1
 	c0 = (c0 + c0 + c0) / (c0 + c0 + 3i)
 	println(c0)
 
-	c := *(*complex)(unsafe.Pointer(&c0))
+	c := *(*complex128)(unsafe.Pointer(&c0))
 	println(c)
 
-	println(complexBits)
-
 	var a interface{}
 	switch c := reflect.NewValue(a).(type) {
 	case *reflect.ComplexValue:
-		if complexBits == 64 {
-			v := c.Get()
-			_, _ = complex64(v), true
-		}
+		v := c.Get()
+		_, _ = complex128(v), true
 	}
 }
diff --git a/test/ken/cplx4.go b/test/ken/cplx4.go
index 3c6f1f68c96..8524e47aec3 100644
--- a/test/ken/cplx4.go
+++ b/test/ken/cplx4.go
@@ -15,7 +15,7 @@ const (
 	C1 = R + I // ADD(5,6)
 )
 
-func doprint(c complex) { fmt.Printf("c = %f\n", c) }
+func doprint(c complex128) { fmt.Printf("c = %f\n", c) }
 
 func main() {
 
@@ -32,12 +32,12 @@ func main() {
 	c2 := complex128(C1)
 	fmt.Printf("c = %G\n", c2)
 
-	// real, imag, cmplx
-	c3 := cmplx(real(c2)+3, imag(c2)-5) + c2
+	// real, imag, complex
+	c3 := complex(real(c2)+3, imag(c2)-5) + c2
 	fmt.Printf("c = %G\n", c3)
 
 	// compiler used to crash on nested divide
-	c4 := cmplx(real(c3/2), imag(c3/2))
+	c4 := complex(real(c3/2), imag(c3/2))
 	if c4 != c3/2 {
 		fmt.Printf("BUG: c3 = %G != c4 = %G\n", c3, c4)
 	}
diff --git a/test/ken/cplx5.go b/test/ken/cplx5.go
index af2a1c57d12..d425a7c4c04 100644
--- a/test/ken/cplx5.go
+++ b/test/ken/cplx5.go
@@ -6,49 +6,49 @@
 
 package main
 
-var a [12]complex
-var s []complex
-var c chan complex
+var a [12]complex128
+var s []complex128
+var c chan complex128
 var f struct {
-	c complex
+	c complex128
 }
-var m map[complex]complex
+var m map[complex128]complex128
 
 func main() {
-	// array of complex
+	// array of complex128
 	for i := 0; i < len(a); i++ {
-		a[i] = cmplx(float(i), float(-i))
+		a[i] = complex(float64(i), float64(-i))
 	}
 	println(a[5])
 
-	// slice of complex
-	s = make([]complex, len(a))
+	// slice of complex128
+	s = make([]complex128, len(a))
 	for i := 0; i < len(s); i++ {
 		s[i] = a[i]
 	}
 	println(s[5])
 
 	// chan
-	c = make(chan complex)
+	c = make(chan complex128)
 	go chantest(c)
 	println(<-c)
 
-	// pointer of complex
+	// pointer of complex128
 	v := a[5]
 	pv := &v
 	println(*pv)
 
-	// field of complex
+	// field of complex128
 	f.c = a[5]
 	println(f.c)
 
-	// map of complex
-	m = make(map[complex]complex)
+	// map of complex128
+	m = make(map[complex128]complex128)
 	for i := 0; i < len(s); i++ {
 		m[-a[i]] = a[i]
 	}
 	println(m[5i-5])
-	println(m[cmplx(-5, 5)])
+	println(m[complex(-5, 5)])
 }
 
-func chantest(c chan complex) { c <- a[5] }
+func chantest(c chan complex128) { c <- a[5] }
diff --git a/test/ken/robfunc.go b/test/ken/robfunc.go
index 12b4b6d7b66..6b3d4b2e460 100644
--- a/test/ken/robfunc.go
+++ b/test/ken/robfunc.go
@@ -8,8 +8,8 @@ package main
 
 func assertequal(is, shouldbe int, msg string) {
 	if is != shouldbe {
-		print("assertion fail" + msg + "\n");
-		panic(1);
+		print("assertion fail" + msg + "\n")
+		panic(1)
 	}
 }
 
@@ -20,75 +20,75 @@ func f2(a int) {
 }
 
 func f3(a, b int) int {
-	return a+b;
+	return a + b
 }
 
-func f4(a, b int, c float) int {
-	return (a+b)/2 + int(c);
+func f4(a, b int, c float64) int {
+	return (a+b)/2 + int(c)
 }
 
 func f5(a int) int {
-	return 5;
+	return 5
 }
 
 func f6(a int) (r int) {
-	return 6;
+	return 6
 }
 
-func f7(a int) (x int, y float) {
-	return 7, 7.0;
+func f7(a int) (x int, y float64) {
+	return 7, 7.0
 }
 
 
-func f8(a int) (x int, y float) {
-	return 8, 8.0;
+func f8(a int) (x int, y float64) {
+	return 8, 8.0
 }
 
 type T struct {
-	x, y int;
+	x, y int
 }
 
-func (t *T) m10(a int, b float) int {
-	return (t.x+a) * (t.y+int(b));
+func (t *T) m10(a int, b float64) int {
+	return (t.x + a) * (t.y + int(b))
 }
 
 
-func f9(a int) (in int, fl float) {
-	i := 9;
-	f := float(9);
-	return i, f;
+func f9(a int) (in int, fl float64) {
+	i := 9
+	f := float64(9)
+	return i, f
 }
 
 
 func main() {
-	f1();
-	f2(1);
-	r3 := f3(1, 2);
-	assertequal(r3, 3, "3");
-	r4 := f4(0, 2, 3.0);
-	assertequal(r4, 4, "4");
-	r5 := f5(1);
-	assertequal(r5, 5, "5");
-	r6 := f6(1);
-	assertequal(r6, 6, "6");
-	var r7 int;
-	var s7 float;
-	r7, s7 = f7(1);
-	assertequal(r7, 7, "r7");
-	assertequal(int(s7), 7, "s7");
-	var r8 int;
-	var s8 float;
-	r8, s8 = f8(1);
-	assertequal(r8, 8, "r8");
-	assertequal(int(s8), 8, "s8");
-	var r9 int;
-	var s9 float;
-	r9, s9 = f9(1);
-	assertequal(r9, 9, "r9");
-	assertequal(int(s9), 9, "s9");
-	var t *T = new(T);
-	t.x = 1;
-	t.y = 2;
-	r10 := t.m10(1, 3.0);
-	assertequal(r10, 10, "10");
+	f1()
+	f2(1)
+	r3 := f3(1, 2)
+	assertequal(r3, 3, "3")
+	r4 := f4(0, 2, 3.0)
+	assertequal(r4, 4, "4")
+	r5 := f5(1)
+	assertequal(r5, 5, "5")
+	r6 := f6(1)
+	assertequal(r6, 6, "6")
+	var r7 int
+	var s7 float64
+	r7, s7 = f7(1)
+	assertequal(r7, 7, "r7")
+	assertequal(int(s7), 7, "s7")
+	var r8 int
+	var s8 float64
+	r8, s8 = f8(1)
+	assertequal(r8, 8, "r8")
+	assertequal(int(s8), 8, "s8")
+	var r9 int
+	var s9 float64
+	r9, s9 = f9(1)
+	assertequal(r9, 9, "r9")
+	assertequal(int(s9), 9, "s9")
+	var t *T = new(T)
+	t.x = 1
+	t.y = 2
+	r10 := t.m10(1, 3.0)
+	assertequal(r10, 10, "10")
 }
diff --git a/test/ken/simpconv.go b/test/ken/simpconv.go
index cb443e3a19b..feb85d29997 100644
--- a/test/ken/simpconv.go
+++ b/test/ken/simpconv.go
@@ -6,20 +6,23 @@
 
 package main
 
-type vlong int64;
-type short int16;
+type vlong int64
+type short int16
 
-func
-main() {
-	s1 := vlong(0);
-	for i:=short(0); i<10; i=i+1 {
-		s1 = s1 + vlong(i);
+func main() {
+	s1 := vlong(0)
+	for i := short(0); i < 10; i = i + 1 {
+		s1 = s1 + vlong(i)
+	}
+	if s1 != 45 {
+		panic(s1)
 	}
-	if s1 != 45 { panic(s1); }
 
-	s2 := float(0);
-	for i:=0; i<10; i=i+1 {
-		s2 = s2 + float(i);
+	s2 := float64(0)
+	for i := 0; i < 10; i = i + 1 {
+		s2 = s2 + float64(i)
+	}
+	if s2 != 45 {
+		panic(s2)
 	}
-	if s2 != 45 { panic(s2); }
 }
diff --git a/test/ken/slicearray.go b/test/ken/slicearray.go
index 6e7088e19c0..5c31270fcd3 100644
--- a/test/ken/slicearray.go
+++ b/test/ken/slicearray.go
@@ -8,8 +8,8 @@ package main
 
 var bx [10]byte
 var by []byte
-var fx [10]float
-var fy []float
+var fx [10]float64
+var fy []float64
 var lb, hb int
 var t int
 
@@ -87,7 +87,7 @@ func main() {
 	by = bx[2:8]
 	tstb()
 
-	// width 4 (float)
+	// width 4 (float64)
 	lb = 0
 	hb = 10
 	fy = fx[lb:hb]
@@ -204,7 +204,7 @@ func init() {
 	by = nil
 
 	for i := 0; i < len(fx); i++ {
-		fx[i] = float(i + 20)
+		fx[i] = float64(i + 20)
 	}
 	fy = nil
 }
diff --git a/test/ken/sliceslice.go b/test/ken/sliceslice.go
index 5a35acaf442..63904212877 100644
--- a/test/ken/sliceslice.go
+++ b/test/ken/sliceslice.go
@@ -8,8 +8,8 @@ package main
 
 var bx []byte
 var by []byte
-var fx []float
-var fy []float
+var fx []float64
+var fy []float64
 var lb, hb int
 var t int
 
@@ -78,7 +78,7 @@ func main() {
 	by = bx[2:8]
 	tstb()
 
-	// width 4 (float)
+	// width 4 (float64)
 	lb = 0
 	hb = 10
 	fy = fx[lb:hb]
@@ -195,9 +195,9 @@ func init() {
 	}
 	by = nil
 
-	fx = make([]float, 10)
+	fx = make([]float64, 10)
 	for i := 0; i < len(fx); i++ {
-		fx[i] = float(i + 20)
+		fx[i] = float64(i + 20)
 	}
 	fy = nil
 }
diff --git a/test/literal.go b/test/literal.go
index 9bdbabca860..bf05388127c 100644
--- a/test/literal.go
+++ b/test/literal.go
@@ -18,7 +18,7 @@ func assert(cond bool, msg string) {
 	}
 }
 
-func equal(a, b float) bool {
+func equal(a, b float32) bool {
 	return a == b
 }
 
@@ -116,23 +116,23 @@ func main() {
 	_, _, _, _ = u30, u31, u32, u33
 
 	// float
-	var f00 float = 3.14159
-	var f01 float = -3.14159
-	var f02 float = +3.14159
-	var f03 float = 0.0
-	var f04 float = .0
-	var f05 float = 0.
-	var f06 float = -0.0
-	var f07 float = 1e10
-	var f08 float = -1e10
-	var f09 float = 1e-10
-	var f10 float = 1e+10
-	var f11 float = 1.e-10
-	var f12 float = 1.e+10
-	var f13 float = .1e-10
-	var f14 float = .1e+10
-	var f15 float = 1.1e-10
-	var f16 float = 1.1e+10
+	var f00 float32 = 3.14159
+	var f01 float32 = -3.14159
+	var f02 float32 = +3.14159
+	var f03 float32 = 0.0
+	var f04 float32 = .0
+	var f05 float32 = 0.
+	var f06 float32 = -0.0
+	var f07 float32 = 1e10
+	var f08 float32 = -1e10
+	var f09 float32 = 1e-10
+	var f10 float32 = 1e+10
+	var f11 float32 = 1.e-10
+	var f12 float32 = 1.e+10
+	var f13 float32 = .1e-10
+	var f14 float32 = .1e+10
+	var f15 float32 = 1.1e-10
+	var f16 float32 = 1.1e+10
 	assert(f01 == -f00, "f01")
 	assert(f02 == -f01, "f02")
 	assert(f03 == f04, "f03")
diff --git a/test/map.go b/test/map.go
index ddff7c7a733..c3963499bce 100644
--- a/test/map.go
+++ b/test/map.go
@@ -21,73 +21,73 @@ func P(a []string) string {
 		}
 		s += `"` + a[i] + `"`
 	}
-	s +="}"
+	s += "}"
 	return s
 }
 
 func main() {
 	// Test a map literal.
-	mlit := map[string] int { "0":0, "1":1, "2":2, "3":3, "4":4 }
+	mlit := map[string]int{"0": 0, "1": 1, "2": 2, "3": 3, "4": 4}
 	for i := 0; i < len(mlit); i++ {
-		s := string([]byte{byte(i)+'0'})
+		s := string([]byte{byte(i) + '0'})
 		if mlit[s] != i {
 			fmt.Printf("mlit[%s] = %d\n", s, mlit[s])
 		}
 	}
 
-	mib := make(map[int] bool)
-	mii := make(map[int] int)
-	mfi := make(map[float] int)
-	mif := make(map[int] float)
-	msi := make(map[string] int)
-	mis := make(map[int] string)
-	mss := make(map[string] string)
-	mspa := make(map[string] []string)
+	mib := make(map[int]bool)
+	mii := make(map[int]int)
+	mfi := make(map[float32]int)
+	mif := make(map[int]float32)
+	msi := make(map[string]int)
+	mis := make(map[int]string)
+	mss := make(map[string]string)
+	mspa := make(map[string][]string)
 	// BUG need an interface map both ways too
 
 	type T struct {
-		i int64	// can't use string here; struct values are only compared at the top level
-		f float
+		i int64 // can't use string here; struct values are only compared at the top level
+		f float32
 	}
-	mipT := make(map[int] *T)
-	mpTi := make(map[*T] int)
-	mit := make(map[int] T)
-//	mti := make(map[T] int)
+	mipT := make(map[int]*T)
+	mpTi := make(map[*T]int)
+	mit := make(map[int]T)
+	//	mti := make(map[T] int)
 
-	type M map[int] int
-	mipM := make(map[int] M)
+	type M map[int]int
+	mipM := make(map[int]M)
 
-	var apT [2*count]*T
+	var apT [2 * count]*T
 
 	for i := 0; i < count; i++ {
 		s := strconv.Itoa(i)
-		s10 := strconv.Itoa(i*10)
-		f := float(i)
-		t := T{int64(i),f}
+		s10 := strconv.Itoa(i * 10)
+		f := float32(i)
+		t := T{int64(i), f}
 		apT[i] = new(T)
 		apT[i].i = int64(i)
 		apT[i].f = f
-		apT[2*i] = new(T)	// need twice as many entries as we use, for the nonexistence check
+		apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check
 		apT[2*i].i = int64(i)
 		apT[2*i].f = f
-		m := M{i: i+1}
+		m := M{i: i + 1}
 		mib[i] = (i != 0)
-		mii[i] = 10*i
-		mfi[float(i)] = 10*i
-		mif[i] = 10.0*f
+		mii[i] = 10 * i
+		mfi[float32(i)] = 10 * i
+		mif[i] = 10.0 * f
 		mis[i] = s
 		msi[s] = i
 		mss[s] = s10
 		mss[s] = s10
 		as := make([]string, 2)
-			as[0] = s10
-			as[1] = s10
+		as[0] = s10
+		as[1] = s10
 		mspa[s] = as
 		mipT[i] = apT[i]
 		mpTi[apT[i]] = i
 		mipM[i] = m
 		mit[i] = t
-	//	mti[t] = i
+		//	mti[t] = i
 	}
 
 	// test len
@@ -121,15 +121,15 @@ func main() {
 	if len(mpTi) != count {
 		fmt.Printf("len(mpTi) = %d\n", len(mpTi))
 	}
-//	if len(mti) != count {
-//		fmt.Printf("len(mti) = %d\n", len(mti))
-//	}
+	//	if len(mti) != count {
+	//		fmt.Printf("len(mti) = %d\n", len(mti))
+	//	}
 	if len(mipM) != count {
 		fmt.Printf("len(mipM) = %d\n", len(mipM))
 	}
-//	if len(mti) != count {
-//		fmt.Printf("len(mti) = %d\n", len(mti))
-//	}
+	//	if len(mti) != count {
+	//		fmt.Printf("len(mti) = %d\n", len(mti))
+	//	}
 	if len(mit) != count {
 		fmt.Printf("len(mit) = %d\n", len(mit))
 	}
@@ -137,25 +137,25 @@ func main() {
 	// test construction directly
 	for i := 0; i < count; i++ {
 		s := strconv.Itoa(i)
-		s10 := strconv.Itoa(i*10)
-		f := float(i)
+		s10 := strconv.Itoa(i * 10)
+		f := float32(i)
 		// BUG m := M(i, i+1)
 		if mib[i] != (i != 0) {
 			fmt.Printf("mib[%d] = %t\n", i, mib[i])
 		}
-		if(mii[i] != 10*i) {
+		if mii[i] != 10*i {
 			fmt.Printf("mii[%d] = %d\n", i, mii[i])
 		}
-		if(mfi[f] != 10*i) {
+		if mfi[f] != 10*i {
 			fmt.Printf("mfi[%d] = %d\n", i, mfi[f])
 		}
-		if(mif[i] != 10.0*f) {
+		if mif[i] != 10.0*f {
 			fmt.Printf("mif[%d] = %g\n", i, mif[i])
 		}
-		if(mis[i] != s) {
+		if mis[i] != s {
 			fmt.Printf("mis[%d] = %s\n", i, mis[i])
 		}
-		if(msi[s] != i) {
+		if msi[s] != i {
 			fmt.Printf("msi[%s] = %d\n", s, msi[s])
 		}
 		if mss[s] != s10 {
@@ -166,22 +166,22 @@ func main() {
 				fmt.Printf("mspa[%s][%d] = %s\n", s, j, mspa[s][j])
 			}
 		}
-		if(mipT[i].i != int64(i) || mipT[i].f != f) {
+		if mipT[i].i != int64(i) || mipT[i].f != f {
 			fmt.Printf("mipT[%d] = %v\n", i, mipT[i])
 		}
-		if(mpTi[apT[i]] != i) {
+		if mpTi[apT[i]] != i {
 			fmt.Printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]])
 		}
-	//	if(mti[t] != i) {
-	//		fmt.Printf("mti[%s] = %s\n", s, mti[t])
-	//	}
-		if (mipM[i][i] != i + 1) {
+		//	if(mti[t] != i) {
+		//		fmt.Printf("mti[%s] = %s\n", s, mti[t])
+		//	}
+		if mipM[i][i] != i+1 {
 			fmt.Printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i])
 		}
-	//	if(mti[t] != i) {
-	//		fmt.Printf("mti[%v] = %d\n", t, mti[t])
-	//	}
-		if(mit[i].i != int64(i) || mit[i].f != f) {
+		//	if(mti[t] != i) {
+		//		fmt.Printf("mti[%v] = %d\n", t, mti[t])
+		//	}
+		if mit[i].i != int64(i) || mit[i].f != f {
 			fmt.Printf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f)
 		}
 	}
@@ -190,7 +190,7 @@ func main() {
 	// failed lookups yield a false value for the boolean.
 	for i := 0; i < count; i++ {
 		s := strconv.Itoa(i)
-		f := float(i)
+		f := float32(i)
 		{
 			_, b := mib[i]
 			if !b {
@@ -311,23 +311,23 @@ func main() {
 				fmt.Printf("tuple existence assign: mit[%d]\n", i)
 			}
 		}
-//		{
-//			_, b := mti[t]
-//			if !b {
-//				fmt.Printf("tuple existence decl: mti[%d]\n", i)
-//			}
-//			_, b = mti[t]
-//			if !b {
-//				fmt.Printf("tuple existence assign: mti[%d]\n", i)
-//			}
-//		}
+		//		{
+		//			_, b := mti[t]
+		//			if !b {
+		//				fmt.Printf("tuple existence decl: mti[%d]\n", i)
+		//			}
+		//			_, b = mti[t]
+		//			if !b {
+		//				fmt.Printf("tuple existence assign: mti[%d]\n", i)
+		//			}
+		//		}
 	}
 
 	// test nonexistence with tuple check
 	// failed lookups yield a false value for the boolean.
 	for i := count; i < 2*count; i++ {
 		s := strconv.Itoa(i)
-		f := float(i)
+		f := float32(i)
 		{
 			_, b := mib[i]
 			if b {
@@ -438,16 +438,16 @@ func main() {
 				fmt.Printf("tuple nonexistence assign: mipM[%d]", i)
 			}
 		}
-//		{
-//			_, b := mti[t]
-//			if b {
-//				fmt.Printf("tuple nonexistence decl: mti[%d]", i)
-//			}
-//			_, b = mti[t]
-//			if b {
-//				fmt.Printf("tuple nonexistence assign: mti[%d]", i)
-//			}
-//		}
+		//		{
+		//			_, b := mti[t]
+		//			if b {
+		//				fmt.Printf("tuple nonexistence decl: mti[%d]", i)
+		//			}
+		//			_, b = mti[t]
+		//			if b {
+		//				fmt.Printf("tuple nonexistence assign: mti[%d]", i)
+		//			}
+		//		}
 		{
 			_, b := mit[i]
 			if b {
@@ -460,32 +460,31 @@ func main() {
 		}
 	}
 
-
 	// tests for structured map element updates
 	for i := 0; i < count; i++ {
 		s := strconv.Itoa(i)
-		mspa[s][i % 2] = "deleted"
-		if mspa[s][i % 2] != "deleted" {
-			fmt.Printf("update mspa[%s][%d] = %s\n", s, i %2, mspa[s][i % 2])
+		mspa[s][i%2] = "deleted"
+		if mspa[s][i%2] != "deleted" {
+			fmt.Printf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2])
 		}
 
 		mipT[i].i += 1
 		if mipT[i].i != int64(i)+1 {
 			fmt.Printf("update mipT[%d].i = %d\n", i, mipT[i].i)
 		}
-		mipT[i].f = float(i + 1)
-		if (mipT[i].f != float(i + 1)) {
+		mipT[i].f = float32(i + 1)
+		if mipT[i].f != float32(i+1) {
 			fmt.Printf("update mipT[%d].f = %g\n", i, mipT[i].f)
 		}
 
 		mipM[i][i]++
-		if mipM[i][i] != (i + 1) + 1 {
+		if mipM[i][i] != (i+1)+1 {
 			fmt.Printf("update mipM[%d][%d] = %i\n", i, i, mipM[i][i])
 		}
 	}
 
 	// test range on nil map
-	var mnil map[string] int
+	var mnil map[string]int
 	for _, _ = range mnil {
 		panic("range mnil")
 	}
diff --git a/test/named.go b/test/named.go
index d2039bab4d4..5b6bb81fe34 100644
--- a/test/named.go
+++ b/test/named.go
@@ -12,7 +12,7 @@ package main
 type Array [10]byte
 type Bool bool
 type Chan chan int
-type Float float
+type Float float32
 type Int int
 type Map map[int]byte
 type Slice []byte
diff --git a/test/nil.go b/test/nil.go
index 6a72b72ebdd..4f4c7552760 100644
--- a/test/nil.go
+++ b/test/nil.go
@@ -10,14 +10,13 @@ type T struct {
 	i int
 }
 
-type IN interface {
-}
+type IN interface{}
 
 func main() {
 	var i *int
-	var f *float
+	var f *float32
 	var s *string
-	var m map[float] *int
+	var m map[float32]*int
 	var c chan int
 	var t *T
 	var in IN
diff --git a/test/recover2.go b/test/recover2.go
index f33af4457b9..9affe25d47a 100644
--- a/test/recover2.go
+++ b/test/recover2.go
@@ -58,7 +58,7 @@ func test3() {
 func test4() {
 	defer mustRecover("interface")
 	var x interface{} = 1
-	println(x.(float))
+	println(x.(float32))
 }
 
 type T struct {
diff --git a/test/test0.go b/test/test0.go
index dd2033a98fd..d8d86c42793 100644
--- a/test/test0.go
+++ b/test/test0.go
@@ -6,12 +6,11 @@
 
 package main
 
-const
-	a_const = 0
+const a_const = 0
 
 const (
-	pi = /* the usual */ 3.14159265358979323
-	e = 2.718281828
+	pi    = /* the usual */ 3.14159265358979323
+	e     = 2.718281828
 	mask1 int = 1 << iota
 	mask2 = 1 << iota
 	mask3 = 1 << iota
@@ -19,7 +18,7 @@ const (
 )
 
 type (
-	Empty interface {}
+	Empty interface{}
 	Point struct {
 		x, y int
 	}
@@ -32,19 +31,21 @@ func (p *Point) Initialize(x, y int) *Point {
 }
 
 func (p *Point) Distance() int {
-	return p.x * p.x + p.y * p.y
+	return p.x*p.x + p.y*p.y
 }
 
 var (
-	x1 int
-	x2 int
-	u, v, w float
+	x1      int
+	x2      int
+	u, v, w float32
 )
 
 func foo() {}
 
 func min(x, y int) int {
-	if x < y { return x; }
+	if x < y {
+		return x
+	}
 	return y
 }
 
@@ -57,24 +58,29 @@ func swap(x, y int) (u, v int) {
 func control_structs() {
 	var p *Point = new(Point).Initialize(2, 3)
 	i := p.Distance()
-	var f float = 0.3
+	var f float32 = 0.3
 	_ = f
-	for {}
-	for {}
+	for {
+	}
+	for {
+	}
 	for j := 0; j < i; j++ {
 		if i == 0 {
-		} else i = 0
-		var x float
+		} else {
+			i = 0
+		}
+		var x float32
 		_ = x
 	}
-	foo:	// a label
+foo: // a label
 	var j int
 	switch y := 0; true {
 	case i < y:
 		fallthrough
 	case i < j:
 	case i == 0, i == 1, i == j:
-		i++; i++
+		i++
+		i++
 		goto foo
 	default:
 		i = -+-+i
diff --git a/test/typeswitch.go b/test/typeswitch.go
index 9e6d10ea879..83fb0985a91 100644
--- a/test/typeswitch.go
+++ b/test/typeswitch.go
@@ -21,12 +21,15 @@ const (
 	Last
 )
 
-type S struct { a int }
+type S struct {
+	a int
+}
+
 var s S = S{1234}
 
 var c = make(chan int)
 
-var a	= []int{0,1,2,3}
+var a = []int{0, 1, 2, 3}
 
 var m = make(map[string]int)
 
@@ -68,10 +71,10 @@ func main() {
 			assert(x == true && i == Bool, "bool")
 		case int:
 			assert(x == 7 && i == Int, "int")
-		case float:
-			assert(x == 7.4 && i == Float, "float")
+		case float64:
+			assert(x == 7.4 && i == Float, "float64")
 		case string:
-			assert(x == "hello"&& i == String, "string")
+			assert(x == "hello" && i == String, "string")
 		case S:
 			assert(x.a == 1234 && i == Struct, "struct")
 		case chan int:
diff --git a/test/zerodivide.go b/test/zerodivide.go
index cd4f52215b4..1948528d245 100644
--- a/test/zerodivide.go
+++ b/test/zerodivide.go
@@ -17,56 +17,90 @@ type Error interface {
 }
 
 type ErrorTest struct {
-	name	string
-	fn	func()
-	err	string
+	name string
+	fn   func()
+	err  string
 }
 
 var (
-	i, j, k int = 0, 0, 1
-	i8, j8, k8 int8 = 0, 0, 1
+	i, j, k       int   = 0, 0, 1
+	i8, j8, k8    int8  = 0, 0, 1
 	i16, j16, k16 int16 = 0, 0, 1
 	i32, j32, k32 int32 = 0, 0, 1
 	i64, j64, k64 int64 = 0, 0, 1
 
-	u, v, w uint = 0, 0, 1
-	u8, v8, w8 uint8 = 0, 0, 1
-	u16, v16, w16 uint16 = 0, 0, 1
-	u32, v32, w32 uint32 = 0, 0, 1
-	u64, v64, w64 uint64 = 0, 0, 1
-	up, vp, wp uintptr = 0, 0, 1
+	u, v, w       uint    = 0, 0, 1
+	u8, v8, w8    uint8   = 0, 0, 1
+	u16, v16, w16 uint16  = 0, 0, 1
+	u32, v32, w32 uint32  = 0, 0, 1
+	u64, v64, w64 uint64  = 0, 0, 1
+	up, vp, wp    uintptr = 0, 0, 1
 
-	f, g, h float = 0, 0, 1
-	f32, g32, h32 float32 = 0, 0, 1
+	f, g, h                         float64 = 0, 0, 1
+	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 complex = 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
+	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++
-	i16++; j16++; k16++
-	i32++; j32++; k32++
-	i64++; j64++; k64++
+	i++
+	j++
+	k++
+	i8++
+	j8++
+	k8++
+	i16++
+	j16++
+	k16++
+	i32++
+	j32++
+	k32++
+	i64++
+	j64++
+	k64++
 
-	u++; v++; w++
-	u8++; v8++; w8++
-	u16++; v16++; w16++
-	u32++; v32++; w32++
-	u64++; v64++; w64++
-	up++; vp++; wp++
+	u++
+	v++
+	w++
+	u8++
+	v8++
+	w8++
+	u16++
+	v16++
+	w16++
+	u32++
+	v32++
+	w32++
+	u64++
+	v64++
+	w64++
+	up++
+	vp++
+	wp++
 
-	f += 1; g += 1; h += 1
-	f32 += 1; g32 += 1; h32 += 1
-	f64 += 1; g64 += 1; h64 += 1
+	f += 1
+	g += 1
+	h += 1
+	f32 += 1
+	g32 += 1
+	h32 += 1
+	f64 += 1
+	g64 += 1
+	h64 += 1
 
-	c += 1+1i; d += 1+1i; e += 1+1i
-	c64 += 1+1i; d64 += 1+1i; e64 += 1+1i
-	c128 += 1+1i; d128 += 1+1i; e128 += 1+1i
+	c += 1 + 1i
+	d += 1 + 1i
+	e += 1 + 1i
+	c64 += 1 + 1i
+	d64 += 1 + 1i
+	e64 += 1 + 1i
+	c128 += 1 + 1i
+	d128 += 1 + 1i
+	e128 += 1 + 1i
 }
 
 var tmp interface{}
@@ -79,52 +113,52 @@ func use(v interface{}) {
 // Verify error/no error for all types.
 var errorTests = []ErrorTest{
 	// All integer divide by zero should error.
-	ErrorTest{ "int 0/0", func() { use(i/j) }, "divide", },
-	ErrorTest{ "int8 0/0", func() { use(i8/j8) }, "divide", },
-	ErrorTest{ "int16 0/0", func() { use(i16/j16) }, "divide", },
-	ErrorTest{ "int32 0/0", func() { use(i32/j32) }, "divide", },
-	ErrorTest{ "int64 0/0", func() { use(i64/j64) }, "divide", },
+	ErrorTest{"int 0/0", func() { use(i / j) }, "divide"},
+	ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"},
+	ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"},
+	ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"},
+	ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"},
 
-	ErrorTest{ "int 1/0", func() { use(k/j) }, "divide", },
-	ErrorTest{ "int8 1/0", func() { use(k8/j8) }, "divide", },
-	ErrorTest{ "int16 1/0", func() { use(k16/j16) }, "divide", },
-	ErrorTest{ "int32 1/0", func() { use(k32/j32) }, "divide", },
-	ErrorTest{ "int64 1/0", func() { use(k64/j64) }, "divide", },
+	ErrorTest{"int 1/0", func() { use(k / j) }, "divide"},
+	ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"},
+	ErrorTest{"int16 1/0", func() { use(k16 / j16) }, "divide"},
+	ErrorTest{"int32 1/0", func() { use(k32 / j32) }, "divide"},
+	ErrorTest{"int64 1/0", func() { use(k64 / j64) }, "divide"},
 
-	ErrorTest{ "uint 0/0", func() { use(u/v) }, "divide", },
-	ErrorTest{ "uint8 0/0", func() { use(u8/v8) }, "divide", },
-	ErrorTest{ "uint16 0/0", func() { use(u16/v16) }, "divide", },
-	ErrorTest{ "uint32 0/0", func() { use(u32/v32) }, "divide", },
-	ErrorTest{ "uint64 0/0", func() { use(u64/v64) }, "divide", },
-	ErrorTest{ "uintptr 0/0", func() { use(up/vp) }, "divide", },
+	ErrorTest{"uint 0/0", func() { use(u / v) }, "divide"},
+	ErrorTest{"uint8 0/0", func() { use(u8 / v8) }, "divide"},
+	ErrorTest{"uint16 0/0", func() { use(u16 / v16) }, "divide"},
+	ErrorTest{"uint32 0/0", func() { use(u32 / v32) }, "divide"},
+	ErrorTest{"uint64 0/0", func() { use(u64 / v64) }, "divide"},
+	ErrorTest{"uintptr 0/0", func() { use(up / vp) }, "divide"},
 
-	ErrorTest{ "uint 1/0", func() { use(w/v) }, "divide", },
-	ErrorTest{ "uint8 1/0", func() { use(w8/v8) }, "divide", },
-	ErrorTest{ "uint16 1/0", func() { use(w16/v16) }, "divide", },
-	ErrorTest{ "uint32 1/0", func() { use(w32/v32) }, "divide", },
-	ErrorTest{ "uint64 1/0", func() { use(w64/v64) }, "divide", },
-	ErrorTest{ "uintptr 1/0", func() { use(wp/vp) }, "divide", },
+	ErrorTest{"uint 1/0", func() { use(w / v) }, "divide"},
+	ErrorTest{"uint8 1/0", func() { use(w8 / v8) }, "divide"},
+	ErrorTest{"uint16 1/0", func() { use(w16 / v16) }, "divide"},
+	ErrorTest{"uint32 1/0", func() { use(w32 / v32) }, "divide"},
+	ErrorTest{"uint64 1/0", func() { use(w64 / v64) }, "divide"},
+	ErrorTest{"uintptr 1/0", func() { use(wp / vp) }, "divide"},
 
-	// All floating divide by zero should not error.
-	ErrorTest{ "float 0/0", func() { use(f/g) }, "", },
-	ErrorTest{ "float32 0/0", func() { use(f32/g32) }, "", },
-	ErrorTest{ "float64 0/0", func() { use(f64/g64) }, "", },
+	// All float64ing divide by zero should not error.
+	ErrorTest{"float64 0/0", func() { use(f / g) }, ""},
+	ErrorTest{"float32 0/0", func() { use(f32 / g32) }, ""},
+	ErrorTest{"float64 0/0", func() { use(f64 / g64) }, ""},
 
-	ErrorTest{ "float 1/0", func() { use(h/g) }, "", },
-	ErrorTest{ "float32 1/0", func() { use(h32/g32) }, "", },
-	ErrorTest{ "float64 1/0", func() { use(h64/g64) }, "", },
-	ErrorTest{ "float64 inf/0", func() { use(inf/g64) }, "", },
-	ErrorTest{ "float64 -inf/0", func() { use(negInf/g64) }, "", },
-	ErrorTest{ "float64 nan/0", func() { use(nan/g64) }, "", },
+	ErrorTest{"float64 1/0", func() { use(h / g) }, ""},
+	ErrorTest{"float32 1/0", func() { use(h32 / g32) }, ""},
+	ErrorTest{"float64 1/0", func() { use(h64 / g64) }, ""},
+	ErrorTest{"float64 inf/0", func() { use(inf / g64) }, ""},
+	ErrorTest{"float64 -inf/0", func() { use(negInf / g64) }, ""},
+	ErrorTest{"float64 nan/0", func() { use(nan / g64) }, ""},
 
 	// All complex divide by zero should not error.
-	ErrorTest{ "complex 0/0", func() { use(c/d) }, "", },
-	ErrorTest{ "complex64 0/0", func() { use(c64/d64) }, "", },
-	ErrorTest{ "complex128 0/0", func() { use(c128/d128) }, "", },
+	ErrorTest{"complex 0/0", func() { use(c / d) }, ""},
+	ErrorTest{"complex64 0/0", func() { use(c64 / d64) }, ""},
+	ErrorTest{"complex128 0/0", func() { use(c128 / d128) }, ""},
 
-	ErrorTest{ "complex 1/0", func() { use(e/d) }, "", },
-	ErrorTest{ "complex64 1/0", func() { use(e64/d64) }, "", },
-	ErrorTest{ "complex128 1/0", func() { use(e128/d128) }, "", },
+	ErrorTest{"complex 1/0", func() { use(e / d) }, ""},
+	ErrorTest{"complex64 1/0", func() { use(e64 / d64) }, ""},
+	ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""},
 }
 
 func error(fn func()) (error string) {
@@ -137,12 +171,12 @@ func error(fn func()) (error string) {
 	return ""
 }
 
-type FloatTest struct{
-	f, g	float64
-	out	float64
+type FloatTest struct {
+	f, g float64
+	out  float64
 }
 
-var floatTests = []FloatTest{
+var float64Tests = []FloatTest{
 	FloatTest{0, 0, nan},
 	FloatTest{nan, 0, nan},
 	FloatTest{inf, 0, inf},
@@ -194,8 +228,8 @@ func main() {
 	}
 
 	// At this point we know we don't error on the values we're testing
-	for _, t := range floatTests {
-		x := t.f/t.g
+	for _, t := range float64Tests {
+		x := t.f / t.g
 		if !alike(x, t.out) {
 			if !bad {
 				bad = true