Imported Upstream version 2011-02-01.1upstream/2011-02-01.1

80 files changed, 4067 insertions, 3161 deletions

diff --git a/test/append.go b/test/append.go
index 17c665227..96421c36b 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 6e69f8aaa..681a5e77c 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/chan/doubleselect.go b/test/chan/doubleselect.go
index 592d2f54a..3c7412ed6 100644
--- a/test/chan/doubleselect.go
+++ b/test/chan/doubleselect.go
@@ -21,6 +21,8 @@ var iterations *int = flag.Int("n", 100000, "number of iterations")
 func sender(n int, c1, c2, c3, c4 chan<- int) {
 	defer close(c1)
 	defer close(c2)
+	defer close(c3)
+	defer close(c4)
 
 	for i := 0; i < n; i++ {
 		select {
@@ -35,26 +37,18 @@ func sender(n int, c1, c2, c3, c4 chan<- int) {
 // mux receives the values from sender and forwards them onto another channel.
 // It would be simplier to just have sender's four cases all be the same
 // channel, but this doesn't actually trigger the bug.
-func mux(out chan<- int, in <-chan int) {
-	for {
-		v := <-in
-		if closed(in) {
-			close(out)
-			break
-		}
+func mux(out chan<- int, in <-chan int, done chan<- bool) {
+	for v := range in {
 		out <- v
 	}
+	done <- true
 }
 
 // recver gets a steam of values from the four mux's and checks for duplicates.
 func recver(in <-chan int) {
 	seen := make(map[int]bool)
 
-	for {
-		v := <-in
-		if closed(in) {
-			break
-		}
+	for v := range in {
 		if _, ok := seen[v]; ok {
 			println("got duplicate value: ", v)
 			panic("fail")
@@ -70,15 +64,23 @@ func main() {
 	c2 := make(chan int)
 	c3 := make(chan int)
 	c4 := make(chan int)
+	done := make(chan bool)
 	cmux := make(chan int)
 	go sender(*iterations, c1, c2, c3, c4)
-	go mux(cmux, c1)
-	go mux(cmux, c2)
-	go mux(cmux, c3)
-	go mux(cmux, c4)
+	go mux(cmux, c1, done)
+	go mux(cmux, c2, done)
+	go mux(cmux, c3, done)
+	go mux(cmux, c4, done)
+	go func() {
+		<-done
+		<-done
+		<-done
+		<-done
+		close(cmux)
+	}()
 	// We keep the recver because it might catch more bugs in the future.
 	// However, the result of the bug linked to at the top is that we'll
-	// end up panicing with: "throw: bad g->status in ready".
+	// end up panicking with: "throw: bad g->status in ready".
 	recver(cmux)
 	print("PASS\n")
 }
diff --git a/test/chan/nonblock.go b/test/chan/nonblock.go
index 52f04bfb1..33afb3291 100644
--- a/test/chan/nonblock.go
+++ b/test/chan/nonblock.go
@@ -76,7 +76,6 @@ func main() {
 	var i64 int64
 	var b bool
 	var s string
-	var ok bool
 
 	var sync = make(chan bool)
 
@@ -86,35 +85,45 @@ func main() {
 		cb := make(chan bool, buffer)
 		cs := make(chan string, buffer)
 
-		i32, ok = <-c32
-		if ok {
+		select {
+		case i32 = <-c32:
 			panic("blocked i32sender")
+		default:
 		}
 
-		i64, ok = <-c64
-		if ok {
+		select {
+		case i64 = <-c64:
 			panic("blocked i64sender")
+		default:
 		}
 
-		b, ok = <-cb
-		if ok {
+		select {
+		case b = <-cb:
 			panic("blocked bsender")
+		default:
 		}
 
-		s, ok = <-cs
-		if ok {
+		select {
+		case s = <-cs:
 			panic("blocked ssender")
+		default:
 		}
 
 		go i32receiver(c32, sync)
 		try := 0
-		for !(c32 <- 123) {
-			try++
-			if try > maxTries {
-				println("i32receiver buffer=", buffer)
-				panic("fail")
+	Send32:
+		for {
+			select {
+			case c32 <- 123:
+				break Send32
+			default:
+				try++
+				if try > maxTries {
+					println("i32receiver buffer=", buffer)
+					panic("fail")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		<-sync
 
@@ -123,13 +132,19 @@ func main() {
 			<-sync
 		}
 		try = 0
-		for i32, ok = <-c32; !ok; i32, ok = <-c32 {
-			try++
-			if try > maxTries {
-				println("i32sender buffer=", buffer)
-				panic("fail")
+	Recv32:
+		for {
+			select {
+			case i32 = <-c32:
+				break Recv32
+			default:
+				try++
+				if try > maxTries {
+					println("i32sender buffer=", buffer)
+					panic("fail")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		if i32 != 234 {
 			panic("i32sender value")
@@ -140,12 +155,18 @@ func main() {
 
 		go i64receiver(c64, sync)
 		try = 0
-		for !(c64 <- 123456) {
-			try++
-			if try > maxTries {
-				panic("i64receiver")
+	Send64:
+		for {
+			select {
+			case c64 <- 123456:
+				break Send64
+			default:
+				try++
+				if try > maxTries {
+					panic("i64receiver")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		<-sync
 
@@ -154,12 +175,18 @@ func main() {
 			<-sync
 		}
 		try = 0
-		for i64, ok = <-c64; !ok; i64, ok = <-c64 {
-			try++
-			if try > maxTries {
-				panic("i64sender")
+	Recv64:
+		for {
+			select {
+			case i64 = <-c64:
+				break Recv64
+			default:
+				try++
+				if try > maxTries {
+					panic("i64sender")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		if i64 != 234567 {
 			panic("i64sender value")
@@ -170,12 +197,18 @@ func main() {
 
 		go breceiver(cb, sync)
 		try = 0
-		for !(cb <- true) {
-			try++
-			if try > maxTries {
-				panic("breceiver")
+	SendBool:
+		for {
+			select {
+			case cb <- true:
+				break SendBool
+			default:
+				try++
+				if try > maxTries {
+					panic("breceiver")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		<-sync
 
@@ -184,12 +217,18 @@ func main() {
 			<-sync
 		}
 		try = 0
-		for b, ok = <-cb; !ok; b, ok = <-cb {
-			try++
-			if try > maxTries {
-				panic("bsender")
+	RecvBool:
+		for {
+			select {
+			case b = <-cb:
+				break RecvBool
+			default:
+				try++
+				if try > maxTries {
+					panic("bsender")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		if !b {
 			panic("bsender value")
@@ -200,12 +239,18 @@ func main() {
 
 		go sreceiver(cs, sync)
 		try = 0
-		for !(cs <- "hello") {
-			try++
-			if try > maxTries {
-				panic("sreceiver")
+	SendString:
+		for {
+			select {
+			case cs <- "hello":
+				break SendString
+			default:
+				try++
+				if try > maxTries {
+					panic("sreceiver")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		<-sync
 
@@ -214,12 +259,18 @@ func main() {
 			<-sync
 		}
 		try = 0
-		for s, ok = <-cs; !ok; s, ok = <-cs {
-			try++
-			if try > maxTries {
-				panic("ssender")
+	RecvString:
+		for {
+			select {
+			case s = <-cs:
+				break RecvString
+			default:
+				try++
+				if try > maxTries {
+					panic("ssender")
+				}
+				sleep()
 			}
-			sleep()
 		}
 		if s != "hello again" {
 			panic("ssender value")
diff --git a/test/chan/perm.go b/test/chan/perm.go
index d08c03519..c725829d1 100644
--- a/test/chan/perm.go
+++ b/test/chan/perm.go
@@ -9,49 +9,46 @@ package main
 var (
 	cr <-chan int
 	cs chan<- int
-	c chan int
+	c  chan int
 )
 
 func main() {
-	cr = c		// ok
-	cs = c		// ok
-	c = cr		// ERROR "illegal types|incompatible|cannot"
-	c = cs		// ERROR "illegal types|incompatible|cannot"
-	cr = cs	// ERROR "illegal types|incompatible|cannot"
-	cs = cr	// ERROR "illegal types|incompatible|cannot"
-
-	c <- 0		// ok
-	ok := c <- 0	// ok
-	_ = ok
-	<-c		// ok
-	x, ok := <-c	// ok
-	_, _ = x, ok
-
-	cr <- 0	// ERROR "send"
-	ok = cr <- 0	// ERROR "send"
-	_ = ok
-	<-cr		// ok
-	x, ok = <-cr	// ok
-	_, _ = x, ok
-
-	cs <- 0	// ok
-	ok = cs <- 0	// ok
-	_ = ok
-	<-cs		// ERROR "receive"
-	x, ok = <-cs	// ERROR "receive"
-	_, _ = x, ok
+	cr = c  // ok
+	cs = c  // ok
+	c = cr  // ERROR "illegal types|incompatible|cannot"
+	c = cs  // ERROR "illegal types|incompatible|cannot"
+	cr = cs // ERROR "illegal types|incompatible|cannot"
+	cs = cr // ERROR "illegal types|incompatible|cannot"
+
+	c <- 0 // ok
+	<-c    // ok
+	//TODO(rsc): uncomment when this syntax is valid for receive+check closed
+	//	x, ok := <-c	// ok
+	//	_, _ = x, ok
+
+	cr <- 0 // ERROR "send"
+	<-cr    // ok
+	//TODO(rsc): uncomment when this syntax is valid for receive+check closed
+	//	x, ok = <-cr	// ok
+	//	_, _ = x, ok
+
+	cs <- 0 // ok
+	<-cs    // ERROR "receive"
+	////TODO(rsc): uncomment when this syntax is valid for receive+check closed
+	////	x, ok = <-cs	// ERROR "receive"
+	////	_, _ = x, ok
 
 	select {
-	case c <- 0:	// ok
-	case x := <-c:	// ok
+	case c <- 0: // ok
+	case x := <-c: // ok
 		_ = x
 
-	case cr <- 0:	// ERROR "send"
-	case x := <-cr:	// ok
+	case cr <- 0: // ERROR "send"
+	case x := <-cr: // ok
 		_ = x
 
-	case cs <- 0:	// ok
-	case x := <-cs:	// ERROR "receive"
+	case cs <- 0: // ok
+	case x := <-cs: // ERROR "receive"
 		_ = x
 	}
 }
diff --git a/test/chan/select3.go b/test/chan/select3.go
index a1a2ef50b..47941063c 100644
--- a/test/chan/select3.go
+++ b/test/chan/select3.go
@@ -97,13 +97,9 @@ func main() {
 		}
 	})
 
-	// sending (a small number of times) to a closed channel is not specified
-	// but the current implementation doesn't block: test that different
-	// implementations behave the same
-	testBlock(never, func() {
-		for i := 0; i < 10; i++ {
-			closedch <- 7
-		}
+	// sending to a closed channel panics.
+	testPanic(always, func() {
+		closedch <- 7
 	})
 
 	// receiving from a non-ready channel always blocks
@@ -189,15 +185,24 @@ func main() {
 		}
 	})
 
-	// selects with closed channels don't block
+	// selects with closed channels behave like ordinary operations
 	testBlock(never, func() {
 		select {
 		case <-closedch:
 		}
 	})
-	testBlock(never, func() {
+	testPanic(always, func() {
 		select {
 		case closedch <- 7:
 		}
 	})
+	
+	// select should not get confused if it sees itself
+	testBlock(always, func() {
+		c := make(chan int)
+		select {
+		case c <- 1:
+		case <-c:
+		}
+	})
 }
diff --git a/test/chan/select5.go b/test/chan/select5.go
new file mode 100644
index 000000000..0678b8dab
--- /dev/null
+++ b/test/chan/select5.go
@@ -0,0 +1,482 @@
+// $G $D/$F.go && $L $F.$A && ./$A.out >tmp.go &&
+// $G tmp.go && $L tmp.$A && ./$A.out || echo BUG: select5
+// rm -f tmp.go
+
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Generate test of channel operations and simple selects.
+// Only doing one real send or receive at a time, but phrased
+// in various ways that the compiler may or may not rewrite
+// into simpler expressions.
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"template"
+)
+
+func main() {
+	out := bufio.NewWriter(os.Stdout)
+	fmt.Fprintln(out, header)
+	a := new(arg)
+
+	// Generate each kind of test as a separate function to avoid
+	// hitting the 6g optimizer with one enormous function.
+	// If we name all the functions init we don't have to
+	// maintain a list of which ones to run.
+	do := func(t *template.Template) {
+		fmt.Fprintln(out, `func init() {`)
+		for ; next(); a.reset() {
+			run(t, a, out)
+		}
+		fmt.Fprintln(out, `}`)
+	}
+	
+	do(recv)
+	do(send)
+	do(recvOrder)
+	do(sendOrder)
+	do(nonblock)
+
+	fmt.Fprintln(out, "//", a.nreset, "cases")
+	out.Flush()
+}
+
+func run(t *template.Template, a interface{}, out io.Writer) {
+	if err := t.Execute(a, out); err != nil {
+		panic(err)
+	}
+}
+
+type arg struct{
+	def bool
+	nreset int
+}
+
+func (a *arg) Maybe() bool {
+	return maybe()
+}
+
+func (a *arg) MaybeDefault() bool {
+	if a.def {
+		return false
+	}
+	a.def = maybe()
+	return a.def
+}
+
+func (a *arg) MustDefault() bool {
+	return !a.def
+}
+
+func (a *arg) reset() {
+	a.def = false
+	a.nreset++
+}
+
+const header = `// GENERATED BY select5.go; DO NOT EDIT
+
+package main
+
+// channel is buffered so test is single-goroutine.
+// we are not interested in the concurrency aspects
+// of select, just testing that the right calls happen.
+var c = make(chan int, 1)
+var nilch chan int
+var n = 1
+var x int
+var i interface{}
+var dummy = make(chan int)
+var m = make(map[int]int)
+var order = 0
+
+func f(p *int) *int {
+	return p
+}
+
+// check order of operations by ensuring that
+// successive calls to checkorder have increasing o values.
+func checkorder(o int) {
+	if o <= order {
+		println("invalid order", o, "after", order)
+		panic("order")
+	}
+	order = o
+}
+
+func fc(c chan int, o int) chan int {
+	checkorder(o)
+	return c
+}
+
+func fp(p *int, o int) *int {
+	checkorder(o)
+	return p
+}
+
+func fn(n, o int) int {
+	checkorder(o)
+	return n
+}
+
+func die(x int) {
+	println("have", x, "want", n)
+	panic("chan")
+}
+
+func main() {
+	// everything happens in init funcs
+}
+`
+
+func parse(s string) *template.Template {
+	t := template.New(nil)
+	t.SetDelims("〈", "〉")
+	if err := t.Parse(s); err != nil {
+		panic(s)
+	}
+	return t
+}
+
+var recv = parse(`
+	〈# Send n, receive it one way or another into x, check that they match.〉
+	c <- n
+	〈.section Maybe〉
+	x = <-c
+	〈.or〉
+	select {
+	〈# Blocking or non-blocking, before the receive.〉
+	〈# The compiler implements two-case select where one is default with custom code,〉
+	〈# so test the default branch both before and after the send.〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Receive from c.  Different cases are direct, indirect, :=, interface, and map assignment.〉
+	〈.section Maybe〉
+	case x = <-c:
+	〈.or〉〈.section Maybe〉
+	case *f(&x) = <-c:
+	〈.or〉〈.section Maybe〉
+	case y := <-c:
+		x = y
+	〈.or〉〈.section Maybe〉
+	case i = <-c:
+		x = i.(int)
+	〈.or〉
+	case m[13] = <-c:
+		x = m[13]
+	〈.end〉〈.end〉〈.end〉〈.end〉
+	〈# Blocking or non-blocking again, after the receive.〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Dummy send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case dummy <- 1:
+		panic("dummy send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-dummy:
+		panic("dummy receive")
+	〈.end〉
+	〈# Nil channel send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case nilch <- 1:
+		panic("nilch send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-nilch:
+		panic("nilch recv")
+	〈.end〉
+	}
+	〈.end〉
+	if x != n {
+		die(x)
+	}
+	n++
+`)
+
+var recvOrder = parse(`
+	〈# Send n, receive it one way or another into x, check that they match.〉
+	〈# Check order of operations along the way by calling functions that check〉
+	〈# that the argument sequence is strictly increasing.〉
+	order = 0
+	c <- n
+	〈.section Maybe〉
+	〈# Outside of select, left-to-right rule applies.〉
+	〈# (Inside select, assignment waits until case is chosen,〉
+	〈# so right hand side happens before anything on left hand side.〉
+	*fp(&x, 1) = <-fc(c, 2)
+	〈.or〉〈.section Maybe〉
+	m[fn(13, 1)] = <-fc(c, 2)
+	x = m[13]
+	〈.or〉
+	select {
+	〈# Blocking or non-blocking, before the receive.〉
+	〈# The compiler implements two-case select where one is default with custom code,〉
+	〈# so test the default branch both before and after the send.〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Receive from c.  Different cases are direct, indirect, :=, interface, and map assignment.〉
+	〈.section Maybe〉
+	case *fp(&x, 100) = <-fc(c, 1):
+	〈.or〉〈.section Maybe〉
+	case y := <-fc(c, 1):
+		x = y
+	〈.or〉〈.section Maybe〉
+	case i = <-fc(c, 1):
+		x = i.(int)
+	〈.or〉
+	case m[fn(13, 100)] = <-fc(c, 1):
+		x = m[13]
+	〈.end〉〈.end〉〈.end〉
+	〈# Blocking or non-blocking again, after the receive.〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Dummy send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case fc(dummy, 2) <- fn(1, 3):
+		panic("dummy send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-fc(dummy, 4):
+		panic("dummy receive")
+	〈.end〉
+	〈# Nil channel send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case fc(nilch, 5) <- fn(1, 6):
+		panic("nilch send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-fc(nilch, 7):
+		panic("nilch recv")
+	〈.end〉
+	}
+	〈.end〉〈.end〉
+	if x != n {
+		die(x)
+	}
+	n++
+`)
+
+var send = parse(`
+	〈# Send n one way or another, receive it into x, check that they match.〉
+	〈.section Maybe〉
+	c <- n
+	〈.or〉
+	select {
+	〈# Blocking or non-blocking, before the receive (same reason as in recv).〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Send c <- n.  No real special cases here, because no values come back〉
+	〈# from the send operation.〉
+	case c <- n:
+	〈# Blocking or non-blocking.〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Dummy send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case dummy <- 1:
+		panic("dummy send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-dummy:
+		panic("dummy receive")
+	〈.end〉
+	〈# Nil channel send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case nilch <- 1:
+		panic("nilch send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-nilch:
+		panic("nilch recv")
+	〈.end〉
+	}
+	〈.end〉
+	x = <-c
+	if x != n {
+		die(x)
+	}
+	n++
+`)
+
+var sendOrder = parse(`
+	〈# Send n one way or another, receive it into x, check that they match.〉
+	〈# Check order of operations along the way by calling functions that check〉
+	〈# that the argument sequence is strictly increasing.〉
+	order = 0
+	〈.section Maybe〉
+	fc(c, 1) <- fn(n, 2)
+	〈.or〉
+	select {
+	〈# Blocking or non-blocking, before the receive (same reason as in recv).〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Send c <- n.  No real special cases here, because no values come back〉
+	〈# from the send operation.〉
+	case fc(c, 1) <- fn(n, 2):
+	〈# Blocking or non-blocking.〉
+	〈.section MaybeDefault〉
+	default:
+		panic("nonblock")
+	〈.end〉
+	〈# Dummy send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case fc(dummy, 3) <- fn(1, 4):
+		panic("dummy send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-fc(dummy, 5):
+		panic("dummy receive")
+	〈.end〉
+	〈# Nil channel send, receive to keep compiler from optimizing select.〉
+	〈.section Maybe〉
+	case fc(nilch, 6) <- fn(1, 7):
+		panic("nilch send")
+	〈.end〉
+	〈.section Maybe〉
+	case <-fc(nilch, 8):
+		panic("nilch recv")
+	〈.end〉
+	}
+	〈.end〉
+	x = <-c
+	if x != n {
+		die(x)
+	}
+	n++
+`)
+
+var nonblock = parse(`
+	x = n
+	〈# Test various combinations of non-blocking operations.〉
+	〈# Receive assignments must not edit or even attempt to compute the address of the lhs.〉
+	select {
+	〈.section MaybeDefault〉
+	default:
+	〈.end〉
+	〈.section Maybe〉
+	case dummy <- 1:
+		panic("dummy <- 1")
+	〈.end〉
+	〈.section Maybe〉
+	case nilch <- 1:
+		panic("nilch <- 1")
+	〈.end〉
+	〈.section Maybe〉
+	case <-dummy:
+		panic("<-dummy")
+	〈.end〉
+	〈.section Maybe〉
+	case x = <-dummy:
+		panic("<-dummy x")
+	〈.end〉
+	〈.section Maybe〉
+	case **(**int)(nil) = <-dummy:
+		panic("<-dummy (and didn't crash saving result!)")
+	〈.end〉
+	〈.section Maybe〉
+	case <-nilch:
+		panic("<-nilch")
+	〈.end〉
+	〈.section Maybe〉
+	case x = <-nilch:
+		panic("<-nilch x")
+	〈.end〉
+	〈.section Maybe〉
+	case **(**int)(nil) = <-nilch:
+		panic("<-nilch (and didn't crash saving result!)")
+	〈.end〉
+	〈.section MustDefault〉
+	default:
+	〈.end〉
+	}
+	if x != n {
+		die(x)
+	}
+	n++
+`)
+
+// Code for enumerating all possible paths through
+// some logic.  The logic should call choose(n) when
+// it wants to choose between n possibilities.
+// On successive runs through the logic, choose(n)
+// will return 0, 1, ..., n-1.  The helper maybe() is
+// similar but returns true and then false.
+//
+// Given a function gen that generates an output
+// using choose and maybe, code can generate all
+// possible outputs using
+//
+//	for next() {
+//		gen()
+//	}
+
+type choice struct {
+	i, n int
+}
+
+var choices []choice
+var cp int = -1
+
+func maybe() bool {
+	return choose(2) == 0
+}
+
+func choose(n int) int {
+	if cp >= len(choices) {
+		// never asked this before: start with 0.
+		choices = append(choices, choice{0, n})
+		cp = len(choices)
+		return 0
+	}
+	// otherwise give recorded answer
+	if n != choices[cp].n {
+		panic("inconsistent choices")
+	}
+	i := choices[cp].i
+	cp++
+	return i
+}
+
+func next() bool {
+	if cp < 0 {
+		// start a new round
+		cp = 0
+		return true
+	}
+
+	// increment last choice sequence
+	cp = len(choices)-1
+	for cp >= 0 && choices[cp].i == choices[cp].n-1 {
+		cp--
+	}
+	if cp < 0 {
+		choices = choices[:0]
+		return false
+	}
+	choices[cp].i++
+	choices = choices[:cp+1]
+	cp = 0
+	return true
+}
+
diff --git a/test/chan/sendstmt.go b/test/chan/sendstmt.go
new file mode 100644
index 000000000..ee6f765cf
--- /dev/null
+++ b/test/chan/sendstmt.go
@@ -0,0 +1,37 @@
+// $G $D/$F.go && $L $F.$A && ./$A.out
+
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test various parsing cases that are a little
+// different now that send is a statement, not a expression.
+
+package main
+
+func main() {
+	chanchan()
+	sendprec()
+}
+
+func chanchan() {
+	cc := make(chan chan int, 1)
+	c := make(chan int, 1)
+	cc <- c
+	select {
+	case <-cc <- 2:
+	default:
+		panic("nonblock")
+	}
+	if <-c != 2 {
+		panic("bad receive")
+	}
+}
+
+func sendprec() {
+	c := make(chan bool, 1)
+	c <- false || true	// not a syntax error: same as c <- (false || true)
+	if !<-c {
+		panic("sent false")
+	}
+}
diff --git a/test/closedchan.go b/test/closedchan.go
index c7c759be3..46d9d0f5d 100644
--- a/test/closedchan.go
+++ b/test/closedchan.go
@@ -21,14 +21,21 @@ type Chan interface {
 	Impl() string
 }
 
-// direct channel operations
+// direct channel operations when possible
 type XChan chan int
+
 func (c XChan) Send(x int) {
 	c <- x
 }
 
 func (c XChan) Nbsend(x int) bool {
-	return c <- x
+	select {
+	case c <- x:
+		return true
+	default:
+		return false
+	}
+	panic("nbsend")
 }
 
 func (c XChan) Recv() int {
@@ -36,8 +43,13 @@ func (c XChan) Recv() int {
 }
 
 func (c XChan) Nbrecv() (int, bool) {
-	x, ok := <-c
-	return x, ok
+	select {
+	case x := <-c:
+		return x, true
+	default:
+		return 0, false
+	}
+	panic("nbrecv")
 }
 
 func (c XChan) Close() {
@@ -54,6 +66,7 @@ func (c XChan) Impl() string {
 
 // indirect operations via select
 type SChan chan int
+
 func (c SChan) Send(x int) {
 	select {
 	case c <- x:
@@ -62,10 +75,10 @@ func (c SChan) Send(x int) {
 
 func (c SChan) Nbsend(x int) bool {
 	select {
-	case c <- x:
-		return true
 	default:
 		return false
+	case c <- x:
+		return true
 	}
 	panic("nbsend")
 }
@@ -80,10 +93,10 @@ func (c SChan) Recv() int {
 
 func (c SChan) Nbrecv() (int, bool) {
 	select {
-	case x := <-c:
-		return x, true
 	default:
 		return 0, false
+	case x := <-c:
+		return x, true
 	}
 	panic("nbrecv")
 }
@@ -100,6 +113,71 @@ func (c SChan) Impl() string {
 	return "(select)"
 }
 
+// indirect operations via larger selects
+var dummy = make(chan bool)
+
+type SSChan chan int
+
+func (c SSChan) Send(x int) {
+	select {
+	case c <- x:
+	case <-dummy:
+	}
+}
+
+func (c SSChan) Nbsend(x int) bool {
+	select {
+	default:
+		return false
+	case <-dummy:
+	case c <- x:
+		return true
+	}
+	panic("nbsend")
+}
+
+func (c SSChan) Recv() int {
+	select {
+	case <-dummy:
+	case x := <-c:
+		return x
+	}
+	panic("recv")
+}
+
+func (c SSChan) Nbrecv() (int, bool) {
+	select {
+	case <-dummy:
+	default:
+		return 0, false
+	case x := <-c:
+		return x, true
+	}
+	panic("nbrecv")
+}
+
+func (c SSChan) Close() {
+	close(c)
+}
+
+func (c SSChan) Closed() bool {
+	return closed(c)
+}
+
+func (c SSChan) Impl() string {
+	return "(select)"
+}
+
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("did not panic")
+		}
+	}()
+	f()
+}
+
 func test1(c Chan) {
 	// not closed until the close signal (a zero value) has been received.
 	if c.Closed() {
@@ -128,18 +206,15 @@ func test1(c Chan) {
 	}
 
 	// send should work with ,ok too: sent a value without blocking, so ok == true.
-	ok := c.Nbsend(1)
-	if !ok {
-		println("test1: send on closed got not ok", c.Impl())
-	}
+	shouldPanic(func() { c.Nbsend(1) })
 
-	// but the value should have been discarded.
+	// the value should have been discarded.
 	if x := c.Recv(); x != 0 {
 		println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
 	}
 
 	// similarly Send.
-	c.Send(2)
+	shouldPanic(func() { c.Send(2) })
 	if x := c.Recv(); x != 0 {
 		println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
 	}
@@ -189,9 +264,12 @@ func closedasync() chan int {
 func main() {
 	test1(XChan(closedsync()))
 	test1(SChan(closedsync()))
+	test1(SSChan(closedsync()))
 
 	testasync1(XChan(closedasync()))
 	testasync1(SChan(closedasync()))
+	testasync1(SSChan(closedasync()))
 	testasync2(XChan(closedasync()))
 	testasync2(SChan(closedasync()))
+	testasync2(SSChan(closedasync()))
 }
diff --git a/test/cmp6.go b/test/cmp6.go
index 981a85953..4c0601187 100644
--- a/test/cmp6.go
+++ b/test/cmp6.go
@@ -11,6 +11,10 @@ func use(bool) {}
 type T1 *int
 type T2 *int
 
+type T3 struct {}
+
+var t3 T3
+
 func main() {
 	// Arguments to comparison must be
 	// assignable one to the other (or vice versa)
@@ -39,4 +43,7 @@ func main() {
 	use(p2 == p2)
 	use(p3 == p1)
 	use(p3 == p2)
+	
+	// Comparison of structs should have a good message
+	use(t3 == t3)	// ERROR "struct"
 }
diff --git a/test/cmplx.go b/test/cmplx.go
index fad96c605..d5a77d684 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 b3c6055ed..b340f04d8 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 96ea704a3..6a1dee9fe 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 f3b7c9abe..f5f7aca9d 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 cf07055cf..67f36e4fd 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 94889d4a9..90ac5490c 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 c31082bcf..95b6346c3 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 269ebdefb..5e5e14501 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/errchk b/test/errchk
index b0edd7a6b..fbb021ce4 100755
--- a/test/errchk
+++ b/test/errchk
@@ -73,6 +73,7 @@ sub chk {
 	my @match;
 	foreach my $src (@{$src{$file}}) {
 		$line++;
+		next if $src =~ m|////|;  # double comment disables ERROR
 		next unless $src =~ m|// (GC_)?ERROR (.*)|;
 		$regexp = $2;
 		if($regexp !~ /^"([^"]*)"/) {
diff --git a/test/fixedbugs/bug006.go b/test/fixedbugs/bug006.go
index e7694f95b..43b5dfb12 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 bd970de5f..d65f6da45 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 e71c4d7f0..7d96988d4 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 551adb77d..ce627472c 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/bug016.go b/test/fixedbugs/bug016.go
index 461bcf82a..1cdd8df08 100644
--- a/test/fixedbugs/bug016.go
+++ b/test/fixedbugs/bug016.go
@@ -1,4 +1,4 @@
-// ! $G $D/$F.go
+// errchk $G -e $D/$F.go
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,8 +7,8 @@
 package main
 
 func main() {
-	var i int = 100;
-	i = i << -3;  // BUG: should not compile (negative shift)
+	var i int = 100
+	i = i << -3 // ERROR "overflows"
 }
 
 /*
diff --git a/test/fixedbugs/bug035.go b/test/fixedbugs/bug035.go
index 461c0607a..bd2a633f2 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 f3749e739..5a776abce 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/bug069.go b/test/fixedbugs/bug069.go
index d6796cd72..bf7316313 100644
--- a/test/fixedbugs/bug069.go
+++ b/test/fixedbugs/bug069.go
@@ -6,15 +6,16 @@
 
 package main
 
-func main(){
-	c := make(chan int);
-	ok := false;
-	var i int;
-
-	i, ok = <-c;  // works
-	_, _ = i, ok;
-
-	ca := new([2]chan int);
-	i, ok = <-(ca[0]);  // fails: c.go:11: bad shape across assignment - cr=1 cl=2
-	_, _ = i, ok;
+func main() {
+	//TODO(rsc): uncomment when this syntax is valid for receive+check closed
+	//	c := make(chan int);
+	//	ok := false;
+	//	var i int;
+	//
+	//	i, ok = <-c;  // works
+	//	_, _ = i, ok;
+	//
+	//	ca := new([2]chan int);
+	//	i, ok = <-(ca[0]);  // fails: c.go:11: bad shape across assignment - cr=1 cl=2
+	//	_, _ = i, ok;
 }
diff --git a/test/fixedbugs/bug080.go b/test/fixedbugs/bug080.go
index a5003d29b..bae16cdb2 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/bug081.go b/test/fixedbugs/bug081.go
index ccb369953..8d3d538c8 100644
--- a/test/fixedbugs/bug081.go
+++ b/test/fixedbugs/bug081.go
@@ -1,12 +1,12 @@
-// ! $G $D/$F.go
+// errchk $G $D/$F.go
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package main	
- 	
-const x x = 2;
+package main
+
+const x x = 2 // ERROR "loop"
 
 /*
 bug081.go:3: first constant must evaluate an expression
diff --git a/test/fixedbugs/bug109.go b/test/fixedbugs/bug109.go
index c679771f2..766657723 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 729299b66..33eb3cb1a 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 f6b03e13d..5ef02b1c1 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/bug196.go b/test/fixedbugs/bug196.go
index ea8ab0dc1..8cb9c9990 100644
--- a/test/fixedbugs/bug196.go
+++ b/test/fixedbugs/bug196.go
@@ -13,11 +13,12 @@ var i int
 func multi() (int, int) { return 1, 2 }
 
 func xxx() {
-	var c chan int
-	x, ok := <-c
+	//TODO(rsc): uncomment when this syntax is valid for receive+check closed
+	//	var c chan int
+	//	x, ok := <-c
 
 	var m map[int]int
-	x, ok = m[1]
+	x, ok := m[1]
 
 	var i interface{}
 	var xx int
diff --git a/test/fixedbugs/bug220.go b/test/fixedbugs/bug220.go
index 3f8aaa4ec..ff027ddc2 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 81b256e31..c7ad1a366 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/bug234.go b/test/fixedbugs/bug234.go
index b806ca64e..9affad043 100644
--- a/test/fixedbugs/bug234.go
+++ b/test/fixedbugs/bug234.go
@@ -7,16 +7,17 @@
 package main
 
 func main() {
-	c := make(chan int, 1)
-	c <- 100
-	x, ok := <-c
-	if x != 100 || !ok {
-		println("x=", x, " ok=", ok, " want 100, true")
-		panic("fail")
-	}
-	x, ok = <-c
-	if x != 0 || ok {
-		println("x=", x, " ok=", ok, " want 0, false")
-		panic("fail")
-	}
+	//TODO(rsc): uncomment when this syntax is valid for receive+check closed
+	//	c := make(chan int, 1)
+	//	c <- 100
+	//	x, ok := <-c
+	//	if x != 100 || !ok {
+	//		println("x=", x, " ok=", ok, " want 100, true")
+	//		panic("fail")
+	//	}
+	//	x, ok = <-c
+	//	if x != 0 || ok {
+	//		println("x=", x, " ok=", ok, " want 0, false")
+	//		panic("fail")
+	//	}
 }
diff --git a/test/fixedbugs/bug238.go b/test/fixedbugs/bug238.go
index 8b7c7ac38..7e8660d37 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/bug242.go b/test/fixedbugs/bug242.go
index 5c21eaaf0..ad1cef8df 100644
--- a/test/fixedbugs/bug242.go
+++ b/test/fixedbugs/bug242.go
@@ -101,10 +101,13 @@ func main() {
 
 	c := make(chan byte, 1)
 	c <- 'C'
+	//TODO(rsc): uncomment when this syntax is valid for receive+check closed
 	// 15          16
-	*f(), p1 = <-e1(c, 16)
+	//	*f(), p1 = <-e1(c, 16)
+	*f(), p1 = <-e1(c, 16), true // delete uncommenting above
 	// 17          18
-	*f(), p2 = <-e1(c, 18)
+	//	*f(), p2 = <-e1(c, 18)
+	*f(), p2, _ = 0, false, e1(c, 18) // delete when uncommenting above
 	a[17] += '0'
 	if !p1 || p2 {
 		println("bad chan check", i, p1, p2)
diff --git a/test/fixedbugs/bug248.dir/bug2.go b/test/fixedbugs/bug248.dir/bug2.go
index 68c0ce0bc..4ea187a4b 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 c96bf1676..e5a244955 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 4d7314432..1c7adb5f5 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 a1a30dfb7..1b42c09ab 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 198bae77a..c59ef29e6 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 bd4d99eb6..2146408a1 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/fixedbugs/bug318.go b/test/fixedbugs/bug318.go
new file mode 100644
index 000000000..9c46a0426
--- /dev/null
+++ b/test/fixedbugs/bug318.go
@@ -0,0 +1,12 @@
+// errchk $G $D/$F.go
+
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Issue 1411.
+
+package main
+
+const ui uint = 0
+const i int = ui // ERROR "type"
diff --git a/test/fixedbugs/bug319.go b/test/fixedbugs/bug319.go
new file mode 100644
index 000000000..f60eee4fb
--- /dev/null
+++ b/test/fixedbugs/bug319.go
@@ -0,0 +1,22 @@
+// $G $D/$F.go
+
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "unsafe"
+
+func main() {
+	var x int
+	
+	a := uint64(uintptr(unsafe.Pointer(&x)))
+	b := uint32(uintptr(unsafe.Pointer(&x)))
+	c := uint16(uintptr(unsafe.Pointer(&x)))
+	d := int64(uintptr(unsafe.Pointer(&x)))
+	e := int32(uintptr(unsafe.Pointer(&x)))
+	f := int16(uintptr(unsafe.Pointer(&x)))
+
+	_, _, _, _, _, _ = a, b, c, d, e, f
+}
diff --git a/test/func.go b/test/func.go
index 0c1a07979..e8ed928bc 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 56f4dfcba..056ff9877 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/garbage/Makefile b/test/garbage/Makefile
index ab29e0956..e83384382 100644
--- a/test/garbage/Makefile
+++ b/test/garbage/Makefile
@@ -11,8 +11,8 @@ ALL=\
 
 all: $(addsuffix .out, $(ALL))
 
-%.$O: %.go
-	$(GC) $*.go
+%.$O: %.go stats.go
+	$(GC) $*.go stats.go
 
 %.out: %.$O
 	$(LD) -o $@ $*.$O
diff --git a/test/garbage/parser.go b/test/garbage/parser.go
index cf68737fb..19a96bc63 100644
--- a/test/garbage/parser.go
+++ b/test/garbage/parser.go
@@ -11,13 +11,19 @@ import (
 	"fmt"
 	"go/ast"
 	"go/parser"
+	"go/token"
 	"os"
 	"path"
 	"runtime"
 	"strings"
 	"time"
+	"http"
+	_ "http/pprof"
+	"log"
 )
 
+var serve = flag.String("serve", "", "serve http on this address at end")
+
 func isGoFile(dir *os.FileInfo) bool {
 	return dir.IsRegular() &&
 		!strings.HasPrefix(dir.Name, ".") && // ignore .files
@@ -30,7 +36,7 @@ func isPkgFile(dir *os.FileInfo) bool {
 }
 
 func pkgName(filename string) string {
-	file, err := parser.ParseFile(filename, nil, parser.PackageClauseOnly)
+	file, err := parser.ParseFile(token.NewFileSet(), filename, nil, parser.PackageClauseOnly)
 	if err != nil || file == nil {
 		return ""
 	}
@@ -58,7 +64,7 @@ func parseDir(dirpath string) map[string]*ast.Package {
 	}
 
 	// get package AST
-	pkgs, err := parser.ParseDir(dirpath, filter, parser.ParseComments)
+	pkgs, err := parser.ParseDir(token.NewFileSet(), dirpath, filter, parser.ParseComments)
 	if err != nil {
 		println("parse", dirpath, err.String())
 		panic("fail")
@@ -67,12 +73,19 @@ func parseDir(dirpath string) map[string]*ast.Package {
 }
 
 func main() {
+	runtime.GOMAXPROCS(4)
+	go func() {}()
+	go func() {}()
+	go func() {}()
 	st := &runtime.MemStats
+	packages = append(packages, packages...)
+	packages = append(packages, packages...)
 	n := flag.Int("n", 4, "iterations")
 	p := flag.Int("p", len(packages), "# of packages to keep in memory")
 	flag.BoolVar(&st.DebugGC, "d", st.DebugGC, "print GC debugging info (pause times)")
 	flag.Parse()
 
+	var lastParsed []map[string]*ast.Package
 	var t0 int64
 	pkgroot := runtime.GOROOT() + "/src/pkg/"
 	for pass := 0; pass < 2; pass++ {
@@ -81,7 +94,7 @@ func main() {
 		// than the normal pauses and would otherwise make
 		// the average look much better than it actually is.
 		st.NumGC = 0
-		st.PauseNs = 0
+		st.PauseTotalNs = 0
 		t0 = time.Nanoseconds()
 
 		for i := 0; i < *n; i++ {
@@ -89,25 +102,34 @@ func main() {
 			for j := range parsed {
 				parsed[j] = parseDir(pkgroot + packages[j%len(packages)])
 			}
+			if i+1 == *n && *serve != "" {
+				lastParsed = parsed
+			}
 		}
 		runtime.GC()
+		runtime.GC()
 	}
 	t1 := time.Nanoseconds()
 
 	fmt.Printf("Alloc=%d/%d Heap=%d Mallocs=%d PauseTime=%.3f/%d = %.3f\n",
 		st.Alloc, st.TotalAlloc,
 		st.Sys,
-		st.Mallocs, float64(st.PauseNs)/1e9,
-		st.NumGC, float64(st.PauseNs)/1e9/float64(st.NumGC))
-
-	fmt.Printf("%10s %10s %10s\n", "size", "#alloc", "#free")
-	for _, s := range st.BySize {
-		fmt.Printf("%10d %10d %10d\n", s.Size, s.Mallocs, s.Frees)
-	}
+		st.Mallocs, float64(st.PauseTotalNs)/1e9,
+		st.NumGC, float64(st.PauseTotalNs)/1e9/float64(st.NumGC))
 
+	/*
+		fmt.Printf("%10s %10s %10s\n", "size", "#alloc", "#free")
+		for _, s := range st.BySize {
+			fmt.Printf("%10d %10d %10d\n", s.Size, s.Mallocs, s.Frees)
+		}
+	*/
 	// Standard gotest benchmark output, collected by build dashboard.
-	fmt.Printf("garbage.BenchmarkParser %d %d ns/op\n", *n, (t1-t0)/int64(*n))
-	fmt.Printf("garbage.BenchmarkParserPause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC))
+	gcstats("BenchmarkParser", *n, t1-t0)
+
+	if *serve != "" {
+		log.Fatal(http.ListenAndServe(*serve, nil))
+		println(lastParsed)
+	}
 }
 
 
@@ -183,7 +205,6 @@ var packages = []string{
 	"math",
 	"mime",
 	"net",
-	"nntp",
 	"os",
 	"os/signal",
 	"patch",
@@ -195,6 +216,7 @@ var packages = []string{
 	"runtime",
 	"scanner",
 	"sort",
+	"smtp",
 	"strconv",
 	"strings",
 	"sync",
diff --git a/test/garbage/peano.go b/test/garbage/peano.go
index b026354e8..b4d318561 100644
--- a/test/garbage/peano.go
+++ b/test/garbage/peano.go
@@ -123,7 +123,6 @@ func verify() {
 
 
 func main() {
-	st := &runtime.MemStats
 	t0 := time.Nanoseconds()
 	verify()
 	for i := 0; i <= 9; i++ {
@@ -132,6 +131,5 @@ func main() {
 	runtime.GC()
 	t1 := time.Nanoseconds()
 
-	fmt.Printf("garbage.BenchmarkPeano 1 %d ns/op\n", t1-t0)
-	fmt.Printf("garbage.BenchmarkPeanoPause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC))
+	gcstats("BenchmarkPeano", 1, t1-t0)
 }
diff --git a/test/garbage/stats.go b/test/garbage/stats.go
new file mode 100644
index 000000000..474e6ad4a
--- /dev/null
+++ b/test/garbage/stats.go
@@ -0,0 +1,44 @@
+// Copyright 2010 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"sort"
+)
+
+func gcstats(name string, n int, t int64) {
+	st := &runtime.MemStats
+	fmt.Printf("garbage.%sMem Alloc=%d/%d Heap=%d NextGC=%d Mallocs=%d\n", name, st.Alloc, st.TotalAlloc, st.Sys, st.NextGC, st.Mallocs)
+	fmt.Printf("garbage.%s %d %d ns/op\n", name, n, t/int64(n))
+	fmt.Printf("garbage.%sLastPause 1 %d ns/op\n", name, st.PauseNs[(st.NumGC-1)%uint32(len(st.PauseNs))])
+	fmt.Printf("garbage.%sPause %d %d ns/op\n", name, st.NumGC, int64(st.PauseTotalNs)/int64(st.NumGC))
+	nn := int(st.NumGC)
+	if nn >= len(st.PauseNs) {
+		nn = len(st.PauseNs)
+	}
+	t1, t2, t3, t4, t5 := tukey5(st.PauseNs[0:nn])
+	fmt.Printf("garbage.%sPause5: %d %d %d %d %d\n", name, t1, t2, t3, t4, t5)
+	
+//	fmt.Printf("garbage.%sScan: %v\n", name, st.ScanDist)
+}
+
+type T []uint64
+func (t T) Len() int { return len(t) }
+func (t T) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
+func (t T) Less(i, j int) bool { return t[i] < t[j] }
+
+func tukey5(raw []uint64) (lo, q1, q2, q3, hi uint64) {
+	x := make(T, len(raw))
+	copy(x, raw)
+	sort.Sort(T(x))
+	lo = x[0]
+	q1 = x[len(x)/4]
+	q2 = x[len(x)/2]
+	q3 = x[len(x)*3/4]
+	hi = x[len(x)-1]
+	return
+}
diff --git a/test/garbage/tree.go b/test/garbage/tree.go
index 816693fbe..c5eae9760 100644
--- a/test/garbage/tree.go
+++ b/test/garbage/tree.go
@@ -39,7 +39,6 @@ package main
 import (
 	"flag"
 	"fmt"
-	"runtime"
 	"time"
 )
 
@@ -95,10 +94,7 @@ func main() {
 	fmt.Printf("long lived tree of depth %d\t check: %d\n", maxDepth, longLivedTree.itemCheck())
 
 	t1 := time.Nanoseconds()
-	st := &runtime.MemStats
 
 	// Standard gotest benchmark output, collected by build dashboard.
-	fmt.Printf("garbage.BenchmarkTree %d %d ns/op\n", *n, (t1-t0)/int64(*n))
-	fmt.Printf("garbage.BenchmarkTreePause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC))
-
+	gcstats("BenchmarkTree", *n, t1-t0)
 }
diff --git a/test/golden.out b/test/golden.out
index e587912a4..425771b4a 100644
--- a/test/golden.out
+++ b/test/golden.out
@@ -4,22 +4,18 @@
 =========== ./cmp2.go
 panic: runtime error: comparing uncomparable type []int
 
-panic PC=xxx
 
 =========== ./cmp3.go
 panic: runtime error: comparing uncomparable type []int
 
-panic PC=xxx
 
 =========== ./cmp4.go
 panic: runtime error: hash of unhashable type []int
 
-panic PC=xxx
 
 =========== ./cmp5.go
 panic: runtime error: hash of unhashable type []int
 
-panic PC=xxx
 
 =========== ./deferprint.go
 printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
@@ -64,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)
@@ -117,12 +112,10 @@ PASS
 =========== interface/fail.go
 panic: interface conversion: *main.S is not main.I: missing method Foo
 
-panic PC=xxx
 
 =========== interface/returntype.go
 panic: interface conversion: *main.S is not main.I2: missing method Name
 
-panic PC=xxx
 
 == nilptr/
 
@@ -130,9 +123,6 @@ panic PC=xxx
 
 == fixedbugs/
 
-=========== fixedbugs/bug016.go
-fixedbugs/bug016.go:11: constant -3 overflows uint
-
 =========== fixedbugs/bug027.go
 hi
 0 44444
@@ -155,21 +145,16 @@ inner loop top i 0
 do break
 broke
 
-=========== fixedbugs/bug081.go
-fixedbugs/bug081.go:9: typechecking loop
-
 =========== fixedbugs/bug093.go
 M
 
 =========== fixedbugs/bug113.go
 panic: interface conversion: interface is int, not int32
 
-panic PC=xxx
 
 =========== fixedbugs/bug148.go
 2 3
 panic: interface conversion: interface is main.T, not main.T
 
-panic PC=xxx
 
 == bugs/
diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index b952f8fc8..b6a582fff 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 20b77c6cc..c40ca1f38 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 6e9bfd023..ba1fa196f 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 26b113992..8ec7d40f5 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 5a66dc9a9..b36e93ecd 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 997894b41..83acc15ff 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 3c6f1f68c..8524e47ae 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 af2a1c57d..d425a7c4c 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 12b4b6d7b..6b3d4b2e4 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 cb443e3a1..feb85d299 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 6e7088e19..5c31270fc 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 5a35acaf4..639042128 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 9bdbabca8..bf0538812 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 ddff7c7a7..c3963499b 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/method1.go b/test/method1.go
index 1a2f8cae5..ec14ef9e4 100644
--- a/test/method1.go
+++ b/test/method1.go
@@ -8,10 +8,10 @@ package main
 
 type T struct { }
 func (t *T) M(int, string)	// GCCGO_ERROR "previous"
-func (t *T) M(int, float) { }   // ERROR "redeclared|redefinition"
+func (t *T) M(int, float64) { }   // ERROR "redeclared|redefinition"
 
 func f(int, string)	// GCCGO_ERROR "previous"
-func f(int, float) { }  // ERROR "redeclared|redefinition"
+func f(int, float64) { }  // ERROR "redeclared|redefinition"
 
 func g(a int, b string)  // GCCGO_ERROR "previous"
 func g(a int, c string)  // ERROR "redeclared|redefinition"
diff --git a/test/named.go b/test/named.go
index d2039bab4..5b6bb81fe 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/named1.go b/test/named1.go
index 600e502f9..1776313f0 100644
--- a/test/named1.go
+++ b/test/named1.go
@@ -43,12 +43,9 @@ func main() {
 	_, b = m[2] // ERROR "cannot .* bool.*type Bool"
 	m[2] = 1, b // ERROR "cannot use.*type Bool.*as type bool"
 
-	b = c <- 1 // ERROR "cannot use.*type bool.*type Bool"
-	_ = b
-	asBool(c <- 1) // ERROR "cannot use.*type bool.*as type Bool"
-
-	_, b = <-c // ERROR "cannot .* bool.*type Bool"
-	_ = b
+	////TODO(rsc): uncomment when this syntax is valid for receive+check closed
+	////	_, b = <-c // ERROR "cannot .* bool.*type Bool"
+	////	_ = b
 
 	var inter interface{}
 	_, b = inter.(Map) // ERROR "cannot .* bool.*type Bool"
diff --git a/test/nil.go b/test/nil.go
index 6a72b72eb..4f4c75527 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 f33af4457..9affe25d4 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/run b/test/run
index 28d0caa0f..ec0195253 100755
--- a/test/run
+++ b/test/run
@@ -42,7 +42,9 @@ TMP2FILE=/tmp/gotest2-$$-$USER
 
 # don't run the machine out of memory: limit individual processes to 4GB.
 # on thresher, 3GB suffices to run the tests; with 2GB, peano fails.
-ulimit -v 4000000
+# Linux charges reserved but not mapped addresses to ulimit -v
+# so we have to use ulimit -m.
+ulimit -m 4000000
 
 # no core files please
 ulimit -c 0
diff --git a/test/stack.go b/test/stack.go
index 816b555a4..1fd57161f 100644
--- a/test/stack.go
+++ b/test/stack.go
@@ -30,6 +30,32 @@ func d(t T) {
 	}
 }
 
+func f0() {
+	// likely to make a new stack for f0,
+	// because the call to f1 puts 3000 bytes
+	// in our frame.
+	f1()
+}
+
+func f1() [3000]byte {
+	// likely to make a new stack for f1,
+	// because 3000 bytes were used by f0
+	// and we need 3000 more for the call
+	// to f2.  if the call to morestack in f1
+	// does not pass the frame size, the new
+	// stack (default size 5k) will not be big
+	// enough for the frame, and the morestack
+	// check in f2 will die, if we get that far 
+	// without faulting.
+	f2()
+	return [3000]byte{}
+}
+
+func f2() [3000]byte {
+	// just take up space
+	return [3000]byte{}
+}
+
 var c = make(chan int)
 var t T
 var b = []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
@@ -40,6 +66,7 @@ func recur(n int) {
 		panic("bad []byte -> string")
 	}
 	go g(c, t)
+	f0()
 	s := <-c
 	if s != len(t) {
 		println("bad go", s)
diff --git a/test/syntax/chan1.go b/test/syntax/chan1.go
new file mode 100644
index 000000000..9c12e5e6f
--- /dev/null
+++ b/test/syntax/chan1.go
@@ -0,0 +1,17 @@
+// errchk $G -e $D/$F.go
+
+// Copyright 2010 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+var c chan int
+var v int
+
+func main() {
+	if c <- v { // ERROR "send statement.*value.*select"
+	}
+}
+
+var _ = c <- v // ERROR "send statement.*value.*select"
diff --git a/test/syntax/typesw.go b/test/syntax/typesw.go
new file mode 100644
index 000000000..47f683cdf
--- /dev/null
+++ b/test/syntax/typesw.go
@@ -0,0 +1,13 @@
+// errchk $G -e $D/$F.go
+
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func main() {
+	switch main() := interface{}(nil).(type) {	// ERROR "invalid variable name"
+	default:
+	}
+}
diff --git a/test/test0.go b/test/test0.go
index dd2033a98..d8d86c427 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 9e6d10ea8..83fb0985a 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 cd4f52215..1948528d2 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++
-
-	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
-
-	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
+	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++
+
+	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
 }
 
 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 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 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) }, "", },
-
-	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{"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{"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"},
+
+	// 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{"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