complex divide: match C99 implementation

R=iant, ken2, r, r2, ken3
CC=golang-dev
https://golang.org/cl/1686044

diff --git a/src/pkg/runtime/complex.c b/src/pkg/runtime/complex.c
index ca6ed79ba390a10ca4424db17aacf2bf4a1b070d..2240d9fb85ba0cf9f1b67986320ce48d625e359d 100644 (file)
--- a/src/pkg/runtime/complex.c
+++ b/src/pkg/runtime/complex.c
@@ -4,33 +4,57 @@
 
 #include "runtime.h"
 
-// complex128div(num, den complex128) (quo complex128)
+typedef struct Complex128 Complex128;
+
 void
-·complex128div(float64 numreal, float64 numimag,
-       float64 denreal, float64 denimag,
-       float64 quoreal, float64 quoimag)
+·complex128div(Complex128 n, Complex128 d, Complex128 q)
 {
+       int32 ninf, dinf, nnan, dnan;
        float64 a, b, ratio, denom;
 
-       a = denreal;
-       if(a < 0)
-               a = -a;
-       b = denimag;
-       if(b < 0)
-               b = -b;
-       if(a <= b) {
-               if(b == 0)
-                       panicstring("complex divide by zero");
-               ratio = denreal/denimag;
-               denom = denreal*ratio + denimag;
-               quoreal = (numreal*ratio + numimag) / denom;
-               quoimag = (numimag*ratio - numreal) / denom;
+       // Special cases as in C99.
+       ninf = isInf(n.real, 0) || isInf(n.imag, 0);
+       dinf = isInf(d.real, 0) || isInf(d.imag, 0);
+
+       nnan = !ninf && (isNaN(n.real) || isNaN(n.imag));
+       dnan = !dinf && (isNaN(d.real) || isNaN(d.imag));
+
+       if(nnan || dnan) {
+               q.real = NaN();
+               q.imag = NaN();
+       } else if(ninf && !dinf && !dnan) {
+               q.real = Inf(0);
+               q.imag = Inf(0);
+       } else if(!ninf && !nnan && dinf) {
+               q.real = 0;
+               q.imag = 0;
+       } else if(d.real == 0 && d.imag == 0) {
+               if(n.real == 0 && n.imag == 0) {
+                       q.real = NaN();
+                       q.imag = NaN();
+               } else {
+                       q.real = Inf(0);
+                       q.imag = Inf(0);
+               }
        } else {
-               ratio = denimag/denreal;
-               denom = denimag*ratio + denreal;
-               quoreal = (numimag*ratio + numreal) / denom;
-               quoimag = (numimag - numreal*ratio) / denom;
+               // Standard complex arithmetic, factored to avoid unnecessary overflow.
+               a = d.real;
+               if(a < 0)
+                       a = -a;
+               b = d.imag;
+               if(b < 0)
+                       b = -b;
+               if(a <= b) {
+                       ratio = d.real/d.imag;
+                       denom = d.real*ratio + d.imag;
+                       q.real = (n.real*ratio + n.imag) / denom;
+                       q.imag = (n.imag*ratio - n.real) / denom;
+               } else {
+                       ratio = d.imag/d.real;
+                       denom = d.imag*ratio + d.real;
+                       q.real = (n.imag*ratio + n.real) / denom;
+                       q.imag = (n.imag - n.real*ratio) / denom;
+               }
        }
-       FLUSH(&quoreal);
-       FLUSH(&quoimag);
+       FLUSH(&q);
 }

diff --git a/test/cmplxdivide.c b/test/cmplxdivide.c
new file mode 100644 (file)
index 0000000..63473ba
--- /dev/null
+++ b/test/cmplxdivide.c
@@ -0,0 +1,61 @@
+// 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.
+
+// gcc '-std=c99' cmplxdivide.c && a.out >cmplxdivide1.go
+
+#include <complex.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#define nelem(x) (sizeof(x)/sizeof((x)[0]))
+
+double f[] = {
+       0,
+       1,
+       -1,
+       2,
+       NAN,
+       INFINITY,
+       -INFINITY,
+};
+
+char*
+fmt(double g)
+{
+       static char buf[10][30];
+       static int n;
+       char *p;
+       
+       p = buf[n++];
+       if(n == 10)
+               n = 0;
+       sprintf(p, "%g", g);
+       if(strcmp(p, "-0") == 0)
+               strcpy(p, "negzero");
+       return p;
+}      
+
+int
+main(void)
+{
+       int i, j, k, l;
+       double complex n, d, q;
+       
+       printf("// # generated by cmplxdivide.c\n");
+       printf("\n");
+       printf("package main\n");
+       printf("var tests = []Test{\n");
+       for(i=0; i<nelem(f); i++)
+       for(j=0; j<nelem(f); j++)
+       for(k=0; k<nelem(f); k++)
+       for(l=0; l<nelem(f); l++) {
+               n = f[i] + f[j]*I;
+               d = f[k] + f[l]*I;
+               q = n/d;
+               printf("\tTest{cmplx(%s, %s), cmplx(%s, %s), cmplx(%s, %s)},\n", fmt(creal(n)), fmt(cimag(n)), fmt(creal(d)), fmt(cimag(d)), fmt(creal(q)), fmt(cimag(q)));
+       }
+       printf("}\n");
+       return 0;
+}

diff --git a/test/cmplxdivide.go b/test/cmplxdivide.go
new file mode 100644 (file)
index 0000000..ac4730d
--- /dev/null
+++ b/test/cmplxdivide.go
@@ -0,0 +1,43 @@
+// $G $D/$F.go $D/cmplxdivide1.go && $L $D/$F.$A && ./$A.out
+
+// 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.
+
+// Driver for complex division table defined in cmplxdivide1.go
+
+package main
+
+import (
+       "cmath"
+       "fmt"
+       "math"
+)
+
+type Test struct{
+       f, g    complex128
+       out     complex128
+}
+
+var nan = math.NaN()
+var inf = math.Inf(1)
+var negzero = math.Copysign(0, -1)
+
+func calike(a, b complex128) bool {
+       switch {
+       case cmath.IsInf(a) && cmath.IsInf(b):
+               return true
+       case cmath.IsNaN(a) && cmath.IsNaN(b):
+               return true
+       }
+       return a == b
+}
+
+func main() {
+       for _, t := range tests {
+               x := t.f/t.g
+               if !calike(x, t.out) {
+                       fmt.Printf("%v/%v: expected %v error; got %v\n", t.f, t.g, t.out, x)
+               }
+       }
+}

diff --git a/test/cmplxdivide1.go b/test/cmplxdivide1.go
new file mode 100644 (file)
index 0000000..5897169
--- /dev/null
+++ b/test/cmplxdivide1.go
@@ -0,0 +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(inf, 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(-inf, 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(inf, 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, inf)},
+       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, -inf)},
+       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, inf)},
+       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)},
+}

diff --git a/test/golden.out b/test/golden.out
index 24e24a28e11fd7972897161b9b3b88540cc22ac7..82e85340a5f89f83377b021b5ff6a47852353e13 100644 (file)
--- a/test/golden.out
+++ b/test/golden.out
@@ -53,14 +53,6 @@ FAIL
 =========== ./turing.go
 Hello World!
 
-=========== ./zerodivide.go
-complex 0/0: expected no error; got "runtime error: complex divide by zero"
-complex64 0/0: expected no error; got "runtime error: complex divide by zero"
-complex128 0/0: expected no error; got "runtime error: complex divide by zero"
-complex 1/0: expected no error; got "runtime error: complex divide by zero"
-complex64 1/0: expected no error; got "runtime error: complex divide by zero"
-complex128 1/0: expected no error; got "runtime error: complex divide by zero"
-
 == ken/
 
 =========== ken/cplx0.go

diff --git a/test/recover2.go b/test/recover2.go
index a6f75770c98ce462db0efe16584181086d4bc4f5..496909f35230f6c6f825153166403e0bf69a923a 100644 (file)
--- a/test/recover2.go
+++ b/test/recover2.go
@@ -81,11 +81,11 @@ func test6() {
 }
 
 func test7() {
-       if syscall.ARCH == "arm" {
-               // ARM doesn't have floating point yet
+       if syscall.ARCH == "arm" || syscall.OS == "nacl" {
+               // ARM doesn't have integer divide trap yet
                return
        }
-       defer mustRecover("complex divide by zero")
-       var x, y complex
+       defer mustRecover("divide by zero")
+       var x, y int
        println(x / y)
 }

diff --git a/test/zerodivide.go b/test/zerodivide.go
index 948aedd93018d7770bc3588b5b6a21ff30b50227..ce0fc82c89c990094158b405fbb76c38effb8fdc 100644 (file)
--- a/test/zerodivide.go
+++ b/test/zerodivide.go
@@ -114,16 +114,15 @@ func error(fn func()) (error string) {
 }
 
 type FloatTest struct{
-       name    string
        f, g    float64
        out     float64
 }
 
 var floatTests = []FloatTest{
-       FloatTest{"float64 0/0", 0, 0, nan },
-       FloatTest{"float64 nan/0", nan, 0, nan },
-       FloatTest{"float64 inf/0", inf, 0, inf },
-       FloatTest{"float64 -inf/0", negInf, 0, negInf },
+       FloatTest{0, 0, nan},
+       FloatTest{nan, 0, nan},
+       FloatTest{inf, 0, inf},
+       FloatTest{negInf, 0, negInf},
 }
 
 func alike(a, b float64) bool {
@@ -138,6 +137,9 @@ func alike(a, b float64) bool {
 
 func main() {
        for _, t := range errorTests {
+               if t.err != "" && syscall.OS == "nacl" {
+                       continue
+               }
                err := error(t.fn)
                switch {
                case t.err == "" && err == "":
@@ -158,7 +160,7 @@ func main() {
        for _, t := range floatTests {
                x := t.f/t.g
                if !alike(x, t.out) {
-                       fmt.Printf("%s: expected %g error; got %g\n", t.name, t.out, x)
+                       fmt.Printf("%v/%v: expected %g error; got %g\n", t.f, t.g, t.out, x)
                }
        }
 }